Commit 88f0bcd5 authored by Xavier Thompson's avatar Xavier Thompson

software/theia: Simplify and improve embedded SR

See merge request nexedi/slapos!1139
parents c9f8bad9 1b877749
Pipeline #21224 failed with stage
in 0 seconds
...@@ -15,24 +15,28 @@ ...@@ -15,24 +15,28 @@
[instance-theia] [instance-theia]
_update_hash_filename_ = instance-theia.cfg.jinja.in _update_hash_filename_ = instance-theia.cfg.jinja.in
md5sum = 7ea72f2300dd2019c2d27549e7128dec md5sum = 7d146ca31d7e44e909386e21e0a562ec
[instance] [instance]
_update_hash_filename_ = instance.cfg.in _update_hash_filename_ = instance.cfg.in
md5sum = af4d92a95dc25c2f64ddbd634996e46c md5sum = e211c439571e2900f9f35482c9638d06
[instance-import] [instance-import]
_update_hash_filename_ = instance-import.cfg.jinja.in _update_hash_filename_ = instance-import.cfg.jinja.in
md5sum = 29bc1c5b76d20fd46430dff5c72d192b md5sum = 23c3df4a889ebfa9f0a94e873e95ad3b
[instance-export] [instance-export]
_update_hash_filename_ = instance-export.cfg.jinja.in _update_hash_filename_ = instance-export.cfg.jinja.in
md5sum = e2630148998c3cdf6d03b5e884d7f464 md5sum = 84ceb4c9ee0f07fce8518ef7517ce1d4
[instance-resilient] [instance-resilient]
_update_hash_filename_ = instance-resilient.cfg.jinja _update_hash_filename_ = instance-resilient.cfg.jinja
md5sum = ad9499e7355ded4975ad313442cecb7a md5sum = ad9499e7355ded4975ad313442cecb7a
[slapos-standalone-script]
_update_hash_filename_ = slapos_standalone_script.py.jinja
md5sum = ef5b73648513caf46573f3302953790f
[theia-common] [theia-common]
_update_hash_filename_ = theia_common.py _update_hash_filename_ = theia_common.py
md5sum = 6a25c6a7f1beb27232a3c9acd8a76500 md5sum = 6a25c6a7f1beb27232a3c9acd8a76500
......
...@@ -92,14 +92,14 @@ inline = ...@@ -92,14 +92,14 @@ inline =
then then
echo "ERROR export script last ran on " $(date -r {{ repr(exitcodefile) }}) echo "ERROR export script last ran on " $(date -r {{ repr(exitcodefile) }})
exit 1 exit 1
elif [ $( cat {{ repr(exitcodefile) }}) -ne 0 ] elif [ "$(cat {{ repr(exitcodefile) }})" = 0 ]
then then
echo "OK export script last ran on " $(date -r {{ repr(exitcodefile) }})
exit 0
else
echo "ERROR export script failed on " $(date -r {{ repr(exitcodefile) }}) echo "ERROR export script failed on " $(date -r {{ repr(exitcodefile) }})
cat {{ repr(errorfile) }} cat {{ repr(errorfile) }}
exit 1 exit 1
else
echo "OK export script last ran on " $(date -r {{ repr(exitcodefile) }})
exit 0
fi fi
{%- endraw %} {%- endraw %}
......
...@@ -154,14 +154,14 @@ inline = ...@@ -154,14 +154,14 @@ inline =
then then
echo "ERROR import script last ran on " $(date -r {{ repr(exitcodefile) }}) echo "ERROR import script last ran on " $(date -r {{ repr(exitcodefile) }})
exit 1 exit 1
elif [ $( cat {{ repr(exitcodefile) }}) -ne 0 ] elif [ "$(cat {{ repr(exitcodefile) }})" = 0 ]
then then
echo "OK import script last ran on " $(date -r {{ repr(exitcodefile) }})
exit 0
else
echo "ERROR import script failed on " $(date -r {{ repr(exitcodefile) }}) echo "ERROR import script failed on " $(date -r {{ repr(exitcodefile) }})
cat {{ repr(errorfile) }} cat {{ repr(errorfile) }}
exit 1 exit 1
else
echo "OK import script last ran on " $(date -r {{ repr(exitcodefile) }})
exit 0
fi fi
{%- endraw %} {%- endraw %}
......
...@@ -15,20 +15,14 @@ ...@@ -15,20 +15,14 @@
], ],
"default": "running" "default": "running"
}, },
"embedded-sr": { "initial-embedded-instance": {
"title": "Embedded Software URL", "title": "Initial Embedded Instance Configuration",
"description": "Optional URL of a software to be embedded", "description": "One-shot optional JSON preconfiguration for an embedded instance. Only applied once when Theia is instantiated. Changing this option afterward will have no effect.",
"type": "string" "type": "string",
}, "examples": [
"embedded-sr-type": { "{\"software-url\": \"~/srv/project/slapos/software/html5as-base/software.cfg\"}",
"title": "Embedded Software Type", "{\"software-url\": \"~/srv/project/slapos/software/html5as/software.cfg\", \"software-type\": \"replicate\", \"instance-parameters\": {\"replicate-quantity\": 3}}"
"description": "Type of the optional embedded software", ]
"type": "string"
},
"embedded-instance-parameters": {
"title": "Embedded Instance Parameters",
"description": "Parameters for the embedded instance, as a JSON dict",
"type": "string"
}, },
"frontend-guid": { "frontend-guid": {
"title": "Frontend Instance ID", "title": "Frontend Instance ID",
......
{% set parameter_dict = dict(default_parameter_dict, **parameter_dict) %} {%- set parameter_dict = dict(default_parameter_dict, **parameter_dict) %}
{% set additional_frontend = parameter_dict['additional-frontend-guid'] %} {%- set additional_frontend = parameter_dict['additional-frontend-guid'] %}
{%- set embedded_instance_config = parameter_dict['initial-embedded-instance'] %}
[buildout] [buildout]
extends = extends =
...@@ -10,7 +11,6 @@ theia-environment-parts = ...@@ -10,7 +11,6 @@ theia-environment-parts =
slapos-repository slapos-repository
runner-link runner-link
settings.json settings.json
request-script-template
theia-parts = theia-parts =
frontend-reload frontend-reload
...@@ -98,6 +98,9 @@ instance-promises = ...@@ -98,6 +98,9 @@ instance-promises =
$${slapos-standalone-listen-promise:name} $${slapos-standalone-listen-promise:name}
$${slapos-standalone-ready-promise:name} $${slapos-standalone-ready-promise:name}
$${slapos-autorun-promise:name} $${slapos-autorun-promise:name}
{% if embedded_instance_config %}
$${embedded-instance-requested-promise:name}
{% endif %}
[theia-listen-promise] [theia-listen-promise]
<= monitor-promise-base <= monitor-promise-base
...@@ -161,6 +164,14 @@ config-service = $${slapos-autorun:service-name} ...@@ -161,6 +164,14 @@ config-service = $${slapos-autorun:service-name}
config-expect = $${slapos-autorun:autorun} config-expect = $${slapos-autorun:autorun}
config-run-directory = $${directory:runner}/var/run config-run-directory = $${directory:runner}/var/run
{% if embedded_instance_config %}
[embedded-instance-requested-promise]
<= monitor-promise-base
promise = check_command_execute
name = embedded-instance-requested-promise.py
config-command = $${embedded-instance-requested-promise-script:output}
{% endif %}
# Remote Caddy Frontend # Remote Caddy Frontend
# --------------------- # ---------------------
...@@ -402,7 +413,7 @@ base-url = $${theia-service:base-url} ...@@ -402,7 +413,7 @@ base-url = $${theia-service:base-url}
[theia-shell] [theia-shell]
recipe = slapos.recipe.template:jinja2 recipe = slapos.recipe.template:jinja2
output = $${directory:bin}/$${:_buildout_section_name_} output = $${directory:bin}/$${:_buildout_section_name_}
inline inline =
{% raw -%} {% raw -%}
#!{{ bash }} #!{{ bash }}
SHELL=$BASH SHELL=$BASH
...@@ -441,35 +452,40 @@ command = ...@@ -441,35 +452,40 @@ command =
# Embedded Instance # Embedded Instance
# ----------------- # -----------------
{%- set embedded_sr = parameter_dict['embedded-sr'] %} [embedded-instance-config]
{%- set embedded_sr_type = parameter_dict['embedded-sr-type'] %} recipe = slapos.recipe.template:jinja2
{%- set embedded_instance_parameters = parameter_dict['embedded-instance-parameters'] %} output = $${directory:etc}/$${:_buildout_section_name_}.json
{%- if embedded_sr %} once = $${:output}
{%- if embedded_sr.startswith('~/') %} config = {{ dumps(embedded_instance_config) }}
{%- set embedded_sr = os_module.path.join(partition_root_path, embedded_sr[2:]) %} context =
{%- set embedded_sr = os_module.path.normpath(embedded_sr) %} key config :config
{%- endif %}
[request-embedded-instance-script]
recipe = slapos.recipe.template
output = $${directory:project}/request_embedded.sh
inline = inline =
#!/bin/sh {%- raw %}
{{ config or "{}"}}
slapos supply {{ embedded_sr }} slaprunner {%- endraw %}
slapos request "embedded_instance" {{ embedded_sr }}
{%- if embedded_sr_type %} --type {{ embedded_sr_type }} {%- endif %}
{%- if embedded_instance_parameters %} --parameters-file $${embedded-instance-parameters:output}
[embedded-instance-parameters] [embedded-instance-requested-promise-script]
recipe = slapos.recipe.template recipe = slapos.recipe.template:jinja2
output = $${directory:project}/$${:_buildout_section_name_}.json output = $${directory:bin}/$${:_buildout_section_name_}
inline = {{ embedded_instance_parameters | indent(2) }} exitcode-file = $${slapos-standalone-script:embedded-request-exitcode-file}
{%- endif %} context =
{%- endif %} key exitcodefile :exitcode-file
{%- raw %}
{%- set embedded_digest = str(embedded_sr) + str(embedded_sr_type) + str(embedded_instance_parameters) %} inline =
{%- set embedded_digest_hash = hashlib_module.md5(embedded_digest.encode()).hexdigest() %} #!/bin/sh
if ! [ -f {{ repr(exitcodefile) }} ]
then
echo "ERROR embedded_instance has not been requested"
exit 1
elif [ "$(cat {{ repr(exitcodefile) }})" = 0 ]
then
echo "OK embedded_instance has been sucessfully requested"
exit 0
else
echo "ERROR request of embedded_instance failed"
exit 1
fi
{%- endraw %}
# SlapOS Standalone # SlapOS Standalone
...@@ -485,10 +501,14 @@ ip = {{ ipv4_random }} ...@@ -485,10 +501,14 @@ ip = {{ ipv4_random }}
ipv4 = {{ ipv4_random }} ipv4 = {{ ipv4_random }}
ipv6 = {{ ipv6_random }} ipv6 = {{ ipv6_random }}
port = $${slapos-standalone-port:port} port = $${slapos-standalone-port:port}
base-directory = $${directory:runner}
software-root = $${directory:runner}/software
instance-root = $${directory:runner}/instance
local-software-release-root = $${directory:home} local-software-release-root = $${directory:home}
slapos-bin = ${buildout:bin-directory}/slapos
slapos-configuration = $${directory:runner}/etc/slapos.cfg slapos-configuration = $${directory:runner}/etc/slapos.cfg
computer-id = slaprunner computer-id = slaprunner
abstract-socket-path = $${directory:home}/standalone-{{ embedded_digest_hash[:16] }} abstract-socket-path = $${directory:home}/standalone-ready
[slapos-standalone-activate] [slapos-standalone-activate]
recipe = slapos.recipe.template recipe = slapos.recipe.template
...@@ -500,98 +520,23 @@ inline = ...@@ -500,98 +520,23 @@ inline =
echo 'Standalone SlapOS for computer `$${slapos-standalone-config:computer-id}` activated' echo 'Standalone SlapOS for computer `$${slapos-standalone-config:computer-id}` activated'
[slapos-standalone-script] [slapos-standalone-script]
recipe = slapos.recipe.template recipe = slapos.recipe.template:jinja2
output = $${directory:bin}/$${:_buildout_section_name_} output = $${directory:bin}/$${:_buildout_section_name_}
inline = embedded-request-exitcode-file = $${directory:etc}/embedded-request-exitcode
#!${python-for-standalone:executable} shared-part-list =
import glob {{ """${buildout:shared-part-list}""" | indent(2) }}
import json context =
import os raw python_for_standalone ${python-for-standalone:executable}
import signal raw request_script_path $${directory:project}/request-embedded-instance.sh
import socket raw parameters_file_path $${directory:project}/embedded-instance-parameters.json
import subprocess key request_script_template request-script-example:inline
import sys key shared_part_list :shared-part-list
import time key embedded_request_exitcode_file :embedded-request-exitcode-file
import traceback key embedded_instance_config embedded-instance-config:output
key home_path directory:home
import slapos.slap.standalone section slap_connection slap-connection
section slapos_standalone_config slapos-standalone-config
# Include this hash, so that if it changes the standalone service will be restarted url = ${slapos-standalone-script:output}
# {{ embedded_digest_hash }}
shared_parts = """{{ '''${buildout:shared-part-list}''' | indent(2) }}"""
shared_part_list = [x.strip() for x in shared_parts.splitlines() if x.strip()]
partition_forward_configuration = (
slapos.slap.standalone.PartitionForwardAsPartitionConfiguration(
master_url="$${slap-connection:server-url}",
computer="$${slap-connection:computer-id}",
partition="$${slap-connection:partition-id}",
cert="$${slap-connection:cert-file}",
key="$${slap-connection:key-file}",
software_release_list=(
'http://git.erp5.org/gitweb/slapos.git/blob_plain/HEAD:/software/apache-frontend/software.cfg',
),
),
)
standalone = slapos.slap.standalone.StandaloneSlapOS(
"$${directory:runner}",
"$${slapos-standalone-config:ipv4}",
$${slapos-standalone-config:port},
computer_id="$${slapos-standalone-config:computer-id}",
shared_part_list=shared_part_list,
software_root="$${directory:runner}/software",
instance_root="$${directory:runner}/instance",
partition_forward_configuration=partition_forward_configuration,
slapos_bin="${buildout:bin-directory}/slapos",
local_software_release_root="$${slapos-standalone-config:local-software-release-root}",
)
def signal_handler(signum, frame):
print("Signal {signum} received".format(signum=signum))
sys.exit()
signal.signal(signal.SIGTERM, signal_handler)
standalone.start()
try:
partition_count = 20
print("Standalone SlapOS: Formatting %d partitions" % partition_count)
standalone.format(partition_count, '$${slapos-standalone-config:ipv4}', '$${slapos-standalone-config:ipv6}')
print("Standalone SlapOS for computer `$${slapos-standalone-config:computer-id}` started")
# Run instance at least once, to start the supervisor managing instances.
try:
standalone.waitForInstance(max_retry=0)
except slapos.slap.standalone.SlapOSNodeCommandError as e:
print("Error instanciating: {}".format(e))
{%- if embedded_sr %}
# Compatibility layer
try:
for cp in standalone.computer.getComputerPartitionList():
if cp.getInstanceParameterDict().get("instance_title") == "Embedded Instance":
print("Renaming 'Embedded Instance' into 'embedded_instance'")
cp.rename(new_name="embedded_instance")
break
except Exception:
print("Exception in compatibility layer, printing and moving on")
traceback.print_exc()
# Run request script
print("Running SlapOS script $${request-embedded-instance-script:output}")
slapos_env = {
'PATH': os.path.dirname(standalone._slapos_bin),
'SLAPOS_CONFIGURATION': standalone._slapos_config,
'SLAPOS_CLIENT_CONFIGURATION': standalone._slapos_config
}
subprocess.call(("$${request-embedded-instance-script:output}",), env=slapos_env)
{%- endif %}
s = socket.socket(socket.AF_UNIX)
s.bind("\0$${slapos-standalone-config:abstract-socket-path}")
s.listen(5)
print("Standalone SlapOS ready")
while True:
s.accept()[0].close()
finally:
print("Stopping standalone subsystem")
standalone.stop()
print("Exiting")
[slapos-standalone] [slapos-standalone]
recipe = slapos.recipe.template recipe = slapos.recipe.template
...@@ -725,18 +670,48 @@ recipe = slapos.cookbook:symbolic.link ...@@ -725,18 +670,48 @@ recipe = slapos.cookbook:symbolic.link
target-directory = $${directory:project} target-directory = $${directory:project}
link-binary = $${directory:runner} link-binary = $${directory:runner}
[request-script-template] [request-script-example]
recipe = slapos.recipe.template recipe = slapos.recipe.template:jinja2
output = $${directory:project}/$${:_buildout_section_name_}.sh output = $${directory:project}/$${:_buildout_section_name_}.sh
software_url = ~/srv/project/slapos/software/html5as-base/software.cfg
request_options = html5as-1 $${:software_url}
header_text =
# # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# This template is generated automatically by buildout. #
# Any changes to this file may be overwritten. #
# Copy and adapt it to create your own request script. #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # #
context =
key software_url :software_url
key request_options :request_options
key header_text :header_text
inline = inline =
#!/bin/sh {%- raw %}
# This template is generated automatically, copy it in order to supply and request. #!/bin/sh -e
# Any manual change to this file may be lost.
software_name=html5as-base #replace the software name writen in ~/srv/project/slapos/software/ {{ header_text }}
software_release_uri=~/srv/project/slapos/software/$software_name/software.cfg
# slapos supply is used to add the software to the software list to be supplied to a node. # slapos supply <url> <node> registers a software for installation on a node.
slapos supply $software_release_uri slaprunner #
# slapos request the allocation of an instance to the master. # A software is uniquely identified by its URL (the URL may be a local path).
# slapos request also gets status and parameters of the instance if it has any # You may choose from softwares available in ~/srv/project/slapos/software.
# (slapos request is meant to be run multiple time until you get the status). #
slapos request $software_name'_1' $software_release_uri # The one and only SlapOS Node embedded inside Theia is called 'slaprunner'.
#
# For more information, run:
# slapos help supply
#
slapos supply {{ software_url }} slaprunner
# slapos request <name> <url> registers an instance for allocation on a node.
#
# An instance is uniquely identified by its name (and its requester).
#
# It will be allocated on a node where the software URL is already supplied.
# Inside Theia that node can only be 'slaprunner'.
#
# For more information, run:
# slapos help request
#
slapos request {{ request_options }}
{% endraw %}
...@@ -31,6 +31,7 @@ pull-backup = template-pull-backup:output ...@@ -31,6 +31,7 @@ pull-backup = template-pull-backup:output
recipe = slapos.recipe.template:jinja2 recipe = slapos.recipe.template:jinja2
url = ${instance-theia:output} url = ${instance-theia:output}
output = $${buildout:directory}/instance-theia.cfg output = $${buildout:directory}/instance-theia.cfg
extensions = jinja2.ext.do
context = context =
jsonkey default_parameter_dict :default-parameters jsonkey default_parameter_dict :default-parameters
key parameter_dict slap-configuration:configuration key parameter_dict slap-configuration:configuration
...@@ -38,14 +39,12 @@ context = ...@@ -38,14 +39,12 @@ context =
key partition_root_path buildout:directory key partition_root_path buildout:directory
key ipv6_random slap-configuration:ipv6-random key ipv6_random slap-configuration:ipv6-random
key ipv4_random slap-configuration:ipv4-random key ipv4_random slap-configuration:ipv4-random
import os_module os import os os
import hashlib_module hashlib import json json
default-parameters = default-parameters =
{ {
"autorun": "running", "autorun": "running",
"embedded-sr": null, "initial-embedded-instance": null,
"embedded-sr-type": null,
"embedded-instance-parameters": null,
"frontend-name": "Theia Frontend", "frontend-name": "Theia Frontend",
"frontend-sr": "$${:frontend-sr}", "frontend-sr": "$${:frontend-sr}",
"frontend-sr-type": "RootSoftwareInstance", "frontend-sr-type": "RootSoftwareInstance",
......
#!{{ python_for_standalone }}
import contextlib
import glob
import json
import logging
import os
import re
import signal
import socket
import subprocess
import sys
import time
import slapos.slap.standalone
from slapos.util import unicode2str
logging.basicConfig(format="[%(asctime)s] %(message)s", level=logging.DEBUG)
REQUEST_SCRIPT_RAW_TEMPLATE = """{{ request_script_template }}"""
{% raw -%}
REQUEST_SCRIPT_TEMPLATE = re.sub(
r"{{\s*(\w+)\s*}}",
r"{\1}",
REQUEST_SCRIPT_RAW_TEMPLATE,
)
{%- endraw %}
REQUEST_SCRIPT_HEADER_TEXT = """
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# This script is generated once by your Theia's SlapOS Standalone service. #
# #
# It was used to pre-request an instance inside Theia's embedded SlapOS #
# according to the preconfiguration parameters given to your Theia. #
# #
# It will not be overwritten or recreated. #
# It will not be launched automatically. #
# #
# You can edit it and run it to modify your embedded instance. #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
""".strip()
def signal_handler(signum, frame):
logging.info("Signal %d received", signum)
sys.exit()
@contextlib.contextmanager
def setupStandalone():
partition_forward_configuration = (
slapos.slap.standalone.PartitionForwardAsPartitionConfiguration(
master_url={{ repr(slap_connection['server-url']) }},
computer={{ repr(slap_connection['computer-id']) }},
partition={{ repr(slap_connection['partition-id']) }},
cert={{ repr(slap_connection['cert-file']) }},
key={{ repr(slap_connection['key-file']) }},
software_release_list=(
'http://git.erp5.org/gitweb/slapos.git/blob_plain/HEAD:/software/apache-frontend/software.cfg',
),
),
)
shared_parts = {{ repr(shared_part_list) }}
shared_part_list = [x.strip() for x in shared_parts.splitlines() if x.strip()]
standalone = slapos.slap.standalone.StandaloneSlapOS(
{{ repr(slapos_standalone_config['base-directory']) }},
{{ repr(slapos_standalone_config['ipv4']) }},
{{ slapos_standalone_config['port'] }},
computer_id={{ repr(slapos_standalone_config['computer-id']) }},
shared_part_list=shared_part_list,
software_root={{ repr(slapos_standalone_config['software-root']) }},
instance_root={{ repr(slapos_standalone_config['instance-root']) }},
partition_forward_configuration=partition_forward_configuration,
slapos_bin={{ repr(slapos_standalone_config['slapos-bin']) }},
local_software_release_root={{ repr(slapos_standalone_config['local-software-release-root']) }},
)
standalone.start()
try:
partition_count = 20
logging.info("Standalone SlapOS: Formatting %d partitions", partition_count)
standalone.format(partition_count, {{ repr(slapos_standalone_config['ipv4']) }}, {{ repr(slapos_standalone_config['ipv6']) }})
logging.info("Standalone SlapOS for computer `%s` started", {{ repr(slapos_standalone_config['computer-id']) }})
# Run instance at least once, to start the supervisor managing instances.
try:
standalone.waitForInstance(max_retry=0)
except slapos.slap.standalone.SlapOSNodeCommandError as e:
logging.info("Error instanciating: {}".format(e))
yield standalone
finally:
logging.info("Stopping standalone subsystem")
standalone.stop()
logging.info("Exiting")
def parseEmbeddedInstanceConfig(config_json_file):
with open(config_json_file) as f:
try:
config = json.load(f)
except json.JSONDecodeError:
logging.error("%s is not valid JSON", config_json_file)
raise
assert(isinstance(config, dict))
if config:
software_url = unicode2str(config['software-url'])
software_type = config.get('software-type')
instance_parameters = config.get('instance-parameters')
assert(isinstance(software_url, str))
if software_type:
software_type = unicode2str(software_type)
assert(isinstance(software_type, str))
if instance_parameters:
assert(isinstance(instance_parameters, dict))
return software_url, software_type, instance_parameters
def createRequestScript(software_url, software_type, instance_parameters):
# Generate request script
request_script_path = {{ repr(request_script_path) }}
parameters_file_path = {{ repr(parameters_file_path) }}
request_options = "embedded_instance " + software_url
if software_type:
request_options += ' --type ' + software_type
if instance_parameters:
with open(parameters_file_path, 'w') as f:
json.dump(instance_parameters, f)
request_options += ' --parameters-file ' + parameters_file_path
with open(request_script_path, 'w') as f:
f.write(REQUEST_SCRIPT_TEMPLATE.format(
header_text = REQUEST_SCRIPT_HEADER_TEXT,
software_url = software_url,
request_options = request_options,
))
f.write("\n")
os.fchmod(f.fileno(), 0o755)
return request_script_path
def main():
signal.signal(signal.SIGTERM, signal_handler)
with setupStandalone() as standalone:
config_json_file = {{ repr(embedded_instance_config) }}
done_file = config_json_file + '.done'
if not os.path.exists(done_file):
with open(done_file, 'w'): pass
try:
config = parseEmbeddedInstanceConfig(config_json_file)
except Exception:
logging.info("Failed to parse embedded instance config", exc_info=True)
config = None
if config:
try:
request_script_path = createRequestScript(*config)
logging.info("Calling %s", request_script_path)
exitcode = subprocess.call((request_script_path,), env={
'HOME': {{ repr(home_path) }},
'PATH': os.path.dirname(standalone._slapos_bin),
'SLAPOS_CONFIGURATION': standalone._slapos_config,
'SLAPOS_CLIENT_CONFIGURATION': standalone._slapos_config,
})
with open({{ repr(embedded_request_exitcode_file) }}, 'w') as f:
f.write(str(exitcode))
except Exception:
logging.info("Failed to request embedded instance", exc_info=True)
s = socket.socket(socket.AF_UNIX)
s.bind({{ repr('\0' + slapos_standalone_config['abstract-socket-path']) }})
s.listen(5)
logging.info("Standalone SlapOS ready")
while True:
s.accept()[0].close()
main()
...@@ -19,17 +19,9 @@ extends = ...@@ -19,17 +19,9 @@ extends =
./buildout.hash.cfg ./buildout.hash.cfg
parts = parts =
theia-wrapper
slapos-cookbook slapos-cookbook
python-for-resiliency
python-for-standalone
instance-theia
instance instance
instance-import
instance-export
instance-resilient
theia-common
theia-export
# default for slapos-standalone # default for slapos-standalone
shared-part-list = shared-part-list =
...@@ -95,6 +87,10 @@ output = ${buildout:directory}/instance-export.cfg.jinja ...@@ -95,6 +87,10 @@ output = ${buildout:directory}/instance-export.cfg.jinja
[instance-resilient] [instance-resilient]
<= download-base <= download-base
[slapos-standalone-script]
<= download-base
destination = ${buildout:directory}/slapos_standalone_script.py.jinja
[theia-common] [theia-common]
<= download-base <= download-base
destination = ${buildout:directory}/theia_common.py destination = ${buildout:directory}/theia_common.py
...@@ -102,10 +98,12 @@ destination = ${buildout:directory}/theia_common.py ...@@ -102,10 +98,12 @@ destination = ${buildout:directory}/theia_common.py
[theia-export] [theia-export]
<= download-base <= download-base
destination = ${buildout:directory}/theia_export.py destination = ${buildout:directory}/theia_export.py
depends = ${theia-common:recipe}
[theia-import] [theia-import]
<= download-base <= download-base
destination = ${buildout:directory}/theia_import.py destination = ${buildout:directory}/theia_import.py
depends = ${theia-common:recipe}
# Utilities # Utilities
......
...@@ -62,10 +62,9 @@ class ERP5Mixin(object): ...@@ -62,10 +62,9 @@ class ERP5Mixin(object):
_test_software_url = erp5_software_release_url _test_software_url = erp5_software_release_url
_connexion_parameters_regex = re.compile(r"{.*}", re.DOTALL) _connexion_parameters_regex = re.compile(r"{.*}", re.DOTALL)
def _getERP5ConnexionParameters(self, software_type='export'): def _getERP5ConnexionParameters(self, instance_type='export'):
slapos = self._getSlapos(software_type) out = self.captureSlapos(
out = subprocess.check_output( 'request', 'test_instance', self._test_software_url,
(slapos, 'request', 'test_instance', self._test_software_url),
stderr=subprocess.STDOUT, stderr=subprocess.STDOUT,
) )
print(out) print(out)
...@@ -110,10 +109,10 @@ class ERP5Mixin(object): ...@@ -110,10 +109,10 @@ class ERP5Mixin(object):
raise Exception("Found several partitions for ERP5 %s" % servicename) raise Exception("Found several partitions for ERP5 %s" % servicename)
return found.pop() return found.pop()
def _getERP5PartitionPath(self, software_type, servicename, *paths): def _getERP5PartitionPath(self, instance_type, servicename, *paths):
partition = self._getERP5Partition(servicename) partition = self._getERP5Partition(servicename)
return self._getPartitionPath( return self.getPartitionPath(
software_type, 'srv', 'runner', 'instance', partition, *paths) instance_type, 'srv', 'runner', 'instance', partition, *paths)
class TestTheiaResilienceERP5(ERP5Mixin, test_resiliency.TestTheiaResilience): class TestTheiaResilienceERP5(ERP5Mixin, test_resiliency.TestTheiaResilience):
...@@ -161,16 +160,15 @@ class TestTheiaResilienceERP5(ERP5Mixin, test_resiliency.TestTheiaResilience): ...@@ -161,16 +160,15 @@ class TestTheiaResilienceERP5(ERP5Mixin, test_resiliency.TestTheiaResilience):
# Update ERP5 parameters # Update ERP5 parameters
print('Requesting ERP5 with parameters %s' % params) print('Requesting ERP5 with parameters %s' % params)
slapos = self._getSlapos() self.checkSlapos('request', 'test_instance', self._test_software_url, '--parameters', params)
subprocess.check_call((slapos, 'request', 'test_instance', self._test_software_url, '--parameters', params))
# Process twice to propagate parameter changes # Process twice to propagate parameter changes
for _ in range(2): for _ in range(2):
subprocess.check_call((slapos, 'node', 'instance')) self.checkSlapos('node', 'instance')
# Restart cron (actually all) services to let them take the new date into account # Restart cron (actually all) services to let them take the new date into account
# XXX this should not be required, updating ERP5 parameters should be enough # XXX this should not be required, updating ERP5 parameters should be enough
subprocess.call((slapos, 'node', 'restart', 'all')) self.callSlapos('node', 'restart', 'all')
# Wait until after the programmed backup date, and a bit more # Wait until after the programmed backup date, and a bit more
t = (soon - datetime.now()).total_seconds() t = (soon - datetime.now()).total_seconds()
...@@ -213,9 +211,8 @@ class TestTheiaResilienceERP5(ERP5Mixin, test_resiliency.TestTheiaResilience): ...@@ -213,9 +211,8 @@ class TestTheiaResilienceERP5(ERP5Mixin, test_resiliency.TestTheiaResilience):
self.assertNotIn(self._erp5_new_title, out) self.assertNotIn(self._erp5_new_title, out)
# Stop all services # Stop all services
slapos = self._getSlapos()
print("Stop all services") print("Stop all services")
subprocess.call((slapos, 'node', 'stop', 'all')) self.callSlapos('node', 'stop', 'all')
# Manually restore mariadb from backup # Manually restore mariadb from backup
mariadb_restore_script = os.path.join(mariadb_partition, 'bin', 'restore-from-backup') mariadb_restore_script = os.path.join(mariadb_partition, 'bin', 'restore-from-backup')
......
...@@ -52,11 +52,53 @@ setUpModule, SlapOSInstanceTestCase = makeModuleSetUpAndTestCaseClass(theia_soft ...@@ -52,11 +52,53 @@ setUpModule, SlapOSInstanceTestCase = makeModuleSetUpAndTestCaseClass(theia_soft
class TheiaTestCase(SlapOSInstanceTestCase): class TheiaTestCase(SlapOSInstanceTestCase):
__partition_reference__ = 'T' # for supervisord sockets in included slapos __partition_reference__ = 'T' # for supervisord sockets in included slapos
@classmethod
def getPath(cls, *components):
return os.path.join(cls.computer_partition_root_path, *components)
@classmethod @classmethod
def _getSlapos(cls): def _getSlapos(cls):
partition_root = cls.computer_partition_root_path try:
slapos = os.path.join(partition_root, 'srv', 'runner', 'bin', 'slapos') return cls._theia_slapos
return slapos except AttributeError:
cls._theia_slapos = slapos = cls.getPath('srv', 'runner', 'bin', 'slapos')
return slapos
@classmethod
def callSlapos(cls, *command, **kwargs):
return subprocess.call((cls._getSlapos(),) + command, **kwargs)
@classmethod
def checkSlapos(cls, *command, **kwargs):
return subprocess.check_call((cls._getSlapos(),) + command, **kwargs)
@classmethod
def captureSlapos(cls, *command, **kwargs):
kwargs.setdefault('universal_newlines', kwargs.pop('text', None))
return subprocess.check_output((cls._getSlapos(),) + command, **kwargs)
@classmethod
def requestInstance(cls, parameter_dict=None, state='started'):
cls.slap.request(
software_release=cls.getSoftwareURL(),
software_type=cls.getInstanceSoftwareType(),
partition_reference=cls.default_partition_reference,
partition_parameter_kw=parameter_dict,
state=state
)
@classmethod
def restartService(cls, service):
with cls.slap.instance_supervisor_rpc as supervisor:
for process_info in supervisor.getAllProcessInfo():
service_name = process_info['name']
if service in service_name:
service_id = '%s:%s' % (process_info['group'], service_name)
supervisor.stopProcess(service_id)
supervisor.startProcess(service_id)
break
else:
raise Exception("Service %s not found" % service)
class TestTheia(TheiaTestCase): class TestTheia(TheiaTestCase):
...@@ -104,7 +146,7 @@ class TestTheia(TheiaTestCase): ...@@ -104,7 +146,7 @@ class TestTheia(TheiaTestCase):
# there's a public folder to serve file # there's a public folder to serve file
with open('{}/srv/frontend-static/public/test_file'.format( with open('{}/srv/frontend-static/public/test_file'.format(
self.computer_partition_root_path), 'w') as f: self.getPath()), 'w') as f:
f.write("hello") f.write("hello")
resp = self.get(urljoin(authenticated_url, '/public/')) resp = self.get(urljoin(authenticated_url, '/public/'))
self.assertIn('test_file', resp.text) self.assertIn('test_file', resp.text)
...@@ -128,10 +170,9 @@ class TestTheia(TheiaTestCase): ...@@ -128,10 +170,9 @@ class TestTheia(TheiaTestCase):
self.assertIn('ipv6', self.connection_parameters) self.assertIn('ipv6', self.connection_parameters)
def test_theia_slapos(self): def test_theia_slapos(self):
home = self.getPath()
# Make sure we can use the shell and the integrated slapos command # Make sure we can use the shell and the integrated slapos command
process = pexpect.spawnu( process = pexpect.spawnu(home + '/bin/theia-shell', env={'HOME': home})
'{}/bin/theia-shell'.format(self.computer_partition_root_path),
env={'HOME': self.computer_partition_root_path})
# use a large enough terminal so that slapos proxy show table fit in the screen # use a large enough terminal so that slapos proxy show table fit in the screen
process.setwinsize(5000, 5000) process.setwinsize(5000, 5000)
...@@ -173,10 +214,11 @@ class TestTheia(TheiaTestCase): ...@@ -173,10 +214,11 @@ class TestTheia(TheiaTestCase):
process.wait() process.wait()
def test_theia_shell_execute_tasks(self): def test_theia_shell_execute_tasks(self):
home = self.getPath()
# shell needs to understand -c "command" arguments for theia tasks feature # shell needs to understand -c "command" arguments for theia tasks feature
test_file = '{}/test file'.format(self.computer_partition_root_path) test_file = home + '/test file'
subprocess.check_call([ subprocess.check_call([
'{}/bin/theia-shell'.format(self.computer_partition_root_path), home + '/bin/theia-shell',
'-c', '-c',
'touch "{}"'.format(test_file) 'touch "{}"'.format(test_file)
]) ])
...@@ -184,26 +226,23 @@ class TestTheia(TheiaTestCase): ...@@ -184,26 +226,23 @@ class TestTheia(TheiaTestCase):
def test_theia_request_script(self): def test_theia_request_script(self):
script_path = os.path.join( script_path = os.path.join(
self.computer_partition_root_path, self.getPath(),
'srv', 'srv',
'project', 'project',
'request-script-template.sh', 'request-script-example.sh',
) )
self.assertTrue(os.path.exists(script_path)) self.assertTrue(os.path.exists(script_path))
def test_slapos_cli(self): def test_slapos_cli(self):
slapos = self._getSlapos() self.assertIn(b'slaprunner', self.captureSlapos('proxy', 'show'))
proxy_show_output = subprocess.check_output((slapos, 'proxy', 'show')) self.assertIn(b'slaprunner', self.captureSlapos('computer', 'list'))
self.assertIn(b'slaprunner', proxy_show_output)
computer_list_output = subprocess.check_output((slapos, 'computer', 'list'))
self.assertIn(b'slaprunner', computer_list_output)
class TestTheiaEmbeddedSlapOSShutdown(TheiaTestCase): class TestTheiaEmbeddedSlapOSShutdown(TheiaTestCase):
def test_stopping_instance_stops_embedded_slapos(self): def test_stopping_instance_stops_embedded_slapos(self):
embedded_slapos_supervisord_socket = _getSupervisordSocketPath( embedded_slapos_supervisord_socket = _getSupervisordSocketPath(
os.path.join( os.path.join(
self.computer_partition_root_path, self.getPath(),
'srv', 'srv',
'runner', 'runner',
'instance', 'instance',
...@@ -231,82 +270,70 @@ class TestTheiaEmbeddedSlapOSShutdown(TheiaTestCase): ...@@ -231,82 +270,70 @@ class TestTheiaEmbeddedSlapOSShutdown(TheiaTestCase):
self.assertFalse(embedded_slapos_process.is_running()) self.assertFalse(embedded_slapos_process.is_running())
class ReRequestMixin(object): class TestTheiaWithEmbeddedInstance(TheiaTestCase):
def rerequest(self, parameter_dict=None, state='started'): sr_url = '~/bogus/sr/url.cfg'
software_url = self.getSoftwareURL() sr_type = 'bogus-type'
software_type = self.getInstanceSoftwareType() sr_config = {"bogus": "yes"}
name = self.default_partition_reference regexpr = re.compile(r"([\w/\-\.]+)\s+slaprunner\s+available")
self.slap.request(
software_release=software_url,
software_type=software_type,
partition_reference=name,
partition_parameter_kw=parameter_dict,
state=state)
def reinstantiate(self):
# Process at least twice to propagate parameter changes
try:
self.slap.waitForInstance()
except SlapOSNodeCommandError:
pass
self.slap.waitForInstance(self.instance_max_retry)
class TestTheiaWithSR(TheiaTestCase, ReRequestMixin): @classmethod
sr_url = '~/bogus/software.cfg' def getInstanceParameterDict(cls, sr_url=None, sr_type=None, sr_config=None):
sr_type = 'bogus_type' return {
instance_parameters = '{\n"bogus_param": "bogus_value",\n"bogus_param2": "bogus_value2"\n}' 'initial-embedded-instance': json.dumps({
'software-url': sr_url or cls.sr_url,
def proxy_show(self, slapos): 'software-type': sr_type or cls.sr_type,
return subprocess.check_output((slapos, 'proxy', 'show'), universal_newlines=True) 'instance-parameters': sr_config or cls.sr_config,
}),
def test(self):
slapos = self._getSlapos()
home = self.computer_partition_root_path
# Check that no request script was generated
request_script = os.path.join(home, 'srv', 'project', 'request_embedded.sh')
self.assertFalse(os.path.exists(request_script))
# Manually request old-name 'Embedded Instance'
old_instance_name = "Embedded Instance"
subprocess.check_call((slapos, 'request', old_instance_name, 'bogus_url'))
self.assertIn(old_instance_name, self.proxy_show(slapos))
# Update Theia instance parameters
embedded_request_parameters = {
'embedded-sr': self.sr_url,
'embedded-sr-type': self.sr_type,
'embedded-instance-parameters': self.instance_parameters
} }
self.rerequest(embedded_request_parameters)
self.reinstantiate()
# Check that embedded instance was requested def expandUrl(self, url):
instance_name = "embedded_instance" if url.startswith('~/'):
info = self.proxy_show(slapos) url = os.path.join(self.getPath(), url[2:])
try: return url
self.assertIn(instance_name, info)
except AssertionError: def assertSupplied(self, sr_url, info=None):
for filename in os.listdir(home): info = info or self.captureSlapos('proxy', 'show', text=True)
if 'standalone' in filename and '.log' in filename: self.assertIn(sr_url, info)
filepath = os.path.join(home, filename) self.assertIn(sr_url, self.regexpr.findall(info))
with open(filepath) as f:
print("Contents of filepath: " + filepath) def assertNotSupplied(self, sr_url, info=None):
print(f.read()) info = info or self.captureSlapos('proxy', 'show', text=True)
raise self.assertNotIn(sr_url, info)
def assertEmbedded(self, sr_url, sr_type, config):
proxy_info = self.captureSlapos('proxy', 'show', text=True)
self.assertSupplied(sr_url, info=proxy_info)
name = 'embedded_instance'
self.assertIn(name, self.captureSlapos('service', 'list', text=True))
info = self.captureSlapos('service', 'info', name, text=True)
self.assertIn(sr_url, info)
self.assertIn(sr_type, proxy_info)
self.assertIn(repr(config).replace("u'", "'"), info)
def assertNotEmbedded(self, sr_url, sr_type, config):
sr_url = self.expandUrl(sr_url)
proxy_info = self.captureSlapos('proxy', 'show', text=True)
self.assertNotSupplied(sr_url, info=proxy_info)
self.assertNotIn(sr_type, proxy_info)
# Check that old-name instance was renamed def test(self):
self.assertNotIn(old_instance_name, info) # Check that embedded instance is supplied and requested
initial_sr_url = self.expandUrl(self.sr_url)
self.assertEmbedded(initial_sr_url, self.sr_type, self.sr_config)
# Check embedded instance parameters # Change parameters for embedded instance
bogus_sr = os.path.join(home, self.sr_url[2:]) sr_url = '/bogus/sr/url-2.cfg'
sr_type = 'bogus-type-2'
sr_config = {"bogus-2": "true"}
self.requestInstance(
self.getInstanceParameterDict(sr_url, sr_type, sr_config))
self.waitForInstance()
self.assertIsNotNone(re.search(r"%s\s+slaprunner\s+available" % (bogus_sr,), info), info) # Check that parameters have not been taken into account
self.assertIsNotNone(re.search(r"%s\s+%s\s+%s" % (bogus_sr, self.sr_type, instance_name), info), info) self.assertNotEmbedded(sr_url, sr_type, sr_config)
service_info = subprocess.check_output((slapos, 'service', 'info', instance_name), universal_newlines=True) # Check that previous instance has not been changed
self.assertIn("{'bogus_param': 'bogus_value', 'bogus_param2': 'bogus_value2'}", service_info) self.assertEmbedded(initial_sr_url, self.sr_type, self.sr_config)
class TestTheiaFrontend(TheiaTestCase): class TestTheiaFrontend(TheiaTestCase):
...@@ -331,7 +358,9 @@ class TestTheiaEnv(TheiaTestCase): ...@@ -331,7 +358,9 @@ class TestTheiaEnv(TheiaTestCase):
@classmethod @classmethod
def getInstanceParameterDict(cls): def getInstanceParameterDict(cls):
return { return {
'embedded-sr': cls.dummy_software_path, 'initial-embedded-instance': json.dumps({
'software-url': cls.dummy_software_path,
}),
'autorun': 'stopped', 'autorun': 'stopped',
} }
...@@ -339,7 +368,7 @@ class TestTheiaEnv(TheiaTestCase): ...@@ -339,7 +368,7 @@ class TestTheiaEnv(TheiaTestCase):
"""Make sure environment variables are the same whether we use shell or supervisor services. """Make sure environment variables are the same whether we use shell or supervisor services.
""" """
# The path of the env.json file expected to be generated by building the dummy software release # The path of the env.json file expected to be generated by building the dummy software release
env_json_path = os.path.join(self.computer_partition_root_path, 'srv', 'runner', 'software', 'env.json') env_json_path = self.getPath('srv', 'runner', 'software', 'env.json')
# Get the pid of the theia process from the test node's instance-supervisord # Get the pid of the theia process from the test node's instance-supervisord
with self.slap.instance_supervisor_rpc as supervisor: with self.slap.instance_supervisor_rpc as supervisor:
...@@ -357,7 +386,7 @@ class TestTheiaEnv(TheiaTestCase): ...@@ -357,7 +386,7 @@ class TestTheiaEnv(TheiaTestCase):
# Start a theia shell that inherits the environment of the theia process # Start a theia shell that inherits the environment of the theia process
# This simulates the environment of a shell launched from the browser application # This simulates the environment of a shell launched from the browser application
theia_shell_process = pexpect.spawnu('{}/bin/theia-shell'.format(self.computer_partition_root_path), env=theia_env) theia_shell_process = pexpect.spawnu('{}/bin/theia-shell'.format(self.getPath()), env=theia_env)
try: try:
theia_shell_process.expect_exact('Standalone SlapOS for computer `slaprunner` activated') theia_shell_process.expect_exact('Standalone SlapOS for computer `slaprunner` activated')
...@@ -377,7 +406,7 @@ class TestTheiaEnv(TheiaTestCase): ...@@ -377,7 +406,7 @@ class TestTheiaEnv(TheiaTestCase):
# Note that we have two services, slapos-node-software and slapos-node-software-all # Note that we have two services, slapos-node-software and slapos-node-software-all
# The later uses --all which is what we want to use here, because the software # The later uses --all which is what we want to use here, because the software
# is already installed and we want to install it again, this time from supervisor # is already installed and we want to install it again, this time from supervisor
embedded_run_path = os.path.join(self.computer_partition_root_path, 'srv', 'runner', 'var', 'run') embedded_run_path = self.getPath('srv', 'runner', 'var', 'run')
embedded_supervisord_socket_path = _getSupervisordSocketPath(embedded_run_path, self.logger) embedded_supervisord_socket_path = _getSupervisordSocketPath(embedded_run_path, self.logger)
with getSupervisorRPC(embedded_supervisord_socket_path) as embedded_supervisor: with getSupervisorRPC(embedded_supervisord_socket_path) as embedded_supervisor:
previous_stop_time = embedded_supervisor.getProcessInfo('slapos-node-software-all')['stop'] previous_stop_time = embedded_supervisor.getProcessInfo('slapos-node-software-all')['stop']
...@@ -410,6 +439,8 @@ class ResilientTheiaMixin(object): ...@@ -410,6 +439,8 @@ class ResilientTheiaMixin(object):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
super(ResilientTheiaMixin, cls).setUpClass() super(ResilientTheiaMixin, cls).setUpClass()
# Patch the computer root path to that of the export theia instance
cls.computer_partition_root_path = cls.getPartitionPath('export')
# Add resiliency files to snapshot patterns # Add resiliency files to snapshot patterns
cls._save_instance_file_pattern_list += ( cls._save_instance_file_pattern_list += (
'*/srv/export-exitcode-file', '*/srv/export-exitcode-file',
...@@ -419,43 +450,53 @@ class ResilientTheiaMixin(object): ...@@ -419,43 +450,53 @@ class ResilientTheiaMixin(object):
) )
@classmethod @classmethod
def _getPartition(cls, software_type): def getPartitionId(cls, instance_type):
software_url = cls.getSoftwareURL() software_url = cls.getSoftwareURL()
for computer_partition in cls.slap.computer.getComputerPartitionList(): for computer_partition in cls.slap.computer.getComputerPartitionList():
partition_url = computer_partition.getSoftwareRelease()._software_release partition_url = computer_partition.getSoftwareRelease()._software_release
partition_type = computer_partition.getType() partition_type = computer_partition.getType()
if partition_url == software_url and partition_type == software_type: if partition_url == software_url and partition_type == instance_type:
return computer_partition return computer_partition.getId()
raise Exception("Theia %s partition not found" % software_type) raise Exception("Theia %s partition not found" % instance_type)
@classmethod
def getPartitionPath(cls, instance_type='export', *paths):
return os.path.join(cls.slap._instance_root, cls.getPartitionId(instance_type), *paths)
@classmethod @classmethod
def _getPartitionId(cls, software_type): def _getSlapos(cls, instance_type='export'):
return cls._getPartition(software_type).getId() return cls.getPartitionPath(instance_type, 'srv', 'runner', 'bin', 'slapos')
@classmethod @classmethod
def _getPartitionPath(cls, software_type, *paths): def callSlapos(cls, *command, **kwargs):
return os.path.join(cls.slap._instance_root, cls._getPartitionId(software_type), *paths) instance_type = kwargs.pop('instance_type', 'export')
return subprocess.call((cls._getSlapos(instance_type),) + command, **kwargs)
@classmethod @classmethod
def _getSlapos(cls, software_type='export'): def checkSlapos(cls, *command, **kwargs):
return cls._getPartitionPath(software_type, 'srv', 'runner', 'bin', 'slapos') instance_type = kwargs.pop('instance_type', 'export')
return subprocess.check_call((cls._getSlapos(instance_type),) + command, **kwargs)
@classmethod
def captureSlapos(cls, *command, **kwargs):
kwargs.setdefault('universal_newlines', kwargs.pop('text', None))
instance_type = kwargs.pop('instance_type', 'export')
return subprocess.check_output((cls._getSlapos(instance_type),) + command, **kwargs)
@classmethod @classmethod
def getInstanceSoftwareType(cls): def getInstanceSoftwareType(cls):
return 'resilient' return 'resilient'
@classmethod
def waitForInstance(cls):
# process twice to propagate to all instances
for _ in range(2):
super(ResilientTheiaMixin, cls).waitForInstance()
class TestTheiaResilientInterface(ResilientTheiaMixin, TestTheia): class TestTheiaResilientInterface(ResilientTheiaMixin, TestTheia):
@classmethod pass
def setUpClass(cls):
super(TestTheiaResilientInterface, cls).setUpClass()
# Patch the computer root path to that of the export theia instance
cls.computer_partition_root_path = cls._getPartitionPath('export')
class TestTheiaResilientWithSR(ResilientTheiaMixin, TestTheiaWithSR): class TestTheiaResilientWithEmbeddedInstance(ResilientTheiaMixin, TestTheiaWithEmbeddedInstance):
@classmethod pass
def setUpClass(cls):
super(TestTheiaResilientWithSR, cls).setUpClass()
# Patch the computer root path to that of the export theia instance
cls.computer_partition_root_path = cls._getPartitionPath('export')
...@@ -63,11 +63,10 @@ def setUpModule(): ...@@ -63,11 +63,10 @@ def setUpModule():
class ResilientTheiaTestCase(ResilientTheiaMixin, TheiaTestCase): class ResilientTheiaTestCase(ResilientTheiaMixin, TheiaTestCase):
@classmethod @classmethod
def _processEmbeddedInstance(cls, retries=0, software_type='export'): def _processEmbeddedInstance(cls, retries=0, instance_type='export'):
slapos = cls._getSlapos(software_type)
for _ in range(retries): for _ in range(retries):
try: try:
output = subprocess.check_output((slapos, 'node', 'instance'), stderr=subprocess.STDOUT) output = cls.captureSlapos('node', 'instance', instance_type=instance_type, stderr=subprocess.STDOUT)
except subprocess.CalledProcessError: except subprocess.CalledProcessError:
continue continue
print(output) print(output)
...@@ -77,19 +76,18 @@ class ResilientTheiaTestCase(ResilientTheiaMixin, TheiaTestCase): ...@@ -77,19 +76,18 @@ class ResilientTheiaTestCase(ResilientTheiaMixin, TheiaTestCase):
# Sleep a bit as an attempt to workaround monitoring boostrap not being ready # Sleep a bit as an attempt to workaround monitoring boostrap not being ready
print("Wait before running slapos node instance one last time") print("Wait before running slapos node instance one last time")
time.sleep(120) time.sleep(120)
subprocess.check_call((slapos, 'node', 'instance')) cls.callSlapos('node', 'instance', instance_type=instance_type)
@classmethod @classmethod
def _deployEmbeddedSoftware(cls, software_url, instance_name, retries=0, software_type='export'): def _deployEmbeddedSoftware(cls, software_url, instance_name, retries=0, instance_type='export'):
slapos = cls._getSlapos(software_type) cls.callSlapos('supply', software_url, 'slaprunner', instance_type=instance_type)
subprocess.check_call((slapos, 'supply', software_url, 'slaprunner'))
try: try:
subprocess.check_output((slapos, 'node', 'software'), stderr=subprocess.STDOUT) cls.captureSlapos('node', 'software', instance_type=instance_type, stderr=subprocess.STDOUT)
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
print(e.output) print(e.output)
raise raise
subprocess.check_call((slapos, 'request', instance_name, software_url)) cls.callSlapos('request', instance_name, software_url, instance_type=instance_type)
cls._processEmbeddedInstance(retries, software_type) cls._processEmbeddedInstance(retries, instance_type)
@classmethod @classmethod
def getInstanceParameterDict(cls): def getInstanceParameterDict(cls):
...@@ -136,16 +134,16 @@ class ResilienceMixin(object): ...@@ -136,16 +134,16 @@ class ResilienceMixin(object):
class ExportAndImportMixin(object): class ExportAndImportMixin(object):
def getExportExitfile(self): def getExportExitfile(self):
return self._getPartitionPath('export', 'srv', 'export-exitcode-file') return self.getPartitionPath('export', 'srv', 'export-exitcode-file')
def getExportErrorfile(self): def getExportErrorfile(self):
return self._getPartitionPath('export', 'srv', 'export-errormessage-file') return self.getPartitionPath('export', 'srv', 'export-errormessage-file')
def getImportExitfile(self): def getImportExitfile(self):
return self._getPartitionPath('import', 'srv', 'import-exitcode-file') return self.getPartitionPath('import', 'srv', 'import-exitcode-file')
def getImportErrorfile(self): def getImportErrorfile(self):
return self._getPartitionPath('import', 'srv', 'import-errormessage-file') return self.getPartitionPath('import', 'srv', 'import-errormessage-file')
def makedirs(self, path): def makedirs(self, path):
try: try:
...@@ -185,7 +183,7 @@ class ExportAndImportMixin(object): ...@@ -185,7 +183,7 @@ class ExportAndImportMixin(object):
initial_exitdate = os.path.getmtime(exitfile) initial_exitdate = os.path.getmtime(exitfile)
# Call export script manually # Call export script manually
theia_export_script = self._getPartitionPath('export', 'bin', 'theia-export-script') theia_export_script = self.getPartitionPath('export', 'bin', 'theia-export-script')
subprocess.check_call((theia_export_script,), stderr=subprocess.STDOUT) subprocess.check_call((theia_export_script,), stderr=subprocess.STDOUT)
# Check that the export exitcode file was modified # Check that the export exitcode file was modified
...@@ -198,8 +196,8 @@ class ExportAndImportMixin(object): ...@@ -198,8 +196,8 @@ class ExportAndImportMixin(object):
def _doTransfer(self): def _doTransfer(self):
# Copy <export>/srv/backup/theia to <import>/srv/backup/theia manually # Copy <export>/srv/backup/theia to <import>/srv/backup/theia manually
export_backup_path = self._getPartitionPath('export', 'srv', 'backup', 'theia') export_backup_path = self.getPartitionPath('export', 'srv', 'backup', 'theia')
import_backup_path = self._getPartitionPath('import', 'srv', 'backup', 'theia') import_backup_path = self.getPartitionPath('import', 'srv', 'backup', 'theia')
shutil.rmtree(import_backup_path) shutil.rmtree(import_backup_path)
shutil.copytree(export_backup_path, import_backup_path) shutil.copytree(export_backup_path, import_backup_path)
...@@ -209,7 +207,7 @@ class ExportAndImportMixin(object): ...@@ -209,7 +207,7 @@ class ExportAndImportMixin(object):
initial_exitdate = os.path.getmtime(exitfile) initial_exitdate = os.path.getmtime(exitfile)
# Call the import script manually # Call the import script manually
theia_import_script = self._getPartitionPath('import', 'bin', 'theia-import-script') theia_import_script = self.getPartitionPath('import', 'bin', 'theia-import-script')
subprocess.check_call((theia_import_script,), stderr=subprocess.STDOUT) subprocess.check_call((theia_import_script,), stderr=subprocess.STDOUT)
# Check that the import exitcode file was updated # Check that the import exitcode file was updated
...@@ -277,11 +275,11 @@ class TestTheiaExportAndImportFailures(ExportAndImportMixin, ResilientTheiaTestC ...@@ -277,11 +275,11 @@ class TestTheiaExportAndImportFailures(ExportAndImportMixin, ResilientTheiaTestC
os.remove(path) os.remove(path)
def customSignatureScript(self, content=None): def customSignatureScript(self, content=None):
custom_script = self._getPartitionPath('export', self.script_relpath) custom_script = self.getPartitionPath('export', self.script_relpath)
self.customScript(custom_script, content) self.customScript(custom_script, content)
def customRestoreScript(self, content=None): def customRestoreScript(self, content=None):
restore_script = self._getPartitionPath('import', 'srv', 'runner-import-restore') restore_script = self.getPartitionPath('import', 'srv', 'runner-import-restore')
self.customScript(restore_script, content) self.customScript(restore_script, content)
return restore_script return restore_script
...@@ -294,7 +292,7 @@ class TestTheiaExportAndImportFailures(ExportAndImportMixin, ResilientTheiaTestC ...@@ -294,7 +292,7 @@ class TestTheiaExportAndImportFailures(ExportAndImportMixin, ResilientTheiaTestC
self.customRestoreScript(content=None) self.customRestoreScript(content=None)
self.cleanupExitfiles() self.cleanupExitfiles()
try: try:
os.remove(self._getPartitionPath('import', self.signature_relpath)) os.remove(self.getPartitionPath('import', self.signature_relpath))
except OSError: except OSError:
pass pass
...@@ -309,13 +307,13 @@ class TestTheiaExportAndImportFailures(ExportAndImportMixin, ResilientTheiaTestC ...@@ -309,13 +307,13 @@ class TestTheiaExportAndImportFailures(ExportAndImportMixin, ResilientTheiaTestC
def test_custom_hash_script(self): def test_custom_hash_script(self):
errmsg = 'Bye bye' errmsg = 'Bye bye'
self.customSignatureScript(content='>&2 echo "%s"\nexit 1' % errmsg) self.customSignatureScript(content='>&2 echo "%s"\nexit 1' % errmsg)
custom_script = self._getPartitionPath('export', self.script_relpath) custom_script = self.getPartitionPath('export', self.script_relpath)
self.assertExportFailure('Compute partitions backup signatures\n ... ERROR !', self.assertExportFailure('Compute partitions backup signatures\n ... ERROR !',
'Custom signature script %s failed' % os.path.abspath(custom_script), 'Custom signature script %s failed' % os.path.abspath(custom_script),
'and stderr:\n%s' % errmsg) 'and stderr:\n%s' % errmsg)
def test_signature_mismatch(self): def test_signature_mismatch(self):
signature_file = self._getPartitionPath('import', self.signature_relpath) signature_file = self.getPartitionPath('import', self.signature_relpath)
self.writeFile(signature_file, 'Bogus Hash\n', mode='a') self.writeFile(signature_file, 'Bogus Hash\n', mode='a')
self.assertImportFailure('ERROR the backup signatures do not match') self.assertImportFailure('ERROR the backup signatures do not match')
...@@ -344,7 +342,7 @@ class TestTheiaExportAndImport(ResilienceMixin, ExportAndImportMixin, ResilientT ...@@ -344,7 +342,7 @@ class TestTheiaExportAndImport(ResilienceMixin, ExportAndImportMixin, ResilientT
def _prepareExport(self): def _prepareExport(self):
# Copy ./resilience_dummy SR in export theia ~/srv/project/dummy # Copy ./resilience_dummy SR in export theia ~/srv/project/dummy
dummy_target_path = self._getPartitionPath('export', 'srv', 'project', 'dummy') dummy_target_path = self.getPartitionPath('export', 'srv', 'project', 'dummy')
shutil.copytree(os.path.dirname(dummy_software_url), dummy_target_path) shutil.copytree(os.path.dirname(dummy_software_url), dummy_target_path)
self._test_software_url = os.path.join(dummy_target_path, 'software.cfg') self._test_software_url = os.path.join(dummy_target_path, 'software.cfg')
...@@ -352,8 +350,8 @@ class TestTheiaExportAndImport(ResilienceMixin, ExportAndImportMixin, ResilientT ...@@ -352,8 +350,8 @@ class TestTheiaExportAndImport(ResilienceMixin, ExportAndImportMixin, ResilientT
self._deployEmbeddedSoftware(self._test_software_url, 'dummy_instance') self._deployEmbeddedSoftware(self._test_software_url, 'dummy_instance')
relpath_dummy = os.path.join('srv', 'runner', 'instance', 'slappart0') relpath_dummy = os.path.join('srv', 'runner', 'instance', 'slappart0')
self.export_dummy_root = dummy_root = self._getPartitionPath('export', relpath_dummy) self.export_dummy_root = dummy_root = self.getPartitionPath('export', relpath_dummy)
self.import_dummy_root = self._getPartitionPath('import', relpath_dummy) self.import_dummy_root = self.getPartitionPath('import', relpath_dummy)
# Check that dummy instance was properly deployed # Check that dummy instance was properly deployed
self.initial_log = self.checkLog(os.path.join(dummy_root, 'log.log')) self.initial_log = self.checkLog(os.path.join(dummy_root, 'log.log'))
...@@ -373,7 +371,7 @@ class TestTheiaExportAndImport(ResilienceMixin, ExportAndImportMixin, ResilientT ...@@ -373,7 +371,7 @@ class TestTheiaExportAndImport(ResilienceMixin, ExportAndImportMixin, ResilientT
self.assertTrue(os.path.exists(os.path.join(dummy_root, 'srv', '.backup_identity_script'))) self.assertTrue(os.path.exists(os.path.join(dummy_root, 'srv', '.backup_identity_script')))
# Remember content of ~/etc in the import theia # Remember content of ~/etc in the import theia
self.etc_listdir = os.listdir(self._getPartitionPath('import', 'etc')) self.etc_listdir = os.listdir(self.getPartitionPath('import', 'etc'))
def _doSync(self): def _doSync(self):
self._doExport() self._doExport()
...@@ -384,14 +382,13 @@ class TestTheiaExportAndImport(ResilienceMixin, ExportAndImportMixin, ResilientT ...@@ -384,14 +382,13 @@ class TestTheiaExportAndImport(ResilienceMixin, ExportAndImportMixin, ResilientT
dummy_root = self.import_dummy_root dummy_root = self.import_dummy_root
# Check that the software url is correct # Check that the software url is correct
adapted_test_url = self._getPartitionPath('import', 'srv', 'project', 'dummy', 'software.cfg') adapted_test_url = self.getPartitionPath('import', 'srv', 'project', 'dummy', 'software.cfg')
proxy_content = subprocess.check_output( proxy_content = self.captureSlapos('proxy', 'show', instance_type='import', text=True)
(self._getSlapos('import'), 'proxy', 'show'), universal_newlines=True)
self.assertIn(adapted_test_url, proxy_content) self.assertIn(adapted_test_url, proxy_content)
self.assertNotIn(self._test_software_url, proxy_content) self.assertNotIn(self._test_software_url, proxy_content)
# Check that ~/etc still contains everything it did before # Check that ~/etc still contains everything it did before
etc_listdir = os.listdir(self._getPartitionPath('import', 'etc')) etc_listdir = os.listdir(self.getPartitionPath('import', 'etc'))
self.assertTrue(set(self.etc_listdir).issubset(etc_listdir)) self.assertTrue(set(self.etc_listdir).issubset(etc_listdir))
# Check that ~/srv/project was exported # Check that ~/srv/project was exported
...@@ -401,7 +398,7 @@ class TestTheiaExportAndImport(ResilienceMixin, ExportAndImportMixin, ResilientT ...@@ -401,7 +398,7 @@ class TestTheiaExportAndImport(ResilienceMixin, ExportAndImportMixin, ResilientT
self.checkLog(os.path.join(dummy_root, 'log.log'), self.initial_log, newline=None) self.checkLog(os.path.join(dummy_root, 'log.log'), self.initial_log, newline=None)
# Check that ~/srv/.backup_identity_script was detected and called # Check that ~/srv/.backup_identity_script was detected and called
signature = self._getPartitionPath( signature = self.getPartitionPath(
'import', 'srv', 'backup', 'theia', 'slappart0.backup.signature.custom') 'import', 'srv', 'backup', 'theia', 'slappart0.backup.signature.custom')
self.assertTrue(os.path.exists(signature)) self.assertTrue(os.path.exists(signature))
with open(signature) as f: with open(signature) as f:
...@@ -418,7 +415,7 @@ class TestTheiaExportAndImport(ResilienceMixin, ExportAndImportMixin, ResilientT ...@@ -418,7 +415,7 @@ class TestTheiaExportAndImport(ResilienceMixin, ExportAndImportMixin, ResilientT
def _doTakeover(self): def _doTakeover(self):
# Start the dummy instance as a sort of fake takeover # Start the dummy instance as a sort of fake takeover
subprocess.check_call((self._getSlapos('import'), 'node', 'instance')) self.callSlapos('node', 'instance', instance_type='import')
def _checkTakeover(self): def _checkTakeover(self):
# Check that dummy instance was properly re-deployed # Check that dummy instance was properly re-deployed
...@@ -493,7 +490,7 @@ class TestTheiaResilience(ResilienceMixin, TakeoverMixin, ResilientTheiaTestCase ...@@ -493,7 +490,7 @@ class TestTheiaResilience(ResilienceMixin, TakeoverMixin, ResilientTheiaTestCase
# Run two synchronisations on the same instances # Run two synchronisations on the same instances
# to make sure everything still works the second time # to make sure everything still works the second time
# Check ~/etc in import theia again # Check ~/etc in import theia again
self.etc_listdir = os.listdir(self._getPartitionPath('import', 'etc')) self.etc_listdir = os.listdir(self.getPartitionPath('import', 'etc'))
self._doSync() self._doSync()
self._checkSync() self._checkSync()
...@@ -502,18 +499,18 @@ class TestTheiaResilience(ResilienceMixin, TakeoverMixin, ResilientTheiaTestCase ...@@ -502,18 +499,18 @@ class TestTheiaResilience(ResilienceMixin, TakeoverMixin, ResilientTheiaTestCase
self._deployEmbeddedSoftware(self._test_software_url, 'test_instance', self.test_instance_max_retries) self._deployEmbeddedSoftware(self._test_software_url, 'test_instance', self.test_instance_max_retries)
# Check that there is an export and import instance and get their partition IDs # Check that there is an export and import instance and get their partition IDs
self.export_id = self._getPartitionId('export') self.export_id = self.getPartitionId('export')
self.import_id = self._getPartitionId('import') self.import_id = self.getPartitionId('import')
# Remember content of ~/etc in the import theia # Remember content of ~/etc in the import theia
self.etc_listdir = os.listdir(self._getPartitionPath('import', 'etc')) self.etc_listdir = os.listdir(self.getPartitionPath('import', 'etc'))
def _doSync(self): def _doSync(self):
start = time.time() start = time.time()
# Call exporter script instead of waiting for cron job # Call exporter script instead of waiting for cron job
# XXX Accelerate cron frequency instead ? # XXX Accelerate cron frequency instead ?
exporter_script = self._getPartitionPath('export', 'bin', 'exporter') exporter_script = self.getPartitionPath('export', 'bin', 'exporter')
transaction_id = str(int(time.time())) transaction_id = str(int(time.time()))
subprocess.check_call((exporter_script, '--transaction-id', transaction_id)) subprocess.check_call((exporter_script, '--transaction-id', transaction_id))
...@@ -524,7 +521,7 @@ class TestTheiaResilience(ResilienceMixin, TakeoverMixin, ResilientTheiaTestCase ...@@ -524,7 +521,7 @@ class TestTheiaResilience(ResilienceMixin, TakeoverMixin, ResilientTheiaTestCase
def _checkSync(self): def _checkSync(self):
# Check that ~/etc still contains everything it did before # Check that ~/etc still contains everything it did before
etc_listdir = os.listdir(self._getPartitionPath('import', 'etc')) etc_listdir = os.listdir(self.getPartitionPath('import', 'etc'))
self.assertTrue(set(self.etc_listdir).issubset(etc_listdir)) self.assertTrue(set(self.etc_listdir).issubset(etc_listdir))
def _doTakeover(self): def _doTakeover(self):
...@@ -541,9 +538,9 @@ class TestTheiaResilience(ResilienceMixin, TakeoverMixin, ResilientTheiaTestCase ...@@ -541,9 +538,9 @@ class TestTheiaResilience(ResilienceMixin, TakeoverMixin, ResilientTheiaTestCase
# Check that there is an export, import and frozen instance and get their new partition IDs # Check that there is an export, import and frozen instance and get their new partition IDs
import_id = self.import_id import_id = self.import_id
export_id = self.export_id export_id = self.export_id
new_export_id = self._getPartitionId('export') new_export_id = self.getPartitionId('export')
new_import_id = self._getPartitionId('import') new_import_id = self.getPartitionId('import')
new_frozen_id = self._getPartitionId('frozen') new_frozen_id = self.getPartitionId('frozen')
# Check that old export instance is now frozen # Check that old export instance is now frozen
self.assertEqual(export_id, new_frozen_id) self.assertEqual(export_id, new_frozen_id)
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment