From f0cc9158e40298f7039fc893da3b5a5ce210f655 Mon Sep 17 00:00:00 2001 From: Claudio-Daniel Freire Date: Tue, 3 May 2011 12:19:32 +0200 Subject: [PATCH] Ticket #29: Phasing out AccessConfiguration. Not fully removed, sadly enough. ExperimentControllers still need them. --- src/nepi/core/attributes.py | 8 + src/nepi/core/execute.py | 31 ++-- src/nepi/core/metadata.py | 127 ++++++++++++-- src/nepi/testbeds/planetlab/application.py | 1 + src/nepi/util/constants.py | 23 +++ src/nepi/util/proxy.py | 185 ++++++--------------- test/core/integration.py | 94 +++++------ test/testbeds/netns/integration.py | 58 +++---- test/testbeds/ns3/integration.py | 25 ++- 9 files changed, 284 insertions(+), 268 deletions(-) diff --git a/src/nepi/core/attributes.py b/src/nepi/core/attributes.py index 21a47973..5072c1b1 100644 --- a/src/nepi/core/attributes.py +++ b/src/nepi/core/attributes.py @@ -16,6 +16,14 @@ class Attribute(object): DOUBLE, INTEGER ] + + type_parsers = { + STRING : str, + BOOL : lambda x : str(x).lower() in ("1","on","yes","true"), + ENUM : str, + DOUBLE : float, + INTEGER : int, + } ### Attribute Flags NoFlags = 0x00 diff --git a/src/nepi/core/execute.py b/src/nepi/core/execute.py index ca3199b3..1f4ece41 100644 --- a/src/nepi/core/execute.py +++ b/src/nepi/core/execute.py @@ -311,7 +311,7 @@ class ExperimentController(object): def __init__(self, experiment_xml, root_dir): self._experiment_xml = experiment_xml self._testbeds = dict() - self._access_config = dict() + self._deployment_config = dict() self._netrefs = dict() self._cross_data = dict() self._root_dir = root_dir @@ -328,9 +328,6 @@ class ExperimentController(object): f.write(self._experiment_xml) f.close() - def set_access_configuration(self, testbed_guid, access_config): - self._access_config[testbed_guid] = access_config - def trace(self, testbed_guid, guid, trace_id, attribute='value'): return self._testbeds[testbed_guid].trace(guid, trace_id, attribute) @@ -393,7 +390,7 @@ class ExperimentController(object): # persist access configuration for all testbeds, so that # recovery mode can reconnect to them if it becomes necessary conf = ConfigParser.RawConfigParser() - for testbed_guid, testbed_config in self._access_config.iteritems(): + for testbed_guid, testbed_config in self._deployment_config.iteritems(): testbed_guid = str(testbed_guid) conf.add_section(testbed_guid) for attr in testbed_config.attributes_list: @@ -401,7 +398,7 @@ class ExperimentController(object): conf.set(testbed_guid, attr, testbed_config.get_attribute_value(attr)) - f = open(os.path.join(self._root_dir, 'access_config.ini'), 'w') + f = open(os.path.join(self._root_dir, 'deployment_config.ini'), 'w') conf.write(f) f.close() @@ -414,7 +411,7 @@ class ExperimentController(object): } conf = ConfigParser.RawConfigParser() - conf.read(os.path.join(self._root_dir, 'access_config.ini')) + conf.read(os.path.join(self._root_dir, 'deployment_config.ini')) for testbed_guid in conf.sections(): testbed_config = proxy.AccessConfiguration() for attr in conf.options(testbed_guid): @@ -433,7 +430,7 @@ class ExperimentController(object): def _unpersist_testbed_proxies(self): try: - os.remove(os.path.join(self._root_dir, 'access_config.ini')) + os.remove(os.path.join(self._root_dir, 'deployment_config.ini')) except: # Just print exceptions, this is just cleanup import traceback @@ -585,18 +582,22 @@ class ExperimentController(object): def _create_testbed_controller(self, guid, data, element_guids, recover): (testbed_id, testbed_version) = data.get_testbed_data(guid) - access_config = None if guid not in self._access_config else\ - self._access_config[guid] + deployment_config = self._deployment_config.get(guid) - if recover and access_config is None: + if deployment_config is None: # need to create one - access_config = self._access_config[guid] = proxy.AccessConfiguration() - if access_config is not None: + deployment_config = self._deployment_config[guid] = proxy.AccessConfiguration() + + for (name, value) in data.get_attribute_data(guid): + if value is not None and deployment_config.has_attribute(name): + deployment_config.set_attribute_value(name, value) + + if deployment_config is not None: # force recovery mode - access_config.set_attribute_value("recover",recover) + deployment_config.set_attribute_value("recover",recover) testbed = proxy.create_testbed_controller(testbed_id, - testbed_version, access_config) + testbed_version, deployment_config) for (name, value) in data.get_attribute_data(guid): testbed.defer_configure(name, value) self._testbeds[guid] = testbed diff --git a/src/nepi/core/metadata.py b/src/nepi/core/metadata.py index 7414b619..9c50ef51 100644 --- a/src/nepi/core/metadata.py +++ b/src/nepi/core/metadata.py @@ -3,7 +3,9 @@ from nepi.core.attributes import Attribute, AttributesMap import sys +import getpass from nepi.util import validation +from nepi.util.constants import ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP, DeploymentConfiguration class VersionedMetadataInfo(object): @property @@ -127,25 +129,120 @@ class VersionedMetadataInfo(object): class Metadata(object): STANDARD_BOX_ATTRIBUTES = ( - ("label", dict({ - "name": "label", - "validation_function": validation.is_string, - "type": Attribute.STRING, - "flags": Attribute.DesignOnly, - "help": "A unique identifier for referring to this box", - })), + ("label", dict( + name = "label", + validation_function = validation.is_string, + type = Attribute.STRING, + flags = Attribute.DesignOnly, + help = "A unique identifier for referring to this box", + )), ) + + # Shorthand for DeploymentConfiguration + # Syntactic sugar to shorten stuff + DC = DeploymentConfiguration STANDARD_TESTBED_ATTRIBUTES = ( - ("home_directory", dict({ - "name": "homeDirectory", - "validation_function": validation.is_string, - "help": "Path to the directory where traces and other files will be stored", - "type": Attribute.STRING, - "value": "", - "flags": Attribute.DesignOnly, - })), + ("home_directory", dict( + name = "homeDirectory", + validation_function = validation.is_string, + help = "Path to the directory where traces and other files will be stored", + type = Attribute.STRING, + value = "", + flags = Attribute.DesignOnly, + )), ) + + DEPLOYMENT_ATTRIBUTES = ( + # TESTBED DEPLOYMENT ATTRIBUTES + (DC.DEPLOYMENT_ENVIRONMENT_SETUP, dict( + name = DC.DEPLOYMENT_ENVIRONMENT_SETUP, + validation_function = validation.is_string, + help = "Shell commands to run before spawning TestbedController processes", + type = Attribute.STRING, + flags = Attribute.DesignOnly, + )), + (DC.DEPLOYMENT_MODE, dict(name = DC.DEPLOYMENT_MODE, + help = "Instance execution mode", + type = Attribute.ENUM, + value = DC.MODE_SINGLE_PROCESS, + allowed = [ + DC.MODE_DAEMON, + DC.MODE_SINGLE_PROCESS + ], + flags = Attribute.DesignOnly, + validation_function = validation.is_enum + )), + (DC.DEPLOYMENT_COMMUNICATION, dict(name = DC.DEPLOYMENT_COMMUNICATION, + help = "Instance communication mode", + type = Attribute.ENUM, + value = DC.ACCESS_LOCAL, + allowed = [ + DC.ACCESS_LOCAL, + DC.ACCESS_SSH + ], + flags = Attribute.DesignOnly, + validation_function = validation.is_enum + )), + (DC.DEPLOYMENT_HOST, dict(name = DC.DEPLOYMENT_HOST, + help = "Host where the testbed will be executed", + type = Attribute.STRING, + value = "localhost", + flags = Attribute.DesignOnly, + validation_function = validation.is_string + )), + (DC.DEPLOYMENT_USER, dict(name = DC.DEPLOYMENT_USER, + help = "User on the Host to execute the testbed", + type = Attribute.STRING, + value = getpass.getuser(), + flags = Attribute.DesignOnly, + validation_function = validation.is_string + )), + (DC.DEPLOYMENT_PORT, dict(name = DC.DEPLOYMENT_PORT, + help = "Port on the Host", + type = Attribute.INTEGER, + value = 22, + flags = Attribute.DesignOnly, + validation_function = validation.is_integer + )), + (DC.ROOT_DIRECTORY, dict(name = DC.ROOT_DIRECTORY, + help = "Root directory for storing process files", + type = Attribute.STRING, + value = ".", + flags = Attribute.DesignOnly, + validation_function = validation.is_string # TODO: validation.is_path + )), + (DC.USE_AGENT, dict(name = DC.USE_AGENT, + help = "Use -A option for forwarding of the authentication agent, if ssh access is used", + type = Attribute.BOOL, + value = False, + flags = Attribute.DesignOnly, + validation_function = validation.is_bool + )), + (DC.LOG_LEVEL, dict(name = DC.LOG_LEVEL, + help = "Log level for instance", + type = Attribute.ENUM, + value = DC.ERROR_LEVEL, + allowed = [ + DC.ERROR_LEVEL, + DC.DEBUG_LEVEL + ], + flags = Attribute.DesignOnly, + validation_function = validation.is_enum + )), + (DC.RECOVER, dict(name = DC.RECOVER, + help = "Do not intantiate testbeds, rather, reconnect to already-running instances. Used to recover from a dead controller.", + type = Attribute.BOOL, + value = False, + flags = Attribute.DesignOnly, + validation_function = validation.is_bool + )), + ) + + STANDARD_TESTBED_ATTRIBUTES += DEPLOYMENT_ATTRIBUTES + + del DC + def __init__(self, testbed_id, version): self._version = version diff --git a/src/nepi/testbeds/planetlab/application.py b/src/nepi/testbeds/planetlab/application.py index 6aea32ef..371d2e8f 100644 --- a/src/nepi/testbeds/planetlab/application.py +++ b/src/nepi/testbeds/planetlab/application.py @@ -508,6 +508,7 @@ class NS3Dependency(Dependency): "rm -rf target && " # mv doesn't like unclean targets "mkdir -p target && " "cd pygccxml-1.0.0 && " + "rm -rf unittests docs && " # pygccxml has ~100M of unit tests - excessive - docs aren't needed either "python setup.py build && " "python setup.py install --install-lib ${BUILD}/target && " "python setup.py clean && " diff --git a/src/nepi/util/constants.py b/src/nepi/util/constants.py index ac23fedd..82b0db6c 100644 --- a/src/nepi/util/constants.py +++ b/src/nepi/util/constants.py @@ -23,3 +23,26 @@ TIME_NOW = "0s" ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP = "_nepi_testbed_environment_setup" + +class DeploymentConfiguration: + MODE_SINGLE_PROCESS = "SINGLE" + MODE_DAEMON = "DAEMON" + ACCESS_SSH = "SSH" + ACCESS_LOCAL = "LOCAL" + ERROR_LEVEL = "Error" + DEBUG_LEVEL = "Debug" + + DEPLOYMENT_MODE = "deployment_mode" + DEPLOYMENT_COMMUNICATION = "deployment_communication" + + DEPLOYMENT_HOST = "deployment_host" + DEPLOYMENT_USER = "deployment_user" + DEPLOYMENT_PORT = "deployment_port" + + DEPLOYMENT_ENVIRONMENT_SETUP = "deployment_environment_setup" + + ROOT_DIRECTORY = "rootDirectory" + USE_AGENT = "useAgent" + LOG_LEVEL = "logLevel" + RECOVER = "recover" + diff --git a/src/nepi/util/proxy.py b/src/nepi/util/proxy.py index 1be195ac..7af0543f 100644 --- a/src/nepi/util/proxy.py +++ b/src/nepi/util/proxy.py @@ -4,7 +4,7 @@ import base64 from nepi.core.attributes import AttributesMap, Attribute from nepi.util import server, validation -from nepi.util.constants import TIME_NOW, ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP +from nepi.util.constants import TIME_NOW, ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP, DeploymentConfiguration as DC import getpass import cPickle import sys @@ -18,7 +18,6 @@ ERROR = 1 # PROTOCOL INSTRUCTION MESSAGES XML = 2 -ACCESS = 3 TRACE = 4 FINISHED = 5 START = 6 @@ -64,7 +63,6 @@ FLOAT = 103 # EXPERIMENT CONTROLER PROTOCOL MESSAGES controller_messages = dict({ XML: "%d" % XML, - ACCESS: "%d|%s" % (ACCESS, "%d|%s|%s|%s|%s|%d|%s|%r|%s"), TRACE: "%d|%s" % (TRACE, "%d|%d|%s|%s"), FINISHED: "%d|%s" % (FINISHED, "%d"), START: "%d" % START, @@ -114,7 +112,6 @@ instruction_text = dict({ OK: "OK", ERROR: "ERROR", XML: "XML", - ACCESS: "ACCESS", TRACE: "TRACE", FINISHED: "FINISHED", START: "START", @@ -192,84 +189,44 @@ def log_reply(server, reply): code_txt, txt)) def to_server_log_level(log_level): - return server.DEBUG_LEVEL \ - if log_level == AccessConfiguration.DEBUG_LEVEL \ - else server.ERROR_LEVEL + return ( + server.DEBUG_LEVEL + if log_level == DC.DEBUG_LEVEL + else server.ERROR_LEVEL + ) def get_access_config_params(access_config): - root_dir = access_config.get_attribute_value("rootDirectory") - log_level = access_config.get_attribute_value("logLevel") + root_dir = access_config.get_attribute_value(DC.ROOT_DIRECTORY) + log_level = access_config.get_attribute_value(DC.LOG_LEVEL) log_level = to_server_log_level(log_level) user = host = port = agent = None - communication = access_config.get_attribute_value("communication") - if communication == AccessConfiguration.ACCESS_SSH: - user = access_config.get_attribute_value("user") - host = access_config.get_attribute_value("host") - port = access_config.get_attribute_value("port") - agent = access_config.get_attribute_value("useAgent") - return (root_dir, log_level, user, host, port, agent) + communication = access_config.get_attribute_value(DC.DEPLOYMENT_COMMUNICATION) + environment_setup = ( + access_config.get_attribute_value(DC.DEPLOYMENT_ENVIRONMENT_SETUP) + if access_config.has_attribute(DC.DEPLOYMENT_ENVIRONMENT_SETUP) + else None + ) + if communication == DC.ACCESS_SSH: + user = access_config.get_attribute_value(DC.DEPLOYMENT_USER) + host = access_config.get_attribute_value(DC.DEPLOYMENT_HOST) + port = access_config.get_attribute_value(DC.DEPLOYMENT_PORT) + agent = access_config.get_attribute_value(DC.USE_AGENT) + return (root_dir, log_level, user, host, port, agent, environment_setup) class AccessConfiguration(AttributesMap): - MODE_SINGLE_PROCESS = "SINGLE" - MODE_DAEMON = "DAEMON" - ACCESS_SSH = "SSH" - ACCESS_LOCAL = "LOCAL" - ERROR_LEVEL = "Error" - DEBUG_LEVEL = "Debug" - - def __init__(self): + def __init__(self, params = None): super(AccessConfiguration, self).__init__() - self.add_attribute(name = "mode", - help = "Instance execution mode", - type = Attribute.ENUM, - value = AccessConfiguration.MODE_SINGLE_PROCESS, - allowed = [AccessConfiguration.MODE_DAEMON, - AccessConfiguration.MODE_SINGLE_PROCESS], - validation_function = validation.is_enum) - self.add_attribute(name = "communication", - help = "Instance communication mode", - type = Attribute.ENUM, - value = AccessConfiguration.ACCESS_LOCAL, - allowed = [AccessConfiguration.ACCESS_LOCAL, - AccessConfiguration.ACCESS_SSH], - validation_function = validation.is_enum) - self.add_attribute(name = "host", - help = "Host where the testbed will be executed", - type = Attribute.STRING, - value = "localhost", - validation_function = validation.is_string) - self.add_attribute(name = "user", - help = "User on the Host to execute the testbed", - type = Attribute.STRING, - value = getpass.getuser(), - validation_function = validation.is_string) - self.add_attribute(name = "port", - help = "Port on the Host", - type = Attribute.INTEGER, - value = 22, - validation_function = validation.is_integer) - self.add_attribute(name = "rootDirectory", - help = "Root directory for storing process files", - type = Attribute.STRING, - value = ".", - validation_function = validation.is_string) # TODO: validation.is_path - self.add_attribute(name = "useAgent", - help = "Use -A option for forwarding of the authentication agent, if ssh access is used", - type = Attribute.BOOL, - value = False, - validation_function = validation.is_bool) - self.add_attribute(name = "logLevel", - help = "Log level for instance", - type = Attribute.ENUM, - value = AccessConfiguration.ERROR_LEVEL, - allowed = [AccessConfiguration.ERROR_LEVEL, - AccessConfiguration.DEBUG_LEVEL], - validation_function = validation.is_enum) - self.add_attribute(name = "recover", - help = "Do not intantiate testbeds, rather, reconnect to already-running instances. Used to recover from a dead controller.", - type = Attribute.BOOL, - value = False, - validation_function = validation.is_bool) + + from nepi.core.metadata import Metadata + + for _,attr_info in Metadata.DEPLOYMENT_ATTRIBUTES: + self.add_attribute(**attr_info) + + if params: + for attr_name, attr_value in params.iteritems(): + parser = Attribute.type_parsers[self.get_attribute_type(attr_name)] + attr_value = parser(attr_value) + self.set_attribute_value(attr_name, attr_value) class TempDir(object): def __init__(self): @@ -284,19 +241,19 @@ class PermDir(object): def create_controller(xml, access_config = None): mode = None if not access_config \ - else access_config.get_attribute_value("mode") + else access_config.get_attribute_value(DC.DEPLOYMENT_MODE) launch = True if not access_config \ - else not access_config.get_attribute_value("recover") - if not mode or mode == AccessConfiguration.MODE_SINGLE_PROCESS: + else not access_config.get_attribute_value(DC.RECOVER) + if not mode or mode == DC.MODE_SINGLE_PROCESS: if not launch: raise ValueError, "Unsupported instantiation mode: %s with lanch=False" % (mode,) from nepi.core.execute import ExperimentController - if not access_config or not access_config.has_attribute("rootDirectory"): + if not access_config or not access_config.has_attribute(DC.ROOT_DIRECTORY): root_dir = TempDir() else: - root_dir = PermDir(access_config.get_attribute_value("rootDirectory")) + root_dir = PermDir(access_config.get_attribute_value(DC.ROOT_DIRECTORY)) controller = ExperimentController(xml, root_dir.path) # inject reference to temporary dir, so that it gets cleaned @@ -304,29 +261,26 @@ def create_controller(xml, access_config = None): controller._tempdir = root_dir return controller - elif mode == AccessConfiguration.MODE_DAEMON: - (root_dir, log_level, user, host, port, agent) = \ + elif mode == DC.MODE_DAEMON: + (root_dir, log_level, user, host, port, agent, environment_setup) = \ get_access_config_params(access_config) return ExperimentControllerProxy(root_dir, log_level, experiment_xml = xml, host = host, port = port, user = user, - agent = agent, launch = launch) + agent = agent, launch = launch, + environment_setup = environment_setup) raise RuntimeError("Unsupported access configuration '%s'" % mode) def create_testbed_controller(testbed_id, testbed_version, access_config): mode = None if not access_config \ - else access_config.get_attribute_value("mode") + else access_config.get_attribute_value(DC.DEPLOYMENT_MODE) launch = True if not access_config \ - else not access_config.get_attribute_value("recover") - environment_setup = access_config \ - and access_config.has_attribute(ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP) \ - and access_config.get_attribute_value(ATTR_NEPI_TESTBED_ENVIRONMENT_SETUP) \ - or "" - if not mode or mode == AccessConfiguration.MODE_SINGLE_PROCESS: + else not access_config.get_attribute_value(DC.RECOVER) + if not mode or mode == DC.MODE_SINGLE_PROCESS: if not launch: raise ValueError, "Unsupported instantiation mode: %s with lanch=False" % (mode,) return _build_testbed_controller(testbed_id, testbed_version) - elif mode == AccessConfiguration.MODE_DAEMON: - (root_dir, log_level, user, host, port, agent) = \ + elif mode == DC.MODE_DAEMON: + (root_dir, log_level, user, host, port, agent, environment_setup) = \ get_access_config_params(access_config) return TestbedControllerProxy(root_dir, log_level, testbed_id = testbed_id, testbed_version = testbed_version, host = host, port = port, @@ -663,8 +617,6 @@ class ExperimentControllerServer(server.Server): try: if instruction == XML: reply = self.experiment_xml(params) - elif instruction == ACCESS: - reply = self.set_access_configuration(params) elif instruction == TRACE: reply = self.trace(params) elif instruction == FINISHED: @@ -697,30 +649,7 @@ class ExperimentControllerServer(server.Server): xml = self._controller.experiment_xml result = base64.b64encode(xml) return "%d|%s" % (OK, result) - - def set_access_configuration(self, params): - testbed_guid = int(params[1]) - mode = params[2] - communication = params[3] - host = params[4] - user = params[5] - port = int(params[6]) - root_dir = params[7] - use_agent = params[8] == "True" - log_level = params[9] - access_config = AccessConfiguration() - access_config.set_attribute_value("mode", mode) - access_config.set_attribute_value("communication", communication) - access_config.set_attribute_value("host", host) - access_config.set_attribute_value("user", user) - access_config.set_attribute_value("port", port) - access_config.set_attribute_value("rootDirectory", root_dir) - access_config.set_attribute_value("useAgent", use_agent) - access_config.set_attribute_value("logLevel", log_level) - self._controller.set_access_configuration(testbed_guid, - access_config) - return "%d|%s" % (OK, "") - + def trace(self, params): testbed_guid = int(params[1]) guid = int(params[2]) @@ -1225,26 +1154,6 @@ class ExperimentControllerProxy(object): raise RuntimeError(text) return text - def set_access_configuration(self, testbed_guid, access_config): - mode = access_config.get_attribute_value("mode") - communication = access_config.get_attribute_value("communication") - host = access_config.get_attribute_value("host") - user = access_config.get_attribute_value("user") - port = access_config.get_attribute_value("port") - root_dir = access_config.get_attribute_value("rootDirectory") - use_agent = access_config.get_attribute_value("useAgent") - log_level = access_config.get_attribute_value("logLevel") - msg = controller_messages[ACCESS] - msg = msg % (testbed_guid, mode, communication, host, user, port, - root_dir, use_agent, log_level) - self._client.send_msg(msg) - reply = self._client.read_reply() - result = reply.split("|") - code = int(result[0]) - text = base64.b64decode(result[1]) - if code == ERROR: - raise RuntimeError(text) - def trace(self, testbed_guid, guid, trace_id, attribute='value'): msg = controller_messages[TRACE] attribute = base64.b64encode(attribute) diff --git a/test/core/integration.py b/test/core/integration.py index 326275b3..d58dc863 100755 --- a/test/core/integration.py +++ b/test/core/integration.py @@ -2,7 +2,7 @@ # -*- coding: utf-8 -*- from nepi.core.design import ExperimentDescription, FactoriesProvider -from nepi.util.constants import STATUS_FINISHED +from nepi.util.constants import STATUS_FINISHED, DeploymentConfiguration as DC from nepi.util import proxy import mock import mock.metadata_v01 @@ -102,9 +102,8 @@ class ExecuteTestCase(unittest.TestCase): exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment() xml = exp_desc.to_xml() access_config = proxy.AccessConfiguration() - access_config.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - access_config.set_attribute_value("rootDirectory", self.root_dir) + access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir) controller = proxy.create_controller(xml, access_config) controller.start() @@ -122,13 +121,13 @@ class ExecuteTestCase(unittest.TestCase): def test_daemonized_testbed_integration(self): exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment() + + desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + desc.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir) + xml = exp_desc.to_xml() + controller = proxy.create_controller(xml, access_config = None) - access_config = proxy.AccessConfiguration() - access_config.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - access_config.set_attribute_value("rootDirectory", self.root_dir) - controller.set_access_configuration(desc.guid, access_config) controller.start() while not controller.is_finished(app.guid): @@ -145,21 +144,19 @@ class ExecuteTestCase(unittest.TestCase): def test_daemonized_all_integration(self): exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment() + + desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + inst_root_dir = os.path.join(self.root_dir, "instance") + os.mkdir(inst_root_dir) + desc.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir) + xml = exp_desc.to_xml() + access_config = proxy.AccessConfiguration() - access_config.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - access_config.set_attribute_value("rootDirectory", self.root_dir) + access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir) controller = proxy.create_controller(xml, access_config) - access_config2 = proxy.AccessConfiguration() - access_config2.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - inst_root_dir = os.path.join(self.root_dir, "instance") - os.mkdir(inst_root_dir) - access_config2.set_attribute_value("rootDirectory", inst_root_dir) - controller.set_access_configuration(desc.guid, access_config2) - controller.start() while not controller.is_finished(app.guid): time.sleep(0.5) @@ -175,21 +172,19 @@ class ExecuteTestCase(unittest.TestCase): def test_daemonized_all_integration_recovery(self): exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment() + + desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + inst_root_dir = os.path.join(self.root_dir, "instance") + os.mkdir(inst_root_dir) + desc.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir) + xml = exp_desc.to_xml() + access_config = proxy.AccessConfiguration() - access_config.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - access_config.set_attribute_value("rootDirectory", self.root_dir) + access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir) controller = proxy.create_controller(xml, access_config) - access_config2 = proxy.AccessConfiguration() - access_config2.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - inst_root_dir = os.path.join(self.root_dir, "instance") - os.mkdir(inst_root_dir) - access_config2.set_attribute_value("rootDirectory", inst_root_dir) - controller.set_access_configuration(desc.guid, access_config2) - controller.start() while not controller.is_finished(app.guid): time.sleep(0.5) @@ -205,7 +200,7 @@ class ExecuteTestCase(unittest.TestCase): del controller # recover - access_config.set_attribute_value("recover",True) + access_config.set_attribute_value(DC.RECOVER,True) controller = proxy.create_controller(xml, access_config) # test recovery @@ -247,29 +242,26 @@ class ExecuteTestCase(unittest.TestCase): # sys.modules["nepi.testbeds.mock"] = mock # is not set in the ssh process exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment() + env = test_util.test_environment() + + desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + inst_root_dir = os.path.join(self.root_dir, "instance") + os.mkdir(inst_root_dir) + desc.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir) + desc.set_attribute_value(DC.DEPLOYMENT_COMMUNICATION, DC.ACCESS_SSH) + desc.set_attribute_value(DC.DEPLOYMENT_PORT, env.port) + desc.set_attribute_value(DC.USE_AGENT, True) + xml = exp_desc.to_xml() + access_config = proxy.AccessConfiguration() - access_config.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - access_config.set_attribute_value("rootDirectory", self.root_dir) - access_config.set_attribute_value("communication", - proxy.AccessConfiguration.ACCESS_SSH) - access_config.set_attribute_value("port", env.port) - access_config.set_attribute_value("useAgent", True) + access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir) + access_config.set_attribute_value(DC.DEPLOYMENT_COMMUNICATION, DC.ACCESS_SSH) + access_config.set_attribute_value(DC.DEPLOYMENT_PORT, env.port) + access_config.set_attribute_value(DC.USE_AGENT, True) controller = proxy.create_controller(xml, access_config) - access_config2 = proxy.AccessConfiguration() - access_config2.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - inst_root_dir = os.path.join(self.root_dir, "instance") - os.mkdir(inst_root_dir) - access_config2.set_attribute_value("rootDirectory", inst_root_dir) - access_config2.set_attribute_value("communication", - proxy.AccessConfiguration.ACCESS_SSH) - access_config2.set_attribute_value("port", env.port) - access_config2.set_attribute_value("useAgent", True) - controller.set_access_configuration(desc.guid, access_config2) - controller.start() while not controller.is_finished(app.guid): time.sleep(0.5) diff --git a/test/testbeds/netns/integration.py b/test/testbeds/netns/integration.py index 2bed30a4..16f336c0 100755 --- a/test/testbeds/netns/integration.py +++ b/test/testbeds/netns/integration.py @@ -5,6 +5,7 @@ import getpass from nepi.core.design import ExperimentDescription, FactoriesProvider from nepi.core.execute import ExperimentController from nepi.util import proxy +from nepi.util.constants import DeploymentConfiguration as DC import os import shutil import tempfile @@ -94,26 +95,21 @@ class NetnsIntegrationTestCase(unittest.TestCase): app.set_attribute_value("user", user) app.connector("node").connect(node1.connector("apps")) app.enable_trace("stdout") + + netns_desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + inst_root_dir = os.path.join(self.root_dir, "instance") + os.mkdir(inst_root_dir) + netns_desc.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir) + netns_desc.set_attribute_value(DC.LOG_LDEVEL, DC.DEBUG_LEVEL) + xml = exp_desc.to_xml() access_config = proxy.AccessConfiguration() - access_config.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - access_config.set_attribute_value("rootDirectory", self.root_dir) - access_config.set_attribute_value("logLevel", - proxy.AccessConfiguration.DEBUG_LEVEL) + access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir) + access_config.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) controller = proxy.create_controller(xml, access_config) - access_config2 = proxy.AccessConfiguration() - access_config2.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - inst_root_dir = os.path.join(self.root_dir, "instance") - os.mkdir(inst_root_dir) - access_config2.set_attribute_value("rootDirectory", inst_root_dir) - access_config2.set_attribute_value("logLevel", - proxy.AccessConfiguration.DEBUG_LEVEL) - controller.set_access_configuration(netns_desc.guid, access_config2) - controller.start() while not controller.is_finished(app.guid): time.sleep(0.5) @@ -159,30 +155,24 @@ class NetnsIntegrationTestCase(unittest.TestCase): app.set_attribute_value("user", user) app.connector("node").connect(node1.connector("apps")) app.enable_trace("stdout") + + netns_desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + inst_root_dir = os.path.join(self.root_dir, "instance") + os.mkdir(inst_root_dir) + netns_desc.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir) + netns_desc.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) + xml = exp_desc.to_xml() access_config = proxy.AccessConfiguration() - access_config.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - access_config.set_attribute_value("rootDirectory", self.root_dir) - access_config.set_attribute_value("logLevel", - proxy.AccessConfiguration.DEBUG_LEVEL) - access_config.set_attribute_value("communication", - proxy.AccessConfiguration.ACCESS_SSH) - access_config.set_attribute_value("port", env.port) - access_config.set_attribute_value("useAgent", True) + access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir) + access_config.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) + access_config.set_attribute_value(DC.DEPLOYMENT_COMMUNICATION, DC.ACCESS_SSH) + access_config.set_attribute_value(DC.DEPLOYMENT_PORT, env.port) + access_config.set_attribute_value(DC.USE_AGENT, True) controller = proxy.create_controller(xml, access_config) - access_config2 = proxy.AccessConfiguration() - access_config2.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - inst_root_dir = os.path.join(self.root_dir, "instance") - os.mkdir(inst_root_dir) - access_config2.set_attribute_value("rootDirectory", inst_root_dir) - access_config2.set_attribute_value("logLevel", - proxy.AccessConfiguration.DEBUG_LEVEL) - controller.set_access_configuration(netns_desc.guid, access_config2) - controller.start() while not controller.is_finished(app.guid): time.sleep(0.5) diff --git a/test/testbeds/ns3/integration.py b/test/testbeds/ns3/integration.py index 2d66f8a6..61df6ae0 100755 --- a/test/testbeds/ns3/integration.py +++ b/test/testbeds/ns3/integration.py @@ -5,6 +5,7 @@ import getpass from nepi.core.design import ExperimentDescription, FactoriesProvider from nepi.core.execute import ExperimentController from nepi.util import proxy +from nepi.util.constants import DeploymentConfiguration as DC import os import shutil import tempfile @@ -127,25 +128,19 @@ class Ns3IntegrationTestCase(unittest.TestCase): app.set_attribute_value("StopTime", "20s") app.connector("node").connect(node1.connector("apps")) + ns3_desc.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + inst_root_dir = os.path.join(self.root_dir, "instance") + os.mkdir(inst_root_dir) + ns3_desc.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir) + ns3_desc.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) + xml = exp_desc.to_xml() access_config = proxy.AccessConfiguration() - access_config.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - access_config.set_attribute_value("rootDirectory", self.root_dir) - access_config.set_attribute_value("logLevel", - proxy.AccessConfiguration.DEBUG_LEVEL) + access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON) + access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir) + access_config.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL) controller = proxy.create_controller(xml, access_config) - access_config2 = proxy.AccessConfiguration() - access_config2.set_attribute_value("mode", - proxy.AccessConfiguration.MODE_DAEMON) - inst_root_dir = os.path.join(self.root_dir, "instance") - os.mkdir(inst_root_dir) - access_config2.set_attribute_value("rootDirectory", inst_root_dir) - access_config2.set_attribute_value("logLevel", - proxy.AccessConfiguration.DEBUG_LEVEL) - controller.set_access_configuration(ns3_desc.guid, access_config2) - controller.start() while not controller.is_finished(app.guid): time.sleep(0.5) -- 2.43.0