def t_tofile(self, host, user):
ec = ExperimentController(exp_id = "test-to-file")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
pcap = ec.register_resource("linux::Tcpdump")
ec.set(pcap, "i", "eth0")
ec.set(pcap, "w", "custom_output")
ec.register_connection(pcap, node)
app = ec.register_resource("linux::Ping")
ec.set(app, "count", "20")
ec.set(app, "target", self.target)
ec.register_connection(app, node)
ec.deploy()
ec.wait_finished(app)
output = ec.trace(pcap, "custom_output")
self.assertTrue(len(output) > 0)
ec.shutdown()
def t_nping(self, host, user):
ec = ExperimentController(exp_id = "test-nping")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
app = ec.register_resource("linux::NPing")
ec.set(app, "c", 1)
ec.set(app, "tcp", True)
ec.set(app, "p", 80)
ec.set(app, "target", self.target)
ec.register_connection(app, node)
ec.deploy()
ec.wait_finished(app)
stdout = ec.trace(app, "stdout")
self.assertTrue(stdout.find("1 IP address pinged in") > -1)
ec.shutdown()
def t_rtt(self, user1, host1, user2, host2):
ec = ExperimentController(exp_id = "test-udptest-rtt")
node1 = ec.register_resource("linux::Node")
ec.set(node1, "hostname", host1)
ec.set(node1, "username", user1)
ec.set(node1, "cleanExperiment", True)
ec.set(node1, "cleanProcesses", True)
server = ec.register_resource("linux::UdpTest")
ec.set(server, "s", True)
ec.register_connection(server, node1)
node2 = ec.register_resource("linux::Node")
ec.set(node2, "hostname", host2)
ec.set(node2, "username", user2)
ec.set(node2, "cleanExperiment", True)
ec.set(node2, "cleanProcesses", True)
client = ec.register_resource("linux::UdpTest")
ec.set(client, "a", True)
ec.set(client, "target", host1)
ec.register_connection(client, node2)
ec.deploy()
ec.wait_finished(client)
stdout = ec.trace(client, "stderr")
self.assertTrue(stdout.find("10 trials with message size 64 Bytes.") > -1)
ec.shutdown()
def test_stop_with_condition(self):
from nepi.execution.resource import ResourceFactory
ResourceFactory.register_type(Application)
ResourceFactory.register_type(Node)
ResourceFactory.register_type(Interface)
ec = ExperimentController()
node = ec.register_resource("Node")
app1 = ec.register_resource("Application")
ec.register_connection(app1, node)
app2 = ec.register_resource("Application")
ec.register_connection(app2, node)
ec.register_condition(app2, ResourceAction.START, app1,
ResourceState.STOPPED)
ec.deploy()
ec.wait_finished([app1, app2])
rmapp1 = ec.get_resource(app1)
rmapp2 = ec.get_resource(app2)
self.assertTrue(rmapp2.start_time > rmapp1.stop_time)
ec.shutdown()
def t_stdout(self, host, user):
ec = ExperimentController(exp_id = "test-stdout")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
app = ec.register_resource("linux::Application")
cmd = "echo 'HOLA'"
ec.set(app, "command", cmd)
ec.register_connection(app, node)
ec.deploy()
ec.wait_finished(app)
self.assertTrue(ec.state(node) == ResourceState.STARTED)
self.assertTrue(ec.state(app) == ResourceState.STOPPED)
stdout = ec.trace(app, "stdout")
self.assertTrue(stdout.strip() == "HOLA")
ec.shutdown()
def t_tun_create(self, host, user, identity):
ec = ExperimentController(exp_id="test-un-create")
node = ec.register_resource("planetlab::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
tun = ec.register_resource("planetlab::Tun")
ec.set(tun, "ip", "%s.1" % self.netblock)
ec.set(tun, "prefix", "24")
ec.register_connection(tun, node)
app = ec.register_resource("linux::Application")
cmd = "ping -c3 %s.1" % self.netblock
ec.set(app, "command", cmd)
ec.register_connection(app, node)
ec.deploy()
ec.wait_finished(app)
ping = ec.trace(app, "stdout")
expected = """3 packets transmitted, 3 received, 0% packet loss"""
self.assertTrue(ping.find(expected) > -1)
if_name = ec.get(tun, "deviceName")
self.assertTrue(if_name.startswith("tun"))
ec.shutdown()
def test_concurrency(self):
from nepi.execution.resource import ResourceFactory
ResourceFactory.register_type(Application)
ResourceFactory.register_type(Node)
ResourceFactory.register_type(Interface)
ResourceFactory.register_type(Channel)
ec = ExperimentController()
node = ec.register_resource("Node")
apps = list()
for i in xrange(1000):
app = ec.register_resource("Application")
ec.register_connection(app, node)
apps.append(app)
ec.deploy()
ec.wait_finished(apps)
self.assertTrue(ec.state(node) == ResourceState.STARTED)
self.assertTrue(
all([ec.state(guid) == ResourceState.STOPPED \
for guid in apps])
)
ec.shutdown()
def t_deploy(self, host, user):
from nepi.execution.resource import ResourceFactory
ResourceFactory.register_type(LinuxNode)
ResourceFactory.register_type(LinuxInterface)
ResourceFactory.register_type(LinuxChannel)
ec = ExperimentController()
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
iface = ec.register_resource("linux::Interface")
chan = ec.register_resource("linux::Channel")
ec.register_connection(iface, node)
ec.register_connection(iface, chan)
ec.deploy()
while not all([ ec.state(guid) == ResourceState.STARTED \
for guid in [node, iface]]):
time.sleep(0.5)
self.assertTrue(ec.state(node) == ResourceState.STARTED)
self.assertTrue(ec.state(iface) == ResourceState.STARTED)
self.assertTrue(ec.get(iface, "deviceName") == "eth0")
ec.shutdown()
def t_dce_ccnpeek_with_stack(self, host, user = None, identity = None):
ec = ExperimentController(exp_id = "test-dce-peek-lostack")
node = ec.register_resource("linux::Node")
if host == "localhost":
ec.set(node, "hostname", host)
else:
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanHome", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.register_connection(simu, node)
nsnode = ec.register_resource("ns3::Node")
ec.set(nsnode, "enableStack", True)
ec.register_connection(nsnode, simu)
### create applications
ccnd = ec.register_resource("linux::ns3::dce::CCND")
ec.set (ccnd, "stackSize", 1<<20)
ec.set (ccnd, "StartTime", "1s")
ec.register_connection(ccnd, nsnode)
ccnpoke = ec.register_resource("linux::ns3::dce::CCNPoke")
ec.set (ccnpoke, "contentName", "ccnx:/chunk0")
ec.set (ccnpoke, "content", "DATA")
ec.set (ccnpoke, "stackSize", 1<<20)
ec.set (ccnpoke, "StartTime", "2s")
ec.register_connection(ccnpoke, nsnode)
ccnpeek = ec.register_resource("linux::ns3::dce::CCNPeek")
ec.set (ccnpeek, "contentName", "ccnx:/chunk0")
ec.set (ccnpeek, "stackSize", 1<<20)
ec.set (ccnpeek, "StartTime", "4s")
ec.set (ccnpeek, "StopTime", "20s")
ec.register_connection(ccnpeek, nsnode)
ec.deploy()
ec.wait_finished([ccnpeek])
expected = "ccnpeek ccnx:/chunk0"
cmdline = ec.trace(ccnpeek, "cmdline")
self.assertTrue(cmdline.find(expected) > -1, cmdline)
expected = "Start Time: NS3 Time: 4s ("
status = ec.trace(ccnpeek, "status")
self.assertTrue(status.find(expected) > -1, status)
expected = "DATA"
stdout = ec.trace(ccnpeek, "stdout")
self.assertTrue(stdout.find(expected) > -1, stdout)
ec.shutdown()
def make_experiment(node_count, app_count, opdelay, delay):
ResourceManager._reschedule_delay = "%0.1fs" % delay
# Create Experiment Controller:
ec = ExperimentController("dce_bench")
# Add the physical host in which to run the simulation
lnode = add_linux_node(ec)
# Add a simulation resource
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.register_connection(simu, lnode)
# Add simulated nodes and applications
nodes = list()
apps = list()
devs = list()
ips = dict()
prefix = "16"
base_addr = "10.0.0.0/%s" % prefix
net = ipaddr.IPv4Network(base_addr)
host_itr = net.iterhosts()
for i in xrange(node_count):
node = add_node(ec, simu)
nodes.append(node)
ip = host_itr.next()
ip = ip.exploded
dev = add_device(ec, node, ip, prefix)
devs.append(dev)
ips[node] = ip
for nid in nodes:
for j in xrange(app_count):
# If there is only one node, ping itself. If there are more
# choose one target randomly.
remote_ip = ips[nid]
if len(nodes) > 1:
choices = ips.values()
choices.remove(remote_ip)
remote_ip = random.choice(choices)
app = add_ping_app(ec, node, remote_ip)
apps.append(app)
chan = ec.register_resource("ns3::CsmaChannel")
ec.set(chan, "Delay", "0s")
for dev in devs:
ec.register_connection(chan, dev)
return (ec, apps, nodes + apps + devs)
def t_simple_multirun(self, host, user, depends):
dirpath = tempfile.mkdtemp()
ec = ExperimentController(exp_id = "test-condition-multirun",
local_dir = dirpath)
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
ping = ec.register_resource("linux::Application")
ec.set(ping, "command", "ping -c10 nepi.inria.fr")
ec.register_connection(ping, node)
collector = ec.register_resource("Collector")
ec.set(collector, "traceName", "stdout")
ec.register_connection(ping, collector)
def compute_metric_callback(ping, ec, run):
stdout = ec.trace(ping, "stdout")
m = _ping_re.match(stdout)
if not m:
return None
return float(m.groupdict()["min"])
metric_callback = functools.partial(compute_metric_callback, ping)
rnr = ExperimentRunner()
runs = rnr.run(ec, min_runs = 5,
compute_metric_callback = metric_callback,
wait_guids = [ping],
wait_time = 0)
self.assertTrue(runs >= 5)
dircount = 0
for d in os.listdir(ec.exp_dir):
path = os.path.join(ec.exp_dir, d)
if os.path.isdir(path):
dircount += 1
logs = glob.glob(os.path.join(path, "*.stdout"))
self.assertEquals(len(logs), 1)
self.assertEquals(runs, dircount)
shutil.rmtree(dirpath)
def t_tun_hybrid_gre_tunnel(self, user1, host1, identity1,
user2, host2, identity2):
ec = ExperimentController(exp_id="test-tap-hybrid-gre-tunnel")
node1 = ec.register_resource("planetlab::Node")
ec.set(node1, "hostname", host1)
ec.set(node1, "username", user1)
ec.set(node1, "identity", identity1)
ec.set(node1, "cleanExperiment", True)
ec.set(node1, "cleanProcesses", True)
tun1 = ec.register_resource("planetlab::Tun")
ec.set(tun1, "ip", "%s.1" % self.netblock)
ec.set(tun1, "prefix", "24")
ec.register_connection(tun1, node1)
node2 = ec.register_resource("linux::Node")
ec.set(node2, "hostname", host2)
ec.set(node2, "username", user2)
ec.set(node2, "identity", identity2)
ec.set(node2, "cleanExperiment", True)
ec.set(node2, "cleanProcesses", True)
tun2 = ec.register_resource("linux::Tun")
ec.set(tun2, "ip", "%s.2" % self.netblock)
ec.set(tun2, "prefix", "24")
ec.register_connection(tun2, node2)
gretun = ec.register_resource("linux::GRETunnel")
ec.register_connection(tun1, gretun)
ec.register_connection(tun2, gretun)
app = ec.register_resource("linux::Application")
# It seems the hybrid tunnel takes some time to setup... we add a sleep 5
# XXX: Debug this to see if it can be fixed on the RMs
cmd = "sleep 5; ping -c3 %s.2" % self.netblock
ec.set(app, "command", cmd)
ec.register_connection(app, node1)
ec.deploy()
ec.wait_finished(app)
ping = ec.trace(app, "stdout")
expected = """3 packets transmitted, 3 received, 0% packet loss"""
self.assertTrue(ping.find(expected) > -1)
if_name = ec.get(tun1, "deviceName")
self.assertTrue(if_name.startswith("tun"))
if_name = ec.get(tun2, "deviceName")
self.assertTrue(if_name.startswith("tun"))
ec.shutdown()
def _ec_from_xml(self, doc):
from nepi.execution.ec import ExperimentController
ec = None
ecnode_list = doc.getElementsByTagName("experiment")
for ecnode in ecnode_list:
if ecnode.nodeType == doc.ELEMENT_NODE:
exp_id = xmldecode(ecnode.getAttribute("exp_id"))
run_id = xmldecode(ecnode.getAttribute("run_id"))
local_dir = xmldecode(ecnode.getAttribute("local_dir"))
# Configure number of preocessing threads
nthreads = xmldecode(ecnode.getAttribute("nthreads"))
os.environ["NEPI_NTHREADS"] = nthreads
# Deserialize netgraph
topology = None
topo_type = None
netgraph = self._netgraph_from_xml(doc, ecnode)
if netgraph:
topo_type = netgraph.topo_type
topology = netgraph.topology
# Instantiate EC
ec = ExperimentController(exp_id = exp_id, local_dir = local_dir,
topology = topology, topo_type = topo_type)
connections = set()
rmsnode_list = ecnode.getElementsByTagName("rms")
if rmsnode_list:
rmnode_list = rmsnode_list[0].getElementsByTagName("rm")
for rmnode in rmnode_list:
if rmnode.nodeType == doc.ELEMENT_NODE:
self._rm_from_xml(doc, rmnode, ec, connections)
for (guid1, guid2) in connections:
ec.register_connection(guid1, guid2)
break
return ec
def t_tap_udp_tunnel(self, user1, host1, identity1, user2, host2,
identity2):
ec = ExperimentController(exp_id="test-tap-udp-tunnel")
node1 = ec.register_resource("linux::Node")
ec.set(node1, "hostname", host1)
ec.set(node1, "username", user1)
ec.set(node1, "identity", identity1)
ec.set(node1, "cleanExperiment", True)
ec.set(node1, "cleanProcesses", True)
tap1 = ec.register_resource("linux::Tap")
ec.set(tap1, "ip", "%s.1" % self.netblock)
ec.set(tap1, "prefix", "32")
ec.register_connection(tap1, node1)
node2 = ec.register_resource("linux::Node")
ec.set(node2, "hostname", host2)
ec.set(node2, "username", user2)
ec.set(node2, "identity", identity2)
ec.set(node2, "cleanExperiment", True)
ec.set(node2, "cleanProcesses", True)
tap2 = ec.register_resource("linux::Tap")
ec.set(tap2, "ip", "%s.2" % self.netblock)
ec.set(tap2, "prefix", "32")
ec.register_connection(tap2, node2)
udptun = ec.register_resource("linux::UdpTunnel")
ec.register_connection(tap1, udptun)
ec.register_connection(tap2, udptun)
app = ec.register_resource("linux::Application")
cmd = "ping -c3 %s.2" % self.netblock
ec.set(app, "command", cmd)
ec.register_connection(app, node1)
ec.deploy()
ec.wait_finished(app)
ping = ec.trace(app, "stdout")
expected = """3 packets transmitted, 3 received, 0% packet loss"""
self.assertTrue(ping.find(expected) > -1)
vif_name = ec.get(tap1, "deviceName")
self.assertTrue(vif_name.startswith("tap"))
vif_name = ec.get(tap2, "deviceName")
self.assertTrue(vif_name.startswith("tap"))
ec.shutdown()
def t_concurrency(self, host, user):
ec = ExperimentController(exp_id="test-concurrency")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
apps = list()
for i in xrange(50):
app = ec.register_resource("linux::Application")
cmd = "ping -c5 %s" % self.target
ec.set(app, "command", cmd)
ec.register_connection(app, node)
apps.append(app)
ec.deploy()
ec.wait_finished(apps)
self.assertTrue(ec.state(node) == ResourceState.STARTED)
self.assertTrue(
all([ec.state(guid) == ResourceState.STOPPED \
for guid in apps])
)
for app in apps:
stdout = ec.trace(app, 'stdout')
size = ec.trace(app, 'stdout', attr = TraceAttr.SIZE)
self.assertEquals(len(stdout), size)
block = ec.trace(app, 'stdout', attr = TraceAttr.STREAM, block = 5, offset = 1)
self.assertEquals(block, stdout[5:10])
path = ec.trace(app, 'stdout', attr = TraceAttr.PATH)
rm = ec.get_resource(app)
p = os.path.join(rm.run_home, 'stdout')
self.assertEquals(path, p)
ec.shutdown()
def t_http_sources(self, host, user):
ec = ExperimentController(exp_id="test-http-sources")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
sources = "http://yans.pl.sophia.inria.fr/code/nef/archive/tip.tar.gz;" \
"http://yans.pl.sophia.inria.fr/code/nef/raw-file/8ace577d4079/src/nef/images/menu/connect.png"
app = ec.register_resource("linux::Application")
ec.set(app, "sources", sources)
command = "ls ${SRC}"
ec.set(app, "command", command)
ec.register_connection(app, node)
ec.deploy()
ec.wait_finished([app])
self.assertTrue(ec.state(node) == ResourceState.STARTED)
self.assertTrue(ec.state(app) == ResourceState.STOPPED)
exitcode = ec.trace(app, "deploy_exitcode")
self.assertTrue(exitcode.strip() == "0")
out = ec.trace(app, "deploy_stdout")
self.assertTrue(out.find("tip.tar.gz") > -1)
self.assertTrue(out.find("connect.png") > -1)
stdout = ec.trace(app, "stdout")
self.assertTrue(stdout.find("tip.tar.gz") > -1)
self.assertTrue(stdout.find("connect.png") > -1)
ec.shutdown()
def test_exception(self):
from nepi.execution.resource import ResourceFactory
ResourceFactory.register_type(ErrorApplication)
ResourceFactory.register_type(Node)
ResourceFactory.register_type(Interface)
ec = ExperimentController()
node = ec.register_resource("Node")
app = ec.register_resource("ErrorApplication")
ec.register_connection(app, node)
ec.deploy()
ec.wait_finished(app)
ec.shutdown()
self.assertEquals(ec._fm._failure_level, FailureLevel.RM_FAILURE)
def test_ccnpeek(self):
ec = ExperimentController(exp_id = "test-linux-ccnpeek")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", self.fedora_host)
ec.set(node, "username", self.fedora_user)
ec.set(node, "identity", self.fedora_identity)
#ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanExperiment", True)
ccnd = ec.register_resource("linux::CCND")
ec.register_connection(ccnd, node)
peek = ec.register_resource("linux::CCNPeek")
ec.set(peek, "contentName", "ccnx:/chunk0")
ec.register_connection(peek, ccnd)
poke = ec.register_resource("linux::CCNPoke")
ec.set(poke, "contentName", "ccnx:/chunk0")
ec.set(poke, "content", "DATA")
ec.register_connection(poke, ccnd)
ec.register_condition(peek, ResourceAction.START, poke,
ResourceState.STARTED)
ec.deploy()
ec.wait_finished(peek)
stdout = ec.trace(peek, "stdout")
print stdout
expected = "DATA"
self.assertTrue(stdout.find(expected) > -1)
ec.shutdown()
def test_runner_max_runs(self):
node_count = 4
app_count = 2
ec = ExperimentController(exp_id = "max-runs-test")
# Add simulated nodes and applications
nodes = list()
apps = list()
ifaces = list()
for i in xrange(node_count):
node = ec.register_resource("dummy::Node")
nodes.append(node)
iface = ec.register_resource("dummy::Interface")
ec.register_connection(node, iface)
ifaces.append(iface)
for i in xrange(app_count):
app = ec.register_resource("dummy::Application")
ec.register_connection(node, app)
apps.append(app)
link = ec.register_resource("dummy::Link")
for iface in ifaces:
ec.register_connection(link, iface)
rnr = ExperimentRunner()
runs = rnr.run(ec, min_runs = 5, max_runs = 10, wait_guids = apps,
wait_time = 0)
self.assertEquals(runs, 10)
def test_critical(self):
from nepi.execution.resource import ResourceFactory
ResourceFactory.register_type(ErrorApplication)
ResourceFactory.register_type(Application)
ResourceFactory.register_type(Node)
ResourceFactory.register_type(Interface)
ec = ExperimentController()
node = ec.register_resource("Node")
apps = list()
eapp = ec.register_resource("ErrorApplication")
ec.set(eapp, "critical", False)
ec.register_connection(eapp, node)
apps.append(eapp)
for i in xrange(10):
app = ec.register_resource("Application")
ec.register_connection(app, node)
apps.append(app)
ec.deploy()
ec.wait_finished(apps)
state = ec.state(eapp)
self.assertEquals(state, ResourceState.FAILED)
apps.remove(eapp)
for app in apps:
state = ec.state(app)
self.assertEquals(state, ResourceState.STOPPED)
ec.shutdown()
self.assertEquals(ec._fm._failure_level, FailureLevel.OK)
def t_real_time(self, host, user = None, identity = None):
ec = ExperimentController(exp_id = "test-ns3-real-time")
node = ec.register_resource("linux::Node")
if host == "localhost":
ec.set(node, "hostname", "localhost")
else:
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanHome", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "simulatorImplementationType", "ns3::RealtimeSimulatorImpl")
ec.set(simu, "checksumEnabled", True)
ec.set(simu, "verbose", True)
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
dev1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
nsnode2 = add_ns3_node(ec, simu)
dev2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
# Create channel
chan = ec.register_resource("ns3::PointToPointChannel")
ec.set(chan, "Delay", "0s")
ec.register_connection(chan, dev1)
ec.register_connection(chan, dev2)
### create pinger
ping = ec.register_resource("ns3::V4Ping")
ec.set (ping, "Remote", "10.0.0.2")
ec.set (ping, "Interval", "1s")
ec.set (ping, "Verbose", True)
ec.set (ping, "StartTime", "0s")
ec.set (ping, "StopTime", "20s")
ec.register_connection(ping, nsnode1)
ec.deploy()
ec.wait_finished([ping])
stdout = ec.trace(simu, "stdout")
expected = "20 packets transmitted, 20 received, 0% packet loss"
self.assertTrue(stdout.find(expected) > -1)
rm = ec.get_resource(ping)
start_time = rm.start_time
stop_time = rm.stop_time
delta = stop_time - start_time
self.assertTrue(delta.seconds >= 20, "Time elapsed %d" % delta.seconds)
self.assertTrue(delta.seconds < 25, "Time elapsed %d" % delta.seconds)
ec.shutdown()
def t_nodns(self, host, user):
ec = ExperimentController(exp_id = "test-nodns")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
app = ec.register_resource("linux::Mtr")
ec.set(app, "noDns", False)
ec.set(app, "target", self.target)
ec.register_connection(app, node)
ec.deploy()
ec.wait_finished(app)
stdout = ec.trace(app, "stdout")
self.assertTrue(stdout.find("1.") > -1)
ec.shutdown()
def t_condition(self, host, user, depends):
ec = ExperimentController(exp_id="test-condition")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
server = ec.register_resource("linux::Application")
cmd = "echo 'HOLA' | nc -l 3333"
ec.set(server, "command", cmd)
ec.set(server, "depends", depends)
ec.register_connection(server, node)
client = ec.register_resource("linux::Application")
cmd = "nc 127.0.0.1 3333"
ec.set(client, "command", cmd)
ec.register_connection(client, node)
ec.register_condition(client, ResourceAction.START, server, ResourceState.STARTED)
apps = [client, server]
ec.deploy()
ec.wait_finished(apps)
self.assertTrue(ec.state(node) == ResourceState.STARTED)
self.assertTrue(ec.state(server) == ResourceState.STOPPED)
self.assertTrue(ec.state(client) == ResourceState.STOPPED)
stdout = ec.trace(client, "stdout")
self.assertTrue(stdout.strip() == "HOLA")
ec.shutdown()
def t_code(self, host, user):
ec = ExperimentController(exp_id = "tests-code")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
prog = """#include <stdio.h>
int
main (void)
{
printf ("Hello, world!\\n");
return 0;
}
"""
cmd = "${RUN_HOME}/hello"
build = "gcc -Wall -x c ${APP_HOME}/code -o hello"
app = ec.register_resource("linux::Application")
ec.set(app, "command", cmd)
ec.set(app, "code", prog)
ec.set(app, "depends", "gcc")
ec.set(app, "build", build)
ec.register_connection(app, node)
ec.deploy()
ec.wait_finished(app)
out = ec.trace(app, 'stdout')
self.assertEquals(out, "Hello, world!\n")
ec.shutdown()
def t_count(self, host, user):
ec = ExperimentController(exp_id = "test-ping-count")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
app = ec.register_resource("linux::Ping")
ec.set(app, "count", "3")
ec.set(app, "target", self.target)
ec.register_connection(app, node)
ec.deploy()
ec.wait_finished(app)
stdout = ec.trace(app, "stdout")
expected = "3 packets transmitted, 3 received, 0% packet loss"
self.assertTrue(stdout.find(expected) > -1)
ec.shutdown()
def t_copy_files(self, host, user):
# create some temp files and directories to copy
dirpath = tempfile.mkdtemp()
f = tempfile.NamedTemporaryFile(dir=dirpath, delete=False)
f.close()
f1 = tempfile.NamedTemporaryFile(delete=False)
f1.close()
f1.name
ec = ExperimentController(exp_id="test-copyfile")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
app = ec.register_resource("linux::Application")
ec.set(app, "command", "ls ${SRC}")
ec.set(app, "sources", "%s;%s" % (dirpath, f1.name))
ec.register_connection(app, node)
ec.deploy()
ec.wait_finished([app])
stdout = ec.trace(app, "stdout")
self.assertTrue(stdout.find(os.path.basename(dirpath)) > -1)
self.assertTrue(stdout.find(os.path.basename(f1.name)) > -1)
ec.shutdown()
os.remove(f1.name)
shutil.rmtree(dirpath)
def t_xterm(self, host, user):
ec = ExperimentController(exp_id="test-xterm")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
app = ec.register_resource("linux::Application")
ec.set(app, "command", "xterm")
ec.set(app, "depends", "xterm")
ec.set(app, "forwardX11", True)
ec.register_connection(app, node)
ec.deploy()
ec.wait_finished([app])
self.assertTrue(ec.state(app) == ResourceState.STOPPED)
ec.shutdown()
def t_compile_debug_mode(self, host, user = None, identity = None):
ec = ExperimentController(exp_id = "test-ns3-debug-mode")
node = ec.register_resource("linux::Node")
if host == "localhost":
ec.set(node, "hostname", host)
else:
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanHome", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.set(simu, "nsLog", "V4Ping:Node")
ec.set(simu, "buildMode", "debug")
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
nsnode2 = add_ns3_node(ec, simu)
dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
# Create channel
chan = ec.register_resource("ns3::CsmaChannel")
ec.set(chan, "Delay", "0s")
ec.register_connection(chan, dev1)
ec.register_connection(chan, dev2)
### create pinger
ping = ec.register_resource("ns3::V4Ping")
ec.set (ping, "Remote", "10.0.0.2")
ec.set (ping, "Interval", "1s")
ec.set (ping, "Verbose", True)
ec.set (ping, "StartTime", "0s")
ec.set (ping, "StopTime", "20s")
ec.register_connection(ping, nsnode1)
ec.deploy()
ec.wait_finished([ping])
stdout = ec.trace(simu, "stdout")
expected = "20 packets transmitted, 20 received, 0% packet loss"
self.assertTrue(stdout.find(expected) > -1)
stderr = ec.trace(simu, "stderr")
expected = "V4Ping:Read32"
self.assertTrue(stderr.find(expected) > -1)
ec.shutdown()
def t_wifi_ping(self, host, user = None, identity = None):
bounds_width = bounds_height = 200
x = y = 100
speed = 1
ec = ExperimentController(exp_id = "test-ns3-wifi-ping")
node = ec.register_resource("linux::Node")
if host == "localhost":
ec.set(node, "hostname", "localhost")
else:
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanHome", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
dev1, phy1 = add_wifi_device(ec, nsnode1, "10.0.0.1", "24", access_point = True)
mobility1 = add_constant_mobility(ec, nsnode1, x, y, 0)
nsnode2 = add_ns3_node(ec, simu)
dev2, phy2 = add_wifi_device(ec, nsnode2, "10.0.0.2", "24", access_point = False)
mobility1 = add_constant_mobility(ec, nsnode2, x, y, 0)
#mobility2 = add_random_mobility(ec, nsnode2, x, y, 0, speed, bounds_width, bounds_height)
# Create channel
chan = add_wifi_channel(ec)
ec.register_connection(chan, phy1)
ec.register_connection(chan, phy2)
### create pinger
ping = ec.register_resource("ns3::V4Ping")
ec.set (ping, "Remote", "10.0.0.1")
ec.set (ping, "Interval", "1s")
ec.set (ping, "Verbose", True)
ec.set (ping, "StartTime", "1s")
ec.set (ping, "StopTime", "21s")
ec.register_connection(ping, nsnode2)
ec.deploy()
ec.wait_finished([ping])
stdout = ec.trace(simu, "stdout")
expected = "20 packets transmitted, 20 received, 0% packet loss"
self.assertTrue(stdout.find(expected) > -1)
ec.shutdown()
def t_traces(self, host, user):
ec = ExperimentController(exp_id = "test-fib-traces")
node1 = ec.register_resource("linux::Node")
ec.set(node1, "hostname", host)
ec.set(node1, "username", user)
ec.set(node1, "cleanExperiment", True)
ec.set(node1, "cleanProcesses", True)
ccnd1 = ec.register_resource("linux::CCND")
ec.register_connection(ccnd1, node1)
entry1 = ec.register_resource("linux::FIBEntry")
ec.set(entry1, "host", self.target)
ec.enable_trace(entry1, "ping")
ec.enable_trace(entry1, "mtr")
ec.register_connection(entry1, ccnd1)
node2 = ec.register_resource("linux::Node")
ec.set(node2, "hostname", self.target)
ec.set(node2, "username", self.fedora_user)
ec.set(node2, "cleanExperiment", True)
ec.set(node2, "cleanProcesses", True)
ccnd2 = ec.register_resource("linux::CCND")
ec.register_connection(ccnd2, node2)
entry2 = ec.register_resource("linux::FIBEntry")
ec.set(entry2, "host", host)
ec.register_connection(entry2, ccnd2)
ec.deploy()
ec.wait_started([ccnd1, ccnd2])
stdout = ec.trace(entry1, "ping")
expected = "icmp_seq=1"
self.assertTrue(stdout.find(expected) > -1)
stdout = ec.trace(entry1, "mtr")
expected = "1."
self.assertTrue(stdout.find(expected) > -1)
ec.shutdown()
def test_serialize(self):
node_count = 4
app_count = 2
dirpath = tempfile.mkdtemp()
ec = ExperimentController(exp_id="serialize-test")
# Add simulated nodes and applications
nodes = list()
apps = list()
ifaces = list()
for i in xrange(node_count):
node = ec.register_resource("dummy::Node")
nodes.append(node)
iface = ec.register_resource("dummy::Interface")
ec.register_connection(node, iface)
ifaces.append(iface)
for i in xrange(app_count):
app = ec.register_resource("dummy::Application")
ec.register_connection(node, app)
apps.append(app)
link = ec.register_resource("dummy::Link")
for iface in ifaces:
ec.register_connection(link, iface)
filepath = ec.save(dirpath)
ec.deploy()
# Wait until nodes and apps are deployed
ec.wait_finished(apps)
# Do the experiment controller shutdown
ec.shutdown()
# Load serialized experiment
ec2 = ExperimentController.load(filepath)
apps = ec2.filter_resources("dummy::Application")
ec2.deploy()
ec2.wait_finished(apps)
ec2.shutdown()
self.assertEquals(len(ec.resources), len(ec2.resources))
shutil.rmtree(dirpath)
def t_dummy(self, host, user = None, identity = None):
ec = ExperimentController(exp_id = "test-ns3-fd-dummy")
node = ec.register_resource("linux::Node")
if host == "localhost":
ec.set(node, "hostname", "localhost")
else:
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanExperiment", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "simulatorImplementationType", "ns3::RealtimeSimulatorImpl")
ec.set(simu, "checksumEnabled", True)
ec.set(simu, "verbose", True)
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
dev1 = add_fd_device(ec, nsnode1, "10.0.0.1", "30")
nsnode2 = add_ns3_node(ec, simu)
dev2 = add_fd_device(ec, nsnode2, "10.0.0.2", "30")
channel = ec.register_resource("ns3::PipeChannel")
ec.register_connection(channel, dev1)
ec.register_connection(channel, dev2)
### create pinger
ping = ec.register_resource("ns3::V4Ping")
ec.set (ping, "Remote", "10.0.0.2")
ec.set (ping, "Interval", "1s")
ec.set (ping, "Verbose", True)
ec.set (ping, "StartTime", "0s")
ec.set (ping, "StopTime", "20s")
ec.register_connection(ping, nsnode1)
ec.deploy()
ec.wait_finished([ping])
stdout = ec.trace(simu, "stdout")
print stdout
expected = "20 packets transmitted, 20 received, 0% packet loss"
self.assertTrue(stdout.find(expected) > -1)
ec.shutdown()
def t_csma_ping(self, host, user=None, identity=None):
ec = ExperimentController(exp_id="test-ns3-csma-ping")
node = ec.register_resource("linux::Node")
if host == "localhost":
ec.set(node, "hostname", "localhost")
else:
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanHome", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
dev1 = add_csma_device(ec, nsnode1, "10.0.0.1", "30")
nsnode2 = add_ns3_node(ec, simu)
dev2 = add_csma_device(ec, nsnode2, "10.0.0.2", "30")
# Create channel
chan = ec.register_resource("ns3::CsmaChannel")
ec.set(chan, "Delay", "0s")
ec.register_connection(chan, dev1)
ec.register_connection(chan, dev2)
### create pinger
ping = ec.register_resource("ns3::V4Ping")
ec.set(ping, "Remote", "10.0.0.2")
ec.set(ping, "Interval", "1s")
ec.set(ping, "Verbose", True)
ec.set(ping, "StartTime", "0s")
ec.set(ping, "StopTime", "20s")
ec.register_connection(ping, nsnode1)
ec.deploy()
ec.wait_finished([ping])
stdout = ec.trace(simu, "stdout")
expected = "20 packets transmitted, 20 received, 0% packet loss"
self.assertTrue(stdout.find(expected) > -1)
ec.shutdown()
def test_serialize(self):
node_count = 4
app_count = 2
ec = ExperimentController(exp_id = "plotter-test")
# Add simulated nodes and applications
nodes = list()
apps = list()
ifaces = list()
for i in xrange(node_count):
node = ec.register_resource("dummy::Node")
nodes.append(node)
iface = ec.register_resource("dummy::Interface")
ec.register_connection(node, iface)
ifaces.append(iface)
for i in xrange(app_count):
app = ec.register_resource("dummy::Application")
ec.register_connection(node, app)
apps.append(app)
link = ec.register_resource("dummy::Link")
for iface in ifaces:
ec.register_connection(link, iface)
fpath = ec.plot()
statinfo = os.stat(fpath)
size = statinfo.st_size
self.assertTrue(size > 0)
self.assertTrue(fpath.endswith(".png"))
os.remove(fpath)
fpath = ec.plot(format = PFormats.DOT)
statinfo = os.stat(fpath)
size = statinfo.st_size
self.assertTrue(size > 0)
self.assertTrue(fpath.endswith(".dot"))
os.remove(fpath)
def test_runner_convergence(self):
node_count = 4
app_count = 2
ec = ExperimentController(exp_id="convergence-test")
# Add simulated nodes and applications
nodes = list()
apps = list()
ifaces = list()
for i in xrange(node_count):
node = ec.register_resource("dummy::Node")
nodes.append(node)
iface = ec.register_resource("dummy::Interface")
ec.register_connection(node, iface)
ifaces.append(iface)
for i in xrange(app_count):
app = ec.register_resource("dummy::Application")
ec.register_connection(node, app)
apps.append(app)
link = ec.register_resource("dummy::Link")
for iface in ifaces:
ec.register_connection(link, iface)
samples = [10, 10, 10, 10, 12, 10, 12, 10, 10, 11]
def compute_metric_callback(samples, ec, run):
return samples[run - 1]
metric_callback = functools.partial(compute_metric_callback, samples)
rnr = ExperimentRunner()
runs = rnr.run(ec,
min_runs=5,
compute_metric_callback=metric_callback,
wait_guids=apps,
wait_time=0)
self.assertEquals(runs, 10)
def test_runner_max_runs(self):
node_count = 4
app_count = 2
ec = ExperimentController(exp_id="max-runs-test")
# Add simulated nodes and applications
nodes = list()
apps = list()
ifaces = list()
for i in xrange(node_count):
node = ec.register_resource("dummy::Node")
nodes.append(node)
iface = ec.register_resource("dummy::Interface")
ec.register_connection(node, iface)
ifaces.append(iface)
for i in xrange(app_count):
app = ec.register_resource("dummy::Application")
ec.register_connection(node, app)
apps.append(app)
link = ec.register_resource("dummy::Link")
for iface in ifaces:
ec.register_connection(link, iface)
rnr = ExperimentRunner()
runs = rnr.run(ec,
min_runs=5,
max_runs=10,
wait_guids=apps,
wait_time=0)
self.assertEquals(runs, 10)
class OMFVLCWrongCaseAllCritical(unittest.TestCase):
id = 1000
def setUp(self):
self.ec = ExperimentController(
exp_id=str(OMFVLCWrongCaseAllCritical.id))
OMFVLCWrongCaseAllCritical.id += 1
self.node1 = self.ec.register_resource("omf::Node")
self.ec.set(self.node1, 'hostname', 'wlab12')
self.ec.set(self.node1, 'xmppUser', "nepi")
self.ec.set(self.node1, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.node1, 'xmppPort', "5222")
self.ec.set(self.node1, 'xmppPassword', "1234")
self.iface1 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.iface1, 'name', "wlan0")
self.ec.set(self.iface1, 'mode', "adhoc")
self.ec.set(self.iface1, 'hw_mode', "g")
self.ec.set(self.iface1, 'essid', "vlcexp")
self.ec.set(self.iface1, 'ip', "10.0.0.12/24")
self.app1 = self.ec.register_resource("omf::Application")
self.ec.set(self.app1, 'appid', 'Vlc#1')
self.ec.set(
self.app1, 'command',
"/opt/vlc-1.1.13/cvlc /opt/10-by-p0d.avi --sout '#rtp{dst=10.0.0.49,port=1234,mux=ts}'"
)
self.ec.set(self.app1, 'env',
"DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority")
self.ec.register_connection(self.app1, self.node1)
self.ec.register_connection(self.node1, self.iface1)
def test_deploy_wo_node(self):
self.node2 = self.ec.register_resource("omf::Node")
self.iface2 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.iface2, 'name', "wlan0")
self.ec.set(self.iface2, 'mode', "adhoc")
self.ec.set(self.iface2, 'hw_mode', "g")
self.ec.set(self.iface2, 'essid', "vlcexp")
self.ec.set(self.iface2, 'ip', "10.0.0.49/24")
self.channel = self.ec.register_resource("omf::Channel")
self.ec.set(self.channel, 'channel', "6")
self.ec.register_connection(self.iface1, self.channel)
self.ec.register_connection(self.node2, self.iface2)
self.ec.register_connection(self.iface2, self.channel)
self.ec.register_condition([self.app1], ResourceAction.STOP, self.app1,
ResourceState.STARTED, "2s")
self.ec.deploy()
self.ec.wait_finished([self.app1])
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.FAILED)
self.ec.shutdown()
self.assertEquals(
self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_hostname(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.set(self.node2, 'xmppUser', "nepi")
self.ec.set(self.node2, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.node2, 'xmppPort', "5222")
self.ec.set(self.node2, 'xmppPassword', "1234")
self.iface2 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.iface2, 'name', "wlan0")
self.ec.set(self.iface2, 'mode', "adhoc")
self.ec.set(self.iface2, 'hw_mode', "g")
self.ec.set(self.iface2, 'essid', "vlcexp")
self.ec.set(self.iface2, 'ip', "10.0.0.49/24")
self.channel = self.ec.register_resource("omf::Channel")
self.ec.set(self.channel, 'channel', "6")
self.ec.register_connection(self.iface1, self.channel)
self.ec.register_connection(self.node2, self.iface2)
self.ec.register_connection(self.iface2, self.channel)
self.ec.register_condition([self.app1], ResourceAction.STOP, self.app1,
ResourceState.STARTED, "2s")
self.ec.deploy()
self.ec.wait_finished([self.app1])
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.FAILED)
self.ec.shutdown()
self.assertEquals(
self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_iface(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.set(self.node2, 'hostname', 'wlab49')
self.ec.set(self.node2, 'xmppUser', "nepi")
self.ec.set(self.node2, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.node2, 'xmppPort', "5222")
self.ec.set(self.node2, 'xmppPassword', "1234")
self.iface2 = self.ec.register_resource("omf::WifiInterface")
self.channel = self.ec.register_resource("omf::Channel")
self.ec.set(self.channel, 'channel', "6")
self.ec.register_connection(self.iface1, self.channel)
self.ec.register_connection(self.node2, self.iface2)
self.ec.register_connection(self.iface2, self.channel)
self.ec.register_condition([self.app1], ResourceAction.STOP, self.app1,
ResourceState.STARTED, "2s")
self.ec.deploy()
self.ec.wait_finished([self.app1])
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.ec.shutdown()
self.assertEquals(
self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_channel(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.set(self.node2, 'hostname', 'wlab49')
self.ec.set(self.node2, 'xmppUser', "nepi")
self.ec.set(self.node2, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.node2, 'xmppPort', "5222")
self.ec.set(self.node2, 'xmppPassword', "1234")
self.iface2 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.iface2, 'name', "wlan0")
self.ec.set(self.iface2, 'mode', "adhoc")
self.ec.set(self.iface2, 'hw_mode', "g")
self.ec.set(self.iface2, 'essid', "vlcexp")
self.ec.set(self.iface2, 'ip', "10.0.0.49/24")
self.channel = self.ec.register_resource("omf::Channel")
self.ec.register_connection(self.iface1, self.channel)
self.ec.register_connection(self.node2, self.iface2)
self.ec.register_connection(self.iface2, self.channel)
self.ec.register_condition([self.app1], ResourceAction.STOP, self.app1,
ResourceState.STARTED, "2s")
self.ec.deploy()
self.ec.wait_finished([self.app1])
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.FAILED)
self.ec.shutdown()
self.assertEquals(
self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_ip(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.set(self.node2, 'hostname', 'wlab49')
self.ec.set(self.node2, 'xmppUser', "nepi")
self.ec.set(self.node2, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.node2, 'xmppPort', "5222")
self.ec.set(self.node2, 'xmppPassword', "1234")
self.iface2 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.iface2, 'name', "wlan0")
self.ec.set(self.iface2, 'mode', "adhoc")
self.ec.set(self.iface2, 'hw_mode', "g")
self.ec.set(self.iface2, 'essid', "vlcexp")
self.channel = self.ec.register_resource("omf::Channel")
self.ec.set(self.channel, 'channel', "6")
self.ec.register_connection(self.iface1, self.channel)
self.ec.register_connection(self.node2, self.iface2)
self.ec.register_connection(self.iface2, self.channel)
self.ec.register_condition([self.app1], ResourceAction.STOP, self.app1,
ResourceState.STARTED, "2s")
self.ec.deploy()
self.ec.wait_finished([self.app1])
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.ec.shutdown()
self.assertEquals(
self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_wo_app(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.set(self.node2, 'hostname', 'wlab49')
self.ec.set(self.node2, 'xmppUser', "nepi")
self.ec.set(self.node2, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.node2, 'xmppPort', "5222")
self.ec.set(self.node2, 'xmppPassword', "1234")
self.iface2 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.iface2, 'name', "wlan0")
self.ec.set(self.iface2, 'mode', "adhoc")
self.ec.set(self.iface2, 'hw_mode', "g")
self.ec.set(self.iface2, 'essid', "vlcexp")
self.ec.set(self.iface2, 'ip', "10.0.0.49/24")
self.channel = self.ec.register_resource("omf::Channel")
self.ec.set(self.channel, 'channel', "6")
self.app2 = self.ec.register_resource("omf::Application")
self.ec.register_connection(self.iface1, self.channel)
self.ec.register_connection(self.iface2, self.channel)
self.ec.register_connection(self.node2, self.iface2)
self.ec.register_connection(self.app2, self.node2)
self.ec.register_condition(self.app2, ResourceAction.START, self.app1,
ResourceState.STARTED, "2s")
self.ec.register_condition([self.app1, self.app2], ResourceAction.STOP,
self.app1, ResourceState.STARTED, "4s")
self.ec.deploy()
self.ec.wait_finished([self.app1, self.app2])
self.assertEquals(
self.ec.get_resource(self.app2).state, ResourceState.FAILED)
self.ec.shutdown()
self.assertEquals(
self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
def test_deploy_wo_app_path(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.set(self.node2, 'hostname', 'wlab49')
self.ec.set(self.node2, 'xmppUser', "nepi")
self.ec.set(self.node2, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.node2, 'xmppPort', "5222")
self.ec.set(self.node2, 'xmppPassword', "1234")
self.iface2 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.iface2, 'name', "wlan0")
self.ec.set(self.iface2, 'mode', "adhoc")
self.ec.set(self.iface2, 'hw_mode', "g")
self.ec.set(self.iface2, 'essid', "vlcexp")
self.ec.set(self.iface2, 'ip', "10.0.0.49/24")
self.channel = self.ec.register_resource("omf::Channel")
self.ec.set(self.channel, 'channel', "6")
self.app2 = self.ec.register_resource("omf::Application")
self.ec.set(self.app2, 'appid', 'Vlc#2')
self.ec.register_connection(self.iface1, self.channel)
self.ec.register_connection(self.iface2, self.channel)
self.ec.register_connection(self.node2, self.iface2)
self.ec.register_connection(self.app2, self.node2)
self.ec.register_condition(self.app2, ResourceAction.START, self.app1,
ResourceState.STARTED, "2s")
self.ec.register_condition([self.app1, self.app2], ResourceAction.STOP,
self.app1, ResourceState.STARTED, "4s")
self.ec.deploy()
self.ec.wait_finished([self.app1, self.app2])
self.assertEquals(
self.ec.get_resource(self.app2).state, ResourceState.FAILED)
self.ec.shutdown()
self.assertEquals(
self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
hostname = options.hostname
username = options.username
ssh_key = options.ssh_key
ec = ExperimentController(exp_id="src-up-exp")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", hostname)
ec.set(node, "username", username)
ec.set(node, "identity", ssh_key)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
path_to_sources = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"hello.c")
app = ec.register_resource("linux::Application")
ec.set(app, "sources", path_to_sources)
ec.set(app, "build", "gcc ${SRC}/hello.c -o ${BIN}/hello")
ec.set(app, "command", "${BIN}/hello")
ec.register_connection(node, app)
ec.deploy()
ec.wait_finished(app)
print ec.trace(app, "stdout")
ec.shutdown()
iface_client4 = create_omf_iface(ec, "192.168.0.5/24", client4)
iface_client5 = create_omf_iface(ec, "192.168.0.6/24", client5)
omf_ifaces = [
iface_center, iface_client1, iface_client2, iface_client3, iface_client4,
iface_client5
]
# Register channel
chan = ec.register_resource("omf::Channel")
ec.set(chan, 'channel', "6")
# Register connection ifaces - channel
ec.register_connection(iface_center, chan)
ec.register_connection(iface_client1, chan)
ec.register_connection(iface_client2, chan)
ec.register_connection(iface_client3, chan)
ec.register_connection(iface_client4, chan)
ec.register_connection(iface_client5, chan)
resources = [video_server] + omf_nodes + omf_ifaces + [chan]
# Deploy physical resources and wait until they become provisioned
ec.deploy(resources)
ec.wait_deployed(resources)
time.sleep(3)
# Set the number of threads.
# NOTE: This must be done before instantiating the EC.
os.environ["NEPI_NTHREADS"] = str(thread_count)
# Create Experiment Controller:
exp_id = "%s_bench" % platform
ec = ExperimentController(exp_id)
# Add the physical node in which to run the simulation
lnode = add_linux_node(ec, clean_run)
# Add a simulation resource
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.register_connection(simu, lnode)
# Add simulated nodes and applications
nodes = list()
apps = list()
devs = list()
ips = dict()
prefix = "16"
base_addr = "10.0.0.0/%s" % prefix
net = ipaddr.IPv4Network(base_addr)
host_itr = net.iterhosts()
for i in xrange(node_count):
node = add_node(ec, simu)
def t_dce_serialize(self, host, user=None, identity=None):
dirpath = tempfile.mkdtemp()
ec = ExperimentController(exp_id="test-ns3-dce")
node = ec.register_resource("linux::Node")
if host == "localhost":
ec.set(node, "hostname", host)
else:
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanHome", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
p2p1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
ec.set(p2p1, "DataRate", "5Mbps")
nsnode2 = add_ns3_node(ec, simu)
p2p2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
ec.set(p2p2, "DataRate", "5Mbps")
# Create channel
chan = ec.register_resource("ns3::PointToPointChannel")
ec.set(chan, "Delay", "2ms")
ec.register_connection(chan, p2p1)
ec.register_connection(chan, p2p2)
### create applications
udp_perf = ec.register_resource("linux::ns3::dce::Application")
ec.set(udp_perf, "binary", "udp-perf")
ec.set(udp_perf, "stackSize", 1 << 20)
ec.set(udp_perf, "arguments", "--duration=10;--nodes=2")
ec.set(udp_perf, "StartTime", "1s")
ec.set(udp_perf, "StopTime", "20s")
ec.register_connection(udp_perf, nsnode1)
udp_perf_client = ec.register_resource("linux::ns3::dce::Application")
ec.set(udp_perf_client, "binary", "udp-perf")
ec.set(udp_perf_client, "stackSize", 1 << 20)
ec.set(udp_perf_client, "arguments",
"--client;--nodes=2;--host=10.0.0.1;--duration=10")
ec.set(udp_perf_client, "StartTime", "2s")
ec.set(udp_perf_client, "StopTime", "20s")
ec.register_connection(udp_perf_client, nsnode2)
filepath = ec.save(dirpath)
ec.deploy()
ec.wait_finished([udp_perf_client])
# Give time to flush the streams
import time
time.sleep(5)
expected = "udp-perf --duration=10 --nodes=2"
cmdline = ec.trace(udp_perf, "cmdline")
self.assertTrue(cmdline.find(expected) > -1, cmdline)
expected = "Start Time: NS3 Time: 1s ("
status = ec.trace(udp_perf, "status")
self.assertTrue(status.find(expected) > -1, status)
expected = "received=1500 bytes, 1 reads (@1500 bytes) 1500"
stdout = ec.trace(udp_perf, "stdout")
self.assertTrue(stdout.find(expected) > -1, stdout)
ec.shutdown()
# Load serialized experiment
ec2 = ExperimentController.load(filepath)
ec2.deploy()
ec2.wait_finished([udp_perf_client])
# Give time to flush the streams
time.sleep(5)
self.assertEquals(len(ec.resources), len(ec2.resources))
expected = "udp-perf --duration=10 --nodes=2"
cmdline = ec2.trace(udp_perf, "cmdline")
self.assertTrue(cmdline.find(expected) > -1, cmdline)
expected = "Start Time: NS3 Time: 1s ("
status = ec2.trace(udp_perf, "status")
self.assertTrue(status.find(expected) > -1, status)
expected = "received=1500 bytes, 1 reads (@1500 bytes) 1500"
stdout = ec2.trace(udp_perf, "stdout")
self.assertTrue(stdout.find(expected) > -1, stdout)
ec2.shutdown()
shutil.rmtree(dirpath)
ec.set(app, "env", env)
ec.set(app, "command", command)
return app
## Create the experiment controller
ec = ExperimentController(exp_id="ccn_advanced_transfer")
# Register first PlanetLab host
node1 = add_node(ec, hostname1, username, ssh_key)
# Register CCN setup for host
peers = [hostname2]
ccnd1 = add_ccnd(ec, peers)
ec.register_connection(ccnd1, node1)
# Register content producer application (ccnseqwriter)
## Push the file into the repository
local_path_to_content = os.path.join(
os.path.dirname(os.path.realpath(__file__)), "..",
"big_buck_bunny_240p_mpeg4_lq.ts")
content_name = "ccnx:/test/FILE"
pub = add_publish(ec, local_path_to_content, content_name)
ec.register_connection(pub, node1)
# The movie can only be published after ccnd is running
ec.register_condition(pub, ResourceAction.START, ccnd1, ResourceState.STARTED)
def test_deploy(self):
ec = ExperimentController(exp_id="5421")
self.node1 = ec.register_resource("omf::Node")
ec.set(self.node1, 'hostname', 'wlab12')
ec.set(self.node1, 'xmppUser', "nepi")
ec.set(self.node1, 'xmppServer', "xmpp-plexus.onelab.eu")
ec.set(self.node1, 'xmppPort', "5222")
ec.set(self.node1, 'xmppPassword', "1234")
self.iface1 = ec.register_resource("omf::WifiInterface")
ec.set(self.iface1, 'name', "wlan0")
ec.set(self.iface1, 'mode', "adhoc")
ec.set(self.iface1, 'hw_mode', "g")
ec.set(self.iface1, 'essid', "vlcexp")
ec.set(self.iface1, 'ip', "10.0.0.17/24")
self.channel = ec.register_resource("omf::Channel")
ec.set(self.channel, 'channel', "6")
ec.set(self.channel, 'xmppUser', "nepi")
ec.set(self.channel, 'xmppServer', "xmpp-plexus.onelab.eu")
ec.set(self.channel, 'xmppPort', "5222")
ec.set(self.channel, 'xmppPassword', "1234")
self.app1 = ec.register_resource("omf::Application")
ec.set(self.app1, 'appid', 'Vlc#1')
ec.set(self.app1, 'command', "ping -c5 10.0.0.17")
ec.register_connection(self.app1, self.node1)
ec.register_connection(self.node1, self.iface1)
ec.register_connection(self.iface1, self.channel)
ec.register_condition(self.app1, ResourceAction.STOP, self.app1,
ResourceState.STARTED, "10s")
ec.deploy()
ec.wait_finished(self.app1)
stdout_1 = ec.trace(self.app1, "stdout")
stderr_1 = ec.trace(self.app1, "stderr")
if stdout_1:
f = open("app1_out.txt", "w")
f.write(stdout_1)
f.close()
if stderr_1:
f = open("app1_err.txt", "w")
f.write(stderr_1)
f.close()
self.assertEquals(
ec.get_resource(self.node1).state, ResourceState.STARTED)
self.assertEquals(
ec.get_resource(self.iface1).state, ResourceState.STARTED)
self.assertEquals(
ec.get_resource(self.channel).state, ResourceState.STARTED)
self.assertEquals(
ec.get_resource(self.app1).state, ResourceState.STOPPED)
ec.shutdown()
self.assertEquals(
ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
ec.get_resource(self.app1).state, ResourceState.RELEASED)
t = open("app1_out.txt", "r")
l = t.readlines()
self.assertEquals(
l[0], "PING 10.0.0.17 (10.0.0.17) 56(84) bytes of data.\n")
self.assertIn(
"5 packets transmitted, 5 received, 0% packet loss, time", l[-2])
self.assertIn("rtt min/avg/max/mdev = ", l[-1])
t.close()
os.remove("app1_out.txt")
queue = ec.register_resource("ns3::DropTailQueue")
ec.register_connection(dev, queue)
return dev
ec = ExperimentController(exp_id="dce-custom-ccn")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", "localhost")
ec.set(node, "cleanProcesses", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
dev1 = add_device(ec, nsnode1, "10.0.0.1", "30")
ec.set(dev1, "DataRate", "5Mbps")
nsnode2 = add_ns3_node(ec, simu)
dev2 = add_device(ec, nsnode2, "10.0.0.2", "30")
ec.set(dev2, "DataRate", "5Mbps")
# Create channel
chan = ec.register_resource("ns3::PointToPointChannel")
ec.set(chan, "Delay", "2ms")
ec.register_connection(chan, dev1)
ec.register_connection(chan, dev2)
ssh_key = "~/.ssh/id_rsa" #source_file = "/home/deimos/GeoCloudResources/E2E_0Gerardo.bin" #file that client will send target_file = "data.txt" port = 20004 seconds = 43200 seconds = 3600 #1 h nodes = [] apps = [] command_server = "timeout %dm iperf -s -f m -i 1 -p %d " %((seconds/60)+5,port)#the timeout takes in advantage to 5 minutes #Creates the BonFIRE node and the application is added bonfire_node = create_node(ec,slice,pleuser,plepass,hostname=bonfire_host[1]) app_bonfire = create_app(ec,command_server,dependencies="iperf") ec.register_connection(app_bonfire,bonfire_node) apps.append(app_bonfire) node_app=dict() #print "Deployed nodes: ",nodes for host in hosts: node = create_node(ec,slice,pleuser,plepass,hostname=hosts[host],country=host) nodes.append(node) command_client = "iperf -i 1 -f m -c %s -t %d -p %d -y c > node%d.out " % (bonfire_host[1],seconds,port,node) app = create_app(ec,command_client,dependencies="iperf") ec.register_connection(app,node) #The app will be started once the app_bf application is running apps.append(app) node_app[node] = app
def t_dce_ping(self, host, user=None, identity=None):
ec = ExperimentController(exp_id="test-dce-ping-app")
node = ec.register_resource("linux::Node")
if host == "localhost":
ec.set(node, "hostname", host)
else:
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanHome", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.set(simu, "buildMode", "debug")
ec.set(simu, "nsLog", "DceApplication")
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
p2p1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
ec.set(p2p1, "DataRate", "5Mbps")
nsnode2 = add_ns3_node(ec, simu)
p2p2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
ec.set(p2p2, "DataRate", "5Mbps")
# Create channel
chan = ec.register_resource("ns3::PointToPointChannel")
ec.set(chan, "Delay", "2ms")
ec.register_connection(chan, p2p1)
ec.register_connection(chan, p2p2)
### create applications
ping = ec.register_resource("linux::ns3::dce::Ping")
ec.set(ping, "stackSize", 1 << 20)
ec.set(ping, "target", "10.0.0.2")
ec.set(ping, "count", "10")
ec.set(ping, "packetSize", "1000")
ec.set(ping, "StartTime", "1s")
ec.set(ping, "StopTime", "20s")
ec.register_connection(ping, nsnode1)
ec.deploy()
ec.wait_finished([ping])
expected = "ping -c 10 -s 1000 10.0.0.2"
cmdline = ec.trace(ping, "cmdline")
self.assertTrue(cmdline.find(expected) > -1, cmdline)
expected = "Start Time: NS3 Time: 1s ("
status = ec.trace(ping, "status")
self.assertTrue(status.find(expected) > -1, status)
expected = "10 packets transmitted, 10 received, 0% packet loss, time 9002ms"
stdout = ec.trace(ping, "stdout")
self.assertTrue(stdout.find(expected) > -1, stdout)
stderr = ec.trace(simu, "stderr")
expected = "DceApplication:StartApplication"
self.assertTrue(stderr.find(expected) > -1, stderr)
ec.shutdown()
def test_deploy(self):
ec = ExperimentController(exp_id="5421")
self.node1 = ec.register_resource("omf::Node")
ec.set(self.node1, 'hostname', 'wlab12')
ec.set(self.node1, 'xmppUser', "nepi")
ec.set(self.node1, 'xmppServer', "xmpp-plexus.onelab.eu")
ec.set(self.node1, 'xmppPort', "5222")
ec.set(self.node1, 'xmppPassword', "1234")
self.iface1 = ec.register_resource("omf::WifiInterface")
ec.set(self.iface1, 'name', "wlan0")
ec.set(self.iface1, 'mode', "adhoc")
ec.set(self.iface1, 'hw_mode', "g")
ec.set(self.iface1, 'essid', "vlcexp")
ec.set(self.iface1, 'ip', "10.0.0.17/24")
self.channel = ec.register_resource("omf::Channel")
ec.set(self.channel, 'channel', "6")
ec.set(self.channel, 'xmppUser', "nepi")
ec.set(self.channel, 'xmppServer', "xmpp-plexus.onelab.eu")
ec.set(self.channel, 'xmppPort', "5222")
ec.set(self.channel, 'xmppPassword', "1234")
self.app1 = ec.register_resource("omf::Application")
ec.set(self.app1, 'appid', 'Vlc#1')
ec.set(
self.app1, 'command',
"/opt/vlc-1.1.13/cvlc /opt/10-by-p0d.avi --sout '#rtp{dst=10.0.0.37,port=1234,mux=ts}'"
)
ec.set(self.app1, 'env',
"DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority")
self.app2 = ec.register_resource("omf::Application")
ec.set(self.app2, 'appid', 'Test#1')
ec.set(self.app2, 'command', "/usr/bin/test -1")
ec.set(self.app2, 'env', " ")
self.app3 = ec.register_resource("omf::Application")
ec.set(self.app3, 'appid', 'Test#2')
ec.set(self.app3, 'command', "/usr/bin/test -2")
ec.set(self.app3, 'env', " ")
self.app4 = ec.register_resource("omf::Application")
ec.set(self.app4, 'appid', 'Test#3')
ec.set(self.app4, 'command', "/usr/bin/test -3")
ec.set(self.app4, 'env', " ")
self.app5 = ec.register_resource("omf::Application")
ec.set(self.app5, 'appid', 'Kill#2')
ec.set(self.app5, 'command', "/usr/bin/killall vlc")
ec.set(self.app5, 'env', " ")
ec.register_connection(self.app1, self.node1)
ec.register_connection(self.app2, self.node1)
ec.register_connection(self.app3, self.node1)
ec.register_connection(self.app4, self.node1)
ec.register_connection(self.app5, self.node1)
ec.register_connection(self.node1, self.iface1)
ec.register_connection(self.iface1, self.channel)
ec.register_condition(self.app2, ResourceAction.START, self.app1,
ResourceState.STARTED, "3s")
ec.register_condition(self.app3, ResourceAction.START, self.app2,
ResourceState.STARTED, "2s")
ec.register_condition(self.app4, ResourceAction.START, self.app3,
ResourceState.STARTED, "3s")
ec.register_condition(self.app5, ResourceAction.START,
[self.app3, self.app2], ResourceState.STARTED,
"2s")
ec.register_condition(self.app5, ResourceAction.START, self.app1,
ResourceState.STARTED, "25s")
ec.register_condition(
[self.app1, self.app2, self.app3, self.app4, self.app5],
ResourceAction.STOP, self.app5, ResourceState.STARTED, "1s")
ec.deploy()
ec.wait_finished(
[self.app1, self.app2, self.app3, self.app4, self.app5])
self.assertGreaterEqual(
round(
tdiffsec(
ec.get_resource(self.app2).start_time,
ec.get_resource(self.app1).start_time), 0), 3.0)
self.assertGreaterEqual(
round(
tdiffsec(
ec.get_resource(self.app3).start_time,
ec.get_resource(self.app2).start_time), 0), 2.0)
self.assertGreaterEqual(
round(
tdiffsec(
ec.get_resource(self.app4).start_time,
ec.get_resource(self.app3).start_time), 0), 3.0)
self.assertGreaterEqual(
round(
tdiffsec(
ec.get_resource(self.app5).start_time,
ec.get_resource(self.app3).start_time), 0), 2.0)
self.assertGreaterEqual(
round(
tdiffsec(
ec.get_resource(self.app5).start_time,
ec.get_resource(self.app1).start_time), 0), 25.0)
self.assertEquals(
ec.get_resource(self.node1).state, ResourceState.STARTED)
self.assertEquals(
ec.get_resource(self.iface1).state, ResourceState.STARTED)
self.assertEquals(
ec.get_resource(self.channel).state, ResourceState.STARTED)
self.assertEquals(
ec.get_resource(self.app1).state, ResourceState.STOPPED)
self.assertEquals(
ec.get_resource(self.app2).state, ResourceState.STOPPED)
self.assertEquals(
ec.get_resource(self.app3).state, ResourceState.STOPPED)
self.assertEquals(
ec.get_resource(self.app4).state, ResourceState.STOPPED)
self.assertEquals(
ec.get_resource(self.app5).state, ResourceState.STOPPED)
ec.shutdown()
self.assertEquals(
ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
ec.get_resource(self.app1).state, ResourceState.RELEASED)
self.assertEquals(
ec.get_resource(self.app2).state, ResourceState.RELEASED)
self.assertEquals(
ec.get_resource(self.app3).state, ResourceState.RELEASED)
self.assertEquals(
ec.get_resource(self.app4).state, ResourceState.RELEASED)
self.assertEquals(
ec.get_resource(self.app5).state, ResourceState.RELEASED)
def t_dce_ping(self, host, user=None, identity=None):
ec = ExperimentController(exp_id="test-dce-ping")
node = ec.register_resource("linux::Node")
if host == "localhost":
ec.set(node, "hostname", host)
else:
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanExperiment", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.set(simu, "buildMode", "debug")
ec.set(simu, "nsLog", "DceApplication")
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
p2p1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
ec.set(p2p1, "DataRate", "5Mbps")
nsnode2 = add_ns3_node(ec, simu)
p2p2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
ec.set(p2p2, "DataRate", "5Mbps")
# Create channel
chan = ec.register_resource("ns3::PointToPointChannel")
ec.set(chan, "Delay", "2ms")
ec.register_connection(chan, p2p1)
ec.register_connection(chan, p2p2)
### create applications
ping = ec.register_resource("linux::ns3::dce::Application")
ec.set(ping, "sources",
"http://www.skbuff.net/iputils/iputils-s20101006.tar.bz2")
ec.set(
ping, "build", "tar xvjf ${SRC}/iputils-s20101006.tar.bz2 && "
"cd iputils-s20101006/ && "
"sed -i 's/CFLAGS=/CFLAGS+=/g' Makefile && "
"make CFLAGS=-fPIC LDFLAGS='-pie -rdynamic' ping && "
"cp ping ${BIN_DCE} && cd - ")
ec.set(ping, "binary", "ping")
ec.set(ping, "stackSize", 1 << 20)
ec.set(ping, "arguments", "-c 10;-s 1000;10.0.0.2")
ec.set(ping, "StartTime", "1s")
ec.set(ping, "StopTime", "20s")
ec.register_connection(ping, nsnode1)
ec.deploy()
ec.wait_finished([ping])
expected = "ping -c 10 -s 1000 10.0.0.2"
cmdline = ec.trace(ping, "cmdline")
self.assertTrue(cmdline.find(expected) > -1, cmdline)
expected = "Start Time: NS3 Time: 1s ("
status = ec.trace(ping, "status")
self.assertTrue(status.find(expected) > -1, status)
expected = "10 packets transmitted, 10 received, 0% packet loss, time 9002ms"
stdout = ec.trace(ping, "stdout")
self.assertTrue(stdout.find(expected) > -1, stdout)
stderr = ec.trace(simu, "stderr")
expected = "DceApplication:StartApplication"
self.assertTrue(stderr.find(expected) > -1, stderr)
ec.shutdown()
class OMFEachTestCase(unittest.TestCase):
def setUp(self):
self.ec = ExperimentController(exp_id="99999")
self.node1 = self.ec.register_resource("omf::Node")
self.ec.set(self.node1, 'hostname', 'wlab12')
self.ec.set(self.node1, 'xmppUser', "nepi")
self.ec.set(self.node1, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.node1, 'xmppPort', "5222")
self.ec.set(self.node1, 'xmppPassword', "1234")
self.iface1 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.iface1, 'name', "wlan0")
self.ec.set(self.iface1, 'mode', "adhoc")
self.ec.set(self.iface1, 'hw_mode', "g")
self.ec.set(self.iface1, 'essid', "vlcexp")
self.ec.set(self.iface1, 'ip', "10.0.0.17/24")
self.channel = self.ec.register_resource("omf::Channel")
self.ec.set(self.channel, 'channel', "6")
self.ec.set(self.channel, 'xmppUser', "nepi")
self.ec.set(self.channel, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.channel, 'xmppPort', "5222")
self.ec.set(self.channel, 'xmppPassword', "1234")
self.app1 = self.ec.register_resource("omf::Application")
self.ec.set(self.app1, 'appid', 'Vlc#1')
self.ec.set(
self.app1, 'command',
"/opt/vlc-1.1.13/cvlc /opt/10-by-p0d.avi --sout '#rtp{dst=10.0.0.37,port=1234,mux=ts}'"
)
self.ec.set(self.app1, 'env',
"DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority")
self.app2 = self.ec.register_resource("omf::Application")
self.app3 = self.ec.register_resource("omf::Application")
self.app4 = self.ec.register_resource("omf::Application")
self.app5 = self.ec.register_resource("omf::Application")
self.ec.register_connection(self.app1, self.node1)
self.ec.register_connection(self.app2, self.node1)
self.ec.register_connection(self.app3, self.node1)
self.ec.register_connection(self.app4, self.node1)
self.ec.register_connection(self.app5, self.node1)
self.ec.register_connection(self.node1, self.iface1)
self.ec.register_connection(self.iface1, self.channel)
self.ec.register_condition(self.app2, ResourceAction.START, self.app1,
ResourceState.STARTED, "3s")
self.ec.register_condition(self.app3, ResourceAction.START, self.app2,
ResourceState.STARTED, "2s")
self.ec.register_condition(self.app4, ResourceAction.START, self.app3,
ResourceState.STARTED, "3s")
self.ec.register_condition(self.app5, ResourceAction.START,
[self.app3, self.app2],
ResourceState.STARTED, "2s")
self.ec.register_condition(self.app5, ResourceAction.START, self.app1,
ResourceState.STARTED, "25s")
self.ec.register_condition(
[self.app1, self.app2, self.app3, self.app4, self.app5],
ResourceAction.STOP, self.app5, ResourceState.STARTED, "1s")
def tearDown(self):
self.ec.shutdown()
def test_creation_and_configuration_node(self):
self.assertEquals(self.ec.get(self.node1, 'hostname'), 'wlab12')
self.assertEquals(self.ec.get(self.node1, 'xmppUser'), 'nepi')
self.assertEquals(self.ec.get(self.node1, 'xmppServer'),
'xmpp-plexus.onelab.eu')
self.assertEquals(self.ec.get(self.node1, 'xmppPort'), '5222')
self.assertEquals(self.ec.get(self.node1, 'xmppPassword'), '1234')
self.assertEquals(self.ec.get(self.node1, 'version'), '6')
def test_creation_and_configuration_interface(self):
self.assertEquals(self.ec.get(self.iface1, 'name'), 'wlan0')
self.assertEquals(self.ec.get(self.iface1, 'mode'), 'adhoc')
self.assertEquals(self.ec.get(self.iface1, 'hw_mode'), 'g')
self.assertEquals(self.ec.get(self.iface1, 'essid'), 'vlcexp')
self.assertEquals(self.ec.get(self.iface1, 'ip'), '10.0.0.17/24')
self.assertEquals(self.ec.get(self.iface1, 'version'), '6')
def test_creation_and_configuration_channel(self):
self.assertEquals(self.ec.get(self.channel, 'channel'), '6')
self.assertEquals(self.ec.get(self.channel, 'xmppUser'), 'nepi')
self.assertEquals(self.ec.get(self.channel, 'xmppServer'),
'xmpp-plexus.onelab.eu')
self.assertEquals(self.ec.get(self.channel, 'xmppPort'), '5222')
self.assertEquals(self.ec.get(self.channel, 'xmppPassword'), '1234')
self.assertEquals(self.ec.get(self.channel, 'version'), '6')
def test_creation_and_configuration_application(self):
self.assertEquals(self.ec.get(self.app1, 'appid'), 'Vlc#1')
self.assertEquals(
self.ec.get(self.app1, 'command'),
"/opt/vlc-1.1.13/cvlc /opt/10-by-p0d.avi --sout '#rtp{dst=10.0.0.37,port=1234,mux=ts}'"
)
self.assertEquals(
self.ec.get(self.app1, 'env'),
'DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority')
self.assertEquals(self.ec.get(self.app1, 'version'), '6')
def test_connection(self):
self.assertEquals(len(self.ec.get_resource(self.node1).connections), 6)
self.assertEquals(len(self.ec.get_resource(self.iface1).connections),
2)
self.assertEquals(len(self.ec.get_resource(self.channel).connections),
1)
self.assertEquals(len(self.ec.get_resource(self.app1).connections), 1)
self.assertEquals(len(self.ec.get_resource(self.app2).connections), 1)
def test_condition(self):
self.assertEquals(
len(
self.ec.get_resource(
self.app1).conditions[ResourceAction.STOP]), 1)
self.assertEquals(
len(
self.ec.get_resource(
self.app2).conditions[ResourceAction.START]), 1)
self.assertEquals(
len(
self.ec.get_resource(
self.app3).conditions[ResourceAction.START]), 1)
self.assertEquals(
len(
self.ec.get_resource(
self.app4).conditions[ResourceAction.STOP]), 1)
self.assertEquals(
len(
self.ec.get_resource(
self.app5).conditions[ResourceAction.START]), 2)
def t_dce_ccn(self, host, user=None, identity=None):
ec = ExperimentController(exp_id="test-dce-ccn")
node = ec.register_resource("linux::Node")
if host == "localhost":
ec.set(node, "hostname", host)
else:
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
#ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanHome", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.set(simu, "buildMode", "debug")
ec.set(simu, "nsLog", "DceApplication")
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
p2p1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
ec.set(p2p1, "DataRate", "5Mbps")
nsnode2 = add_ns3_node(ec, simu)
p2p2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
ec.set(p2p2, "DataRate", "5Mbps")
# Create channel
chan = ec.register_resource("ns3::PointToPointChannel")
ec.set(chan, "Delay", "2ms")
ec.register_connection(chan, p2p1)
ec.register_connection(chan, p2p2)
### create applications
ccnd1 = ec.register_resource("linux::ns3::dce::CCNApplication")
if host == self.fedora_host:
depends = (" autoconf openssl-devel expat-devel libpcap-devel "
" ecryptfs-utils-devel libxml2-devel automake gawk "
" gcc gcc-c++ git pcre-devel make ")
else: # UBUNTU
# NOTE THAT INSTALLATION MIGHT FAIL IF openjdk-6-jdk is not installed
depends = (
"libpcap0.8-dev openjdk-6-jdk ant1.8 autoconf "
"libssl-dev libexpat-dev libpcap-dev libecryptfs0 libxml2-utils auto"
"make gawk gcc g++ git-core pkg-config libpcre3-dev openjdk-6-jre-lib"
)
ec.set(ccnd1, "depends", depends)
ec.set(ccnd1, "sources",
"http://www.ccnx.org/releases/ccnx-0.7.2.tar.gz")
ec.set(
ccnd1, "build", "tar zxf ${SRC}/ccnx-0.7.2.tar.gz && "
"cd ccnx-0.7.2 && "
" INSTALL_BASE=${BIN_DCE}/.. ./configure && "
" make MORE_LDLIBS='-pie -rdynamic' && "
" make install && "
" cp ${BIN_DCE}/../bin/ccn* ${BIN_DCE} && "
" cd -")
ec.set(ccnd1, "binary", "ccnd")
ec.set(ccnd1, "stackSize", 1 << 20)
ec.set(ccnd1, "environment", "CCND_CAP=50000; CCND_DEBUG=7")
ec.set(ccnd1, "StartTime", "1s")
ec.set(ccnd1, "StopTime", "20s")
ec.register_connection(ccnd1, nsnode1)
repofile = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"ccn", "repoFile1")
ccnr = ec.register_resource("linux::ns3::dce::CCNApplication")
ec.set(ccnr, "binary", "ccnr")
ec.set(ccnr, "environment", "CCNR_DIRECTORY=/REPO/")
ec.set(ccnr, "files", "%s=/REPO/repoFile1" % repofile)
ec.set(ccnr, "stackSize", 1 << 20)
ec.set(ccnr, "StartTime", "2s")
ec.set(ccnr, "StopTime", "120s")
ec.register_connection(ccnr, nsnode1)
ccndc1 = ec.register_resource("linux::ns3::dce::CCNApplication")
ec.set(ccndc1, "binary", "ccndc")
ec.set(ccndc1, "arguments", "-v;add;ccnx:/;udp;10.0.0.2")
ec.set(ccndc1, "stackSize", 1 << 20)
ec.set(ccndc1, "StartTime", "2s")
ec.set(ccndc1, "StopTime", "120s")
ec.register_connection(ccndc1, nsnode1)
ccnd2 = ec.register_resource("linux::ns3::dce::CCNApplication")
ec.set(ccnd2, "binary", "ccnd")
ec.set(ccnd2, "stackSize", 1 << 20)
ec.set(ccnd2, "environment", "CCND_CAP=50000; CCND_DEBUG=7")
ec.set(ccnd2, "StartTime", "1s")
ec.set(ccnd2, "StopTime", "120s")
ec.register_connection(ccnd2, nsnode2)
ccndc2 = ec.register_resource("linux::ns3::dce::CCNApplication")
ec.set(ccndc2, "binary", "ccndc")
ec.set(ccndc2, "arguments", "-v;add;ccnx:/;udp;10.0.0.1")
ec.set(ccndc2, "stackSize", 1 << 20)
ec.set(ccndc2, "StartTime", "2s")
ec.set(ccndc2, "StopTime", "120s")
ec.register_connection(ccndc2, nsnode2)
ccnpeek = ec.register_resource("linux::ns3::dce::CCNApplication")
ec.set(ccnpeek, "binary", "ccnpeek")
ec.set(ccnpeek, "arguments", "ccnx:/test/bunny.ts")
ec.set(ccnpeek, "stdinFile", "")
ec.set(ccnpeek, "stackSize", 1 << 20)
ec.set(ccnpeek, "StartTime", "4s")
ec.set(ccnpeek, "StopTime", "120s")
ec.register_connection(ccnpeek, nsnode2)
ccncat = ec.register_resource("linux::ns3::dce::CCNApplication")
ec.set(ccncat, "binary", "ccncat")
ec.set(ccncat, "arguments", "ccnx:/test/bunny.ts")
ec.set(ccncat, "stdinFile", "")
ec.set(ccncat, "stackSize", 1 << 20)
ec.set(ccncat, "StartTime", "4s")
ec.set(ccncat, "StopTime", "120s")
ec.register_connection(ccncat, nsnode2)
ec.deploy()
ec.wait_finished([ccncat])
expected = "ccncat ccnx:/test/bunny.ts"
cmdline = ec.trace(ccncat, "cmdline")
self.assertTrue(cmdline.find(expected) > -1, cmdline)
expected = "Start Time: NS3 Time: 4s ("
status = ec.trace(ccncat, "status")
self.assertTrue(status.find(expected) > -1, status)
expected = 2873956
stdout = ec.trace(ccncat, "stdout")
self.assertTrue(len(stdout) == expected, stdout)
ec.shutdown()
# Create and Configure the Nodes
node1 = ec.register_resource("omf::Node")
ec.set(node1, "hostname", nodex)
ec.set(node1, "xmppUser", slicename)
ec.set(node1, "xmppServer", "nitlab.inf.uth.gr")
ec.set(node1, "xmppPort", "5222")
ec.set(node1, "xmppPassword", "1234")
# Create and Configure the Interfaces
iface1 = ec.register_resource("omf::WifiInterface")
ec.set(iface1, "name", "wlan0")
ec.set(iface1, "mode", "adhoc")
ec.set(iface1, "hw_mode", "g")
ec.set(iface1, "essid", "vlc")
ec.set(iface1, "ip", "192.168.0.%s/24" % nodex[-2:])
ec.register_connection(node1, iface1)
# Create and Configure the Nodes
node2 = ec.register_resource("omf::Node")
ec.set(node2, "hostname", nodez)
ec.set(node2, "xmppUser", slicename)
ec.set(node2, "xmppServer", "nitlab.inf.uth.gr")
ec.set(node2, "xmppPort", "5222")
ec.set(node2, "xmppPassword", "1234")
# Create and Configure the Interfaces
iface2 = ec.register_resource("omf::WifiInterface")
ec.set(iface2, "name", "wlan0")
ec.set(iface2, "mode", "adhoc")
ec.set(iface2, "hw_mode", "g")
ec.set(iface2, "essid", "vlc")
def t_dce_ccn(self, host, user = None, identity = None):
ec = ExperimentController(exp_id = "test-dce-ccn-app")
node = ec.register_resource("linux::Node")
if host == "localhost":
ec.set(node, "hostname", host)
else:
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanHome", True)
simu = ec.register_resource("linux::ns3::Simulation")
#ec.set(simu, "verbose", True)
#ec.set(simu, "buildMode", "debug")
#ec.set(simu, "nsLog", "DceApplication")
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
p2p1 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
ec.set(p2p1, "DataRate", "5Mbps")
nsnode2 = add_ns3_node(ec, simu)
p2p2 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
ec.set(p2p2, "DataRate", "5Mbps")
# Create channel
chan = ec.register_resource("ns3::PointToPointChannel")
ec.set(chan, "Delay", "2ms")
ec.register_connection(chan, p2p1)
ec.register_connection(chan, p2p2)
### create applications
ccnd1 = ec.register_resource("linux::ns3::dce::CCND")
ec.set (ccnd1, "stackSize", 1<<20)
ec.set (ccnd1, "debug", 7)
ec.set (ccnd1, "capacity", 50000)
ec.set (ccnd1, "StartTime", "1s")
ec.set (ccnd1, "StopTime", "20s")
ec.register_connection(ccnd1, nsnode1)
repofile = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
"repoFile1")
ccnr = ec.register_resource("linux::ns3::dce::CCNR")
ec.set (ccnr, "repoFile1", repofile)
ec.set (ccnr, "stackSize", 1<<20)
ec.set (ccnr, "StartTime", "2s")
ec.set (ccnr, "StopTime", "120s")
ec.register_connection(ccnr, nsnode1)
ccndc1 = ec.register_resource("linux::ns3::dce::FIBEntry")
ec.set (ccndc1, "protocol", "udp")
ec.set (ccndc1, "uri", "ccnx:/")
ec.set (ccndc1, "host", "10.0.0.2")
ec.set (ccndc1, "stackSize", 1<<20)
ec.set (ccndc1, "StartTime", "2s")
ec.set (ccndc1, "StopTime", "120s")
ec.register_connection(ccndc1, nsnode1)
ccnd2 = ec.register_resource("linux::ns3::dce::CCND")
ec.set (ccnd2, "stackSize", 1<<20)
ec.set (ccnd2, "debug", 7)
ec.set (ccnd2, "capacity", 50000)
ec.set (ccnd2, "StartTime", "1s")
ec.set (ccnd2, "StopTime", "20s")
ec.register_connection(ccnd2, nsnode2)
ccndc2 = ec.register_resource("linux::ns3::dce::FIBEntry")
ec.set (ccndc2, "protocol", "udp")
ec.set (ccndc2, "uri", "ccnx:/")
ec.set (ccndc2, "host", "10.0.0.1")
ec.set (ccndc2, "stackSize", 1<<20)
ec.set (ccndc2, "StartTime", "2s")
ec.set (ccndc2, "StopTime", "120s")
ec.register_connection(ccndc2, nsnode2)
ccnpeek = ec.register_resource("linux::ns3::dce::CCNPeek")
ec.set (ccnpeek, "contentName", "ccnx:/test/bunny.ts")
ec.set (ccnpeek, "stackSize", 1<<20)
ec.set (ccnpeek, "StartTime", "4s")
ec.set (ccnpeek, "StopTime", "120s")
ec.register_connection(ccnpeek, nsnode2)
ccncat = ec.register_resource("linux::ns3::dce::CCNCat")
ec.set (ccncat, "contentName", "ccnx:/test/bunny.ts")
ec.set (ccncat, "stackSize", 1<<20)
ec.set (ccncat, "StartTime", "4s")
ec.set (ccncat, "StopTime", "120s")
ec.register_connection(ccncat, nsnode2)
ec.deploy()
ec.wait_finished([ccncat])
expected = "ccncat ccnx:/test/bunny.ts"
cmdline = ec.trace(ccncat, "cmdline")
self.assertTrue(cmdline.find(expected) > -1, cmdline)
expected = "Start Time: NS3 Time: 4s ("
status = ec.trace(ccncat, "status")
self.assertTrue(status.find(expected) > -1, status)
expected = 2873956
stdout = ec.trace(ccncat, "stdout")
self.assertTrue(len(stdout) == expected , stdout)
ec.shutdown()
ec.set(iface2, 'essid', "vlc")
ec.set(iface2, 'ip', "192.168.0.27/24")
chan = ec.register_resource("omf::Channel")
ec.set(chan, 'channel', "6")
# Create and Configure the Application
app1 = ec.register_resource("omf::Application")
ec.set(app1, 'command', "DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority /root/vlc/vlc-1.1.13/cvlc /root/10-by-p0d.avi --sout '#rtp{dst=192.168.0.27,port=1234,mux=ts}'")
app2 = ec.register_resource("omf::Application")
ec.set(app2, 'command', "DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority /root/vlc/vlc-1.1.13/cvlc rtp://192.168.0.27:1234")
# Connection
ec.register_connection(iface1, node1)
ec.register_connection(iface2, node2)
ec.register_connection(iface1, chan)
ec.register_connection(iface2, chan)
ec.register_connection(app1, node1)
ec.register_connection(app2, node2)
ec.register_condition([app2], ResourceAction.START, app1, ResourceState.STARTED , "4s")
ec.register_condition([app1,app2], ResourceAction.STOP, app2, ResourceState.STARTED , "30s")
# Deploy
ec.deploy()
ec.wait_finished([app1,app2])
def t_condition_serialize(self, host, user, depends):
dirpath = tempfile.mkdtemp()
ec = ExperimentController(exp_id="test-condition-serial")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
server = ec.register_resource("linux::Application")
cmd = "echo 'HOLA' | nc -l 3333"
ec.set(server, "command", cmd)
ec.set(server, "depends", depends)
ec.register_connection(server, node)
client = ec.register_resource("linux::Application")
cmd = "nc 127.0.0.1 3333"
ec.set(client, "command", cmd)
ec.register_connection(client, node)
ec.register_condition(client, ResourceAction.START, server,
ResourceState.STARTED)
apps = [client, server]
filepath = ec.save(dirpath)
ec.deploy()
ec.wait_finished(apps)
self.assertTrue(ec.state(node) == ResourceState.STARTED)
self.assertTrue(ec.state(server) == ResourceState.STOPPED)
self.assertTrue(ec.state(client) == ResourceState.STOPPED)
stdout = ec.trace(client, "stdout")
self.assertTrue(stdout.strip() == "HOLA")
ec.shutdown()
# Load serialized experiment
ec2 = ExperimentController.load(filepath)
ec2.deploy()
ec2.wait_finished(apps)
self.assertEquals(len(ec.resources), len(ec2.resources))
self.assertTrue(ec2.state(node) == ResourceState.STARTED)
self.assertTrue(ec2.state(server) == ResourceState.STOPPED)
self.assertTrue(ec2.state(client) == ResourceState.STOPPED)
stdout = ec2.trace(client, "stdout")
self.assertTrue(stdout.strip() == "HOLA")
ec2.shutdown()
shutil.rmtree(dirpath)
ec.set(node2, "country", "Spain")
ec.set(node2, "username", slicename)
ec.set(node2, "pluser", pl_user)
ec.set(node2, "plpassword", pl_password)
ec.set(node2, "cleanHome", True)
ec.set(node2, "cleanProcesses", True)
remote_hostname = ec.get_attribute(node1, "hostname")
destination = "%s@%s" % (slicename, remote_hostname)
app1 = ec.register_resource("LinuxApplication")
file = "../big_file.geo"
ec.set(app1, "sources", file)
command = "scp $SRC/big_file.geo %s" % destination
ec.set(app1, "command", command)
ec.register_connection(app1, node1)
app2 = ec.register_resource("LinuxApplication")
ec.set(app, "sudo", sudo)
ec.set(app, "depends", "ifstat")
command = "ifstat -b eth0 > ifstat.txt"
command = "iperf ..."
ec.set(app2, "command", command)
ec.register_connection(app2, node1)
ec.register_condition(app2, ResourceAction.START, app1, ResourceState.STARTED)
# Deploy
ec.deploy()
ec.wait_finished([app1, app2])
def t_wifi_serialize(self, host, user=None, identity=None):
bounds_width = bounds_height = 200
x = y = 100
speed = 1
dirpath = tempfile.mkdtemp()
ec = ExperimentController(exp_id="test-ns3-wifi-ping")
node = ec.register_resource("linux::Node")
if host == "localhost":
ec.set(node, "hostname", "localhost")
else:
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanHome", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
dev1, phy1 = add_wifi_device(ec,
nsnode1,
"10.0.0.1",
"24",
access_point=True)
mobility1 = add_constant_mobility(ec, nsnode1, x, y, 0)
nsnode2 = add_ns3_node(ec, simu)
dev2, phy2 = add_wifi_device(ec,
nsnode2,
"10.0.0.2",
"24",
access_point=False)
mobility1 = add_constant_mobility(ec, nsnode2, x, y, 0)
#mobility2 = add_random_mobility(ec, nsnode2, x, y, 0, speed, bounds_width, bounds_height)
# Create channel
chan = add_wifi_channel(ec)
ec.register_connection(chan, phy1)
ec.register_connection(chan, phy2)
### create pinger
ping = ec.register_resource("ns3::V4Ping")
ec.set(ping, "Remote", "10.0.0.1")
ec.set(ping, "Interval", "1s")
ec.set(ping, "Verbose", True)
ec.set(ping, "StartTime", "1s")
ec.set(ping, "StopTime", "21s")
ec.register_connection(ping, nsnode2)
filepath = ec.save(dirpath)
print filepath
ec.deploy()
ec.wait_finished([ping])
stdout = ec.trace(simu, "stdout")
expected = "20 packets transmitted, 20 received, 0% packet loss"
self.assertTrue(stdout.find(expected) > -1)
ec.shutdown()
# Load serialized experiment
ec2 = ExperimentController.load(filepath)
ec2.deploy()
ec2.wait_finished([ping])
self.assertEquals(len(ec.resources), len(ec2.resources))
stdout = ec2.trace(simu, "stdout")
expected = "20 packets transmitted, 20 received, 0% packet loss"
self.assertTrue(stdout.find(expected) > -1)
ec2.shutdown()
shutil.rmtree(dirpath)
class OMFVLCWrongCaseWithNonCritical(unittest.TestCase):
id = 2000
def setUp(self):
self.ec = ExperimentController(
exp_id=str(OMFVLCWrongCaseWithNonCritical.id))
OMFVLCWrongCaseWithNonCritical.id += 1
self.node1 = self.ec.register_resource("omf::Node")
self.ec.set(self.node1, 'hostname', 'omf.plexus.wlab17')
self.ec.set(self.node1, 'xmppUser', "nepi")
self.ec.set(self.node1, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.node1, 'xmppPort', "5222")
self.ec.set(self.node1, 'xmppPassword', "1234")
self.ec.set(self.node1, 'version', "5")
self.iface1 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.iface1, 'name', "wlan0")
self.ec.set(self.iface1, 'mode', "adhoc")
self.ec.set(self.iface1, 'hw_mode', "g")
self.ec.set(self.iface1, 'essid', "vlcexp")
self.ec.set(self.iface1, 'ip', "10.0.0.17/24")
self.ec.set(self.iface1, 'version', "5")
self.app1 = self.ec.register_resource("omf::Application")
self.ec.set(self.app1, 'appid', 'Kill#1')
self.ec.set(self.app1, 'command', "/usr/bin/test -1")
self.ec.set(self.app1, 'env',
"DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority")
self.ec.set(self.app1, 'version', "5")
self.ec.register_connection(self.app1, self.node1)
self.ec.register_connection(self.node1, self.iface1)
def test_deploy_with_node_nc(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.set(self.node2, "critical", False)
self.ec.set(self.node2, 'version', "5")
self.iface2 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.iface2, 'name', "wlan0")
self.ec.set(self.iface2, 'mode', "adhoc")
self.ec.set(self.iface2, 'hw_mode', "g")
self.ec.set(self.iface2, 'essid', "vlcexp")
self.ec.set(self.iface2, 'ip', "10.0.0.37/24")
self.ec.set(self.iface2, 'version', "5")
self.channel = self.ec.register_resource("omf::Channel")
self.ec.set(self.channel, 'channel', "6")
self.ec.set(self.channel, 'xmppUser', "nepi")
self.ec.set(self.channel, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.channel, 'xmppPort', "5222")
self.ec.set(self.channel, 'xmppPassword', "1234")
self.ec.set(self.channel, 'version', "5")
self.ec.register_connection(self.iface1, self.channel)
self.ec.register_connection(self.node2, self.iface2)
self.ec.register_connection(self.iface2, self.channel)
self.ec.register_condition([self.app1], ResourceAction.STOP, self.app1,
ResourceState.STARTED, "5s")
self.ec.deploy()
self.ec.wait_finished([self.app1])
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.FAILED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.ec.shutdown()
self.assertEquals(
self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_with_node_and_iface_nc(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.set(self.node2, "critical", False)
self.ec.set(self.node2, 'version', "5")
self.iface2 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.node2, "critical", False)
self.ec.set(self.iface2, 'name', "wlan0")
self.ec.set(self.iface2, 'mode', "adhoc")
self.ec.set(self.iface2, 'hw_mode', "g")
self.ec.set(self.iface2, 'essid', "vlcexp")
self.ec.set(self.iface2, 'ip', "10.0.0.37/24")
self.ec.set(self.iface2, 'version', "5")
self.channel = self.ec.register_resource("omf::Channel")
self.ec.set(self.channel, 'channel', "6")
self.ec.set(self.channel, 'xmppUser', "nepi")
self.ec.set(self.channel, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.channel, 'xmppPort', "5222")
self.ec.set(self.channel, 'xmppPassword', "1234")
self.ec.set(self.channel, 'version', "5")
self.ec.register_connection(self.iface1, self.channel)
self.ec.register_connection(self.node2, self.iface2)
self.ec.register_connection(self.iface2, self.channel)
self.ec.register_condition([self.app1], ResourceAction.STOP, self.app1,
ResourceState.STARTED, "5s")
self.ec.deploy()
self.ec.wait_finished([self.app1])
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.FAILED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.ec.shutdown()
self.assertEquals(
self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_with_node_iface_channel_nc(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.set(self.node2, "critical", False)
self.ec.set(self.node2, 'hostname', 'omf.plexus.wlab37')
self.ec.set(self.node2, 'version', "5")
self.iface2 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.node2, "critical", False)
self.ec.set(self.iface2, 'name', "wlan0")
self.ec.set(self.iface2, 'mode', "adhoc")
self.ec.set(self.iface2, 'hw_mode', "g")
self.ec.set(self.iface2, 'essid', "vlcexp")
self.ec.set(self.iface2, 'ip', "10.0.0.37/24")
self.ec.set(self.iface2, 'version', "5")
self.channel = self.ec.register_resource("omf::Channel")
self.ec.set(self.channel, 'channel', "6")
self.ec.set(self.channel, "critical", False)
self.ec.set(self.channel, 'version', "5")
self.ec.register_connection(self.iface1, self.channel)
self.ec.register_connection(self.node2, self.iface2)
self.ec.register_connection(self.iface2, self.channel)
self.ec.register_condition([self.app1], ResourceAction.STOP, self.app1,
ResourceState.STARTED, "10s")
self.ec.deploy()
self.ec.wait_finished([self.app1])
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.FAILED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.FAILED)
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.FAILED)
self.ec.shutdown()
self.assertEquals(
self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
def test_deploy_with_app_nc(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.set(self.node2, 'hostname', 'omf.plexus.wlab37')
self.ec.set(self.node2, 'xmppUser', "nepi")
self.ec.set(self.node2, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.node2, 'xmppPort', "5222")
self.ec.set(self.node2, 'xmppPassword', "1234")
self.ec.set(self.node2, 'version', "5")
self.iface2 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.iface2, 'name', "wlan0")
self.ec.set(self.iface2, 'mode', "adhoc")
self.ec.set(self.iface2, 'hw_mode', "g")
self.ec.set(self.iface2, 'essid', "vlcexp")
self.ec.set(self.iface2, 'ip', "10.0.0.37/24")
self.ec.set(self.iface2, 'version', "5")
self.channel = self.ec.register_resource("omf::Channel")
self.ec.set(self.channel, 'channel', "6")
self.ec.set(self.channel, 'xmppUser', "nepi")
self.ec.set(self.channel, 'xmppServer', "xmpp-plexus.onelab.eu")
self.ec.set(self.channel, 'xmppPort', "5222")
self.ec.set(self.channel, 'xmppPassword', "1234")
self.ec.set(self.channel, 'version', "5")
self.app2 = self.ec.register_resource("omf::Application")
self.ec.set(self.app2, "critical", False)
self.ec.set(self.app2, 'appid', 'Kill#22')
self.ec.set(self.app2, 'version', "5")
self.ec.register_connection(self.iface1, self.channel)
self.ec.register_connection(self.node2, self.iface2)
self.ec.register_connection(self.iface2, self.channel)
self.ec.register_connection(self.app2, self.node2)
self.ec.register_condition(self.app2, ResourceAction.START, self.app1,
ResourceState.STARTED, "6s")
self.ec.register_condition([self.app1, self.app2], ResourceAction.STOP,
self.app1, ResourceState.STARTED, "10s")
self.ec.deploy()
self.ec.wait_finished([self.app1, self.app2])
self.assertEquals(
self.ec.get_resource(self.app1).state, ResourceState.STOPPED)
self.assertEquals(
self.ec.get_resource(self.app2).state, ResourceState.FAILED)
self.ec.shutdown()
self.assertEquals(
self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
def test_deploy_with_all_nc_and_app_critical(self):
self.node2 = self.ec.register_resource("omf::Node")
self.ec.set(self.node2, "critical", False)
self.ec.set(self.node2, 'hostname', 'omf.plexus.wlab37')
self.ec.set(self.node2, 'version', "5")
self.iface2 = self.ec.register_resource("omf::WifiInterface")
self.ec.set(self.iface2, "critical", False)
self.ec.set(self.iface2, 'version', "5")
self.channel = self.ec.register_resource("omf::Channel")
self.ec.set(self.channel, "critical", False)
self.ec.set(self.channel, 'channel', "6")
self.ec.set(self.channel, 'version', "5")
self.app2 = self.ec.register_resource("omf::Application")
self.ec.set(self.app2, 'appid', 'Kill#22')
self.ec.set(self.app2, 'version', "5")
self.ec.register_connection(self.iface1, self.channel)
self.ec.register_connection(self.node2, self.iface2)
self.ec.register_connection(self.iface2, self.channel)
self.ec.register_connection(self.app2, self.node2)
self.ec.register_condition(self.app2, ResourceAction.START, self.app1,
ResourceState.STARTED, "6s")
self.ec.register_condition([self.app1, self.app2], ResourceAction.STOP,
self.app1, ResourceState.STARTED, "10s")
self.ec.deploy()
self.ec.wait_finished([self.app1, self.app2])
self.assertEquals(
self.ec.get_resource(self.app2).state, ResourceState.FAILED)
self.ec.shutdown()
self.assertEquals(
self.ec.get_resource(self.node1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.node2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.iface2).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.channel).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app1).state, ResourceState.RELEASED)
self.assertEquals(
self.ec.get_resource(self.app2).state, ResourceState.RELEASED)
def t_routing_serialize(self, host, user=None, identity=None):
"""
network topology:
n4
|
n1 -- p2p -- n2 -- csma -- n5 -- p2p -- n6
| |
ping n6 n3
"""
dirpath = tempfile.mkdtemp()
ec = ExperimentController(exp_id="test-ns3-routes")
node = ec.register_resource("linux::Node")
if host == "localhost":
ec.set(node, "hostname", host)
else:
ec.set(node, "hostname", host)
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanProcesses", True)
#ec.set(node, "cleanHome", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
p2p12 = add_point2point_device(ec, nsnode1, "10.0.0.1", "30")
nsnode2 = add_ns3_node(ec, simu)
p2p21 = add_point2point_device(ec, nsnode2, "10.0.0.2", "30")
csma2 = add_csma_device(ec, nsnode2, "10.0.1.1", "24")
nsnode3 = add_ns3_node(ec, simu)
csma3 = add_csma_device(ec, nsnode3, "10.0.1.2", "24")
nsnode4 = add_ns3_node(ec, simu)
csma4 = add_csma_device(ec, nsnode4, "10.0.1.3", "24")
nsnode5 = add_ns3_node(ec, simu)
p2p56 = add_point2point_device(ec, nsnode5, "10.0.2.1", "30")
csma5 = add_csma_device(ec, nsnode5, "10.0.1.4", "24")
nsnode6 = add_ns3_node(ec, simu)
p2p65 = add_point2point_device(ec, nsnode6, "10.0.2.2", "30")
# P2P chan1
p2p_chan1 = ec.register_resource("ns3::PointToPointChannel")
ec.set(p2p_chan1, "Delay", "0s")
ec.register_connection(p2p_chan1, p2p12)
ec.register_connection(p2p_chan1, p2p21)
# CSMA chan
csma_chan = ec.register_resource("ns3::CsmaChannel")
ec.set(csma_chan, "Delay", "0s")
ec.register_connection(csma_chan, csma2)
ec.register_connection(csma_chan, csma3)
ec.register_connection(csma_chan, csma4)
ec.register_connection(csma_chan, csma5)
# P2P chan2
p2p_chan2 = ec.register_resource("ns3::PointToPointChannel")
ec.set(p2p_chan2, "Delay", "0s")
ec.register_connection(p2p_chan2, p2p56)
ec.register_connection(p2p_chan2, p2p65)
# Add routes - n1 - n6
r1 = ec.register_resource("ns3::Route")
ec.set(r1, "network", "10.0.2.0")
ec.set(r1, "prefix", "30")
ec.set(r1, "nexthop", "10.0.0.2")
ec.register_connection(r1, nsnode1)
# Add routes - n2 - n6
r2 = ec.register_resource("ns3::Route")
ec.set(r2, "network", "10.0.2.0")
ec.set(r2, "prefix", "30")
ec.set(r2, "nexthop", "10.0.1.4")
ec.register_connection(r2, nsnode2)
# Add routes - n5 - n1
r5 = ec.register_resource("ns3::Route")
ec.set(r5, "network", "10.0.0.0")
ec.set(r5, "prefix", "30")
ec.set(r5, "nexthop", "10.0.1.1")
ec.register_connection(r5, nsnode5)
# Add routes - n6 - n1
r6 = ec.register_resource("ns3::Route")
ec.set(r6, "network", "10.0.0.0")
ec.set(r6, "prefix", "30")
ec.set(r6, "nexthop", "10.0.2.1")
ec.register_connection(r6, nsnode6)
### create pinger
ping = ec.register_resource("ns3::V4Ping")
ec.set(ping, "Remote", "10.0.2.2")
ec.set(ping, "Interval", "1s")
ec.set(ping, "Verbose", True)
ec.set(ping, "StartTime", "1s")
ec.set(ping, "StopTime", "21s")
ec.register_connection(ping, nsnode1)
filepath = ec.save(dirpath)
print filepath
ec.deploy()
ec.wait_finished([ping])
stdout = ec.trace(simu, "stdout")
expected = "20 packets transmitted, 20 received, 0% packet loss"
self.assertTrue(stdout.find(expected) > -1)
ec.shutdown()
# Load serialized experiment
ec2 = ExperimentController.load(filepath)
ec2.deploy()
ec2.wait_finished([ping])
self.assertEquals(len(ec.resources), len(ec2.resources))
stdout = ec2.trace(simu, "stdout")
expected = "20 packets transmitted, 20 received, 0% packet loss"
self.assertTrue(stdout.find(expected) > -1)
ec2.shutdown()
shutil.rmtree(dirpath)
slice = "ibbtple_geocloud"
pleuser= os.environ["PL_USER"]
plepass= os.environ["PL_PASS"]
ssh_key = "~/.ssh/id_rsa"
seconds = 3600 #1 h
nodes = []
apps = []
node = create_node(ec,slice,pleuser,plepass,hostname="ple6.ipv6.lip6.fr")
#node_nz1=planetlab1.cs.otago.ac.nz
node_nz2="planetlab-1.cs.auckland.ac.nz" #customer
nodes.append(node)
command_client = "ping %s -w %d > node%d.out " % (node_nz2,seconds,node)
app = create_app(ec,command_client)
ec.register_connection(app,node)
ec.deploy()
ec.wait_finished(app)
trace=ec.trace(app,"node%d.out"%(node))
f = open("NZ:"+":"+"node%d_PING.out"%(node),"w")
f.write(trace)
f.close()
#print ec.trace(app1,"stdout")
# Do the experiment controller shutdown:
ec.shutdown()
# END
ec.register_connection(node, dev)
queue = ec.register_resource("ns3::DropTailQueue")
ec.register_connection(dev, queue)
return dev
ec = ExperimentController(exp_id="dce-ping-app")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", "localhost")
ec.set(node, "cleanProcesses", True)
simu = ec.register_resource("linux::ns3::Simulation")
ec.register_connection(simu, node)
nsnode1 = add_ns3_node(ec, simu)
dev1 = add_device(ec, nsnode1, "10.0.0.1", "30")
ec.set(dev1, "DataRate", "5Mbps")
nsnode2 = add_ns3_node(ec, simu)
dev2 = add_device(ec, nsnode2, "10.0.0.2", "30")
ec.set(dev2, "DataRate", "5Mbps")
# Create channel
chan = ec.register_resource("ns3::PointToPointChannel")
ec.set(chan, "Delay", "2ms")
ec.register_connection(chan, dev1)
ec.register_connection(chan, dev2)
