# # CORE # Copyright (c)2011-2012 the Boeing Company. # See the LICENSE file included in this distribution. # # author: Jeff Ahrenholz # ''' mobility.py: mobility helpers for moving nodes and calculating wireless range. ''' import sys, os, time, string, math, threading import heapq from core.api import coreapi from core.conf import ConfigurableManager, Configurable from core.coreobj import PyCoreNode from core.misc.utils import check_call from core.misc.ipaddr import IPAddr class MobilityManager(ConfigurableManager): ''' Member of session class for handling configuration data for mobility and range models. ''' _name = "MobilityManager" _type = coreapi.CORE_TLV_REG_WIRELESS def __init__(self, session): ConfigurableManager.__init__(self, session) self.verbose = self.session.getcfgitembool('verbose', False) # configurations for basic range, indexed by WLAN node number, are # stored in self.configs # mapping from model names to their classes self._modelclsmap = {} # dummy node objects for tracking position of nodes on other servers self.phys = {} self.physnets = {} self.session.broker.handlers += (self.physnodehandlelink, ) self.register() def startup(self): ''' Session is transitioning from instantiation to runtime state. Instantiate any mobility models that have been configured for a WLAN. ''' for nodenum in self.configs: v = self.configs[nodenum] try: n = self.session.obj(nodenum) except KeyError: self.session.warn("Skipping mobility configuration for unknown" "node %d." % nodenum) continue for model in v: try: cls = self._modelclsmap[model[0]] except KeyError: self.session.warn("Skipping mobility configuration for " "unknown model '%s'" % model[0]) continue n.setmodel(cls, model[1]) if self.session.master: self.installphysnodes(n) if n.mobility: self.session.evq.add_event(0.0, n.mobility.startup) def reset(self): ''' Reset all configs. ''' self.clearconfig(nodenum=None) def register(self): ''' Register models as configurable object(s) with the Session object. ''' models = [BasicRangeModel, Ns2ScriptedMobility] for m in models: self.session.addconfobj(m._name, m._type, m.configure_mob) self._modelclsmap[m._name] = m def handleevent(self, msg): ''' Handle an Event Message used to start, stop, or pause mobility scripts for a given WlanNode. ''' eventtype = msg.gettlv(coreapi.CORE_TLV_EVENT_TYPE) nodenum = msg.gettlv(coreapi.CORE_TLV_EVENT_NODE) name = msg.gettlv(coreapi.CORE_TLV_EVENT_NAME) try: node = self.session.obj(nodenum) except KeyError: self.session.warn("Ignoring event for model '%s', unknown node " \ "'%s'" % (name, nodenum)) return # name is e.g. "mobility:ns2script" models = name[9:].split(',') for m in models: try: cls = self._modelclsmap[m] except KeyError: self.session.warn("Ignoring event for unknown model '%s'" % m) continue _name = "waypoint" if cls._type == coreapi.CORE_TLV_REG_WIRELESS: model = node.mobility elif cls._type == coreapi.CORE_TLV_REG_MOBILITY: model = node.mobility else: continue if model is None: self.session.warn("Ignoring event, %s has no model" % node.name) continue if cls._name != model._name: self.session.warn("Ignoring event for %s wrong model %s,%s" % \ (node.name, cls._name, model._name)) continue if eventtype == coreapi.CORE_EVENT_STOP or \ eventtype == coreapi.CORE_EVENT_RESTART: model.stop(move_initial=True) if eventtype == coreapi.CORE_EVENT_START or \ eventtype == coreapi.CORE_EVENT_RESTART: model.start() if eventtype == coreapi.CORE_EVENT_PAUSE: model.pause() def sendevent(self, model): ''' Send an event message on behalf of a mobility model. This communicates the current and end (max) times to the GUI. ''' if model.state == model.STATE_STOPPED: eventtype = coreapi.CORE_EVENT_STOP elif model.state == model.STATE_RUNNING: eventtype = coreapi.CORE_EVENT_START elif model.state == model.STATE_PAUSED: eventtype = coreapi.CORE_EVENT_PAUSE data = "start=%d" % int(model.lasttime - model.timezero) data += " end=%d" % int(model.endtime) tlvdata = "" tlvdata += coreapi.CoreEventTlv.pack(coreapi.CORE_TLV_EVENT_NODE, model.objid) tlvdata += coreapi.CoreEventTlv.pack(coreapi.CORE_TLV_EVENT_TYPE, eventtype) tlvdata += coreapi.CoreEventTlv.pack(coreapi.CORE_TLV_EVENT_NAME, "mobility:%s" % model._name) tlvdata += coreapi.CoreEventTlv.pack(coreapi.CORE_TLV_EVENT_DATA, data) tlvdata += coreapi.CoreEventTlv.pack(coreapi.CORE_TLV_EVENT_TIME, "%s" % time.time()) msg = coreapi.CoreEventMessage.pack(0, tlvdata) try: self.session.broadcastraw(None, msg) except Exception, e: self.warn("Error sending Event Message: %s" % e) def updatewlans(self, moved, moved_netifs): ''' A mobility script has caused nodes in the 'moved' list to move. Update every WlanNode. This saves range calculations if the model were to recalculate for each individual node movement. ''' for nodenum in self.configs: try: n = self.session.obj(nodenum) except KeyError: continue if n.model: n.model.update(moved, moved_netifs) def addphys(self, netnum, node): ''' Keep track of PhysicalNodes and which network they belong to. ''' nodenum = node.objid self.phys[nodenum] = node if netnum not in self.physnets: self.physnets[netnum] = [nodenum,] else: self.physnets[netnum].append(nodenum) def physnodehandlelink(self, msg): ''' Broker handler. Snoop Link add messages to get node numbers of PhyiscalNodes and their nets. Physical nodes exist only on other servers, but a shadow object is created here for tracking node position. ''' if msg.msgtype == coreapi.CORE_API_LINK_MSG and \ msg.flags & coreapi.CORE_API_ADD_FLAG: nn = msg.nodenumbers() # first node is always link layer node in Link add message if nn[0] not in self.session.broker.nets: return if nn[1] in self.session.broker.phys: # record the fact that this PhysicalNode is linked to a net dummy = PyCoreNode(session=self.session, objid=nn[1], name="n%d" % nn[1], start=False) self.addphys(nn[0], dummy) def physnodeupdateposition(self, msg): ''' Snoop node messages belonging to physical nodes. The dummy object in self.phys[] records the node position. ''' nodenum = msg.nodenumbers()[0] try: dummy = self.phys[nodenum] nodexpos = msg.gettlv(coreapi.CORE_TLV_NODE_XPOS) nodeypos = msg.gettlv(coreapi.CORE_TLV_NODE_YPOS) dummy.setposition(nodexpos, nodeypos, None) except KeyError: pass def installphysnodes(self, net): ''' After installing a mobility model on a net, include any physical nodes that we have recorded. Use the GreTap tunnel to the physical node as the node's interface. ''' try: nodenums = self.physnets[net.objid] except KeyError: return for nodenum in nodenums: node = self.phys[nodenum] servers = self.session.broker.getserversbynode(nodenum) (host, port, sock) = self.session.broker.getserver(servers[0]) netif = self.session.broker.gettunnel(net.objid, IPAddr.toint(host)) node.addnetif(netif, 0) netif.node = node (x,y,z) = netif.node.position.get() netif.poshook(netif, x, y, z) class WirelessModel(Configurable): ''' Base class used by EMANE models and the basic range model. Used for managing arbitrary configuration parameters. ''' _type = coreapi.CORE_TLV_REG_WIRELESS _bitmap = None _positioncallback = None def __init__(self, session, objid, verbose = False, values = None): Configurable.__init__(self, session, objid) self.verbose = verbose # 'values' can be retrieved from a ConfigurableManager, or used here # during initialization, depending on the model. def tolinkmsgs(self, flags): ''' May be used if the model can populate the GUI with wireless (green) link lines. ''' return [] def update(self, moved, moved_netifs): raise NotImplementedError class BasicRangeModel(WirelessModel): ''' Basic Range wireless model, calculates range between nodes and links and unlinks nodes based on this distance. This was formerly done from the GUI. ''' _name = "basic_range" # configuration parameters are # ( 'name', 'type', 'default', 'possible-value-list', 'caption') _confmatrix = [ ("range", coreapi.CONF_DATA_TYPE_UINT32, '275', '', 'wireless range (pixels)'), ("bandwidth", coreapi.CONF_DATA_TYPE_UINT32, '54000', '', 'bandwidth (bps)'), ("jitter", coreapi.CONF_DATA_TYPE_FLOAT, '0.0', '', 'transmission jitter (usec)'), ("delay", coreapi.CONF_DATA_TYPE_FLOAT, '5000.0', '', 'transmission delay (usec)'), ("error", coreapi.CONF_DATA_TYPE_FLOAT, '0.0', '', 'error rate (%)'), ] # value groupings _confgroups = "Basic Range Parameters:1-%d" % len(_confmatrix) def __init__(self, session, objid, verbose = False, values=None): ''' Range model is only instantiated during runtime. ''' super(BasicRangeModel, self).__init__(session = session, objid = objid, verbose = verbose) self.wlan = session.obj(objid) self._netifs = {} self._netifslock = threading.Lock() if values is None: values = session.mobility.getconfig(objid, self._name, self.getdefaultvalues())[1] self.range = float(self.valueof("range", values)) if self.verbose: self.session.info("Basic range model configured for WLAN %d using" \ " range %d" % (objid, self.range)) self.bw = int(self.valueof("bandwidth", values)) if self.bw == 0.0: self.bw = None self.delay = float(self.valueof("delay", values)) if self.delay == 0.0: self.delay = None self.loss = float(self.valueof("error", values)) if self.loss == 0.0: self.loss = None self.jitter = float(self.valueof("jitter", values)) if self.jitter == 0.0: self.jitter = None @classmethod def configure_mob(cls, session, msg): ''' Handle configuration messages for setting up a model. Pass the MobilityManager object as the manager object. ''' return cls.configure(session.mobility, msg) def setlinkparams(self): ''' Apply link parameters to all interfaces. This is invoked from WlanNode.setmodel() after the position callback has been set. ''' with self._netifslock: for netif in self._netifs: self.wlan.linkconfig(netif, bw=self.bw, delay=self.delay, loss=self.loss, duplicate=None, jitter=self.jitter) def get_position(self, netif): with self._netifslock: return self._netifs[netif] def set_position(self, netif, x = None, y = None, z = None): ''' A node has moved; given an interface, a new (x,y,z) position has been set; calculate the new distance between other nodes and link or unlink node pairs based on the configured range. ''' #print "set_position(%s, x=%s, y=%s, z=%s)" % (netif.localname, x, y, z) self._netifslock.acquire() self._netifs[netif] = (x, y, z) if x is None or y is None: self._netifslock.release() return for netif2 in self._netifs: self.calclink(netif, netif2) self._netifslock.release() _positioncallback = set_position def update(self, moved, moved_netifs): ''' Node positions have changed without recalc. Update positions from node.position, then re-calculate links for those that have moved. Assumes bidirectional links, with one calculation per node pair, where one of the nodes has moved. ''' with self._netifslock: while len(moved_netifs): netif = moved_netifs.pop() (nx, ny, nz) = netif.node.getposition() if netif in self._netifs: self._netifs[netif] = (nx, ny, nz) for netif2 in self._netifs: if netif2 in moved_netifs: continue self.calclink(netif, netif2) def calclink(self, netif, netif2): ''' Helper used by set_position() and update() to calculate distance between two interfaces and perform linking/unlinking. Sends link/unlink messages and updates the WlanNode's linked dict. ''' if netif == netif2: return (x, y, z) = self._netifs[netif] (x2, y2, z2) = self._netifs[netif2] if x2 is None or y2 is None: return d = self.calcdistance( (x,y,z), (x2,y2,z2) ) # ordering is important, to keep the wlan._linked dict organized a = min(netif, netif2) b = max(netif, netif2) try: self.wlan._linked_lock.acquire() linked = self.wlan.linked(a, b) except KeyError: return finally: self.wlan._linked_lock.release() if d > self.range: if linked: self.wlan.unlink(a, b) self.sendlinkmsg(a, b, unlink=True) else: if not linked: self.wlan.link(a, b) self.sendlinkmsg(a, b) def calcdistance(self, p1, p2): ''' Calculate the distance between two three-dimensional points. ''' a = p1[0] - p2[0] b = p1[1] - p2[1] c = 0 if p1[2] is not None and p2[2] is not None: c = p1[2] - p2[2] return math.hypot(math.hypot(a, b), c) def linkmsg(self, netif, netif2, flags): ''' Create a wireless link/unlink API message. ''' n1 = netif.localname.split('.')[0] n2 = netif2.localname.split('.')[0] tlvdata = coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_N1NUMBER, netif.node.objid) tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_N2NUMBER, netif2.node.objid) tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_NETID, self.wlan.objid) #tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_IF1NUM, # netif.index) #tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_IF2NUM, # netif2.index) tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_TYPE, coreapi.CORE_LINK_WIRELESS) return coreapi.CoreLinkMessage.pack(flags, tlvdata) def sendlinkmsg(self, netif, netif2, unlink=False): ''' Send a wireless link/unlink API message to the GUI. ''' if unlink: flags = coreapi.CORE_API_DEL_FLAG else: flags = coreapi.CORE_API_ADD_FLAG msg = self.linkmsg(netif, netif2, flags) self.session.broadcastraw(src=None, data=msg) self.session.sdt.updatelink(netif.node.objid, netif2.node.objid, flags, wireless=True) def tolinkmsgs(self, flags): ''' Return a list of wireless link messages for when the GUI reconnects. ''' r = [] with self.wlan._linked_lock: for a in self.wlan._linked: for b in self.wlan._linked[a]: if self.wlan._linked[a][b]: r.append(self.linkmsg(a, b, flags)) return r class WayPointMobility(WirelessModel): ''' Abstract class for mobility models that set node waypoints. ''' _name = "waypoint" _type = coreapi.CORE_TLV_REG_MOBILITY STATE_STOPPED = 0 STATE_RUNNING = 1 STATE_PAUSED = 2 class WayPoint(object): def __init__(self, time, nodenum, coords, speed): self.time = time self.nodenum = nodenum self.coords = coords self.speed = speed def __cmp__(self, other): tmp = cmp(self.time, other.time) if tmp == 0: tmp = cmp(self.nodenum, other.nodenum) return tmp def __init__(self, session, objid, verbose = False, values = None): super(WayPointMobility, self).__init__(session = session, objid = objid, verbose = verbose, values = values) self.state = self.STATE_STOPPED self.queue = [] self.queue_copy = [] self.points = {} self.initial = {} self.lasttime = None self.endtime = None self.wlan = session.obj(objid) # these are really set in child class via confmatrix self.loop = False self.refresh_ms = 50 # flag whether to stop scheduling when queue is empty # (ns-3 sets this to False as new waypoints may be added from trace) self.empty_queue_stop = True def runround(self): ''' Advance script time and move nodes. ''' if self.state != self.STATE_RUNNING: return t = self.lasttime self.lasttime = time.time() now = self.lasttime - self.timezero dt = self.lasttime - t #print "runround(now=%.2f, dt=%.2f)" % (now, dt) # keep current waypoints up-to-date self.updatepoints(now) if not len(self.points): if len(self.queue): # more future waypoints, allow time for self.lasttime update nexttime = self.queue[0].time - now if nexttime > (0.001 * self.refresh_ms): nexttime -= (0.001 * self.refresh_ms) self.session.evq.add_event(nexttime, self.runround) return else: # no more waypoints or queued items, loop? if not self.empty_queue_stop: # keep running every refresh_ms, even with empty queue self.session.evq.add_event(0.001 * self.refresh_ms, self.runround) return if not self.loopwaypoints(): return self.stop(move_initial=False) if not len(self.queue): # prevent busy loop return return self.run() # only move netifs attached to self.wlan, or all nodenum in script? moved = [] moved_netifs = [] for netif in self.wlan.netifs(): node = netif.node if self.movenode(node, dt): moved.append(node) moved_netifs.append(netif) # calculate all ranges after moving nodes; this saves calculations #self.wlan.model.update(moved) self.session.mobility.updatewlans(moved, moved_netifs) # TODO: check session state self.session.evq.add_event(0.001 * self.refresh_ms, self.runround) def run(self): self.timezero = time.time() self.lasttime = self.timezero - (0.001 * self.refresh_ms) self.movenodesinitial() self.runround() self.session.mobility.sendevent(self) def movenode(self, node, dt): ''' Calculate next node location and update its coordinates. Returns True if the node's position has changed. ''' if node.objid not in self.points: return False x1, y1, z1 = node.getposition() x2, y2, z2 = self.points[node.objid].coords speed = self.points[node.objid].speed # instantaneous move (prevents dx/dy == 0.0 below) if speed == 0: self.setnodeposition(node, x2, y2, z2) del self.points[node.objid] return True # speed can be a velocity vector (ns3 mobility) or speed value if isinstance(speed, (float, int)): # linear speed value alpha = math.atan2(y2 - y1, x2 - x1) sx = speed * math.cos(alpha) sy = speed * math.sin(alpha) else: # velocity vector sx = speed[0] sy = speed[1] # calculate dt * speed = distance moved dx = sx * dt dy = sy * dt # prevent overshoot if abs(dx) > abs(x2 - x1): dx = x2 - x1 if abs(dy) > abs(y2 - y1): dy = y2 - y1 if dx == 0.0 and dy == 0.0: if self.endtime < (self.lasttime - self.timezero): # the last node to reach the last waypoint determines this # script's endtime self.endtime = self.lasttime - self.timezero del self.points[node.objid] return False #print "node %s dx,dy= <%s, %d>" % (node.name, dx, dy) if (x1 + dx) < 0.0: dx = 0.0 - x1 if (y1 + dy) < 0.0: dy = 0.0 - y1 self.setnodeposition(node, x1 + dx, y1 + dy, z1) return True def movenodesinitial(self): ''' Move nodes to their initial positions. Then calculate the ranges. ''' moved = [] moved_netifs = [] for netif in self.wlan.netifs(): node = netif.node if node.objid not in self.initial: continue (x, y, z) = self.initial[node.objid].coords self.setnodeposition(node, x, y, z) moved.append(node) moved_netifs.append(netif) #self.wlan.model.update(moved) self.session.mobility.updatewlans(moved, moved_netifs) def addwaypoint(self, time, nodenum, x, y, z, speed): ''' Waypoints are pushed to a heapq, sorted by time. ''' #print "addwaypoint: %s %s %s,%s,%s %s" % (time, nodenum, x, y, z, speed) wp = self.WayPoint(time, nodenum, coords=(x,y,z), speed=speed) heapq.heappush(self.queue, wp) def addinitial(self, nodenum, x, y, z): ''' Record initial position in a dict. ''' wp = self.WayPoint(0, nodenum, coords=(x,y,z), speed=0) self.initial[nodenum] = wp def updatepoints(self, now): ''' Move items from self.queue to self.points when their time has come. ''' while len(self.queue): if self.queue[0].time > now: break wp = heapq.heappop(self.queue) self.points[wp.nodenum] = wp def copywaypoints(self): ''' Store backup copy of waypoints for looping and stopping. ''' self.queue_copy = list(self.queue) def loopwaypoints(self): ''' Restore backup copy of waypoints when looping. ''' self.queue = list(self.queue_copy) return self.loop def setnodeposition(self, node, x, y, z): ''' Helper to move a node, notify any GUI (connected session handlers), without invoking the interface poshook callback that may perform range calculation. ''' # this would cause PyCoreNetIf.poshook() callback (range calculation) #node.setposition(x, y, z) node.position.set(x, y, z) msg = node.tonodemsg(flags=0) self.session.broadcastraw(None, msg) self.session.sdt.updatenode(node, flags=0, x=x, y=y, z=z) def setendtime(self): ''' Set self.endtime to the time of the last waypoint in the queue of waypoints. This is just an estimate. The endtime will later be adjusted, after one round of the script has run, to be the time that the last moving node has reached its final waypoint. ''' try: self.endtime = self.queue[-1].time except IndexError: self.endtime = 0 def start(self): ''' Run the script from the beginning or unpause from where it was before. ''' laststate = self.state self.state = self.STATE_RUNNING if laststate == self.STATE_STOPPED or laststate == self.STATE_RUNNING: self.loopwaypoints() self.timezero = 0 self.lasttime = 0 self.run() elif laststate == self.STATE_PAUSED: now = time.time() self.timezero += now - self.lasttime self.lasttime = now - (0.001 * self.refresh_ms) self.runround() def stop(self, move_initial=True): ''' Stop the script and move nodes to initial positions. ''' self.state = self.STATE_STOPPED self.loopwaypoints() self.timezero = 0 self.lasttime = 0 if move_initial: self.movenodesinitial() self.session.mobility.sendevent(self) def pause(self): ''' Pause the script; pause time is stored to self.lasttime. ''' self.state = self.STATE_PAUSED self.lasttime = time.time() class Ns2ScriptedMobility(WayPointMobility): ''' Handles the ns-2 script format, generated by scengen/setdest or BonnMotion. ''' _name = "ns2script" _confmatrix = [ ("file", coreapi.CONF_DATA_TYPE_STRING, '', '', 'mobility script file'), ("refresh_ms", coreapi.CONF_DATA_TYPE_UINT32, '50', '', 'refresh time (ms)'), ("loop", coreapi.CONF_DATA_TYPE_BOOL, '1', 'On,Off', 'loop'), ("autostart", coreapi.CONF_DATA_TYPE_STRING, '', '', 'auto-start seconds (0.0 for runtime)'), ("map", coreapi.CONF_DATA_TYPE_STRING, '', '', 'node mapping (optional, e.g. 0:1,1:2,2:3)'), ("script_start", coreapi.CONF_DATA_TYPE_STRING, '', '', 'script file to run upon start'), ("script_pause", coreapi.CONF_DATA_TYPE_STRING, '', '', 'script file to run upon pause'), ("script_stop", coreapi.CONF_DATA_TYPE_STRING, '', '', 'script file to run upon stop'), ] _confgroups = "ns-2 Mobility Script Parameters:1-%d" % len(_confmatrix) def __init__(self, session, objid, verbose = False, values = None): ''' ''' super(Ns2ScriptedMobility, self).__init__(session = session, objid = objid, verbose = verbose, values = values) self._netifs = {} self._netifslock = threading.Lock() if values is None: values = session.mobility.getconfig(objid, self._name, self.getdefaultvalues())[1] self.file = self.valueof("file", values) self.refresh_ms = int(self.valueof("refresh_ms", values)) self.loop = (self.valueof("loop", values).lower() == "on") self.autostart = self.valueof("autostart", values) self.parsemap(self.valueof("map", values)) self.script_start = self.valueof("script_start", values) self.script_pause = self.valueof("script_pause", values) self.script_stop = self.valueof("script_stop", values) if self.verbose: self.session.info("ns-2 scripted mobility configured for WLAN %d" \ " using file: %s" % (objid, self.file)) self.readscriptfile() self.copywaypoints() self.setendtime() @classmethod def configure_mob(cls, session, msg): ''' Handle configuration messages for setting up a model. Pass the MobilityManager object as the manager object. ''' return cls.configure(session.mobility, msg) def readscriptfile(self): ''' Read in mobility script from a file. This adds waypoints to a priority queue, sorted by waypoint time. Initial waypoints are stored in a separate dict. ''' filename = self.findfile(self.file) try: f = open(filename, 'r') except IOError, e: self.session.warn("ns-2 scripted mobility failed to load file " \ " '%s' (%s)" % (self.file, e)) return if self.verbose: self.session.info("reading ns-2 script file: %s" % filename) ln = 0 ix = iy = iz = None inodenum = None for line in f: ln += 1 if line[:2] != '$n': continue try: if line[:8] == "$ns_ at ": if ix is not None and iy is not None: self.addinitial(self.map(inodenum), ix, iy, iz) ix = iy = iz = None # waypoints: # $ns_ at 1.00 "$node_(6) setdest 500.0 178.0 25.0" parts = line.split() time = float(parts[2]) nodenum = parts[3][1+parts[3].index('('):parts[3].index(')')] x = float(parts[5]) y = float(parts[6]) z = None speed = float(parts[7].strip('"')) self.addwaypoint(time, self.map(nodenum), x, y, z, speed) elif line[:7] == "$node_(": # initial position (time=0, speed=0): # $node_(6) set X_ 780.0 parts = line.split() time = 0.0 nodenum = parts[0][1+parts[0].index('('):parts[0].index(')')] if parts[2] == 'X_': if ix is not None and iy is not None: self.addinitial(self.map(inodenum), ix, iy, iz) ix = iy = iz = None ix = float(parts[3]) elif parts[2] == 'Y_': iy = float(parts[3]) elif parts[2] == 'Z_': iz = float(parts[3]) self.addinitial(self.map(nodenum), ix, iy, iz) ix = iy = iz = None inodenum = nodenum else: raise ValueError except ValueError, e: self.session.warn("skipping line %d of file %s '%s' (%s)" % \ (ln, self.file, line, e)) continue if ix is not None and iy is not None: self.addinitial(self.map(inodenum), ix, iy, iz) def findfile(self, fn): ''' Locate a script file. If the specified file doesn't exist, look in the same directory as the scenario file (session.filename), or in the default configs directory (~/.core/configs). This allows for sample files without absolute pathnames. ''' if os.path.exists(fn): return fn if self.session.filename is not None: d = os.path.dirname(self.session.filename) sessfn = os.path.join(d, fn) if (os.path.exists(sessfn)): return sessfn if self.session.user is not None: userfn = os.path.join('/home', self.session.user, '.core', 'configs', fn) if (os.path.exists(userfn)): return userfn return fn def parsemap(self, mapstr): ''' Parse a node mapping string, given as a configuration parameter. ''' self.nodemap = {} if mapstr.strip() == '': return for pair in mapstr.split(','): parts = pair.split(':') try: if len(parts) != 2: raise ValueError self.nodemap[int(parts[0])] = int(parts[1]) except ValueError: self.session.warn("ns-2 mobility node map error") return def map(self, nodenum): ''' Map one node number (from a script file) to another. ''' nodenum = int(nodenum) try: return self.nodemap[nodenum] except KeyError: return nodenum def startup(self): ''' Start running the script if autostart is enabled. Move node to initial positions when any autostart time is specified. Ignore the script if autostart is an empty string (can still be started via GUI controls). ''' if self.autostart == '': if self.verbose: self.session.info("not auto-starting ns-2 script for %s" % \ self.wlan.name) return try: t = float(self.autostart) except ValueError: self.session.warn("Invalid auto-start seconds specified '%s' for " \ "%s" % (self.autostart, self.wlan.name)) return self.movenodesinitial() if self.verbose: self.session.info("scheduling ns-2 script for %s autostart at %s" \ % (self.wlan.name, t)) self.state = self.STATE_RUNNING self.session.evq.add_event(t, self.run) def start(self): ''' Handle the case when un-paused. ''' laststate = self.state super(Ns2ScriptedMobility, self).start() if laststate == self.STATE_PAUSED: self.statescript("unpause") def run(self): ''' Start is pressed or autostart is triggered. ''' super(Ns2ScriptedMobility, self).run() self.statescript("run") def pause(self): super(Ns2ScriptedMobility, self).pause() self.statescript("pause") def stop(self, move_initial=True): super(Ns2ScriptedMobility, self).stop(move_initial=move_initial) self.statescript("stop") def statescript(self, typestr): filename = None if typestr == "run" or typestr == "unpause": filename = self.script_start elif typestr == "pause": filename = self.script_pause elif typestr == "stop": filename = self.script_stop if filename is None or filename == '': return filename = self.findfile(filename) try: check_call(["/bin/sh", filename, typestr], cwd=self.session.sessiondir, env=self.session.getenviron()) except Exception, e: self.session.warn("Error running script '%s' for WLAN state %s: " \ "%s" % (filename, typestr, e))