break
if reschedule:
-
callback = functools.partial(wait_all_and_start, group)
self.schedule("1s", callback)
else:
with self._release_lock:
if self._state != ResourceState.RELEASED:
self.do_deploy()
- self.debug("----- READY ---- ")
def release(self):
""" Perform actions to free resources used by the RM.
self.error(err)
self.set_released()
- self.debug("----- RELEASED ---- ")
def fail(self):
""" Sets the RM to state FAILED.
def set_started(self):
""" Mark ResourceManager as STARTED """
self.set_state(ResourceState.STARTED, "_start_time")
+ self.debug("----- STARTED ---- ")
def set_stopped(self):
""" Mark ResourceManager as STOPPED """
self.set_state(ResourceState.STOPPED, "_stop_time")
+ self.debug("----- STOPPED ---- ")
def set_ready(self):
""" Mark ResourceManager as READY """
self.set_state(ResourceState.READY, "_ready_time")
+ self.debug("----- READY ---- ")
def set_released(self):
""" Mark ResourceManager as REALEASED """
self.set_state(ResourceState.RELEASED, "_release_time")
+ self.debug("----- RELEASED ---- ")
def set_failed(self):
""" Mark ResourceManager as FAILED """
self.set_state(ResourceState.FAILED, "_failed_time")
+ self.debug("----- FAILED ---- ")
def set_discovered(self):
""" Mark ResourceManager as DISCOVERED """
self.set_state(ResourceState.DISCOVERED, "_discover_time")
+ self.debug("----- DISCOVERED ---- ")
def set_provisioned(self):
""" Mark ResourceManager as PROVISIONED """
self.set_state(ResourceState.PROVISIONED, "_provision_time")
+ self.debug("----- PROVISIONED ---- ")
def set_state(self, state, state_time_attr):
""" Set the state of the RM while keeping a trace of the time """
self.do_discover()
self.do_provision()
- self.debug("----- READY ---- ")
self.set_ready()
@property
self.do_discover()
self.do_provision()
- self.debug("----- READY ---- ")
self.set_ready()
def upload_start_command(self):
self.do_discover()
self.do_provision()
- self.debug("----- READY ---- ")
self.set_ready()
def upload_start_command(self):
self.do_discover()
self.do_provision()
- self.debug("----- READY ---- ")
self.set_ready()
def upload_start_command(self):
self.do_provision()
self.configure()
- self.debug("----- READY ---- ")
self.set_ready()
def upload_start_command(self):
# ccnd needs to wait until node is deployed and running
self.ec.schedule(reschedule_delay, self.deploy)
else:
-
# TODO: Create socket!!
socket_name = self.get("socketName")
self._client = LinuxNS3Client(socket_name)
#self.do_discover()
#self.do_provision()
- self.debug("----- READY ---- ")
self.set_ready()
+ def do_start(self):
+ command = self.get("command")
+
+ self.info("Starting ns-3 simulation")
+
+ self._client.start()
+
+ self.set_started()
+
+ # TODO! DESTROY SOCKET AND SHUTDOWN CLIENT
self.do_discover()
self.do_provision()
- self.debug("----- READY ---- ")
self.set_ready()
def do_start(self):
class NS3BaseApplication(NS3Base):
_rtype = "abstract::ns3::Application"
+ @property
+ def node(self):
+ from nepi.resources.ns3.ns3node import NS3BaseNode
+ nodes = self.get_connected(NS3BaseNode.get_rtype())
+
+ if not nodes:
+ msg = "Application not connected to node"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return nodes[0]
+
+ @property
+ def _rms_to_wait(self):
+ rms = set()
+ rms.add(self.node)
+ return rms
+
def _connect_object(self):
node = self.node
- if node and node.uuid not in self.connected:
+ if node.uuid not in self.connected:
self.simulator.invoke(node.uuid, "AddApplication", self.uuid)
self._connected.add(node.uuid)
+ """
def do_start(self):
if self.state == ResourceState.READY:
self.info("Starting")
self.info("Stopping command '%s'" % command)
self.simulator.invoke(self.uuid, "Stop")
self.set_stopped()
+ """
--- /dev/null
+#
+# NEPI, a framework to manage network experiments
+# Copyright (C) 2014 INRIA
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# 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 <alina.quereilhac@inria.fr>
+
+from nepi.execution.resource import clsinit_copy
+from nepi.resources.ns3.ns3base import NS3Base
+
+@clsinit_copy
+class NS3BaseArpL3Protocol(NS3Base):
+ _rtype = "abstract::ns3::ArpL3Protocol"
+
+ @property
+ def node(self):
+ from nepi.resources.ns3.ns3node import NS3BaseNode
+ nodes = self.get_connected(NS3BaseNode.get_rtype())
+
+ if not nodes:
+ msg = "ArpL3Protocol not connected to node"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return nodes[0]
+
+ @property
+ def _rms_to_wait(self):
+ rms = set()
+ rms.add(self.node)
+ return rms
+
@property
def simulator(self):
- # Ns3 RMs should be connected to the simulator through a ns3 node
- node = self.node
- if node: return node.simulator
- return None
-
+ return self.node.simulator
+
@property
def node(self):
from nepi.resources.ns3.ns3node import NS3BaseNode
return None
@property
- def others_to_wait(self):
- others = set()
+ def _rms_to_wait(self):
+ """ Returns the collection of ns-3 RMs that this RM needs to
+ wait for before start
+
+ This method should be overriden to wait for other ns-3
+ objects to be deployed before proceeding with the deployment
+
+ """
+ rms = set()
node = self.node
- if node: others.add(node)
- return others
+ if node: rms.add(node)
+ return rms
def _instantiate_object(self):
if self.uuid:
self.simulator.invoke(node.uuid, "AggregateObject", self.uuid)
self._connected.add(node.uuid)
- def _wait_others(self):
- """ Returns the collection of ns-3 RMs that this RM needs to
- wait for before start
-
- This method should be overriden to wait for other ns-3
- objects to be deployed before proceeding with the deployment
-
- """
- for other in self.others_to_wait:
- if other and other.state < ResourceState.READY:
+ def _wait_rms(self):
+ """ Returns True if dependent RMs are not yer READY, False otherwise"""
+ for rm in self._rms_to_wait:
+ if rm and rm.state < ResourceState.READY:
+ rm.debug("Not yet READY")
return True
return False
def do_provision(self):
- # create run dir for ns3 object
+ # TODO: create run dir for ns3 object !!!!
# self.simulator.node.mkdir(self.run_home)
self._instantiate_object()
super(NS3Base, self).do_provision()
def do_deploy(self):
- if not self.simulator or self.simulator.state < ResourceState.READY or \
- self._wait_others():
+ if self._wait_rms():
self.debug("---- RESCHEDULING DEPLOY ----" )
-
- # ccnd needs to wait until node is deployed and running
self.ec.schedule(reschedule_delay, self.deploy)
else:
- # TODO: CREATE AND CONFIGURE NS-3 C++ OBJECT
+ self.info("Entering deploy")
self.do_discover()
self.do_provision()
- self.debug("----- READY ---- ")
self.set_ready()
def do_start(self):
class NS3BaseChannel(NS3Base):
_rtype = "abstract::ns3::Channel"
+ @property
+ def simulator(self):
+ return self.devices[0].node.simulator
+
@property
def devices(self):
from nepi.resources.ns3.ns3netdevice import NS3BaseNetDevice
- return self.get_connected(NS3BaseNetDevice.get_rtype())
+ devices = self.get_connected(NS3BaseNetDevice.get_rtype())
+
+ if not devices:
+ msg = "Channel not connected to devices"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return devices
@property
- def simulator(self):
- devices = self.devices
- if devices: return devices[0].node.simulator
- return None
-
+ def _rms_to_wait(self):
+ rms = set()
+ rms.add(self.simulator)
+ return rms
+
def device(self):
from nepi.resources.ns3.ns3netdevice import NS3BaseNetDevice
devices = self.get_connected(NS3BaseNetDevice.get_rtype())
- if devices: return devices[0]
- return None
+
+ if not devices:
+ msg = "ErrorModel not connected to device"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return devices[0]
@property
- def others_to_wait(self):
- others = set()
- device = self.device
- if device: others.add(device)
- return others
+ def _rms_to_wait(self):
+ rms = set()
+ rms.add(self.device)
+ return rms
def _connect_object(self):
device = self.device
- if device and device.uuid not in self.connected:
+ if device.uuid not in self.connected:
self.simulator.invoke(device.uuid, "SetReceiveErrorModel", self.uuid)
self._connected.add(device.uuid)
from nepi.execution.resource import clsinit_copy
from nepi.resources.ns3.ns3base import NS3Base
-from nepi.resources.ns3.ns3wifiphy import NS3BaseWifiPhy
@clsinit_copy
class NS3BaseErrorRateModel(NS3Base):
@property
def phy(self):
+ from nepi.resources.ns3.ns3wifiphy import NS3BaseWifiPhy
phys = self.get_connected(NS3BaseWifiPhy.get_rtype())
- if phys: return phys[0]
- return None
+
+ if not phys:
+ msg = "ErrorRateModel not connected to phy"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return phys[0]
@property
- def others_to_wait(self):
- others = set()
- phy = self.phy
- if phy: others.add(phy)
- return others
+ def _rms_to_wait(self):
+ rms = set()
+ rms.add(self.phy)
+ return rms
def _connect_object(self):
phy = self.phy
- if phy and phy.uuid not in self.connected:
+ if phy.uuid not in self.connected:
self.simulator.invoke(phy.uuid, "SetErrorRateModel", self.uuid)
self._connected.add(phy.uuid)
--- /dev/null
+#
+# NEPI, a framework to manage network experiments
+# Copyright (C) 2014 INRIA
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# 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 <alina.quereilhac@inria.fr>
+
+from nepi.execution.resource import clsinit_copy
+from nepi.resources.ns3.ns3base import NS3Base
+
+@clsinit_copy
+class NS3BaseIcmpv4L4Protocol(NS3Base):
+ _rtype = "abstract::ns3::Icmpv4L4Protocol"
+
+ @property
+ def node(self):
+ from nepi.resources.ns3.ns3node import NS3BaseNode
+ nodes = self.get_connected(NS3BaseNode.get_rtype())
+
+ if not nodes:
+ msg = "Icmp4L4Protocol not connected to node"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return nodes[0]
+
+ @property
+ def _rms_to_wait(self):
+ rms = set()
+ rms.add(self.node)
+ return rms
+
class NS3BaseIpv4L3Protocol(NS3Base):
_rtype = "abstract::ns3::Ipv4L3Protocol"
+ @property
+ def node(self):
+ from nepi.resources.ns3.ns3node import NS3BaseNode
+ nodes = self.get_connected(NS3BaseNode.get_rtype())
+
+ if not nodes:
+ msg = "Ipv4L3Protocol not connected to node"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return nodes[0]
+
+ @property
+ def _rms_to_wait(self):
+ rms = set()
+ rms.add(self.node)
+ return rms
+
def _configure_object(self):
simulator = self.simulator
cls._register_attribute(ip)
cls._register_attribute(prefix)
+ @property
+ def node(self):
+ from nepi.resources.ns3.ns3node import NS3BaseNode
+ nodes = self.get_connected(NS3BaseNode.get_rtype())
+
+ if not nodes:
+ msg = "Device not connected to node"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return nodes[0]
+
@property
def channel(self):
from nepi.resources.ns3.ns3channel import NS3BaseChannel
channels = self.get_connected(NS3BaseChannel.get_rtype())
- if channels: return channels[0]
- return None
+
+ if not channels:
+ msg = "Device not connected to channel"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return channels[0]
@property
- def others_to_wait(self):
+ def _rms_to_wait(self):
others = set()
- node = self.node
- if node: others.add(node)
- channel = self.channel
- if channel: others.add(channel)
+ node = self.node
+ others.add(node)
+
+ ipv4 = node.ipv4
+ if node.ipv4:
+ others.add(ipv4)
+
+ others.add(self.channel)
return others
def _configure_object(self):
if isinstance(rm, NS3Simulator):
return rm
- return None
-
+ msg = "Node not connected to simulator"
+ self.error(msg)
+ raise RuntimeError, msg
+
@property
def ipv4(self):
from nepi.resources.ns3.ns3ipv4l3protocol import NS3BaseIpv4L3Protocol
return None
@property
- def others_to_wait(self):
- return set()
+ def _rms_to_wait(self):
+ rms = set()
+ rms.add(self.simulator)
+ return rms
def _configure_object(self):
### node.AggregateObject(PacketSocketFactory())
from nepi.execution.resource import clsinit_copy
from nepi.resources.ns3.ns3base import NS3Base
-from nepi.resources.ns3.ns3channel import NS3BaseChannel
@clsinit_copy
class NS3BasePropagationDelayModel(NS3Base):
@property
def simulator(self):
- channel = self.channel
- if channel: return channel.simulator
- return None
+ return self.channel.simulator
@property
def channel(self):
+ from nepi.resources.ns3.ns3channel import NS3BaseChannel
channels = self.get_connected(NS3BaseChannel.get_rtype())
- if channels: return channels[0]
- return None
+
+ if not channels:
+ msg = "PropagationDelayModel not connected to channel"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return channels[0]
@property
- def others_to_wait(self):
+ def _rms_to_wait(self):
others = set()
- channel = self.channel
- if channel: others.add(channel)
+ others.add(self.channel)
return others
def _connect_object(self):
channel = self.channel
- if channel and channel.uuid not in self.connected:
+ if channel.uuid not in self.connected:
self.simulator.invoke(channel.uuid, "SetPropagationDelayModel", self.uuid)
self._connected.add(channel.uuid)
from nepi.execution.resource import clsinit_copy
from nepi.resources.ns3.ns3base import NS3Base
-from nepi.resources.ns3.ns3channel import NS3BaseChannel
@clsinit_copy
class NS3BasePropagationLossModel(NS3Base):
@property
def simulator(self):
- channel = self.channel
- if channel: return channel.simulator
- return None
+ return self.channel.simulator
@property
def channel(self):
+ from nepi.resources.ns3.ns3channel import NS3BaseChannel
channels = self.get_connected(NS3BaseChannel.get_rtype())
- if channels: return channels[0]
- return None
+
+ if not channels:
+ msg = "PropagationLossModel not connected to channel"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return channels[0]
@property
- def others_to_wait(self):
+ def _rms_to_wait(self):
others = set()
- channel = self.channel
- if channel: others.add(channel)
+ others.add(self.channel)
return others
def _connect_object(self):
channel = self.channel
- if channel and channel.uuid not in self.connected:
+ if channel.uuid not in self.connected:
self.simulator.invoke(channel.uuid, "SetPropagationLossModel", self.uuid)
self._connected.add(channel.uuid)
def device(self):
from nepi.resources.ns3.ns3netdevice import NS3BaseNetDevice
devices = self.get_connected(NS3BaseNetDevice.get_rtype())
- if devices: return devices[0]
- return None
+
+ if not devices:
+ msg = "Queue not connected to device"
+ self.error(msg, out, err)
+ raise RuntimeError, msg
+
+ return devices[0]
@property
def node(self):
- device = self.device
- if device: return device.node
- return None
+ return self.device.node
@property
- def others_to_wait(self):
- others = set()
- device = self.device
- if device: others.add(device)
- return others
+ def _rms_to_wait(self):
+ rms = set()
+ rms.add(self.device)
+ return rms
def _connect_object(self):
device = self.device
- if device and device.uuid not in self.connected:
+ if device.uuid not in self.connected:
self.simulator.invoke(device.uuid, "SetQueue", self.uuid)
self._connected.add(device.uuid)
class NS3BaseWifiMac(NS3Base):
_rtype = "abstract::ns3::WifiMac"
+ @property
+ def node(self):
+ return self.device.node
+
@property
def device(self):
from nepi.resources.ns3.ns3device import NS3BaseNetDevice
devices = self.get_connected(NS3BaseNetDevice.get_rtype())
- if devices: return devices[0]
- return None
+
+ if not devices:
+ msg = "WifiMac not connected to device"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return devices[0]
@property
- def others_to_wait(self):
- others = set()
- device = self.device
- if device: others.add(device)
- return others
+ def _rms_to_wait(self):
+ rms = set()
+ rms.add(self.device)
+ return rms
def _connect_object(self):
device = self.device
- if device and device.uuid not in self.connected:
+ if device.uuid not in self.connected:
self.simulator.invoke(device.uuid, "SetMac", self.uuid)
self._connected.add(device.uuid)
class NS3BaseWifiPhy(NS3Base):
_rtype = "abstract::ns3::WifiPhy"
+ @property
+ def node(self):
+ return self.device.node
+
@property
def device(self):
from nepi.resources.ns3.ns3device import NS3BaseNetDevice
devices = self.get_connected(NS3BaseNetDevice.get_rtype())
- if devices: return devices[0]
- return None
+
+ if not devices:
+ msg = "WifiPhy not connected to device"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return devices[0]
@property
- def others_to_wait(self):
- others = set()
- device = self.device
- if device: others.add(device)
- return others
+ def _rms_to_wait(self):
+ rms = set()
+ rms.add(self.device)
+ return rms
def _connect_object(self):
device = self.device
- if device and device.uuid not in self.connected:
+ if device.uuid not in self.connected:
self.simulator.invoke(device.uuid, "SetPhy", self.uuid)
self.simulator.invoke(self.uuid, "SetDevice", device.uuid)
self._connected.add(device.uuid)
- node = device.node
- if node:
- self.simulator.invoke(self.uuid, "SetMobility", node.uuid)
+ self.simulator.invoke(self.uuid, "SetMobility", self.node.uuid)
class NS3BaseWifiRemoteStationManager(NS3Base):
_rtype = "abstract::ns3::WifiRemoteStationManager"
+ @property
+ def node(self):
+ return self.device.node
+
@property
def device(self):
+ from nepi.resources.ns3.ns3device import NS3BaseNetDevice
devices = self.get_connected(NS3BaseNetDevice.get_rtype())
- if devices: return devices[0]
- return None
- @property
- def node(self):
- device = self.device
- if device: return device.node
- return None
+ if not devices:
+ msg = "WifiRemoteStationManager not connected to device"
+ self.error(msg)
+ raise RuntimeError, msg
+
+ return devices[0]
@property
- def others_to_wait(self):
- others = set()
- device = self.device
- if device: others.add(device)
- return others
+ def _rms_to_wait(self):
+ rms = set()
+ rms.add(self.device)
+ return rms
def _connect_object(self):
device = self.device
- if device and device.uuid not in self.connected:
+ if device.uuid not in self.connected:
self.simulator.invoke(device.uuid, "SetRemoteStationManager", self.uuid)
self._connected.add(device.uuid)
import os
import re
+base_types = ["ns3::Node",
+ "ns3::Application",
+ "ns3::NetDevice",
+ "ns3::Channel",
+ "ns3::Queue",
+ "ns3::Icmpv4L4Protocol",
+ "ns3::ArpL3Protocol",
+ "ns3::Ipv4L3Protocol",
+ "ns3::PropagationLossModel",
+ "ns3::PropagationDelayModel",
+ "ns3::WifiRemoteStationManager",
+ "ns3::WifiPhy",
+ "ns3::WifiMac",
+ "ns3::ErrorModel",
+ "ns3::ErrorRateModel"]
+
def discard(ns3, tid):
rtype = tid.GetName()
-
- words = ["variable", "object", "probe", "adaptor", "wrapper",
- "container", "derived", "simple"]
- for word in words:
- if rtype.lower().find(word) > -1:
- return True
-
- bases = ["ns3::Scheduler", "ns3::SimulatorImpl"]
type_id = ns3.TypeId()
- for base in bases:
- tid_base = type_id.LookupByName(base)
- if tid.IsChildOf(tid_base):
- return True
- return False
+ for type_name in base_types:
+ tid_base = type_id.LookupByName(type_name)
+ if type_name == rtype or tid.IsChildOf(tid_base):
+ return False
+
+ return True
def select_base_class(ns3, tid):
base_class_import = "from nepi.resources.ns3.ns3base import NS3Base"
rtype = tid.GetName()
- if rtype == "ns3::Node":
- base_class_import = "from nepi.resources.ns3.ns3node import NS3BaseNode"
- base_class = "NS3BaseNode"
- elif rtype == "ns3::Ipv4L3Protocol":
- base_class_import = "from nepi.resources.ns3.ns3ipv4l3protocol import NS3BaseIpv4L3Protocol"
- base_class = "NS3BaseIpv4L3Protocol"
- else:
- type_id = ns3.TypeId()
-
- bases = ["ns3::Application",
- "ns3::NetDevice",
- "ns3::Channel",
- "ns3::Queue",
- "ns3::PropagationLossModel",
- "ns3::PropagationDelayModel",
- "ns3::WifiRemoteStationManager",
- "ns3::WifiPhy",
- "ns3::WifiMac",
- "ns3::ErrorModel",
- "ns3::ErrorRateModel"]
-
- for base in bases:
- tid_base = type_id.LookupByName(base)
- if tid.IsChildOf(tid_base):
- base_class = "NS3Base" + base.replace("ns3::", "")
- base_module = "ns3" + base.replace("ns3::", "").lower()
- base_class_import = "from nepi.resources.ns3.%s import %s " % (
- base_module, base_class)
+ type_id = ns3.TypeId()
+
+ for type_name in base_types:
+ tid_base = type_id.LookupByName(type_name)
+ if type_name == rtype or tid.IsChildOf(tid_base):
+ base_class = "NS3Base" + type_name.replace("ns3::", "")
+ base_module = "ns3" + type_name.replace("ns3::", "").lower()
+ base_class_import = "from nepi.resources.ns3.%s import %s " % (
+ base_module, base_class)
return (base_class_import, base_class)
self.do_discover()
self.do_provision()
- self.debug("----- READY ---- ")
self.set_ready()
def do_start(self):
ec.set(p1, "prefix", "30")
ec.register_connection(nsnode1, p1)
q1 = ec.register_resource("ns3::DropTailQueue")
- ec.register_connection(nsnode1, q1)
+ ec.register_connection(p1, q1)
nsnode2 = ec.register_resource("ns3::Node")
ec.register_connection(nsnode2, simu)
ec.set(p2, "prefix", "30")
ec.register_connection(nsnode2, p2)
q2 = ec.register_resource("ns3::DropTailQueue")
- ec.register_connection(nsnode2, q2)
+ ec.register_connection(p2, q2)
# Create channel
chan = ec.register_resource("ns3::PointToPointChannel")
ec.deploy()
- time.sleep(5)
+ time.sleep(30)
ec.shutdown()
git://git.onelab.eu / nepi.git / commitdiff