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 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_register_condition(self):
ec = ExperimentController()
rm = ResourceManager(ec, 15)
group = [1, 3, 5, 7]
rm.register_condition(ResourceAction.START, group,
ResourceState.STARTED)
group = [10, 8]
rm.register_condition(ResourceAction.START,
group,
ResourceState.STARTED,
time="10s")
waiting_for = []
conditions = rm.conditions.get(ResourceAction.START)
for (group, state, time) in conditions:
waiting_for.extend(group)
self.assertEquals(waiting_for, [1, 3, 5, 7, 10, 8])
group = [1, 2, 3, 4, 6]
rm.unregister_condition(group)
waiting_for = []
conditions = rm.conditions.get(ResourceAction.START)
for (group, state, time) in conditions:
waiting_for.extend(group)
self.assertEquals(waiting_for, [5, 7, 10, 8])
def setUp(self):
self.ec = ExperimentController(exp_id = "99999")
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.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.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.ec.set(self.app1, 'version', "5")
self.app2 = self.ec.register_resource("omf::Application")
self.ec.set(self.app2, 'version', "5")
self.app3 = self.ec.register_resource("omf::Application")
self.ec.set(self.app3, 'version', "5")
self.app4 = self.ec.register_resource("omf::Application")
self.ec.set(self.app4, 'version', "5")
self.app5 = self.ec.register_resource("omf::Application")
self.ec.set(self.app5, 'version', "5")
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 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 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 _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 test_schedule_print(self):
def myfunc():
return 'hola!'
ec = ExperimentController()
tid = ec.schedule("0s", myfunc, track=True)
while True:
task = ec.get_task(tid)
if task.status != TaskStatus.NEW:
break
time.sleep(1)
self.assertEquals('hola!', task.result)
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 test_schedule_exception(self):
def raise_error():
# When this task is executed and the error raise,
# the FailureManager should set its failure level to
# TASK_FAILURE
raise RuntimeError, "NOT A REAL ERROR. JUST TESTING!"
ec = ExperimentController()
tid = ec.schedule("2s", raise_error, track=True)
while True:
task = ec.get_task(tid)
if task.status != TaskStatus.NEW:
break
time.sleep(1)
self.assertEquals(task.status, TaskStatus.ERROR)
def test_schedule_exception(self):
def raise_error():
# When this task is executed and the error raise,
# the FailureManager should set its failure level to
# TASK_FAILURE
raise RuntimeError, "NOT A REAL ERROR. JUST TESTING!"
ec = ExperimentController()
tid = ec.schedule("2s", raise_error, track = True)
while True:
task = ec.get_task(tid)
if task.status != TaskStatus.NEW:
break
time.sleep(1)
self.assertEquals(task.status, TaskStatus.ERROR)
def test_schedule_date(self):
def get_time():
return datetime.datetime.now()
ec = ExperimentController()
schedule_time = datetime.datetime.now()
tid = ec.schedule("4s", get_time, track=True)
while True:
task = ec.get_task(tid)
if task.status != TaskStatus.NEW:
break
time.sleep(1)
execution_time = task.result
delta = execution_time - schedule_time
self.assertTrue(delta > datetime.timedelta(seconds=4))
self.assertTrue(delta < datetime.timedelta(seconds=5))
ec.shutdown()
def run_experiment(self, filepath, wait_time, wait_guids):
""" Run an experiment based on the description stored
in filepath.
"""
ec = ExperimentController.load(filepath)
ec.deploy()
ec.wait_finished(wait_guids)
time.sleep(wait_time)
ec.release()
if ec.state == ECState.FAILED:
raise RuntimeError, "Experiment failed"
return ec
def run_experiment(self, filepath, wait_time, wait_guids):
""" Run an experiment based on the description stored
in filepath.
"""
ec = ExperimentController.load(filepath)
ec.deploy()
ec.wait_finished(wait_guids)
time.sleep(wait_time)
ec.release()
if ec.state == ECState.FAILED:
raise RuntimeError, "Experiment failed"
return ec
def make_experiment(node_count, app_count, opdelay, delay):
ResourceManager._reschedule_delay = "%0.1fs" % delay
hostnames = []
with open("planetlab_hosts.txt", "r") as f:
for line in f:
line = line.strip()
if not line:
continue
hostnames.append(line)
# Create Experiment Controller:
ec = ExperimentController("linux_bench")
nodes = []
apps = []
for i in xrange(node_count):
hostname = hostnames[i]
node = add_node(ec, hostname)
nodes.append(node)
i = 0
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.
hostname = hostnames[i]
if len(nodes) > 1:
choices = hostnames[:]
choices.remove(hostname)
hostname = random.choice(choices)
app = add_app(ec, node, hostname)
apps.append(app)
i += 1
return (ec, apps, nodes + apps)
def test_schedule_print(self):
def myfunc():
return 'hola!'
ec = ExperimentController()
tid = ec.schedule("0s", myfunc, track=True)
while True:
task = ec.get_task(tid)
if task.status != TaskStatus.NEW:
break
time.sleep(1)
self.assertEquals('hola!', task.result)
ec.shutdown()
def test_schedule_date(self):
def get_time():
return datetime.datetime.now()
ec = ExperimentController()
schedule_time = datetime.datetime.now()
tid = ec.schedule("4s", get_time, track=True)
while True:
task = ec.get_task(tid)
if task.status != TaskStatus.NEW:
break
time.sleep(1)
execution_time = task.result
delta = execution_time - schedule_time
self.assertTrue(delta > datetime.timedelta(seconds=4))
self.assertTrue(delta < datetime.timedelta(seconds=5))
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()
ec.set(app, "command", command)
return app
def add_ccncat(ec, content_name):
env = "PATH=$PATH:${BIN}/ccnx-0.8.2/bin"
command = "ccncat %s" % content_name
app = ec.register_resource("linux::Application")
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")
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Author: Alina Quereilhac <*****@*****.**>
Julien Tribino <*****@*****.**>
"""
#!/usr/bin/env python
from nepi.execution.resource import ResourceFactory, ResourceAction, ResourceState
from nepi.execution.ec import ExperimentController
# Create the EC
ec = ExperimentController()
# Create and Configure the Nodes
node1 = ec.register_resource("omf::Node")
ec.set(node1, 'hostname', 'node025')
ec.set(node1, 'xmppServer', "nitlab.inf.uth.gr")
ec.set(node1, 'xmppUser', "nepi")
ec.set(node1, 'xmppPort', "5222")
ec.set(node1, 'xmppPassword', "1234")
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")
parser = OptionParser(usage = usage)
parser.add_option("-a", "--hostname", dest="hostname",
help="Remote host", type="str")
parser.add_option("-u", "--username", dest="username",
help="Username to SSH to remote host", type="str")
parser.add_option("-i", "--ssh-key", dest="ssh_key",
help="Path to private SSH key to be used for connection",
type="str")
(options, args) = parser.parse_args()
hostname = options.hostname
username = options.username
ssh_key = options.ssh_key
ec = ExperimentController(exp_id = "ping-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)
app = ec.register_resource("linux::Application")
ec.set(app, "command", "ping -c3 nepi.inria.fr")
ec.register_connection(app, node)
ec.deploy()
ec.wait_finished(app)
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_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()
- Experiment:
* t0 : Deployment
* t1 : After the application started, one stdin message is sent
* t2 (t1 + 5s) : An other message is send
"""
#!/usr/bin/env python
from nepi.execution.resource import ResourceFactory, ResourceAction, ResourceState
from nepi.execution.ec import ExperimentController
import time
# Create the EC
ec = ExperimentController()
# Create and Configure the Nodes
node1 = ec.register_resource("omf::Node")
ec.set(node1, 'hostname', 'omf.plexus.wlab17')
ec.set(node1, 'xmppServer', "nepi")
ec.set(node1, 'xmppUser', "xmpp-plexus.onelab.eu")
ec.set(node1, 'xmppPort', "5222")
ec.set(node1, 'xmppPassword', "1234")
ec.set(node1, 'version', "5")
# Create and Configure the Application
app1 = ec.register_resource("omf::Application")
ec.set(app1, 'appid', "robot")
ec.set(app1, 'command', "/root/CTRL_test.rb coord.csv")
ec.set(app1, 'env', "DISPLAY=localhost:10.0 XAUTHORITY=/root/.Xauthority")
ec.register_connection(app, node)
return app
############## Experiment design and execution ################################
platform = "ns3"
# 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()
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 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_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)
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)
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_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()
# Set experiment for broadcast or vod mode
parser = argparse.ArgumentParser(description='NEPI VoD/Broadcast experiment')
parser.add_argument('-m',
'--mode',
help='Set vlc mode, possible values <vod> or <broadcast>',
required=True)
args = parser.parse_args()
mode = args.mode
# Create the entity Experiment Controller
exp_id = "vod_exp"
ec = ExperimentController(exp_id)
# Define SFA credentials
slicename = 'ple.inria.nepi'
sfauser = '******'
sfaPrivateKey = '/home/alina/.sfi/aquereilhac.pkey'
# Functions for nodes and ifaces registration
def create_planetlab_node(ec, host):
node = ec.register_resource("planetlab::sfa::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", "inria_nepi")
ec.set(node, "sfauser", sfauser)
"(e.g. hostname must be of form: node0ZZ)",
type="str")
parser.add_option("-c", "--channel", dest="channel",
help="Nitos reserved channel",
type="str")
parser.add_option("-s", "--slice-name", dest="slicename",
help="Nitos slice name", type="str")
(options, args) = parser.parse_args()
nodex = options.nodex
nodez = options.nodez
slicename = options.slicename
chan = options.channel
# Create the EC
ec = ExperimentController(exp_id="nitos_omf6_vlc")
# 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")
def t_dce_ccnpeek(self, host, user = None, identity = None):
ec = ExperimentController(exp_id = "test-dce-ccnpeek")
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", "DceApplication")
ec.register_connection(simu, node)
nsnode = add_ns3_node(ec, 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 t_tap_create(self, host, user=None, identity=None):
ec = ExperimentController(exp_id="test-tap-create")
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", host)
if host != "localhost":
ec.set(node, "username", user)
ec.set(node, "identity", identity)
ec.set(node, "cleanExperiment", True)
ec.set(node, "cleanProcesses", True)
tap = ec.register_resource("linux::Tap")
ec.set(tap, "ip", "%s.1" % self.netblock)
ec.set(tap, "prefix", "24")
ec.register_connection(tap, 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(tap, "deviceName")
self.assertTrue(if_name.startswith("tap"))
ec.shutdown()
"(e.g. hostname must be of form: node0ZZ)",
type="str")
parser.add_option("-c", "--channel", dest="channel",
help="Nitos reserved channel",
type="str")
parser.add_option("-s", "--slice-name", dest="slicename",
help="Nitos slice name", type="str")
(options, args) = parser.parse_args()
nodex = options.nodex
nodez = options.nodez
slicename = options.slicename
chan = options.channel
# Create the EC
ec = ExperimentController(exp_id="nitos_omf6_ping")
# 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", "ping")
ec.set(node, "operatingSystem", operatingSystem)
if minBandwidth:
ec.set(node, "minBandwidth", minBandwidth)
if minCpu:
ec.set(node, "minCpu", minCpu)
ec.set(node, "critical", critical)
#ec.set(node, "cleanExperiment", True)
#ec.set(node, "cleanProcesses", True)
return node
exp_id = "scalability_exp"
# Create the entity Experiment Controller:
ec = ExperimentController(exp_id)
# Register the nodes resources:
# The username in this case is the slice name, the one to use for login in
# via ssh into PlanetLab nodes. Replace with your own slice name.
username = os.environ.get("PL_SLICE")
# The pluser and plpassword are the ones used to login in the PlanetLab web
# site. Replace with your own user and password account information.
pl_user = os.environ.get("PL_USER")
pl_password = os.environ.get("PL_PASS")
# Choose the PlanetLab nodes for the experiment, in this example 5 nodes are
# used, and they are picked according to different criterias.
def t_ping(self, host, user):
ec = ExperimentController(exp_id="test-ping")
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 = "ping -c5 %s" % self.target
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")
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_cross_ping(self, host, user = None, identity = None):
ec = ExperimentController(exp_id = "test-linux-ns3-tap-fd")
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.set(simu, "buildMode", "debug")
#ec.set(simu, "nsLog", "FdNetDevice")
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")
# Add routes on the NS3 side
r1 = ec.register_resource("ns3::Route")
ec.set(r1, "network", "10.0.1.0")
ec.set(r1, "prefix", "30")
ec.set(r1, "nexthop", "10.0.0.1")
ec.register_connection(r1, nsnode2)
# Create channel
chan = ec.register_resource("ns3::PointToPointChannel")
ec.set(chan, "Delay", "0s")
ec.register_connection(chan, dev1)
ec.register_connection(chan, dev2)
fddev = add_fd_device(ec, nsnode1, "10.0.1.2", "30")
ec.enable_trace(fddev, "pcap")
ec.enable_trace(fddev, "promiscPcap")
ec.enable_trace(fddev, "ascii")
tap = add_tap_device(ec, node, "10.0.1.1", "30")
crosslink = ec.register_resource("linux::ns3::TapFdLink")
ec.register_connection(crosslink, tap)
ec.register_connection(crosslink, fddev)
# Add routes on the localhost side
r2 = ec.register_resource("linux::Route")
ec.set(r2, "network", "10.0.0.0")
ec.set(r2, "prefix", "30")
ec.set(r2, "nexthop", "10.0.1.2")
ec.register_connection(r2, tap)
app = ec.register_resource("linux::Application")
ec.set(app, "command", "ping -c3 10.0.0.1")
ec.register_connection(app, node)
ec.register_condition(app, ResourceAction.START, simu,
ResourceState.STARTED, time="5s")
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)
## Releasing to force ns3 to flush the traces
ec.release()
pcap = ec.trace(fddev, "pcap")
self.assertTrue(len(pcap) > 4000)
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)
if source:
ec.set(app,"sources",source)
ec.set(app,"command",command)
return app
#Argentina is missing ,"Argentina":"planet-lab2.itba.edu.ar"
#Host where the ground stations will be allocated
hosts ={"Argentina":"planetlab1.pop-rs.rnp.br","China":"planetlab1.buaa.edu.cn","Spain":"planetlab2.dit.upm.es","Norway":"planetlab1.cs.uit.no","New Zealand":"planetlab1.cs.otago.ac.nz","Florida":"planetlab1.csee.usf.edu","Israel":"planetlab2.mta.ac.il","Brazil":"planetlab1.pop-pa.rnp.br","Reunion Island":"lim-planetlab-1.univ-reunion.fr","Malaysia":"planetlab1.comp.nus.edu.sg","Canada":"planetlab-2.usask.ca","Australia":"pl1.eng.monash.edu.au"}
#hosts ={"Argentina":"planetlab1.pop-rs.rnp.br","China":"planetlab1.buaa.edu.cn","Spain":"planetlab2.dit.upm.es","Norway":"planetlab1.cs.uit.no","New Zealand":"planetlab1.cs.otago.ac.nz","Florida":"planetlab1.csee.usf.edu","Israel":"planetlab2.mta.ac.il","Brazil":"planetlab1.pop-pa.rnp.br","Malaysia":"planetlab1.comp.nus.edu.sg","Canada":"planetlab-2.usask.ca","Australia":"pl1.eng.monash.edu.au"}
#hosts={"New Zealand":"planetlab1.cs.otago.ac.nz"}
#Host where the BonFIRE cloud will be
bonfire_host = ("France","ple6.ipv6.lip6.fr")
ec = ExperimentController("test_ple")
# The username in this case is the slice name, the one to use for login in
# via ssh into PlanetLab nodes. Replace with your own slice name.
slice = "ibbtple_geocloud"
pleuser= os.environ["PL_USER"]
plepass= os.environ["PL_PASS"]
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 = []
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Author: Alina Quereilhac <*****@*****.**>
from nepi.execution.ec import ExperimentController
ec = ExperimentController(exp_id = "ns3-local-wifi-ping")
# Simulation will executed in the local machine
node = ec.register_resource("linux::Node")
ec.set(node, "hostname", "localhost")
# Add a simulation resource
simu = ec.register_resource("linux::ns3::Simulation")
ec.set(simu, "verbose", True)
ec.register_connection(simu, node)
## Add a ns-3 node with its protocol stack
nsnode1 = ec.register_resource("ns3::Node")
ec.register_connection(nsnode1, simu)
ipv4 = ec.register_resource("ns3::Ipv4L3Protocol")
type="str")
parser.add_option("-a", "--hostname1", dest="hostname1",
help="Remote host 1", type="str")
parser.add_option("-b", "--hostname2", dest="hostname2",
help="Remote host 2", type="str")
(options, args) = parser.parse_args()
hostname1 = options.hostname1
hostname2 = options.hostname2
pl_slice = options.pl_slice
pl_ssh_key = options.pl_ssh_key
pl_user = options.pl_user
pl_password = options.pl_password
## Create the experiment controller
ec = ExperimentController(exp_id = "pl_ccn_simple_transfer")
##### CONFIGURING NODE 1
## Register node 1
node1 = ec.register_resource("planetlab::Node")
# Set the hostname of the first node to use for the experiment
ec.set(node1, "hostname", hostname1)
# username should be your SSH user
ec.set(node1, "username", pl_slice)
# Path to the SSH private key
ec.set(node1, "identity", pl_ssh_key)
# Planetlab web site user and password
ec.set(node1, "pluser", pl_user)
ec.set(node1, "plpassword", pl_password)
# Clean all files, results, etc, from previous experiments wit the same exp_id
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()
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Author: Lucia Guevgeozian <*****@*****.**>
from nepi.execution.ec import ExperimentController
from nepi.execution.resource import ResourceAction, ResourceState
import os
# Create the EC
exp_id = "example_geo"
ec = ExperimentController(exp_id)
pl_user = "******"
pl_password = os.environ.get("PL_PASS")
slicename = "inria_sfatest"
node1 = ec.register_resource("PlanetlabNode")
ec.set(node1, "hostname", "planetlab2.dit.upm.es")
minBandwidth = X
ec.set(node1, "minBandwidth", minBandwidth)
ec.set(node1, "username", slicename)
ec.set(node1, "pluser", pl_user)
ec.set(node1, "plpassword", pl_password)
ec.set(node1, "cleanHome", True)
ec.set(node1, "cleanProcesses", True)
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)
ec.register_connection(node, tcp)
return node
def add_device(ec, node, ip, prefix):
dev = ec.register_resource("ns3::PointToPointNetDevice")
ec.set(dev, "ip", ip)
ec.set(dev, "prefix", prefix)
ec.register_connection(node, dev)
queue = ec.register_resource("ns3::DropTailQueue")
ec.register_connection(dev, queue)
return dev
ec = ExperimentController(exp_id = "dce-custom-dlm-ping")
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.set(simu, "enableDump", 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)
#No tiene : Denmark
#Austria,
#################
nodes_customers = ("Argentina", "Australia", "Austria", "Belgium", "Brazil",
"Canada", "China", "Cyprus", "Czech Republic", "Denmark",
"Ecuador", "Egypt", "Findland", "France", "Germany",
"Greece", "HongKong", "Hungary", "Iceland", "India",
"Ireland", "Israel", "Italy", "Japan", "Jordan", "Korea",
"Mexico", "Netherlands", "NewZealand", "Norway", "Pakistan",
"Poland", "Portugal", "PuertoRico", "Romania",
"RussianFederation", "Singapore", "Slovenia", "Spain",
"SriLanca", "Sweeden", "Switzerland", "Taiwan", "Thailand",
"Tunisia", "Turkey", "UnitedKingdom", "UnitedStates",
"Uruguay", "Venezuela")
ec = ExperimentController("test_ple")
# The username in this case is the slice name, the one to use for login in
# via ssh into PlanetLab nodes. Replace with your own slice name.
slice = "ibbtple_geocloud"
pleuser = os.environ["PL_USER"]
plepass = os.environ["PL_PASS"]
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 = []
return node
def add_device(ec, node, ip, prefix):
dev = ec.register_resource("ns3::PointToPointNetDevice")
ec.set(dev, "ip", ip)
ec.set(dev, "prefix", prefix)
ec.register_connection(node, dev)
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")
import os
import time
import argparse
# Set experiment for broadcast or vod mode
parser = argparse.ArgumentParser(description='NEPI VoD/Broadcast experiment')
parser.add_argument('-m', '--mode', help='Set vlc mode, possible values <vod> or <broadcast>', required=True)
args = parser.parse_args()
mode = args.mode
# Create the entity Experiment Controller
exp_id = "vod_exp"
ec = ExperimentController(exp_id)
# Define SFA credentials
slicename = 'ple.inria.nepi'
sfauser = '******'
sfaPrivateKey = '/home/alina/.sfi/aquereilhac.pkey'
# Functions for nodes and ifaces registration
def create_planetlab_node(ec, host):
node = ec.register_resource("planetlab::sfa::Node")
ec.set(node, "hostname", host)
ec.set(node, "username", "inria_nepi")
ec.set(node, "sfauser", sfauser)
ec.set(node, "sfaPrivateKey", sfaPrivateKey)
def create_app(ec,command,sudo=None,dependencies=None,source=None):
app = ec.register_resource("LinuxApplication")
if sudo:
ec.set(app,"sudo",sudo)
if dependencies:
ec.set(app,"depends",dependencies)
if source:
ec.set(app,"sources",source)
ec.set(app,"command",command)
return app
hosts={"New Zealand":"planetlab1.cs.otago.ac.nz"}
#Host where the BonFIRE cloud will be
bonfire_host = ("France","ple6.ipv6.lip6.fr")
ec = ExperimentController("test_ple")
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)
app = ec.register_resource("linux::Application")
ec.set(app, "command", command)
ec.register_connection(app, node)
return app
############## Experiment design and execution ################################
platform = "planetlab"
# 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)
# Authentication for MyPLC
username = '******'
pl_user = os.environ.get("PL_USER")
pl_password = os.environ.get("PL_PASS")
# App to run on each node
command = "ping -c5 nepi.inria.fr"
# Add simulated nodes and applications
nodes = list()
apps = list()
for i in xrange(node_count):
node = create_node(ec, username, pl_user, pl_password)
def t_tun_udp_tunnel(self, user1, host1, identity1, user2, host2, identity2):
ec = ExperimentController(exp_id="test-tun-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)
tun1 = ec.register_resource("linux::Tun")
ec.set(tun1, "ip", "%s.1" % self.netblock)
ec.set(tun1, "prefix", "32")
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", "32")
ec.register_connection(tun2, node2)
udptun = ec.register_resource("linux::UdpTunnel")
ec.register_connection(tun1, udptun)
ec.register_connection(tun2, 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(tun1, "deviceName")
self.assertTrue(vif_name.startswith("tun"))
vif_name = ec.get(tun2, "deviceName")
self.assertTrue(vif_name.startswith("tun"))
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()
