Check to make sure sudo works without password.

an unprivileged Python process

.gitignore

@@ -1,8 +1,6 @@
 mnexec
 *.pyc
 *~
-\#*\#
 mininet.egg-info
-build/*
-dist/*
-
+build
+dist

.pylint

@@ -25,6 +25,9 @@ ignore=CVS
 # Pickle collected data for later comparisons.
 persistent=yes
 
+# Set the cache size for astng objects.
+cache-size=500
+
 # List of plugins (as comma separated values of python modules names) to load,
 # usually to register additional checkers.
 load-plugins=
@@ -32,15 +35,24 @@ load-plugins=
 
 [MESSAGES CONTROL]
 
-# Enable the message, report, category or checker with the given id(s). You can
-# either give multiple identifier separated by comma (,) or put this option
-# multiple time.
-#enable=
+# Enable only checker(s) with the given id(s). This option conflicts with the
+# disable-checker option
+#enable-checker=
 
-# Disable the message, report, category or checker with the given id(s). You
-# can either give multiple identifier separated by comma (,) or put this option
-# multiple time (only on the command line, not in the configuration file where
-# it should appear only once).
+# Enable all checker(s) except those with the given id(s). This option
+# conflicts with the enable-checker option
+#disable-checker=
+
+# Enable all messages in the listed categories (IRCWEF).
+#enable-msg-cat=
+
+# Disable all messages in the listed categories (IRCWEF).
+disable-msg-cat=IR
+
+# Enable the message(s) with the given id(s).
+#enable-msg=
+
+# Disable the message(s) with the given id(s).
 disable=W0704,C0103,W0231,E1102,W0511,W0142,R0902,R0903,R0904,R0913,R0914,R0801,I0011
 
 
@@ -48,7 +60,7 @@ disable=W0704,C0103,W0231,E1102,W0511,W0142,R0902,R0903,R0904,R0913,R0914,R0801,
 
 # Set the output format. Available formats are text, parseable, colorized, msvs
 # (visual studio) and html
-output-format=colorized
+output-format=text
 
 # Include message's id in outpu
 include-ids=yes
@@ -264,7 +276,7 @@ int-import-graph=
 max-line-length=80
 
 # Maximum number of lines in a module
-max-module-lines=1500
+max-module-lines=1000
 
 # String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
 # tab).

Makefile

@@ -1,39 +1,30 @@
+all: codecheck test
+
+clean:
+	rm -rf build dist *.egg-info *.pyc mnexec bin/mnexec
+
 MININET = mininet/*.py
 TEST = mininet/test/*.py
 EXAMPLES = examples/*.py
 BIN = bin/mn
 PYSRC = $(MININET) $(TEST) $(EXAMPLES) $(BIN)
-MNEXEC = mnexec
+
 P8IGN = E251,E201,E302,E202
 
-all: codecheck test
-
-clean:
-	rm -rf build dist *.egg-info *.pyc $(MNEXEC)
-
 codecheck: $(PYSRC)
 	-echo "Running code check"
 	pyflakes $(PYSRC)
 	pylint --rcfile=.pylint $(PYSRC)
 	pep8 --repeat --ignore=$(P8IGN) $(PYSRC)
 
-errcheck: $(PYSRC)
-	-echo "Running check for errors only"
-	pyflakes $(PYSRC)
-	pylint -E --rcfile=.pylint $(PYSRC)
-
 test: $(MININET) $(TEST)
 	-echo "Running tests"
 	mininet/test/test_nets.py
 
-install: $(MNEXEC)
-	install $(MNEXEC) /usr/local/bin/
+install: mnexec
+	cp mnexec bin/
 	python setup.py install
 
-develop: $(MNEXEC)
-	install $(MNEXEC) /usr/local/bin/
-	python setup.py develop
-
 doc:
 	doxygen doxygen.cfg
 

bin/mn

@@ -18,17 +18,13 @@ import time
 
 from mininet.clean import cleanup
 from mininet.cli import CLI
-from mininet.log import lg, LEVELS, info, warn
-from mininet.net import Mininet, MininetWithControlNet
-from mininet.node import ( Host, CPULimitedHost, Controller, OVSController,
-                           NOX, RemoteController, UserSwitch, OVSKernelSwitch,
-                           OVSLegacyKernelSwitch )
-from mininet.link import Link, TCLink
+from mininet.log import lg, LEVELS, info
+from mininet.net import Mininet, init
+from mininet.node import KernelSwitch, Host, Controller, ControllerParams, NOX
+from mininet.node import RemoteController, UserSwitch, OVSKernelSwitch
 from mininet.topo import SingleSwitchTopo, LinearTopo, SingleSwitchReversedTopo
 from mininet.topolib import TreeTopo
-from mininet.util import makeNumeric, custom, customConstructor, splitArgs
-from mininet.util import buildTopo
-
+from mininet.util import makeNumeric
 
 # built in topologies, created only when run
 TOPODEF = 'minimal'
@@ -39,26 +35,20 @@ TOPOS = { 'minimal': lambda: SingleSwitchTopo( k=2 ),
          'tree': TreeTopo }
 
 SWITCHDEF = 'ovsk'
-SWITCHES = { 'user': UserSwitch,
-            'ovsk': OVSKernelSwitch,
-             'ovsl': OVSLegacyKernelSwitch }
+SWITCHES = { 'kernel': KernelSwitch,
+            'user': UserSwitch,
+            'ovsk': OVSKernelSwitch }
 
-HOSTDEF = 'proc'
-HOSTS = { 'proc': Host,
-          'rt': custom( CPULimitedHost, sched='rt' ),
-          'cfs': custom( CPULimitedHost, sched='cfs' ) }
+HOSTDEF = 'process'
+HOSTS = { 'process': Host }
 
 CONTROLLERDEF = 'ref'
+# a and b are the name and inNamespace params.
 CONTROLLERS = { 'ref': Controller,
-                'ovsc': OVSController,
-                'nox': NOX,
-                'remote': RemoteController,
-                'none': lambda name: None }
-
-LINKDEF = 'default'
-LINKS = { 'default': Link,
-          'tc': TCLink }
-
+               'nox_dump': lambda name: NOX( name, 'packetdump' ),
+               'nox_pysw': lambda name: NOX( name, 'pyswitch' ),
+               'remote': lambda name: None,
+               'none': lambda name: None }
 
 # optional tests to run
 TESTS = [ 'cli', 'build', 'pingall', 'pingpair', 'iperf', 'all', 'iperfudp',
@@ -67,6 +57,25 @@ TESTS = [ 'cli', 'build', 'pingall', 'pingpair', 'iperf', 'all', 'iperfudp',
 ALTSPELLING = { 'pingall': 'pingAll', 'pingpair': 'pingPair',
     'iperfudp': 'iperfUdp', 'iperfUDP': 'iperfUdp', 'prefixlen': 'prefixLen' }
 
+def buildTopo( topo ):
+    "Create topology from string with format (object, arg1, arg2,...)."
+    topo_split = topo.split( ',' )
+    topo_name = topo_split[ 0 ]
+    topo_params = topo_split[ 1: ]
+
+    # Convert int and float args; removes the need for every topology to
+    # be flexible with input arg formats.
+    topo_seq_params = [ s for s in topo_params if '=' not in s ]
+    topo_seq_params = [ makeNumeric( s ) for s in topo_seq_params ]
+    topo_kw_params = {}
+    for s in [ p for p in topo_params if '=' in p ]:
+        key, val = s.split( '=' )
+        topo_kw_params[ key ] = makeNumeric( val )
+
+    if topo_name not in TOPOS.keys():
+        raise Exception( 'Invalid topo_name %s' % topo_name )
+    return TOPOS[ topo_name ]( *topo_seq_params, **topo_kw_params )
+
 
 def addDictOption( opts, choicesDict, default, name, helpStr=None ):
     """Convenience function to add choices dicts to OptionParser.
@@ -79,10 +88,10 @@ def addDictOption( opts, choicesDict, default, name, helpStr=None ):
         raise Exception( 'Invalid  default %s for choices dict: %s' %
                         ( default, name ) )
     if not helpStr:
-        helpStr = ( '|'.join( sorted( choicesDict.keys() ) ) +
-                   '[,param=value...]' )
+        helpStr = '[' + ' '.join( choicesDict.keys() ) + ']'
     opts.add_option( '--' + name,
-                    type='string',
+                    type='choice',
+                    choices=choicesDict.keys(),
                     default = default,
                     help = helpStr )
 
@@ -115,11 +124,11 @@ class MininetRunner( object ):
 
     def parseCustomFile( self, fileName ):
         "Parse custom file and add params before parsing cmd-line options."
-        customs = {}
+        custom = {}
         if os.path.isfile( fileName ):
-            execfile( fileName, customs, customs )
-            for name, val in customs.iteritems():
-                self.setCustom( name, val )
+            execfile( fileName, custom, custom )
+            for name in custom:
+                self.setCustom( name, custom[ name ] )
         else:
             raise Exception( 'could not find custom file: %s' % fileName )
 
@@ -127,10 +136,11 @@ class MininetRunner( object ):
         """Parse command-line args and return options object.
            returns: opts parse options dict"""
         if '--custom' in sys.argv:
+            print "custom in sys.argv"
             index = sys.argv.index( '--custom' )
             if len( sys.argv ) > index + 1:
-                filename = sys.argv[ index + 1 ]
-                self.parseCustomFile( filename )
+                custom = sys.argv[ index + 1 ]
+                self.parseCustomFile( custom )
             else:
                 raise Exception( 'Custom file name not found' )
 
@@ -138,43 +148,46 @@ class MininetRunner( object ):
         addDictOption( opts, SWITCHES, SWITCHDEF, 'switch' )
         addDictOption( opts, HOSTS, HOSTDEF, 'host' )
         addDictOption( opts, CONTROLLERS, CONTROLLERDEF, 'controller' )
-        addDictOption( opts, LINKS, LINKDEF, 'link' )
-        addDictOption( opts, TOPOS, TOPODEF, 'topo' )
 
+        opts.add_option( '--topo', type='string', default=TOPODEF,
+                        help='[' + ' '.join( TOPOS.keys() ) + '],arg1,arg2,'
+                        '...argN')
         opts.add_option( '--clean', '-c', action='store_true',
                         default=False, help='clean and exit' )
         opts.add_option( '--custom', type='string', default=None,
                         help='read custom topo and node params from .py file' )
         opts.add_option( '--test', type='choice', choices=TESTS,
                         default=TESTS[ 0 ],
-                        help='|'.join( TESTS ) )
+                        help='[' + ' '.join( TESTS ) + ']' )
         opts.add_option( '--xterms', '-x', action='store_true',
                         default=False, help='spawn xterms for each node' )
-        opts.add_option( '--ipbase', '-i', type='string', default='10.0.0.0/8',
-                         help='base IP address for hosts' )
         opts.add_option( '--mac', action='store_true',
-                        default=False, help='automatically set host MACs' )
+                        default=False, help='set MACs equal to DPIDs' )
         opts.add_option( '--arp', action='store_true',
                         default=False, help='set all-pairs ARP entries' )
         opts.add_option( '--verbosity', '-v', type='choice',
                         choices=LEVELS.keys(), default = 'info',
-                        help = '|'.join( LEVELS.keys() )  )
+                        help = '[' + ' '.join( LEVELS.keys() ) + ']' )
+        opts.add_option( '--ip', type='string', default='127.0.0.1',
+                        help='[ip address as a dotted decimal string for a'
+                        'remote controller]' )
+        opts.add_option( '--port', type='int', default=6633,
+                        help='[port integer for a listening remote'
+                        ' controller]' )
         opts.add_option( '--innamespace', action='store_true',
                         default=False, help='sw and ctrl in namespace?' )
-        opts.add_option( '--listenport', type='int', default=6635,
-                         help='base port for passive switch listening' )
+        opts.add_option( '--listenport', type='int', default=6634,
+                        help='[base port for passive switch listening'
+                        ' controller]' )
         opts.add_option( '--nolistenport', action='store_true',
                         default=False, help="don't use passive listening port")
         opts.add_option( '--pre', type='string', default=None,
-                        help='CLI script to run before tests' )
+                        help='[CLI script to run before tests]' )
         opts.add_option( '--post', type='string', default=None,
-                        help='CLI script to run after tests' )
+                        help='[CLI script to run after tests]' )
         opts.add_option( '--prefixlen', type='int', default=8,
-                        help='prefix length (e.g. /8) for automatic '
-                        'network configuration' )
-        opts.add_option( '--pin', action='store_true',
-                         default=False, help="pin hosts to CPU cores "
-                         "(requires --host cfs or --host rt)" )
+                        help='[prefix length (e.g. /8) for automatic '
+                        'network configuration]' )
 
         self.options, self.args = opts.parse_args()
 
@@ -189,6 +202,9 @@ class MininetRunner( object ):
                     % self.options.verbosity )
         lg.setLogLevel( self.options.verbosity )
 
+        # validate environment setup
+        init()
+
     def begin( self ):
         "Create and run mininet."
 
@@ -198,33 +214,35 @@ class MininetRunner( object ):
 
         start = time.time()
 
-        topo = buildTopo( TOPOS, self.options.topo )
-        switch = customConstructor( SWITCHES, self.options.switch )
-        host = customConstructor( HOSTS, self.options.host )
-        controller = customConstructor( CONTROLLERS, self.options.controller )
-        link = customConstructor( LINKS, self.options.link )
+        topo = buildTopo( self.options.topo )
+        switch = SWITCHES[ self.options.switch ]
+        host = HOSTS[ self.options.host ]
+        controller = CONTROLLERS[ self.options.controller ]
+        if self.options.controller == 'remote':
+            controller = lambda a: RemoteController( a,
+                             defaultIP=self.options.ip,
+                             port=self.options.port )
 
         if self.validate:
             self.validate( self.options )
 
+        # We should clarify what this is actually for...
+        # It seems like it should be default values for the
+        # *data* network, so it may be misnamed.
+        controllerParams = ControllerParams( '10.0.0.0',
+            self.options.prefixlen)
+
         inNamespace = self.options.innamespace
-        Net = MininetWithControlNet if inNamespace else Mininet
-        ipBase = self.options.ipbase
         xterms = self.options.xterms
         mac = self.options.mac
         arp = self.options.arp
-        pin = self.options.pin
         listenPort = None
         if not self.options.nolistenport:
             listenPort = self.options.listenport
-        mn = Net( topo=topo,
-                  switch=switch, host=host, controller=controller,
-                  link=link,
-                  ipBase=ipBase,
-                  inNamespace=inNamespace,
-                  xterms=xterms, autoSetMacs=mac,
-                  autoStaticArp=arp, autoPinCpus=pin,
-                  listenPort=listenPort )
+        mn = Mininet( topo, switch, host, controller, controllerParams,
+                     inNamespace=inNamespace,
+                     xterms=xterms, autoSetMacs=mac,
+                     autoStaticArp=arp, listenPort=listenPort )
 
         if self.options.pre:
             CLI( mn, script=self.options.pre )

examples/README

@@ -6,21 +6,12 @@ Mininet's Python API.
 
 ---
 
-baresshd.py:
-
-This example uses Mininet's medium-level API to create an sshd
-process running in a namespace. Doesn't use OpenFlow.
-
 consoles.py:
 
 This example creates a grid of console windows, one for each node, 
 and allows interaction with and monitoring of each console, including
 graphical monitoring.
 
-controllers.py:
-
-This example creates a network and adds multiple controllers to it.
-
 emptynet.py:
 
 This example demonstrates creating an empty network (i.e. with no
@@ -35,34 +26,16 @@ miniedit.py:
 
 This example demonstrates creating a network via a graphical editor.
 
-multiping.py:
-
-This example demonstrates one method for 
-monitoring output from multiple hosts, using node.monitor().
-
-multipoll.py:
-
-This example demonstrates monitoring output files from multiple hosts.
-
 multitest.py:
 
 This example creates a network and runs multiple tests on it.
 
-popenpoll.py:
-
-This example demonstrates monitoring output from multiple hosts using
-the node.popen() interface (which returns Popen objects) and pmonitor().
-
 scratchnet.py, scratchnetuser.py:
 
 These two examples demonstrate how to create a network by using the lowest-
 level Mininet functions. Generally the higher-level API is easier to use,
 but scratchnet shows what is going on behind the scenes.
 
-simpleperf.py:
-
-A simple example of configuring network and CPU bandwidth limits.
-
 sshd.py:
 
 This example shows how to run an sshd process in each host, allowing
@@ -71,10 +44,10 @@ to an interface in the root namespace (generaly the control network
 already lives in the root namespace, so it does not need to be explicitly
 connected.)
 
-treeping64.py:
+treeping64:
 
 This example creates a 64-host tree network, and attempts to check full
-connectivity using ping, for different switch/datapath types.
+connectivity using ping, for three different switch/datapath types.
 
 tree1024.py:
 
@@ -82,3 +55,7 @@ This example attempts to create a 1024-host network, and then runs the
 CLI on it. It may run into scalability limits, depending on available
 memory and sysctl configuration (see INSTALL.)
 
+udpbwtest.py:
+
+This example shows how to run a test across an entire network, and monitor
+the output of a set of hosts in real time.

examples/baresshd.py

@@ -6,17 +6,14 @@ from mininet.node import Host
 
 print "*** Creating nodes"
 h1 = Host( 'h1' )
-
 root = Host( 'root', inNamespace=False )
 
 print "*** Creating links"
 h1.linkTo( root )
 
-print h1
-
 print "*** Configuring nodes"
-h1.setIP( '10.0.0.1', 8 )
-root.setIP( '10.0.0.2', 8 )
+h1.setIP( h1.intfs[ 0 ], '10.0.0.1', 8 )
+root.setIP( root.intfs[ 0 ], '10.0.0.2', 8 )
 
 print "*** Creating banner file"
 f = open( '/tmp/%s.banner' % h1.name, 'w' )

examples/consoles.py

@@ -107,10 +107,8 @@ class Console( Frame ):
         self.text.insert( 'end', text )
         self.text.mark_set( 'insert', 'end' )
         self.text.see( 'insert' )
-        outputHook = lambda x, y: True  # make pylint happier
         if self.outputHook:
-            outputHook = self.outputHook
-        outputHook( self, text )
+            self.outputHook( self, text )
 
     def handleKey( self, event ):
         "If it's an interactive command, send it to the node."
@@ -132,22 +130,27 @@ class Console( Frame ):
         self.sendCmd( cmd )
 
     # Callback ignores event
-    def handleInt( self, _event=None ):
+    # pylint: disable-msg=W0613
+    def handleInt( self, event=None ):
         "Handle control-c."
         self.node.sendInt()
+    # pylint: enable-msg=W0613
 
     def sendCmd( self, cmd ):
         "Send a command to our node."
         if not self.node.waiting:
             self.node.sendCmd( cmd )
 
-    def handleReadable( self, _fds, timeoutms=None ):
+    # Callback ignores fds
+    # pylint: disable-msg=W0613
+    def handleReadable( self, fds, timeoutms=None ):
         "Handle file readable event."
         data = self.node.monitor( timeoutms )
         self.append( data )
         if not self.node.waiting:
             # Print prompt
             self.append( self.prompt )
+    # pylint: enable-msg=W0613
 
     def waiting( self ):
         "Are we waiting for output?"
@@ -316,7 +319,9 @@ class ConsoleApp( Frame ):
 
         self.pack( expand=True, fill='both' )
 
-    def updateGraph( self, _console, output ):
+    # Update callback doesn't use console arg
+    # pylint: disable-msg=W0613
+    def updateGraph( self, console, output ):
         "Update our graph."
         m = re.search( r'(\d+) Mbits/sec', output )
         if not m:
@@ -327,6 +332,7 @@ class ConsoleApp( Frame ):
             self.graph.addBar( self.bw )
             self.bw = 0
             self.updates = 0
+    # pylint: enable-msg=W0613
 
     def setOutputHook( self, fn=None, consoles=None ):
         "Register fn as output hook [on specific consoles.]"

examples/cpu.py

@@ -1,81 +0,0 @@
-#!/usr/bin/python
-
-"""
-cpu.py: test iperf bandwidth for varying cpu limtis
-"""
-
-from mininet.net import Mininet
-from mininet.node import CPULimitedHost
-from mininet.topolib import TreeTopo
-from mininet.util import custom
-from mininet.log import setLogLevel, output
-
-from time import sleep
-
-def waitListening(client, server, port):
-    "Wait until server is listening on port"
-    if not client.cmd('which telnet'):
-        raise Exception('Could not find telnet')
-    cmd = ('sh -c "echo A | telnet -e A %s %s"' %
-           (server.IP(), port))
-    while 'Connected' not in client.cmd(cmd):
-        output('waiting for', server,
-               'to listen on port', port, '\n')
-        sleep(.5)
-
-
-def bwtest( cpuLimits, period_us=100000, seconds=5 ):
-    """Example/test of link and CPU bandwidth limits
-       cpu: cpu limit as fraction of overall CPU time"""
-
-    topo = TreeTopo( depth=1, fanout=2 )
-
-    results = {}
-
-    for sched in 'rt', 'cfs':
-        print '*** Testing with', sched, 'bandwidth limiting'
-        for cpu in cpuLimits:
-            host = custom( CPULimitedHost, sched=sched,
-                           period_us=period_us,
-                           cpu=cpu )
-            net = Mininet( topo=topo, host=host )
-            net.start()
-            net.pingAll()
-            hosts = [ net.getNodeByName( h ) for h in topo.hosts() ]
-            client, server = hosts[ 0 ], hosts[ -1 ]
-            server.cmd( 'iperf -s -p 5001 &' )
-            waitListening( client, server, 5001 )
-            result = client.cmd( 'iperf -yc -t %s -c %s' % (
-                    seconds, server.IP() ) ).split( ',' )
-            bps = float( result[ -1 ] )
-            server.cmdPrint( 'kill %iperf' )
-            net.stop()
-            updated = results.get( sched, [] )
-            updated += [ ( cpu, bps ) ]
-            results[ sched ] = updated
-
-    return results
-
-
-def dump( results ):
-    "Dump results"
-
-    fmt = '%s\t%s\t%s'
-
-    print
-    print fmt % ( 'sched', 'cpu', 'client MB/s' )
-    print
-
-    for sched in sorted( results.keys() ):
-        entries = results[ sched ]
-        for cpu, bps in entries:
-            pct = '%.2f%%' % ( cpu * 100 )
-            mbps = bps / 1e6
-            print fmt % ( sched, pct, mbps )
-
-
-if __name__ == '__main__':
-    setLogLevel( 'info' )
-    limits = [ .45, .4, .3, .2, .1 ]
-    out = bwtest( limits )
-    dump( out )

examples/limit.py

@@ -1,69 +0,0 @@
-#!/usr/bin/python
-
-"""
-limit.py: example of using link and CPU limits
-"""
-
-from mininet.net import Mininet
-from mininet.link import TCIntf
-from mininet.node import CPULimitedHost
-from mininet.topolib import TreeTopo
-from mininet.util import custom, quietRun
-from mininet.log import setLogLevel
-from time import sleep
-
-def testLinkLimit( net, bw ):
-    "Run bandwidth limit test"
-    print '*** Testing network %.2f Mbps bandwidth limit' % bw
-    net.iperf( )
-
-def testCpuLimit( net, cpu ):
-    "run CPU limit test"
-    pct = cpu * 100
-    print '*** Testing CPU %.0f%% bandwidth limit' % pct
-    h1, h2 = net.hosts
-    h1.cmd( 'while true; do a=1; done &' )
-    h2.cmd( 'while true; do a=1; done &' )
-    pid1 = h1.cmd( 'echo $!' ).strip()
-    pid2 = h2.cmd( 'echo $!' ).strip()
-    cmd = 'ps -p %s,%s -o pid,%%cpu,args' % ( pid1, pid2 )
-    # It's a shame that this is what pylint prefers
-    for _ in range( 5 ):
-        sleep( 1 )
-        print quietRun( cmd ).strip()
-    h1.cmd( 'kill %1')
-    h2.cmd( 'kill %1')
-
-def limit( bw=10, cpu=.4 ):
-    """Example/test of link and CPU bandwidth limits
-       bw: interface bandwidth limit in Mbps
-       cpu: cpu limit as fraction of overall CPU time"""
-    intf = custom( TCIntf, bw=bw )
-    myTopo = TreeTopo( depth=1, fanout=2 )
-    for sched in 'rt', 'cfs':
-        print '*** Testing with', sched, 'bandwidth limiting'
-        host = custom( CPULimitedHost, sched=sched, cpu=cpu )
-        net = Mininet( topo=myTopo, intf=intf, host=host )
-        net.start()
-        testLinkLimit( net, bw=bw )
-        testCpuLimit( net, cpu=cpu )
-        net.stop()
-
-def verySimpleLimit( bw=150 ):
-    "Absurdly simple limiting test"
-    intf = custom( TCIntf, bw=bw )
-    net = Mininet( intf=intf )
-    h1, h2 = net.addHost( 'h1' ), net.addHost( 'h2' )
-    net.addLink( h1, h2 )
-    net.start()
-    net.pingAll()
-    net.iperf()
-    h1.cmdPrint( 'tc -s qdisc ls dev', h1.defaultIntf() )
-    h2.cmdPrint( 'tc -d class show dev', h2.defaultIntf() )
-    h1.cmdPrint( 'tc -s qdisc ls dev', h1.defaultIntf() )
-    h2.cmdPrint( 'tc -d class show dev', h2.defaultIntf() )
-    net.stop()
-
-if __name__ == '__main__':
-    setLogLevel( 'info' )
-    limit()

examples/linearbandwidth.py

@@ -6,9 +6,9 @@ using both kernel and user datapaths.
 
 We construct a network of N hosts and N-1 switches, connected as follows:
 
-h1 <-> s1 <-> s2 .. sN-1
-       |       |    |
-       h2      h3   hN
+h1 <-> sN+1 <-> sN+2 .. sN+N-1
+       |        |       |
+       h2       h3      hN
 
 WARNING: by default, the reference controller only supports 16
 switches, so this test WILL NOT WORK unless you have recompiled
@@ -23,40 +23,42 @@ of switches, this example demonstrates:
 
 """
 
-from mininet.net import Mininet
-from mininet.node import UserSwitch, OVSKernelSwitch
-from mininet.topo import Topo
-from mininet.log import lg
-from mininet.util import irange
-
 import sys
 flush = sys.stdout.flush
 
+from mininet.net import init, Mininet
+# from mininet.node import KernelSwitch
+from mininet.node import UserSwitch, OVSKernelSwitch
+from mininet.topo import Topo, Node
+from mininet.log import lg
+
 class LinearTestTopo( Topo ):
     "Topology for a string of N hosts and N-1 switches."
 
-    def __init__( self, N, **params ):
+    def __init__( self, N ):
 
-        # Initialize topology
-        Topo.__init__( self, **params )
+        # Add default members to class.
+        super( LinearTestTopo, self ).__init__()
 
-        # Create switches and hosts
-        hosts = [ self.add_host( 'h%s' % h )
-                  for h in irange( 1, N ) ]
-        switches = [ self.add_switch( 's%s' % s )
-                     for s in irange( 1, N - 1 ) ]
+        # Create switch and host nodes
+        hosts = range( 1, N + 1 )
+        switches = range( N + 1 , N + N )
+        for h in hosts:
+            self.add_node( h, Node( is_switch=False ) )
+        for s in switches:
+            self.add_node( s, Node( is_switch=True ) )
 
         # Wire up switches
-        last = None
-        for switch in switches:
-            if last:
-                self.add_link( last, switch )
-            last = switch
+        for s in switches[ :-1 ]:
+            self.add_edge( s, s + 1 )
 
         # Wire up hosts
-        self.add_link( hosts[ 0 ], switches[ 0 ] )
-        for host, switch in zip( hosts[ 1: ], switches ):
-            self.add_link( host, switch )
+        self.add_edge( hosts[ 0 ], switches[ 0 ] )
+        for h in hosts[ 1: ]:
+            self.add_edge( h, h + N - 1 )
+
+        # Consider all switches and hosts 'on'
+        self.enable_all()
 
 
 def linearBandwidthTest( lengths ):
@@ -67,16 +69,15 @@ def linearBandwidthTest( lengths ):
     switchCount = max( lengths )
     hostCount = switchCount + 1
 
-    switches = { 'reference user': UserSwitch,
+    switches = {  # 'reference kernel': KernelSwitch,
+            'reference user': UserSwitch,
             'Open vSwitch kernel': OVSKernelSwitch }
 
-    topo = LinearTestTopo( hostCount )
-
     for datapath in switches.keys():
         print "*** testing", datapath, "datapath"
         Switch = switches[ datapath ]
         results[ datapath ] = []
-        net = Mininet( topo=topo, switch=Switch )
+        net = Mininet( topo=LinearTestTopo( hostCount ), switch=Switch )
         net.start()
         print "*** testing basic connectivity"
         for n in lengths:
@@ -105,6 +106,7 @@ def linearBandwidthTest( lengths ):
 
 if __name__ == '__main__':
     lg.setLogLevel( 'info' )
+    init()
     sizes = [ 1, 10, 20, 40, 60, 80, 100 ]
     print "*** Running linearBandwidthTest", sizes
     linearBandwidthTest( sizes  )

examples/miniedit.py

@@ -299,11 +299,14 @@ class MiniEdit( Frame ):
         # Delete from view
         self.canvas.delete( item )
 
-    def deleteSelection( self, _event ):
+    # Callback ignores event
+    # pylint: disable-msg=W0613
+    def deleteSelection( self, event ):
         "Delete the selected item."
         if self.selection is not None:
             self.deleteItem( self.selection )
         self.selectItem( None )
+    # pylint: enable-msg=W0613
 
     def nodeIcon( self, node, name ):
         "Create a new node icon."
@@ -347,11 +350,14 @@ class MiniEdit( Frame ):
         c = self.canvas
         c.coords( self.link, self.linkx, self.linky, x, y )
 
-    def releaseLink( self, _event ):
+    # Callback ignores event
+    # pylint: disable-msg=W0613
+    def releaseLink( self, event ):
         "Give up on the current link."
         if self.link is not None:
             self.canvas.delete( self.link )
         self.linkWidget = self.linkItem = self.link = None
+    # pylint: enable-msg=W0613
 
     # Generic node handlers
 
@@ -379,9 +385,12 @@ class MiniEdit( Frame ):
         "Select node on entry."
         self.selectNode( event )
 
-    def leaveNode( self, _event ):
+    # Callback ignores event
+    # pylint: disable-msg=W0613
+    def leaveNode( self, event ):
         "Restore old selection on exit."
         self.selectItem( self.lastSelection )
+    # pylint: enable-msg=W0613
 
     def clickNode( self, event ):
         "Node click handler."
@@ -445,21 +454,23 @@ class MiniEdit( Frame ):
         # Link bindings
         # Selection still needs a bit of work overall
         # Callbacks ignore event
+        # pylint: disable-msg=W0613
 
-        def select( _event, link=self.link ):
+        def select( event, link=self.link ):
             "Select item on mouse entry."
             self.selectItem( link )
 
-        def highlight( _event, link=self.link ):
+        def highlight( event, link=self.link ):
             "Highlight item on mouse entry."
             # self.selectItem( link )
             self.canvas.itemconfig( link, fill='green' )
 
-        def unhighlight( _event, link=self.link ):
+        def unhighlight( event, link=self.link ):
             "Unhighlight item on mouse exit."
             self.canvas.itemconfig( link, fill='blue' )
             # self.selectItem( None )
 
+        # pylint: disable-msg=W0613
         self.canvas.tag_bind( self.link, '<Enter>', highlight )
         self.canvas.tag_bind( self.link, '<Leave>', unhighlight )
         self.canvas.tag_bind( self.link, '<ButtonPress-1>', select )
@@ -591,7 +602,7 @@ class MiniEdit( Frame ):
         cleanUpScreens()
         self.net = None
 
-    def xterm( self, _=None ):
+    def xterm( self, _ignore=None ):
         "Make an xterm when a button is pressed."
         if ( self.selection is None or
              self.net is None or

examples/multiping.py

@@ -1,86 +0,0 @@
-#!/usr/bin/python
-
-"""
-multiping.py: monitor multiple sets of hosts using ping
-
-This demonstrates how one may send a simple shell script to
-multiple hosts and monitor their output interactively for a period=
-of time.
-"""
-
-from mininet.net import Mininet
-from mininet.node import Node
-from mininet.topo import SingleSwitchTopo
-from mininet.log import setLogLevel
-
-from select import poll, POLLIN
-from time import time
-
-def chunks( l, n ):
-    "Divide list l into chunks of size n - thanks Stackoverflow"
-    return [ l[ i : i + n ] for i in range( 0, len( l ), n ) ]
-
-def startpings( host, targetips ):
-    "Tell host to repeatedly ping targets"
-
-    targetips.append( '10.0.0.200' )
-
-    targetips = ' '.join( targetips )
-
-    # BL: Not sure why loopback intf isn't up!
-    host.cmd( 'ifconfig lo up' )
-
-    # Simple ping loop
-    cmd = ( 'while true; do '
-            ' for ip in %s; do ' % targetips +
-            '  echo -n %s "->" $ip ' % host.IP() +
-            '   `ping -c1 -w 1 $ip | grep packets` ;'
-            '  sleep 1;'
-            ' done; '
-            'done &' )
-
-    print ( '*** Host %s (%s) will be pinging ips: %s' %
-           ( host.name, host.IP(), targetips ) )
-
-    host.cmd( cmd )
-
-def multiping( netsize, chunksize, seconds):
-    "Ping subsets of size chunksize in net of size netsize"
-
-    # Create network and identify subnets
-    topo = SingleSwitchTopo( netsize )
-    net = Mininet( topo=topo )
-    net.start()
-    hosts = net.hosts
-    subnets = chunks( hosts, chunksize )
-
-    # Create polling object
-    fds = [ host.stdout.fileno() for host in hosts ]
-    poller = poll()
-    for fd in fds:
-        poller.register( fd, POLLIN )
-
-    # Start pings
-    for subnet in subnets:
-        ips = [ host.IP() for host in subnet ]
-        for host in subnet:
-            startpings( host, ips )
-
-    # Monitor output
-    endTime = time() + seconds
-    while time() < endTime:
-        readable = poller.poll(1000)
-        for fd, _mask in readable:
-            node = Node.outToNode[ fd ]
-            print '%s:' % node.name, node.monitor().strip()
-
-    # Stop pings
-    for host in hosts:
-        host.cmd( 'kill %while' )
-
-    net.stop()
-
-
-if __name__ == '__main__':
-    setLogLevel( 'info' )
-    multiping( netsize=20, chunksize=4, seconds=10 )

examples/multipoll.py

@@ -1,81 +0,0 @@
-#!/usr/bin/python
-
-"""
-Simple example of sending output to multiple files and
-monitoring them
-"""
-
-from mininet.topo import SingleSwitchTopo
-from mininet.net import Mininet
-from mininet.log import setLogLevel
-
-from time import time
-from select import poll, POLLIN
-from subprocess import Popen, PIPE
-
-def monitorFiles( outfiles, seconds, timeoutms ):
-    "Monitor set of files and return [(host, line)...]"
-    devnull = open( '/dev/null', 'w' )
-    tails, fdToFile, fdToHost = {}, {}, {}
-    for h, outfile in outfiles.iteritems():
-        tail = Popen( [ 'tail', '-f', outfile ],
-                     stdout=PIPE, stderr=devnull )
-        fd = tail.stdout.fileno()
-        tails[ h ] = tail
-        fdToFile[ fd ] = tail.stdout
-        fdToHost[ fd ] = h
-    # Prepare to poll output files
-    readable = poll()
-    for t in tails.values():
-        readable.register( t.stdout.fileno(), POLLIN )
-    # Run until a set number of seconds have elapsed
-    endTime = time() + seconds
-    while time() < endTime:
-        fdlist = readable.poll(timeoutms)
-        if fdlist:
-            for fd, _flags in fdlist:
-                f = fdToFile[ fd ]
-                host = fdToHost[ fd ]
-                # Wait for a line of output
-                line = f.readline().strip()
-                yield host, line
-        else:
-            # If we timed out, return nothing
-            yield None, ''
-    for t in tails.values():
-        t.terminate()
-    devnull.close()  # Not really necessary
-
-
-def monitorTest( N=3, seconds=3 ):
-    "Run pings and monitor multiple hosts"
-    topo = SingleSwitchTopo( N )
-    net = Mininet( topo )
-    net.start()
-    hosts = net.hosts
-    print "Starting test..."
-    server = hosts[ 0 ]
-    outfiles, errfiles = {}, {}
-    for h in hosts:
-        # Create and/or erase output files
-        outfiles[ h ] = '/tmp/%s.out' % h.name
-        errfiles[ h ] = '/tmp/%s.err' % h.name
-        h.cmd( 'echo >', outfiles[ h ] )
-        h.cmd( 'echo >', errfiles[ h ] )
-        # Start pings
-        h.cmdPrint('ping', server.IP(),
-                   '>', outfiles[ h ],
-                   '2>', errfiles[ h ],
-                   '&' )
-    print "Monitoring output for", seconds, "seconds"
-    for h, line in monitorFiles( outfiles, seconds, timeoutms=500 ):
-        if h:
-            print '%s: %s' % ( h.name, line )
-    for h in hosts:
-        h.cmd('kill %ping')
-    net.stop()
-
-
-if __name__ == '__main__':
-    setLogLevel('info')
-    monitorTest()

examples/popen.py

@@ -1,36 +0,0 @@
-#!/usr/bin/python
-
-"""
-This example monitors a number of hosts using host.popen() and
-pmonitor()
-"""
-
-from mininet.net import Mininet
-from mininet.node import CPULimitedHost
-from mininet.topo import SingleSwitchTopo
-from mininet.log import setLogLevel
-from mininet.util import custom, pmonitor
-
-def monitorhosts( hosts=5, sched='cfs' ):
-    "Start a bunch of pings and monitor them using popen"
-    mytopo = SingleSwitchTopo( hosts )
-    cpu = .5 / hosts
-    myhost = custom( CPULimitedHost, cpu=cpu, sched=sched )
-    net = Mininet( topo=mytopo, host=myhost )
-    net.start()
-    # Start a bunch of pings
-    popens = {}
-    last = net.hosts[ -1 ]
-    for host in net.hosts:
-        popens[ host ] = host.popen( "ping -c5 %s" % last.IP() )
-        last = host
-    # Monitor them and print output
-    for host, line in pmonitor( popens ):
-        if host:
-            print "<%s>: %s" % ( host.name, line.strip() )
-    # Done
-    net.stop()
-
-if __name__ == '__main__':
-    setLogLevel( 'info' )
-    monitorhosts( hosts=5 )

examples/popenpoll.py

@@ -1,33 +0,0 @@
-#!/usr/bin/python
-
-"Monitor multiple hosts using popen()/pmonitor()"
-
-from mininet.net import Mininet
-from mininet.topo import SingleSwitchTopo
-from mininet.util import pmonitor
-from time import time
-from signal import SIGINT
-
-def pmonitorTest( N=3, seconds=10 ):
-    "Run pings and monitor multiple hosts using pmonitor"
-    topo = SingleSwitchTopo( N )
-    net = Mininet( topo )
-    net.start()
-    hosts = net.hosts
-    print "Starting test..."
-    server = hosts[ 0 ]
-    popens = {}
-    for h in hosts:
-        popens[ h ] = h.popen('ping', server.IP() )
-    print "Monitoring output for", seconds, "seconds"
-    endTime = time() + seconds
-    for h, line in pmonitor( popens, timeoutms=500 ):
-        if h:
-            print '%s: %s' % ( h.name, line ),
-        if time() >= endTime:
-            for p in popens.values():
-                p.send_signal( SIGINT )
-    net.stop()
-
-if __name__ == '__main__':
-    pmonitorTest()

examples/scratchnet.py

@@ -8,16 +8,13 @@ but it exposes the configuration details and allows customization.
 For most tasks, the higher-level API will be preferable.
 """
 
-from mininet.net import Mininet
-from mininet.node import Node
-from mininet.link import Link
+from mininet.net import init
+from mininet.node import Node, OVSKernelSwitch
+from mininet.util import createLink
 from mininet.log import setLogLevel, info
-from mininet.util import quietRun
 
-from time import sleep
-
-def scratchNet( cname='controller', cargs='-v ptcp:' ):
-    "Create network from scratch using Open vSwitch."
+def scratchNet( cname='controller', cargs='ptcp:' ):
+    "Create network from scratch using kernel switch."
 
     info( "*** Creating nodes\n" )
     controller = Node( 'c0', inNamespace=False )
@@ -26,43 +23,36 @@ def scratchNet( cname='controller', cargs='-v ptcp:' ):
     h1 = Node( 'h1' )
 
     info( "*** Creating links\n" )
-    Link( h0, switch )
-    Link( h1, switch )
+    createLink( node1=h0, node2=switch, port1=0, port2=0 )
+    createLink( node1=h1, node2=switch, port1=0, port2=1 )
 
     info( "*** Configuring hosts\n" )
-    h0.setIP( '192.168.123.1/24' )
-    h1.setIP( '192.168.123.2/24' )
+    h0.setIP( h0.intfs[ 0 ], '192.168.123.1', 24 )
+    h1.setIP( h1.intfs[ 0 ], '192.168.123.2', 24 )
     info( str( h0 ) + '\n' )
     info( str( h1 ) + '\n' )
 
-    info( "*** Starting network using Open vSwitch\n" )
+    info( "*** Starting network using Open vSwitch kernel datapath\n" )
     controller.cmd( cname + ' ' + cargs + '&' )
-    switch.cmd( 'ovs-vsctl del-br dp0' )
-    switch.cmd( 'ovs-vsctl add-br dp0' )
+    switch.cmd( 'ovs-dpctl del-dp dp0' )
+    switch.cmd( 'ovs-dpctl add-dp dp0' )
     for intf in switch.intfs.values():
-        print switch.cmd( 'ovs-vsctl add-port dp0 %s' % intf )
-
-    # Note: controller and switch are in root namespace, and we
-    # can connect via loopback interface
-    switch.cmd( 'ovs-vsctl set-controller dp0 tcp:127.0.0.1:6633' )
-
-    info( '*** Waiting for switch to connect to controller' )
-    while 'is_connected' not in quietRun( 'ovs-vsctl show' ):
-        sleep( 1 )
-        info( '.' )
-    info( '\n' )
+        print switch.cmd( 'ovs-dpctl add-if dp0 ' + intf )
+    print switch.cmd( 'ovs-openflowd dp0 tcp:127.0.0.1 &' )
 
     info( "*** Running test\n" )
     h0.cmdPrint( 'ping -c1 ' + h1.IP() )
 
     info( "*** Stopping network\n" )
     controller.cmd( 'kill %' + cname )
-    switch.cmd( 'ovs-vsctl del-br dp0' )
+    switch.cmd( 'ovs-dpctl del-dp dp0' )
+    switch.cmd( 'kill %ovs-openflowd' )
     switch.deleteIntfs()
     info( '\n' )
 
 if __name__ == '__main__':
     setLogLevel( 'info' )
     info( '*** Scratch network demo (kernel datapath)\n' )
-    Mininet.init()
+    OVSKernelSwitch.setup()
+    init()
     scratchNet()

examples/scratchnetuser.py

@@ -10,16 +10,11 @@ For most tasks, the higher-level API will be preferable.
 This version uses the user datapath and an explicit control network.
 """
 
-from mininet.net import Mininet
+from mininet.net import init
 from mininet.node import Node
-from mininet.link import Link
+from mininet.util import createLink
 from mininet.log import setLogLevel, info
 
-def linkIntfs( node1, node2 ):
-    "Create link from node1 to node2 and return intfs"
-    link = Link( node1, node2 )
-    return link.intf1, link.intf2
-
 def scratchNetUser( cname='controller', cargs='ptcp:' ):
     "Create network from scratch using user switch."
 
@@ -33,17 +28,17 @@ def scratchNetUser( cname='controller', cargs='ptcp:' ):
     switch = Node( 's0')
     h0 = Node( 'h0' )
     h1 = Node( 'h1' )
-    cintf, sintf = linkIntfs( controller, switch )
-    h0intf, sintf1 = linkIntfs( h0, switch )
-    h1intf, sintf2 = linkIntfs( h1, switch )
+    cintf, sintf = createLink( controller, switch )
+    h0intf, sintf1 = createLink( h0, switch )
+    h1intf, sintf2 = createLink( h1, switch )
 
     info( '*** Configuring control network\n' )
-    controller.setIP( '10.0.123.1/24', cintf )
-    switch.setIP( '10.0.123.2/24', sintf)
+    controller.setIP( cintf, '10.0.123.1', 24 )
+    switch.setIP( sintf, '10.0.123.2', 24 )
 
     info( '*** Configuring hosts\n' )
-    h0.setIP( '192.168.123.1/24', h0intf )
-    h1.setIP( '192.168.123.2/24', h1intf )
+    h0.setIP( h0intf, '192.168.123.1', 24 )
+    h1.setIP( h1intf, '192.168.123.2', 24 )
 
     info( '*** Network state:\n' )
     for node in controller, switch, h0, h1:
@@ -52,7 +47,7 @@ def scratchNetUser( cname='controller', cargs='ptcp:' ):
     info( '*** Starting controller and user datapath\n' )
     controller.cmd( cname + ' ' + cargs + '&' )
     switch.cmd( 'ifconfig lo 127.0.0.1' )
-    intfs = [ str( i ) for i in sintf1, sintf2 ]
+    intfs = [ sintf1, sintf2 ]
     switch.cmd( 'ofdatapath -i ' + ','.join( intfs ) + ' ptcp: &' )
     switch.cmd( 'ofprotocol tcp:' + controller.IP() + ' tcp:localhost &' )
 
@@ -69,5 +64,5 @@ def scratchNetUser( cname='controller', cargs='ptcp:' ):
 if __name__ == '__main__':
     setLogLevel( 'info' )
     info( '*** Scratch network demo (user datapath)\n' )
-    Mininet.init()
+    init()
     scratchNetUser()

examples/simpleperf.py

@@ -1,44 +0,0 @@
-#!/usr/bin/python
-
-"""
-Simple example of setting network and CPU parameters
-"""
-
-from mininet.topo import Topo
-from mininet.net import Mininet
-from mininet.node import CPULimitedHost
-from mininet.link import TCLink
-from mininet.util import dumpNodeConnections
-from mininet.log import setLogLevel
-
-class SingleSwitchTopo(Topo):
-    "Single switch connected to n hosts."
-    def __init__(self, n=2, **opts):
-        Topo.__init__(self, **opts)
-        switch = self.add_switch('s1')
-        for h in range(n):
-            # Each host gets 50%/n of system CPU
-            host = self.add_host('h%s' % (h + 1),
-                                 cpu=.5 / n)
-            # 10 Mbps, 5ms delay, 10% loss
-            self.add_link(host, switch,
-                          bw=10, delay='5ms', loss=10, use_htb=True)
-
-def perfTest():
-    "Create network and run simple performance test"
-    topo = SingleSwitchTopo(n=4)
-    net = Mininet(topo=topo,
-                  host=CPULimitedHost, link=TCLink)
-    net.start()
-    print "Dumping host connections"
-    dumpNodeConnections(net.hosts)
-    print "Testing network connectivity"
-    net.pingAll()
-    print "Testing bandwidth between h1 and h4"
-    h1, h4 = net.getNodeByName('h1', 'h4')
-    net.iperf((h1, h4))
-    net.stop()
-
-if __name__ == '__main__':
-    setLogLevel('info')
-    perfTest()

examples/sshd.py

@@ -21,7 +21,7 @@ from mininet.cli import CLI
 from mininet.log import lg
 from mininet.node import Node, OVSKernelSwitch
 from mininet.topolib import TreeTopo
-from mininet.link import Link
+from mininet.util import createLink
 
 def TreeNet( depth=1, fanout=2, **kwargs ):
     "Convenience function for creating tree networks."
@@ -37,13 +37,13 @@ def connectToRootNS( network, switch, ip, prefixLen, routes ):
       routes: host networks to route to"""
     # Create a node in root namespace and link to switch 0
     root = Node( 'root', inNamespace=False )
-    intf = Link( root, switch ).intf1
-    root.setIP( ip, prefixLen, intf )
+    intf = createLink( root, switch )[ 0 ]
+    root.setIP( intf, ip, prefixLen )
     # Start network that now includes link to root namespace
     network.start()
     # Add routes from root ns to hosts
     for route in routes:
-        root.cmd( 'route add -net ' + route + ' dev ' + str( intf ) )
+        root.cmd( 'route add -net ' + route + ' dev ' + intf )
 
 def sshd( network, cmd='/usr/sbin/sshd', opts='-D' ):
     "Start a network, connect it to root ns, and run sshd on all hosts."

mininet/clean.py

@@ -45,12 +45,6 @@ def cleanup():
         if dp != '':
             sh( 'dpctl deldp ' + dp )
 
-    info( "***  Removing OVS datapaths" )
-    dps = sh("ovs-vsctl list-br").split( '\n' )
-    for dp in dps:
-        if dp:
-            sh( 'ovs-vsctl del-br ' + dp )
-
     info( "*** Removing all links of the pattern foo-ethX\n" )
     links = sh( "ip link show | egrep -o '(\w+-eth\w+)'" ).split( '\n' )
     for link in links:

mininet/cli.py

@@ -30,11 +30,10 @@ from cmd import Cmd
 from os import isatty
 from select import poll, POLLIN
 import sys
-import time
 
 from mininet.log import info, output, error
 from mininet.term import makeTerms
-from mininet.util import quietRun, isShellBuiltin, dumpNodeConnections
+from mininet.util import quietRun, isShellBuiltin
 
 class CLI( Cmd ):
     "Simple command-line interface to talk to nodes."
@@ -47,9 +46,6 @@ class CLI( Cmd ):
         self.nodemap = {}  # map names to Node objects
         for node in self.nodelist:
             self.nodemap[ node.name ] = node
-        # Local variable bindings for py command
-        self.locals = { 'net': mininet }
-        self.locals.update( self.nodemap )
         # Attempt to handle input
         self.stdin = stdin
         self.inPoller = poll()
@@ -81,7 +77,7 @@ class CLI( Cmd ):
     # Disable pylint "Unused argument: 'arg's'" messages, as well as
     # "method could be a function" warning, since each CLI function
     # must have the same interface
-    # pylint: disable-msg=R0201
+    # pylint: disable-msg=W0613,R0201
 
     helpStr = (
         'You may also send a command to a node using:\n'
@@ -108,14 +104,21 @@ class CLI( Cmd ):
         if line is '':
             output( self.helpStr )
 
-    def do_nodes( self, _line ):
+    def do_nodes( self, line ):
         "List all nodes."
         nodes = ' '.join( [ node.name for node in sorted( self.nodelist ) ] )
         output( 'available nodes are: \n%s\n' % nodes )
 
-    def do_net( self, _line ):
+    def do_net( self, line ):
         "List network connections."
-        dumpNodeConnections( self.nodelist )
+        for switch in self.mn.switches:
+            output( switch.name, '<->' )
+            for intf in switch.intfs.values():
+                # Ugly, but pylint wants it
+                name = switch.connection.get( intf,
+                    ( None, 'Unknown ' ) )[ 1 ]
+                output( ' %s' % name )
+            output( '\n' )
 
     def do_sh( self, line ):
         "Run an external shell command"
@@ -128,7 +131,7 @@ class CLI( Cmd ):
         """Evaluate a Python expression.
            Node names may be used, e.g.: h1.cmd('ls')"""
         try:
-            result = eval( line, globals(), self.locals )
+            result = eval( line, globals(), self.nodemap )
             if not result:
                 return
             elif isinstance( result, str ):
@@ -140,11 +143,11 @@ class CLI( Cmd ):
 
     # pylint: enable-msg=W0703
 
-    def do_pingall( self, _line ):
+    def do_pingall( self, line ):
         "Ping between all hosts."
         self.mn.pingAll()
 
-    def do_pingpair( self, _line ):
+    def do_pingpair( self, line ):
         "Ping between first two hosts, useful for testing."
         self.mn.pingPair()
 
@@ -188,16 +191,16 @@ class CLI( Cmd ):
             error( 'invalid number of args: iperfudp bw src dst\n' +
                    'bw examples: 10M\n' )
 
-    def do_intfs( self, _line ):
+    def do_intfs( self, line ):
         "List interfaces."
         for node in self.nodelist:
             output( '%s: %s\n' %
-                ( node.name, ','.join( node.intfNames() ) ) )
+                ( node.name, ' '.join( sorted( node.intfs.values() ) ) ) )
 
-    def do_dump( self, _line ):
+    def do_dump( self, line ):
         "Dump node info."
         for node in self.nodelist:
-            output( '%s\n' % repr( node ) )
+            output( '%s\n' % node )
 
     def do_link( self, line ):
         "Bring link(s) between two nodes up or down."
@@ -226,7 +229,7 @@ class CLI( Cmd ):
         "Spawn gnome-terminal(s) for the given node(s)."
         self.do_xterm( line, term='gterm' )
 
-    def do_exit( self, _line ):
+    def do_exit( self, line ):
         "Exit"
         return 'exited by user command'
 
@@ -272,19 +275,16 @@ class CLI( Cmd ):
     def do_dpctl( self, line ):
         "Run dpctl command on all switches."
         args = line.split()
-        if len(args) < 1:
+        if len(args) == 0:
             error( 'usage: dpctl command [arg1] [arg2] ...\n' )
             return
+        if not self.mn.listenPort:
+            error( "can't run dpctl w/no passive listening port\n")
+            return
         for sw in self.mn.switches:
             output( '*** ' + sw.name + ' ' + ('-' * 72) + '\n' )
-            output( sw.dpctl( *args ) )
-
-    def do_time( self, line ):
-        "Measure time taken for any command in Mininet."
-        start = time.time()
-        self.onecmd(line)
-        elapsed = time.time() - start
-        self.stdout.write("*** Elapsed time: %0.6f secs\n" % elapsed)
+            output( sw.cmd( 'dpctl ' + ' '.join(args) +
+                            ' tcp:127.0.0.1:%i' % sw.listenPort ) )
 
     def default( self, line ):
         """Called on an input line when the command prefix is not recognized.
@@ -293,8 +293,6 @@ class CLI( Cmd ):
         corresponding IP addrs."""
 
         first, args, line = self.parseline( line )
-        if not args:
-            return
         if args and len(args) > 0 and args[ -1 ] == '\n':
             args = args[ :-1 ]
         rest = args.split( ' ' )
@@ -313,7 +311,7 @@ class CLI( Cmd ):
         else:
             error( '*** Unknown command: %s\n' % first )
 
-    # pylint: enable-msg=R0201
+    # pylint: enable-msg=W0613,R0201
 
     def waitForNode( self, node ):
         "Wait for a node to finish, and  print its output."
@@ -321,8 +319,8 @@ class CLI( Cmd ):
         nodePoller = poll()
         nodePoller.register( node.stdout )
         bothPoller = poll()
-        bothPoller.register( self.stdin, POLLIN )
-        bothPoller.register( node.stdout, POLLIN )
+        bothPoller.register( self.stdin )
+        bothPoller.register( node.stdout )
         if self.isatty():
             # Buffer by character, so that interactive
             # commands sort of work

mininet/link.py

@@ -1,390 +0,0 @@
-"""
-link.py: interface and link abstractions for mininet
-
-It seems useful to bundle functionality for interfaces into a single
-class.
-
-Also it seems useful to enable the possibility of multiple flavors of
-links, including:
-
-- simple veth pairs
-- tunneled links
-- patchable links (which can be disconnected and reconnected via a patchbay)
-- link simulators (e.g. wireless)
-
-Basic division of labor:
-
-  Nodes: know how to execute commands
-  Intfs: know how to configure themselves
-  Links: know how to connect nodes together
-
-Intf: basic interface object that can configure itself
-TCIntf: interface with bandwidth limiting and delay via tc
-
-Link: basic link class for creating veth pairs
-"""
-
-from mininet.log import info, error, debug
-from mininet.util import makeIntfPair
-from time import sleep
-import re
-
-class Intf( object ):
-
-    "Basic interface object that can configure itself."
-
-    def __init__( self, name, node=None, port=None, link=None, **params ):
-        """name: interface name (e.g. h1-eth0)
-           node: owning node (where this intf most likely lives)
-           link: parent link if we're part of a link
-           other arguments are passed to config()"""
-        self.node = node
-        self.name = name
-        self.link = link
-        self.mac, self.ip, self.prefixLen = None, None, None
-        # Add to node (and move ourselves if necessary )
-        node.addIntf( self, port=port )
-        # Save params for future reference
-        self.params = params
-        self.config( **params )
-
-    def cmd( self, *args, **kwargs ):
-        "Run a command in our owning node"
-        return self.node.cmd( *args, **kwargs )
-
-    def ifconfig( self, *args ):
-        "Configure ourselves using ifconfig"
-        return self.cmd( 'ifconfig', self.name, *args )
-
-    def setIP( self, ipstr, prefixLen=None ):
-        """Set our IP address"""
-        # This is a sign that we should perhaps rethink our prefix
-        # mechanism and/or the way we specify IP addresses
-        if '/' in ipstr:
-            self.ip, self.prefixLen = ipstr.split( '/' )
-            return self.ifconfig( ipstr, 'up' )
-        else:
-            self.ip, self.prefixLen = ipstr, prefixLen
-            return self.ifconfig( '%s/%s' % ( ipstr, prefixLen ) )
-
-    def setMAC( self, macstr ):
-        """Set the MAC address for an interface.
-           macstr: MAC address as string"""
-        self.mac = macstr
-        return ( self.ifconfig( 'down' ) +
-                 self.ifconfig( 'hw', 'ether', macstr ) +
-                 self.ifconfig( 'up' ) )
-
-    _ipMatchRegex = re.compile( r'\d+\.\d+\.\d+\.\d+' )
-    _macMatchRegex = re.compile( r'..:..:..:..:..:..' )
-
-    def updateIP( self ):
-        "Return updated IP address based on ifconfig"
-        ifconfig = self.ifconfig()
-        ips = self._ipMatchRegex.findall( ifconfig )
-        self.ip = ips[ 0 ] if ips else None
-        return self.ip
-
-    def updateMAC( self ):
-        "Return updated MAC address based on ifconfig"
-        ifconfig = self.ifconfig()
-        macs = self._macMatchRegex.findall( ifconfig )
-        self.mac = macs[ 0 ] if macs else None
-        return self.mac
-
-    def IP( self ):
-        "Return IP address"
-        return self.ip
-
-    def MAC( self ):
-        "Return MAC address"
-        return self.mac
-
-    def isUp( self, setUp=False ):
-        "Return whether interface is up"
-        if setUp:
-            self.ifconfig( 'up' )
-        return "UP" in self.ifconfig()
-
-    def rename( self, newname ):
-        "Rename interface"
-        self.ifconfig( 'down' )
-        result = self.cmd( 'ip link set', self.name, 'name', newname )
-        self.name = newname
-        self.ifconfig( 'up' )
-        return result
-
-    # The reason why we configure things in this way is so
-    # That the parameters can be listed and documented in
-    # the config method.
-    # Dealing with subclasses and superclasses is slightly
-    # annoying, but at least the information is there!
-
-    def setParam( self, results, method, **param ):
-        """Internal method: configure a *single* parameter
-           results: dict of results to update
-           method: config method name
-           param: arg=value (ignore if value=None)
-           value may also be list or dict"""
-        name, value = param.items()[ 0 ]
-        f = getattr( self, method, None )
-        if not f or value is None:
-            return
-        if type( value ) is list:
-            result = f( *value )
-        elif type( value ) is dict:
-            result = f( **value )
-        else:
-            result = f( value )
-        results[ name ] = result
-        return result
-
-    def config( self, mac=None, ip=None, ifconfig=None,
-                up=True, **_params ):
-        """Configure Node according to (optional) parameters:
-           mac: MAC address
-           ip: IP address
-           ifconfig: arbitrary interface configuration
-           Subclasses should override this method and call
-           the parent class's config(**params)"""
-        # If we were overriding this method, we would call
-        # the superclass config method here as follows:
-        # r = Parent.config( **params )
-        r = {}
-        self.setParam( r, 'setMAC', mac=mac )
-        self.setParam( r, 'setIP', ip=ip )
-        self.setParam( r, 'isUp', up=up )
-        self.setParam( r, 'ifconfig', ifconfig=ifconfig )
-        self.updateIP()
-        self.updateMAC()
-        return r
-
-    def delete( self ):
-        "Delete interface"
-        self.cmd( 'ip link del ' + self.name )
-        # Does it help to sleep to let things run?
-        sleep( 0.001 )
-
-    def __repr__( self ):
-        return '<%s %s>' % ( self.__class__.__name__, self.name )
-
-    def __str__( self ):
-        return self.name
-
-
-class TCIntf( Intf ):
-    """Interface customized by tc (traffic control) utility
-       Allows specification of bandwidth limits (various methods)
-       as well as delay, loss and max queue length"""
-
-    def bwCmds( self, bw=None, speedup=0, use_hfsc=False, use_tbf=False,
-                enable_ecn=False, enable_red=False ):
-        "Return tc commands to set bandwidth"
-
-        cmds, parent = [], ' root '
-
-        if bw and ( bw < 0 or bw > 1000 ):
-            error( 'Bandwidth', bw, 'is outside range 0..1000 Mbps\n' )
-
-        elif bw is not None:
-            # BL: this seems a bit brittle...
-            if ( speedup > 0 and
-                 self.node.name[0:1] == 's' ):
-                bw = speedup
-            # This may not be correct - we should look more closely
-            # at the semantics of burst (and cburst) to make sure we
-            # are specifying the correct sizes. For now I have used
-            # the same settings we had in the mininet-hifi code.
-            if use_hfsc:
-                cmds += [ '%s qdisc add dev %s root handle 1:0 hfsc default 1',
-                          '%s class add dev %s parent 1:0 classid 1:1 hfsc sc '
-                          + 'rate %fMbit ul rate %fMbit' % ( bw, bw ) ]
-            elif use_tbf:
-                latency_us = 10 * 1500 * 8 / bw
-                cmds += ['%s qdisc add dev %s root handle 1: tbf ' +
-                        'rate %fMbit burst 15000 latency %fus' %
-                         ( bw, latency_us ) ]
-            else:
-                cmds += [ '%s qdisc add dev %s root handle 1:0 htb default 1',
-                         '%s class add dev %s parent 1:0 classid 1:1 htb ' +
-                         'rate %fMbit burst 15k' % bw ]
-            parent = ' parent 1:1 '
-
-            # ECN or RED
-            if enable_ecn:
-                cmds += [ '%s qdisc add dev %s' + parent +
-                          'handle 10: red limit 1000000 ' +
-                          'min 30000 max 35000 avpkt 1500 ' +
-                          'burst 20 ' +
-                          'bandwidth %fmbit probability 1 ecn' % bw ]
-                parent = ' parent 10: '
-            elif enable_red:
-                cmds += [ '%s qdisc add dev %s' + parent +
-                          'handle 10: red limit 1000000 ' +
-                          'min 30000 max 35000 avpkt 1500 ' +
-                          'burst 20 ' +
-                          'bandwidth %fmbit probability 1' % bw ]
-                parent = ' parent 10: '
-        return cmds, parent
-
-    @staticmethod
-    def delayCmds( parent, delay=None, loss=None,
-                   max_queue_size=None ):
-        "Internal method: return tc commands for delay and loss"
-        cmds = []
-        if delay and delay < 0:
-            error( 'Negative delay', delay, '\n' )
-        elif loss and ( loss < 0 or loss > 100 ):
-            error( 'Bad loss percentage', loss, '%%\n' )
-        else:
-            # Delay/loss/max queue size
-            netemargs = '%s%s%s' % (
-                'delay %s ' % delay if delay is not None else '',
-                'loss %d ' % loss if loss is not None else '',
-                'limit %d' % max_queue_size if max_queue_size is not None
-                 else '' )
-            if netemargs:
-                cmds = [ '%s qdisc add dev %s ' + parent +
-                         ' handle 10: netem ' +
-                          netemargs ]
-        return cmds
-
-    def tc( self, cmd, tc='tc' ):
-        "Execute tc command for our interface"
-        c = cmd % (tc, self)  # Add in tc command and our name
-        debug(" *** executing command: %s\n" % c)
-        return self.cmd( c )
-
-    def config( self, bw=None, delay=None, loss=None, disable_gro=True,
-                speedup=0, use_hfsc=False, use_tbf=False, enable_ecn=False,
-                enable_red=False, max_queue_size=None, **params ):
-        "Configure the port and set its properties."
-
-        result = Intf.config( self, **params)
-
-        # Disable GRO
-        if disable_gro:
-            self.cmd( 'ethtool -K %s gro off' % self )
-
-        # Optimization: return if nothing else to configure
-        # Question: what happens if we want to reset things?
-        if ( bw is None and not delay and not loss
-             and max_queue_size is None ):
-            return
-
-        # Clear existing configuration
-        cmds = [ '%s qdisc del dev %s root' ]
-
-        # Bandwidth limits via various methods
-        bwcmds, parent = self.bwCmds( bw=bw, speedup=speedup,
-                                 use_hfsc=use_hfsc, use_tbf=use_tbf,
-                                 enable_ecn=enable_ecn,
-                                 enable_red=enable_red )
-        cmds += bwcmds
-
-        # Delay/loss/max_queue_size using netem
-        cmds += self.delayCmds( delay=delay, loss=loss,
-                                 max_queue_size=max_queue_size,
-                                 parent=parent )
-
-        # Ugly but functional: display configuration info
-        stuff = ( ( [ '%.2fMbit' % bw ] if bw is not None else [] ) +
-                  ( [ '%s delay' % delay ] if delay is not None else [] ) +
-                  ( ['%d%% loss' % loss ] if loss is not None else [] ) +
-                  ( [ 'ECN' ] if enable_ecn  else [ 'RED' ]
-                    if enable_red else [] ) )
-        info( '(' + ' '.join( stuff ) + ') ' )
-
-        # Execute all the commands in our node
-        debug("at map stage w/cmds: %s\n" % cmds)
-        tcoutputs = [ self.tc(cmd) for cmd in cmds ]
-        debug( "cmds:", cmds, '\n' )
-        debug( "outputs:", tcoutputs, '\n' )
-        result[ 'tcoutputs'] = tcoutputs
-
-        return result
-
-
-class Link( object ):
-
-    """A basic link is just a veth pair.
-       Other types of links could be tunnels, link emulators, etc.."""
-
-    def __init__( self, node1, node2, port1=None, port2=None,
-                  intfName1=None, intfName2=None,
-                  intf=Intf, cls1=None, cls2=None, params1=None,
-                  params2=None ):
-        """Create veth link to another node, making two new interfaces.
-           node1: first node
-           node2: second node
-           port1: node1 port number (optional)
-           port2: node2 port number (optional)
-           intf: default interface class/constructor
-           cls1, cls2: optional interface-specific constructors
-           intfName1: node1 interface name (optional)
-           intfName2: node2  interface name (optional)
-           params1: parameters for interface 1
-           params2: parameters for interface 2"""
-        # This is a bit awkward; it seems that having everything in
-        # params would be more orthogonal, but being able to specify
-        # in-line arguments is more convenient!
-        if port1 is None:
-            port1 = node1.newPort()
-        if port2 is None:
-            port2 = node2.newPort()
-        if not intfName1:
-            intfName1 = self.intfName( node1, port1 )
-        if not intfName2:
-            intfName2 = self.intfName( node2, port2 )
-
-        self.makeIntfPair( intfName1, intfName2 )
-
-        if not cls1:
-            cls1 = intf
-        if not cls2:
-            cls2 = intf
-        if not params1:
-            params1 = {}
-        if not params2:
-            params2 = {}
-
-        intf1 = cls1( name=intfName1, node=node1, port=port1,
-                      link=self, **params1  )
-        intf2 = cls2( name=intfName2, node=node2, port=port2,
-                      link=self, **params2 )
-
-        # All we are is dust in the wind, and our two interfaces
-        self.intf1, self.intf2 = intf1, intf2
-
-    @classmethod
-    def intfName( cls, node, n ):
-        "Construct a canonical interface name node-ethN for interface n."
-        return node.name + '-eth' + repr( n )
-
-    @classmethod
-    def makeIntfPair( cls, intf1, intf2 ):
-        """Create pair of interfaces
-           intf1: name of interface 1
-           intf2: name of interface 2
-           (override this class method [and possibly delete()]
-           to change link type)"""
-        makeIntfPair( intf1, intf2  )
-
-    def delete( self ):
-        "Delete this link"
-        self.intf1.delete()
-        self.intf2.delete()
-
-    def __str__( self ):
-        return '%s<->%s' % ( self.intf1, self.intf2 )
-
-class TCLink( Link ):
-    "Link with symmetric TC interfaces configured via opts"
-    def __init__( self, node1, node2, port1=None, port2=None,
-                  intfName1=None, intfName2=None, **params ):
-        Link.__init__( self, node1, node2, port1=port1, port2=port2,
-                       intfName1=intfName1, intfName2=intfName2,
-                       cls1=TCIntf,
-                       cls2=TCIntf,
-                       params1=params,
-                       params2=params)

mininet/net.py

@@ -1,6 +1,6 @@
 """
 
-    Mininet: A simple networking testbed for OpenFlow/SDN!
+    Mininet: A simple networking testbed for OpenFlow!
 
 author: Bob Lantz (rlantz@cs.stanford.edu)
 author: Brandon Heller (brandonh@stanford.edu)
@@ -91,227 +91,229 @@ import re
 import select
 import signal
 from time import sleep
+from subprocess import check_output
 
 from mininet.cli import CLI
 from mininet.log import info, error, debug, output
-from mininet.node import Host, OVSKernelSwitch, Controller
-from mininet.link import Link, Intf
-from mininet.util import quietRun, fixLimits, numCores
-from mininet.util import macColonHex, ipStr, ipParse, netParse, ipAdd
+from mininet.node import Host, UserSwitch, OVSKernelSwitch, Controller
+from mininet.node import ControllerParams
+from mininet.util import quietRun, fixLimits
+from mininet.util import createLink, macColonHex, ipStr, ipParse
 from mininet.term import cleanUpScreens, makeTerms
 
 class Mininet( object ):
     "Network emulation with hosts spawned in network namespaces."
 
     def __init__( self, topo=None, switch=OVSKernelSwitch, host=Host,
-                 controller=Controller, link=Link, intf=Intf,
-                 build=True, xterms=False, cleanup=False, ipBase='10.0.0.0/8',
+                 controller=Controller,
+                 cparams=ControllerParams( '10.0.0.0', 8 ),
+                 build=True, xterms=False, cleanup=False,
                  inNamespace=False,
-                 autoSetMacs=False, autoStaticArp=False, autoPinCpus=False,
-                 listenPort=None ):
+                 autoSetMacs=False, autoStaticArp=False, listenPort=None ):
         """Create Mininet object.
            topo: Topo (topology) object or None
-           switch: default Switch class
-           host: default Host class/constructor
-           controller: default Controller class/constructor
-           link: default Link class/constructor
-           intf: default Intf class/constructor
-           ipBase: base IP address for hosts,
+           switch: Switch class
+           host: Host class
+           controller: Controller class
+           cparams: ControllerParams object
            build: build now from topo?
            xterms: if build now, spawn xterms?
            cleanup: if build now, cleanup before creating?
            inNamespace: spawn switches and controller in net namespaces?
-           autoSetMacs: set MAC addrs automatically like IP addresses?
+           autoSetMacs: set MAC addrs from topo?
            autoStaticArp: set all-pairs static MAC addrs?
-           autoPinCpus: pin hosts to (real) cores (requires CPULimitedHost)?
            listenPort: base listening port to open; will be incremented for
                each additional switch in the net if inNamespace=False"""
-        self.topo = topo
         self.switch = switch
         self.host = host
         self.controller = controller
-        self.link = link
-        self.intf = intf
-        self.ipBase = ipBase
-        self.ipBaseNum, self.prefixLen = netParse( self.ipBase )
-        self.nextIP = 1  # start for address allocation
+        self.cparams = cparams
+        self.topo = topo
         self.inNamespace = inNamespace
         self.xterms = xterms
         self.cleanup = cleanup
         self.autoSetMacs = autoSetMacs
         self.autoStaticArp = autoStaticArp
-        self.autoPinCpus = autoPinCpus
-        self.numCores = numCores()
-        self.nextCore = 0  # next core for pinning hosts to CPUs
         self.listenPort = listenPort
 
         self.hosts = []
         self.switches = []
         self.controllers = []
-
         self.nameToNode = {}  # name to Node (Host/Switch) objects
-
+        self.idToNode = {}  # dpid to Node (Host/Switch) objects
+        self.dps = 0  # number of created kernel datapaths
         self.terms = []  # list of spawned xterm processes
 
-        Mininet.init()  # Initialize Mininet if necessary
+        init()
+        switch.setup()
 
         self.built = False
         if topo and build:
             self.build()
 
-    def addHost( self, name, cls=None, **params ):
+    def addHost( self, name, mac=None, ip=None ):
         """Add host.
            name: name of host to add
-           cls: custom host class/constructor (optional)
-           params: parameters for host
+           mac: default MAC address for intf 0
+           ip: default IP address for intf 0
            returns: added host"""
-        # Default IP and MAC addresses
-        defaults = { 'ip': ipAdd( self.nextIP,
-                                  ipBaseNum=self.ipBaseNum,
-                                  prefixLen=self.prefixLen ) +
-                                  '/%s' % self.prefixLen }
-        if self.autoSetMacs:
-            defaults[ 'mac'] = macColonHex( self.nextIP )
-        if self.autoPinCpus:
-            defaults[ 'cores' ] = self.nextCore
-            self.nextCore = ( self.nextCore + 1 ) % self.numCores
-        self.nextIP += 1
-        defaults.update( params )
-        if not cls:
-            cls = self.host
-        h = cls( name, **defaults )
-        self.hosts.append( h )
-        self.nameToNode[ name ] = h
-        return h
+        host = self.host( name, defaultMAC=mac, defaultIP=ip )
+        self.hosts.append( host )
+        self.nameToNode[ name ] = host
+        return host
 
-    def addSwitch( self, name, cls=None, **params ):
+    def addSwitch( self, name, mac=None, ip=None ):
         """Add switch.
            name: name of switch to add
-           cls: custom switch class/constructor (optional)
+           mac: default MAC address for kernel/OVS switch intf 0
            returns: added switch
-           side effect: increments listenPort ivar ."""
-        defaults = { 'listenPort': self.listenPort,
-                     'inNamespace': self.inNamespace }
-        defaults.update( params )
-        if not cls:
-            cls = self.switch
-        sw = cls( name, **defaults )
+           side effect: increments the listenPort member variable."""
+        if self.switch == UserSwitch:
+            sw = self.switch( name, listenPort=self.listenPort,
+                defaultMAC=mac, defaultIP=ip, inNamespace=self.inNamespace )
+        else:
+            sw = self.switch( name, listenPort=self.listenPort,
+                defaultMAC=mac, defaultIP=ip, dp=self.dps,
+                inNamespace=self.inNamespace )
         if not self.inNamespace and self.listenPort:
             self.listenPort += 1
+        self.dps += 1
         self.switches.append( sw )
         self.nameToNode[ name ] = sw
         return sw
 
-    def addController( self, name='c0', controller=None, **params ):
+    def addController( self, name='c0', controller=None, **kwargs ):
         """Add controller.
            controller: Controller class"""
         if not controller:
             controller = self.controller
-        controller_new = controller( name, **params )
+        controller_new = controller( name, **kwargs )
         if controller_new:  # allow controller-less setups
             self.controllers.append( controller_new )
             self.nameToNode[ name ] = controller_new
         return controller_new
 
-    # BL: is this better than just using nameToNode[] ?
-    # Should it have a better name?
-    def getNodeByName( self, *args ):
-        "Return node(s) with given name(s)"
-        if len( args ) == 1:
-            return self.nameToNode[ args[ 0 ] ]
-        return [ self.nameToNode[ n ] for n in args ]
+    # Control network support:
+    #
+    # Create an explicit control network. Currently this is only
+    # used by the user datapath configuration.
+    #
+    # Notes:
+    #
+    # 1. If the controller and switches are in the same (e.g. root)
+    #    namespace, they can just use the loopback connection.
+    #
+    # 2. If we can get unix domain sockets to work, we can use them
+    #    instead of an explicit control network.
+    #
+    # 3. Instead of routing, we could bridge or use 'in-band' control.
+    #
+    # 4. Even if we dispense with this in general, it could still be
+    #    useful for people who wish to simulate a separate control
+    #    network (since real networks may need one!)
 
-    def get( self, *args ):
-        "Convenience alias for getNodeByName"
-        return self.getNodeByName( *args )
+    def configureControlNetwork( self ):
+        "Configure control network."
+        self.configureRoutedControlNetwork()
 
-    def addLink( self, node1, node2, port1=None, port2=None,
-                 cls=None, **params ):
-        """"Add a link from node1 to node2
-            node1: source node
-            node2: dest node
-            port1: source port
-            port2: dest port
-            returns: link object"""
-        defaults = { 'port1': port1,
-                     'port2': port2,
-                     'intf': self.intf }
-        defaults.update( params )
-        if not cls:
-            cls = self.link
-        return cls( node1, node2, **defaults )
+    # We still need to figure out the right way to pass
+    # in the control network location.
+
+    def configureRoutedControlNetwork( self, ip='192.168.123.1',
+        prefixLen=16 ):
+        """Configure a routed control network on controller and switches.
+           For use with the user datapath only right now.
+           """
+        controller = self.controllers[ 0 ]
+        info( controller.name + ' <->' )
+        cip = ip
+        snum = ipParse( ip )
+        for switch in self.switches:
+            info( ' ' + switch.name )
+            sintf, cintf = createLink( switch, controller )
+            snum += 1
+            while snum & 0xff in [ 0, 255 ]:
+                snum += 1
+            sip = ipStr( snum )
+            controller.setIP( cintf, cip, prefixLen )
+            switch.setIP( sintf, sip, prefixLen )
+            controller.setHostRoute( sip, cintf )
+            switch.setHostRoute( cip, sintf )
+        info( '\n' )
+        info( '*** Testing control network\n' )
+        while not controller.intfIsUp( cintf ):
+            info( '*** Waiting for', cintf, 'to come up\n' )
+            sleep( 1 )
+        for switch in self.switches:
+            while not switch.intfIsUp( sintf ):
+                info( '*** Waiting for', sintf, 'to come up\n' )
+                sleep( 1 )
+            if self.ping( hosts=[ switch, controller ] ) != 0:
+                error( '*** Error: control network test failed\n' )
+                exit( 1 )
+        info( '\n' )
 
     def configHosts( self ):
         "Configure a set of hosts."
+        # params were: hosts, ips
         for host in self.hosts:
-            info( host.name + ' ' )
-            intf = host.defaultIntf()
-            if intf:
-                host.configDefault( defaultRoute=intf )
-            else:
-                # Don't configure nonexistent intf
-                host.configDefault( ip=None, mac=None )
+            hintf = host.intfs[ 0 ]
+            host.setIP( hintf, host.defaultIP, self.cparams.prefixLen )
+            host.setDefaultRoute( hintf )
             # You're low priority, dude!
-            # BL: do we want to do this here or not?
-            # May not make sense if we have CPU lmiting...
-            # quietRun( 'renice +18 -p ' + repr( host.pid ) )
-            # This may not be the right place to do this, but
-            # it needs to be done somewhere.
-            host.cmd( 'ifconfig lo up' )
+            quietRun( 'renice +18 -p ' + repr( host.pid ) )
+            info( host.name + ' ' )
         info( '\n' )
 
-    def buildFromTopo( self, topo=None ):
+    def buildFromTopo( self, topo ):
         """Build mininet from a topology object
            At the end of this function, everything should be connected
            and up."""
 
+        def addNode( prefix, addMethod, nodeId ):
+            "Add a host or a switch."
+            name = prefix + topo.name( nodeId )
+            mac = macColonHex( nodeId ) if self.setMacs else None
+            ip = topo.ip( nodeId )
+            node = addMethod( name, mac=mac, ip=ip )
+            self.idToNode[ nodeId ] = node
+            info( name + ' ' )
+
         # Possibly we should clean up here and/or validate
         # the topo
         if self.cleanup:
             pass
 
+        info( '*** Adding controller\n' )
+        self.addController( 'c0' )
         info( '*** Creating network\n' )
-
-        if not self.controllers:
-            # Add a default controller
-            info( '*** Adding controller\n' )
-            self.addController( 'c0' )
-
         info( '*** Adding hosts:\n' )
-        for hostName in topo.hosts():
-            self.addHost( hostName, **topo.nodeInfo( hostName ) )
-            info( hostName + ' ' )
-
+        for hostId in sorted( topo.hosts() ):
+            addNode( 'h', self.addHost, hostId )
         info( '\n*** Adding switches:\n' )
-        for switchName in topo.switches():
-            self.addSwitch( switchName, **topo.nodeInfo( switchName) )
-            info( switchName + ' ' )
-
+        for switchId in sorted( topo.switches() ):
+            addNode( 's', self.addSwitch, switchId )
         info( '\n*** Adding links:\n' )
-        for srcName, dstName in topo.links(sort=True):
-            src, dst = self.nameToNode[ srcName ], self.nameToNode[ dstName ]
-            params = topo.linkInfo( srcName, dstName )
-            srcPort, dstPort = topo.port( srcName, dstName )
-            self.addLink( src, dst, srcPort, dstPort, **params )
+        for srcId, dstId in sorted( topo.edges() ):
+            src, dst = self.idToNode[ srcId ], self.idToNode[ dstId ]
+            srcPort, dstPort = topo.port( srcId, dstId )
+            createLink( src, dst, srcPort, dstPort )
             info( '(%s, %s) ' % ( src.name, dst.name ) )
-
         info( '\n' )
 
-    def configureControlNetwork( self ):
-        "Control net config hook: override in subclass"
-        raise Exception( 'configureControlNetwork: '
-               'should be overriden in subclass', self )
-
     def build( self ):
         "Build mininet."
         if self.topo:
             self.buildFromTopo( self.topo )
-        if ( self.inNamespace ):
+        if self.inNamespace:
+            info( '*** Configuring control network\n' )
             self.configureControlNetwork()
         info( '*** Configuring hosts\n' )
         self.configHosts()
         if self.xterms:
             self.startTerms()
+        if self.autoSetMacs:
+            self.setMacs()
         if self.autoStaticArp:
             self.staticArp()
         self.built = True
@@ -326,10 +328,17 @@ class Mininet( object ):
 
     def stopXterms( self ):
         "Kill each xterm."
+        # Kill xterms
         for term in self.terms:
             os.kill( term.pid, signal.SIGKILL )
         cleanUpScreens()
 
+    def setMacs( self ):
+        """Set MAC addrs to correspond to default MACs on hosts.
+           Assume that the host only has one interface."""
+        for host in self.hosts:
+            host.setMAC( host.intfs[ 0 ], host.defaultMAC )
+
     def staticArp( self ):
         "Add all-pairs ARP entries to remove the need to handle broadcast."
         for src in self.hosts:
@@ -357,19 +366,18 @@ class Mininet( object ):
             self.stopXterms()
         info( '*** Stopping %i hosts\n' % len( self.hosts ) )
         for host in self.hosts:
-            info( host.name + ' ' )
+            info( '%s ' % host.name )
             host.terminate()
         info( '\n' )
         info( '*** Stopping %i switches\n' % len( self.switches ) )
         for switch in self.switches:
-            info( switch.name + ' ' )
+            info( switch.name )
             switch.stop()
         info( '\n' )
         info( '*** Stopping %i controllers\n' % len( self.controllers ) )
         for controller in self.controllers:
-            info( controller.name + ' ' )
             controller.stop()
-        info( '\n*** Done\n' )
+        info( '*** Done\n' )
 
     def run( self, test, *args, **kwargs ):
         "Perform a complete start/test/stop cycle."
@@ -403,9 +411,6 @@ class Mininet( object ):
             if not ready and timeoutms >= 0:
                 yield None, None
 
-    # XXX These test methods should be moved out of this class.
-    # Probably we should create a tests.py for them
-
     @staticmethod
     def _parsePing( pingOutput ):
         "Parse ping output and return packets sent, received."
@@ -477,8 +482,6 @@ class Mininet( object ):
             error( 'could not parse iperf output: ' + iperfOutput )
             return ''
 
-    # XXX This should be cleaned up
-
     def iperf( self, hosts=None, l4Type='TCP', udpBw='10M' ):
         """Run iperf between two hosts.
            hosts: list of hosts; if None, uses opposite hosts
@@ -506,11 +509,10 @@ class Mininet( object ):
         servout = ''
         while server.lastPid is None:
             servout += server.monitor()
-        if l4Type == 'TCP':
-            while 'Connected' not in client.cmd(
-                'sh -c "echo A | telnet -e A %s 5001"' % server.IP()):
-                output('waiting for iperf to start up...')
-                sleep(.5)
+        while 'Connected' not in client.cmd(
+            'sh -c "echo A | telnet -e A %s 5001"' % server.IP()):
+            output('waiting for iperf to start up')
+            sleep(.5)
         cliout = client.cmd( iperfArgs + '-t 5 -c ' + server.IP() + ' ' +
                            bwArgs )
         debug( 'Client output: %s\n' % cliout )
@@ -523,8 +525,6 @@ class Mininet( object ):
         output( '*** Results: %s\n' % result )
         return result
 
-    # BL: I think this can be rewritten now that we have
-    # a real link class.
     def configLinkStatus( self, src, dst, status ):
         """Change status of src <-> dst links.
            src: node name
@@ -535,18 +535,15 @@ class Mininet( object ):
         elif dst not in self.nameToNode:
             error( 'dst not in network: %s\n' % dst )
         else:
-            if type( src ) is str:
-                src = self.nameToNode[ src ]
-            if type( dst ) is str:
-                dst = self.nameToNode[ dst ]
-            connections = src.connectionsTo( dst )
+            srcNode, dstNode = self.nameToNode[ src ], self.nameToNode[ dst ]
+            connections = srcNode.connectionsTo( dstNode )
             if len( connections ) == 0:
                 error( 'src and dst not connected: %s %s\n' % ( src, dst) )
             for srcIntf, dstIntf in connections:
-                result = srcIntf.ifconfig( status )
+                result = srcNode.cmd( 'ifconfig', srcIntf, status )
                 if result:
                     error( 'link src status change failed: %s\n' % result )
-                result = dstIntf.ifconfig( status )
+                result = dstNode.cmd( 'ifconfig', dstIntf, status )
                 if result:
                     error( 'link dst status change failed: %s\n' % result )
 
@@ -557,89 +554,25 @@ class Mininet( object ):
         self.stop()
         return result
 
-    inited = False
 
-    @classmethod
-    def init( cls ):
-        "Initialize Mininet"
-        if cls.inited:
-            return
-        if os.getuid() != 0:
-            # Note: this script must be run as root
-            # Probably we should only sudo when we need
-            # to as per Big Switch's patch
-            print "*** Mininet must run as root."
-            exit( 1 )
-        fixLimits()
-        cls.inited = True
+# pylint thinks inited is unused
+# pylint: disable-msg=W0612
 
+def init():
+    "Initialize Mininet."
+    if init.inited:
+        return
+    # Make sure we can sudo without a password
+    try:
+        check_output( [ 'sudo', '-n', 'echo' ] )
+    except:
+        raise Exception( "Could not run sudo -n echo - check /etc/sudoers" )
+    # Make sure mnexec is in our path
+    if not quietRun( 'which mnexec' ):
+        raise Exception( "Could not find mnexec - check $PATH" )
+    fixLimits()
+    init.inited = True
 
-class MininetWithControlNet( Mininet ):
+init.inited = False
 
-    """Control network support:
-
-       Create an explicit control network. Currently this is only
-       used/usable with the user datapath.
-
-       Notes:
-
-       1. If the controller and switches are in the same (e.g. root)
-          namespace, they can just use the loopback connection.
-
-       2. If we can get unix domain sockets to work, we can use them
-          instead of an explicit control network.
-
-       3. Instead of routing, we could bridge or use 'in-band' control.
-
-       4. Even if we dispense with this in general, it could still be
-          useful for people who wish to simulate a separate control
-          network (since real networks may need one!)
-
-       5. Basically nobody ever used this code, so it has been moved
-          into its own class.
-
-       6. Ultimately we may wish to extend this to allow us to create a
-          control network which every node's control interface is
-          attached to."""
-
-    def configureControlNetwork( self ):
-        "Configure control network."
-        self.configureRoutedControlNetwork()
-
-    # We still need to figure out the right way to pass
-    # in the control network location.
-
-    def configureRoutedControlNetwork( self, ip='192.168.123.1',
-        prefixLen=16 ):
-        """Configure a routed control network on controller and switches.
-           For use with the user datapath only right now."""
-        controller = self.controllers[ 0 ]
-        info( controller.name + ' <->' )
-        cip = ip
-        snum = ipParse( ip )
-        for switch in self.switches:
-            info( ' ' + switch.name )
-            link = self.link( switch, controller, port1=0 )
-            sintf, cintf = link.intf1, link.intf2
-            switch.controlIntf = sintf
-            snum += 1
-            while snum & 0xff in [ 0, 255 ]:
-                snum += 1
-            sip = ipStr( snum )
-            cintf.setIP( cip, prefixLen )
-            sintf.setIP( sip, prefixLen )
-            controller.setHostRoute( sip, cintf )
-            switch.setHostRoute( cip, sintf )
-        info( '\n' )
-        info( '*** Testing control network\n' )
-        while not cintf.isUp():
-            info( '*** Waiting for', cintf, 'to come up\n' )
-            sleep( 1 )
-        for switch in self.switches:
-            while not sintf.isUp():
-                info( '*** Waiting for', sintf, 'to come up\n' )
-                sleep( 1 )
-            if self.ping( hosts=[ switch, controller ] ) != 0:
-                error( '*** Error: control network test failed\n' )
-                exit( 1 )
-        info( '\n' )
+# pylint: enable-msg=W0612

mininet/test/test_nets.py

@@ -5,14 +5,16 @@
 
 import unittest
 
-from mininet.net import Mininet
-from mininet.node import Host, Controller
+from mininet.net import init, Mininet
+from mininet.node import Host, Controller, ControllerParams
+# from mininet.node import KernelSwitch
 from mininet.node import UserSwitch, OVSKernelSwitch
 from mininet.topo import SingleSwitchTopo, LinearTopo
 from mininet.log import setLogLevel
 
 SWITCHES = { 'user': UserSwitch,
              'ovsk': OVSKernelSwitch,
+            # 'kernel': KernelSwitch
 }
 
 
@@ -21,15 +23,21 @@ class testSingleSwitch( unittest.TestCase ):
 
     def testMinimal( self ):
         "Ping test with both datapaths on minimal topology"
+        init()
         for switch in SWITCHES.values():
-            mn = Mininet( SingleSwitchTopo(), switch, Host, Controller )
+            controllerParams = ControllerParams( '10.0.0.0', 8 )
+            mn = Mininet( SingleSwitchTopo(), switch, Host, Controller,
+                         controllerParams )
             dropped = mn.run( mn.ping )
             self.assertEqual( dropped, 0 )
 
     def testSingle5( self ):
         "Ping test with both datapaths on 5-host single-switch topology"
+        init()
         for switch in SWITCHES.values():
-            mn = Mininet( SingleSwitchTopo( k=5 ), switch, Host, Controller )
+            controllerParams = ControllerParams( '10.0.0.0', 8 )
+            mn = Mininet( SingleSwitchTopo( k=5 ), switch, Host, Controller,
+                         controllerParams )
             dropped = mn.run( mn.ping )
             self.assertEqual( dropped, 0 )
 
@@ -39,12 +47,15 @@ class testLinear( unittest.TestCase ):
 
     def testLinear5( self ):
         "Ping test with both datapaths on a 5-switch topology"
+        init()
         for switch in SWITCHES.values():
-            mn = Mininet( LinearTopo( k=5 ), switch, Host, Controller )
+            controllerParams = ControllerParams( '10.0.0.0', 8 )
+            mn = Mininet( LinearTopo( k=5 ), switch, Host, Controller,
+                         controllerParams )
             dropped = mn.run( mn.ping )
             self.assertEqual( dropped, 0 )
 
 
 if __name__ == '__main__':
-    setLogLevel( 'warning' )
+    setLogLevel('warning')
     unittest.main()

mininet/topo.py

@@ -16,125 +16,258 @@ setup for testing, and can even be emulated with the Mininet package.
 # from networkx.classes.graph import Graph
 
 from networkx import Graph
-from mininet.util import irange, natural, naturalSeq
+from mininet.node import SWITCH_PORT_BASE
+
+class NodeID(object):
+    '''Topo node identifier.'''
+
+    def __init__(self, dpid = None):
+        '''Init.
+
+        @param dpid dpid
+        '''
+        # DPID-compatible hashable identifier: opaque 64-bit unsigned int
+        self.dpid = dpid
+
+    def __str__(self):
+        '''String conversion.
+
+        @return str dpid as string
+        '''
+        return str(self.dpid)
+
+    def name_str(self):
+        '''Name conversion.
+
+        @return name name as string
+        '''
+        return str(self.dpid)
+
+    def ip_str(self):
+        '''Name conversion.
+
+        @return ip ip as string
+        '''
+        hi = (self.dpid & 0xff0000) >> 16
+        mid = (self.dpid & 0xff00) >> 8
+        lo = self.dpid & 0xff
+        return "10.%i.%i.%i" % (hi, mid, lo)
+
+
+class Node(object):
+    '''Node-specific vertex metadata for a Topo object.'''
+
+    def __init__(self, connected = False, admin_on = True,
+                 power_on = True, fault = False, is_switch = True):
+        '''Init.
+
+        @param connected actively connected to controller
+        @param admin_on administratively on or off
+        @param power_on powered on or off
+        @param fault fault seen on node
+        @param is_switch switch or host
+        '''
+        self.connected = connected
+        self.admin_on = admin_on
+        self.power_on = power_on
+        self.fault = fault
+        self.is_switch = is_switch
+
+
+class Edge(object):
+    '''Edge-specific metadata for a StructuredTopo graph.'''
+
+    def __init__(self, admin_on = True, power_on = True, fault = False):
+        '''Init.
+
+        @param admin_on administratively on or off; defaults to True
+        @param power_on powered on or off; defaults to True
+        @param fault fault seen on edge; defaults to False
+        '''
+        self.admin_on = admin_on
+        self.power_on = power_on
+        self.fault = fault
+
 
 class Topo(object):
-    "Data center network representation for structured multi-trees."
+    '''Data center network representation for structured multi-trees.'''
 
-    def __init__(self, hopts=None, sopts=None, lopts=None):
-        """Topo object:
-           hinfo: default host options
-           sopts: default switch options
-           lopts: default link options"""
-        self.g = Graph()
-        self.node_info = {}
-        self.link_info = {}  # (src, dst) tuples hash to EdgeInfo objects
-        self.hopts = {} if hopts is None else hopts
-        self.sopts = {} if sopts is None else sopts
-        self.lopts = {} if lopts is None else lopts
-        self.ports = {}  # ports[src][dst] is port on src that connects to dst
+    def __init__(self):
+        '''Create Topo object.
 
-    def add_node(self, name, **opts):
-        """Add Node to graph.
-           name: name
-           opts: node options
-           returns: node name"""
-        self.g.add_node(name)
-        self.node_info[name] = opts
-        return name
-
-    def add_host(self, name, **opts):
-        """Convenience method: Add host to graph.
-           name: host name
-           opts: host options
-           returns: host name"""
-        if not opts and self.hopts:
-            opts = self.hopts
-        return self.add_node(name, **opts)
-
-    def add_switch(self, name, **opts):
-        """Convenience method: Add switch to graph.
-           name: switch name
-           opts: switch options
-           returns: switch name"""
-        if not opts and self.sopts:
-            opts = self.sopts
-        result = self.add_node(name, is_switch=True, **opts)
-        return result
-
-    def add_link(self, node1, node2, port1=None, port2=None,
-                 **opts):
-        """node1, node2: nodes to link together
-           port1, port2: ports (optional)
-           opts: link options (optional)
-           returns: link info key"""
-        if not opts and self.lopts:
-            opts = self.lopts
-        self.add_port(node1, node2, port1, port2)
-        key = tuple(self.sorted([node1, node2]))
-        self.link_info[key] = opts
-        self.g.add_edge(*key)
-        return key
-
-    def add_port(self, src, dst, sport=None, dport=None):
-        '''Generate port mapping for new edge.
-        @param src source switch name
-        @param dst destination switch name
         '''
-        self.ports.setdefault(src, {})
-        self.ports.setdefault(dst, {})
-        # New port: number of outlinks + base
-        src_base = 1 if self.is_switch(src) else 0
-        dst_base = 1 if self.is_switch(dst) else 0
-        if sport is None:
-            sport = len(self.ports[src]) + src_base
-        if dport is None:
-            dport = len(self.ports[dst]) + dst_base
-        self.ports[src][dst] = sport
-        self.ports[dst][src] = dport
+        self.g = Graph()
+        self.node_info = {}  # dpids hash to Node objects
+        self.edge_info = {}  # (src_dpid, dst_dpid) tuples hash to Edge objects
+        self.ports = {}  # ports[src][dst] is port on src that connects to dst
+        self.id_gen = NodeID  # class used to generate dpid
 
-    def nodes(self, sort=True):
-        "Return nodes in graph"
-        if sort:
-            return self.sorted( self.g.nodes() )
+    def add_node(self, dpid, node):
+        '''Add Node to graph.
+
+        @param dpid dpid
+        @param node Node object
+        '''
+        self.g.add_node(dpid)
+        self.node_info[dpid] = node
+
+    def add_edge(self, src, dst, edge = None):
+        '''Add edge (Node, Node) to graph.
+
+        @param src src dpid
+        @param dst dst dpid
+        @param edge Edge object
+        '''
+        src, dst = tuple(sorted([src, dst]))
+        self.g.add_edge(src, dst)
+        if not edge:
+            edge = Edge()
+        self.edge_info[(src, dst)] = edge
+        self.add_port(src, dst)
+
+    def add_port(self, src, dst):
+        '''Generate port mapping for new edge.
+
+        @param src source switch DPID
+        @param dst destination switch DPID
+        '''
+        src_base = SWITCH_PORT_BASE if self.is_switch(src) else 0
+        dst_base = SWITCH_PORT_BASE if self.is_switch(dst) else 0
+        if src not in self.ports:
+            self.ports[src] = {}
+        if dst not in self.ports[src]:
+            # num outlinks
+            self.ports[src][dst] = len(self.ports[src]) + src_base
+        if dst not in self.ports:
+            self.ports[dst] = {}
+        if src not in self.ports[dst]:
+            # num outlinks
+            self.ports[dst][src] = len(self.ports[dst]) + dst_base
+
+    def node_enabled(self, dpid):
+        '''Is node connected, admin on, powered on, and fault-free?
+
+        @param dpid dpid
+
+        @return bool node is enabled
+        '''
+        ni = self.node_info[dpid]
+        return ni.connected and ni.admin_on and ni.power_on and not ni.fault
+
+    def nodes_enabled(self, dpids, enabled = True):
+        '''Return subset of enabled nodes
+
+        @param dpids list of dpids
+        @param enabled only return enabled nodes?
+
+        @return dpids filtered list of dpids
+        '''
+        if enabled:
+            return [n for n in dpids if self.node_enabled(n)]
         else:
-            return self.g.nodes()
+            return dpids
+
+    def nodes(self, enabled = True):
+        '''Return graph nodes.
+
+        @param enabled only return enabled nodes?
+
+        @return dpids list of dpids
+        '''
+        return self.nodes_enabled(self.g.nodes(), enabled)
+
+    def nodes_str(self, dpids):
+        '''Return string of custom-encoded nodes.
+
+        @param dpids list of dpids
+
+        @return str string
+        '''
+        return [str(self.id_gen(dpid = dpid)) for dpid in dpids]
 
     def is_switch(self, n):
         '''Returns true if node is a switch.'''
-        info = self.node_info[n]
-        return info and info.get('is_switch', False)
+        return self.node_info[n].is_switch
 
-    def switches(self, sort=True):
+    def switches(self, enabled = True):
         '''Return switches.
-        sort: sort switches alphabetically
+
+        @param enabled only return enabled nodes?
+
         @return dpids list of dpids
         '''
-        return [n for n in self.nodes(sort) if self.is_switch(n)]
+        nodes = [n for n in self.g.nodes() if self.is_switch(n)]
+        return self.nodes_enabled(nodes, enabled)
 
-    def hosts(self, sort=True):
+    def hosts(self, enabled = True):
         '''Return hosts.
-        sort: sort hosts alphabetically
+
+        @param enabled only return enabled nodes?
+
         @return dpids list of dpids
         '''
-        return [n for n in self.nodes(sort) if not self.is_switch(n)]
 
-    def links(self, sort=True):
-        '''Return links.
-        sort: sort links alphabetically
-        @return links list of name pairs
+        def is_host(n):
+            '''Returns true if node is a host.'''
+            return not self.node_info[n].is_switch
+
+        nodes = [n for n in self.g.nodes() if is_host(n)]
+        return self.nodes_enabled(nodes, enabled)
+
+    def edge_enabled(self, edge):
+        '''Is edge admin on, powered on, and fault-free?
+
+        @param edge (src, dst) dpid tuple
+
+        @return bool edge is enabled
         '''
-        if not sort:
-            return self.g.edges()
+        src, dst = edge
+        src, dst = tuple(sorted([src, dst]))
+        ei = self.edge_info[tuple(sorted([src, dst]))]
+        return ei.admin_on and ei.power_on and not ei.fault
+
+    def edges_enabled(self, edges, enabled = True):
+        '''Return subset of enabled edges
+
+        @param edges list of edges
+        @param enabled only return enabled edges?
+
+        @return edges filtered list of edges
+        '''
+        if enabled:
+            return [e for e in edges if self.edge_enabled(e)]
         else:
-            links = [tuple(self.sorted(e)) for e in self.g.edges()]
-            return sorted( links, key=naturalSeq )
+            return edges
+
+    def edges(self, enabled = True):
+        '''Return edges.
+
+        @param enabled only return enabled edges?
+
+        @return edges list of dpid pairs
+        '''
+        return self.edges_enabled(self.g.edges(), enabled)
+
+    def edges_str(self, dpid_pairs):
+        '''Return string of custom-encoded node pairs.
+
+        @param dpid_pairs list of dpid pairs (src, dst)
+
+        @return str string
+        '''
+        edges = []
+        for pair in dpid_pairs:
+            src, dst = pair
+            src = str(self.id_gen(dpid = src))
+            dst = str(self.id_gen(dpid = dst))
+            edges.append((src, dst))
+        return edges
 
     def port(self, src, dst):
         '''Get port number.
 
-        @param src source switch name
-        @param dst destination switch name
+        @param src source switch DPID
+        @param dst destination switch DPID
         @return tuple (src_port, dst_port):
             src_port: port on source switch leading to the destination switch
             dst_port: port on destination switch leading to the source switch
@@ -143,88 +276,130 @@ class Topo(object):
             assert dst in self.ports and src in self.ports[dst]
             return (self.ports[src][dst], self.ports[dst][src])
 
-    def linkInfo( self, src, dst ):
-        "Return link metadata"
-        src, dst = self.sorted([src, dst])
-        return self.link_info[(src, dst)]
+    def enable_edges(self):
+        '''Enable all edges in the network graph.
 
-    def setlinkInfo( self, src, dst, info ):
-        "Set link metadata"
-        src, dst = self.sorted([src, dst])
-        self.link_info[(src, dst)] = info
+        Set admin on, power on, and fault off.
+        '''
+        for e in self.g.edges():
+            src, dst = e
+            ei = self.edge_info[tuple(sorted([src, dst]))]
+            ei.admin_on = True
+            ei.power_on = True
+            ei.fault = False
 
-    def nodeInfo( self, name ):
-        "Return metadata (dict) for node"
-        info = self.node_info[ name ]
-        return info if info is not None else {}
+    def enable_nodes(self):
+        '''Enable all nodes in the network graph.
 
-    def setNodeInfo( self, name, info ):
-        "Set metadata (dict) for node"
-        self.node_info[ name ] = info
+        Set connected on, admin on, power on, and fault off.
+        '''
+        for node in self.g.nodes():
+            ni = self.node_info[node]
+            ni.connected = True
+            ni.admin_on = True
+            ni.power_on = True
+            ni.fault = False
+
+    def enable_all(self):
+        '''Enable all nodes and edges in the network graph.'''
+        self.enable_nodes()
+        self.enable_edges()
+
+    def name(self, dpid):
+        '''Get string name of node ID.
+
+        @param dpid DPID of host or switch
+        @return name_str string name with no dashes
+        '''
+        return self.id_gen(dpid = dpid).name_str()
+
+    def ip(self, dpid):
+        '''Get IP dotted-decimal string of node ID.
+
+        @param dpid DPID of host or switch
+        @return ip_str
+        '''
+        return self.id_gen(dpid = dpid).ip_str()
 
-    @staticmethod
-    def sorted( items ):
-        "Items sorted in natural (i.e. alphabetical) order"
-        return sorted(items, key=natural)
 
 class SingleSwitchTopo(Topo):
     '''Single switch connected to k hosts.'''
 
-    def __init__(self, k=2, **opts):
+    def __init__(self, k = 2, enable_all = True):
         '''Init.
 
         @param k number of hosts
         @param enable_all enables all nodes and switches?
         '''
-        super(SingleSwitchTopo, self).__init__(**opts)
+        super(SingleSwitchTopo, self).__init__()
 
         self.k = k
 
-        switch = self.add_switch('s1')
-        for h in irange(1, k):
-            host = self.add_host('h%s' % h)
-            self.add_link(host, switch)
+        self.add_node(1, Node())
+        hosts = range(2, k + 2)
+        for h in hosts:
+            self.add_node(h, Node(is_switch = False))
+            self.add_edge(h, 1, Edge())
+
+        if enable_all:
+            self.enable_all()
 
 
-class SingleSwitchReversedTopo(Topo):
+class SingleSwitchReversedTopo(SingleSwitchTopo):
     '''Single switch connected to k hosts, with reversed ports.
 
     The lowest-numbered host is connected to the highest-numbered port.
 
     Useful to verify that Mininet properly handles custom port numberings.
     '''
-    def __init__(self, k=2, **opts):
-        '''Init.
 
-        @param k number of hosts
-        @param enable_all enables all nodes and switches?
+    def port(self, src, dst):
+        '''Get port number.
+
+        @param src source switch DPID
+        @param dst destination switch DPID
+        @return tuple (src_port, dst_port):
+            src_port: port on source switch leading to the destination switch
+            dst_port: port on destination switch leading to the source switch
         '''
-        super(SingleSwitchReversedTopo, self).__init__(**opts)
-        self.k = k
-        switch = self.add_switch('s1')
-        for h in irange(1, k):
-            host = self.add_host('h%s' % h)
-            self.add_link(host, switch,
-                          port1=0, port2=(k - h + 1))
+        if src == 1:
+            if dst in range(2, self.k + 2):
+                dst_index = dst - 2
+                highest = self.k - 1
+                return (highest - dst_index, 0)
+            else:
+                raise Exception('unexpected dst: %i' % dst)
+        elif src in range(2, self.k + 2):
+            if dst == 1:
+                raise Exception('unexpected dst: %i' % dst)
+            else:
+                src_index = src - 2
+                highest = self.k - 1
+                return (0, highest - src_index)
+
 
 class LinearTopo(Topo):
-    "Linear topology of k switches, with one host per switch."
+    '''Linear topology of k switches, with one host per switch.'''
 
-    def __init__(self, k=2, **opts):
-        """Init.
-           k: number of switches (and hosts)
-           hconf: host configuration options
-           lconf: link configuration options"""
+    def __init__(self, k = 2, enable_all = True):
+        '''Init.
 
-        super(LinearTopo, self).__init__(**opts)
+        @param k number of switches (and hosts too)
+        @param enable_all enables all nodes and switches?
+        '''
+        super(LinearTopo, self).__init__()
 
         self.k = k
 
-        lastSwitch = None
-        for i in irange(1, k):
-            host = self.add_host('h%s' % i)
-            switch = self.add_switch('s%s' % i)
-            self.add_link( host, switch)
-            if lastSwitch:
-                self.add_link( switch, lastSwitch)
-            lastSwitch = switch
+        switches = range(1, k + 1)
+        for s in switches:
+            h = s + k
+            self.add_node(s, Node())
+            self.add_node(h, Node(is_switch = False))
+            self.add_edge(s, h, Edge())
+        for s in switches:
+            if s != k:
+                self.add_edge(s, s + 1, Edge())
+
+        if enable_all:
+            self.enable_all()

mininet/topolib.py

@@ -1,6 +1,6 @@
 "Library of potentially useful topologies for Mininet"
 
-from mininet.topo import Topo
+from mininet.topo import Topo, Node
 from mininet.net import Mininet
 
 class TreeTopo( Topo ):
@@ -8,27 +8,36 @@ class TreeTopo( Topo ):
 
     def __init__( self, depth=1, fanout=2 ):
         super( TreeTopo, self ).__init__()
-        # Numbering:  h1..N, s1..M
+        # Numbering:  h1..N, sN+1..M
+        hostCount = fanout ** depth
         self.hostNum = 1
-        self.switchNum = 1
+        self.switchNum = hostCount + 1
         # Build topology
         self.addTree( depth, fanout )
+        # Consider all switches and hosts 'on'
+        self.enable_all()
+
+    # It is OK that i is "unused" in the for loop.
+    # pylint: disable-msg=W0612
 
     def addTree( self, depth, fanout ):
         """Add a subtree starting with node n.
            returns: last node added"""
         isSwitch = depth > 0
         if isSwitch:
-            node = self.add_switch( 's%s' % self.switchNum )
+            num = self.switchNum
             self.switchNum += 1
-            for _ in range( fanout ):
-                child = self.addTree( depth - 1, fanout )
-                self.add_link( node, child )
         else:
-            node = self.add_host( 'h%s' % self.hostNum )
+            num = self.hostNum
             self.hostNum += 1
-        return node
+        self.add_node( num, Node( is_switch=isSwitch ) )
+        if isSwitch:
+            for i in range( 0, fanout ):
+                child = self.addTree( depth - 1, fanout )
+                self.add_edge( num, child )
+        return num
 
+    # pylint: enable-msg=W0612
 
 def TreeNet( depth=1, fanout=2, **kwargs ):
     "Convenience function for creating tree networks."

mininet/util.py

@@ -1,14 +1,12 @@
 "Utility functions for Mininet."
 
-from mininet.log import output, info, error
-
 from time import sleep
-from resource import setrlimit, RLIMIT_NPROC, RLIMIT_NOFILE
-from select import poll, POLLIN
+from resource import setrlimit, getrlimit, RLIMIT_NPROC, RLIMIT_NOFILE
+import select
 from subprocess import call, check_call, Popen, PIPE, STDOUT
-import re
-from fcntl import fcntl, F_GETFL, F_SETFL
-from os import O_NONBLOCK
+import os
+
+from mininet.log import error, warn
 
 # Command execution support
 
@@ -25,98 +23,34 @@ def checkRun( cmd ):
 # pylint doesn't understand explicit type checking
 # pylint: disable-msg=E1103
 
-def oldQuietRun( *cmd ):
+def quietRun( *cmd ):
     """Run a command, routing stderr to stdout, and return the output.
        cmd: list of command params"""
     if len( cmd ) == 1:
         cmd = cmd[ 0 ]
         if isinstance( cmd, str ):
             cmd = cmd.split( ' ' )
+    cmd = ["sudo", "-E", "env", "PATH=%s" % os.environ["PATH"]] + cmd
     popen = Popen( cmd, stdout=PIPE, stderr=STDOUT )
     # We can't use Popen.communicate() because it uses
     # select(), which can't handle
     # high file descriptor numbers! poll() can, however.
-    out = ''
-    readable = poll()
+    output = ''
+    readable = select.poll()
     readable.register( popen.stdout )
     while True:
         while readable.poll():
             data = popen.stdout.read( 1024 )
             if len( data ) == 0:
                 break
-            out += data
+            output += data
         popen.poll()
         if popen.returncode != None:
             break
-    return out
-
-
-# This is a bit complicated, but it enables us to
-# monitor command output as it is happening
-
-def errRun( *cmd, **kwargs ):
-    """Run a command and return stdout, stderr and return code
-       cmd: string or list of command and args
-       stderr: STDOUT to merge stderr with stdout
-       shell: run command using shell
-       echo: monitor output to console"""
-    # Allow passing in a list or a string
-    if len( cmd ) == 1:
-        cmd = cmd[ 0 ]
-        if isinstance( cmd, str ):
-            cmd = cmd.split( ' ' )
-    cmd = [ str( arg ) for arg in cmd ]
-    # By default we separate stderr, don't run in a shell, and don't echo
-    stderr = kwargs.get( 'stderr', PIPE )
-    shell = kwargs.get( 'shell', False )
-    echo = kwargs.get( 'echo', False )
-    if echo:
-        # cmd goes to stderr, output goes to stdout
-        info( cmd, '\n' )
-    popen = Popen( cmd, stdout=PIPE, stderr=stderr, shell=shell )
-    # We use poll() because select() doesn't work with large fd numbers,
-    # and thus communicate() doesn't work either
-    out, err = '', ''
-    poller = poll()
-    poller.register( popen.stdout, POLLIN )
-    fdtofile = { popen.stdout.fileno(): popen.stdout }
-    outDone, errDone = False, True
-    if popen.stderr:
-        fdtofile[ popen.stderr.fileno() ] = popen.stderr
-        poller.register( popen.stderr, POLLIN )
-        errDone = False
-    while not outDone or not errDone:
-        readable = poller.poll()
-        for fd, _event in readable:
-            f = fdtofile[ fd ]
-            data = f.read( 1024 )
-            if echo:
-                output( data )
-            if f == popen.stdout:
-                out += data
-                if data == '':
-                    outDone = True
-            elif f == popen.stderr:
-                err += data
-                if data == '':
-                    errDone = True
-    returncode = popen.wait()
-    return out, err, returncode
-
-def errFail( *cmd, **kwargs ):
-    "Run a command using errRun and raise exception on nonzero exit"
-    out, err, ret = errRun( *cmd, **kwargs )
-    if ret:
-        raise Exception( "errFail: %s failed with return code %s: %s"
-                         % ( cmd, ret, err ) )
-    return out, err, ret
-
-def quietRun( cmd, **kwargs ):
-    "Run a command and return merged stdout and stderr"
-    return errRun( cmd, stderr=STDOUT, **kwargs )[ 0 ]
+    return output
 
 # pylint: enable-msg=E1103
-# pylint: disable-msg=E1101
+# pylint: disable-msg=E1101,W0612
 
 def isShellBuiltin( cmd ):
     "Return True if cmd is a bash builtin."
@@ -129,7 +63,7 @@ def isShellBuiltin( cmd ):
 
 isShellBuiltin.builtIns = None
 
-# pylint: enable-msg=E1101
+# pylint: enable-msg=E1101,W0612
 
 # Interface management
 #
@@ -192,41 +126,25 @@ def moveIntf( intf, node, printError=False, retries=3, delaySecs=0.001 ):
        printError: if true, print error"""
     retry( retries, delaySecs, moveIntfNoRetry, intf, node, printError )
 
-# Support for dumping network
+def createLink( node1, node2, port1=None, port2=None ):
+    """Create a link between nodes, making an interface for each.
+       node1: Node object
+       node2: Node object
+       port1: node1 port number (optional)
+       port2: node2 port number (optional)
+       returns: intf1 name, intf2 name"""
+    return node1.linkTo( node2, port1, port2 )
 
-def dumpNodeConnections( nodes ):
-    "Dump connections to/from nodes."
-
-    def dumpConnections( node ):
-        "Helper function: dump connections to node"
-        for intf in node.intfList():
-            output( ' %s:' % intf )
-            if intf.link:
-                intfs = [ intf.link.intf1, intf.link.intf2 ]
-                intfs.remove( intf )
-                output( intfs[ 0 ] )
-            else:
-                output( ' ' )
-
-    for node in nodes:
-        output( node.name )
-        dumpConnections( node )
-        output( '\n' )
-
-def dumpNetConnections( net ):
-    "Dump connections in network"
-    nodes = net.controllers + net.switches + net.hosts
-    dumpNodeConnections( nodes )
 
 # IP and Mac address formatting and parsing
 
-def _colonHex( val, bytecount ):
+def _colonHex( val, count ):
     """Generate colon-hex string.
        val: input as unsigned int
-       bytescount: number of bytes to convert
+       count: number of bytes to convert
        returns: chStr colon-hex string"""
     pieces = []
-    for i in range( bytecount - 1, -1, -1 ):
+    for i in range( count - 1, -1, -1 ):
         piece = ( ( 0xff << ( i * 8 ) ) & val ) >> ( i * 8 )
         pieces.append( '%02x' % piece )
     chStr = ':'.join( pieces )
@@ -242,44 +160,23 @@ def ipStr( ip ):
     """Generate IP address string from an unsigned int.
        ip: unsigned int of form w << 24 | x << 16 | y << 8 | z
        returns: ip address string w.x.y.z, or 10.x.y.z if w==0"""
-    w = ( ip >> 24 ) & 0xff
+    w = ( ip & 0xff000000 ) >> 24
     w = 10 if w == 0 else w
-    x = ( ip >> 16 ) & 0xff
-    y = ( ip >> 8 ) & 0xff
+    x = ( ip & 0xff0000 ) >> 16
+    y = ( ip & 0xff00 ) >> 8
     z = ip & 0xff
     return "%i.%i.%i.%i" % ( w, x, y, z )
 
 def ipNum( w, x, y, z ):
-    """Generate unsigned int from components of IP address
+    """Generate unsigned int from components ofIP address
        returns: w << 24 | x << 16 | y << 8 | z"""
     return  ( w << 24 ) | ( x << 16 ) | ( y << 8 ) | z
 
-def ipAdd( i, prefixLen=8, ipBaseNum=0x0a000000 ):
-    """Return IP address string from ints
-       i: int to be added to ipbase
-       prefixLen: optional IP prefix length
-       ipBaseNum: option base IP address as int
-       returns IP address as string"""
-    # Ugly but functional
-    assert i < ( 1 << ( 32 - prefixLen ) )
-    mask = 0xffffffff ^ ( ( 1 << prefixLen ) - 1 )
-    ipnum = i + ( ipBaseNum & mask )
-    return ipStr( ipnum )
-
 def ipParse( ip ):
     "Parse an IP address and return an unsigned int."
     args = [ int( arg ) for arg in ip.split( '.' ) ]
     return ipNum( *args )
 
-def netParse( ipstr ):
-    """Parse an IP network specification, returning
-       address and prefix len as unsigned ints"""
-    prefixLen = 0
-    if '/' in ipstr:
-        ip, pf = ipstr.split( '/' )
-        prefixLen = int( pf )
-    return ipParse( ip ), prefixLen
-
 def checkInt( s ):
     "Check if input string is an int"
     try:
@@ -305,149 +202,27 @@ def makeNumeric( s ):
     else:
         return s
 
-# Popen support
-
-def pmonitor(popens, timeoutms=500, readline=True,
-             readmax=1024 ):
-    """Monitor dict of hosts to popen objects
-       a line at a time
-       timeoutms: timeout for poll()
-       readline: return single line of output
-       yields: host, line/output (if any)
-       terminates: when all EOFs received"""
-    poller = poll()
-    fdToHost = {}
-    for host, popen in popens.iteritems():
-        fd = popen.stdout.fileno()
-        fdToHost[ fd ] = host
-        poller.register( fd, POLLIN )
-        if not readline:
-            # Use non-blocking reads
-            flags = fcntl( fd, F_GETFL )
-            fcntl( fd, F_SETFL, flags | O_NONBLOCK )
-    while True:
-        fds = poller.poll( timeoutms )
-        if fds:
-            for fd, _event in fds:
-                host = fdToHost[ fd ]
-                popen = popens[ host ]
-                if readline:
-                    # Attempt to read a line of output
-                    # This blocks until we receive a newline!
-                    line = popen.stdout.readline()
-                else:
-                    line = popen.stdout.read( readmax )
-                yield host, line
-                # Check for EOF
-                if not line:
-                    popen.poll()
-                    if popen.returncode is not None:
-                        poller.unregister( fd )
-                        del popens[ host ]
-                        if not popens:
-                            return
-        else:
-            yield None, ''
 
 # Other stuff we use
 
 def fixLimits():
     "Fix ridiculously small resource limits."
-    setrlimit( RLIMIT_NPROC, ( 8192, 8192 ) )
-    setrlimit( RLIMIT_NOFILE, ( 16384, 16384 ) )
-
-def mountCgroups():
-    "Make sure cgroups file system is mounted"
-    mounts = quietRun( 'mount' )
-    cgdir = '/sys/fs/cgroup'
-    csdir = cgdir + '/cpuset'
-    if 'cgroups on %s' % cgdir not in mounts:
-        raise Exception( "cgroups not mounted on " + cgdir )
-    if 'cpuset on %s' % csdir not in mounts:
-        errRun( 'mkdir -p ' + csdir )
-        errRun( 'mount -t cgroup -ocpuset cpuset ' + csdir )
-
-def natural( text ):
-    "To sort sanely/alphabetically: sorted( l, key=natural )"
-    def num( s ):
-        "Convert text segment to int if necessary"
-        return int( s ) if s.isdigit() else s
-    return [  num( s ) for s in re.split( r'(\d+)', text ) ]
-
-def naturalSeq( t ):
-    "Natural sort key function for sequences"
-    return [ natural( x ) for x in t ]
-
-def numCores():
-    "Returns number of CPU cores based on /proc/cpuinfo"
-    if hasattr( numCores, 'ncores' ):
-        return numCores.ncores
-    try:
-        numCores.ncores = int( quietRun('grep -c processor /proc/cpuinfo') )
-    except ValueError:
-        return 0
-    return numCores.ncores
-
-def irange(start, end):
-    """Inclusive range from start to end (vs. Python insanity.)
-       irange(1,5) -> 1, 2, 3, 4, 5"""
-    return range( start, end + 1 )
-
-def custom( cls, **params ):
-    "Returns customized constructor for class cls."
-    def customized( *args, **kwargs):
-        "Customized constructor"
-        kwargs.update( params )
-        return cls( *args, **kwargs )
-    return customized
-
-def splitArgs( argstr ):
-    """Split argument string into usable python arguments
-       argstr: argument string with format fn,arg2,kw1=arg3...
-       returns: fn, args, kwargs"""
-    split = argstr.split( ',' )
-    fn = split[ 0 ]
-    params = split[ 1: ]
-    # Convert int and float args; removes the need for function
-    # to be flexible with input arg formats.
-    args = [ makeNumeric( s ) for s in params if '=' not in s ]
-    kwargs = {}
-    for s in [ p for p in params if '=' in p ]:
-        key, val = s.split( '=' )
-        kwargs[ key ] = makeNumeric( val )
-    return fn, args, kwargs
-
-def customConstructor( constructors, argStr ):
-    """Return custom constructor based on argStr
-    
-    The args and key/val pairs in argsStr will be automatically applied
-    when the generated constructor is later used.
-    """
-    cname, newargs, kwargs = splitArgs( argStr )
-    constructor = constructors.get( cname, None )
-
-    if not constructor:
-        raise Exception( "error: %s is unknown - please specify one of %s" %
-               ( cname, constructors.keys() ) )
-
-    def customized( name, *args, **params ):
-        "Customized constructor, useful for Node, Link, and other classes"
-        params.update( kwargs )
-        if not newargs:
-            return constructor( name, *args, **params )
-        if args:
-            warn( 'warning: %s replacing %s with %s\n' % (
-                  constructor, args, newargs ) )
-        return constructor( name, *newargs, **params )
-
-    return customized
-
-def buildTopo( topos, topoStr ):
-    """Create topology from string with format (object, arg1, arg2,...).
-    
-    input topos is a dict of topo names to constructors, possibly w/args.
-    """
-    topo, args, kwargs = splitArgs( topoStr )
-    if topo not in topos:
-        raise Exception( 'Invalid topo name %s' % topo )
-    return topos[ topo ]( *args, **kwargs )
+    manyprocs = 8192
+    manyfiles = 32768
+    minprocs, maxprocs = getrlimit( RLIMIT_NPROC )
+    minfiles, maxfiles = getrlimit( RLIMIT_NOFILE )
+    # Root can raise limits
+    if os.getuid() == 0:
+        maxprocs = max( maxprocs, manyprocs )
+        maxfiles = max( maxfiles, manyfiles )
+    minprocs = min( manyprocs, maxprocs )
+    minfiles = min( manyfiles, maxfiles )
+    setrlimit( RLIMIT_NPROC, ( minprocs, maxprocs ) )
+    setrlimit( RLIMIT_NOFILE, ( minfiles, maxfiles ) )
+    nprocs = max( getrlimit( RLIMIT_NPROC ) )
+    nfiles = max( getrlimit( RLIMIT_NOFILE ) )
+    # Complain if limits are too low
+    if nprocs < manyprocs:
+        warn( '*** Warning: process limit is low:', nprocs, 'procs\n' )
+    if nfiles < manyfiles:
+        warn( '*** Warning: open file limit is low:', nfiles, 'files \n' )

mnexec.c

@@ -7,8 +7,6 @@
  *  - detaching from a controlling tty using setsid
  *  - running in a network namespace
  *  - printing out the pid of a process so we can identify it later
- *  - attaching to a namespace and cgroup
- *  - setting RT scheduling
  *
  * Partially based on public domain setsid(1)
 */
@@ -16,83 +14,23 @@
 #include <stdio.h>
 #include <linux/sched.h>
 #include <unistd.h>
-#include <limits.h>
-#include <syscall.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <limits.h>
-#include <sched.h>
 
 void usage(char *name) 
 {
     printf("Execution utility for Mininet.\n"
-           "usage: %s [-cdnp] [-a pid] [-g group] [-r rtprio] cmd args...\n"
+           "usage: %s [-cdnp]\n"
            "-c: close all file descriptors except stdin/out/error\n"
            "-d: detach from tty by calling setsid()\n"
            "-n: run in new network namespace\n"
-           "-p: print ^A + pid\n"
-           "-a pid: attach to pid's network namespace\n"
-           "-g group: add to cgroup\n"
-           "-r rtprio: run with SCHED_RR (usually requires -g)\n",
-           name);
-}
-
-
-int setns(int fd, int nstype)
-{
-	return syscall(308, fd, nstype);
-}
-
-/* Validate alphanumeric path foo1/bar2/baz */
-void validate(char *path)
-{
-    char *s;
-    for (s=path; *s; s++) {
-        if (!isalnum(*s) && *s != '/') {
-            fprintf(stderr, "invalid path: %s\n", path);
-            exit(1);
-        }
-    }
-}
-
-/* Add our pid to cgroup */
-int cgroup(char *gname)
-{
-    static char path[PATH_MAX];
-    static char *groups[] = {
-        "cpu", "cpuacct", "cpuset", NULL
-    };
-    char **gptr;
-    pid_t pid = getpid();
-    int count = 0;
-    validate(gname);
-    for (gptr = groups; *gptr; gptr++) {
-        FILE *f;
-        snprintf(path, PATH_MAX, "/sys/fs/cgroup/%s/%s/tasks",
-                 *gptr, gname);
-        f = fopen(path, "w");
-        if (f) {
-            count++;
-            fprintf(f, "%d\n", pid);
-            fclose(f);
-        }
-    }
-    if (!count) {
-        fprintf(stderr, "cgroup: could not add to cgroup %s\n",
-            gname);
-        exit(1);
-    }
+           "-p: print ^A + pid\n", name);
 }
 
 int main(int argc, char *argv[])
 {
     char c;
     int fd;
-    char path[PATH_MAX];
-    int nsid;
-    int pid;
-    static struct sched_param sp;
-    while ((c = getopt(argc, argv, "+cdnpa:g:r:")) != -1)
+    
+    while ((c = getopt(argc, argv, "+cdnp")) != -1)
         switch(c) {
         case 'c':
             /* close file descriptors except stdin/out/error */
@@ -126,42 +64,16 @@ int main(int argc, char *argv[])
             printf("\001%d\n", getpid());
             fflush(stdout);
             break;
-        case 'a':
-            /* Attach to pid's network namespace */
-            pid = atoi(optarg);
-            sprintf(path, "/proc/%d/ns/net", pid );
-            nsid = open(path, O_RDONLY);
-            if (nsid < 0) {
-                perror(path);
-                return 1;
-            }
-            if (setns(nsid, 0) != 0) {
-                perror("setns");
-                return 1;
-            }
-            break;
-        case 'g':
-            /* Attach to cgroup */
-            cgroup(optarg);
-            break;
-        case 'r':
-            /* Set RT scheduling priority */
-            sp.sched_priority = atoi(optarg);
-            if (sched_setscheduler(getpid(), SCHED_RR, &sp) < 0) {
-                perror("sched_setscheduler");
-                return 1;
-            }
-            break;
         default:
             usage(argv[0]);
             break;
         }
 
     if (optind < argc) {
-        execvp(argv[optind], &argv[optind]);
-        perror(argv[optind]);
-        return 1;
-    }
+		execvp(argv[optind], &argv[optind]);
+		perror(argv[optind]);
+		return 1;
+	}
     
     usage(argv[0]);
 }

setup.py

@@ -5,7 +5,8 @@
 from setuptools import setup, find_packages
 from os.path import join
 
-scripts = [ join( 'bin', filename ) for filename in [ 'mn' ] ]
+scripts = [ join( 'bin', filename ) for filename in [ 
+    'mn', 'mnexec' ] ]
 
 modname = distname = 'mininet'
 

util/build-ovs-packages.sh

@@ -1,94 +0,0 @@
-#!/bin/bash
-
-# Attempt to build debian packages for OVS
-
-set -e  # exit on error
-set -u  # exit on undefined variable
-
-kvers=`uname -r`
-ksrc=/lib/modules/$kvers/build
-dist=`lsb_release -is | tr [A-Z] [a-z]`
-release=`lsb_release -rs`
-arch=`uname -m`
-buildsuffix=-2
-if [ "$arch" = "i686" ]; then arch=i386; fi
-if [ "$arch" = "x86_64" ]; then arch=amd64; fi
-
-overs=1.4.0
-ovs=openvswitch-$overs
-ovstgz=$ovs.tar.gz
-ovsurl=http://openvswitch.org/releases/$ovstgz
-
-install='sudo apt-get install -y'
-
-echo "*** Installing debian/ubuntu build system"
- $install build-essential devscripts ubuntu-dev-tools debhelper dh-make
- $install diff patch cdbs quilt gnupg fakeroot lintian pbuilder piuparts
- $install module-assistant
-
-echo "*** Installing OVS dependencies"
- $install pkg-config gcc make python-dev libssl-dev libtool
- $install dkms ipsec-tools
-
-echo "*** Installing headers for $kvers"
- $install linux-headers-$kvers
-
-echo "*** Retrieving OVS source"
- wget -c $ovsurl
- tar xzf $ovstgz
- cd $ovs
-
-echo "*** Patching OVS source"
- # Not sure why this fails, but off it goes!
- sed -i -e 's/dh_strip/# dh_strip/' debian/rules
- if [ "$release" = "10.04" ]; then
-  # Lucid doesn't seem to have all the packages for ovsdbmonitor
-  echo "*** Patching debian/rules to remove dh_python2"
-  sed -i -e 's/dh_python2/dh_pysupport/' debian/rules
-  echo "*** Not building ovsdbmonitor since it's too hard on 10.04"
-  mv debian/ovsdbmonitor.install debian/ovsdbmonitor.install.backup
-  sed -i -e 's/ovsdbmonitor.install/ovsdbmonitor.install.backup/' Makefile.in
- else
-  # Install a bag of hurt for ovsdbmonitor
-  $install python-pyside.qtcore pyqt4-dev-tools python-twisted python-twisted-bin \
-   python-twisted-core python-twisted-conch python-anyjson python-zope.interface
- fi
- # init script was written to assume that commands complete
- sed -i -e 's/^set -e/#set -e/' debian/openvswitch-controller.init
-
-echo "*** Building OVS user packages"
- opts=--with-linux=/lib/modules/`uname -r`/build
- fakeroot make -f debian/rules DATAPATH_CONFIGURE_OPTS=$opts binary
-
-echo "*** Building OVS datapath kernel module package"
- # Still looking for the "right" way to do this...
- sudo mkdir -p /usr/src/linux
- ln -sf _debian/openvswitch.tar.gz .
- sudo make -f debian/rules.modules KSRC=$ksrc KVERS=$kvers binary-modules
-
-echo "*** Built the following packages:"
- cd ~
- ls -l *deb
-
-archive=ovs-$overs-core-$dist-$release-$arch$buildsuffix.tar
-ovsbase='common pki switch brcompat controller datapath-dkms'
-echo "*** Packing up $ovsbase .debs into:"
-echo "    $archive"
- pkgs=""
- for component in $ovsbase; do
-  if echo $component | egrep 'dkms|pki'; then
-    # Architecture-independent packages
-    deb=(openvswitch-${component}_$overs*all.deb)
-  else
-    deb=(openvswitch-${component}_$overs*$arch.deb)
-  fi
-  pkgs="$pkgs $deb"
- done
- rm -rf $archive
- tar cf $archive $pkgs
-
-echo "*** Contents of archive $archive:"
- tar tf $archive
-
-echo "*** Done (hopefully)"
-

util/doxify.py

@@ -82,7 +82,7 @@ if __name__ == '__main__':
     fixLines( infile.readlines(), outfid )
     infile.close()
     os.close( outfid )
-    call( [ 'doxypy', outname ] )
+    call( [ 'doxypy.py', outname ] )
 
 
 

util/install.sh

@@ -1,5 +1,4 @@
 #!/usr/bin/env bash
-
 # Mininet install script for Ubuntu (and Debian Lenny)
 # Brandon Heller (brandonh@stanford.edu)
 
@@ -17,78 +16,57 @@ KERNEL_LOC=http://www.openflow.org/downloads/mininet
 DIST=Unknown
 RELEASE=Unknown
 CODENAME=Unknown
-ARCH=`uname -m`
-if [ "$ARCH" = "x86_64" ]; then ARCH="amd64"; fi
-if [ "$ARCH" = "i686" ]; then ARCH="i386"; fi
-
 test -e /etc/debian_version && DIST="Debian"
 grep Ubuntu /etc/lsb-release &> /dev/null && DIST="Ubuntu"
 if [ "$DIST" = "Ubuntu" ] || [ "$DIST" = "Debian" ]; then
-    install='sudo apt-get -y install'
-    remove='sudo apt-get -y remove'
-    pkginst='sudo dpkg -i'
-    # Prereqs for this script
-    if ! which lsb_release &> /dev/null; then
-        $install lsb-release
-    fi
-    if ! which bc &> /dev/null; then
-        $install bc
-    fi 
+    sudo apt-get install -y lsb-release
 fi
 if which lsb_release &> /dev/null; then
     DIST=`lsb_release -is`
     RELEASE=`lsb_release -rs`
     CODENAME=`lsb_release -cs`
 fi
-echo "Detected Linux distribution: $DIST $RELEASE $CODENAME $ARCH"
+echo "Detected Linux distribution: $DIST $RELEASE $CODENAME"
 
 # Kernel params
 
-if [ "$DIST" = "Ubuntu" ]; then
+if [ "$DIST" = "Debian" ]; then
+    KERNEL_NAME=2.6.33.1-mininet
+    KERNEL_HEADERS=linux-headers-${KERNEL_NAME}_${KERNEL_NAME}-10.00.Custom_i386.deb
+    KERNEL_IMAGE=linux-image-${KERNEL_NAME}_${KERNEL_NAME}-10.00.Custom_i386.deb
+elif [ "$DIST" = "Ubuntu" ]; then
     if [ "$RELEASE" = "10.04" ]; then
         KERNEL_NAME='3.0.0-15-generic'
     else
         KERNEL_NAME=`uname -r`
     fi
     KERNEL_HEADERS=linux-headers-${KERNEL_NAME}
-elif [ "$DIST" = "Debian" ] && [ "$ARCH" = "i386" ] && [ "$CODENAME" = "lenny" ]; then
-    KERNEL_NAME=2.6.33.1-mininet
-    KERNEL_HEADERS=linux-headers-${KERNEL_NAME}_${KERNEL_NAME}-10.00.Custom_i386.deb
-    KERNEL_IMAGE=linux-image-${KERNEL_NAME}_${KERNEL_NAME}-10.00.Custom_i386.deb
 else
-    echo "Install.sh currently only supports Ubuntu and Debian Lenny i386."
+    echo "Install.sh currently only supports Ubuntu and Debian."
     exit 1
 fi
 
-# More distribution info
-DIST_LC=`echo $DIST | tr [A-Z] [a-z]` # as lower case
 
 # Kernel Deb pkg to be removed:
-KERNEL_IMAGE_OLD=linux-image-2.6.26-33-generic
+KERNEL_IMAGE_OLD=linux-image-2.6.26-2-686
 
 DRIVERS_DIR=/lib/modules/${KERNEL_NAME}/kernel/drivers/net
 
-OVS_RELEASE=1.4.0
-OVS_PACKAGE_LOC=https://github.com/downloads/mininet/mininet
-OVS_BUILDSUFFIX=-ignore # was -2
-OVS_PACKAGE_NAME=ovs-$OVS_RELEASE-core-$DIST_LC-$RELEASE-$ARCH$OVS_BUILDSUFFIX.tar
+OVS_RELEASE=v1.2.2
 OVS_SRC=~/openvswitch
-OVS_TAG=v$OVS_RELEASE
 OVS_BUILD=$OVS_SRC/build-$KERNEL_NAME
 OVS_KMODS=($OVS_BUILD/datapath/linux/{openvswitch_mod.ko,brcompat_mod.ko})
 
 function kernel {
     echo "Install Mininet-compatible kernel if necessary"
     sudo apt-get update
-    if [ "$DIST" = "Ubuntu" ] &&  [ "$RELEASE" = "10.04" ]; then
-        $install linux-image-$KERNEL_NAME
-    elif [ "$DIST" = "Debian" ]; then
+    if [ "$DIST" = "Debian" ]; then
         # The easy approach: download pre-built linux-image and linux-headers packages:
         wget -c $KERNEL_LOC/$KERNEL_HEADERS
         wget -c $KERNEL_LOC/$KERNEL_IMAGE
 
         # Install custom linux headers and image:
-        $pkginst $KERNEL_IMAGE $KERNEL_HEADERS
+        sudo dpkg -i $KERNEL_IMAGE $KERNEL_HEADERS
 
         # The next two steps are to work around a bug in newer versions of
         # kernel-package, which fails to add initrd images with the latest kernels.
@@ -105,15 +83,16 @@ function kernel {
         # /boot/grub/menu.lst to set the default to the entry corresponding to the
         # kernel you just installed.
     fi
+    if [ "$DIST" = "Ubuntu" ] &&  [ "$RELEASE" = "10.04" ]; then
+        sudo apt-get -y install linux-image-$KERNEL_NAME
+    fi
 }
 
 function kernel_clean {
     echo "Cleaning kernel..."
 
     # To save disk space, remove previous kernel
-    if ! $remove $KERNEL_IMAGE_OLD; then
-        echo $KERNEL_IMAGE_OLD not installed.
-    fi
+    sudo apt-get -y remove $KERNEL_IMAGE_OLD
 
     # Also remove downloaded packages:
     rm -f ~/linux-headers-* ~/linux-image-*
@@ -122,8 +101,8 @@ function kernel_clean {
 # Install Mininet deps
 function mn_deps {
     echo "Installing Mininet dependencies"
-    $install gcc make screen psmisc xterm ssh iperf iproute \
-        python-setuptools python-networkx cgroup-bin ethtool
+    sudo aptitude install -y gcc make screen psmisc xterm ssh iperf iproute \
+        python-setuptools python-networkx
 
     if [ "$DIST" = "Ubuntu" ] && [ "$RELEASE" = "10.04" ]; then
         echo "Upgrading networkx to avoid deprecation warning"
@@ -145,14 +124,16 @@ function mn_deps {
 
 # The following will cause a full OF install, covering:
 # -user switch
+# -dissector
 # The instructions below are an abbreviated version from
 # http://www.openflowswitch.org/wk/index.php/Debian_Install
 # ... modified to use Debian Lenny rather than unstable.
 function of {
-    echo "Installing OpenFlow reference implementation..."
+    echo "Installing OpenFlow and its tools..."
+
     cd ~/
-    $install git-core autoconf automake autotools-dev pkg-config \
-		make gcc libtool libc6-dev 
+    sudo apt-get install -y git-core automake m4 pkg-config libtool \
+		make libc6-dev autoconf autotools-dev gcc
     git clone git://openflowswitch.org/openflow.git
     cd ~/openflow
 
@@ -165,9 +146,19 @@ function of {
     make
     sudo make install
 
+    # Install dissector:
+    sudo apt-get install -y wireshark libgtk2.0-dev
+    cd ~/openflow/utilities/wireshark_dissectors/openflow
+    make
+    sudo make install
+
+    # Copy coloring rules: OF is white-on-blue:
+    mkdir -p ~/.wireshark
+    cp ~/mininet/util/colorfilters ~/.wireshark
+
     # Remove avahi-daemon, which may cause unwanted discovery packets to be 
-    # sent during tests, near link status changes:
-    $remove avahi-daemon
+	# sent during tests, near link status changes:
+    sudo apt-get remove -y avahi-daemon
 
     # Disable IPv6.  Add to /etc/modprobe.d/blacklist:
     if [ "$DIST" = "Ubuntu" ]; then
@@ -176,157 +167,46 @@ function of {
         BLACKLIST=/etc/modprobe.d/blacklist
     fi
     sudo sh -c "echo 'blacklist net-pf-10\nblacklist ipv6' >> $BLACKLIST"
-    cd ~
 }
 
-function wireshark {
-    echo "Installing Wireshark dissector..."
-
-    sudo apt-get install -y wireshark libgtk2.0-dev
-
-    if [ "$DIST" = "Ubuntu" ] && [ "$RELEASE" != "10.04" ]; then
-        # Install newer version
-        sudo apt-get install -y scons mercurial libglib2.0-dev
-        sudo apt-get install -y libwiretap-dev libwireshark-dev
-        cd ~
-        hg clone https://bitbucket.org/barnstorm/of-dissector
-        cd of-dissector/src
-        export WIRESHARK=/usr/include/wireshark
-        scons
-        # libwireshark0/ on 11.04; libwireshark1/ on later
-        WSDIR=`ls -d /usr/lib/wireshark/libwireshark* | head -1`
-        WSPLUGDIR=$WSDIR/plugins/
-        sudo cp openflow.so $WSPLUGDIR
-        echo "Copied openflow plugin to $WSPLUGDIR"
-    else
-        # Install older version from reference source
-        cd ~/openflow/utilities/wireshark_dissectors/openflow
-        make
-        sudo make install
-    fi
-
-    # Copy coloring rules: OF is white-on-blue:
-    mkdir -p ~/.wireshark
-    cp ~/mininet/util/colorfilters ~/.wireshark
-}
-
-
 # Install Open vSwitch
 # Instructions derived from OVS INSTALL, INSTALL.OpenFlow and README files.
-
 function ovs {
     echo "Installing Open vSwitch..."
 
-    # Required for module build/dkms install
-    $install $KERNEL_HEADERS
-
-    ovspresent=0
-
-    # First see if we have packages
-    # XXX wget -c seems to fail from github/amazon s3
-    cd /tmp
-    if wget $OVS_PACKAGE_LOC/$OVS_PACKAGE_NAME 2> /dev/null; then
-	$install patch dkms fakeroot python-argparse
-        tar xf $OVS_PACKAGE_NAME
-        orig=`tar tf $OVS_PACKAGE_NAME`
-        # Now install packages in reasonable dependency order
-        order='dkms common pki openvswitch-switch brcompat controller'
-        pkgs=""
-        for p in $order; do
-            pkg=`echo "$orig" | grep $p`
-	    # Annoyingly, things seem to be missing without this flag
-            $pkginst --force-confmiss $pkg
-        done
-        ovspresent=1
+    if [ "$DIST" = "Debian" ] && [ "$CODENAME" == "lenny" ]; then
+        sudo aptitude -y install pkg-config gcc make git-core python-dev libssl-dev
+        # Install Autoconf 2.63+ backport from Debian Backports repo:
+        # Instructions from http://backports.org/dokuwiki/doku.php?id=instructions
+        sudo su -c "echo 'deb http://www.backports.org/debian lenny-backports main contrib non-free' >> /etc/apt/sources.list"
+        sudo apt-get update
+        sudo apt-get -y --force-yes install debian-backports-keyring
+        sudo apt-get -y --force-yes -t lenny-backports install autoconf
     fi
 
-    # Otherwise try distribution's OVS packages
-    if [ "$DIST" = "Ubuntu" ] && [ `expr $RELEASE '>=' 11.10` = 1 ]; then
-        if ! dpkg --get-selections | grep openvswitch-datapath; then
-            # If you've already installed a datapath, assume you
-            # know what you're doing and don't need dkms datapath.
-            # Otherwise, install it.
-            $install openvswitch-datapath-dkms
-        fi
-	if $install openvswitch-switch openvswitch-controller; then
-            echo "Ignoring error installing openvswitch-controller"
-        fi
-        ovspresent=1
+    if [ "$DIST" = "Ubuntu" ]; then
+        sudo apt-get -y install $KERNEL_HEADERS
     fi
 
-    # Switch can run on its own, but 
-    # Mininet should control the controller
-    if [ -e /etc/init.d/openvswitch-controller ]; then
-        if sudo service openvswitch-controller stop; then
-            echo "Stopped running controller"
-        fi
-        sudo update-rc.d openvswitch-controller disable
-    fi
-
-    if [ $ovspresent = 1 ]; then
-        echo "Done (hopefully) installing packages"
-        cd ~
-        return
-    fi
-
-    # Otherwise attempt to install from source
-
-    $install pkg-config gcc make python-dev libssl-dev libtool
-
-    if [ "$DIST" = "Debian" ]; then
-        if [ "$CODENAME" = "lenny" ]; then
-            $install git-core
-            # Install Autoconf 2.63+ backport from Debian Backports repo:
-            # Instructions from http://backports.org/dokuwiki/doku.php?id=instructions
-            sudo su -c "echo 'deb http://www.backports.org/debian lenny-backports main contrib non-free' >> /etc/apt/sources.list"
-            sudo apt-get update
-            sudo apt-get -y --force-yes install debian-backports-keyring
-            sudo apt-get -y --force-yes -t lenny-backports install autoconf
-        fi
-    else
-        $install git
-    fi    
-
     # Install OVS from release
     cd ~/
-    git clone git://openvswitch.org/openvswitch $OVS_SRC
+    git clone git://openvswitch.org/openvswitch
     cd $OVS_SRC
-    git checkout $OVS_TAG
+    git checkout $OVS_RELEASE
     ./boot.sh
     BUILDDIR=/lib/modules/${KERNEL_NAME}/build
     if [ ! -e $BUILDDIR ]; then
         echo "Creating build sdirectory $BUILDDIR"
         sudo mkdir -p $BUILDDIR
     fi
-    opts="--with-linux=$BUILDDIR"
-    mkdir -p $OVS_BUILD
-    cd $OVS_BUILD
+	opts="--with-linux=$BUILDDIR"
+	mkdir -p $OVS_BUILD
+	cd $OVS_BUILD
     ../configure $opts
     make
     sudo make install
-
-    modprobe
-}
-
-function remove_ovs {
-    pkgs=`dpkg --get-selections | grep openvswitch | awk '{ print $1;}'`
-    echo "Removing existing Open vSwitch packages:"
-    echo $pkgs
-    if ! $remove $pkgs; then
-        echo "Not all packages removed correctly"
-    fi
-    # For some reason this doesn't happen
-    if scripts=`ls /etc/init.d/*openvswitch* 2>/dev/null`; then
-        echo $scripts
-        for s in $scripts; do
-            s=$(basename $s)
-            echo SCRIPT $s
-            sudo service $s stop
-            sudo rm -f /etc/init.d/$s
-            sudo update-rc.d -f $s remove
-        done
-    fi
-    echo "Done removing OVS"
+	# openflowd is deprecated, but for now copy it in
+	sudo cp tests/test-openflowd /usr/local/bin/ovs-openflowd
 }
 
 # Install NOX with tutorial files
@@ -334,17 +214,17 @@ function nox {
     echo "Installing NOX w/tutorial files..."
 
     # Install NOX deps:
-    $install autoconf automake g++ libtool python python-twisted \
+    sudo apt-get -y install autoconf automake g++ libtool python python-twisted \
 		swig libssl-dev make
     if [ "$DIST" = "Debian" ]; then
-        $install libboost1.35-dev
+        sudo apt-get -y install libboost1.35-dev
     elif [ "$DIST" = "Ubuntu" ]; then
-        $install python-dev libboost-dev 
-        $install libboost-filesystem-dev
-        $install libboost-test-dev
+        sudo apt-get -y install python-dev libboost-dev 
+        sudo apt-get -y install libboost-filesystem-dev
+        sudo apt-get -y install libboost-test-dev
     fi
     # Install NOX optional deps:
-    $install libsqlite3-dev python-simplejson
+    sudo apt-get install -y libsqlite3-dev python-simplejson
 
     # Fetch NOX destiny
     cd ~/
@@ -354,10 +234,7 @@ function nox {
 
     # Apply patches
     git checkout -b tutorial-destiny
-    git am ~/mininet/util/nox-patches/*tutorial-port-nox-destiny*.patch
-    if [ "$DIST" = "Ubuntu" ] && [ `expr $RELEASE '>=' 12.04` = 1 ]; then
-        git am ~/mininet/util/nox-patches/*nox-ubuntu12-hacks.patch
-    fi
+    git am ~/mininet/util/nox-patches/*.patch
 
     # Build
     ./boot.sh
@@ -380,7 +257,7 @@ function oftest {
     echo "Installing oftest..."
 
     # Install deps:
-    $install tcpdump python-scapy
+    sudo apt-get install -y tcpdump python-scapy
 
     # Install oftest:
     cd ~/
@@ -394,7 +271,7 @@ function oftest {
 function cbench {
     echo "Installing cbench..."
     
-    $install libsnmp-dev libpcap-dev libconfig-dev
+    sudo apt-get install -y libsnmp-dev libpcap-dev
     cd ~/
     git clone git://openflow.org/oflops.git
     cd oflops
@@ -413,13 +290,13 @@ function other {
 
     # Install tcpdump and tshark, cmd-line packet dump tools.  Also install gitk,
     # a graphical git history viewer.
-    $install tcpdump tshark gitk
+    sudo apt-get install -y tcpdump tshark gitk
 
     # Install common text editors
-    $install vim nano emacs
+    sudo apt-get install -y vim nano emacs
 
     # Install NTP
-    $install ntp
+    sudo apt-get install -y ntp
 
     # Set git to colorize everything.
     git config --global color.diff auto
@@ -454,8 +331,8 @@ function all {
     kernel
     mn_deps
     of
-    wireshark
     ovs
+    modprobe
     nox
     oftest
     cbench
@@ -509,12 +386,10 @@ function usage {
     printf -- ' -f: install open(F)low\n' >&2
     printf -- ' -h: print this (H)elp message\n' >&2
     printf -- ' -k: install new (K)ernel\n' >&2
-    printf -- ' -m: install Open vSwitch kernel (M)odule from source dir\n' >&2
+    printf -- ' -m: install Open vSwitch kernel (M)odule\n' >&2
     printf -- ' -n: install mini(N)et dependencies + core files\n' >&2
-    printf -- ' -r: remove existing Open vSwitch packages\n' >&2
     printf -- ' -t: install o(T)her stuff\n' >&2
     printf -- ' -v: install open (V)switch\n' >&2
-    printf -- ' -w: install OpenFlow (w)ireshark dissector\n' >&2
     printf -- ' -x: install NO(X) OpenFlow controller\n' >&2
     printf -- ' -y: install (A)ll packages\n' >&2    
     
@@ -525,7 +400,7 @@ if [ $# -eq 0 ]
 then
     all
 else
-    while getopts 'abcdfhkmnrtvwx' OPTION
+    while getopts 'abcdfhkmntvx' OPTION
     do
       case $OPTION in
       a)    all;;
@@ -537,10 +412,8 @@ else
       k)    kernel;;
       m)    modprobe;;
       n)    mn_deps;;
-      r)    remove_ovs;;
       t)    other;;
       v)    ovs;;
-      w)    wireshark;;
       x)    nox;;
       ?)    usage;;
       esac

util/nox-patches/0002-nox-ubuntu12-hacks.patch

@@ -1,175 +0,0 @@
-From 166693d7cb640d4a41251b87e92c52d9c688196b Mon Sep 17 00:00:00 2001
-From: Bob Lantz <rlantz@cs.stanford.edu>
-Date: Mon, 14 May 2012 15:30:44 -0700
-Subject: [PATCH] Hacks to get NOX classic/destiny to compile under Ubuntu
- 12.04
-
-Thanks to Srinivasu R. Kanduru for the initial patch.
-
-Apologies for the hacks - it is my hope that this will be fixed
-upstream eventually.
-
----
- config/ac_pkg_swig.m4                              |    7 ++++---
- src/Make.vars                                      |    2 +-
- src/nox/coreapps/pyrt/deferredcallback.cc          |    2 +-
- src/nox/coreapps/pyrt/pyglue.cc                    |    2 +-
- src/nox/coreapps/pyrt/pyrt.cc                      |    2 +-
- src/nox/netapps/authenticator/auth.i               |    2 ++
- src/nox/netapps/authenticator/flow_util.i          |    1 +
- src/nox/netapps/routing/routing.i                  |    2 ++
- .../switch_management/pyswitch_management.i        |    2 ++
- src/nox/netapps/tests/tests.cc                     |    2 +-
- src/nox/netapps/topology/pytopology.i              |    2 ++
- 11 files changed, 18 insertions(+), 8 deletions(-)
-
-diff --git a/config/ac_pkg_swig.m4 b/config/ac_pkg_swig.m4
-index d12556e..9b608f2 100644
---- a/config/ac_pkg_swig.m4
-+++ b/config/ac_pkg_swig.m4
-@@ -78,9 +78,10 @@ AC_DEFUN([AC_PROG_SWIG],[
-                         if test -z "$available_patch" ; then
-                                 [available_patch=0]
-                         fi
--                        if test $available_major -ne $required_major \
--                                -o $available_minor -ne $required_minor \
--                                -o $available_patch -lt $required_patch ; then
-+			major_done=`test $available_major -gt $required_major`
-+			minor_done=`test $available_minor -gt $required_minor`
-+                        if test !$major_done -a !$minor_done \
-+                                -a $available_patch -lt $required_patch ; then
-                                 AC_MSG_WARN([SWIG version >= $1 is required.  You have $swig_version.  You should look at http://www.swig.org])
-                                 SWIG=''
-                         else
-diff --git a/src/Make.vars b/src/Make.vars
-index d70d6aa..93b2879 100644
---- a/src/Make.vars
-+++ b/src/Make.vars
-@@ -53,7 +53,7 @@ AM_LDFLAGS += -export-dynamic
- endif
- 
- # set python runtimefiles to be installed in the same directory as pkg
--pkglib_SCRIPTS = $(NOX_RUNTIMEFILES) $(NOX_PYBUILDFILES)
-+pkgdata_SCRIPTS = $(NOX_RUNTIMEFILES) $(NOX_PYBUILDFILES)
- BUILT_SOURCES  = $(NOX_PYBUILDFILES)
- 
- # Runtime-files build and clean rules
-diff --git a/src/nox/coreapps/pyrt/deferredcallback.cc b/src/nox/coreapps/pyrt/deferredcallback.cc
-index 3a40fa7..111a586 100644
---- a/src/nox/coreapps/pyrt/deferredcallback.cc
-+++ b/src/nox/coreapps/pyrt/deferredcallback.cc
-@@ -69,7 +69,7 @@ DeferredCallback::get_instance(const Callback& c)
-     DeferredCallback* cb = new DeferredCallback(c);
- 
-     // flag as used in *_wrap.cc....correct?
--    return SWIG_Python_NewPointerObj(cb, s, SWIG_POINTER_OWN | 0);
-+    return SWIG_Python_NewPointerObj(m, cb, s, SWIG_POINTER_OWN | 0);
- }
- 
- bool
-diff --git a/src/nox/coreapps/pyrt/pyglue.cc b/src/nox/coreapps/pyrt/pyglue.cc
-index 48b9716..317fd04 100644
---- a/src/nox/coreapps/pyrt/pyglue.cc
-+++ b/src/nox/coreapps/pyrt/pyglue.cc
-@@ -874,7 +874,7 @@ to_python(const Flow& flow)
-     if (!s) {
-         throw std::runtime_error("Could not find Flow SWIG type_info");
-     }
--    return SWIG_Python_NewPointerObj(f, s, SWIG_POINTER_OWN | 0);
-+    return SWIG_Python_NewPointerObj(m, f, s, SWIG_POINTER_OWN | 0);
- 
- //     PyObject* dict = PyDict_New();
- //     if (!dict) {
-diff --git a/src/nox/coreapps/pyrt/pyrt.cc b/src/nox/coreapps/pyrt/pyrt.cc
-index fbda461..8ec05d6 100644
---- a/src/nox/coreapps/pyrt/pyrt.cc
-+++ b/src/nox/coreapps/pyrt/pyrt.cc
-@@ -776,7 +776,7 @@ Python_event_manager::create_python_context(const Context* ctxt,
-                             pretty_print_python_exception());
-     }
- 
--    PyObject* pyctxt = SWIG_Python_NewPointerObj(p, s, 0);
-+    PyObject* pyctxt = SWIG_Python_NewPointerObj(m, p, s, 0);
-     Py_INCREF(pyctxt); // XXX needed?
- 
-     //Py_DECREF(m);
-diff --git a/src/nox/netapps/authenticator/auth.i b/src/nox/netapps/authenticator/auth.i
-index 1de1a17..bfa04e2 100644
---- a/src/nox/netapps/authenticator/auth.i
-+++ b/src/nox/netapps/authenticator/auth.i
-@@ -18,6 +18,8 @@
- 
- %module "nox.netapps.authenticator.pyauth"
- 
-+// Hack to get it to compile -BL
-+%include "std_list.i"
- %{
- #include "core_events.hh"
- #include "pyrt/pycontext.hh"
-diff --git a/src/nox/netapps/authenticator/flow_util.i b/src/nox/netapps/authenticator/flow_util.i
-index f67c3ef..2a314e2 100644
---- a/src/nox/netapps/authenticator/flow_util.i
-+++ b/src/nox/netapps/authenticator/flow_util.i
-@@ -32,6 +32,7 @@ using namespace vigil::applications;
- %}
- 
- %include "common-defs.i"
-+%include "std_list.i"
- 
- %import "netinet/netinet.i"
- %import "pyrt/event.i"
-diff --git a/src/nox/netapps/routing/routing.i b/src/nox/netapps/routing/routing.i
-index 44ccb3d..f9221a2 100644
---- a/src/nox/netapps/routing/routing.i
-+++ b/src/nox/netapps/routing/routing.i
-@@ -17,6 +17,8 @@
-  */
- %module "nox.netapps.routing.pyrouting"
- 
-+// Hack to get it to compile -BL
-+%include "std_list.i"
- %{
- #include "pyrouting.hh"
- #include "routing.hh"
-diff --git a/src/nox/netapps/switch_management/pyswitch_management.i b/src/nox/netapps/switch_management/pyswitch_management.i
-index 72bfed4..ad2c90d 100644
---- a/src/nox/netapps/switch_management/pyswitch_management.i
-+++ b/src/nox/netapps/switch_management/pyswitch_management.i
-@@ -18,6 +18,8 @@
- 
- %module "nox.netapps.pyswitch_management"
- 
-+// Hack to get it to compile -BL
-+%include "std_list.i"
- %{
- #include "switch_management_proxy.hh"
- #include "pyrt/pycontext.hh"
-diff --git a/src/nox/netapps/tests/tests.cc b/src/nox/netapps/tests/tests.cc
-index 20e900d..f027028 100644
---- a/src/nox/netapps/tests/tests.cc
-+++ b/src/nox/netapps/tests/tests.cc
-@@ -306,7 +306,7 @@ private:
-             throw runtime_error("Could not find PyContext SWIG type_info.");
-         }
-         
--        PyObject* pyctxt = SWIG_Python_NewPointerObj(p, s, 0);
-+        PyObject* pyctxt = SWIG_Python_NewPointerObj(m, p, s, 0);
-         assert(pyctxt);
- 
-         Py_DECREF(m);
-diff --git a/src/nox/netapps/topology/pytopology.i b/src/nox/netapps/topology/pytopology.i
-index 94a9f4b..7a8cd94 100644
---- a/src/nox/netapps/topology/pytopology.i
-+++ b/src/nox/netapps/topology/pytopology.i
-@@ -18,6 +18,8 @@
- 
- %module "nox.netapps.topology"
- 
-+// Hack to get it to compile -BL
-+%include "std_list.i"
- %{
- #include "pytopology.hh"
- #include "pyrt/pycontext.hh"
--- 
-1.7.5.4
-

util/nox-patches/README

@@ -1,2 +1 @@
-0001: This patch adds the OpenFlow tutorial module source code to nox-destiny.
-0002: This patch hacks nox-destiny to compile on Ubuntu 12.04.
+This patch adds the OpenFlow tutorial module source code to nox-destiny.

util/sch_htb-ofbuf/Makefile

@@ -1,11 +0,0 @@
-obj-m = sch_htb.o
-KVERSION = $(shell uname -r)
-all:
-	        make -C /lib/modules/$(KVERSION)/build M=$(PWD) modules
-install:
-		test -e /lib/modules/$(KVERSION)/kernel/net/sched/sch_htb.ko.bak || mv /lib/modules/$(KVERSION)/kernel/net/sched/sch_htb.ko /lib/modules/$(KVERSION)/kernel/net/sched/sch_htb.ko.bak
-		cp sch_htb.ko /lib/modules/$(KVERSION)/kernel/net/sched/sch_htb.ko
-		rmmod sch_htb
-		modprobe sch_htb
-clean:
-	        make -C /lib/modules/$(KVERSION)/build M=$(PWD) clean

util/sch_htb-ofbuf/README

@@ -1,10 +0,0 @@
-Modified sch_htb implementation with ofbuf support.
-
-To compile, just type make.  To use this module instead
-of regular sch_htb, do:
-
-0. make
-1. rmmod sch_htb
-2. insmod ./sch_htb.ko
-
-To revert, just rmmod sch_htb.

util/vm/install-mininet-vm.sh

@@ -1,36 +0,0 @@
-#!/bin/bash
-
-# This script is intended to install Mininet into
-# a brand-new Ubuntu (10.04 or 11.10) virtual machine,
-# to create a fully usable "tutorial" VM.
-
-set -e
-sudo sh -c 'cat >> /etc/sudoers' <<EOF
-openflow ALL=NOPASSWD: ALL
-EOF
-sudo sed -i -e 's/Default/#Default/' /etc/sudoers
-sudo sed -i -e 's/ubuntu/mininet-vm/' /etc/hostname
-sudo sed -i -e 's/ubuntu/mininet-vm/g' /etc/hosts
-sudo hostname `cat /etc/hostname`
-sudo sed -i -e 's/quiet splash/text/' /etc/default/grub
-sudo update-grub
-sudo sed -i -e 's/us.archive.ubuntu.com/mirrors.kernel.org/' \
-	/etc/apt/sources.list
-sudo apt-get update
-sudo apt-get -y install git-core openssh-server
-git clone git://github.com/mininet/mininet
-cd mininet
-# Check out branch for cs244
-git checkout -b cs244 origin/class/cs244
-cd
-time mininet/util/install.sh
-if ! grep NOX_CORE_DIR .bashrc; then
-  echo "export NOX_CORE_DIR=~/noxcore/build/src/" >> .bashrc
-fi
-echo <<EOF
-You may need to reboot and then:
-sudo dpkg-reconfigure openvswitch-datapath-dkms
-sudo service openvswitch-switch start
-EOF
-
-