initial import (Boeing r1752, NRL r878)

daemon/core/netns/nodes.py

@@ -0,0 +1,401 @@
+#
+# CORE
+# Copyright (c)2010-2013 the Boeing Company.
+# See the LICENSE file included in this distribution.
+#
+# authors: Tom Goff <thomas.goff@boeing.com>
+#          Jeff Ahrenholz <jeffrey.m.ahrenholz@boeing.com>
+#
+'''
+nodes.py: definition of an LxcNode and CoreNode classes, and other node classes
+that inherit from the CoreNode, implementing specific node types.
+'''
+
+from vnode import *
+from vnet import *
+from core.misc.ipaddr import *
+from core.api import coreapi
+from core.coreobj import PyCoreNode
+
+class CtrlNet(LxBrNet):
+    policy = "ACCEPT"
+    CTRLIF_IDX_BASE = 99  # base control interface index
+
+    def __init__(self, session, objid = "ctrlnet", name = None,
+                 verbose = False, netid = 1, prefix = None,
+                 hostid = None, start = True, assign_address = True,
+                 updown_script = None):
+        if not prefix:
+            prefix = "172.16.%d.0/24" % netid
+        self.prefix = IPv4Prefix(prefix)
+        self.hostid = hostid
+        self.assign_address = assign_address
+        self.updown_script = updown_script
+        LxBrNet.__init__(self, session, objid = objid, name = name,
+                         verbose = verbose, start = start)
+
+    def startup(self):
+        LxBrNet.startup(self)
+        if self.hostid:
+            addr = self.prefix.addr(self.hostid)
+        else:
+            addr = self.prefix.maxaddr()
+        addrlist = ["%s/%s" % (addr, self.prefix.prefixlen)]
+        if self.assign_address:
+            self.addrconfig(addrlist = addrlist)
+        if self.updown_script is not None:
+            self.info("interface %s updown script '%s startup' called" % \
+                      (self.brname, self.updown_script))
+            check_call([self.updown_script, self.brname, "startup"])
+
+    def shutdown(self):
+        if self.updown_script is not None:
+            self.info("interface %s updown script '%s shutdown' called" % \
+                      (self.brname, self.updown_script))
+            check_call([self.updown_script, self.brname, "shutdown"])
+        LxBrNet.shutdown(self)
+
+    def tolinkmsgs(self, flags):
+        ''' Do not include CtrlNet in link messages describing this session.
+        '''
+        return []
+
+class CoreNode(LxcNode):
+    apitype = coreapi.CORE_NODE_DEF
+
+class PtpNet(LxBrNet):
+    policy = "ACCEPT"
+
+    def attach(self, netif):
+        if len(self._netif) > 1:
+            raise ValueError, \
+                  "Point-to-point links support at most 2 network interfaces"
+        LxBrNet.attach(self, netif)
+
+    def tonodemsg(self, flags):
+        ''' Do not generate a Node Message for point-to-point links. They are
+            built using a link message instead.
+        '''
+        pass
+
+    def tolinkmsgs(self, flags):
+        ''' Build CORE API TLVs for a point-to-point link. One Link message
+            describes this network.
+        '''
+        tlvdata = ""
+        if len(self._netif) != 2:
+            return tlvdata
+        (if1, if2) = self._netif.items()
+        if1 = if1[1]
+        if2 = if2[1]
+        tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_N1NUMBER,
+                                            if1.node.objid)
+        tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_N2NUMBER,
+                                            if2.node.objid)
+        delay = if1.getparam('delay')
+        bw = if1.getparam('bw')
+        loss = if1.getparam('loss')
+        duplicate = if1.getparam('duplicate')
+        jitter = if1.getparam('jitter')
+        if delay is not None:
+            tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_DELAY,
+                                                delay)
+        if bw is not None:
+            tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_BW, bw)
+        if loss is not None:
+            tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_PER,
+                                                str(loss))
+        if duplicate is not None:
+            tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_DUP,
+                                                str(duplicate))
+        if jitter is not None:
+            tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_JITTER,
+                                                jitter)
+        tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_TYPE,
+                                            self.linktype)
+
+        tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_IF1NUM, \
+                                            if1.node.getifindex(if1))
+        for addr in if1.addrlist:
+            (ip, sep, mask)  = addr.partition('/')
+            mask = int(mask)
+            if isIPv4Address(ip):
+                family = AF_INET
+                tlvtypeip = coreapi.CORE_TLV_LINK_IF1IP4
+                tlvtypemask = coreapi.CORE_TLV_LINK_IF1IP4MASK
+            else:
+                family = AF_INET6
+                tlvtypeip = coreapi.CORE_TLV_LINK_IF1IP6
+                tlvtypemask = coreapi.CORE_TLV_LINK_IF1IP6MASK
+            ipl = socket.inet_pton(family, ip)
+            tlvdata += coreapi.CoreLinkTlv.pack(tlvtypeip,
+                                                IPAddr(af=family, addr=ipl))
+            tlvdata += coreapi.CoreLinkTlv.pack(tlvtypemask, mask)
+
+        tlvdata += coreapi.CoreLinkTlv.pack(coreapi.CORE_TLV_LINK_IF2NUM, \
+                                            if2.node.getifindex(if2))
+        for addr in if2.addrlist:
+            (ip, sep, mask)  = addr.partition('/')
+            mask = int(mask)
+            if isIPv4Address(ip):
+                family = AF_INET
+                tlvtypeip = coreapi.CORE_TLV_LINK_IF2IP4
+                tlvtypemask = coreapi.CORE_TLV_LINK_IF2IP4MASK
+            else:
+                family = AF_INET6
+                tlvtypeip = coreapi.CORE_TLV_LINK_IF2IP6
+                tlvtypemask = coreapi.CORE_TLV_LINK_IF2IP6MASK
+            ipl = socket.inet_pton(family, ip)
+            tlvdata += coreapi.CoreLinkTlv.pack(tlvtypeip,
+                                                IPAddr(af=family, addr=ipl))
+            tlvdata += coreapi.CoreLinkTlv.pack(tlvtypemask, mask)
+        msg = coreapi.CoreLinkMessage.pack(flags, tlvdata)
+        return [msg,]
+
+class SwitchNode(LxBrNet):
+    apitype = coreapi.CORE_NODE_SWITCH
+    policy = "ACCEPT"
+    type = "lanswitch"
+
+class HubNode(LxBrNet):
+    apitype = coreapi.CORE_NODE_HUB
+    policy = "ACCEPT"
+    type = "hub"
+    
+    def __init__(self, session, objid = None, name = None, verbose = False,
+                        start = True):
+        ''' the Hub node forwards packets to all bridge ports by turning off
+            the MAC address learning
+        '''
+        LxBrNet.__init__(self, session, objid, name, verbose, start)
+        if start:
+            check_call([BRCTL_BIN, "setageing", self.brname, "0"])
+
+
+class WlanNode(LxBrNet):
+    apitype = coreapi.CORE_NODE_WLAN
+    linktype = coreapi.CORE_LINK_WIRELESS
+    policy = "DROP"
+    type = "wlan"
+    
+    def __init__(self, session, objid = None, name = None, verbose = False,
+                        start = True, policy = None):
+        LxBrNet.__init__(self, session, objid, name, verbose, start, policy)
+        # wireless model such as basic range
+        self.model = None
+        # mobility model such as scripted
+        self.mobility = None
+        
+    def attach(self, netif):
+        LxBrNet.attach(self, netif)
+        if self.model:
+            netif.poshook = self.model._positioncallback
+            if netif.node is None:
+                return
+            (x,y,z) = netif.node.position.get()
+            # invokes any netif.poshook
+            netif.setposition(x, y, z)
+            #self.model.setlinkparams()
+        
+    def setmodel(self, model, config):
+        ''' Mobility and wireless model.
+        '''
+        if (self.verbose):
+            self.info("adding model %s" % model._name)
+        if model._type == coreapi.CORE_TLV_REG_WIRELESS:
+            self.model = model(session=self.session, objid=self.objid,
+                               verbose=self.verbose, values=config)
+            if self.model._positioncallback:
+                for netif in self.netifs():
+                    netif.poshook = self.model._positioncallback
+                    if netif.node is not None:
+                        (x,y,z) = netif.node.position.get()
+                        netif.poshook(netif, x, y, z)
+            self.model.setlinkparams()
+        elif model._type == coreapi.CORE_TLV_REG_MOBILITY:
+            self.mobility = model(session=self.session, objid=self.objid,
+                               verbose=self.verbose, values=config)
+        
+    def tolinkmsgs(self, flags):
+        msgs = LxBrNet.tolinkmsgs(self, flags)
+        if self.model:
+            msgs += self.model.tolinkmsgs(flags)
+        return msgs
+
+
+class RJ45Node(PyCoreNode, PyCoreNetIf):
+    ''' RJ45Node is a physical interface on the host linked to the emulated
+        network.
+    '''
+    apitype = coreapi.CORE_NODE_RJ45
+    
+    def __init__(self, session, objid = None, name = None, mtu = 1500,
+                 verbose = False, start = True):
+        PyCoreNode.__init__(self, session, objid, name, verbose=verbose,
+                            start=start)
+        # this initializes net, params, poshook
+        PyCoreNetIf.__init__(self, node=self, name=name, mtu = mtu)
+        self.up = False
+        self.lock = threading.RLock()
+        self.ifindex = None
+        # the following are PyCoreNetIf attributes
+        self.transport_type = "raw"
+        self.localname = name
+        self.type = "rj45"
+        if start:
+            self.startup()
+
+    def startup(self):
+        ''' Set the interface in the up state.
+        '''
+        # interface will also be marked up during net.attach()
+        self.savestate()
+        try:
+            check_call([IP_BIN, "link", "set", self.localname, "up"])
+        except:
+            self.warn("Failed to run command: %s link set %s up" % \
+                      (IP_BIN, self.localname))
+            return
+        self.up = True
+        
+    def shutdown(self):
+        ''' Bring the interface down. Remove any addresses and queuing
+            disciplines.
+        '''
+        if not self.up:
+            return
+        check_call([IP_BIN, "link", "set", self.localname, "down"])
+        check_call([IP_BIN, "addr", "flush", "dev", self.localname])
+        mutecall([TC_BIN, "qdisc", "del", "dev", self.localname, "root"])
+        self.up = False
+        self.restorestate()
+        
+    def attachnet(self, net):
+        PyCoreNetIf.attachnet(self, net)
+        
+    def detachnet(self):
+        PyCoreNetIf.detachnet(self)
+
+    def newnetif(self, net = None, addrlist = [], hwaddr = None,
+                 ifindex = None, ifname = None):        
+        ''' This is called when linking with another node. Since this node 
+            represents an interface, we do not create another object here,
+            but attach ourselves to the given network.
+        '''
+        self.lock.acquire()
+        try:
+            if ifindex is None:
+                ifindex = 0
+            if self.net is not None:
+                raise ValueError, \
+                        "RJ45 nodes support at most 1 network interface"
+            self._netif[ifindex] = self
+            self.node = self # PyCoreNetIf.node is self
+            self.ifindex = ifindex
+            if net is not None:
+                self.attachnet(net)
+            for addr in maketuple(addrlist):
+                self.addaddr(addr)
+            return ifindex
+        finally:
+            self.lock.release()
+    
+    def delnetif(self, ifindex):
+        if ifindex is None:
+            ifindex = 0
+        if ifindex not in self._netif:
+            raise ValueError, "ifindex %s does not exist" % ifindex
+        self._netif.pop(ifindex)
+        if ifindex == self.ifindex:
+            self.shutdown()
+        else:
+            raise ValueError, "ifindex %s does not exist" % ifindex
+
+    def netif(self, ifindex, net=None):
+        ''' This object is considered the network interface, so we only
+            return self here. This keeps the RJ45Node compatible with
+            real nodes.
+        '''
+        if net is not None and net == self.net:
+            return self
+        if ifindex is None:
+            ifindex = 0
+        if ifindex == self.ifindex:
+            return self
+        return None
+    
+    def getifindex(self, netif):
+        if netif != self:
+            return None
+        return self.ifindex
+        
+    def addaddr(self, addr):
+        if self.up:
+            check_call([IP_BIN, "addr", "add", str(addr), "dev", self.name])
+        PyCoreNetIf.addaddr(self, addr)
+
+    def deladdr(self, addr):
+        if self.up:
+            check_call([IP_BIN, "addr", "del", str(addr), "dev", self.name])
+        PyCoreNetIf.deladdr(self, addr)
+        
+    def savestate(self):
+        ''' Save the addresses and other interface state before using the
+        interface for emulation purposes. TODO: save/restore the PROMISC flag
+        '''
+        self.old_up = False
+        self.old_addrs = []
+        cmd = [IP_BIN, "addr", "show", "dev", self.localname]
+        try:
+            tmp = subprocess.Popen(cmd, stdout = subprocess.PIPE)
+        except OSError:
+            self.warn("Failed to run %s command: %s" % (IP_BIN, cmd))
+        if tmp.wait():
+            self.warn("Command failed: %s" % cmd)
+            return
+        lines = tmp.stdout.read()
+        tmp.stdout.close()
+        for l in lines.split('\n'):
+            items = l.split()
+            if len(items) < 2:
+                continue
+            if items[1] == "%s:" % self.localname:
+                flags = items[2][1:-1].split(',')
+                if "UP" in flags:
+                    self.old_up = True
+            elif items[0] == "inet":
+                self.old_addrs.append((items[1], items[3]))
+            elif items[0] == "inet6":
+                if items[1][:4] == "fe80":
+                    continue
+                self.old_addrs.append((items[1], None))
+                    
+    def restorestate(self):
+        ''' Restore the addresses and other interface state after using it.
+        '''
+        for addr in self.old_addrs:
+            if addr[1] is None:
+                check_call([IP_BIN, "addr", "add", addr[0], "dev",
+                            self.localname])
+            else:
+                check_call([IP_BIN, "addr", "add", addr[0], "brd", addr[1], 
+                            "dev", self.localname])
+        if self.old_up:
+            check_call([IP_BIN, "link", "set", self.localname, "up"])
+            
+    def setposition(self, x=None, y=None, z=None):
+        ''' Use setposition() from both parent classes.
+        '''
+        PyCoreObj.setposition(self, x, y, z)
+        # invoke any poshook
+        PyCoreNetIf.setposition(self, x, y, z)
+               
+            
+
+
+
+class TunnelNode(GreTapBridge):
+    apitype = coreapi.CORE_NODE_TUNNEL
+    policy = "ACCEPT"
+    type = "tunnel"
+

daemon/core/netns/vif.py

@@ -0,0 +1,168 @@
+#
+# CORE
+# Copyright (c)2011-2012 the Boeing Company.
+# See the LICENSE file included in this distribution.
+#
+# authors: Tom Goff <thomas.goff@boeing.com>
+#          Jeff Ahrenholz <jeffrey.m.ahrenholz@boeing.com>
+#
+'''
+vif.py: PyCoreNetIf classes that implement the interfaces available
+under Linux.
+'''
+
+import os, signal, shutil, sys, subprocess, vnodeclient, threading, string
+import random, time
+from core.api import coreapi
+from core.misc.utils import *
+from core.constants import *
+from core.coreobj import PyCoreObj, PyCoreNode, PyCoreNetIf, Position
+from core.emane.nodes import EmaneNode
+
+checkexec([IP_BIN])
+
+class VEth(PyCoreNetIf):
+    def __init__(self, node, name, localname, mtu = 1500, net = None,
+                 start = True):
+        # note that net arg is ignored
+        PyCoreNetIf.__init__(self, node = node, name = name, mtu = mtu)
+        self.localname = localname
+        self.up = False
+        if start:
+            self.startup()
+
+    def startup(self):
+        check_call([IP_BIN, "link", "add", "name", self.localname,
+                    "type", "veth", "peer", "name", self.name])
+        check_call([IP_BIN, "link", "set", self.localname, "up"])
+        self.up = True
+
+    def shutdown(self):
+        if not self.up:
+            return
+        if self.node:
+            self.node.cmd([IP_BIN, "-6", "addr", "flush", "dev", self.name])
+        if self.localname:
+            mutedetach([IP_BIN, "link", "delete", self.localname])
+        self.up = False
+
+
+class TunTap(PyCoreNetIf):
+    ''' TUN/TAP virtual device in TAP mode
+    '''
+    def __init__(self, node, name, localname, mtu = 1500, net = None,
+                 start = True):
+        PyCoreNetIf.__init__(self, node = node, name = name, mtu = mtu)
+        self.localname = localname
+        self.up = False
+        self.transport_type = "virtual"
+        if start:
+            self.startup()
+
+    def startup(self):
+        # TODO: more sophisticated TAP creation here
+        #   Debian does not support -p (tap) option, RedHat does.
+        # For now, this is disabled to allow the TAP to be created by another 
+        # system (e.g. EMANE's emanetransportd)
+        #check_call(["tunctl", "-t", self.name])
+        # self.install()
+        self.up = True
+
+    def shutdown(self):
+        if not self.up:
+            return
+        self.node.cmd([IP_BIN, "-6", "addr", "flush", "dev", self.name])
+        #if self.name:
+        #    mutedetach(["tunctl", "-d", self.localname])
+        self.up = False
+
+    def install(self):
+        ''' Install this TAP into its namespace. This is not done from the
+            startup() method but called at a later time when a userspace
+            program (running on the host) has had a chance to open the socket
+            end of the TAP.
+        '''
+        netns = str(self.node.pid)
+        # check for presence of device - tap device may not appear right away
+        # waits ~= stime * ( 2 ** attempts) seconds 
+        attempts = 9
+        stime = 0.01
+        while attempts > 0:
+            try:
+                mutecheck_call([IP_BIN, "link", "show", self.localname])
+                break
+            except Exception, e:
+                msg = "ip link show %s error (%d): %s" % \
+                        (self.localname, attempts, e)
+                if attempts > 1:
+                    msg += ", retrying..."
+                self.node.info(msg)
+            time.sleep(stime)
+            stime *= 2
+            attempts -= 1
+        # install tap device into namespace
+        try:
+            check_call([IP_BIN, "link", "set", self.localname, "netns", netns])
+        except Exception, e:
+            msg = "error installing TAP interface %s, command:" % self.localname
+            msg += "ip link set %s netns %s" % (self.localname, netns)
+            self.node.exception(coreapi.CORE_EXCP_LEVEL_ERROR, self.localname, msg)
+            self.node.warn(msg)
+            return
+        self.node.cmd([IP_BIN, "link", "set", self.localname,
+                       "name", self.name])
+        for addr in self.addrlist:
+            self.node.cmd([IP_BIN, "addr", "add", str(addr),
+                  "dev", self.name])
+        self.node.cmd([IP_BIN, "link", "set", self.name,  "up"])
+
+class GreTap(PyCoreNetIf):
+    ''' GRE TAP device for tunneling between emulation servers.
+        Uses the "gretap" tunnel device type from Linux which is a GRE device
+        having a MAC address. The MAC address is required for bridging.
+    '''
+    def __init__(self, node = None, name = None, session = None, mtu = 1458,
+                 remoteip = None, objid = None, localip = None, ttl = 255,
+                 key = None, start = True):
+        PyCoreNetIf.__init__(self, node = node, name = name, mtu = mtu)
+        self.session = session
+        if objid is None:
+            # from PyCoreObj
+            objid = (((id(self) >> 16) ^ (id(self) & 0xffff)) & 0xffff)
+        self.objid = objid
+        sessionid = self.session.shortsessionid()
+        # interface name on the local host machine
+        self.localname = "gt.%s.%s" % (self.objid, sessionid)
+        self.transport_type = "raw"
+        if not start:
+            self.up = False
+            return
+        
+        if remoteip is None:
+            raise ValueError, "missing remote IP required for GRE TAP device"
+        cmd = ("ip", "link", "add", self.localname, "type", "gretap",
+               "remote", str(remoteip))
+        if localip:
+            cmd += ("local", str(localip))
+        if ttl:
+            cmd += ("ttl", str(ttl))
+        if key:
+            cmd += ("key", str(key))
+        check_call(cmd)
+        cmd = ("ip", "link", "set", self.localname, "up")
+        check_call(cmd)
+        self.up = True
+
+    def shutdown(self):
+        if self.localname:
+            cmd = ("ip", "link", "set", self.localname, "down")
+            check_call(cmd)
+            cmd = ("ip", "link", "del", self.localname)
+            check_call(cmd)
+            self.localname = None
+    
+    def tonodemsg(self, flags):
+        return None
+        
+    def tolinkmsgs(self, flags):
+        return []

daemon/core/netns/vnet.py

@@ -0,0 +1,496 @@
+#
+# CORE
+# Copyright (c)2010-2012 the Boeing Company.
+# See the LICENSE file included in this distribution.
+#
+# authors: Tom Goff <thomas.goff@boeing.com>
+#          Jeff Ahrenholz <jeffrey.m.ahrenholz@boeing.com>
+#
+'''
+vnet.py: PyCoreNet and LxBrNet classes that implement virtual networks using
+Linux Ethernet bridging and ebtables rules.
+'''
+
+import os, sys, threading, time, subprocess
+
+from core.api import coreapi
+from core.misc.utils import *
+from core.constants import *
+from core.coreobj import PyCoreNet, PyCoreObj
+from core.netns.vif import VEth, GreTap
+
+checkexec([BRCTL_BIN, IP_BIN, EBTABLES_BIN, TC_BIN])
+
+ebtables_lock = threading.Lock()
+
+class EbtablesQueue(object):
+    ''' Helper class for queuing up ebtables commands into rate-limited
+    atomic commits. This improves performance and reliability when there are
+    many WLAN link updates.
+    '''
+    # update rate is every 300ms
+    rate = 0.3
+    # ebtables
+    atomic_file = "/tmp/pycore.ebtables.atomic"
+    
+    def __init__(self):
+        ''' Initialize the helper class, but don't start the update thread
+        until a WLAN is instantiated.
+        '''
+        self.doupdateloop = False
+        self.updatethread = None
+        # this lock protects cmds and updates lists
+        self.updatelock = threading.Lock()
+        # list of pending ebtables commands
+        self.cmds = []
+        # list of WLANs requiring update
+        self.updates = []
+        # timestamps of last WLAN update; this keeps track of WLANs that are
+        # using this queue
+        self.last_update_time = {}
+        
+    def startupdateloop(self, wlan):
+        ''' Kick off the update loop; only needs to be invoked once.
+        '''
+        self.updatelock.acquire()
+        self.last_update_time[wlan] = time.time()
+        self.updatelock.release()
+        if self.doupdateloop:
+            return
+        self.doupdateloop = True
+        self.updatethread = threading.Thread(target = self.updateloop)
+        self.updatethread.daemon = True
+        self.updatethread.start()
+    
+    def stopupdateloop(self, wlan):
+        ''' Kill the update loop thread if there are no more WLANs using it.
+        '''
+        self.updatelock.acquire()
+        try:
+            del self.last_update_time[wlan]
+        except KeyError:
+            pass
+        self.updatelock.release()
+        if len(self.last_update_time) > 0:
+            return
+        self.doupdateloop = False
+        if self.updatethread:
+            self.updatethread.join()
+            self.updatethread = None
+    
+    def ebatomiccmd(self, cmd):
+        ''' Helper for building ebtables atomic file command list.
+        '''
+        r = [EBTABLES_BIN, "--atomic-file", self.atomic_file]
+        if cmd:
+            r.extend(cmd)
+        return r
+        
+    def lastupdate(self, wlan):
+        ''' Return the time elapsed since this WLAN was last updated.
+        '''
+        try:
+            elapsed = time.time() - self.last_update_time[wlan]
+        except KeyError:
+            self.last_update_time[wlan] = time.time()
+            elapsed = 0.0
+        return elapsed
+    
+    def updated(self, wlan):
+        ''' Keep track of when this WLAN was last updated.
+        '''
+        self.last_update_time[wlan] = time.time()
+        self.updates.remove(wlan)
+        
+    def updateloop(self):
+        ''' Thread target that looks for WLANs needing update, and
+        rate limits the amount of ebtables activity. Only one userspace program
+        should use ebtables at any given time, or results can be unpredictable.
+        '''
+        while self.doupdateloop:
+            self.updatelock.acquire()
+            for wlan in self.updates:
+                if self.lastupdate(wlan) > self.rate:
+                    self.buildcmds(wlan)
+                    #print "ebtables commit %d rules" % len(self.cmds)
+                    self.ebcommit(wlan)
+                    self.updated(wlan)
+            self.updatelock.release()
+            time.sleep(self.rate)
+    
+    def ebcommit(self, wlan):
+        ''' Perform ebtables atomic commit using commands built in the
+        self.cmds list.
+        '''
+        # save kernel ebtables snapshot to a file
+        cmd = self.ebatomiccmd(["--atomic-save",])
+        try:
+            check_call(cmd)
+        except Exception, e:
+            self.eberror(wlan, "atomic-save (%s)" % cmd, e)
+            # no atomic file, exit
+            return
+        # modify the table file using queued ebtables commands
+        for c in self.cmds:
+            cmd = self.ebatomiccmd(c)
+            try:
+                check_call(cmd)
+            except Exception, e:
+                self.eberror(wlan, "cmd=%s" % cmd, e)
+                pass
+        self.cmds = []
+        # commit the table file to the kernel
+        cmd = self.ebatomiccmd(["--atomic-commit",])
+        try:
+            check_call(cmd)
+            os.unlink(self.atomic_file)
+        except Exception, e:
+            self.eberror(wlan, "atomic-commit (%s)" % cmd, e)
+        
+    def ebchange(self, wlan):
+        ''' Flag a change to the given WLAN's _linked dict, so the ebtables
+        chain will be rebuilt at the next interval.
+        '''
+        self.updatelock.acquire()
+        if wlan not in self.updates:
+            self.updates.append(wlan)
+        self.updatelock.release()
+    
+    def buildcmds(self, wlan):
+        ''' Inspect a _linked dict from a wlan, and rebuild the ebtables chain
+        for that WLAN.
+        '''
+        wlan._linked_lock.acquire()
+        # flush the chain
+        self.cmds.extend([["-F", wlan.brname],])
+        # rebuild the chain
+        for (netif1, v) in wlan._linked.items():
+            for (netif2, linked) in v.items():
+                if wlan.policy == "DROP" and linked:
+                    self.cmds.extend([["-A", wlan.brname, "-i", netif1.localname,
+                        "-o", netif2.localname, "-j", "ACCEPT"],
+                        ["-A", wlan.brname, "-o", netif1.localname,
+                        "-i", netif2.localname, "-j", "ACCEPT"]])
+                elif wlan.policy == "ACCEPT" and not linked:
+                    self.cmds.extend([["-A", wlan.brname, "-i", netif1.localname,
+                        "-o", netif2.localname, "-j", "DROP"],
+                        ["-A", wlan.brname, "-o", netif1.localname,
+                        "-i", netif2.localname, "-j", "DROP"]])
+        wlan._linked_lock.release()
+    
+    def eberror(self, wlan, source, error):
+        ''' Log an ebtables command error and send an exception.
+        '''
+        if not wlan:
+            return
+        wlan.exception(coreapi.CORE_EXCP_LEVEL_ERROR, wlan.brname,
+                       "ebtables command error: %s\n%s\n" % (source, error))
+        
+
+# a global object because all WLANs share the same queue
+# cannot have multiple threads invoking the ebtables commnd
+ebq = EbtablesQueue()
+
+def ebtablescmds(call, cmds):
+    ebtables_lock.acquire()
+    try:
+        for cmd in cmds:
+            call(cmd)
+    finally:
+        ebtables_lock.release()
+
+class LxBrNet(PyCoreNet):
+
+    policy = "DROP"
+
+    def __init__(self, session, objid = None, name = None, verbose = False,
+                        start = True, policy = None):
+        PyCoreNet.__init__(self, session, objid, name, verbose, start)
+        if name is None:
+            name = str(self.objid)
+        if policy is not None:
+            self.policy = policy
+        self.name = name
+        self.brname = "b.%s.%s" % (str(self.objid), self.session.sessionid)
+        self.up = False
+        if start:
+            self.startup()
+            ebq.startupdateloop(self)
+
+    def startup(self):
+        try:
+            check_call([BRCTL_BIN, "addbr", self.brname])
+        except Exception, e:
+            self.exception(coreapi.CORE_EXCP_LEVEL_FATAL, self.brname,
+                           "Error adding bridge: %s" % e)
+        try:
+            # turn off spanning tree protocol and forwarding delay
+            check_call([BRCTL_BIN, "stp", self.brname, "off"])
+            check_call([BRCTL_BIN, "setfd", self.brname, "0"])
+            check_call([IP_BIN, "link", "set", self.brname, "up"])
+            # create a new ebtables chain for this bridge
+            ebtablescmds(check_call, [
+                [EBTABLES_BIN, "-N", self.brname, "-P", self.policy],
+                [EBTABLES_BIN, "-A", "FORWARD",
+                "--logical-in", self.brname, "-j", self.brname]])
+            # turn off multicast snooping so mcast forwarding occurs w/o IGMP joins
+            snoop = "/sys/devices/virtual/net/%s/bridge/multicast_snooping" % \
+                self.brname
+            if os.path.exists(snoop):
+                open(snoop, "w").write('0')
+        except Exception, e:
+            self.exception(coreapi.CORE_EXCP_LEVEL_WARNING, self.brname,
+                           "Error setting bridge parameters: %s" % e)
+
+        self.up = True
+
+    def shutdown(self):
+        if not self.up:
+            return
+        ebq.stopupdateloop(self)
+        mutecall([IP_BIN, "link", "set", self.brname, "down"])
+        mutecall([BRCTL_BIN, "delbr", self.brname])
+        ebtablescmds(mutecall, [
+            [EBTABLES_BIN, "-D", "FORWARD",
+             "--logical-in", self.brname, "-j", self.brname],
+            [EBTABLES_BIN, "-X", self.brname]])
+        for netif in self.netifs():
+            # removes veth pairs used for bridge-to-bridge connections
+            netif.shutdown()
+        self._netif.clear()
+        self._linked.clear()
+        del self.session
+        self.up = False
+
+    def attach(self, netif):
+        if self.up:
+            try:
+                check_call([BRCTL_BIN, "addif", self.brname, netif.localname])
+                check_call([IP_BIN, "link", "set", netif.localname, "up"])
+            except Exception, e:
+                self.exception(coreapi.CORE_EXCP_LEVEL_ERROR, self.brname,
+                               "Error joining interface %s to bridge %s: %s" % \
+                               (netif.localname, self.brname, e))
+                return
+        PyCoreNet.attach(self, netif)
+
+    def detach(self, netif):
+        if self.up:
+            try:
+                check_call([BRCTL_BIN, "delif", self.brname, netif.localname])
+            except Exception, e:
+                self.exception(coreapi.CORE_EXCP_LEVEL_ERROR, self.brname,
+                               "Error removing interface %s from bridge %s: %s" % \
+                               (netif.localname, self.brname, e))
+                return
+        PyCoreNet.detach(self, netif)
+
+    def linked(self, netif1, netif2):
+        # check if the network interfaces are attached to this network
+        if self._netif[netif1.netifi] != netif1:
+            raise ValueError, "inconsistency for netif %s" % netif1.name
+        if self._netif[netif2.netifi] != netif2:
+            raise ValueError, "inconsistency for netif %s" % netif2.name
+        try:
+            linked = self._linked[netif1][netif2]
+        except KeyError:
+            if self.policy == "ACCEPT":
+                linked = True
+            elif self.policy == "DROP":
+                linked = False
+            else:
+                raise Exception, "unknown policy: %s" % self.policy
+            self._linked[netif1][netif2] = linked
+        return linked
+
+    def unlink(self, netif1, netif2):
+        ''' Unlink two PyCoreNetIfs, resulting in adding or removing ebtables
+        filtering rules.
+        '''
+        self._linked_lock.acquire()
+        if not self.linked(netif1, netif2):
+            self._linked_lock.release()
+            return
+        self._linked[netif1][netif2] = False
+        self._linked_lock.release()
+        ebq.ebchange(self)
+
+    def link(self, netif1, netif2):
+        ''' Link two PyCoreNetIfs together, resulting in adding or removing
+        ebtables filtering rules.
+        '''
+        self._linked_lock.acquire()
+        if self.linked(netif1, netif2):
+            self._linked_lock.release()
+            return
+        self._linked[netif1][netif2] = True
+        self._linked_lock.release()
+        ebq.ebchange(self)
+
+    def linkconfig(self, netif, bw = None, delay = None,
+                   loss = None, duplicate = None, jitter = None, netif2 = None):
+        ''' Configure link parameters by applying tc queuing disciplines on the
+            interface.
+        '''
+        tc = [TC_BIN, "qdisc", "replace", "dev", netif.localname]
+        parent = ["root"]
+        changed = False
+        if netif.setparam('bw', bw):
+            # from tc-tbf(8): minimum value for burst is rate / kernel_hz
+            if bw is not None:
+                burst = max(2 * netif.mtu, bw / 1000)
+                limit = 0xffff # max IP payload
+                tbf = ["tbf", "rate", str(bw),
+                       "burst", str(burst), "limit", str(limit)]
+            if bw > 0:
+                if self.up:
+                    check_call(tc + parent + ["handle", "1:"] + tbf)
+                netif.setparam('has_tbf', True)
+                changed = True
+            elif netif.getparam('has_tbf') and bw <= 0:
+                tcd = [] + tc
+                tcd[2] = "delete"
+                if self.up:
+                    check_call(tcd + parent)
+                netif.setparam('has_tbf', False)
+                # removing the parent removes the child
+                netif.setparam('has_netem', False)
+                changed = True
+        if netif.getparam('has_tbf'):
+            parent = ["parent", "1:1"]
+        netem = ["netem"]
+        changed = max(changed, netif.setparam('delay', delay))
+        if loss is not None:
+            loss = float(loss)
+        changed = max(changed, netif.setparam('loss', loss))
+        if duplicate is not None:
+            duplicate = float(duplicate)
+        changed = max(changed, netif.setparam('duplicate', duplicate))
+        changed = max(changed, netif.setparam('jitter', jitter))
+        if not changed:
+            return
+        # jitter and delay use the same delay statement
+        if delay is not None:
+            netem += ["delay", "%sus" % delay]
+        if jitter is not None:
+            if delay is None:
+                netem += ["delay", "0us", "%sus" % jitter, "25%"]
+            else:
+                netem += ["%sus" % jitter, "25%"]
+        
+        if loss is not None:
+            netem += ["loss", "%s%%" % min(loss, 100)]
+        if duplicate is not None:
+            netem += ["duplicate", "%s%%" % min(duplicate, 100)]
+        if delay <= 0 and loss <= 0 and duplicate <= 0:
+            # possibly remove netem if it exists and parent queue wasn't removed
+            if not netif.getparam('has_netem'):
+                return
+            tc[2] = "delete"
+            if self.up:
+                check_call(tc + parent + ["handle", "10:"])
+            netif.setparam('has_netem', False)
+        elif len(netem) > 1:
+            if self.up:
+                check_call(tc + parent + ["handle", "10:"] + netem)
+            netif.setparam('has_netem', True)
+
+    def linknet(self, net):
+        ''' Link this bridge with another by creating a veth pair and installing
+            each device into each bridge.
+        '''
+        sessionid = self.session.sessionid
+        localname = "n%s.%s.%s" % (self.objid, net.objid, sessionid)
+        name = "n%s.%s.%s" % (net.objid, self.objid, sessionid)
+        netif = VEth(node = None, name = name, localname = localname,
+                     mtu = 1500, net = self, start = self.up)        
+        self.attach(netif)
+        if net.up:
+            # this is similar to net.attach() but uses netif.name instead 
+            # of localname
+            check_call([BRCTL_BIN, "addif", net.brname, netif.name])
+            check_call([IP_BIN, "link", "set", netif.name, "up"])
+        i = net.newifindex()
+        net._netif[i] = netif
+        with net._linked_lock:
+            net._linked[netif] = {}
+        netif.net = self
+        netif.othernet = net
+
+    def addrconfig(self, addrlist):
+        ''' Set addresses on the bridge.
+        '''
+        if not self.up:
+            return
+        for addr in addrlist:
+            try:
+                check_call([IP_BIN, "addr", "add", str(addr), "dev", self.brname])
+            except Exception, e:
+                self.exception(coreapi.CORE_EXCP_LEVEL_ERROR, self.brname,
+                               "Error adding IP address: %s" % e)
+
+class GreTapBridge(LxBrNet):
+    ''' A network consisting of a bridge with a gretap device for tunneling to 
+        another system.
+    '''
+    def __init__(self, session, remoteip = None, objid = None, name = None,
+                 policy = "ACCEPT", localip = None, ttl = 255, key = None,
+                 verbose = False, start = True):
+        LxBrNet.__init__(self, session = session, objid = objid,
+                      name = name, verbose = verbose, policy = policy,
+                      start = False)
+        self.grekey = key
+        if self.grekey is None:
+            self.grekey = self.session.sessionid ^ self.objid
+        self.localnum = None
+        self.remotenum = None
+        self.remoteip = remoteip
+        self.localip = localip
+        self.ttl = ttl
+        if remoteip is None:
+            self.gretap = None
+        else:
+            self.gretap = GreTap(node = self, name = None, session = session,
+                                    remoteip = remoteip, objid = None, localip = localip, ttl = ttl,
+                                    key = self.grekey)
+        if start:
+            self.startup()
+
+    def startup(self):
+        ''' Creates a bridge and adds the gretap device to it.
+        '''
+        LxBrNet.startup(self)
+        if self.gretap:
+            self.attach(self.gretap)
+
+    def shutdown(self):
+        ''' Detach the gretap device and remove the bridge.
+        '''
+        if self.gretap:
+            self.detach(self.gretap)
+            self.gretap.shutdown()
+            self.gretap = None
+        LxBrNet.shutdown(self)
+    
+    def addrconfig(self, addrlist):
+        ''' Set the remote tunnel endpoint. This is a one-time method for 
+            creating the GreTap device, which requires the remoteip at startup.
+            The 1st address in the provided list is remoteip, 2nd optionally
+            specifies localip.
+        '''
+        if self.gretap:
+            raise ValueError, "gretap already exists for %s" % self.name
+        remoteip = addrlist[0].split('/')[0]
+        localip = None
+        if len(addrlist) > 1:
+            localip = addrlist[1].split('/')[0]
+        self.gretap = GreTap(session = self.session, remoteip = remoteip,
+                             objid = None, name = None,
+                             localip = localip, ttl = self.ttl, key = self.grekey)
+        self.attach(self.gretap)
+
+    def setkey(self, key):
+        ''' Set the GRE key used for the GreTap device. This needs to be set
+            prior to instantiating the GreTap device (before addrconfig).
+        '''
+        self.grekey = key

daemon/core/netns/vnode.py

@@ -0,0 +1,402 @@
+#
+# CORE
+# Copyright (c)2010-2012 the Boeing Company.
+# See the LICENSE file included in this distribution.
+#
+# authors: Tom Goff <thomas.goff@boeing.com>
+#          Jeff Ahrenholz <jeffrey.m.ahrenholz@boeing.com>
+#
+'''
+vnode.py: PyCoreNode and LxcNode classes that implement the network namespace
+virtual node.
+'''
+
+import os, signal, sys, subprocess, vnodeclient, threading, string, shutil
+import random, time
+from core.api import coreapi
+from core.misc.utils import *
+from core.constants import *
+from core.coreobj import PyCoreObj, PyCoreNode, PyCoreNetIf, Position
+from core.netns.vif import VEth, TunTap
+from core.emane.nodes import EmaneNode
+
+checkexec([IP_BIN])
+
+class SimpleLxcNode(PyCoreNode):
+    def __init__(self, session, objid = None, name = None, nodedir = None,
+                 verbose = False, start = True):
+        PyCoreNode.__init__(self, session, objid, name, verbose=verbose,
+                            start=start)
+        self.nodedir = nodedir
+        self.ctrlchnlname = \
+            os.path.abspath(os.path.join(self.session.sessiondir, self.name))
+        self.vnodeclient = None
+        self.pid = None
+        self.up = False
+        self.lock = threading.RLock()
+        self._mounts = []
+
+    def alive(self):
+        try:
+            os.kill(self.pid, 0)
+        except OSError:
+            return False
+        return True
+
+    def startup(self):
+        ''' Start a new namespace node by invoking the vnoded process that
+            allocates a new namespace. Bring up the loopback device and set
+            the hostname.
+        '''
+        if self.up:
+            raise Exception, "already up"
+        vnoded = ["%s/vnoded" % CORE_SBIN_DIR, "-v", "-c", self.ctrlchnlname,
+                  "-l", self.ctrlchnlname + ".log",
+                  "-p", self.ctrlchnlname + ".pid"]
+        if self.nodedir:
+            vnoded += ["-C", self.nodedir]
+        try:
+            tmp = subprocess.Popen(vnoded, stdout = subprocess.PIPE,
+                                   env = self.session.getenviron(state=False))
+        except OSError, e:
+            msg = "error running vnoded command: %s (%s)" % (vnoded, e)
+            self.exception(coreapi.CORE_EXCP_LEVEL_FATAL,
+                "SimpleLxcNode.startup()", msg)
+            raise Exception, msg
+        try:
+            self.pid = int(tmp.stdout.read())
+            tmp.stdout.close()
+        except Exception:
+            msg = "vnoded failed to create a namespace; "
+            msg += "check kernel support and user priveleges"
+            self.exception(coreapi.CORE_EXCP_LEVEL_FATAL,
+                           "SimpleLxcNode.startup()", msg)
+        if tmp.wait():
+            raise Exception, ("command failed: %s" % vnoded)
+        self.vnodeclient = vnodeclient.VnodeClient(self.name,
+                                                   self.ctrlchnlname)
+        self.info("bringing up loopback interface")
+        self.cmd([IP_BIN, "link", "set", "lo", "up"])
+        self.info("setting hostname: %s" % self.name)
+        self.cmd(["hostname", self.name])
+        self.up = True
+
+    def shutdown(self):
+        if not self.up:
+            return
+        while self._mounts:
+            source, target = self._mounts.pop(-1)
+            self.umount(target)
+        #print "XXX del vnodeclient:", self.vnodeclient
+        # XXX XXX XXX this causes a serious crash
+        #del self.vnodeclient
+        for netif in self.netifs():
+            netif.shutdown()
+        try:
+            os.kill(self.pid, signal.SIGTERM)
+            os.waitpid(self.pid, 0)
+        except OSError:
+            pass
+        try:
+            os.unlink(self.ctrlchnlname)
+        except OSError:
+            pass
+        self._netif.clear()
+        #del self.session
+        # print "XXX del vnodeclient:", self.vnodeclient
+        del self.vnodeclient
+        self.up = False
+
+    def cmd(self, args, wait = True):
+        return self.vnodeclient.cmd(args, wait)
+
+    def cmdresult(self, args):
+        return self.vnodeclient.cmdresult(args)
+
+    def popen(self, args):
+        return self.vnodeclient.popen(args)
+
+    def icmd(self, args):
+        return self.vnodeclient.icmd(args)
+
+    def redircmd(self, infd, outfd, errfd, args, wait = True):
+        return self.vnodeclient.redircmd(infd, outfd, errfd, args, wait)
+
+    def term(self, sh = "/bin/sh"):
+        return self.vnodeclient.term(sh = sh)
+
+    def termcmdstring(self, sh = "/bin/sh"):
+        return self.vnodeclient.termcmdstring(sh = sh)
+
+    def shcmd(self, cmdstr, sh = "/bin/sh"):
+        return self.vnodeclient.shcmd(cmdstr, sh = sh)
+
+    def boot(self):
+        pass
+
+    def mount(self, source, target):
+        source = os.path.abspath(source)
+        self.info("mounting %s at %s" % (source, target))
+        try:
+            shcmd = "mkdir -p '%s' && %s -n --bind '%s' '%s'" % \
+                (target, MOUNT_BIN, source, target)
+            self.shcmd(shcmd)
+            self._mounts.append((source, target))
+        except:
+            self.warn("mounting failed for %s at %s" % (source, target))
+
+    def umount(self, target):
+        self.info("unmounting '%s'" % target)
+        try:
+            self.cmd([UMOUNT_BIN, "-n", "-l", target])
+        except:
+            self.warn("unmounting failed for %s" % target)
+
+    def newifindex(self):
+        with self.lock:
+            return PyCoreNode.newifindex(self)
+
+    def newveth(self, ifindex = None, ifname = None, net = None):
+        self.lock.acquire()
+        try:
+            if ifindex is None:
+                ifindex = self.newifindex()
+            if ifname is None:
+                ifname = "eth%d" % ifindex
+            sessionid = self.session.shortsessionid()
+            name = "n%s.%s.%s" % (self.objid, ifindex, sessionid)
+            localname = "n%s.%s.%s" % (self.objid, ifname, sessionid)
+            ifclass = VEth
+            veth = ifclass(node = self, name = name, localname = localname,
+                           mtu = 1500, net = net, start = self.up)
+            if self.up:
+                check_call([IP_BIN, "link", "set", veth.name,
+                            "netns", str(self.pid)])
+                self.cmd([IP_BIN, "link", "set", veth.name, "name", ifname])
+            veth.name = ifname
+            try:
+                self.addnetif(veth, ifindex)
+            except:
+                veth.shutdown()
+                del veth
+                raise
+            return ifindex
+        finally:
+            self.lock.release()
+
+    def newtuntap(self, ifindex = None, ifname = None, net = None):
+        self.lock.acquire()
+        try:
+            if ifindex is None:
+                ifindex = self.newifindex()
+            if ifname is None:
+                ifname = "eth%d" % ifindex
+            sessionid = self.session.shortsessionid()
+            localname = "n%s.%s.%s" % (self.objid, ifindex, sessionid)
+            name = ifname
+            ifclass = TunTap
+            tuntap = ifclass(node = self, name = name, localname = localname,
+                             mtu = 1500, net = net, start = self.up)
+            try:
+                self.addnetif(tuntap, ifindex)
+            except:
+                tuntap.shutdown()
+                del tuntap
+                raise
+            return ifindex
+        finally:
+            self.lock.release()
+
+    def sethwaddr(self, ifindex, addr):
+        self._netif[ifindex].sethwaddr(addr)
+        if self.up:
+            (status, result) = self.cmdresult([IP_BIN, "link", "set", "dev",
+                                    self.ifname(ifindex), "address", str(addr)])
+            if status:
+                self.exception(coreapi.CORE_EXCP_LEVEL_ERROR,
+                    "SimpleLxcNode.sethwaddr()",
+                    "error setting MAC address %s" % str(addr))
+    def addaddr(self, ifindex, addr):
+        if self.up:
+            self.cmd([IP_BIN, "addr", "add", str(addr),
+                  "dev", self.ifname(ifindex)])
+        self._netif[ifindex].addaddr(addr)
+
+    def deladdr(self, ifindex, addr):
+        try:
+            self._netif[ifindex].deladdr(addr)
+        except ValueError:
+            self.warn("trying to delete unknown address: %s" % addr)
+        if self.up:
+            self.cmd([IP_BIN, "addr", "del", str(addr),
+                  "dev", self.ifname(ifindex)])
+
+    valid_deladdrtype = ("inet", "inet6", "inet6link")
+    def delalladdr(self, ifindex, addrtypes = valid_deladdrtype):
+        addr = self.getaddr(self.ifname(ifindex), rescan = True)
+        for t in addrtypes:
+            if t not in self.valid_deladdrtype:
+                raise ValueError, "addr type must be in: " + \
+                    " ".join(self.valid_deladdrtype)
+            for a in addr[t]:
+                self.deladdr(ifindex, a)
+        # update cached information
+        self.getaddr(self.ifname(ifindex), rescan = True)
+
+    def ifup(self, ifindex):
+        if self.up:
+            self.cmd([IP_BIN, "link", "set", self.ifname(ifindex), "up"])
+
+    def newnetif(self, net = None, addrlist = [], hwaddr = None,
+                 ifindex = None, ifname = None):
+        self.lock.acquire()
+        try:
+            if isinstance(net, EmaneNode):
+                ifindex = self.newtuntap(ifindex = ifindex, ifname = ifname,
+                                         net = net)
+                # TUN/TAP is not ready for addressing yet; the device may
+                #   take some time to appear, and installing it into a
+                #   namespace after it has been bound removes addressing;
+                #   save addresses with the interface now
+                self.attachnet(ifindex, net)
+                netif = self.netif(ifindex)
+                netif.sethwaddr(hwaddr)
+                for addr in maketuple(addrlist):
+                    netif.addaddr(addr)
+                return ifindex
+            else:
+                ifindex = self.newveth(ifindex = ifindex, ifname = ifname,
+                                       net = net)
+            if net is not None:
+                self.attachnet(ifindex, net)
+            if hwaddr:
+                self.sethwaddr(ifindex, hwaddr)
+            for addr in maketuple(addrlist):
+                self.addaddr(ifindex, addr)
+            self.ifup(ifindex)
+            return ifindex
+        finally:
+            self.lock.release()
+
+    def connectnode(self, ifname, othernode, otherifname):
+        tmplen = 8
+        tmp1 = "tmp." + "".join([random.choice(string.ascii_lowercase)
+                                 for x in xrange(tmplen)])
+        tmp2 = "tmp." + "".join([random.choice(string.ascii_lowercase)
+                                 for x in xrange(tmplen)])
+        check_call([IP_BIN, "link", "add", "name", tmp1,
+                    "type", "veth", "peer", "name", tmp2])
+
+        check_call([IP_BIN, "link", "set", tmp1, "netns", str(self.pid)])
+        self.cmd([IP_BIN, "link", "set", tmp1, "name", ifname])
+        self.addnetif(PyCoreNetIf(self, ifname), self.newifindex())
+
+        check_call([IP_BIN, "link", "set", tmp2, "netns", str(othernode.pid)])
+        othernode.cmd([IP_BIN, "link", "set", tmp2, "name", otherifname])
+        othernode.addnetif(PyCoreNetIf(othernode, otherifname),
+                           othernode.newifindex())
+
+    def addfile(self, srcname, filename):
+        shcmd = "mkdir -p $(dirname '%s') && mv '%s' '%s' && sync" % \
+            (filename, srcname, filename)
+        self.shcmd(shcmd)
+
+    def getaddr(self, ifname, rescan = False):
+        return self.vnodeclient.getaddr(ifname = ifname, rescan = rescan)
+
+    def netifstats(self, ifname = None):
+        return self.vnodeclient.netifstats(ifname = ifname)
+
+
+class LxcNode(SimpleLxcNode):
+    def __init__(self, session, objid = None, name = None,
+                 nodedir = None, bootsh = "boot.sh", verbose = False,
+                 start = True):
+        super(LxcNode, self).__init__(session = session, objid = objid,
+                                      name = name, nodedir = nodedir,
+                                      verbose = verbose, start = start)
+        self.bootsh = bootsh
+        if start:
+            self.startup()
+
+    def boot(self):
+        self.session.services.bootnodeservices(self)
+        
+    def validate(self):
+        self.session.services.validatenodeservices(self)
+
+    def startup(self):
+        self.lock.acquire()
+        try:
+            self.makenodedir()
+            super(LxcNode, self).startup()
+            self.privatedir("/var/run")
+            self.privatedir("/var/log")
+        except OSError, e:
+            self.warn("Error with LxcNode.startup(): %s" % e)
+            self.exception(coreapi.CORE_EXCP_LEVEL_ERROR,
+                "LxcNode.startup()", "%s" % e)
+        finally:
+            self.lock.release()
+
+    def shutdown(self):
+        if not self.up:
+            return
+        self.lock.acquire()
+        # services are instead stopped when session enters datacollect state
+        #self.session.services.stopnodeservices(self)
+        try:
+            super(LxcNode, self).shutdown()
+        finally:
+            self.rmnodedir()
+            self.lock.release()
+
+    def privatedir(self, path):
+        if path[0] != "/":
+            raise ValueError, "path not fully qualified: " + path
+        hostpath = os.path.join(self.nodedir, path[1:].replace("/", "."))
+        try:
+            os.mkdir(hostpath)
+        except OSError:
+            pass
+        except Exception, e:
+            raise Exception, e
+        self.mount(hostpath, path)
+
+    def hostfilename(self, filename):
+        ''' Return the name of a node's file on the host filesystem.
+        '''
+        dirname, basename = os.path.split(filename)
+        if not basename:
+            raise ValueError, "no basename for filename: " + filename
+        if dirname and dirname[0] == "/":
+            dirname = dirname[1:]
+        dirname = dirname.replace("/", ".")
+        dirname = os.path.join(self.nodedir, dirname)
+        return os.path.join(dirname, basename)
+
+    def opennodefile(self, filename, mode = "w"):
+        hostfilename = self.hostfilename(filename)
+        dirname, basename = os.path.split(hostfilename)
+        if not os.path.isdir(dirname):
+            os.makedirs(dirname, mode = 0755)
+        return open(hostfilename, mode)
+
+    def nodefile(self, filename, contents, mode = 0644):
+        f = self.opennodefile(filename, "w")
+        f.write(contents)
+        os.chmod(f.name, mode)
+        f.close()
+        self.info("created nodefile: '%s'; mode: 0%o" % (f.name, mode))
+        
+    def nodefilecopy(self, filename, srcfilename, mode = None):
+        ''' Copy a file to a node, following symlinks and preserving metadata.
+        Change file mode if specified.
+        '''
+        hostfilename = self.hostfilename(filename)
+        shutil.copy2(srcfilename, hostfilename)
+        if mode is not None:
+            os.chmod(hostfilename, mode)
+        self.info("copied nodefile: '%s'; mode: %s" % (hostfilename, mode))
+        
+

daemon/core/netns/vnodeclient.py

@@ -0,0 +1,221 @@
+#
+# CORE
+# Copyright (c)2010-2012 the Boeing Company.
+# See the LICENSE file included in this distribution.
+#
+# author: Tom Goff <thomas.goff@boeing.com>
+#
+'''
+vnodeclient.py: implementation of the VnodeClient class for issuing commands
+over a control channel to the vnoded process running in a network namespace.
+The control channel can be accessed via calls to the vcmd Python module or
+by invoking the vcmd shell command.
+'''
+
+import os, stat, sys
+from core.constants import *
+
+USE_VCMD_MODULE = True
+
+if USE_VCMD_MODULE:
+    import vcmd
+else:
+    import subprocess
+
+VCMD = os.path.join(CORE_SBIN_DIR, "vcmd")
+
+class VnodeClient(object):
+    def __init__(self, name, ctrlchnlname):
+        self.name = name
+        self.ctrlchnlname = ctrlchnlname
+        if USE_VCMD_MODULE:
+            self.cmdchnl = vcmd.VCmd(self.ctrlchnlname)
+        else:
+            self.cmdchnl = None
+        self._addr = {}
+
+    def warn(self, msg):
+        print >> sys.stderr, "%s: %s" % (self.name, msg)
+
+    def connected(self):
+        if USE_VCMD_MODULE:
+            return self.cmdchnl.connected()
+        else:
+            return True
+
+    def cmd(self, args, wait = True):
+        ''' Execute a command on a node and return the status (return code).
+        '''
+        if USE_VCMD_MODULE:
+            if not self.cmdchnl.connected():
+                raise ValueError, "self.cmdchnl not connected"
+            tmp = self.cmdchnl.qcmd(args)
+            if not wait:
+                return tmp
+            tmp = tmp.wait()
+        else:
+            if wait:
+                mode = os.P_WAIT
+            else:
+                mode = os.P_NOWAIT
+            tmp = os.spawnlp(mode, VCMD, VCMD, "-c",
+                             self.ctrlchnlname, "-q", "--", *args)
+            if not wait:
+                return tmp
+        if tmp:
+            self.warn("cmd exited with status %s: %s" % (tmp, str(args)))
+        return tmp
+
+    def cmdresult(self, args):
+        ''' Execute a command on a node and return a tuple containing the
+            exit status and result string. stderr output
+            is folded into the stdout result string.
+        '''
+        cmdid, cmdin, cmdout, cmderr = self.popen(args)
+        result = cmdout.read()
+        result += cmderr.read()
+        cmdin.close()
+        cmdout.close()
+        cmderr.close()
+        status = cmdid.wait()
+        return (status, result)
+
+    def popen(self, args):
+        if USE_VCMD_MODULE:
+            if not self.cmdchnl.connected():
+                raise ValueError, "self.cmdchnl not connected"
+            return self.cmdchnl.popen(args)
+        else:
+            cmd = [VCMD, "-c", self.ctrlchnlname, "--"]
+            cmd.extend(args)
+            tmp = subprocess.Popen(cmd, stdin = subprocess.PIPE,
+                                   stdout = subprocess.PIPE,
+                                   stderr = subprocess.PIPE)
+            return tmp, tmp.stdin, tmp.stdout, tmp.stderr
+
+    def icmd(self, args):
+        return os.spawnlp(os.P_WAIT, VCMD, VCMD, "-c", self.ctrlchnlname,
+                          "--", *args)
+
+    def redircmd(self, infd, outfd, errfd, args, wait = True):
+        '''
+        Execute a command on a node with standard input, output, and
+        error redirected according to the given file descriptors.
+        '''
+        if not USE_VCMD_MODULE:
+            raise NotImplementedError
+        if not self.cmdchnl.connected():
+            raise ValueError, "self.cmdchnl not connected"
+        tmp = self.cmdchnl.redircmd(infd, outfd, errfd, args)
+        if not wait:
+            return tmp
+        tmp = tmp.wait()
+        if tmp:
+            self.warn("cmd exited with status %s: %s" % (tmp, str(args)))
+        return tmp
+
+    def term(self, sh = "/bin/sh"):
+        return os.spawnlp(os.P_NOWAIT, "xterm", "xterm", "-ut",
+                          "-title", self.name, "-e",
+                          VCMD, "-c", self.ctrlchnlname, "--", sh)
+
+    def termcmdstring(self, sh = "/bin/sh"):
+        return "%s -c %s -- %s" % (VCMD, self.ctrlchnlname, sh)
+
+    def shcmd(self, cmdstr, sh = "/bin/sh"):
+        return self.cmd([sh, "-c", cmdstr])
+
+    def getaddr(self, ifname, rescan = False):
+        if ifname in self._addr and not rescan:
+            return self._addr[ifname]
+        tmp = {"ether": [], "inet": [], "inet6": [], "inet6link": []}
+        cmd = [IP_BIN, "addr", "show", "dev", ifname]
+        cmdid, cmdin, cmdout, cmderr = self.popen(cmd)
+        cmdin.close()
+        for line in cmdout:
+            line = line.strip().split()
+            if line[0] == "link/ether":
+                tmp["ether"].append(line[1])
+            elif line[0] == "inet":
+                tmp["inet"].append(line[1])
+            elif line[0] == "inet6":
+                if line[3] == "global":
+                    tmp["inet6"].append(line[1])
+                elif line[3] == "link":
+                    tmp["inet6link"].append(line[1])
+                else:
+                    self.warn("unknown scope: %s" % line[3])
+            else:
+                pass
+        err = cmderr.read()
+        cmdout.close()
+        cmderr.close()
+        status = cmdid.wait()
+        if status:
+            self.warn("nonzero exist status (%s) for cmd: %s" % (status, cmd))
+        if err:
+            self.warn("error output: %s" % err)
+        self._addr[ifname] = tmp
+        return tmp
+
+    def netifstats(self, ifname = None):
+        stats = {}
+        cmd = ["cat", "/proc/net/dev"]
+        cmdid, cmdin, cmdout, cmderr = self.popen(cmd)
+        cmdin.close()
+        # ignore first line
+        cmdout.readline()
+        # second line has count names
+        tmp = cmdout.readline().strip().split("|")
+        rxkeys = tmp[1].split()
+        txkeys = tmp[2].split()
+        for line in cmdout:
+            line = line.strip().split()
+            devname, tmp = line[0].split(":")
+            if tmp:
+                line.insert(1, tmp)
+            stats[devname] = {"rx": {}, "tx": {}}
+            field = 1
+            for count in rxkeys:
+                stats[devname]["rx"][count] = int(line[field])
+                field += 1
+            for count in txkeys:
+                stats[devname]["tx"][count] = int(line[field])
+                field += 1
+        err = cmderr.read()
+        cmdout.close()
+        cmderr.close()
+        status = cmdid.wait()
+        if status:
+            self.warn("nonzero exist status (%s) for cmd: %s" % (status, cmd))
+        if err:
+            self.warn("error output: %s" % err)
+        if ifname is not None:
+            return stats[ifname]
+        else:
+            return stats
+
+def createclients(sessiondir, clientcls = VnodeClient,
+                  cmdchnlfilterfunc = None):
+    direntries = map(lambda x: os.path.join(sessiondir, x),
+                     os.listdir(sessiondir))
+    cmdchnls = filter(lambda x: stat.S_ISSOCK(os.stat(x).st_mode), direntries)
+    if cmdchnlfilterfunc:
+        cmdchnls = filter(cmdchnlfilterfunc, cmdchnls)
+    cmdchnls.sort()
+    return map(lambda x: clientcls(os.path.basename(x), x), cmdchnls)
+
+def createremoteclients(sessiondir, clientcls = VnodeClient,
+                  filterfunc = None):
+    ''' Creates remote VnodeClients, for nodes emulated on other machines. The
+    session.Broker writes a n1.conf/server file having the server's info.
+    '''
+    direntries = map(lambda x: os.path.join(sessiondir, x),
+                     os.listdir(sessiondir))
+    nodedirs = filter(lambda x: stat.S_ISDIR(os.stat(x).st_mode), direntries)
+    nodedirs = filter(lambda x: os.path.exists(os.path.join(x, "server")), 
+                      nodedirs)
+    if filterfunc:
+        nodedirs = filter(filterfunc, nodedirs)
+    nodedirs.sort()
+    return map(lambda x: clientcls(x), nodedirs)