Not fully removed, sadly enough.
ExperimentControllers still need them.
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
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
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)
# 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:
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()
}
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):
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
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
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
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
"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 && "
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"
+
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
# PROTOCOL INSTRUCTION MESSAGES
XML = 2
-ACCESS = 3
TRACE = 4
FINISHED = 5
START = 6
# 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,
OK: "OK",
ERROR: "ERROR",
XML: "XML",
- ACCESS: "ACCESS",
TRACE: "TRACE",
FINISHED: "FINISHED",
START: "START",
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):
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
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,
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:
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])
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)
# -*- 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
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()
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):
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)
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)
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
# 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)
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
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)
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)
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
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)
git://git.onelab.eu / nepi.git / commitdiff