use isinstance( intf, OVSIntf )

CONTRIBUTORS

@@ -29,16 +29,14 @@ Andrew Ferguson
 Eder Leao Fernandes
 Gregory Gee
 Jon Hall
-Roan Huang
 Vitaly Ivanov
-Babis Kaidos
 Rich Lane
-Rémy Léone
 Zi Shen Lim
-David Mahler
 Murphy McCauley
 José Pedro Oliveira
 James Page
+Rich Lane
+Rémy Léone
 Angad Singh
 Piyush Srivastava
 Ed Swierk

INSTALL

@@ -2,7 +2,7 @@
 Mininet Installation/Configuration Notes
 ----------------------------------------
 
-Mininet 2.2.1
+Mininet 2.2.0
 ---
 
 The supported installation methods for Mininet are 1) using a

LICENSE

@@ -1,6 +1,6 @@
-Mininet 2.2.1 License
+Mininet 2.2.0 License
 
-Copyright (c) 2013-2015 Open Networking Laboratory
+Copyright (c) 2013-2014 Open Networking Laboratory
 Copyright (c) 2009-2012 Bob Lantz and The Board of Trustees of
 The Leland Stanford Junior University
 

README.md

@@ -3,7 +3,7 @@ Mininet: Rapid Prototyping for Software Defined Networks
 
 *The best way to emulate almost any network on your laptop!*
 
-Mininet 2.2.1
+Mininet 2.2.0
 
 ### What is Mininet?
 
@@ -68,25 +68,44 @@ Mininet includes:
 
 ### New features in this release
 
-This is primarily a performance improvement and bug fix release.
+This release provides a number of bug fixes as well as
+several new features, including:
 
-- Batch startup has been implemented for Open vSwitch, improving
-  startup performance.
+* Improved OpenFlow 1.3 support
 
-- OVS patch links have been implemented via OVSLink and --link ovs
+	- `mn --switch ovs,protocols=openflow13` starts OVS in 1.3 mode
+	- `install.sh -w` installs a 1.3-compatible Wireshark dissector using
+	  Loxigen
+	- `install.sh -y` installs the Ryu 1.3-compatible controller
 
-  Warning! These links have *serious limitations* compared to
-  virtual Ethernet pairs: they are not attached to real Linux
-  interfaces so you cannot use tcpdump or wireshark with them;
-  they also cannot be used in long chains - we don't recommend more
-  than 64 OVSLinks, for example --linear,64. However, they can offer
-  significantly better performance than veth pairs, for certain
-  configurations.
+* A new `nodelib.py` node library, and new `Node` types including
+  `LinuxBridge`, `OVSBridge`, `LinuxRouter` (see `examples/`)
+  and `NAT`
 
-- You can now easily install Mininet on a Raspberry Pi ;-)
+* A `--nat` option which connects a Mininet network to your LAN using NAT
+  (For this to work correctly, Mininet's `--ipbase` subnet should not 
+  overlap with any external or internet IP addresses you wish to use)
 
-- Additional information for this release and previous releases
-  may be found in the release notes on docs.mininet.org
+* An improved MiniEdit GUI (`examples/miniedit.py`) - thanks to
+  Gregory Gee
+
+* Support for multiple `--custom` arguments to `mn`
+
+* Experimental cluster support - consult the 
+  [documentation](http://docs.mininet.org) for details -
+  as well as `examples/cluster.py` and an experimental `--cluster`
+  option for topologies built with the default `Host` and `OVSSwitch`
+  classes:
+
+  `mn --cluster localhost,server1,server2`
+
+Note that examples contain experimental features which might
+"graduate" into mainline Mininet in the future, but they should 
+not be considered a stable part of the Mininet API!
+
+A number of bugs have also been fixed, most notably multiple link
+support in `Topo()`. See github issues and the release notes on
+the Mininet wiki for additional information.
 
 ### Installation
 
@@ -110,8 +129,6 @@ Mininet mailing list, `mininet-discuss` at:
 
 ### Join Us
 
-Thanks again to all of the Mininet contributors!
-
 Mininet is an open source project and is currently hosted
 at <https://github.com/mininet>.  You are encouraged to download
 the code, examine it, modify it, and submit bug reports, bug fixes,
@@ -125,5 +142,12 @@ hard work that Mininet continues to grow and improve.
 Best wishes, and we look forward to seeing what you can do with
 Mininet to change the networking world!
 
-Bob Lantz
-Mininet Core Team
+The Mininet Core Team:
+
+* Bob Lantz
+* Brian O'Connor
+* Cody Burkard
+
+Thanks again to all of the Mininet contributors, particularly Gregory
+Gee for his work on MiniEdit.
+

bin/mn

@@ -25,16 +25,15 @@ from mininet.cli import CLI
 from mininet.log import lg, LEVELS, info, debug, warn, error
 from mininet.net import Mininet, MininetWithControlNet, VERSION
 from mininet.node import ( Host, CPULimitedHost, Controller, OVSController,
-                           Ryu, NOX, RemoteController, findController,
-                           DefaultController, NullController,
+                           RYU, NOX, RemoteController, findController,
+                           DefaultController,
                            UserSwitch, OVSSwitch, OVSBridge,
-                           IVSSwitch )
+                           OVSLegacyKernelSwitch, IVSSwitch )
 from mininet.nodelib import LinuxBridge
 from mininet.link import Link, TCLink, OVSLink
-from mininet.topo import ( SingleSwitchTopo, LinearTopo,
-                           SingleSwitchReversedTopo, MinimalTopo )
+from mininet.topo import SingleSwitchTopo, LinearTopo, SingleSwitchReversedTopo
 from mininet.topolib import TreeTopo, TorusTopo
-from mininet.util import customClass, specialClass, splitArgs
+from mininet.util import customConstructor, splitArgs
 from mininet.util import buildTopo
 
 from functools import partial
@@ -42,15 +41,14 @@ from functools import partial
 # Experimental! cluster edition prototype
 from mininet.examples.cluster import ( MininetCluster, RemoteHost,
                                        RemoteOVSSwitch, RemoteLink,
-                                       SwitchBinPlacer, RandomPlacer,
-                                       ClusterCleanup )
+                                       SwitchBinPlacer, RandomPlacer )
 from mininet.examples.clustercli import ClusterCLI
 
 PLACEMENT = { 'block': SwitchBinPlacer, 'random': RandomPlacer }
 
 # built in topologies, created only when run
 TOPODEF = 'minimal'
-TOPOS = { 'minimal': MinimalTopo,
+TOPOS = { 'minimal': lambda: SingleSwitchTopo( k=2 ),
           'linear': LinearTopo,
           'reversed': SingleSwitchReversedTopo,
           'single': SingleSwitchTopo,
@@ -63,24 +61,24 @@ SWITCHES = { 'user': UserSwitch,
              'ovsbr' : OVSBridge,
              # Keep ovsk for compatibility with 2.0
              'ovsk': OVSSwitch,
+             'ovsl': OVSLegacyKernelSwitch,
              'ivs': IVSSwitch,
              'lxbr': LinuxBridge,
              'default': OVSSwitch }
 
 HOSTDEF = 'proc'
 HOSTS = { 'proc': Host,
-          'rt': specialClass( CPULimitedHost, defaults=dict( sched='rt' ) ),
-          'cfs': specialClass( CPULimitedHost, defaults=dict( sched='cfs' ) ) }
+          'rt': partial( CPULimitedHost, sched='rt' ),
+          'cfs': partial( CPULimitedHost, sched='cfs' ) }
 
 CONTROLLERDEF = 'default'
-
 CONTROLLERS = { 'ref': Controller,
                 'ovsc': OVSController,
                 'nox': NOX,
                 'remote': RemoteController,
-                'ryu': Ryu,
+                'ryu': RYU,
                 'default': DefaultController,  # Note: replaced below
-                'none': NullController }
+                'none': lambda name: None }
 
 LINKDEF = 'default'
 LINKS = { 'default': Link,
@@ -98,21 +96,24 @@ ALTSPELLING = { 'pingall': 'pingAll',
                 'iperfUDP': 'iperfUdp' }
 
 
-def addDictOption( opts, choicesDict, default, name, **kwargs ):
+def addDictOption( opts, choicesDict, default, name, helpStr=None ):
     """Convenience function to add choices dicts to OptionParser.
        opts: OptionParser instance
        choicesDict: dictionary of valid choices, must include default
        default: default choice key
        name: long option name
-       kwargs: additional arguments to add_option"""
-    helpStr = ( '|'.join( sorted( choicesDict.keys() ) ) +
-                '[,param=value...]' )
-    helpList = [ '%s=%s' % ( k, v.__name__ )
-                 for k, v in choicesDict.items() ]
-    helpStr += ' ' + ( ' '.join( helpList ) )
-    params = dict( type='string', default=default, help=helpStr )
-    params.update( **kwargs )
-    opts.add_option( '--' + name, **params )
+       help: string"""
+    if default not in choicesDict:
+        raise Exception( 'Invalid  default %s for choices dict: %s' %
+                         ( default, name ) )
+    if not helpStr:
+        helpStr = ( '|'.join( sorted( choicesDict.keys() ) ) +
+                    '[,param=value...]' )
+    opts.add_option( '--' + name,
+                     type='string',
+                     default = default,
+                     help = helpStr )
+
 
 def version( *_args ):
     "Print Mininet version and exit"
@@ -197,7 +198,7 @@ class MininetRunner( object ):
         opts = OptionParser( description=desc, usage=usage )
         addDictOption( opts, SWITCHES, SWITCHDEF, 'switch' )
         addDictOption( opts, HOSTS, HOSTDEF, 'host' )
-        addDictOption( opts, CONTROLLERS, [], 'controller', action='append' )
+        addDictOption( opts, CONTROLLERS, CONTROLLERDEF, 'controller' )
         addDictOption( opts, LINKS, LINKDEF, 'link' )
         addDictOption( opts, TOPOS, TOPODEF, 'topo' )
 
@@ -280,39 +281,34 @@ class MininetRunner( object ):
     def begin( self ):
         "Create and run mininet."
 
-        if self.options.cluster:
-            servers = self.options.cluster.split( ',' )
-            for server in servers:
-                ClusterCleanup.add( server )
-
         if self.options.clean:
             cleanup()
             exit()
 
         start = time.time()
 
-        if not self.options.controller:
+        if self.options.controller == 'default':
             # Update default based on available controllers
             CONTROLLERS[ 'default' ] = findController()
-            self.options.controller = [ 'default' ]
-            if not CONTROLLERS[ 'default' ]:
-                self.options.controller = [ 'none' ]
+            if CONTROLLERS[ 'default' ] is None:
                 if self.options.switch == 'default':
                     info( '*** No default OpenFlow controller found '
                           'for default switch!\n' )
                     info( '*** Falling back to OVS Bridge\n' )
                     self.options.switch = 'ovsbr'
-                elif self.options.switch not in ( 'ovsbr', 'lxbr' ):
+                    self.options.controller = 'none'
+                elif self.options.switch in ( 'ovsbr', 'lxbr' ):
+                    self.options.controller = 'none'
+                else:
                     raise Exception( "Could not find a default controller "
                                      "for switch %s" %
                                      self.options.switch )
 
         topo = buildTopo( TOPOS, self.options.topo )
-        switch = customClass( SWITCHES, self.options.switch )
-        host = customClass( HOSTS, self.options.host )
-        controller = [ customClass( CONTROLLERS, c )
-                       for c in self.options.controller ]
-        link = customClass( LINKS, self.options.link )
+        switch = customConstructor( SWITCHES, self.options.switch )
+        host = customConstructor( HOSTS, self.options.host )
+        controller = customConstructor( CONTROLLERS, self.options.controller )
+        link = customConstructor( LINKS, self.options.link )
 
         if self.validate:
             self.validate( self.options )
@@ -338,7 +334,7 @@ class MininetRunner( object ):
             warn( '*** WARNING: Experimental cluster mode!\n'
                   '*** Using RemoteHost, RemoteOVSSwitch, RemoteLink\n' )
             host, switch, link = RemoteHost, RemoteOVSSwitch, RemoteLink
-            Net = partial( MininetCluster, servers=servers,
+            Net = partial( MininetCluster, servers=cluster.split( ',' ),
                            placement=PLACEMENT[ self.options.placement ] )
 
         mn = Net( topo=topo,

examples/cluster.py

@@ -79,10 +79,9 @@ from mininet.link import Link, Intf
 from mininet.net import Mininet
 from mininet.topo import LinearTopo
 from mininet.topolib import TreeTopo
-from mininet.util import quietRun, errRun
+from mininet.util import quietRun, makeIntfPair, errRun, retry
 from mininet.examples.clustercli import CLI
 from mininet.log import setLogLevel, debug, info, error
-from mininet.clean import addCleanupCallback
 
 from signal import signal, SIGINT, SIG_IGN
 from subprocess import Popen, PIPE, STDOUT
@@ -90,51 +89,9 @@ import os
 from random import randrange
 import sys
 import re
-from itertools import groupby
-from operator import attrgetter
+
 from distutils.version import StrictVersion
 
-
-def findUser():
-    "Try to return logged-in (usually non-root) user"
-    return (
-            # If we're running sudo
-            os.environ.get( 'SUDO_USER', False ) or
-            # Logged-in user (if we have a tty)
-            ( quietRun( 'who am i' ).split() or [ False ] )[ 0 ] or
-            # Give up and return effective user
-            quietRun( 'whoami' ) )
-
-
-class ClusterCleanup( object ):
-    "Cleanup callback"
-
-    inited = False
-    serveruser = {}
-
-    @classmethod
-    def add( cls, server, user='' ):
-        "Add an entry to server: user dict"
-        if not cls.inited:
-            addCleanupCallback( cls.cleanup )
-        if not user:
-            user = findUser()
-        cls.serveruser[ server ] = user
-
-    @classmethod
-    def cleanup( cls ):
-        "Clean up"
-        info( '*** Cleaning up cluster\n' )
-        for server, user in cls.serveruser.iteritems():
-            if server == 'localhost':
-                # Handled by mininet.clean.cleanup()
-                continue
-            else:
-                cmd = [ 'su', user, '-c',
-                        'ssh %s@%s sudo mn -c' % ( user, server ) ]
-                info( cmd, '\n' )
-                info( quietRun( cmd ) )
-
 # BL note: so little code is required for remote nodes,
 # we will probably just want to update the main Node()
 # class to enable it for remote access! However, there
@@ -168,8 +125,7 @@ class RemoteMixin( object ):
         self.server = server if server else 'localhost'
         self.serverIP = ( serverIP if serverIP
                           else self.findServerIP( self.server ) )
-        self.user = user if user else findUser()
-        ClusterCleanup.add( server=server, user=user )
+        self.user = user if user else self.findUser()
         if controlPath is True:
             # Set a default control path for shared SSH connections
             controlPath = '/tmp/mn-%r@%h:%p'
@@ -182,7 +138,7 @@ class RemoteMixin( object ):
                 self.sshcmd += [ '-o', 'ControlPath=' + self.controlPath,
                                  '-o', 'ControlMaster=auto',
                                  '-o', 'ControlPersist=' + '1' ]
-            self.sshcmd += [ self.dest ]
+            self.sshcmd = self.sshcmd + [ self.dest ]
             self.isRemote = True
         else:
             self.dest = None
@@ -192,6 +148,17 @@ class RemoteMixin( object ):
         self.shell, self.pid = None, None
         super( RemoteMixin, self ).__init__( name, **kwargs )
 
+    @staticmethod
+    def findUser():
+        "Try to return logged-in (usually non-root) user"
+        return (
+            # If we're running sudo
+            os.environ.get( 'SUDO_USER', False ) or
+            # Logged-in user (if we have a tty)
+            ( quietRun( 'who am i' ).split() or [ False ] )[ 0 ] or
+            # Give up and return effective user
+            quietRun( 'whoami' ) )
+
     # Determine IP address of local host
     _ipMatchRegex = re.compile( r'\d+\.\d+\.\d+\.\d+' )
 
@@ -277,7 +244,7 @@ class RemoteMixin( object ):
                 # Drop privileges
                 cmd = [ 'sudo', '-E', '-u', self.user ] + cmd
         params.update( preexec_fn=self._ignoreSignal )
-        debug( '_popen', cmd, '\n' )
+        debug( '_popen', ' '.join(cmd), params )
         popen = super( RemoteMixin, self )._popen( cmd, **params )
         return popen
 
@@ -287,9 +254,18 @@ class RemoteMixin( object ):
 
     def addIntf( self, *args, **kwargs ):
         "Override: use RemoteLink.moveIntf"
-        kwargs.update( moveIntfFn=RemoteLink.moveIntf )
-        return super( RemoteMixin, self).addIntf( *args, **kwargs )
+        return super( RemoteMixin,
+                      self).addIntf( *args,
+                                     moveIntfFn=RemoteLink.moveIntf,
+                                     **kwargs )
 
+    def cleanup( self ):
+        "Help python collect its garbage."
+        # Intfs may end up in root NS
+        for intfName in self.intfNames():
+            if self.name in intfName:
+                self.rcmd( 'ip link del ' + intfName )
+        self.shell = None
 
 class RemoteNode( RemoteMixin, Node ):
     "A node on a remote server"
@@ -306,11 +282,6 @@ class RemoteOVSSwitch( RemoteMixin, OVSSwitch ):
 
     OVSVersions = {}
 
-    def __init__( self, *args, **kwargs ):
-        # No batch startup yet
-        kwargs.update( batch=True )
-        super( RemoteOVSSwitch, self ).__init__( *args, **kwargs )
-
     def isOldOVS( self ):
         "Is remote switch using an old OVS version?"
         cls = type( self )
@@ -323,28 +294,6 @@ class RemoteOVSSwitch( RemoteMixin, OVSSwitch ):
         return ( StrictVersion( cls.OVSVersions[ self.server ] ) <
                  StrictVersion( '1.10' ) )
 
-    @classmethod
-    def batchStartup( cls, switches, **_kwargs ):
-        "Start up switches in per-server batches"
-        key = attrgetter( 'server' )
-        for server, switchGroup in groupby( sorted( switches, key=key ), key ):
-            info( '(%s)' % server )
-            group = tuple( switchGroup )
-            switch = group[ 0 ]
-            OVSSwitch.batchStartup( group, run=switch.cmd )
-        return switches
-
-    @classmethod
-    def batchShutdown( cls, switches, **_kwargs ):
-        "Stop switches in per-server batches"
-        key = attrgetter( 'server' )
-        for server, switchGroup in groupby( sorted( switches, key=key ), key ):
-            info( '(%s)' % server )
-            group = tuple( switchGroup )
-            switch = group[ 0 ]
-            OVSSwitch.batchShutdown( group, run=switch.rcmd )
-        return switches
-
 
 class RemoteLink( Link ):
     "A RemoteLink is a link between nodes which may be on different servers"
@@ -365,27 +314,24 @@ class RemoteLink( Link ):
         "Stop this link"
         if self.tunnel:
             self.tunnel.terminate()
-            self.intf1.delete()
-            self.intf2.delete()
-        else:
-            Link.stop( self )
         self.tunnel = None
 
-    def makeIntfPair( self, intfname1, intfname2, addr1=None, addr2=None,
-                      node1=None, node2=None, deleteIntfs=True   ):
+    def makeIntfPair( self, intfname1, intfname2, addr1=None, addr2=None ):
         """Create pair of interfaces
             intfname1: name of interface 1
             intfname2: name of interface 2
             (override this method [and possibly delete()]
             to change link type)"""
-        node1 = self.node1 if node1 is None else node1
-        node2 = self.node2 if node2 is None else node2
+        node1, node2 = self.node1, self.node2
         server1 = getattr( node1, 'server', 'localhost' )
         server2 = getattr( node2, 'server', 'localhost' )
-        if server1 == server2:
-            # Link within same server
-            return Link.makeIntfPair( intfname1, intfname2, addr1, addr2,
-                                      node1, node2, deleteIntfs=deleteIntfs )
+        if server1 == 'localhost' and server2 == 'localhost':
+            # Local link
+            return makeIntfPair( intfname1, intfname2, addr1, addr2 )
+        elif server1 == server2:
+            # Remote link on same remote server
+            return makeIntfPair( intfname1, intfname2, addr1, addr2,
+                                 runCmd=node1.rcmd )
         # Otherwise, make a tunnel
         self.tunnel = self.makeTunnel( node1, node2, intfname1, intfname2,
                                        addr1, addr2 )
@@ -422,11 +368,12 @@ class RemoteLink( Link ):
         # 1. Create tap interfaces
         for node in node1, node2:
             # For now we are hard-wiring tap9, which we will rename
+            node.rcmd( 'ip link delete tap9', stderr=PIPE )
             cmd = 'ip tuntap add dev tap9 mode tap user ' + node.user
-            result = node.rcmd( cmd )
-            if result:
-                raise Exception( 'error creating tap9 on %s: %s' %
-                                 ( node, result ) )
+            node.rcmd( cmd )
+            links = node.rcmd( 'ip link show' )
+            # print 'after add, links =', links
+            assert 'tap9' in links
         # 2. Create ssh tunnel between tap interfaces
         # -n: close stdin
         dest = '%s@%s' % ( node2.user, node2.serverIP )
@@ -439,25 +386,29 @@ class RemoteLink( Link ):
         debug( 'Waiting for tunnel to come up...\n' )
         ch = tunnel.stdout.read( 1 )
         if ch != '@':
-            raise Exception( 'makeTunnel:\n',
-                             'Tunnel setup failed for',
-                             '%s:%s' % ( node1, node1.dest ), 'to',
-                             '%s:%s\n' % ( node2, node2.dest ),
-                             'command was:', cmd, '\n' )
+            error( 'makeTunnel:\n',
+                   'Tunnel setup failed for',
+                   '%s:%s' % ( node1, node1.dest ), 'to',
+                   '%s:%s\n' % ( node2, node2.dest ),
+                   'command was:', cmd, '\n' )
+            tunnel.terminate()
+            tunnel.wait()
+            error( ch + tunnel.stdout.read() )
+            error( tunnel.stderr.read() )
+            sys.exit( 1 )
         # 3. Move interfaces if necessary
         for node in node1, node2:
-            if not self.moveIntf( 'tap9', node ):
-                raise Exception( 'interface move failed on node %s' % node )
+            if node.inNamespace:
+                retry( 3, .01, RemoteLink.moveIntf, 'tap9', node )
         # 4. Rename tap interfaces to desired names
         for node, intf, addr in ( ( node1, intfname1, addr1 ),
                                   ( node2, intfname2, addr2 ) ):
             if not addr:
-                result = node.cmd( 'ip link set tap9 name', intf )
+                node.cmd( 'ip link set tap9 name', intf )
             else:
-                result = node.cmd( 'ip link set tap9 name', intf,
-                                   'address', addr )
-            if result:
-                raise Exception( 'error renaming %s: %s' % ( intf, result ) )
+                node.cmd( 'ip link set tap9 name', intf, 'address', addr )
+        for node, intf in ( ( node1, intfname1 ), ( node2, intfname2 ) ):
+            assert intf in node.cmd( 'ip link show' )
         return tunnel
 
     def status( self ):
@@ -673,7 +624,7 @@ class MininetCluster( Mininet ):
         if not self.serverIP:
             self.serverIP = { server: RemoteMixin.findServerIP( server )
                               for server in self.servers }
-        self.user = params.pop( 'user', findUser() )
+        self.user = params.pop( 'user', RemoteMixin.findUser() )
         if params.pop( 'precheck' ):
             self.precheck()
         self.connections = {}

examples/controlnet.py

@@ -27,18 +27,11 @@ from mininet.log import setLogLevel, info
 
 class DataController( Controller ):
     """Data Network Controller.
-       patched to avoid checkListening error and to delete intfs"""
-
+       patched to avoid checkListening error"""
     def checkListening( self ):
         "Ignore spurious error"
         pass
 
-    def stop( self, *args, **kwargs ):
-        "Make sure intfs are deleted"
-        kwargs.update( deleteIntfs=True )
-        super( DataController, self ).stop( *args, **kwargs )
-
-
 class MininetFacade( object ):
     """Mininet object facade that allows a single CLI to
        talk to one or more networks"""

examples/linuxrouter.py

@@ -6,25 +6,20 @@ linuxrouter.py: Example network with Linux IP router
 This example converts a Node into a router using IP forwarding
 already built into Linux.
 
-The example topology creates a router and three IP subnets:
+The topology contains a router with three IP subnets:
+ - 192.168.1.0/24 (interface IP: 192.168.1.1)
+ - 172.16.0.0/12 (interface IP: 172.16.0.1)
+ - 10.0.0.0/8 (interface IP: 10.0.0.1)
 
-    - 192.168.1.0/24 (r0-eth1, IP: 192.168.1.1)
-    - 172.16.0.0/12 (r0-eth2, IP: 172.16.0.1)
-    - 10.0.0.0/8 (r0-eth3, IP: 10.0.0.1)
+ It also contains three hosts, one in each subnet:
+ - h1 (IP: 192.168.1.100)
+ - h2 (IP: 172.16.0.100)
+ - h3 (IP: 10.0.0.100)
 
-Each subnet consists of a single host connected to
-a single switch:
+ Routing entries can be added to the routing tables of the
+ hosts or router using the "ip route add" or "route add" command.
+ See the man pages for more details.
 
-    r0-eth1 - s1-eth1 - h1-eth0 (IP: 192.168.1.100)
-    r0-eth2 - s2-eth1 - h2-eth0 (IP: 172.16.0.100)
-    r0-eth3 - s3-eth1 - h3-eth0 (IP: 10.0.0.100)
-
-The example relies on default routing entries that are
-automatically created for each router interface, as well
-as 'defaultRoute' parameters for the host interfaces.
-
-Additional routes may be added to the router or hosts by
-executing 'ip route' or 'route' commands on the router or hosts.
 """
 
 from mininet.topo import Topo
@@ -47,39 +42,29 @@ class LinuxRouter( Node ):
 
 
 class NetworkTopo( Topo ):
-    "A LinuxRouter connecting three IP subnets"
+    "A simple topology of a router with three subnets (one host in each)."
 
     def build( self, **_opts ):
-
-        defaultIP = '192.168.1.1/24'  # IP address for r0-eth1
-        router = self.addNode( 'r0', cls=LinuxRouter, ip=defaultIP )
-
-        s1, s2, s3 = [ self.addSwitch( s ) for s in 's1', 's2', 's3' ]
-
-        self.addLink( s1, router, intfName2='r0-eth1',
-                      params2={ 'ip' : defaultIP } )  # for clarity
-        self.addLink( s2, router, intfName2='r0-eth2',
-                      params2={ 'ip' : '172.16.0.1/12' } )
-        self.addLink( s3, router, intfName2='r0-eth3',
-                      params2={ 'ip' : '10.0.0.1/8' } )
-
+        router = self.addNode( 'r0', cls=LinuxRouter, ip='192.168.1.1/24' )
         h1 = self.addHost( 'h1', ip='192.168.1.100/24',
                            defaultRoute='via 192.168.1.1' )
         h2 = self.addHost( 'h2', ip='172.16.0.100/12',
                            defaultRoute='via 172.16.0.1' )
         h3 = self.addHost( 'h3', ip='10.0.0.100/8',
                            defaultRoute='via 10.0.0.1' )
-
-        for h, s in [ (h1, s1), (h2, s2), (h3, s3) ]:
-            self.addLink( h, s )
-
+        self.addLink( h1, router, intfName2='r0-eth1',
+                      params2={ 'ip' : '192.168.1.1/24' } )
+        self.addLink( h2, router, intfName2='r0-eth2',
+                      params2={ 'ip' : '172.16.0.1/12' } )
+        self.addLink( h3, router, intfName2='r0-eth3',
+                      params2={ 'ip' : '10.0.0.1/8' } )
 
 def run():
     "Test linux router"
     topo = NetworkTopo()
-    net = Mininet( topo=topo )  # controller is used by s1-s3
+    net = Mininet( topo=topo, controller=None )  # no controller needed
     net.start()
-    info( '*** Routing Table on Router:\n' )
+    info( '*** Routing Table on Router\n' )
     print net[ 'r0' ].cmd( 'route' )
     CLI( net )
     net.stop()

examples/miniedit.py

@@ -49,7 +49,7 @@ from mininet.log import info, setLogLevel
 from mininet.net import Mininet, VERSION
 from mininet.util import netParse, ipAdd, quietRun
 from mininet.util import buildTopo
-from mininet.util import custom, customClass
+from mininet.util import custom, customConstructor
 from mininet.term import makeTerm, cleanUpScreens
 from mininet.node import Controller, RemoteController, NOX, OVSController
 from mininet.node import CPULimitedHost, Host, Node
@@ -3222,7 +3222,7 @@ class MiniEdit( Frame ):
             return
         self.newTopology()
         topo = buildTopo( TOPOS, self.options.topo )
-        link = customClass( LINKS, self.options.link )
+        link = customConstructor( LINKS, self.options.link )
         importNet = Mininet(topo=topo, build=False, link=link)
         importNet.build()
 

examples/sshd.py

@@ -23,6 +23,7 @@ from mininet.cli import CLI
 from mininet.log import lg
 from mininet.node import Node
 from mininet.topolib import TreeTopo
+from mininet.link import Link
 from mininet.util import waitListening
 
 def TreeNet( depth=1, fanout=2, **kwargs ):
@@ -38,7 +39,7 @@ def connectToRootNS( network, switch, ip, routes ):
       routes: host networks to route to"""
     # Create a node in root namespace and link to switch 0
     root = Node( 'root', inNamespace=False )
-    intf = network.addLink( root, switch ).intf1
+    intf = Link( root, switch ).intf1
     root.setIP( ip, intf=intf )
     # Start network that now includes link to root namespace
     network.start()

examples/tree1024.py

@@ -9,10 +9,10 @@ and running sysctl -p. Check util/sysctl_addon.
 
 from mininet.cli import CLI
 from mininet.log import setLogLevel
-from mininet.node import OVSSwitch
+from mininet.node import OVSKernelSwitch
 from mininet.topolib import TreeNet
 
 if __name__ == '__main__':
     setLogLevel( 'info' )
-    network = TreeNet( depth=2, fanout=32, switch=OVSSwitch )
+    network = TreeNet( depth=2, fanout=32, switch=OVSKernelSwitch )
     network.run( CLI, network )

mininet/clean.py

@@ -38,89 +38,60 @@ def killprocs( pattern ):
         else:
             break
 
-class Cleanup( object ):
-    "Wrapper for cleanup()"
+def cleanup():
+    """Clean up junk which might be left over from old runs;
+       do fast stuff before slow dp and link removal!"""
 
-    callbacks = []
+    info("*** Removing excess controllers/ofprotocols/ofdatapaths/pings/noxes"
+         "\n")
+    zombies = 'controller ofprotocol ofdatapath ping nox_core lt-nox_core '
+    zombies += 'ovs-openflowd ovs-controller udpbwtest mnexec ivs'
+    # Note: real zombie processes can't actually be killed, since they
+    # are already (un)dead. Then again,
+    # you can't connect to them either, so they're mostly harmless.
+    # Send SIGTERM first to give processes a chance to shutdown cleanly.
+    sh( 'killall ' + zombies + ' 2> /dev/null' )
+    time.sleep( 1 )
+    sh( 'killall -9 ' + zombies + ' 2> /dev/null' )
 
-    @classmethod
-    def cleanup( cls):
-        """Clean up junk which might be left over from old runs;
-           do fast stuff before slow dp and link removal!"""
+    # And kill off sudo mnexec
+    sh( 'pkill -9 -f "sudo mnexec"')
 
-        info( "*** Removing excess controllers/ofprotocols/ofdatapaths/"
-              "pings/noxes\n" )
-        zombies = 'controller ofprotocol ofdatapath ping nox_core lt-nox_core '
-        zombies += 'ovs-openflowd ovs-controller udpbwtest mnexec ivs'
-        # Note: real zombie processes can't actually be killed, since they
-        # are already (un)dead. Then again,
-        # you can't connect to them either, so they're mostly harmless.
-        # Send SIGTERM first to give processes a chance to shutdown cleanly.
-        sh( 'killall ' + zombies + ' 2> /dev/null' )
-        time.sleep( 1 )
-        sh( 'killall -9 ' + zombies + ' 2> /dev/null' )
+    info( "*** Removing junk from /tmp\n" )
+    sh( 'rm -f /tmp/vconn* /tmp/vlogs* /tmp/*.out /tmp/*.log' )
 
-        # And kill off sudo mnexec
-        sh( 'pkill -9 -f "sudo mnexec"')
+    info( "*** Removing old X11 tunnels\n" )
+    cleanUpScreens()
 
-        info( "*** Removing junk from /tmp\n" )
-        sh( 'rm -f /tmp/vconn* /tmp/vlogs* /tmp/*.out /tmp/*.log' )
+    info( "*** Removing excess kernel datapaths\n" )
+    dps = sh( "ps ax | egrep -o 'dp[0-9]+' | sed 's/dp/nl:/'" ).splitlines()
+    for dp in dps:
+        if dp:
+            sh( 'dpctl deldp ' + dp )
 
-        info( "*** Removing old X11 tunnels\n" )
-        cleanUpScreens()
+    info( "***  Removing OVS datapaths" )
+    dps = sh("ovs-vsctl --timeout=1 list-br").strip().splitlines()
+    if dps:
+        sh( "ovs-vsctl " + " -- ".join( "--if-exists del-br " + dp
+                                        for dp in dps if dp ) )
+    # And in case the above didn't work...
+    dps = sh("ovs-vsctl --timeout=1 list-br").strip().splitlines()
+    for dp in dps:
+        sh( 'ovs-vsctl del-br ' + dp )
 
-        info( "*** Removing excess kernel datapaths\n" )
-        dps = sh( "ps ax | egrep -o 'dp[0-9]+' | sed 's/dp/nl:/'"
-                  ).splitlines()
-        for dp in dps:
-            if dp:
-                sh( 'dpctl deldp ' + dp )
+    info( "*** Removing all links of the pattern foo-ethX\n" )
+    links = sh( "ip link show | "
+                "egrep -o '([-_.[:alnum:]]+-eth[[:digit:]]+)'" ).splitlines()
+    for link in links:
+        if link:
+            sh( "ip link del " + link )
 
-        info( "***  Removing OVS datapaths\n" )
-        dps = sh("ovs-vsctl --timeout=1 list-br").strip().splitlines()
-        if dps:
-            sh( "ovs-vsctl " + " -- ".join( "--if-exists del-br " + dp
-                                            for dp in dps if dp ) )
-        # And in case the above didn't work...
-        dps = sh( "ovs-vsctl --timeout=1 list-br" ).strip().splitlines()
-        for dp in dps:
-            sh( 'ovs-vsctl del-br ' + dp )
+    info( "*** Killing stale mininet node processes\n" )
+    killprocs( 'mininet:' )
 
-        info( "*** Removing all links of the pattern foo-ethX\n" )
-        links = sh( "ip link show | "
-                    "egrep -o '([-_.[:alnum:]]+-eth[[:digit:]]+)'"
-                    ).splitlines()
-        # Delete blocks of links
-        n = 1000  # chunk size
-        for i in xrange( 0, len( links ), n ):
-            cmd = ';'.join( 'ip link del %s' % link
-                             for link in links[ i : i + n ] )
-            sh( '( %s ) 2> /dev/null' % cmd )
+    info( "*** Shutting down stale tunnels\n" )
+    killprocs( 'Tunnel=Ethernet' )
+    killprocs( '.ssh/mn')
+    sh( 'rm -f ~/.ssh/mn/*' )
 
-        if 'tap9' in sh( 'ip link show' ):
-            info( "*** Removing tap9 - assuming it's from cluster edition\n" )
-            sh( 'ip link del tap9' )
-
-        info( "*** Killing stale mininet node processes\n" )
-        killprocs( 'mininet:' )
-
-        info( "*** Shutting down stale tunnels\n" )
-        killprocs( 'Tunnel=Ethernet' )
-        killprocs( '.ssh/mn')
-        sh( 'rm -f ~/.ssh/mn/*' )
-
-        # Call any additional cleanup code if necessary
-        for callback in cls.callbacks:
-            callback()
-
-        info( "*** Cleanup complete.\n" )
-
-    @classmethod
-    def addCleanupCallback( cls, callback ):
-        "Add cleanup callback"
-        if callback not in cls.callbacks:
-            cls.callbacks.append( callback )
-
-
-cleanup = Cleanup.cleanup
-addCleanupCallback = Cleanup.addCleanupCallback
+    info( "*** Cleanup complete.\n" )

mininet/cli.py

@@ -45,10 +45,6 @@ class CLI( Cmd ):
     prompt = 'mininet> '
 
     def __init__( self, mininet, stdin=sys.stdin, script=None ):
-        """Start and run interactive or batch mode CLI
-           mininet: Mininet network object
-           stdin: standard input for CLI
-           script: script to run in batch mode"""
         self.mn = mininet
         # Local variable bindings for py command
         self.locals = { 'net': mininet }
@@ -60,54 +56,33 @@ class CLI( Cmd ):
         Cmd.__init__( self )
         info( '*** Starting CLI:\n' )
 
-        if self.inputFile:
-            self.do_source( self.inputFile )
-            return
-
-        self.initReadline()
-        self.run()
-
-    readlineInited = False
-
-    @classmethod
-    def initReadline( cls ):
-        "Set up history if readline is available"
-        # Only set up readline once to prevent multiplying the history file
-        if cls.readlineInited:
-            return
-        cls.readlineInited = True
+        # Set up history if readline is available
         try:
-            from readline import read_history_file, write_history_file
+            import readline
         except ImportError:
             pass
         else:
-            history_path = os.path.expanduser( '~/.mininet_history' )
-            if os.path.isfile( history_path ):
-                read_history_file( history_path )
-            atexit.register( lambda: write_history_file( history_path ) )
+            history_path = os.path.expanduser('~/.mininet_history')
+            if os.path.isfile(history_path):
+                readline.read_history_file(history_path)
+            atexit.register(lambda: readline.write_history_file(history_path))
 
-    def run( self ):
-        "Run our cmdloop(), catching KeyboardInterrupt"
+        if self.inputFile:
+            self.do_source( self.inputFile )
+            return
         while True:
             try:
                 # Make sure no nodes are still waiting
                 for node in self.mn.values():
                     while node.waiting:
-                        info( 'stopping', node, '\n' )
                         node.sendInt()
                         node.waitOutput()
                 if self.isatty():
-                    quietRun( 'stty echo sane intr ^C' )
+                    quietRun( 'stty echo sane intr "^C"' )
                 self.cmdloop()
                 break
             except KeyboardInterrupt:
-                # Output a message - unless it's also interrupted
-                # pylint: disable=broad-except
-                try:
-                    output( '\nInterrupt\n' )
-                except Exception:
-                    pass
-                # pylint: enable=broad-except
+                output( '\nInterrupt\n' )
 
     def emptyline( self ):
         "Don't repeat last command when you hit return."

mininet/link.py

@@ -25,7 +25,7 @@ Link: basic link class for creating veth pairs
 """
 
 from mininet.log import info, error, debug
-from mininet.util import makeIntfPair
+from mininet.util import makeIntfPair, quietRun
 import mininet.node
 import re
 
@@ -50,11 +50,7 @@ class Intf( object ):
         if self.name == 'lo':
             self.ip = '127.0.0.1'
         # Add to node (and move ourselves if necessary )
-        moveIntfFn = params.pop( 'moveIntfFn', None )
-        if moveIntfFn:
-            node.addIntf( self, port=port, moveIntfFn=moveIntfFn )
-        else:
-            node.addIntf( self, port=port )
+        node.addIntf( self, port=port )
         # Save params for future reference
         self.params = params
         self.config( **params )
@@ -197,10 +193,9 @@ class Intf( object ):
     def delete( self ):
         "Delete interface"
         self.cmd( 'ip link del ' + self.name )
-        # We used to do this, but it slows us down:
-        # if self.node.inNamespace:
-        # Link may have been dumped into root NS
-        # quietRun( 'ip link del ' + self.name )
+        if self.node.inNamespace:
+            # Link may have been dumped into root NS
+            quietRun( 'ip link del ' + self.name )
 
     def status( self ):
         "Return intf status as a string"
@@ -222,19 +217,15 @@ class TCIntf( Intf ):
        Allows specification of bandwidth limits (various methods)
        as well as delay, loss and max queue length"""
 
-    # The parameters we use seem to work reasonably up to 1 Gb/sec
-    # For higher data rates, we will probably need to change them.
-    bwParamMax = 1000
-
     def bwCmds( self, bw=None, speedup=0, use_hfsc=False, use_tbf=False,
                 latency_ms=None, enable_ecn=False, enable_red=False ):
         "Return tc commands to set bandwidth"
 
         cmds, parent = [], ' root '
 
-        if bw and ( bw < 0 or bw > self.bwParamMax ):
-            error( 'Bandwidth limit', bw, 'is outside supported range 0..%d'
-                   % self.bwParamMax, '- ignoring\n' )
+        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
@@ -377,11 +368,10 @@ class Link( object ):
     """A basic link is just a veth pair.
        Other types of links could be tunnels, link emulators, etc.."""
 
-    # pylint: disable=too-many-branches
     def __init__( self, node1, node2, port1=None, port2=None,
                   intfName1=None, intfName2=None, addr1=None, addr2=None,
                   intf=Intf, cls1=None, cls2=None, params1=None,
-                  params2=None, fast=True ):
+                  params2=None ):
         """Create veth link to another node, making two new interfaces.
            node1: first node
            node2: second node
@@ -416,14 +406,7 @@ class Link( object ):
         if not intfName2:
             intfName2 = self.intfName( node2, params2[ 'port' ] )
 
-        self.fast = fast
-        if fast:
-            params1.setdefault( 'moveIntfFn', self._ignore )
-            params2.setdefault( 'moveIntfFn', self._ignore )
-            self.makeIntfPair( intfName1, intfName2, addr1, addr2,
-                               node1, node2, deleteIntfs=False )
-        else:
-            self.makeIntfPair( intfName1, intfName2, addr1, addr2 )
+        self.makeIntfPair( intfName1, intfName2, addr1, addr2 )
 
         if not cls1:
             cls1 = intf
@@ -437,12 +420,6 @@ class Link( object ):
 
         # All we are is dust in the wind, and our two interfaces
         self.intf1, self.intf2 = intf1, intf2
-    # pylint: enable=too-many-branches
-
-    @staticmethod
-    def _ignore( *args, **kwargs ):
-        "Ignore any arguments"
-        pass
 
     def intfName( self, node, n ):
         "Construct a canonical interface name node-ethN for interface n."
@@ -451,32 +428,24 @@ class Link( object ):
         return node.name + '-eth' + repr( n )
 
     @classmethod
-    def makeIntfPair( cls, intfname1, intfname2, addr1=None, addr2=None,
-                      node1=None, node2=None, deleteIntfs=True ):
+    def makeIntfPair( cls, intfname1, intfname2, addr1=None, addr2=None ):
         """Create pair of interfaces
-           intfname1: name for interface 1
-           intfname2: name for interface 2
-           addr1: MAC address for interface 1 (optional)
-           addr2: MAC address for interface 2 (optional)
-           node1: home node for interface 1 (optional)
-           node2: home node for interface 2 (optional)
+           intfname1: name of interface 1
+           intfname2: name of interface 2
            (override this method [and possibly delete()]
            to change link type)"""
         # Leave this as a class method for now
         assert cls
-        return makeIntfPair( intfname1, intfname2, addr1, addr2, node1, node2,
-                             deleteIntfs=deleteIntfs )
+        return makeIntfPair( intfname1, intfname2, addr1, addr2 )
 
     def delete( self ):
         "Delete this link"
         self.intf1.delete()
-        # We only need to delete one side, though this doesn't seem to
-        # cost us much and might help subclasses.
-        # self.intf2.delete()
+        self.intf2.delete()
 
     def stop( self ):
         "Override to stop and clean up link as needed"
-        self.delete()
+        pass
 
     def status( self ):
         "Return link status as a string"
@@ -489,27 +458,24 @@ class Link( object ):
 class OVSIntf( Intf ):
     "Patch interface on an OVSSwitch"
 
-    def ifconfig( self, *args ):
-        cmd = ' '.join( args )
+    def ifconfig( self, cmd ):
         if cmd == 'up':
-            # OVSIntf is always up
+            "OVSIntf is always up"
             return
         else:
             raise Exception( 'OVSIntf cannot do ifconfig ' + cmd )
 
 
 class OVSLink( Link ):
-    """Link that makes patch links between OVSSwitches
-       Warning: in testing we have found that no more
-       than ~64 OVS patch links should be used in row."""
+    "Link that makes patch links between OVSSwitches"
 
     def __init__( self, node1, node2, **kwargs ):
         "See Link.__init__() for options"
         self.isPatchLink = False
-        if ( isinstance( node1, mininet.node.OVSSwitch ) and
-             isinstance( node2, mininet.node.OVSSwitch ) ):
-            self.isPatchLink = True
-            kwargs.update( cls1=OVSIntf, cls2=OVSIntf )
+        if ( type( node1 ) is mininet.node.OVSSwitch and
+             type( node2 ) is mininet.node.OVSSwitch ):
+             self.isPatchLink = True
+             kwargs.update( cls1=OVSIntf, cls2=OVSIntf )
         Link.__init__( self, node1, node2, **kwargs )
 
     def makeIntfPair( self, *args, **kwargs ):

mininet/net.py

@@ -102,13 +102,12 @@ from mininet.node import ( Node, Host, OVSKernelSwitch, DefaultController,
                            Controller )
 from mininet.nodelib import NAT
 from mininet.link import Link, Intf
-from mininet.util import ( quietRun, fixLimits, numCores, ensureRoot,
-                           macColonHex, ipStr, ipParse, netParse, ipAdd,
-                           waitListening )
+from mininet.util import quietRun, fixLimits, numCores, ensureRoot
+from mininet.util import macColonHex, ipStr, ipParse, netParse, ipAdd
 from mininet.term import cleanUpScreens, makeTerms
 
 # Mininet version: should be consistent with README and LICENSE
-VERSION = "2.2.1"
+VERSION = "2.2.0"
 
 class Mininet( object ):
     "Network emulation with hosts spawned in network namespaces."
@@ -402,7 +401,7 @@ class Mininet( object ):
             if not isinstance( classes, list ):
                 classes = [ classes ]
             for i, cls in enumerate( classes ):
-                # Allow Controller objects because nobody understands partial()
+                # Allow Controller objects because nobody understands currying
                 if isinstance( cls, Controller ):
                     self.addController( cls )
                 else:
@@ -415,12 +414,7 @@ class Mininet( object ):
 
         info( '\n*** Adding switches:\n' )
         for switchName in topo.switches():
-            # A bit ugly: add batch parameter if appropriate
-            params = topo.nodeInfo( switchName)
-            cls = params.get( 'cls', self.switch )
-            if hasattr( cls, 'batchStartup' ):
-                params.setdefault( 'batch', True )
-            self.addSwitch( switchName, **params )
+            self.addSwitch( switchName, **topo.nodeInfo( switchName) )
             info( switchName + ' ' )
 
         info( '\n*** Adding links:\n' )
@@ -487,13 +481,6 @@ class Mininet( object ):
         for switch in self.switches:
             info( switch.name + ' ')
             switch.start( self.controllers )
-        started = {}
-        for swclass, switches in groupby(
-                sorted( self.switches, key=type ), type ):
-            switches = tuple( switches )
-            if hasattr( swclass, 'batchStartup' ):
-                success = swclass.batchStartup( switches )
-                started.update( { s: s for s in success } )
         info( '\n' )
         if self.waitConn:
             self.waitConnected()
@@ -508,25 +495,20 @@ class Mininet( object ):
         if self.terms:
             info( '*** Stopping %i terms\n' % len( self.terms ) )
             self.stopXterms()
-        info( '*** Stopping %i links\n' % len( self.links ) )
-        for link in self.links:
-            info( '.' )
-            link.stop()
-        info( '\n' )
         info( '*** Stopping %i switches\n' % len( self.switches ) )
-        stopped = {}
         for swclass, switches in groupby(
                 sorted( self.switches, key=type ), type ):
-            switches = tuple( switches )
             if hasattr( swclass, 'batchShutdown' ):
-                success = swclass.batchShutdown( switches )
-                stopped.update( { s: s for s in success } )
+                swclass.batchShutdown( switches )
         for switch in self.switches:
             info( switch.name + ' ' )
-            if switch not in stopped:
-                switch.stop()
+            switch.stop()
             switch.terminate()
         info( '\n' )
+        info( '*** Stopping %i links\n' % len( self.links ) )
+        for link in self.links:
+            link.stop()
+        info( '\n' )
         info( '*** Stopping %i hosts\n' % len( self.hosts ) )
         for host in self.hosts:
             info( host.name + ' ' )
@@ -730,25 +712,27 @@ class Mininet( object ):
     # XXX This should be cleaned up
 
     def iperf( self, hosts=None, l4Type='TCP', udpBw='10M', fmt=None,
-               seconds=5, port=5001):
+               seconds=5):
         """Run iperf between two hosts.
            hosts: list of hosts; if None, uses first and last hosts
            l4Type: string, one of [ TCP, UDP ]
            udpBw: bandwidth target for UDP test
            fmt: iperf format argument if any
            seconds: iperf time to transmit
-           port: iperf port
            returns: two-element array of [ server, client ] speeds
            note: send() is buffered, so client rate can be much higher than
            the actual transmission rate; on an unloaded system, server
            rate should be much closer to the actual receive rate"""
+        if not quietRun( 'which telnet' ):
+            error( 'Cannot find telnet in $PATH - required for iperf test' )
+            return
         hosts = hosts or [ self.hosts[ 0 ], self.hosts[ -1 ] ]
         assert len( hosts ) == 2
         client, server = hosts
-        output( '*** Iperf: testing', l4Type, 'bandwidth between',
-                client, 'and', server, '\n' )
+        output( '*** Iperf: testing ' + l4Type + ' bandwidth between ' )
+        output( "%s and %s\n" % ( client.name, server.name ) )
         server.cmd( 'killall -9 iperf' )
-        iperfArgs = 'iperf -p %d ' % port
+        iperfArgs = 'iperf '
         bwArgs = ''
         if l4Type == 'UDP':
             iperfArgs += '-u '
@@ -757,16 +741,20 @@ class Mininet( object ):
             raise Exception( 'Unexpected l4 type: %s' % l4Type )
         if fmt:
             iperfArgs += '-f %s ' % fmt
-        server.sendCmd( iperfArgs + '-s' )
+        server.sendCmd( iperfArgs + '-s', printPid=True )
+        servout = ''
+        while server.lastPid is None:
+            servout += server.monitor()
         if l4Type == 'TCP':
-            if not waitListening( client, server.IP(), port ):
-                raise Exception( 'Could not connect to iperf on port %d'
-                                 % port )
+            while 'Connected' not in client.cmd(
+                    'sh -c "echo A | telnet -e A %s 5001"' % server.IP()):
+                info( 'Waiting for iperf to start up...' )
+                sleep(.5)
         cliout = client.cmd( iperfArgs + '-t %d -c ' % seconds +
                              server.IP() + ' ' + bwArgs )
         debug( 'Client output: %s\n' % cliout )
         server.sendInt()
-        servout = server.waitOutput()
+        servout += server.waitOutput()
         debug( 'Server output: %s\n' % servout )
         result = [ self._parseIperf( servout ), self._parseIperf( cliout ) ]
         if l4Type == 'UDP':

mininet/node.py

@@ -23,26 +23,20 @@ Switch: superclass for switch nodes.
 UserSwitch: a switch using the user-space switch from the OpenFlow
     reference implementation.
 
-OVSSwitch: a switch using the Open vSwitch OpenFlow-compatible switch
+KernelSwitch: a switch using the kernel switch from the OpenFlow reference
+    implementation.
+
+OVSSwitch: a switch using the OpenVSwitch OpenFlow-compatible switch
     implementation (openvswitch.org).
 
-OVSBridge: an Ethernet bridge implemented using Open vSwitch.
-    Supports STP.
-
-IVSSwitch: OpenFlow switch using the Indigo Virtual Switch.
-
 Controller: superclass for OpenFlow controllers. The default controller
     is controller(8) from the reference implementation.
 
-OVSController: The test controller from Open vSwitch.
-
 NOXController: a controller node using NOX (noxrepo.org).
 
-Ryu: The Ryu controller (https://osrg.github.io/ryu/)
-
 RemoteController: a remote controller node, which may use any
     arbitrary OpenFlow-compatible controller, and which is not
-    created or managed by Mininet.
+    created or managed by mininet.
 
 Future enhancements:
 
@@ -63,7 +57,7 @@ from time import sleep
 from mininet.log import info, error, warn, debug
 from mininet.util import ( quietRun, errRun, errFail, moveIntf, isShellBuiltin,
                            numCores, retry, mountCgroups )
-from mininet.moduledeps import moduleDeps, pathCheck, TUN
+from mininet.moduledeps import moduleDeps, pathCheck, OVS_KMOD, OF_KMOD, TUN
 from mininet.link import Link, Intf, TCIntf, OVSIntf
 from re import findall
 from distutils.version import StrictVersion
@@ -131,11 +125,11 @@ class Node( object ):
         opts = '-cd' if mnopts is None else mnopts
         if self.inNamespace:
             opts += 'n'
-        # bash -i: force interactive
+        # bash -m: enable job control, i: force interactive
         # -s: pass $* to shell, and make process easy to find in ps
         # prompt is set to sentinel chr( 127 )
         cmd = [ 'mnexec', opts, 'env', 'PS1=' + chr( 127 ),
-                'bash', '--norc', '-is', 'mininet:' + self.name ]
+                'bash', '--norc', '-mis', 'mininet:' + self.name ]
         # Spawn a shell subprocess in a pseudo-tty, to disable buffering
         # in the subprocess and insulate it from signals (e.g. SIGINT)
         # received by the parent
@@ -163,8 +157,8 @@ class Node( object ):
                 break
             self.pollOut.poll()
         self.waiting = False
-        # +m: disable job control notification
-        self.cmd( 'unset HISTFILE; stty -echo; set +m' )
+        self.cmd( 'stty -echo' )
+        self.cmd( 'set +m' )
 
     def mountPrivateDirs( self ):
         "mount private directories"
@@ -200,11 +194,10 @@ class Node( object ):
 
     def cleanup( self ):
         "Help python collect its garbage."
-        # We used to do this, but it slows us down:
         # Intfs may end up in root NS
-        # for intfName in self.intfNames():
-        # if self.name in intfName:
-        # quietRun( 'ip link del ' + intfName )
+        for intfName in self.intfNames():
+            if self.name in intfName:
+                quietRun( 'ip link del ' + intfName )
         self.shell = None
 
     # Subshell I/O, commands and control
@@ -265,9 +258,9 @@ class Node( object ):
         """Send a command, followed by a command to echo a sentinel,
            and return without waiting for the command to complete.
            args: command and arguments, or string
-           printPid: print command's PID? (False)"""
-        assert self.shell and not self.waiting
-        printPid = kwargs.get( 'printPid', False )
+           printPid: print command's PID?"""
+        assert not self.waiting
+        printPid = kwargs.get( 'printPid', True )
         # Allow sendCmd( [ list ] )
         if len( args ) == 1 and isinstance( args[ 0 ], list ):
             cmd = args[ 0 ]
@@ -346,11 +339,8 @@ class Node( object ):
         verbose = kwargs.get( 'verbose', False )
         log = info if verbose else debug
         log( '*** %s : %s\n' % ( self.name, args ) )
-        if self.shell:
-            self.sendCmd( *args, **kwargs )
-            return self.waitOutput( verbose )
-        else:
-            warn( '(%s exited - ignoring cmd%s)\n' % ( self, args ) )
+        self.sendCmd( *args, **kwargs )
+        return self.waitOutput( verbose )
 
     def cmdPrint( self, *args):
         """Call cmd and printing its output
@@ -513,13 +503,15 @@ class Node( object ):
            mac: MAC address as string"""
         return self.intf( intf ).setMAC( mac )
 
-    def setIP( self, ip, prefixLen=8, intf=None, **kwargs ):
+    def setIP( self, ip, prefixLen=8, intf=None ):
         """Set the IP address for an interface.
            intf: intf or intf name
            ip: IP address as a string
-           prefixLen: prefix length, e.g. 8 for /8 or 16M addrs
-           kwargs: any additional arguments for intf.setIP"""
-        return self.intf( intf ).setIP( ip, prefixLen, **kwargs )
+           prefixLen: prefix length, e.g. 8 for /8 or 16M addrs"""
+        # This should probably be rethought
+        if '/' not in ip:
+            ip = '%s/%s' % ( ip, prefixLen )
+        return self.intf( intf ).setIP( ip )
 
     def IP( self, intf=None ):
         "Return IP address of a node or specific interface."
@@ -679,7 +671,7 @@ class CPULimitedHost( Host ):
         "Clean up our cgroup"
         # info( '*** deleting cgroup', self.cgroup, '\n' )
         _out, _err, exitcode = errRun( 'cgdelete -r ' + self.cgroup )
-        return exitcode == 0  # success condition
+        return exitcode != 0
 
     def popen( self, *args, **kwargs ):
         """Return a Popen() object in node's namespace
@@ -901,12 +893,6 @@ class Switch( Node ):
         debug( 'Assuming', repr( self ), 'is connected to a controller\n' )
         return True
 
-    def stop( self, deleteIntfs=True ):
-        """Stop switch
-           deleteIntfs: delete interfaces? (True)"""
-        if deleteIntfs:
-            self.deleteIntfs()
-
     def __repr__( self ):
         "More informative string representation"
         intfs = ( ','.join( [ '%s:%s' % ( i.name, i.IP() )
@@ -1013,32 +999,73 @@ class UserSwitch( Switch ):
         self.cmd( 'kill %ofprotocol' )
         super( UserSwitch, self ).stop( deleteIntfs )
 
+class OVSLegacyKernelSwitch( Switch ):
+    """Open VSwitch legacy kernel-space switch using ovs-openflowd.
+       Currently only works in the root namespace."""
+
+    def __init__( self, name, dp=None, **kwargs ):
+        """Init.
+           name: name for switch
+           dp: netlink id (0, 1, 2, ...)
+           defaultMAC: default MAC as unsigned int; random value if None"""
+        Switch.__init__( self, name, **kwargs )
+        self.dp = dp if dp else self.name
+        self.intf = self.dp
+        if self.inNamespace:
+            error( "OVSKernelSwitch currently only works"
+                   " in the root namespace.\n" )
+            exit( 1 )
+
+    @classmethod
+    def setup( cls ):
+        "Ensure any dependencies are loaded; if not, try to load them."
+        pathCheck( 'ovs-dpctl', 'ovs-openflowd',
+                   moduleName='Open vSwitch (openvswitch.org)')
+        moduleDeps( subtract=OF_KMOD, add=OVS_KMOD )
+
+    def start( self, controllers ):
+        "Start up kernel datapath."
+        ofplog = '/tmp/' + self.name + '-ofp.log'
+        # Delete local datapath if it exists;
+        # then create a new one monitoring the given interfaces
+        self.cmd( 'ovs-dpctl del-dp ' + self.dp )
+        self.cmd( 'ovs-dpctl add-dp ' + self.dp )
+        intfs = [ str( i ) for i in self.intfList() if not i.IP() ]
+        self.cmd( 'ovs-dpctl', 'add-if', self.dp, ' '.join( intfs ) )
+        # Run protocol daemon
+        clist = ','.join( [ 'tcp:%s:%d' % ( c.IP(), c.port )
+                            for c in controllers ] )
+        self.cmd( 'ovs-openflowd ' + self.dp +
+                  ' ' + clist +
+                  ' --fail=secure ' + self.opts +
+                  ' --datapath-id=' + self.dpid +
+                  ' 1>' + ofplog + ' 2>' + ofplog + '&' )
+        self.execed = False
+
+    def stop( self, deleteIntfs=True ):
+        """Terminate kernel datapath."
+           deleteIntfs: delete interfaces? (True)"""
+        quietRun( 'ovs-dpctl del-dp ' + self.dp )
+        self.cmd( 'kill %ovs-openflowd' )
+        super( OVSLegacyKernelSwitch, self ).stop( deleteIntfs )
+
 
 class OVSSwitch( Switch ):
     "Open vSwitch switch. Depends on ovs-vsctl."
 
     def __init__( self, name, failMode='secure', datapath='kernel',
-                  inband=False, protocols=None,
-                  reconnectms=1000, stp=False, batch=False, **params ):
-        """name: name for switch
+                  inband=False, protocols=None, **params ):
+        """Init.
+           name: name for switch
            failMode: controller loss behavior (secure|open)
            datapath: userspace or kernel mode (kernel|user)
-           inband: use in-band control (False)
-           protocols: use specific OpenFlow version(s) (e.g. OpenFlow13)
-                      Unspecified (or old OVS version) uses OVS default
-           reconnectms: max reconnect timeout in ms (0/None for default)
-           stp: enable STP (False, requires failMode=standalone)
-           batch: enable batch startup (False)"""
+           inband: use in-band control (False)"""
         Switch.__init__( self, name, **params )
         self.failMode = failMode
         self.datapath = datapath
         self.inband = inband
         self.protocols = protocols
-        self.reconnectms = reconnectms
-        self.stp = stp
         self._uuids = []  # controller UUIDs
-        self.batch = batch
-        self.commands = []  # saved commands for batch startup
 
     @classmethod
     def setup( cls ):
@@ -1068,18 +1095,17 @@ class OVSSwitch( Switch ):
         return ( StrictVersion( cls.OVSVersion ) <
                  StrictVersion( '1.10' ) )
 
+    @classmethod
+    def batchShutdown( cls, switches ):
+        "Call ovs-vsctl del-br on all OVSSwitches in a list"
+        quietRun( 'ovs-vsctl ' +
+                  ' -- '.join( '--if-exists del-br %s' % s
+                               for s in switches ) )
+
     def dpctl( self, *args ):
         "Run ovs-ofctl command"
         return self.cmd( 'ovs-ofctl', args[ 0 ], self, *args[ 1: ] )
 
-    def vsctl( self, *args, **kwargs ):
-        "Run ovs-vsctl command (or queue for later execution)"
-        if self.batch:
-            cmd = ' '.join( str( arg ).strip() for arg in args )
-            self.commands.append( cmd )
-        else:
-            return self.cmd( 'ovs-vsctl', *args, **kwargs )
-
     @staticmethod
     def TCReapply( intf ):
         """Unfortunately OVS and Mininet are fighting
@@ -1090,13 +1116,13 @@ class OVSSwitch( Switch ):
 
     def attach( self, intf ):
         "Connect a data port"
-        self.vsctl( 'add-port', self, intf )
+        self.cmd( 'ovs-vsctl add-port', self, intf )
         self.cmd( 'ifconfig', intf, 'up' )
         self.TCReapply( intf )
 
     def detach( self, intf ):
         "Disconnect a data port"
-        self.vsctl( 'del-port', self, intf )
+        self.cmd( 'ovs-vsctl del-port', self, intf )
 
     def controllerUUIDs( self, update=False ):
         """Return ovsdb UUIDs for our controllers
@@ -1114,109 +1140,77 @@ class OVSSwitch( Switch ):
     def connected( self ):
         "Are we connected to at least one of our controllers?"
         for uuid in self.controllerUUIDs():
-            if 'true' in self.vsctl( '-- get Controller',
-                                     uuid, 'is_connected' ):
+            if 'true' in self.cmd( 'ovs-vsctl -- get Controller',
+                                            uuid, 'is_connected' ):
                 return True
         return self.failMode == 'standalone'
 
-    def intfOpts( self, intf ):
-        "Return OVS interface options for intf"
-        opts = ''
-        if not self.isOldOVS():
-            # ofport_request is not supported on old OVS
-            opts += ' ofport_request=%s' % self.ports[ intf ]
-            # Patch ports don't work well with old OVS
-            if isinstance( intf, OVSIntf ):
-                intf1, intf2 = intf.link.intf1, intf.link.intf2
-                peer = intf1 if intf1 != intf else intf2
-                opts += ' type=patch options:peer=%s' % peer
-        return '' if not opts else ' -- set Interface %s' % intf + opts
-
-    def bridgeOpts( self ):
-        "Return OVS bridge options"
-        opts = ( ' other_config:datapath-id=%s' % self.dpid +
-                 ' fail_mode=%s' % self.failMode )
-        if not self.inband:
-            opts += ' other-config:disable-in-band=true'
-        if self.datapath == 'user':
-            opts += ' datapath_type=netdev'
-        if self.protocols and not self.isOldOVS():
-            opts += ' protocols=%s' % self.protocols
-        if self.stp and self.failMode == 'standalone':
-            opts += ' stp_enable=true' % self
-        return opts
+    @staticmethod
+    def patchOpts( intf ):
+        "Return OVS patch port options (if any) for intf"
+        if not isinstance( intf, OVSIntf ):
+            # Ignore if it's not a patch link
+            return ''
+        intf1, intf2 = intf.link.intf1, intf.link.intf2
+        peer = intf1 if intf1 != intf else intf2
+        return ( '-- set Interface %s type=patch '
+                 '-- set Interface %s options:peer=%s ' %
+                 ( intf, intf, peer ) )
 
     def start( self, controllers ):
         "Start up a new OVS OpenFlow switch using ovs-vsctl"
         if self.inNamespace:
             raise Exception(
                 'OVS kernel switch does not work in a namespace' )
+        # Annoyingly, --if-exists option seems not to work
+        self.cmd( 'ovs-vsctl del-br', self )
         int( self.dpid, 16 )  # DPID must be a hex string
-        # Command to add interfaces
-        intfs = ''.join( ' -- add-port %s %s' % ( self, intf ) +
-                         self.intfOpts( intf )
-                         for intf in self.intfList()
-                         if self.ports[ intf ] and not intf.IP() )
-        # Command to create controller entries
-        clist = [ ( self.name + c.name, '%s:%s:%d' %
-                  ( c.protocol, c.IP(), c.port ) )
-                  for c in controllers ]
+        # Interfaces and controllers
+        intfs = ' '.join( '-- add-port %s %s ' % ( self, intf ) +
+                          '-- set Interface %s ' % intf +
+                          'ofport_request=%s ' % self.ports[ intf ]
+                          + self.patchOpts( intf )
+                          for intf in self.intfList()
+                          if self.ports[ intf ] and not intf.IP() )
+        clist = ' '.join( '%s:%s:%d' % ( c.protocol, c.IP(), c.port )
+                          for c in controllers )
         if self.listenPort:
-            clist.append( ( self.name + '-listen',
-                            'ptcp:%s' % self.listenPort ) )
-        ccmd = '-- --id=@%s create Controller target=\\"%s\\"'
-        if self.reconnectms:
-            ccmd += ' max_backoff=%d' % self.reconnectms
-        cargs = ' '.join( ccmd % ( name, target )
-                          for name, target in clist )
-        # Controller ID list
-        cids = ','.join( '@%s' % name for name, _target in clist )
-        # Try to delete any existing bridges with the same name
+            clist += ' ptcp:%s' % self.listenPort
+        # Construct big ovs-vsctl command for new versions of OVS
         if not self.isOldOVS():
-            cargs += ' -- --if-exists del-br %s' % self
-        # One ovs-vsctl command to rule them all!
-        self.vsctl( cargs +
-                    ' -- add-br %s' % self +
-                    ' -- set bridge %s controller=[%s]' % ( self, cids  ) +
-                    self.bridgeOpts() +
-                    intfs )
-        # If necessary, restore TC config overwritten by OVS
-        if not self.batch:
+            cmd = ( 'ovs-vsctl add-br %s ' % self +
+                    '-- set Bridge %s ' % self +
+                    'other_config:datapath-id=%s ' % self.dpid +
+                    '-- set-fail-mode %s %s ' % ( self, self.failMode ) +
+                    intfs +
+                    '-- set-controller %s %s ' % ( self, clist ) )
+        # Construct ovs-vsctl commands for old versions of OVS
+        else:
+            self.cmd( 'ovs-vsctl add-br', self )
             for intf in self.intfList():
-                self.TCReapply( intf )
-
-    # This should be ~ int( quietRun( 'getconf ARG_MAX' ) ),
-    # but the real limit seems to be much lower
-    argmax = 128000
-
-    @classmethod
-    def batchStartup( cls, switches, run=errRun ):
-        """Batch startup for OVS
-           switches: switches to start up
-           run: function to run commands (errRun)"""
-        info( '...' )
-        cmds = 'ovs-vsctl'
-        for switch in switches:
-            if switch.isOldOVS():
-                # Ideally we'd optimize this also
-                run( 'ovs-vsctl del-br %s' % switch )
-            for cmd in switch.commands:
-                cmd = cmd.strip()
-                # Don't exceed ARG_MAX
-                if len( cmds ) + len( cmd ) >= cls.argmax:
-                    run( cmds, shell=True )
-                    cmds = 'ovs-vsctl'
-                cmds += ' ' + cmd
-                switch.cmds = []
-                switch.batch = False
-        if cmds:
-            run( cmds, shell=True )
-        # Reapply link config if necessary...
-        for switch in switches:
-            for intf in switch.intfs.itervalues():
-                if isinstance( intf, TCIntf ):
-                    intf.config( **intf.params )
-        return switches
+                if not intf.IP():
+                    self.cmd( 'ovs-vsctl add-port', self, intf )
+            cmd = ( 'ovs-vsctl set Bridge %s ' % self +
+                    'other_config:datapath-id=%s ' % self.dpid +
+                    '-- set-fail-mode %s %s ' % ( self, self.failMode ) +
+                    '-- set-controller %s %s ' % ( self, clist ) )
+        if not self.inband:
+            cmd += ( '-- set bridge %s '
+                     'other-config:disable-in-band=true ' % self )
+        if self.datapath == 'user':
+            cmd += '-- set bridge %s datapath_type=netdev ' % self
+        if self.protocols:
+            cmd += '-- set bridge %s protocols=%s' % ( self, self.protocols )
+        # Do it!!
+        self.cmd( cmd )
+        # Reconnect quickly to controllers (1s vs. 15s max_backoff)
+        uuids = [ '-- set Controller %s max_backoff=1000' % uuid
+                  for uuid in self.controllerUUIDs() ]
+        if uuids:
+            self.cmd( 'ovs-vsctl', *uuids )
+        # If necessary, restore TC config overwritten by OVS
+        for intf in self.intfList():
+            self.TCReapply( intf )
 
     def stop( self, deleteIntfs=True ):
         """Terminate OVS switch.
@@ -1226,22 +1220,6 @@ class OVSSwitch( Switch ):
             self.cmd( 'ip link del', self )
         super( OVSSwitch, self ).stop( deleteIntfs )
 
-    @classmethod
-    def batchShutdown( cls, switches, run=errRun ):
-        "Shut down a list of OVS switches"
-        delcmd = 'del-br %s'
-        if switches and not switches[ 0 ].isOldOVS():
-            delcmd = '--if-exists ' + delcmd
-        # First, delete them all from ovsdb
-        run( 'ovs-vsctl ' +
-             ' -- '.join( delcmd % s for s in switches ) )
-        # Next, shut down all of the processes
-        pids = ' '.join( str( switch.pid ) for switch in switches )
-        run( 'kill -HUP ' + pids )
-        for switch in switches:
-            switch.shell = None
-        return switches
-
 
 OVSKernelSwitch = OVSSwitch
 
@@ -1249,24 +1227,13 @@ OVSKernelSwitch = OVSSwitch
 class OVSBridge( OVSSwitch ):
     "OVSBridge is an OVSSwitch in standalone/bridge mode"
 
-    def __init__( self, *args, **kwargs ):
-        """stp: enable Spanning Tree Protocol (False)
-           see OVSSwitch for other options"""
+    def __init__( self, args, **kwargs ):
         kwargs.update( failMode='standalone' )
-        OVSSwitch.__init__( self, *args, **kwargs )
+        OVSSwitch.__init__( self, args, **kwargs )
 
     def start( self, controllers ):
-        "Start bridge, ignoring controllers argument"
         OVSSwitch.start( self, controllers=[] )
 
-    def connected( self ):
-        "Are we forwarding yet?"
-        if self.stp:
-            status = self.dpctl( 'show' )
-            return 'STP_FORWARD' in status and not 'STP_LEARN' in status
-        else:
-            return True
-
 
 class IVSSwitch( Switch ):
     "Indigo Virtual Switch"
@@ -1293,7 +1260,6 @@ class IVSSwitch( Switch ):
         "Kill each IVS switch, to be waited on later in stop()"
         for switch in switches:
             switch.cmd( 'kill %ivs' )
-        return switches
 
     def start( self, controllers ):
         "Start up a new IVS switch"
@@ -1348,10 +1314,6 @@ class Controller( Node ):
         self.command = command
         self.cargs = cargs
         self.cdir = cdir
-        # Accept 'ip:port' syntax as shorthand
-        if ':' in ip:
-            ip, port = ip.split( ':' )
-            port = int( port )
         self.ip = ip
         self.port = port
         self.protocol = protocol
@@ -1451,7 +1413,7 @@ class NOX( Controller ):
                              cdir=noxCoreDir,
                              **kwargs )
 
-class Ryu( Controller ):
+class RYU( Controller ):
     "Controller to run Ryu application"
     def __init__( self, name, *ryuArgs, **kwargs ):
         """Init.
@@ -1473,7 +1435,6 @@ class Ryu( Controller ):
                              cdir=ryuCoreDir,
                              **kwargs )
 
-
 class RemoteController( Controller ):
     "Controller running outside of Mininet's control."
 
@@ -1517,7 +1478,3 @@ def DefaultController( name, controllers=DefaultControllers, **kwargs ):
     if not controller:
         raise Exception( 'Could not find a default OpenFlow controller' )
     return controller( name, **kwargs )
-
-def NullController( *_args, **_kwargs ):
-    "Nonexistent controller - simply returns None"
-    return None

mininet/term.py

@@ -35,7 +35,7 @@ def tunnelX11( node, display=None):
                 "EXEC:'mnexec -a 1 socat STDIO %s'" % connection ]
     return 'localhost:' + screen, node.popen( cmd )
 
-def makeTerm( node, title='Node', term='xterm', display=None, cmd='bash'):
+def makeTerm( node, title='Node', term='xterm', display=None ):
     """Create an X11 tunnel to the node and start up a terminal.
        node: Node object
        title: base title
@@ -54,8 +54,7 @@ def makeTerm( node, title='Node', term='xterm', display=None, cmd='bash'):
     display, tunnel = tunnelX11( node, display )
     if display is None:
         return []
-    term = node.popen( cmds[ term ] +
-                       [ display, '-e', 'env TERM=ansi %s' % cmd ] )
+    term = node.popen( cmds[ term ] + [ display, '-e', 'env TERM=ansi bash'] )
     return [ tunnel, term ] if tunnel else [ term ]
 
 def runX11( node, cmd ):

mininet/test/test_switchdpidassignment.py

@@ -8,7 +8,8 @@ import sys
 
 from mininet.net import Mininet
 from mininet.node import Host, Controller
-from mininet.node import ( UserSwitch, OVSSwitch, IVSSwitch )
+from mininet.node import ( UserSwitch, OVSSwitch, OVSLegacyKernelSwitch,
+                           IVSSwitch )
 from mininet.topo import Topo
 from mininet.log import setLogLevel
 from mininet.util import quietRun
@@ -80,6 +81,12 @@ class testSwitchOVSUser( TestSwitchDpidAssignmentOVS ):
     "Test dpid assignnment of OVS User Switch."
     switchClass = OVSUser
 
+@unittest.skipUnless( quietRun( 'which ovs-openflowd' ),
+                      'OVS Legacy Kernel switch is not installed' )
+class testSwitchOVSLegacyKernel( TestSwitchDpidAssignmentOVS ):
+    "Test dpid assignnment of OVS Legacy Kernel Switch."
+    switchClass = OVSLegacyKernelSwitch
+
 @unittest.skipUnless( quietRun( 'which ivs-ctl' ),
                       'IVS switch is not installed' )
 class testSwitchIVS( TestSwitchDpidAssignmentOVS ):

mininet/topo.py

@@ -318,12 +318,6 @@ class SingleSwitchReversedTopo( Topo ):
                           port1=0, port2=( k - h + 1 ) )
 
 
-class MinimalTopo( SingleSwitchTopo ):
-    "Minimal topology with two hosts and one switch"
-    def build( self ):
-        return SingleSwitchTopo.build( self, k=2 )
-
-
 class LinearTopo( Topo ):
     "Linear topology of k switches, with n hosts per switch."
 

mininet/util.py

@@ -56,7 +56,6 @@ def oldQuietRun( *cmd ):
 # This is a bit complicated, but it enables us to
 # monitor command output as it is happening
 
-# pylint: disable=too-many-branches
 def errRun( *cmd, **kwargs ):
     """Run a command and return stdout, stderr and return code
        cmd: string or list of command and args
@@ -78,7 +77,6 @@ def errRun( *cmd, **kwargs ):
         cmd = [ str( arg ) for arg in cmd ]
     elif isinstance( cmd, list ) and shell:
         cmd = " ".join( arg for arg in cmd )
-    debug( '*** errRun:', 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
@@ -93,31 +91,21 @@ def errRun( *cmd, **kwargs ):
         errDone = False
     while not outDone or not errDone:
         readable = poller.poll()
-        for fd, event in readable:
+        for fd, _event in readable:
             f = fdtofile[ fd ]
-            if event & POLLIN:
-                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
-            else:  # POLLHUP or something unexpected
-                if f == popen.stdout:
+            data = f.read( 1024 )
+            if echo:
+                output( data )
+            if f == popen.stdout:
+                out += data
+                if data == '':
                     outDone = True
-                elif f == popen.stderr:
+            elif f == popen.stderr:
+                err += data
+                if data == '':
                     errDone = True
-                poller.unregister( fd )
-
     returncode = popen.wait()
-    debug( out, err, returncode )
     return out, err, returncode
-# pylint: enable=too-many-branches
 
 def errFail( *cmd, **kwargs ):
     "Run a command using errRun and raise exception on nonzero exit"
@@ -157,41 +145,27 @@ isShellBuiltin.builtIns = None
 # live in the root namespace and thus do not have to be
 # explicitly moved.
 
-def makeIntfPair( intf1, intf2, addr1=None, addr2=None, node1=None, node2=None,
-                  deleteIntfs=True, runCmd=None ):
-    """Make a veth pair connnecting new interfaces intf1 and intf2
-       intf1: name for interface 1
-       intf2: name for interface 2
-       addr1: MAC address for interface 1 (optional)
-       addr2: MAC address for interface 2 (optional)
-       node1: home node for interface 1 (optional)
-       node2: home node for interface 2 (optional)
-       deleteIntfs: delete intfs before creating them
+def makeIntfPair( intf1, intf2, addr1=None, addr2=None, runCmd=quietRun ):
+    """Make a veth pair connecting intf1 and intf2.
+       intf1: string, interface
+       intf2: string, interface
        runCmd: function to run shell commands (quietRun)
-       raises Exception on failure"""
-    if not runCmd:
-        runCmd = quietRun if not node1 else node1.cmd
-        runCmd2 = quietRun if not node2 else node2.cmd
-    if deleteIntfs:
-        # Delete any old interfaces with the same names
-        runCmd( 'ip link del ' + intf1 )
-        runCmd2( 'ip link del ' + intf2 )
+       returns: ip link add result"""
+    # Delete any old interfaces with the same names
+    runCmd( 'ip link del ' + intf1 )
+    runCmd( 'ip link del ' + intf2 )
     # Create new pair
-    netns = 1 if not node2 else node2.pid
     if addr1 is None and addr2 is None:
-        cmdOutput = runCmd( 'ip link add name %s '
-                            'type veth peer name %s '
-                            'netns %s' % ( intf1, intf2, netns ) )
+        cmd = 'ip link add name ' + intf1 + ' type veth peer name ' + intf2
     else:
-        cmdOutput = runCmd( 'ip link add name %s '
-                            'address %s '
-                            'type veth peer name %s '
-                            'address %s '
-                            'netns %s' %
-                            (  intf1, addr1, intf2, addr2, netns ) )
-    if cmdOutput:
-        raise Exception( "Error creating interface pair (%s,%s): %s " %
-                         ( intf1, intf2, cmdOutput ) )
+        cmd = ( 'ip link add name ' + intf1 + ' address ' + addr1 +
+                ' type veth peer name ' + intf2 + ' address ' + addr2 )
+    cmdOutput = runCmd( cmd )
+    if cmdOutput == '':
+        return True
+    else:
+        error( "Error creating interface pair: %s " % cmdOutput )
+        return False
 
 def retry( retries, delaySecs, fn, *args, **keywords ):
     """Try something several times before giving up.
@@ -523,54 +497,31 @@ def splitArgs( argstr ):
         kwargs[ key ] = makeNumeric( val )
     return fn, args, kwargs
 
-def customClass( classes, argStr ):
-    """Return customized class based on argStr
-    The args and key/val pairs in argStr will be automatically applied
-    when the generated class is later used.
+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, args, kwargs = splitArgs( argStr )
-    cls = classes.get( cname, None )
-    if not cls:
+    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, classes.keys() ) )
-    if not args and not kwargs:
-        return cls
+                         ( cname, constructors.keys() ) )
 
-    return specialClass( cls, append=args, defaults=kwargs )
-
-def specialClass( cls, prepend=None, append=None,
-                  defaults=None, override=None ):
-    """Like functools.partial, but it returns a class
-       prepend: arguments to prepend to argument list
-       append: arguments to append to argument list
-       defaults: default values for keyword arguments
-       override: keyword arguments to override"""
-
-    if prepend is None:
-        prepend = []
-
-    if append is None:
-        append = []
-
-    if defaults is None:
-        defaults = {}
-
-    if override is None:
-        override = {}
-
-    class CustomClass( cls ):
-        "Customized subclass with preset args/params"
-        def __init__( self, *args, **params ):
-            newparams = defaults.copy()
-            newparams.update( params )
-            newparams.update( override )
-            cls.__init__( self, *( list( prepend ) + list( args ) +
-                                   list( append ) ),
-                          **newparams )
-
-    CustomClass.__name__ = '%s%s' % ( cls.__name__, defaults )
-    return CustomClass
+    def customized( name, *args, **params ):
+        "Customized constructor, useful for Node, Link, and other classes"
+        params = params.copy()
+        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 )
 
+    customized.__name__ = 'customConstructor(%s)' % argStr
+    return customized
 
 def buildTopo( topos, topoStr ):
     """Create topology from string with format (object, arg1, arg2,...).
@@ -600,20 +551,18 @@ def waitListening( client=None, server='127.0.0.1', port=80, timeout=None ):
         raise Exception('Could not find telnet' )
     # pylint: disable=maybe-no-member
     serverIP = server if isinstance( server, basestring ) else server.IP()
-    cmd = ( 'echo A | telnet -e A %s %s' % ( serverIP, port ) )
+    cmd = ( 'sh -c "echo A | telnet -e A %s %s"' %
+            ( serverIP, port ) )
     time = 0
-    result = runCmd( cmd )
-    while 'Connected' not in result:
-        if 'No route' in result:
-            rtable = runCmd( 'route' )
-            error( 'no route to %s:\n%s' % ( server, rtable ) )
-            return False
-        if timeout and time >= timeout:
-            error( 'could not connect to %s on port %d\n' % ( server, port ) )
-            return False
-        debug( 'waiting for', server, 'to listen on port', port, '\n' )
-        info( '.' )
+    while 'Connected' not in runCmd( cmd ):
+        if timeout:
+            print time
+            if time >= timeout:
+                error( 'could not connect to %s on port %d\n'
+                       % ( server, port ) )
+                return False
+        output('waiting for', server,
+               'to listen on port', port, '\n')
         sleep( .5 )
         time += .5
-        result = runCmd( cmd )
     return True

util/clustersetup.sh

@@ -25,20 +25,20 @@ clean=false
 declare -a hosts=()
 user=$(whoami)
 SSHDIR=/tmp/mn/ssh
-USERDIR=$HOME/.ssh
-usage="./clustersetup.sh [ -p|h|c ] [ host1 ] [ host2 ] ...\n
+USERDIR=/home/$user/.ssh
+usage=$'./clustersetup.sh [ -p|h|c ] [ host1 ] [ host2 ] ...\n
         Authenticate yourself and other cluster nodes to each other
         via ssh for mininet cluster edition. By default, we use a
         temporary ssh setup. An ssh directory is mounted over
-        $USERDIR on each machine in the cluster.
+        /home/user/.ssh on each machine in the cluster.
         
                 -h: display this help
                 -p: create a persistent ssh setup. This will add
                     new ssh keys and known_hosts to each nodes
-                    $USERDIR directory
+                    /home/user/.ssh directory
                 -c: method to clean up a temporary ssh setup.
                     Any hosts taken as arguments will be cleaned
-        "
+        '
 
 persistentSetup() {
     echo "***creating key pair"
@@ -74,40 +74,40 @@ tempSetup() {
     echo "***creating temporary ssh directory"
     mkdir -p $SSHDIR 
     echo "***creating key pair"
-    ssh-keygen -t rsa -C "Cluster_Edition_Key" -f $SSHDIR/id_rsa -N '' &> /dev/null
+    ssh-keygen -t rsa -C "Cluster_Edition_Key" -f /tmp/mn/ssh/id_rsa -N '' &> /dev/null
 
     echo "***mounting temporary ssh directory"
-    sudo mount --bind $SSHDIR $USERDIR
+    sudo mount --bind $SSHDIR /home/$user/.ssh
     cp $SSHDIR/id_rsa.pub $SSHDIR/authorized_keys
 
-    for host in $hosts; do
-        echo "***copying public key to $host"
-        ssh-copy-id $user@$host &> /dev/null
-        echo "***mounting remote temporary ssh directory for $host"
-        ssh -o ForwardAgent=yes  $user@$host "
-        mkdir -p $SSHDIR
-        cp $USERDIR/authorized_keys $SSHDIR/authorized_keys
-        sudo mount --bind $SSHDIR $USERDIR"
-        echo "***copying key pair to $host"
-        scp $SSHDIR/{id_rsa,id_rsa.pub} $user@$host:$SSHDIR
-    done
+for host in $hosts; do
+    echo "***copying public key to $host"
+    ssh-copy-id $user@$host &> /dev/null
+    echo "***mounting remote temporary ssh directory for $host"
+    ssh -o ForwardAgent=yes  $user@$host "
+    mkdir -p /tmp/mn/ssh
+    cp /home/$user/.ssh/authorized_keys $SSHDIR/authorized_keys
+    sudo mount --bind $SSHDIR /home/$user/.ssh"
+    echo "***copying key pair to $host"
+    scp $SSHDIR/{id_rsa,id_rsa.pub} $user@$host:$SSHDIR
+done
 
-    for host in $hosts; do
-        echo "***copying known_hosts to $host"
-        scp $SSHDIR/known_hosts $user@$host:$SSHDIR
-    done
+for host in $hosts; do
+    echo "***copying known_hosts to $host"
+    scp $SSHDIR/known_hosts $user@$host:$SSHDIR
+done
 }
 
 cleanup() {
     
     for host in $hosts; do
     echo "***cleaning up $host"
-    ssh $user@$host "sudo umount $USERDIR
+    ssh $user@$host "sudo umount /home/$user/.ssh
                           sudo rm -rf $SSHDIR"
     done
 
     echo "**unmounting local directories"
-    sudo umount $USERDIR
+    sudo umount /home/$user/.ssh
     echo "***removing temporary ssh directory"
     sudo rm -rf $SSHDIR
     echo "done!"

util/install.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-# Mininet install script for Ubuntu (and Debian Wheezy+)
+# Mininet install script for Ubuntu (and Debian Lenny)
 # Brandon Heller (brandonh@stanford.edu)
 
 # Fail on error
@@ -102,10 +102,7 @@ OF13_SWITCH_REV=${OF13_SWITCH_REV:-""}
 function kernel {
     echo "Install Mininet-compatible kernel if necessary"
     sudo apt-get update
-    if ! $install linux-image-$KERNEL_NAME; then
-        echo "Could not install linux-image-$KERNEL_NAME"
-        echo "Skipping - assuming installed kernel is OK."
-    fi
+    $install linux-image-$KERNEL_NAME
 }
 
 function kernel_clean {
@@ -192,24 +189,17 @@ function of13 {
     fi
 
     # Install netbee
-    if [ "$DIST" = "Ubuntu" ] && version_ge $RELEASE 14.04; then
-        NBEESRC="nbeesrc-feb-24-2015"
-        NBEEDIR="netbee"
-    else
-        NBEESRC="nbeesrc-jan-10-2013"
-        NBEEDIR="nbeesrc-jan-10-2013"
-    fi
-
+    NBEESRC="nbeesrc-jan-10-2013"
     NBEEURL=${NBEEURL:-http://www.nbee.org/download/}
     wget -nc ${NBEEURL}${NBEESRC}.zip
     unzip ${NBEESRC}.zip
-    cd ${NBEEDIR}/src
+    cd ${NBEESRC}/src
     cmake .
     make
     cd $BUILD_DIR/
-    sudo cp ${NBEEDIR}/bin/libn*.so /usr/local/lib
+    sudo cp ${NBEESRC}/bin/libn*.so /usr/local/lib
     sudo ldconfig
-    sudo cp -R ${NBEEDIR}/include/ /usr/
+    sudo cp -R ${NBEESRC}/include/ /usr/
 
     # Resume the install:
     cd $BUILD_DIR/ofsoftswitch13
@@ -268,63 +258,53 @@ function ubuntuOvs {
     OVS_SRC=$BUILD_DIR/openvswitch
     OVS_TARBALL_LOC=http://openvswitch.org/releases
 
-    if ! echo "$DIST" | egrep "Ubuntu|Debian" > /dev/null; then
-        echo "OS must be Ubuntu or Debian"
-        $cd BUILD_DIR
-        return
-    fi
-    if [ "$DIST" = "Ubuntu" ] && ! version_ge $RELEASE 12.04; then
-        echo "Ubuntu version must be >= 12.04"
-        cd $BUILD_DIR
-        return
-    fi
-    if [ "$DIST" = "Debian" ] && ! version_ge $RELEASE 7.0; then
-        echo "Debian version must be >= 7.0"
-        cd $BUILD_DIR
-        return
-    fi
+    if [ "$DIST" = "Ubuntu" ] && version_ge $RELEASE 12.04; then
+        rm -rf $OVS_SRC
+        mkdir -p $OVS_SRC
+        cd $OVS_SRC
 
-    rm -rf $OVS_SRC
-    mkdir -p $OVS_SRC
-    cd $OVS_SRC
+        if wget $OVS_TARBALL_LOC/openvswitch-$OVS_RELEASE.tar.gz 2> /dev/null; then
+            tar xzf openvswitch-$OVS_RELEASE.tar.gz
+        else
+            echo "Failed to find OVS at $OVS_TARBALL_LOC/openvswitch-$OVS_RELEASE.tar.gz"
+            cd $BUILD_DIR
+            return
+        fi
 
-    if wget $OVS_TARBALL_LOC/openvswitch-$OVS_RELEASE.tar.gz 2> /dev/null; then
-        tar xzf openvswitch-$OVS_RELEASE.tar.gz
+        # Remove any old packages
+        $remove openvswitch-common openvswitch-datapath-dkms openvswitch-controller \
+                openvswitch-pki openvswitch-switch
+
+        # Get build deps
+        $install build-essential fakeroot debhelper autoconf automake libssl-dev \
+                 pkg-config bzip2 openssl python-all procps python-qt4 \
+                 python-zopeinterface python-twisted-conch dkms
+
+        # Build OVS
+        cd $BUILD_DIR/openvswitch/openvswitch-$OVS_RELEASE
+                DEB_BUILD_OPTIONS='parallel=2 nocheck' fakeroot debian/rules binary
+        cd ..
+        $pkginst openvswitch-common_$OVS_RELEASE*.deb openvswitch-datapath-dkms_$OVS_RELEASE*.deb \
+                 openvswitch-pki_$OVS_RELEASE*.deb openvswitch-switch_$OVS_RELEASE*.deb
+        if $pkginst openvswitch-controller_$OVS_RELEASE*.deb; then
+            echo "Ignoring error installing openvswitch-controller"
+        fi
+
+        modinfo openvswitch
+        sudo ovs-vsctl show
+        # Switch can run on its own, but
+        # Mininet should control the controller
+        # This appears to only be an issue on Ubuntu/Debian
+        if sudo service openvswitch-controller stop; then
+            echo "Stopped running controller"
+        fi
+        if [ -e /etc/init.d/openvswitch-controller ]; then
+            sudo update-rc.d openvswitch-controller disable
+        fi
     else
-        echo "Failed to find OVS at $OVS_TARBALL_LOC/openvswitch-$OVS_RELEASE.tar.gz"
-        cd $BUILD_DIR
-        return
-    fi
-
-    # Remove any old packages
-    $remove openvswitch-common openvswitch-datapath-dkms openvswitch-controller \
-            openvswitch-pki openvswitch-switch
-
-    # Get build deps
-    $install build-essential fakeroot debhelper autoconf automake libssl-dev \
-             pkg-config bzip2 openssl python-all procps python-qt4 \
-             python-zopeinterface python-twisted-conch dkms
-
-    # Build OVS
-    cd $BUILD_DIR/openvswitch/openvswitch-$OVS_RELEASE
-            DEB_BUILD_OPTIONS='parallel=2 nocheck' fakeroot debian/rules binary
-    cd ..
-    $pkginst openvswitch-common_$OVS_RELEASE*.deb openvswitch-datapath-dkms_$OVS_RELEASE*.deb \
-             openvswitch-pki_$OVS_RELEASE*.deb openvswitch-switch_$OVS_RELEASE*.deb
-    if $pkginst openvswitch-controller_$OVS_RELEASE*.deb; then
-        echo "Ignoring error installing openvswitch-controller"
-    fi
-
-    modinfo openvswitch
-    sudo ovs-vsctl show
-    # Switch can run on its own, but
-    # Mininet should control the controller
-    # This appears to only be an issue on Ubuntu/Debian
-    if sudo service openvswitch-controller stop; then
-        echo "Stopped running controller"
-    fi
-    if [ -e /etc/init.d/openvswitch-controller ]; then
-        sudo update-rc.d openvswitch-controller disable
+        echo "Failed to install Open vSwitch.  OS must be Ubuntu >= 12.04"
+            cd $BUILD_DIR
+            return
     fi
 }
 
@@ -339,17 +319,14 @@ function ovs {
         return
     fi
 
-    if [ "$DIST" = "Ubuntu" ] && ! version_ge $RELEASE 14.04; then
-        # Older Ubuntu versions need openvswitch-datapath/-dkms
-        # Manually installing openvswitch-datapath may be necessary
-        # for manually built kernel .debs using Debian's defective kernel
-        # packaging, which doesn't yield usable headers.
-        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
+    # Manually installing openvswitch-datapath may be necessary
+    # for manually built kernel .debs using Debian's defective kernel
+    # packaging, which doesn't yield usable headers.
+    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
 
     $install openvswitch-switch
@@ -366,7 +343,7 @@ function ovs {
     else
         echo "Attempting to install openvswitch-testcontroller"
         if ! $install openvswitch-testcontroller; then
-            echo "Failed - skipping openvswitch-testcontroller"
+            echo "Failed - giving up"
         fi
     fi
 
@@ -590,7 +567,7 @@ net.ipv6.conf.lo.disable_ipv6 = 1' | sudo tee -a /etc/sysctl.conf > /dev/null
     # Since the above doesn't disable neighbor discovery, also do this:
     if ! grep 'ipv6.disable' /etc/default/grub; then
         sudo sed -i -e \
-        's/GRUB_CMDLINE_LINUX_DEFAULT="/GRUB_CMDLINE_LINUX_DEFAULT="ipv6.disable=1 /' \
+        's/GRUB_CMDLINE_LINUX_DEFAULT="/GRUB_CMDLINE_LINUX_DEFAULT="ipv6.disable=1/' \
         /etc/default/grub
         sudo update-grub
     fi

util/versioncheck.py

@@ -8,7 +8,7 @@ version = 'Mininet ' + co( 'PYTHONPATH=. bin/mn --version', shell=True )
 version = version.strip()
 
 # Find all Mininet path references
-lines = co( "egrep -or 'Mininet [0-9\.\+]+\w*' *", shell=True )
+lines = co( "egrep -or 'Mininet [0-9\.]+\w*' *", shell=True )
 
 error = False
 

util/vm/build.py

@@ -323,7 +323,7 @@ zerombr yes
 clearpart --all --initlabel
 #Automatic partitioning
 autopart
-#System authorization information
+#System authorization infomation
 auth  --useshadow  --enablemd5
 #Firewall configuration
 firewall --disabled