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(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir)
access_config.set_attribute_value(
DC.DEPLOYMENT_ENVIRONMENT_SETUP,
"export PYTHONPATH=%r:%r:$PYTHONPATH "
"export NEPI_TESTBEDS='mock:mock mock2:mock2' " % (
os.path.dirname(os.path.dirname(mock.__file__)),
os.path.dirname(os.path.dirname(mock2.__file__)),
))
controller = proxy.create_experiment_controller(xml, access_config)
controller.start()
while not controller.is_finished(app.guid):
time.sleep(0.5)
fake_result = controller.trace(app.guid, "fake")
comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
--- 10.0.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
"""
self.assertTrue(fake_result.startswith(comp_result))
self.assertEquals(controller.get_testbed_id(node1.guid), "mock")
self.assertEquals(controller.get_testbed_version(node1.guid), "0.1")
self.assertEquals(controller.get_factory_id(node1.guid), "Node")
# controller dies
del controller
# recover
access_config.set_attribute_value(DC.RECOVER, True)
controller = proxy.create_experiment_controller(xml, access_config)
# test recovery
self.assertTrue(controller.is_finished(app.guid))
fake_result = controller.trace(app.guid, "fake")
self.assertTrue(fake_result.startswith(comp_result))
controller.stop()
controller.shutdown()
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(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
access_config.set_attribute_value(DC.ROOT_DIRECTORY, self.root_dir)
access_config.set_attribute_value(DC.DEPLOYMENT_ENVIRONMENT_SETUP,
"export PYTHONPATH=%r:%r:$PYTHONPATH "
"export NEPI_TESTBEDS='mock:mock mock2:mock2' " % (
os.path.dirname(os.path.dirname(mock.__file__)),
os.path.dirname(os.path.dirname(mock2.__file__)),))
controller = proxy.create_experiment_controller(xml, access_config)
controller.start()
while not controller.is_finished(app.guid):
time.sleep(0.5)
fake_result = controller.trace(app.guid, "fake")
comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
--- 10.0.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
"""
self.assertTrue(fake_result.startswith(comp_result))
self.assertEquals(controller.get_testbed_id(node1.guid), "mock")
self.assertEquals(controller.get_testbed_version(node1.guid), "0.1")
self.assertEquals(controller.get_factory_id(node1.guid), "Node")
# controller dies
del controller
# recover
access_config.set_attribute_value(DC.RECOVER,True)
controller = proxy.create_experiment_controller(xml, access_config)
# test recovery
self.assertTrue(controller.is_finished(app.guid))
fake_result = controller.trace(app.guid, "fake")
self.assertTrue(fake_result.startswith(comp_result))
controller.stop()
controller.shutdown()
def test_reference_expressions(self):
exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
iface1.set_attribute_value("label", "some")
addr = iface1.add_address()
addr.set_attribute_value("Address", "10.0.0.2")
iface2.set_attribute_value("test", "{#[some].addr[0].[Address]#}")
xml = exp_desc.to_xml()
access_config = None
controller = proxy.create_experiment_controller(xml, access_config)
controller.start()
while not controller.is_finished(app.guid):
time.sleep(0.5)
fake_result = controller.trace(app.guid, "fake")
comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
--- 10.0.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
"""
self.assertTrue(fake_result.startswith(comp_result))
self.assertEqual(
controller._testbeds[desc.guid].get(iface2.guid, "test"),
addr.get_attribute_value("Address") )
controller.stop()
controller.shutdown()
def _run_one_experiment(self):
from nepi.util import proxy
access_config = proxy.AccessConfiguration()
for attr in self._access_config.attributes:
if attr.value:
access_config.set_attribute_value(attr.name, attr.value)
access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
root_dir = "%s_%d" % (
access_config.get_attribute_value(DC.ROOT_DIRECTORY),
self._current)
access_config.set_attribute_value(DC.ROOT_DIRECTORY, root_dir)
controller = proxy.create_experiment_controller(self._experiment_xml,
access_config)
self._access_configs[self._current] = access_config
self._controllers[self._current] = controller
controller.start()
started_at = time.time()
# wait until all specified guids have finished execution
if self._wait_guids:
while all(itertools.imap(controller.is_finished, self._wait_guids)):
time.sleep(0.5)
# wait until the minimum experiment duration time has elapsed
if self._duration:
while (time.time() - started_at) < self._duration:
time.sleep(0.5)
controller.stop()
def test_testbed_reference_expressions(self):
exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
iface1.set_attribute_value("label", "some")
addr = iface1.add_address()
addr.set_attribute_value("Address", "10.0.0.2")
desc2 = exp_desc.add_testbed_description(
FactoriesProvider("mock2") )
desc2.set_attribute_value(DC.DEPLOYMENT_HOST, "{#[some].addr[0].[Address]#}")
# DC.DEPLOYMENT_HOST should be ignored if DC.DEPLOYMENT_CONNECTION is not set
# But it should be resolved anyway
xml = exp_desc.to_xml()
access_config = None
controller = proxy.create_experiment_controller(xml, access_config)
controller.start()
while not controller.is_finished(app.guid):
time.sleep(0.5)
fake_result = controller.trace(app.guid, "fake")
comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
--- 10.0.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
"""
self.assertTrue(fake_result.startswith(comp_result))
self.assertEqual(
controller._deployment_config[desc2.guid]
.get_attribute_value(DC.DEPLOYMENT_HOST),
addr.get_attribute_value("Address") )
controller.stop()
controller.shutdown()
def _run_one_experiment(self):
from nepi.util import proxy
access_config = proxy.AccessConfiguration()
for attr in self._access_config.attributes:
if attr.value:
access_config.set_attribute_value(attr.name, attr.value)
access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
root_dir = "%s_%d" % (access_config.get_attribute_value(
DC.ROOT_DIRECTORY), self._current)
access_config.set_attribute_value(DC.ROOT_DIRECTORY, root_dir)
controller = proxy.create_experiment_controller(
self._experiment_xml, access_config)
self._access_configs[self._current] = access_config
self._controllers[self._current] = controller
controller.start()
started_at = time.time()
# wait until all specified guids have finished execution
if self._wait_guids:
while all(itertools.imap(controller.is_finished,
self._wait_guids)):
time.sleep(0.5)
# wait until the minimum experiment duration time has elapsed
if self._duration:
while (time.time() - started_at) < self._duration:
time.sleep(0.5)
controller.stop()
def test_single_process_integration(self):
exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment()
xml = exp_desc.to_xml()
access_config = None
controller = proxy.create_experiment_controller(xml, access_config)
controller.start()
started_time = controller.started_time
self.assertTrue(started_time < time.time())
while not controller.is_finished(app.guid):
time.sleep(0.5)
fake_result = controller.trace(app.guid, "fake")
comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
--- 10.0.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
"""
self.assertTrue(fake_result.startswith(comp_result))
self.assertEquals(controller.get_testbed_id(node1.guid), "mock")
self.assertEquals(controller.get_testbed_version(node1.guid), "0.1")
self.assertEquals(controller.get_factory_id(node1.guid), "Node")
controller.stop()
stopped_time = controller.stopped_time
self.assertTrue(stopped_time < time.time())
controller.shutdown()
def test_single_process_integration(self):
exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment(
)
xml = exp_desc.to_xml()
access_config = None
controller = proxy.create_experiment_controller(xml, access_config)
controller.start()
started_time = controller.started_time
self.assertTrue(started_time < time.time())
while not controller.is_finished(app.guid):
time.sleep(0.5)
fake_result = controller.trace(app.guid, "fake")
comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
--- 10.0.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
"""
self.assertTrue(fake_result.startswith(comp_result))
self.assertEquals(controller.get_testbed_id(node1.guid), "mock")
self.assertEquals(controller.get_testbed_version(node1.guid), "0.1")
self.assertEquals(controller.get_factory_id(node1.guid), "Node")
controller.stop()
stopped_time = controller.stopped_time
self.assertTrue(stopped_time < time.time())
controller.shutdown()
def test_testbed_reference_expressions(self):
exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment(
)
iface1.set_attribute_value("label", "some")
addr = iface1.add_address()
addr.set_attribute_value("Address", "10.0.0.2")
desc2 = exp_desc.add_testbed_description(FactoriesProvider("mock2"))
desc2.set_attribute_value(DC.DEPLOYMENT_HOST,
"{#[some].addr[0].[Address]#}")
# DC.DEPLOYMENT_HOST should be ignored if DC.DEPLOYMENT_CONNECTION is not set
# But it should be resolved anyway
xml = exp_desc.to_xml()
access_config = None
controller = proxy.create_experiment_controller(xml, access_config)
controller.start()
while not controller.is_finished(app.guid):
time.sleep(0.5)
fake_result = controller.trace(app.guid, "fake")
comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
--- 10.0.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
"""
self.assertTrue(fake_result.startswith(comp_result))
self.assertEqual(
controller._deployment_config[desc2.guid].get_attribute_value(
DC.DEPLOYMENT_HOST), addr.get_attribute_value("Address"))
controller.stop()
controller.shutdown()
def test_reference_expressions(self):
exp_desc, desc, app, node1, node2, iface1, iface2 = self.make_test_experiment(
)
iface1.set_attribute_value("label", "some")
addr = iface1.add_address()
addr.set_attribute_value("Address", "10.0.0.2")
iface2.set_attribute_value("test", "{#[some].addr[0].[Address]#}")
xml = exp_desc.to_xml()
access_config = None
controller = proxy.create_experiment_controller(xml, access_config)
controller.start()
while not controller.is_finished(app.guid):
time.sleep(0.5)
fake_result = controller.trace(app.guid, "fake")
comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
--- 10.0.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
"""
self.assertTrue(fake_result.startswith(comp_result))
self.assertEqual(
controller._testbeds[desc.guid].get(iface2.guid, "test"),
addr.get_attribute_value("Address"))
controller.stop()
controller.shutdown()
def _test_switched(self, controller_access_config = None,
testbed_access_config = None):
testbed_id = "netns"
exp_desc = ExperimentDescription()
user = getpass.getuser()
netns_provider = FactoriesProvider(testbed_id)
netns_desc = exp_desc.add_testbed_description(netns_provider)
netns_desc.set_attribute_value("homeDirectory", self.root_dir)
#netns_desc.set_attribute_value("enableDebug", True)
node1 = netns_desc.create("Node")
node2 = netns_desc.create("Node")
iface1 = netns_desc.create("NodeInterface")
iface1.set_attribute_value("up", True)
node1.connector("devs").connect(iface1.connector("node"))
ip1 = iface1.add_address()
ip1.set_attribute_value("Address", "10.0.0.1")
iface2 = netns_desc.create("NodeInterface")
iface2.set_attribute_value("up", True)
node2.connector("devs").connect(iface2.connector("node"))
ip2 = iface2.add_address()
ip2.set_attribute_value("Address", "10.0.0.2")
switch = netns_desc.create("Switch")
switch.set_attribute_value("up", True)
iface1.connector("switch").connect(switch.connector("devs"))
iface2.connector("switch").connect(switch.connector("devs"))
app = netns_desc.create("Application")
app.set_attribute_value("command", "ping -qc1 10.0.0.2")
app.set_attribute_value("user", user)
app.connector("node").connect(node1.connector("apps"))
app.enable_trace("stdout")
if testbed_access_config:
for attr in testbed_access_config.attributes:
if attr.value:
netns_desc.set_attribute_value(attr.name, attr.value)
xml = exp_desc.to_xml()
controller = proxy.create_experiment_controller(xml,
controller_access_config)
try:
controller.start()
while not controller.is_finished(app.guid):
time.sleep(0.5)
ping_result = controller.trace(app.guid, "stdout")
comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
--- 10.0.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
"""
self.assertTrue(ping_result.startswith(comp_result))
finally:
controller.stop()
controller.shutdown()
def test_single_process_cross_integration(self):
exp_desc, desc1, desc2, iface12, iface21 = \
self.make_cross_test_experiment()
xml = exp_desc.to_xml()
access_config = None
controller = proxy.create_experiment_controller(xml, access_config)
controller.start()
cross1 = controller.get(iface12.guid, "cross")
cross2 = controller.get(iface21.guid, "cross")
self.assertTrue(cross1 == cross2 == True)
controller.stop()
controller.shutdown()
def test_single_process_cross_integration(self):
exp_desc, desc1, desc2, iface12, iface21 = \
self.make_cross_test_experiment()
xml = exp_desc.to_xml()
access_config = None
controller = proxy.create_experiment_controller(xml, access_config)
controller.start()
cross1 = controller.get(iface12.guid, "cross")
cross2 = controller.get(iface21.guid, "cross")
self.assertTrue(cross1 == cross2 == True)
controller.stop()
controller.shutdown()
def ptest_experiment_suite(self):
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(DC.LOG_LEVEL, DC.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.DEPLOYMENT_ENVIRONMENT_SETUP,
"export PYTHONPATH=%r:%r:$PYTHONPATH "
"export NEPI_TESTBEDS='mock:mock mock2:mock2' " % (
os.path.dirname(os.path.dirname(mock.__file__)),
os.path.dirname(os.path.dirname(mock2.__file__)),
))
print self.root_dir
exp_suite = proxy.create_experiment_suite(xml,
access_config,
repetitions=4)
exp_suite.start()
while not exp_suite.is_finished():
time.sleep(0.5)
for access_config in exp_suite.get_access_configurations():
access_config.set_attribute_value(DC.RECOVER, True)
controller = proxy.create_experiment_controller(
None, access_config)
fake_result = controller.trace(app.guid, "fake")
comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
--- 10.0.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
"""
self.assertTrue(fake_result.startswith(comp_result))
self.assertEquals(controller.get_testbed_id(node1.guid), "mock")
self.assertEquals(controller.get_testbed_version(node1.guid),
"0.1")
self.assertEquals(controller.get_factory_id(node1.guid), "Node")
exp_suite.shutdown()
def test_ssh_daemonized_integration(self):
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)
xml = exp_desc.to_xml()
access_config = proxy.AccessConfiguration()
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)
access_config.set_attribute_value(
DC.DEPLOYMENT_ENVIRONMENT_SETUP,
"export PYTHONPATH=%r:%r:$PYTHONPATH "
"export NEPI_TESTBEDS='mock:mock mock2:mock2' " % (
os.path.dirname(os.path.dirname(mock.__file__)),
os.path.dirname(os.path.dirname(mock2.__file__)),
))
controller = proxy.create_experiment_controller(xml, access_config)
try:
controller.start()
while not controller.is_finished(app.guid):
time.sleep(0.5)
fake_result = controller.trace(app.guid, "fake")
comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
--- 10.0.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
"""
self.assertTrue(fake_result.startswith(comp_result))
finally:
controller.stop()
controller.shutdown()
def ptest_experiment_suite(self):
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(DC.LOG_LEVEL, DC.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.DEPLOYMENT_ENVIRONMENT_SETUP,
"export PYTHONPATH=%r:%r:$PYTHONPATH "
"export NEPI_TESTBEDS='mock:mock mock2:mock2' " % (
os.path.dirname(os.path.dirname(mock.__file__)),
os.path.dirname(os.path.dirname(mock2.__file__)),))
print self.root_dir
exp_suite = proxy.create_experiment_suite(xml, access_config, repetitions = 4)
exp_suite.start()
while not exp_suite.is_finished():
time.sleep(0.5)
for access_config in exp_suite.get_access_configurations():
access_config.set_attribute_value(DC.RECOVER, True)
controller = proxy.create_experiment_controller(None, access_config)
fake_result = controller.trace(app.guid, "fake")
comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
--- 10.0.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
"""
self.assertTrue(fake_result.startswith(comp_result))
self.assertEquals(controller.get_testbed_id(node1.guid), "mock")
self.assertEquals(controller.get_testbed_version(node1.guid), "0.1")
self.assertEquals(controller.get_factory_id(node1.guid), "Node")
exp_suite.shutdown()
def test_ssh_daemonized_integration(self):
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)
xml = exp_desc.to_xml()
access_config = proxy.AccessConfiguration()
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)
access_config.set_attribute_value(DC.DEPLOYMENT_ENVIRONMENT_SETUP,
"export PYTHONPATH=%r:%r:$PYTHONPATH "
"export NEPI_TESTBEDS='mock:mock mock2:mock2' " % (
os.path.dirname(os.path.dirname(mock.__file__)),
os.path.dirname(os.path.dirname(mock2.__file__)),))
controller = proxy.create_experiment_controller(xml, access_config)
try:
controller.start()
while not controller.is_finished(app.guid):
time.sleep(0.5)
fake_result = controller.trace(app.guid, "fake")
comp_result = """PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
--- 10.0.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
"""
self.assertTrue(fake_result.startswith(comp_result))
finally:
controller.stop()
controller.shutdown()
def _test_recover(self, daemonize_testbed, controller_access_configuration, environ=None, use_sfa=False):
pl, exp = self.make_experiment_desc(use_sfa)
pl.set_attribute_value(DC.RECOVERY_POLICY, DC.POLICY_RECOVER)
node1 = pl.create("Node")
node2 = pl.create("Node")
node1.set_attribute_value("hostname", self.host1)
node2.set_attribute_value("hostname", self.host2)
iface1 = pl.create("NodeInterface")
iface2 = pl.create("NodeInterface")
inet = pl.create("Internet")
node1.connector("devs").connect(iface1.connector("node"))
node2.connector("devs").connect(iface2.connector("node"))
iface1.connector("inet").connect(inet.connector("devs"))
iface2.connector("inet").connect(inet.connector("devs"))
tap1 = pl.create("TapInterface")
tap2 = pl.create("TapInterface")
node1.connector("devs").connect(tap1.connector("node"))
node2.connector("devs").connect(tap2.connector("node"))
tap1.connector("udp").connect(tap2.connector("udp"))
tap1ip = tap1.add_address()
tap1ip.set_attribute_value("Address", "192.168.2.2")
tap1ip.set_attribute_value("NetPrefix", 24)
tap1ip.set_attribute_value("Broadcast", False)
tap2ip = tap2.add_address()
tap2ip.set_attribute_value("Address", "192.168.2.3")
tap2ip.set_attribute_value("NetPrefix", 24)
tap2ip.set_attribute_value("Broadcast", False)
app = pl.create("Application")
app.set_attribute_value("command", "ping -qc10 192.168.2.3")
app.enable_trace("stdout")
app.connector("node").connect(node1.connector("apps"))
if daemonize_testbed:
pl.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
inst_root_dir = os.path.join(self.root_dir, "instance")
os.mkdir(inst_root_dir)
pl.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir)
pl.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL)
if environ:
pl.set_attribute_value(DC.DEPLOYMENT_ENVIRONMENT_SETUP, environ)
xml = exp.to_xml()
if controller_access_configuration:
controller = proxy.create_experiment_controller(xml, controller_access_configuration)
else:
controller = ExperimentController(xml, self.root_dir)
try:
controller.start()
# purposedly break connection
controller = None
# recover
if controller_access_configuration:
controller_access_configuration.set_attribute_value(DC.RECOVER, True)
controller = proxy.create_experiment_controller(None, controller_access_configuration)
else:
controller = ExperimentController(None, self.root_dir)
controller.recover()
while not controller.is_finished(app.guid):
time.sleep(0.5)
ping_result = controller.trace(app.guid, "stdout")
comp_result = r"""PING .* \(.*\) \d*\(\d*\) bytes of data.
--- .* ping statistics ---
10 packets transmitted, 10 received, 0% packet loss, time \d*ms.*
"""
self.assertTrue(re.match(comp_result, ping_result, re.MULTILINE), "Unexpected trace:\n" + ping_result)
finally:
if controller is not None:
try:
controller.stop()
except:
import traceback
traceback.print_exc()
try:
controller.shutdown()
except:
import traceback
traceback.print_exc()
def _test_if(self, daemonize_testbed, controller_access_configuration):
exp_desc = ExperimentDescription()
testbed_id = "ns3"
ns3_provider = FactoriesProvider(testbed_id)
ns3_desc = exp_desc.add_testbed_description(ns3_provider)
ns3_desc.set_attribute_value("homeDirectory", self.root_dir)
node1 = ns3_desc.create("ns3::Node")
ipv41 = ns3_desc.create("ns3::Ipv4L3Protocol")
arp1 = ns3_desc.create("ns3::ArpL3Protocol")
icmp1 = ns3_desc.create("ns3::Icmpv4L4Protocol")
node1.connector("protos").connect(ipv41.connector("node"))
node1.connector("protos").connect(arp1.connector("node"))
node1.connector("protos").connect(icmp1.connector("node"))
iface1 = ns3_desc.create("ns3::PointToPointNetDevice")
queue1 = ns3_desc.create("ns3::DropTailQueue")
node1.connector("devs").connect(iface1.connector("node"))
iface1.connector("queue").connect(queue1.connector("dev"))
trace1 = iface1.enable_trace("P2PAsciiTrace")
ip1 = iface1.add_address()
ip1.set_attribute_value("Address", "10.0.0.1")
node2 = ns3_desc.create("ns3::Node")
ipv42 = ns3_desc.create("ns3::Ipv4L3Protocol")
arp2 = ns3_desc.create("ns3::ArpL3Protocol")
icmp2 = ns3_desc.create("ns3::Icmpv4L4Protocol")
node2.connector("protos").connect(ipv42.connector("node"))
node2.connector("protos").connect(arp2.connector("node"))
node2.connector("protos").connect(icmp2.connector("node"))
iface2 = ns3_desc.create("ns3::PointToPointNetDevice")
queue2 = ns3_desc.create("ns3::DropTailQueue")
node2.connector("devs").connect(iface2.connector("node"))
iface2.connector("queue").connect(queue2.connector("dev"))
trace2 = iface2.enable_trace("P2PAsciiTrace")
ip2 = iface2.add_address()
ip2.set_attribute_value("Address", "10.0.0.2")
chan = ns3_desc.create("ns3::PointToPointChannel")
iface1.connector("chan").connect(chan.connector("dev2"))
iface2.connector("chan").connect(chan.connector("dev2"))
app = ns3_desc.create("ns3::V4Ping")
app.set_attribute_value("Remote", "10.0.0.2")
app.set_attribute_value("StartTime", "0s")
app.set_attribute_value("StopTime", "20s")
app.connector("node").connect(node1.connector("apps"))
if daemonize_testbed:
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()
if controller_access_configuration:
controller = ExperimentController(xml, self.root_dir)
else:
controller = proxy.create_experiment_controller(xml,
controller_access_configuration)
try:
controller.start()
while not controller.is_finished(app.guid):
time.sleep(0.5)
ping_result = controller.trace(iface2.guid, "P2PAsciiTrace")
comp_result = "- 19.021 /NodeList/1/DeviceList/0/$ns3::PointToPointNetDevice/TxQueue/Dequeue ns3::PppHeader (Point-to-Point Protocol: IP (0x0021)) ns3::Ipv4Header (tos 0x0 DSCP Default ECN Not-ECT ttl 64 id 19 protocol 1 offset (bytes) 0 flags [none] length: 84 10.0.0.2 > 10.0.0.1) ns3::Icmpv4Header (type=0, code=0) ns3::Icmpv4Echo (identifier=0, sequence=19)"
if ping_result.find(comp_result) == -1:
self.fail("Unexpected trace: %s" % (ping_result,))
finally:
controller.stop()
controller.shutdown()
def _test_simple(self,
daemonize_testbed,
controller_access_configuration,
environ=None,
use_sfa=False):
pl, exp = self.make_experiment_desc(use_sfa)
node1 = pl.create("Node")
node2 = pl.create("Node")
node1.set_attribute_value("hostname", self.host1)
node2.set_attribute_value("hostname", self.host2)
iface1 = pl.create("NodeInterface")
iface2 = pl.create("NodeInterface")
iface2.set_attribute_value("label", "node2iface")
inet = pl.create("Internet")
node1.connector("devs").connect(iface1.connector("node"))
node2.connector("devs").connect(iface2.connector("node"))
iface1.connector("inet").connect(inet.connector("devs"))
iface2.connector("inet").connect(inet.connector("devs"))
app = pl.create("Application")
app.set_attribute_value(
"command", "ping -qc1 {#[node2iface].addr[0].[Address]#}")
app.enable_trace("stdout")
app.connector("node").connect(node1.connector("apps"))
if daemonize_testbed:
pl.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
inst_root_dir = os.path.join(self.root_dir, "instance")
os.mkdir(inst_root_dir)
pl.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir)
pl.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL)
if environ:
pl.set_attribute_value(DC.DEPLOYMENT_ENVIRONMENT_SETUP,
environ)
xml = exp.to_xml()
if controller_access_configuration:
controller = proxy.create_experiment_controller(
xml, controller_access_configuration)
else:
controller = ExperimentController(xml, self.root_dir)
try:
controller.start()
while not controller.is_finished(app.guid):
time.sleep(0.5)
ping_result = controller.trace(app.guid, "stdout")
comp_result = r"""PING .* \(.*\) \d*\(\d*\) bytes of data.
--- .* ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time \d*ms.*
"""
self.assertTrue(re.match(comp_result, ping_result, re.MULTILINE),
"Unexpected trace:\n" + ping_result)
finally:
try:
controller.stop()
except:
import traceback
traceback.print_exc()
try:
controller.shutdown()
except:
import traceback
traceback.print_exc()
def _test_fd_net_device(self, daemonize_testbed,
controller_access_configuration):
testbed_id = "ns3"
exp_desc = ExperimentDescription()
ns3_provider = FactoriesProvider(testbed_id)
ns3_desc1 = exp_desc.add_testbed_description(ns3_provider)
root_dir1 = os.path.join(self.root_dir, "1")
ns3_desc1.set_attribute_value("homeDirectory", root_dir1)
ns3_desc1.set_attribute_value("SimulatorImplementationType",
"ns3::RealtimeSimulatorImpl")
ns3_desc1.set_attribute_value("ChecksumEnabled", True)
ns3_desc2 = exp_desc.add_testbed_description(ns3_provider)
root_dir2 = os.path.join(self.root_dir, "2")
ns3_desc2.set_attribute_value("homeDirectory", root_dir2)
ns3_desc2.set_attribute_value("SimulatorImplementationType",
"ns3::RealtimeSimulatorImpl")
ns3_desc2.set_attribute_value("ChecksumEnabled", True)
node1 = ns3_desc1.create("ns3::Node")
ipv41 = ns3_desc1.create("ns3::Ipv4L3Protocol")
arp1 = ns3_desc1.create("ns3::ArpL3Protocol")
icmp1 = ns3_desc1.create("ns3::Icmpv4L4Protocol")
node1.connector("protos").connect(ipv41.connector("node"))
node1.connector("protos").connect(arp1.connector("node"))
node1.connector("protos").connect(icmp1.connector("node"))
iface1 = ns3_desc1.create("ns3::FdNetDevice")
node1.connector("devs").connect(iface1.connector("node"))
ip1 = iface1.add_address()
ip1.set_attribute_value("Address", "10.0.0.1")
tc1 = ns3_desc1.create("ns3::Nepi::TunChannel")
tc1.connector("fd->").connect(iface1.connector("->fd"))
node2 = ns3_desc2.create("ns3::Node")
ipv42 = ns3_desc2.create("ns3::Ipv4L3Protocol")
arp2 = ns3_desc2.create("ns3::ArpL3Protocol")
icmp2 = ns3_desc2.create("ns3::Icmpv4L4Protocol")
node2.connector("protos").connect(ipv42.connector("node"))
node2.connector("protos").connect(arp2.connector("node"))
node2.connector("protos").connect(icmp2.connector("node"))
iface2 = ns3_desc2.create("ns3::FdNetDevice")
iface2.enable_trace("FdAsciiTrace")
node2.connector("devs").connect(iface2.connector("node"))
ip2 = iface2.add_address()
ip2.set_attribute_value("Address", "10.0.0.2")
tc2 = ns3_desc2.create("ns3::Nepi::TunChannel")
tc2.connector("fd->").connect(iface2.connector("->fd"))
tc2.connector("udp").connect(tc1.connector("udp"))
app = ns3_desc1.create("ns3::V4Ping")
app.set_attribute_value("Remote", "10.0.0.2")
app.set_attribute_value("StartTime", "0s")
app.set_attribute_value("StopTime", "2s")
app.connector("node").connect(node1.connector("apps"))
if daemonize_testbed:
ns3_desc1.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
inst_root_dir = os.path.join(root_dir1, "instance")
os.makedirs(inst_root_dir)
ns3_desc1.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir)
#ns3_desc1.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL)
ns3_desc2.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
inst_root_dir = os.path.join(root_dir2, "instance")
os.makedirs(inst_root_dir)
ns3_desc2.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir)
#ns3_desc2.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL)
xml = exp_desc.to_xml()
if controller_access_configuration:
controller = ExperimentController(xml, self.root_dir)
else:
controller = proxy.create_experiment_controller(xml,
controller_access_configuration)
try:
controller.start()
while not controller.is_finished(app.guid):
time.sleep(0.5)
ping_result = controller.trace(iface2.guid, "FdAsciiTrace")
ping_exp_result = r"""r [-+0-9.e]+ /NodeList/0/DeviceList/0/\$ns3::FdNetDevice/Rx Payload \(size=42\)
r [-+0-9.e]+ /NodeList/0/DeviceList/0/\$ns3::FdNetDevice/Rx Payload \(size=98\)
r [-+0-9.e]+ /NodeList/0/DeviceList/0/\$ns3::FdNetDevice/Rx Payload \(size=42\)
r [-+0-9.e]+ /NodeList/0/DeviceList/0/\$ns3::FdNetDevice/Rx Payload \(size=98\)
"""
if not re.match(ping_exp_result, ping_result):
self.fail("Unexpected trace: %s" % (ping_result,))
finally:
controller.stop()
controller.shutdown()
def _test_simple(self, daemonize_testbed, controller_access_configuration, environ=None, use_sfa=False):
pl, exp = self.make_experiment_desc(use_sfa)
node1 = pl.create("Node")
node2 = pl.create("Node")
node1.set_attribute_value("hostname", self.host1)
node2.set_attribute_value("hostname", self.host2)
iface1 = pl.create("NodeInterface")
iface2 = pl.create("NodeInterface")
iface2.set_attribute_value("label", "node2iface")
inet = pl.create("Internet")
node1.connector("devs").connect(iface1.connector("node"))
node2.connector("devs").connect(iface2.connector("node"))
iface1.connector("inet").connect(inet.connector("devs"))
iface2.connector("inet").connect(inet.connector("devs"))
app = pl.create("Application")
app.set_attribute_value("command", "ping -qc1 {#[node2iface].addr[0].[Address]#}")
app.enable_trace("stdout")
app.connector("node").connect(node1.connector("apps"))
if daemonize_testbed:
pl.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
inst_root_dir = os.path.join(self.root_dir, "instance")
os.mkdir(inst_root_dir)
pl.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir)
pl.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL)
if environ:
pl.set_attribute_value(DC.DEPLOYMENT_ENVIRONMENT_SETUP, environ)
xml = exp.to_xml()
if controller_access_configuration:
controller = proxy.create_experiment_controller(xml, controller_access_configuration)
else:
controller = ExperimentController(xml, self.root_dir)
try:
controller.start()
while not controller.is_finished(app.guid):
time.sleep(0.5)
ping_result = controller.trace(app.guid, "stdout")
comp_result = r"""PING .* \(.*\) \d*\(\d*\) bytes of data.
--- .* ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time \d*ms.*
"""
self.assertTrue(re.match(comp_result, ping_result, re.MULTILINE), "Unexpected trace:\n" + ping_result)
finally:
try:
controller.stop()
except:
import traceback
traceback.print_exc()
try:
controller.shutdown()
except:
import traceback
traceback.print_exc()
def _test_recover(self,
daemonize_testbed,
controller_access_configuration,
environ=None,
use_sfa=False):
pl, exp = self.make_experiment_desc(use_sfa)
pl.set_attribute_value(DC.RECOVERY_POLICY, DC.POLICY_RECOVER)
node1 = pl.create("Node")
node2 = pl.create("Node")
node1.set_attribute_value("hostname", self.host1)
node2.set_attribute_value("hostname", self.host2)
iface1 = pl.create("NodeInterface")
iface2 = pl.create("NodeInterface")
inet = pl.create("Internet")
node1.connector("devs").connect(iface1.connector("node"))
node2.connector("devs").connect(iface2.connector("node"))
iface1.connector("inet").connect(inet.connector("devs"))
iface2.connector("inet").connect(inet.connector("devs"))
tap1 = pl.create("TapInterface")
tap2 = pl.create("TapInterface")
node1.connector("devs").connect(tap1.connector("node"))
node2.connector("devs").connect(tap2.connector("node"))
tap1.connector("udp").connect(tap2.connector("udp"))
tap1ip = tap1.add_address()
tap1ip.set_attribute_value("Address", "192.168.2.2")
tap1ip.set_attribute_value("NetPrefix", 24)
tap1ip.set_attribute_value("Broadcast", False)
tap2ip = tap2.add_address()
tap2ip.set_attribute_value("Address", "192.168.2.3")
tap2ip.set_attribute_value("NetPrefix", 24)
tap2ip.set_attribute_value("Broadcast", False)
app = pl.create("Application")
app.set_attribute_value("command", "ping -qc10 192.168.2.3")
app.enable_trace("stdout")
app.connector("node").connect(node1.connector("apps"))
if daemonize_testbed:
pl.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
inst_root_dir = os.path.join(self.root_dir, "instance")
os.mkdir(inst_root_dir)
pl.set_attribute_value(DC.ROOT_DIRECTORY, inst_root_dir)
pl.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL)
if environ:
pl.set_attribute_value(DC.DEPLOYMENT_ENVIRONMENT_SETUP,
environ)
xml = exp.to_xml()
if controller_access_configuration:
controller = proxy.create_experiment_controller(
xml, controller_access_configuration)
else:
controller = ExperimentController(xml, self.root_dir)
try:
controller.start()
# purposedly break connection
controller = None
# recover
if controller_access_configuration:
controller_access_configuration.set_attribute_value(
DC.RECOVER, True)
controller = proxy.create_experiment_controller(
None, controller_access_configuration)
else:
controller = ExperimentController(None, self.root_dir)
controller.recover()
while not controller.is_finished(app.guid):
time.sleep(0.5)
ping_result = controller.trace(app.guid, "stdout")
comp_result = r"""PING .* \(.*\) \d*\(\d*\) bytes of data.
--- .* ping statistics ---
10 packets transmitted, 10 received, 0% packet loss, time \d*ms.*
"""
self.assertTrue(re.match(comp_result, ping_result, re.MULTILINE),
"Unexpected trace:\n" + ping_result)
finally:
if controller is not None:
try:
controller.stop()
except:
import traceback
traceback.print_exc()
try:
controller.shutdown()
except:
import traceback
traceback.print_exc()
ip21.set_attribute_value("Address", "192.168.0.2")
ip21.set_attribute_value("NetPrefix", 30)
app1 = netns_desc.create("Application")
app1.set_attribute_value("command", "ping -qc 10 192.168.0.1")
app1.set_attribute_value("user", user)
app1.connector("node").connect(node1.connector("apps"))
app1.enable_trace("stdout")
xml = exp_desc.to_xml()
controller_access_config = proxy.AccessConfiguration()
controller_access_config.set_attribute_value(DC.DEPLOYMENT_MODE,
DC.MODE_DAEMON)
controller_access_config.set_attribute_value(DC.ROOT_DIRECTORY, root_dir)
controller_access_config.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL)
controller = proxy.create_experiment_controller(xml, controller_access_config)
controller.start()
while not controller.is_finished(app1.guid):
time.sleep(0.5)
result = controller.trace(app1.guid, "stdout")
controller.stop()
controller.shutdown()
print result
ip21.set_attribute_value("Address", "192.168.0.2")
ip21.set_attribute_value("NetPrefix", 30)
app1 = netns_desc.create("Application")
app1.set_attribute_value("command", "ping -qc 10 192.168.0.1")
app1.set_attribute_value("user", user)
app1.connector("node").connect(node1.connector("apps"))
app1.enable_trace("stdout")
xml = exp_desc.to_xml()
controller_access_config = proxy.AccessConfiguration()
controller_access_config.set_attribute_value(DC.DEPLOYMENT_MODE, DC.MODE_DAEMON)
controller_access_config.set_attribute_value(DC.ROOT_DIRECTORY, root_dir)
controller_access_config.set_attribute_value(DC.LOG_LEVEL, DC.DEBUG_LEVEL)
controller = proxy.create_experiment_controller(xml, controller_access_config)
controller.start()
while not controller.is_finished(app1.guid):
time.sleep(0.5)
result = controller.trace(app1.guid, "stdout")
controller.stop()
controller.shutdown()
print result
