def start( self, controllers ):
     "Start up kernel datapath."
     self.startIntfs()
     # Delete local datapath if it exists;
     # then create a new one monitoring the given interfaces
     quietRun( self.vsctl_cmd + ' -- --if-exists del-br ' + self.dp )
     self.cmd( self.vsctl_cmd + ' add-br ' + self.dp )
     self.cmd( self.vsctl_cmd + ' set-fail-mode ' + self.dp + ' secure')
     mac_str = ''
     if self.defaultMAC:
         # ovs-openflowd expects a string of exactly 16 hex digits with no
         # colons.
         dpid_str = '0000' + \
                   ''.join( self.defaultMAC.split( ':' ) ) + ' '
         self.cmd(self.vsctl_cmd + ' --no-wait set bridge %s other-config:datapath_type=system other-config:datapath-id=%s' % (self.dp, dpid_str))
     ports = sorted( self.ports.values() )
     if len( ports ) != ports[ -1 ] + 1 - self.portBase:
         raise Exception( 'only contiguous, one-indexed port ranges '
                         'supported: %s' % self.intfs )
     intfs = [ self.intfs[ port ] for port in ports ]
     for i in intfs:
         self.cmd( self.vsctl_cmd, 'add-port', self.dp, i ) 
     self.cmd( self.vsctl_cmd + ' set-controller ' + self.dp +
         ' '.join( [ ' tcp:%s:%d' % ( c.IP(), c.port ) \
                 for c in controllers ] ))
     self.execed = False

 def waitForNode( self, node ):
     "Wait for a node to finish, and  print its output."
     # Pollers
     nodePoller = poll()
     nodePoller.register( node.stdout )
     bothPoller = poll()
     bothPoller.register( self.stdin, POLLIN )
     bothPoller.register( node.stdout, POLLIN )
     if self.isatty():
         # Buffer by character, so that interactive
         # commands sort of work
         quietRun( 'stty -icanon min 1' )
     while True:
         try:
             bothPoller.poll()
             # XXX BL: this doesn't quite do what we want.
             if False and self.inputFile:
                 key = self.inputFile.read( 1 )
                 if key is not '':
                     node.write(key)
                 else:
                     self.inputFile = None
             if isReadable( self.inPoller ):
                 key = self.stdin.read( 1 )
                 node.write( key )
             if isReadable( nodePoller ):
                 data = node.monitor()
                 output( data )
             if not node.waiting:
                 break
         except KeyboardInterrupt:
             node.sendInt()

 def start( self, controllers ):
     "Start up kernel datapath."
     ofplog = '/tmp/' + self.name + '-ofp.log'
     quietRun( 'ifconfig lo up' )
     # Delete local datapath if it exists;
     # then create a new one monitoring the given interfaces
     quietRun( 'ovs-dpctl del-dp ' + self.dp )
     self.cmd( 'ovs-dpctl add-dp ' + self.dp )
     mac_str = ''
     if self.defaultMAC:
         # ovs-openflowd expects a string of exactly 16 hex digits with no
         # colons.
         mac_str = ' --datapath-id=0000' + \
                   ''.join( self.defaultMAC.split( ':' ) ) + ' '
     ports = sorted( self.ports.values() )
     if len( ports ) != ports[ -1 ] + 1 - self.portBase:
         raise Exception( 'only contiguous, one-indexed port ranges '
                         'supported: %s' % self.intfs )
     intfs = [ self.intfs[ port ] for port in ports ]
     self.cmd( 'ovs-dpctl', 'add-if', self.dp, ' '.join( intfs ) )
     # Run protocol daemon
     controller = controllers[ 0 ]
     self.cmd( 'ovs-openflowd ' + self.dp +
         ' tcp:%s:%d' % ( controller.IP(), controller.port ) +
         ' --fail=secure ' + self.opts + mac_str +
         ' 1>' + ofplog + ' 2>' + ofplog + '&' )
     self.execed = False

 def start( self, controllers ):
     "Start up kernel datapath."
     ofplog = '/tmp/' + self.name + '-ofp.log'
     self.startIntfs()
     # Delete local datapath if it exists;
     # then create a new one monitoring the given interfaces
     quietRun( 'ovs-dpctl del-dp ' + self.dp )
     self.cmd( 'ovs-dpctl add-dp ' + self.dp )
     mac_str = ''
     if self.defaultMAC:
         # ovs-openflowd expects a string of exactly 16 hex digits with no
         # colons.
         mac_str = ' --datapath-id=0000' + \
                   ''.join( self.defaultMAC.split( ':' ) ) + ' '
     ports = sorted( self.ports.values() )
     if len( ports ) != ports[ -1 ] + 1 - self.portBase:
         raise Exception( 'only contiguous, one-indexed port ranges '
                         'supported: %s' % self.intfs )
     intfs = [ self.intfs[ port ] for port in ports ]
     self.cmd( 'ovs-dpctl', 'add-if', self.dp, ' '.join( intfs ) )
     # Run protocol daemon
     if not self.defVendor:
         # Mark the switch so controller will send LLDP/BDDP on all ports
         self.opts += ' --mfr-desc="big switch networks" --dp-desc="bigtest datapath" '
     self.cmd( 'ovs-openflowd ' + self.dp +
         ' '.join( [ ' tcp:%s:%d' % ( c.IP(), c.port ) \
                     for c in controllers ] ) +
         ' --fail=secure ' + self.opts + mac_str +
         ' 1>' + ofplog + ' 2>' + ofplog + '&' )
     self.execed = False

def stopUDPClient():
    '''stop a UDP client 
    '''
    info('** Stop UDP client!!')
    #host.cmd('cd ./%s/; nohup python2.7 ./')
    quietRun("pkill -9 -f client")
    quietRun("pkill -9 -f client.py")

 def cleanup( self ):
     "Help python collect its garbage."
     if not self.inNamespace:
         for intfName in self.intfNames():
             if self.name in intfName:
                 quietRun( 'ip link del ' + intfName )
     self.shell = None

def tunnelX11( node, display=None):
    """Create an X11 tunnel from node:6000 to the root host
       display: display on root host (optional)
       returns: node $DISPLAY, Popen object for tunnel"""
    if display is None and 'DISPLAY' in environ:
        display = environ[ 'DISPLAY' ]
    if display is None:
        error( "Error: Cannot connect to display\n" )
        return None, None
    host, screen = display.split( ':' )
    # Unix sockets should work
    if not host or host == 'unix':
        # GDM3 doesn't put credentials in .Xauthority,
        # so allow root to just connect
        quietRun( 'xhost +si:localuser:root' )
        return display, None
    else:
        # Add credentials with new hostname
        creds = subprocess.check_output( 'xauth list $DISPLAY', shell=True ).split('/', 1)
        if len( creds ) == 2:
            newCred = node.name + '/' + creds[ 1 ]
            node.cmd( 'xauth add ' + newCred )

        # Create a tunnel for the TCP connection
        port = 6000 + int( float( screen ) )
        connection = r'TCP\:%s\:%s' % ( host, port )
        cmd = [ "socat", "TCP-LISTEN:%d,fork,reuseaddr" % port,
                "EXEC:'mnexec -a 1 socat STDIO %s'" % connection ]
    return 'localhost:' + screen, node.popen( cmd )

 def cleanup( self ):
     "Help python collect its garbage."
     # Intfs may end up in root NS
     for intfName in self.intfNames():
         if self.name in intfName:
             quietRun( 'ip link del ' + intfName )
     self.shell = None

 def start(self, controllers):
     "Start up kernel datapath."
     ofplog = "/tmp/" + self.name + "-ofp.log"
     quietRun("ifconfig lo up")
     # Delete local datapath if it exists;
     # then create a new one monitoring the given interfaces
     self.cmd("ovs-dpctl del-dp " + self.dp)
     self.cmd("ovs-dpctl add-dp " + self.dp)
     intfs = [str(i) for i in self.intfList() if not i.IP()]
     self.cmd("ovs-dpctl", "add-if", self.dp, " ".join(intfs))
     # Run protocol daemon
     clist = ",".join(["tcp:%s:%d" % (c.IP(), c.port) for c in controllers])
     self.cmd(
         "ovs-openflowd "
         + self.dp
         + " "
         + clist
         + " --fail=secure "
         + self.opts
         + " --datapath-id="
         + self.dpid
         + " 1>"
         + ofplog
         + " 2>"
         + ofplog
         + "&"
     )
     self.execed = False

 def __init__( self, mininet, stdin=sys.stdin, script=None ):
     self.mn = mininet
     # Local variable bindings for py command
     self.locals = { 'net': mininet }
     # Attempt to handle input
     self.stdin = stdin
     self.inPoller = poll()
     self.inPoller.register( stdin )
     self.inputFile = script
     Cmd.__init__( self )
     info( '*** Starting CLI:\n' )
     if self.inputFile:
         self.do_source( self.inputFile )
         return
     while True:
         try:
             # Make sure no nodes are still waiting
             for node in self.mn.values():
                 while node.waiting:
                     node.sendInt()
                     node.monitor()
             if self.isatty():
                 quietRun( 'stty sane' )
             self.cmdloop()
             break
         except KeyboardInterrupt:
             output( '\nInterrupt\n' )

 def do_noecho( self, line ):
     "Run an interactive command with echoing turned off."
     if self.isatty():
         quietRun( 'stty -echo' )
     self.default( line )
     if self.isatty():
         quietRun( 'stty echo' )

 def __init__( self, mininet, stdin=sys.stdin, script=None ):
     self.mn = mininet
     self.nodelist = self.mn.controllers + self.mn.switches + self.mn.hosts
     self.nodemap = {}  # map names to Node objects
     for node in self.nodelist:
         self.nodemap[ node.name ] = node
     # Attempt to handle input
     self.stdin = stdin
     self.inPoller = poll()
     self.inPoller.register( stdin )
     self.inputFile = script
     Cmd.__init__( self )
     info( '*** Starting CLI:\n' )
     if self.inputFile:
         self.do_source( self.inputFile )
         return
     while True:
         try:
             # Make sure no nodes are still waiting
             for node in self.nodelist:
                 while node.waiting:
                     node.sendInt()
                     node.monitor()
             if self.isatty():
                 quietRun( 'stty sane' )
             self.cmdloop()
             break
         except KeyboardInterrupt:
             output( '\nInterrupt\n' )

 def setupInts(intfs):
     '''
     add taps and bring them up.
     '''
     for i in intfs:
         quietRun('ip tuntap add dev %s mode tap' % i)
         quietRun('ip link set dev %s up' % i)
         info('*** Intf %s set\n' % i)

def cleanUpScreens():
    "Remove moldy old screen sessions."
    r = r'(\d+\.mininet\.[hsc]\d+)'
    output = quietRun( 'screen -ls' ).split( '\n' )
    for line in output:
        m = re.search( r, line )
        if m:
            quietRun( 'screen -S ' + m.group( 1 ) + ' -X quit' )

def configSFlow(spine, leaf, collector, ifname):
    sflow = 'ovs-vsctl -- [email protected] create sflow agent=%s target=%s sampling=10 polling=20 --' % (ifname, collector)
    for s in range(1,spine+1):
        sflow += ' -- set bridge s%s [email protected]' % s
    for ls in range(1,leaf+1):
        sflow += ' -- set bridge s%s [email protected]' % (spine+ls)
    info('*** Configuring sFlow collector=%s \n' % collector)
    quietRun(sflow)

 def cgroupSet(self, param, value, resource="cpu"):
     "Set a cgroup parameter and return its value"
     cmd = "cgset -r %s.%s=%s /%s" % (resource, param, value, self.name)
     quietRun(cmd)
     nvalue = int(self.cgroupGet(param, resource))
     if nvalue != value:
         error("*** error: cgroupSet: %s set to %s instead of %s\n" % (param, nvalue, value))
     return nvalue

 def __init__( self, net, *args, **kwargs ):
     self.iperfs = {}
     self.bw = '12k'
     self.mn = net
     self.lastbw = {}  # last bandwidth reports
     self.start()
     quietRun( 'rm /tmp/*.iperf /tmp/*.client' )
     CLI.__init__( self, net, *args, **kwargs )

 def setupInts(intfs):
     """
     add taps and bring them up.
     """
     for i in intfs:
         quietRun("ip tuntap add dev %s mode tap" % i)
         quietRun("ip link set dev %s up" % i)
         info("*** Intf %s set\n" % i)

    def delete( self ):
        "Delete interface"
        self.cmd( 'ip link del ' + self.name )
	self.cmd( 'ovs-vsctl del-port ' + self.name.split('-')[0] + ' ' + self.name) ###
        if self.node.inNamespace:
            # Link may have been dumped into root NS
            quietRun( 'ip link del ' + self.name )
	    quietRun( 'ovs-vsctl del-port ' + self.name.split('-')[0] + ' ' + self.name) ###

 def deleteIntf(self, intf):
     del self.connection[intf]
     port = self.intfToPort(intf)
     if port is not None:
         del self.intfs[port]
     del self.ports[intf]
     
     quietRun( 'ip link del ' + intf )
     sleep( 0.001 )