Default ipv6 action should be 'add'

This may be a useful feature, but it doesn't fit well into
the established Mininet API, which assumes a single default
IP address for each interface.

.github/ISSUE_TEMPLATE

@@ -1,19 +0,0 @@
-Mininet uses GitHub issues for bug reports and feature requests only.
-These issues can be viewed at bugs.mininet.org
-
-If you have a question that is not a bug report or a feature request,
-please use the documentation at docs.mininet.org, the FAQ
-at faq.mininet.org, and the mininet-discuss mailing list.
-
-For bug reports, please fill in the following information in detail,
-and also feel free to include additional information such as debug
-output from mn -v debug, etc.
---- Cut Here ---
-### Expected/Desired Behavior:
-
-### Actual Behavior:
-
-### Detailed Steps to Reproduce the Behavior:
-
-### Additional Information:
-

.pylint

@@ -44,9 +44,7 @@ load-plugins=
 disable=pointless-except, invalid-name, super-init-not-called, fixme, star-args,
         too-many-instance-attributes, too-few-public-methods, too-many-arguments,
         too-many-locals, too-many-public-methods, duplicate-code, bad-whitespace,
-        locally-disabled, locally-enabled
-
-# bad-continuation, wrong-import-order
+        locally-disabled
 
 [REPORTS]
 
@@ -63,7 +61,7 @@ include-ids=yes
 # written in a file name "pylint_global.[txt|html]".
 files-output=no
 
-# Tells whether to display a full report or only the messages
+# Tells wether to display a full report or only the messages
 reports=no
 
 # Python expression which should return a note less than 10 (10 is the highes
@@ -113,10 +111,10 @@ const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
 class-rgx=[A-Z_][a-zA-Z0-9]+$
 
 # Regular expression which should only match correct function names
-function-rgx=[a-z_][a-z0-9]{2,30}$
+function-rgx=[a-z_][a-z0-9_]{2,30}$
 
 # Regular expression which should only match correct method names
-method-rgx=[a-z_][a-z0-9]{2,30}$
+method-rgx=[a-z_][a-z0-9_]{2,30}$
 
 # Regular expression which should only match correct instance attribute names
 attr-rgx=[a-z_][a-z0-9_]{2,30}$
@@ -125,7 +123,7 @@ attr-rgx=[a-z_][a-z0-9_]{2,30}$
 argument-rgx=[a-z_][a-z0-9_]{2,30}$
 
 # Regular expression which should only match correct variable names
-variable-rgx=[a-z_][a-z0-9]{2,30}$
+variable-rgx=[a-z_][a-z0-9_]{2,30}$
 
 # Regular expression which should only match correct list comprehension /
 # generator expression variable names

.travis.yml

@@ -1,35 +0,0 @@
-language: python
-sudo: required
-
-matrix:
-  include:
-    - dist: trusty
-      python: 2.7
-      env: dist="14.04 LTS trusty"
-    - dist: trusty
-      python: 3.6
-      env: dist="14.04 LTS trusty"
-
-before_install:
-- sudo apt-get update -qq
-- sudo apt-get install -qq vlan
-- PYTHON=`which python` util/install.sh -n
-
-install:
-- bash -c "if [ `lsb_release -rs` == '14.04' ]; then make codecheck; fi"
-- pip install pexpect || pip3 install pexpect
-- util/install.sh -nfvw
-
-script:
-- alias sudo="sudo env PATH=$PATH"
-- export PYTHON=`which python`
-- echo 'px import sys; print(sys.version_info)' | sudo $PYTHON bin/mn -v output
-- sudo $PYTHON bin/mn --test pingall
-- sudo $PYTHON mininet/test/runner.py -v -quick
-- sudo $PYTHON examples/test/runner.py -v -quick
-
-notifications:
-  email:
-    on_success: never
-
-# More details: https://docs.travis-ci.com/user/notifications

CONTRIBUTORS

@@ -29,13 +29,10 @@ 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

INSTALL

@@ -2,7 +2,7 @@
 Mininet Installation/Configuration Notes
 ----------------------------------------
 
-Mininet 2.3.0d5
+Mininet 2.2.1d2
 ---
 
 The supported installation methods for Mininet are 1) using a
@@ -65,7 +65,7 @@ like to contribute an installation script, we would welcome it!)
    where <release tag> is the release you want to check out.
 
    If you are running Ubuntu, Debian, or Fedora, you may be able to use
-   our handy `install.sh` script, which is in `util/`.
+   our handy `install.sh` script, which is in `mininet/util`.
 
    *WARNING: USE AT YOUR OWN RISK!*
 
@@ -81,7 +81,7 @@ like to contribute an installation script, we would welcome it!)
    To install Mininet itself, the OpenFlow reference implementation, and
    Open vSwitch, you may use:
 
-        util/install.sh -fnv
+        mininet/util/install.sh -fnv
 
    This should be reasonably quick, and the following command should
    work after the installation:
@@ -92,14 +92,14 @@ like to contribute an installation script, we would welcome it!)
    including POX, the OpenFlow WireShark dissector, the `oftest`
    framework, and other potentially useful software, you may use:
 
-        util/install.sh -a
+        mininet/util/install.sh -a
 
    This takes about 4 minutes on our test system.
 
    You can change the directory where the dependencies are installed using
    the -s <directory> flag.
 
-        util/install.sh -s <directory> -a
+        mininet/util/install.sh -s <directory> -a
 
 3.2. Native installation from source on Fedora 18+.
 
@@ -128,7 +128,7 @@ like to contribute an installation script, we would welcome it!)
     * install Mininet, the OpenFlow reference implementation, and
       Open vSwitch
 
-        util/install.sh -fnv
+        mininet/util/install.sh -fnv
 
     * enable and start openvswitch
 

LICENSE

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

Makefile

@@ -2,16 +2,13 @@ MININET = mininet/*.py
 TEST = mininet/test/*.py
 EXAMPLES = mininet/examples/*.py
 MN = bin/mn
-PYTHON ?= python
-PYMN = $(PYTHON) -B bin/mn
 BIN = $(MN)
 PYSRC = $(MININET) $(TEST) $(EXAMPLES) $(BIN)
 MNEXEC = mnexec
 MANPAGES = mn.1 mnexec.1
 P8IGN = E251,E201,E302,E202,E126,E127,E203,E226
-PREFIX ?= /usr
-BINDIR ?= $(PREFIX)/bin
-MANDIR ?= $(PREFIX)/share/man/man1
+BINDIR = /usr/bin
+MANDIR = /usr/share/man/man1
 DOCDIRS = doc/html doc/latex
 PDF = doc/latex/refman.pdf
 
@@ -46,28 +43,24 @@ slowtest: $(MININET)
 	mininet/examples/test/runner.py -v
 
 mnexec: mnexec.c $(MN) mininet/net.py
-	cc $(CFLAGS) $(LDFLAGS) -DVERSION=\"`PYTHONPATH=. $(PYMN) --version`\" $< -o $@
+	cc $(CFLAGS) $(LDFLAGS) -DVERSION=\"`PYTHONPATH=. $(MN) --version`\" $< -o $@
 
-install-mnexec: $(MNEXEC)
-	install -D $(MNEXEC) $(BINDIR)/$(MNEXEC)
-
-install-manpages: $(MANPAGES)
-	install -D -t $(MANDIR) $(MANPAGES)
-
-install: install-mnexec install-manpages
-	$(PYTHON) setup.py install
+install: $(MNEXEC) $(MANPAGES)
+	install $(MNEXEC) $(BINDIR)
+	install $(MANPAGES) $(MANDIR)
+	python setup.py install
 
 develop: $(MNEXEC) $(MANPAGES)
 # 	Perhaps we should link these as well
 	install $(MNEXEC) $(BINDIR)
 	install $(MANPAGES) $(MANDIR)
-	$(PYTHON) setup.py develop
+	python setup.py develop
 
 man: $(MANPAGES)
 
 mn.1: $(MN)
 	PYTHONPATH=. help2man -N -n "create a Mininet network." \
-	--no-discard-stderr "$(PYMN)" -o $@
+	--no-discard-stderr $< -o $@
 
 mnexec.1: mnexec
 	help2man -N -n "execution utility for Mininet." \

README.md

@@ -1,10 +1,9 @@
 Mininet: Rapid Prototyping for Software Defined Networks
 ========================================================
+
 *The best way to emulate almost any network on your laptop!*
 
-Mininet 2.3.0d5
-
-[![Build Status][1]](https://travis-ci.org/mininet/mininet)
+Mininet 2.2.1d2
 
 ### What is Mininet?
 
@@ -84,8 +83,6 @@ This is primarily a performance improvement and bug fix release.
   significantly better performance than veth pairs, for certain
   configurations.
 
-- You can now easily install Mininet on a Raspberry Pi ;-)
-
 - Additional information for this release and previous releases
   may be found in the release notes on docs.mininet.org
 
@@ -111,8 +108,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,
@@ -126,7 +121,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.
 
-[1]: https://travis-ci.org/mininet/mininet.svg?branch=master

bin/mn

@@ -21,18 +21,17 @@ if 'PYTHONPATH' in os.environ:
     sys.path = os.environ[ 'PYTHONPATH' ].split( ':' ) + sys.path
 
 from mininet.clean import cleanup
-import mininet.cli
-from mininet.log import lg, LEVELS, info, debug, warn, error, output
+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,
+                           DefaultController,
                            UserSwitch, OVSSwitch, OVSBridge,
                            IVSSwitch )
 from mininet.nodelib import LinuxBridge
-from mininet.link import Link, TCLink, TCULink, OVSLink
-from mininet.topo import ( SingleSwitchTopo, LinearTopo,
-                           SingleSwitchReversedTopo, MinimalTopo )
+from mininet.link import Link, TCLink, OVSLink
+from mininet.topo import SingleSwitchTopo, LinearTopo, SingleSwitchReversedTopo
 from mininet.topolib import TreeTopo, TorusTopo
 from mininet.util import customClass, specialClass, splitArgs
 from mininet.util import buildTopo
@@ -50,7 +49,7 @@ 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,
@@ -78,81 +77,43 @@ CONTROLLERS = { 'ref': Controller,
                 'nox': NOX,
                 'remote': RemoteController,
                 'ryu': Ryu,
-                'default': DefaultController,  # Note: overridden below
-                'none': NullController }
+                'default': DefaultController,  # Note: replaced below
+                'none': lambda name: None }
 
 LINKDEF = 'default'
-LINKS = { 'default': Link,  # Note: overridden below
+LINKS = { 'default': Link,
           'tc': TCLink,
-          'tcu': TCULink,
           'ovs': OVSLink }
 
-# TESTS dict can contain functions and/or Mininet() method names
-# XXX: it would be nice if we could specify a default test, but
-# this may be tricky
-TESTS = { name: True
-          for name in ( 'pingall', 'pingpair', 'iperf', 'iperfudp' ) }
 
-CLI = None  # Set below if needed
+# optional tests to run
+TESTS = [ 'cli', 'build', 'pingall', 'pingpair', 'iperf', 'all', 'iperfudp',
+          'none' ]
 
-# Locally defined tests
-def allTest( net ):
-    "Run ping and iperf tests"
-    net.waitConnected()
-    net.start()
-    net.ping()
-    net.iperf()
-
-def nullTest( _net ):
-    "Null 'test' (does nothing)"
-    pass
-
-TESTS.update( all=allTest, none=nullTest, build=nullTest )
-
-# Map to alternate spellings of Mininet() methods
-ALTSPELLING = { 'pingall': 'pingAll', 'pingpair': 'pingPair',
-                'iperfudp': 'iperfUdp' }
-
-def runTests( mn, options ):
-    """Run tests
-       mn: Mininet object
-       option: list of test optinos """
-    # Split option into test name and parameters
-    for option in options:
-        # Multiple tests may be separated by '+' for now
-        for test in option.split( '+' ):
-            test, args, kwargs = splitArgs( test )
-            test = ALTSPELLING.get( test.lower(), test )
-            testfn = TESTS.get( test, test )
-            if callable( testfn ):
-                testfn( mn, *args, **kwargs )
-            elif hasattr( mn, test ):
-                mn.waitConnected()
-                getattr( mn, test )( *args, **kwargs )
-            else:
-                raise Exception( 'Test %s is unknown - please specify one of '
-                                 '%s ' % ( test, TESTS.keys() ) )
+ALTSPELLING = { 'pingall': 'pingAll',
+                'pingpair': 'pingPair',
+                'iperfudp': 'iperfUdp',
+                'iperfUDP': 'iperfUdp' }
 
 
-def addDictOption( opts, choicesDict, default, name, **kwargs ):
+def addDictOption( opts, choicesDict, default, name, helpStr=None, **kwargs ):
     """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
+       helpStr: help string
        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 ) )
+    if not helpStr:
+        helpStr = ( '|'.join( sorted( choicesDict.keys() ) ) +
+                    '[,param=value...]' )
     params = dict( type='string', default=default, help=helpStr )
     params.update( **kwargs )
     opts.add_option( '--' + name, **params )
 
 def version( *_args ):
     "Print Mininet version and exit"
-    output( "%s\n" % VERSION )
+    print "%s" % VERSION
     exit()
 
 
@@ -186,18 +147,15 @@ class MininetRunner( object ):
         for fileName in files:
             customs = {}
             if os.path.isfile( fileName ):
-                # pylint: disable=exec-used
-                exec( compile( open( fileName ).read(), fileName, 'exec' ),
-                      customs, customs )
-                for name, val in customs.items():
+                execfile( fileName, customs, customs )
+                for name, val in customs.iteritems():
                     self.setCustom( name, val )
             else:
                 raise Exception( 'could not find custom file: %s' % fileName )
 
     def setCustom( self, name, value ):
         "Set custom parameters for MininetRunner."
-        if name in ( 'topos', 'switches', 'hosts', 'controllers', 'links'
-                     'testnames', 'tests' ):
+        if name in ( 'topos', 'switches', 'hosts', 'controllers' ):
             # Update dictionaries
             param = name.upper()
             globals()[ param ].update( value )
@@ -247,8 +205,10 @@ class MininetRunner( object ):
                          type='string',
                          help='read custom classes or params from .py file(s)'
                          )
-        opts.add_option( '--test', default=[], action='append',
-                         dest='test', help='|'.join( TESTS.keys() ) )
+
+        opts.add_option( '--test', type='choice', choices=TESTS,
+                         default=TESTS[ 0 ],
+                         help='|'.join( TESTS ) )
         opts.add_option( '--xterms', '-x', action='store_true',
                          default=False, help='spawn xterms for each node' )
         opts.add_option( '--ipbase', '-i', type='string', default='10.0.0.0/8',
@@ -258,11 +218,11 @@ class MininetRunner( object ):
         opts.add_option( '--arp', action='store_true',
                          default=False, help='set all-pairs ARP entries' )
         opts.add_option( '--verbosity', '-v', type='choice',
-                         choices=list( LEVELS.keys() ), default = 'info',
+                         choices=LEVELS.keys(), default = 'info',
                          help = '|'.join( LEVELS.keys() )  )
         opts.add_option( '--innamespace', action='store_true',
                          default=False, help='sw and ctrl in namespace?' )
-        opts.add_option( '--listenport', type='int', default=6654,
+        opts.add_option( '--listenport', type='int', default=6634,
                          help='base port for passive switch listening' )
         opts.add_option( '--nolistenport', action='store_true',
                          default=False, help="don't use passive listening " +
@@ -275,7 +235,7 @@ class MininetRunner( object ):
                          default=False, help="pin hosts to CPU cores "
                          "(requires --host cfs or --host rt)" )
         opts.add_option( '--nat', action='callback', callback=self.setNat,
-                         help="[option=val...] adds a NAT to the topology that"
+                         help="adds a NAT to the topology that"
                          " connects Mininet hosts to the physical network."
                          " Warning: This may route any traffic on the machine"
                          " that uses Mininet's"
@@ -288,7 +248,7 @@ class MininetRunner( object ):
                          metavar='server1,server2...',
                          help=( 'run on multiple servers (experimental!)' ) )
         opts.add_option( '--placement', type='choice',
-                         choices=list( PLACEMENT.keys() ), default='block',
+                         choices=PLACEMENT.keys(), default='block',
                          metavar='block|random',
                          help=( 'node placement for --cluster '
                                 '(experimental!) ' ) )
@@ -305,106 +265,116 @@ class MininetRunner( object ):
 
         # set logging verbosity
         if LEVELS[self.options.verbosity] > LEVELS['output']:
-            warn( '*** WARNING: selected verbosity level (%s) will hide CLI '
+            print ( '*** WARNING: selected verbosity level (%s) will hide CLI '
                     'output!\n'
-                    'Please restart Mininet with -v [debug, info, output].\n'
+                    'Please restart Mininet with -v [debug, info, output].'
                     % self.options.verbosity )
         lg.setLogLevel( self.options.verbosity )
 
     # Maybe we'll reorganize this someday...
-    # pylint: disable=too-many-branches,too-many-statements,global-statement
+    # pylint: disable=too-many-branches,too-many-statements
 
     def begin( self ):
         "Create and run mininet."
 
-        global CLI
-
-        opts = self.options
-
-        if opts.cluster:
-            servers = opts.cluster.split( ',' )
+        if self.options.cluster:
+            servers = self.options.cluster.split( ',' )
             for server in servers:
                 ClusterCleanup.add( server )
 
-        if opts.clean:
+        if self.options.clean:
             cleanup()
             exit()
 
         start = time.time()
 
-        if not opts.controller:
+        if not self.options.controller:
             # Update default based on available controllers
             CONTROLLERS[ 'default' ] = findController()
-            opts.controller = [ 'default' ]
+            self.options.controller = [ 'default' ]
             if not CONTROLLERS[ 'default' ]:
-                opts.controller = [ 'none' ]
-                if opts.switch == 'default':
+                self.options.controller = [ 'none' ]
+                if self.options.switch == 'default':
                     info( '*** No default OpenFlow controller found '
                           'for default switch!\n' )
                     info( '*** Falling back to OVS Bridge\n' )
-                    opts.switch = 'ovsbr'
-                elif opts.switch not in ( 'ovsbr', 'lxbr' ):
+                    self.options.switch = 'ovsbr'
+                elif self.options.switch not in ( 'ovsbr', 'lxbr' ):
                     raise Exception( "Could not find a default controller "
                                      "for switch %s" %
-                                     opts.switch )
+                                     self.options.switch )
 
-        topo = buildTopo( TOPOS, opts.topo )
-        switch = customClass( SWITCHES, opts.switch )
-        host = customClass( HOSTS, opts.host )
+        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 opts.controller ]
-
-        if opts.switch == 'user' and opts.link == 'default':
-            debug( '*** Using TCULink with UserSwitch\n' )
-            # Use link configured correctly for UserSwitch
-            opts.link = 'tcu'
-
-        link = customClass( LINKS, opts.link )
+                       for c in self.options.controller ]
+        link = customClass( LINKS, self.options.link )
 
         if self.validate:
-            self.validate( opts )
+            self.validate( self.options )
 
-        if opts.nolistenport:
-            opts.listenport = None
+        ipBase = self.options.ipbase
+        xterms = self.options.xterms
+        mac = self.options.mac
+        arp = self.options.arp
+        pin = self.options.pin
+        listenPort = None
+        if not self.options.nolistenport:
+            listenPort = self.options.listenport
 
-        # Handle innamespace, cluster options
-        if opts.innamespace and opts.cluster:
-            error( "Please specify --innamespace OR --cluster\n" )
+        # Handle inNamespace, cluster options
+        inNamespace = self.options.innamespace
+        cluster = self.options.cluster
+        if inNamespace and cluster:
+            print "Please specify --innamespace OR --cluster"
             exit()
-        Net = MininetWithControlNet if opts.innamespace else Mininet
-        if opts.cluster:
+        Net = MininetWithControlNet if inNamespace else Mininet
+        cli = ClusterCLI if cluster else CLI
+        if cluster:
             warn( '*** WARNING: Experimental cluster mode!\n'
                   '*** Using RemoteHost, RemoteOVSSwitch, RemoteLink\n' )
             host, switch, link = RemoteHost, RemoteOVSSwitch, RemoteLink
             Net = partial( MininetCluster, servers=servers,
-                           placement=PLACEMENT[ opts.placement ] )
-            mininet.cli.CLI = ClusterCLI
+                           placement=PLACEMENT[ self.options.placement ] )
 
         mn = Net( topo=topo,
-                  switch=switch, host=host, controller=controller, link=link,
-                  ipBase=opts.ipbase, inNamespace=opts.innamespace,
-                  xterms=opts.xterms, autoSetMacs=opts.mac,
-                  autoStaticArp=opts.arp, autoPinCpus=opts.pin,
-                  listenPort=opts.listenport )
+                  switch=switch, host=host, controller=controller,
+                  link=link,
+                  ipBase=ipBase,
+                  inNamespace=inNamespace,
+                  xterms=xterms, autoSetMacs=mac,
+                  autoStaticArp=arp, autoPinCpus=pin,
+                  listenPort=listenPort )
 
-        if opts.ensure_value( 'nat', False ):
-            mn.addNAT( *opts.nat_args, **opts.nat_kwargs ).configDefault()
+        if self.options.ensure_value( 'nat', False ):
+            nat = mn.addNAT( *self.options.nat_args,
+                             **self.options.nat_kwargs )
+            nat.configDefault()
 
-        # --custom files can set CLI or change mininet.cli.CLI
-        CLI = mininet.cli.CLI if CLI is None else CLI
+        if self.options.pre:
+            cli( mn, script=self.options.pre )
 
-        if opts.pre:
-            CLI( mn, script=opts.pre )
+        test = self.options.test
+        test = ALTSPELLING.get( test, test )
 
         mn.start()
 
-        if opts.test:
-            runTests( mn, opts.test )
-        else:
-            CLI( mn )
+        if test == 'none':
+            pass
+        elif test == 'all':
+            mn.waitConnected()
+            mn.start()
+            mn.ping()
+            mn.iperf()
+        elif test == 'cli':
+            cli( mn )
+        elif test != 'build':
+            mn.waitConnected()
+            getattr( mn, test )()
 
-        if opts.post:
-            CLI( mn, script=opts.post )
+        if self.options.post:
+            cli( mn, script=self.options.post )
 
         mn.stop()
 

custom/topo-2sw-2host.py

@@ -13,9 +13,12 @@ from mininet.topo import Topo
 class MyTopo( Topo ):
     "Simple topology example."
 
-    def build( self ):
+    def __init__( self ):
         "Create custom topo."
 
+        # Initialize topology
+        Topo.__init__( self )
+
         # Add hosts and switches
         leftHost = self.addHost( 'h1' )
         rightHost = self.addHost( 'h2' )

examples/baresshd.py

@@ -3,35 +3,32 @@
 "This example doesn't use OpenFlow, but attempts to run sshd in a namespace."
 
 import sys
-
 from mininet.node import Host
 from mininet.util import ensureRoot, waitListening
-from mininet.log import info, warn, output
-
 
 ensureRoot()
 timeout = 5
 
-info( "*** Creating nodes\n" )
+print "*** Creating nodes"
 h1 = Host( 'h1' )
 
 root = Host( 'root', inNamespace=False )
 
-info( "*** Creating link\n" )
+print "*** Creating links"
 h1.linkTo( root )
 
-info( h1 )
+print h1
 
-info( "*** Configuring nodes\n" )
+print "*** Configuring nodes"
 h1.setIP( '10.0.0.1', 8 )
 root.setIP( '10.0.0.2', 8 )
 
-info( "*** Creating banner file\n" )
+print "*** Creating banner file"
 f = open( '/tmp/%s.banner' % h1.name, 'w' )
 f.write( 'Welcome to %s at %s\n' % ( h1.name, h1.IP() ) )
 f.close()
 
-info( "*** Running sshd\n" )
+print "*** Running sshd"
 cmd = '/usr/sbin/sshd -o UseDNS=no -u0 -o "Banner /tmp/%s.banner"' % h1.name
 # add arguments from the command line
 if len( sys.argv ) > 1:
@@ -40,7 +37,7 @@ h1.cmd( cmd )
 listening = waitListening( server=h1, port=22, timeout=timeout )
 
 if listening:
-    output( "*** You may now ssh into", h1.name, "at", h1.IP(), '\n' )
+    print "*** You may now ssh into", h1.name, "at", h1.IP()
 else:
-    warn( "*** Warning: after %s seconds, %s is not listening on port 22"
-            % ( timeout, h1.name ), '\n' )
+    print ( "*** Warning: after %s seconds, %s is not listening on port 22"
+            % ( timeout, h1.name ) )

examples/cluster.py

@@ -74,7 +74,6 @@ Things to do:
 - hifi support (e.g. delay compensation)
 """
 
-
 from mininet.node import Node, Host, OVSSwitch, Controller
 from mininet.link import Link, Intf
 from mininet.net import Mininet
@@ -104,7 +103,7 @@ def findUser():
             # 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' ).strip() )
+            quietRun( 'whoami' ) )
 
 
 class ClusterCleanup( object ):
@@ -126,7 +125,7 @@ class ClusterCleanup( object ):
     def cleanup( cls ):
         "Clean up"
         info( '*** Cleaning up cluster\n' )
-        for server, user in cls.serveruser.items():
+        for server, user in cls.serveruser.iteritems():
             if server == 'localhost':
                 # Handled by mininet.clean.cleanup()
                 continue
@@ -239,7 +238,7 @@ class RemoteMixin( object ):
            args: string or list of strings
            returns: stdout and stderr"""
         popen = self.rpopen( *cmd, **opts )
-        # info( 'RCMD: POPEN:', popen, '\n' )
+        # print 'RCMD: POPEN:', popen
         # These loops are tricky to get right.
         # Once the process exits, we can read
         # EOF twice if necessary.
@@ -288,7 +287,7 @@ class RemoteMixin( object ):
 
     def addIntf( self, *args, **kwargs ):
         "Override: use RemoteLink.moveIntf"
-        # kwargs.update( moveIntfFn=RemoteLink.moveIntf )
+        kwargs.update( moveIntfFn=RemoteLink.moveIntf )
         return super( RemoteMixin, self).addIntf( *args, **kwargs )
 
 
@@ -393,30 +392,33 @@ class RemoteLink( Link ):
         return self.tunnel
 
     @staticmethod
-    def moveIntf( intf, node ):
+    def moveIntf( intf, node, printError=True ):
         """Move remote interface from root ns to node
             intf: string, interface
             dstNode: destination Node
-            srcNode: source Node or None (default) for root ns"""
+            srcNode: source Node or None (default) for root ns
+            printError: if true, print error"""
         intf = str( intf )
         cmd = 'ip link set %s netns %s' % ( intf, node.pid )
-        result = node.rcmd( cmd )
-        if result:
-            raise Exception('error executing command %s' % cmd)
+        node.rcmd( cmd )
+        links = node.cmd( 'ip link show' )
+        if not ' %s:' % intf in links:
+            if printError:
+                error( '*** Error: RemoteLink.moveIntf: ' + intf +
+                       ' not successfully moved to ' + node.name + '\n' )
+            return False
         return True
 
     def makeTunnel( self, node1, node2, intfname1, intfname2,
                     addr1=None, addr2=None ):
         "Make a tunnel across switches on different servers"
         # We should never try to create a tunnel to ourselves!
-        assert node1.server != node2.server
+        assert node1.server != 'localhost' or node2.server != 'localhost'
         # And we can't ssh into this server remotely as 'localhost',
         # so try again swappping node1 and node2
         if node2.server == 'localhost':
             return self.makeTunnel( node2, node1, intfname2, intfname1,
                                     addr2, addr1 )
-        debug( '\n*** Make SSH tunnel ' + node1.server + ':' + intfname1 +
-               ' == ' + node2.server + ':' + intfname2 )
         # 1. Create tap interfaces
         for node in node1, node2:
             # For now we are hard-wiring tap9, which we will rename
@@ -472,91 +474,6 @@ class RemoteLink( Link ):
         return result
 
 
-class RemoteSSHLink( RemoteLink ):
-    "Remote link using SSH tunnels"
-    def __init__(self, node1, node2, **kwargs):
-        RemoteLink.__init__( self, node1, node2, **kwargs )
-
-
-class RemoteGRELink( RemoteLink ):
-    "Remote link using GRE tunnels"
-
-    GRE_KEY = 0
-
-    def __init__(self, node1, node2, **kwargs):
-        RemoteLink.__init__( self, node1, node2, **kwargs )
-
-    def stop( self ):
-        "Stop this link"
-        if self.tunnel:
-            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   ):
-        """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
-        server1 = getattr( node1, 'server', 'localhost' )
-        server2 = getattr( node2, 'server', 'localhost' )
-        if server1 == server2:
-            # Link within same server
-            Link.makeIntfPair( intfname1, intfname2, addr1, addr2,
-                               node1, node2, deleteIntfs=deleteIntfs )
-            # Need to reduce the MTU of all emulated hosts to 1450 for GRE
-            # tunneling, otherwise packets larger than 1400 bytes cannot be
-            # successfully transmitted through the tunnel.
-            node1.cmd('ip link set dev %s mtu 1450' % intfname1)
-            node2.cmd('ip link set dev %s mtu 1450' % intfname2)
-        else:
-            # Otherwise, make a tunnel
-            self.makeTunnel( node1, node2, intfname1, intfname2, addr1, addr2 )
-            self.tunnel = 1
-
-    def makeTunnel(self, node1, node2, intfname1, intfname2,
-                       addr1=None, addr2=None):
-        "Make a tunnel across switches on different servers"
-        # We should never try to create a tunnel to ourselves!
-        assert node1.server != node2.server
-        if node2.server == 'localhost':
-            return self.makeTunnel( node2, node1, intfname2, intfname1,
-                                    addr2, addr1 )
-        IP1, IP2 = node1.serverIP, node2.serverIP
-        # GRE tunnel needs to be set up with the IP of the local interface
-        # that connects the remote node, NOT '127.0.0.1' of localhost
-        if node1.server == 'localhost':
-            output = quietRun('ip route get %s' % node2.serverIP)
-            IP1 = output.split(' src ')[1].split()[0]
-        debug( '\n*** Make GRE tunnel ' + node1.server + ':' + intfname1 +
-               ' == ' + node2.server + ':' + intfname2 )
-        tun1 = 'local ' + IP1 + ' remote ' + IP2
-        tun2 = 'local ' + IP2 + ' remote ' + IP1
-        self.__class__.GRE_KEY += 1
-        for (node, intfname, addr, tun) in [(node1, intfname1, addr1, tun1),
-                                            (node2, intfname2, addr2, tun2)]:
-            node.rcmd('ip link delete ' + intfname)
-            result = node.rcmd('ip link add name ' + intfname + ' type gretap '
-                               + tun + ' ttl 64 key '
-                               + str( self.__class__.GRE_KEY) )
-            if result:
-                raise Exception('error creating gretap on %s: %s'
-                                % (node, result))
-            if addr:
-                node.rcmd('ip link set %s address %s' % (intfname, addr))
-
-            node.rcmd('ip link set dev %s up' % intfname)
-            node.rcmd('ip link set dev %s mtu 1450' % intfname)
-            if not self.moveIntf(intfname, node):
-                raise Exception('interface move failed on node %s' % node)
-
-
 # Some simple placement algorithms for MininetCluster
 
 class Placer( object ):
@@ -843,26 +760,11 @@ class MininetCluster( Mininet ):
     def addController( self, *args, **kwargs ):
         "Patch to update IP address to global IP address"
         controller = Mininet.addController( self, *args, **kwargs )
-        loopback = '127.0.0.1'
-        if ( not isinstance( controller, Controller ) or
-             controller.IP() != loopback ):
-            return
-        # Find route to a different server IP address
-        serverIPs = [ ip for ip in self.serverIP.values()
-                      if ip is not controller.IP() ]
-        if not serverIPs:
-            return  # no remote servers - loopback is fine
-        remoteIP = serverIPs[ 0 ]
-        # Route should contain 'dev <intfname>'
-        route = controller.cmd( 'ip route get', remoteIP,
-                                r'| egrep -o "dev\s[^[:space:]]+"' )
-        if not route:
-            raise Exception('addController: no route from', controller,
-                            'to', remoteIP )
-        intf = route.split()[ 1 ].strip()
-        debug( 'adding', intf, 'to', controller )
-        Intf( intf, node=controller ).updateIP()
-        debug( controller, 'IP address updated to', controller.IP() )
+        # Update IP address for controller that may not be local
+        if ( isinstance( controller, Controller)
+             and controller.IP() == '127.0.0.1'
+             and ' eth0:' in controller.cmd( 'ip link show' ) ):
+            Intf( 'eth0', node=controller ).updateIP()
         return controller
 
     def buildFromTopo( self, *args, **kwargs ):
@@ -873,11 +775,11 @@ class MininetCluster( Mininet ):
         Mininet.buildFromTopo( self, *args, **kwargs )
 
 
-def testNsTunnels( remote='ubuntu2', link=RemoteGRELink ):
+def testNsTunnels():
     "Test tunnels between nodes in namespaces"
-    net = Mininet( host=RemoteHost, link=link )
-    h1 = net.addHost( 'h1')
-    h2 = net.addHost( 'h2', server=remote )
+    net = Mininet( host=RemoteHost, link=RemoteLink )
+    h1 = net.addHost( 'h1' )
+    h2 = net.addHost( 'h2', server='ubuntu2' )
     net.addLink( h1, h2 )
     net.start()
     net.pingAll()
@@ -888,30 +790,30 @@ def testNsTunnels( remote='ubuntu2', link=RemoteGRELink ):
 # This shows how node options may be used to manage
 # cluster placement using the net.add*() API
 
-def testRemoteNet( remote='ubuntu2', link=RemoteGRELink ):
+def testRemoteNet( remote='ubuntu2' ):
     "Test remote Node classes"
-    info( '*** Remote Node Test\n' )
-    net = Mininet( host=RemoteHost, switch=RemoteOVSSwitch, link=link )
+    print '*** Remote Node Test'
+    net = Mininet( host=RemoteHost, switch=RemoteOVSSwitch,
+                   link=RemoteLink )
     c0 = net.addController( 'c0' )
     # Make sure controller knows its non-loopback address
     Intf( 'eth0', node=c0 ).updateIP()
-    info( "*** Creating local h1\n" )
+    print "*** Creating local h1"
     h1 = net.addHost( 'h1' )
-    info( "*** Creating remote h2\n" )
+    print "*** Creating remote h2"
     h2 = net.addHost( 'h2', server=remote )
-    info( "*** Creating local s1\n" )
+    print "*** Creating local s1"
     s1 = net.addSwitch( 's1' )
-    info( "*** Creating remote s2\n" )
+    print "*** Creating remote s2"
     s2 = net.addSwitch( 's2', server=remote )
-    info( "*** Adding links\n" )
+    print "*** Adding links"
     net.addLink( h1, s1 )
     net.addLink( s1, s2 )
     net.addLink( h2, s2 )
     net.start()
-    info( 'Mininet is running on', quietRun( 'hostname' ).strip(), '\n' )
+    print 'Mininet is running on', quietRun( 'hostname' ).strip()
     for node in c0, h1, h2, s1, s2:
-        info( 'Node', node, 'is running on',
-              node.cmd( 'hostname' ).strip(), '\n' )
+        print 'Node', node, 'is running on', node.cmd( 'hostname' ).strip()
     net.pingAll()
     CLI( net )
     net.stop()
@@ -949,11 +851,11 @@ def ClusterController( *args, **kwargs):
     Intf( 'eth0', node=controller ).updateIP()
     return controller
 
-def testRemoteTopo( link=RemoteGRELink ):
+def testRemoteTopo():
     "Test remote Node classes using Mininet()/Topo() API"
     topo = LinearTopo( 2 )
     net = Mininet( topo=topo, host=HostPlacer, switch=SwitchPlacer,
-                   link=link, controller=ClusterController )
+                   link=RemoteLink, controller=ClusterController )
     net.start()
     net.pingAll()
     net.stop()
@@ -963,17 +865,18 @@ def testRemoteTopo( link=RemoteGRELink ):
 # do random switch placement rather than completely random
 # host placement.
 
-def testRemoteSwitches( remote='ubuntu2', link=RemoteGRELink ):
+def testRemoteSwitches():
     "Test with local hosts and remote switches"
-    servers = [ 'localhost', remote]
+    servers = [ 'localhost', 'ubuntu2']
     topo = TreeTopo( depth=4, fanout=2 )
-    net = MininetCluster( topo=topo, servers=servers, link=link,
+    net = MininetCluster( topo=topo, servers=servers,
                           placement=RoundRobinPlacer )
     net.start()
     net.pingAll()
     net.stop()
 
 
+#
 # For testing and demo purposes it would be nice to draw the
 # network graph and color it based on server.
 
@@ -981,36 +884,31 @@ def testRemoteSwitches( remote='ubuntu2', link=RemoteGRELink ):
 # functions, for maximum ease of use. MininetCluster() also
 # pre-flights and multiplexes server connections.
 
-def testMininetCluster( remote='ubuntu2', link=RemoteGRELink ):
+def testMininetCluster():
     "Test MininetCluster()"
-    servers = [ 'localhost', remote ]
+    servers = [ 'localhost', 'ubuntu2' ]
     topo = TreeTopo( depth=3, fanout=3 )
-    net = MininetCluster( topo=topo, servers=servers, link=link,
+    net = MininetCluster( topo=topo, servers=servers,
                           placement=SwitchBinPlacer )
     net.start()
     net.pingAll()
     net.stop()
 
-def signalTest( remote='ubuntu2'):
+def signalTest():
     "Make sure hosts are robust to signals"
-    h = RemoteHost( 'h0', server=remote )
+    h = RemoteHost( 'h0', server='ubuntu1' )
     h.shell.send_signal( SIGINT )
     h.shell.poll()
     if h.shell.returncode is None:
-        info( 'signalTest: SUCCESS: ', h, 'has not exited after SIGINT', '\n' )
+        print 'OK: ', h, 'has not exited'
     else:
-        info( 'signalTest: FAILURE:', h, 'exited with code',
-              h.shell.returncode, '\n' )
+        print 'FAILURE:', h, 'exited with code', h.shell.returncode
     h.stop()
 
-
 if __name__ == '__main__':
     setLogLevel( 'info' )
-    remoteServer = 'ubuntu2'
-    remoteLink = RemoteSSHLink
-    testRemoteTopo(link=remoteLink)
-    testNsTunnels( remote=remoteServer, link=remoteLink )
-    testRemoteNet( remote=remoteServer, link=remoteLink)
-    testMininetCluster( remote=remoteServer, link=remoteLink)
-    testRemoteSwitches( remote=remoteServer, link=remoteLink)
-    signalTest( remote=remoteServer )
+    # testRemoteTopo()
+    # testRemoteNet()
+    # testMininetCluster()
+    # testRemoteSwitches()
+    signalTest()

examples/clustercli.py

@@ -27,22 +27,17 @@ class ClusterCLI( CLI ):
     def do_plot( self, _line ):
         "Plot topology colored by node placement"
         # Import networkx if needed
-        global nx, plt, graphviz_layout
+        global nx, plt
         if not nx:
             try:
-                # pylint: disable=import-error,no-member
+                # pylint: disable=import-error
                 import networkx
                 nx = networkx  # satisfy pylint
                 from matplotlib import pyplot
-                plt = pyplot   # satisfy pylint
+                plt = pyplot   # satisfiy pylint
                 import pygraphviz
                 assert pygraphviz  # silence pyflakes
-                # Networkx moved this around
-                if hasattr( nx, 'graphviz_layout' ):
-                    graphviz_layout = nx.graphviz_layout
-                else:
-                    graphviz_layout = nx.drawing.nx_agraph.graphviz_layout
-                # pylint: enable=import-error,no-member
+                # pylint: enable=import-error
             except ImportError:
                 error( 'plot requires networkx, matplotlib and pygraphviz - '
                        'please install them and try again\n' )
@@ -50,8 +45,7 @@ class ClusterCLI( CLI ):
         # Make a networkx Graph
         g = nx.Graph()
         mn = self.mn
-        servers = getattr( mn, 'servers', [ 'localhost' ] )
-        hosts, switches = mn.hosts, mn.switches
+        servers, hosts, switches = mn.servers, mn.hosts, mn.switches
         nodes = hosts + switches
         g.add_nodes_from( nodes )
         links = [ ( link.intf1.node, link.intf2.node )
@@ -61,7 +55,7 @@ class ClusterCLI( CLI ):
         # shapes = hlen * [ 's' ] + slen * [ 'o' ]
         color = dict( zip( servers, self.colorsFor( servers ) ) )
         # Plot it!
-        pos = graphviz_layout( g )
+        pos = nx.graphviz_layout( g )
         opts = { 'ax': None, 'font_weight': 'bold',
                  'width': 2, 'edge_color': 'darkblue' }
         hcolors = [ color[ getattr( h, 'server', 'localhost' ) ]

examples/clusterdemo.py

@@ -2,9 +2,7 @@
 
 "clusterdemo.py: demo of Mininet Cluster Edition prototype"
 
-from mininet.examples.cluster import ( MininetCluster, SwitchBinPlacer,
-                                       RemoteLink )
-# ^ Could also use: RemoteSSHLink, RemoteGRELink
+from mininet.examples.cluster import MininetCluster, SwitchBinPlacer
 from mininet.topolib import TreeTopo
 from mininet.log import setLogLevel
 from mininet.examples.clustercli import ClusterCLI as CLI
@@ -13,7 +11,7 @@ def demo():
     "Simple Demo of Cluster Mode"
     servers = [ 'localhost', 'ubuntu2', 'ubuntu3' ]
     topo = TreeTopo( depth=3, fanout=3 )
-    net = MininetCluster( topo=topo, servers=servers, Link=RemoteLink,
+    net = MininetCluster( topo=topo, servers=servers,
                           placement=SwitchBinPlacer )
     net.start()
     CLI( net )

examples/clusterperf.py

@@ -1,23 +0,0 @@
-#!/usr/bin/python
-
-"clusterperf.py compare the maximum throughput between SSH and GRE tunnels"
-
-from mininet.examples.cluster import RemoteSSHLink, RemoteGRELink, RemoteHost
-from mininet.net import Mininet
-from mininet.log import setLogLevel
-
-def perf(Link):
-    "Test connectivity nand performance over Link"
-    net = Mininet( host=RemoteHost, link=Link )
-    h1 = net.addHost( 'h1')
-    h2 = net.addHost( 'h2', server='ubuntu2' )
-    net.addLink( h1, h2 )
-    net.start()
-    net.pingAll()
-    net.iperf()
-    net.stop()
-
-if __name__ == '__main__':
-    setLogLevel('info')
-    perf( RemoteSSHLink )
-    perf( RemoteGRELink )

examples/controllers.py

@@ -17,7 +17,7 @@ setLogLevel( 'info' )
 # Ignore the warning message that the remote isn't (yet) running
 c0 = Controller( 'c0', port=6633 )
 c1 = Controller( 'c1', port=6634 )
-c2 = RemoteController( 'c2', ip='127.0.0.1', port=6633 )
+c2 = RemoteController( 'c2', ip='127.0.0.1' )
 
 cmap = { 's1': c0, 's2': c1, 's3': c2 }
 

examples/controllers2.py

@@ -11,50 +11,49 @@ Note that one could also create a custom switch class and pass it into
 the Mininet() constructor.
 """
 
-
 from mininet.net import Mininet
 from mininet.node import Controller, OVSSwitch
 from mininet.cli import CLI
-from mininet.log import setLogLevel, info
+from mininet.log import setLogLevel
 
 def multiControllerNet():
     "Create a network from semi-scratch with multiple controllers."
 
     net = Mininet( controller=Controller, switch=OVSSwitch )
 
-    info( "*** Creating (reference) controllers\n" )
+    print "*** Creating (reference) controllers"
     c1 = net.addController( 'c1', port=6633 )
     c2 = net.addController( 'c2', port=6634 )
 
-    info( "*** Creating switches\n" )
+    print "*** Creating switches"
     s1 = net.addSwitch( 's1' )
     s2 = net.addSwitch( 's2' )
 
-    info( "*** Creating hosts\n" )
-    hosts1 = [ net.addHost( 'h%d' % n ) for n in ( 3, 4 ) ]
-    hosts2 = [ net.addHost( 'h%d' % n ) for n in ( 5, 6 ) ]
+    print "*** Creating hosts"
+    hosts1 = [ net.addHost( 'h%d' % n ) for n in 3, 4 ]
+    hosts2 = [ net.addHost( 'h%d' % n ) for n in 5, 6 ]
 
-    info( "*** Creating links\n" )
+    print "*** Creating links"
     for h in hosts1:
         net.addLink( s1, h )
     for h in hosts2:
         net.addLink( s2, h )
     net.addLink( s1, s2 )
 
-    info( "*** Starting network\n" )
+    print "*** Starting network"
     net.build()
     c1.start()
     c2.start()
     s1.start( [ c1 ] )
     s2.start( [ c2 ] )
 
-    info( "*** Testing network\n" )
+    print "*** Testing network"
     net.pingAll()
 
-    info( "*** Running CLI\n" )
+    print "*** Running CLI"
     CLI( net )
 
-    info( "*** Stopping network\n" )
+    print "*** Stopping network"
     net.stop()
 
 if __name__ == '__main__':

examples/controlnet.py

@@ -49,7 +49,7 @@ class MininetFacade( object ):
            args: unnamed networks passed as arguments
            kwargs: named networks passed as arguments"""
         self.net = net
-        self.nets = [ net ] + list( args ) + list( kwargs.values() )
+        self.nets = [ net ] + list( args ) + kwargs.values()
         self.nameToNet = kwargs
         self.nameToNet['net'] = net
 
@@ -100,9 +100,10 @@ class MininetFacade( object ):
 
 class ControlNetwork( Topo ):
     "Control Network Topology"
-    def build( self, n, dataController=DataController, **_kwargs ):
+    def __init__( self, n, dataController=DataController, **kwargs ):
         """n: number of data network controller nodes
            dataController: class for data network controllers"""
+        Topo.__init__( self, **kwargs )
         # Connect everything to a single switch
         cs0 = self.addSwitch( 'cs0' )
         # Add hosts which will serve as data network controllers

examples/cpu.py

@@ -2,40 +2,16 @@
 
 """
 cpu.py: test iperf bandwidth for varying cpu limits
-
-Since we are limiting the hosts (only), we should expect the iperf
-processes to be affected, as well as any system processing which is
-billed to the hosts.
-
-We reserve >50% of cycles for system processing; we assume that
-this is enough for it not to affect results. Hosts are limited to
-40% of total cycles, which we assume is enough to make them CPU
-bound.
-
-As CPU performance increases over time, we may have to reduce the
-overall CPU allocation so that the host processing is still CPU bound.
-This is perhaps an argument for specifying performance in a more
-system-independent manner.
-
-It would also be nice to have a better handle on limiting packet
-processing cycles. It's not entirely clear to me how those are
-billed to user or system processes if we are using OVS with a kernel
-datapath. With a user datapath, they are easier to account for, but
-overall performance is usually lower.
-
-Although the iperf client uses more CPU and should be CPU bound (?),
-we measure the received data at the server since the client transmit
-rate includes buffering.
 """
 
 from mininet.net import Mininet
 from mininet.node import CPULimitedHost
 from mininet.topolib import TreeTopo
-from mininet.util import custom, waitListening, decode
+from mininet.util import custom, waitListening
 from mininet.log import setLogLevel, info
-from mininet.clean import cleanup
 
-def bwtest( cpuLimits, period_us=100000, seconds=10 ):
+
+def bwtest( cpuLimits, period_us=100000, seconds=5 ):
     """Example/test of link and CPU bandwidth limits
        cpu: cpu limit as fraction of overall CPU time"""
 
@@ -44,36 +20,27 @@ def bwtest( cpuLimits, period_us=100000, seconds=10 ):
     results = {}
 
     for sched in 'rt', 'cfs':
-        info( '*** Testing with', sched, 'bandwidth limiting\n' )
+        print '*** Testing with', sched, 'bandwidth limiting'
         for cpu in cpuLimits:
-            # cpu is the cpu fraction for all hosts, so we divide
-            # it across two hosts
             host = custom( CPULimitedHost, sched=sched,
                            period_us=period_us,
-                           cpu=.5*cpu )
+                           cpu=cpu )
             try:
                 net = Mininet( topo=topo, host=host )
             # pylint: disable=bare-except
             except:
-                info( '*** Skipping scheduler %s and cleaning up\n' % sched )
-                cleanup()
+                info( '*** Skipping host %s\n' % sched )
                 break
             net.start()
             net.pingAll()
             hosts = [ net.getNodeByName( h ) for h in topo.hosts() ]
             client, server = hosts[ 0 ], hosts[ -1 ]
-            info( '*** Starting iperf with %d%% of CPU allocated to hosts\n' %
-                  ( 100.0 * cpu ) )
-            # We measure at the server because it doesn't include
-            # the client's buffer fill rate
-            popen = server.popen( 'iperf -yc -s -p 5001' )
+            server.cmd( 'iperf -s -p 5001 &' )
             waitListening( client, server, 5001 )
-            # ignore empty result from waitListening/telnet
-            popen.stdout.readline()
-            client.cmd( 'iperf -yc -t %s -c %s' % ( seconds, server.IP() ) )
-            result = decode( popen.stdout.readline() ).split( ',' )
+            result = client.cmd( 'iperf -yc -t %s -c %s' % (
+                seconds, server.IP() ) ).split( ',' )
             bps = float( result[ -1 ] )
-            popen.terminate()
+            server.cmdPrint( 'kill %iperf' )
             net.stop()
             updated = results.get( sched, [] )
             updated += [ ( cpu, bps ) ]
@@ -85,23 +52,22 @@ def bwtest( cpuLimits, period_us=100000, seconds=10 ):
 def dump( results ):
     "Dump results"
 
-    fmt = '%s\t%s\t%s\n'
+    fmt = '%s\t%s\t%s'
 
-    info( '\n' )
-    info( fmt % ( 'sched', 'cpu', 'received bits/sec' ) )
+    print
+    print fmt % ( 'sched', 'cpu', 'client MB/s' )
+    print
 
     for sched in sorted( results.keys() ):
         entries = results[ sched ]
         for cpu, bps in entries:
-            pct = '%d%%' % ( cpu * 100 )
-            mbps = '%.2e' % bps
-            info( fmt % ( sched, pct, mbps ) )
+            pct = '%.2f%%' % ( cpu * 100 )
+            mbps = bps / 1e6
+            print fmt % ( sched, pct, mbps )
 
 
 if __name__ == '__main__':
     setLogLevel( 'info' )
-    # These are the limits for the hosts/iperfs - the
-    # rest is for system processes
-    limits = [ .5, .4, .3, .2, .1 ]
+    limits = [ .45, .4, .3, .2, .1 ]
     out = bwtest( limits )
     dump( out )

examples/hwintf.py

@@ -17,11 +17,10 @@ from mininet.util import quietRun
 
 def checkIntf( intf ):
     "Make sure intf exists and is not configured."
-    config = quietRun( 'ifconfig %s 2>/dev/null' % intf, shell=True )
-    if not config:
+    if ( ' %s:' % intf ) not in quietRun( 'ip link show' ):
         error( 'Error:', intf, 'does not exist!\n' )
         exit( 1 )
-    ips = re.findall( r'\d+\.\d+\.\d+\.\d+', config )
+    ips = re.findall( r'\d+\.\d+\.\d+\.\d+', quietRun( 'ifconfig ' + intf ) )
     if ips:
         error( 'Error:', intf, 'has an IP address,'
                'and is probably in use!\n' )

examples/linearbandwidth.py

@@ -23,11 +23,10 @@ of switches, this example demonstrates:
 
 """
 
-
 from mininet.net import Mininet
 from mininet.node import UserSwitch, OVSKernelSwitch, Controller
 from mininet.topo import Topo
-from mininet.log import lg, info
+from mininet.log import lg
 from mininet.util import irange, quietRun
 from mininet.link import TCLink
 from functools import partial
@@ -38,7 +37,11 @@ flush = sys.stdout.flush
 class LinearTestTopo( Topo ):
     "Topology for a string of N hosts and N-1 switches."
 
-    def build( self, N, **params ):
+    def __init__( self, N, **params ):
+
+        # Initialize topology
+        Topo.__init__( self, **params )
+
         # Create switches and hosts
         hosts = [ self.addHost( 'h%s' % h )
                   for h in irange( 1, N ) ]
@@ -80,43 +83,44 @@ def linearBandwidthTest( lengths ):
     assert 'reno' in output
 
     for datapath in switches.keys():
-        info( "*** testing", datapath, "datapath\n" )
+        print "*** testing", datapath, "datapath"
         Switch = switches[ datapath ]
         results[ datapath ] = []
-        link = partial( TCLink, delay='2ms', bw=10 )
+        link = partial( TCLink, delay='1ms' )
         net = Mininet( topo=topo, switch=Switch,
                        controller=Controller, waitConnected=True,
                        link=link )
         net.start()
-        info( "*** testing basic connectivity\n" )
+        print "*** testing basic connectivity"
         for n in lengths:
             net.ping( [ net.hosts[ 0 ], net.hosts[ n ] ] )
-        info( "*** testing bandwidth\n" )
+        print "*** testing bandwidth"
         for n in lengths:
             src, dst = net.hosts[ 0 ], net.hosts[ n ]
             # Try to prime the pump to reduce PACKET_INs during test
             # since the reference controller is reactive
             src.cmd( 'telnet', dst.IP(), '5001' )
-            info( "testing", src.name, "<->", dst.name, '\n' )
-            # serverbw = received; _clientbw = buffered
-            serverbw, _clientbw = net.iperf( [ src, dst ], seconds=10 )
-            info( serverbw, '\n' )
+            print "testing", src.name, "<->", dst.name,
+            bandwidth = net.iperf( [ src, dst ], seconds=10 )
+            print bandwidth
             flush()
-            results[ datapath ] += [ ( n, serverbw ) ]
+            results[ datapath ] += [ ( n, bandwidth ) ]
         net.stop()
 
     for datapath in switches.keys():
-        info( "\n*** Linear network results for", datapath, "datapath:\n" )
+        print
+        print "*** Linear network results for", datapath, "datapath:"
+        print
         result = results[ datapath ]
-        info( "SwitchCount\tiperf Results\n" )
-        for switchCount, serverbw in result:
-            info( switchCount, '\t\t' )
-            info( serverbw, '\n' )
-        info( '\n')
-    info( '\n' )
+        print "SwitchCount\tiperf Results"
+        for switchCount, bandwidth in result:
+            print switchCount, '\t\t',
+            print bandwidth[ 0 ], 'server, ', bandwidth[ 1 ], 'client'
+        print
+    print
 
 if __name__ == '__main__':
     lg.setLogLevel( 'info' )
-    sizes = [ 1, 10, 20, 40, 60, 80 ]
-    info( "*** Running linearBandwidthTest", sizes, '\n' )
+    sizes = [ 1, 10, 20, 40, 60, 80, 100 ]
+    print "*** Running linearBandwidthTest", sizes
     linearBandwidthTest( sizes  )

examples/linuxrouter.py

@@ -27,14 +27,12 @@ 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
 from mininet.net import Mininet
 from mininet.node import Node
 from mininet.log import setLogLevel, info
 from mininet.cli import CLI
 
-
 class LinuxRouter( Node ):
     "A Node with IP forwarding enabled."
 
@@ -56,7 +54,7 @@ class NetworkTopo( Topo ):
         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' ) ]
+        s1, s2, s3 = [ self.addSwitch( s ) for s in 's1', 's2', 's3' ]
 
         self.addLink( s1, router, intfName2='r0-eth1',
                       params2={ 'ip' : defaultIP } )  # for clarity
@@ -82,7 +80,7 @@ def run():
     net = Mininet( topo=topo )  # controller is used by s1-s3
     net.start()
     info( '*** Routing Table on Router:\n' )
-    info( net[ 'r0' ].cmd( 'route' ) )
+    print net[ 'r0' ].cmd( 'route' )
     CLI( net )
     net.stop()
 

examples/miniedit.py

@@ -20,39 +20,24 @@ OpenFlow icon from https://www.opennetworking.org/
 
 MINIEDIT_VERSION = '2.2.0.1'
 
-import sys
 from optparse import OptionParser
+# from Tkinter import *
+from Tkinter import ( Frame, Label, LabelFrame, Entry, OptionMenu, Checkbutton,
+                      Menu, Toplevel, Button, BitmapImage, PhotoImage, Canvas,
+                      Scrollbar, Wm, TclError, StringVar, IntVar,
+                      E, W, EW, NW, Y, VERTICAL, SOLID, CENTER,
+                      RIGHT, LEFT, BOTH, TRUE, FALSE )
+from ttk import Notebook
+from tkMessageBox import showerror
 from subprocess import call
-
-# pylint: disable=import-error
-if sys.version_info[0] == 2:
-    from Tkinter import ( Frame, Label, LabelFrame, Entry, OptionMenu,
-                          Checkbutton, Menu, Toplevel, Button, BitmapImage,
-                          PhotoImage, Canvas, Scrollbar, Wm, TclError,
-                          StringVar, IntVar, E, W, EW, NW, Y, VERTICAL, SOLID,
-                          CENTER, RIGHT, LEFT, BOTH, TRUE, FALSE )
-    from ttk import Notebook
-    from tkMessageBox import showerror
-    import tkFont
-    import tkFileDialog
-    import tkSimpleDialog
-else:
-    from tkinter import ( Frame, Label, LabelFrame, Entry, OptionMenu,
-                          Checkbutton, Menu, Toplevel, Button, BitmapImage,
-                          PhotoImage, Canvas, Scrollbar, Wm, TclError,
-                          StringVar, IntVar, E, W, EW, NW, Y, VERTICAL, SOLID,
-                          CENTER, RIGHT, LEFT, BOTH, TRUE, FALSE )
-    from tkinter.ttk import Notebook
-    from tkinter.messagebox import showerror
-    from tkinter import font as tkFont
-    from tkinter import simpledialog as tkSimpleDialog
-    from tkinter import filedialog as tkFileDialog
-# pylint: enable=import-error
-
+import tkFont
+import tkFileDialog
+import tkSimpleDialog
 import re
 import json
 from distutils.version import StrictVersion
 import os
+import sys
 from functools import partial
 
 if 'PYTHONPATH' in os.environ:
@@ -60,7 +45,7 @@ if 'PYTHONPATH' in os.environ:
 
 # someday: from ttk import *
 
-from mininet.log import info, debug, warn, setLogLevel
+from mininet.log import info, setLogLevel
 from mininet.net import Mininet, VERSION
 from mininet.util import netParse, ipAdd, quietRun
 from mininet.util import buildTopo
@@ -75,7 +60,7 @@ from mininet.moduledeps import moduleDeps
 from mininet.topo import SingleSwitchTopo, LinearTopo, SingleSwitchReversedTopo
 from mininet.topolib import TreeTopo
 
-info( 'MiniEdit running against Mininet '+VERSION, '\n' )
+print 'MiniEdit running against Mininet '+VERSION
 MININET_VERSION = re.sub(r'[^\d\.]', '', VERSION)
 if StrictVersion(MININET_VERSION) > StrictVersion('2.0'):
     from mininet.node import IVSSwitch
@@ -394,14 +379,14 @@ class PrefsDialog(tkSimpleDialog.Dialog):
     @staticmethod
     def getOvsVersion():
         "Return OVS version"
-        outp = quietRun("ovs-vsctl --version")
-        r = r'ovs-vsctl \(Open vSwitch\) (.*)'
+        outp = quietRun("ovs-vsctl show")
+        r = r'ovs_version: "(.*)"'
         m = re.search(r, outp)
         if m is None:
-            warn( 'Version check failed' )
+            print 'Version check failed'
             return None
         else:
-            info( 'Open vSwitch version is '+m.group(1), '\n' )
+            print 'Open vSwitch version is '+m.group(1)
             return m.group(1)
 
 
@@ -770,7 +755,7 @@ class SwitchDialog(CustomDialog):
     def apply(self):
         externalInterfaces = []
         for row in range(self.tableFrame.rows):
-            # debug( 'Interface is ' + self.tableFrame.get(row, 0), '\n' )
+            #print 'Interface is ' + self.tableFrame.get(row, 0)
             if len(self.tableFrame.get(row, 0)) > 0:
                 externalInterfaces.append(self.tableFrame.get(row, 0))
 
@@ -881,7 +866,7 @@ class TableFrame(Frame):
         return widget.get()
 
     def addRow( self, value=None, readonly=False ):
-        # debug( "Adding row " + str(self.rows +1), '\n' )
+        #print "Adding row " + str(self.rows +1)
         current_row = []
         for column in range(self.columns):
             label = Entry(self, borderwidth=0)
@@ -1423,7 +1408,7 @@ class MiniEdit( Frame ):
     def convertJsonUnicode(self, text):
         "Some part of Mininet don't like Unicode"
         if isinstance(text, dict):
-            return {self.convertJsonUnicode(key): self.convertJsonUnicode(value) for key, value in text.items()}
+            return {self.convertJsonUnicode(key): self.convertJsonUnicode(value) for key, value in text.iteritems()}
         elif isinstance(text, list):
             return [self.convertJsonUnicode(element) for element in text]
         elif isinstance(text, unicode):
@@ -1684,7 +1669,7 @@ class MiniEdit( Frame ):
                 f.write(json.dumps(savingDictionary, sort_keys=True, indent=4, separators=(',', ': ')))
             # pylint: disable=broad-except
             except Exception as er:
-                warn( er, '\n' )
+                print er
             # pylint: enable=broad-except
             finally:
                 f.close()
@@ -1698,7 +1683,7 @@ class MiniEdit( Frame ):
 
         fileName = tkFileDialog.asksaveasfilename(filetypes=myFormats ,title="Export the topology as...")
         if len(fileName ) > 0:
-            # debug( "Now saving under %s\n" % fileName )
+            #print "Now saving under %s" % fileName
             f = open(fileName, 'wb')
 
             f.write("#!/usr/bin/python\n")
@@ -1850,7 +1835,7 @@ class MiniEdit( Frame ):
 
             # Save Links
             f.write("    info( '*** Add links\\n')\n")
-            for key,linkDetail in self.links.items():
+            for key,linkDetail in self.links.iteritems():
                 tags = self.canvas.gettags(key)
                 if 'data' in tags:
                     optsExist = False
@@ -2504,7 +2489,7 @@ class MiniEdit( Frame ):
             if len(hostBox.result['privateDirectory']) > 0:
                 newHostOpts['privateDirectory'] = hostBox.result['privateDirectory']
             self.hostOpts[name] = newHostOpts
-            info( 'New host details for ' + name + ' = ' + str(newHostOpts), '\n' )
+            print 'New host details for ' + name + ' = ' + str(newHostOpts)
 
     def switchDetails( self, _ignore=None ):
         if ( self.selection is None or
@@ -2542,7 +2527,7 @@ class MiniEdit( Frame ):
             newSwitchOpts['sflow'] = switchBox.result['sflow']
             newSwitchOpts['netflow'] = switchBox.result['netflow']
             self.switchOpts[name] = newSwitchOpts
-            info( 'New switch details for ' + name + ' = ' + str(newSwitchOpts), '\n' )
+            print 'New switch details for ' + name + ' = ' + str(newSwitchOpts)
 
     def linkUp( self ):
         if ( self.selection is None or
@@ -2581,12 +2566,12 @@ class MiniEdit( Frame ):
         linkBox = LinkDialog(self, title='Link Details', linkDefaults=linkopts)
         if linkBox.result is not None:
             linkDetail['linkOpts'] = linkBox.result
-            info( 'New link details = ' + str(linkBox.result), '\n' )
+            print 'New link details = ' + str(linkBox.result)
 
     def prefDetails( self ):
         prefDefaults = self.appPrefs
         prefBox = PrefsDialog(self, title='Preferences', prefDefaults=prefDefaults)
-        info( 'New Prefs = ' + str(prefBox.result), '\n' )
+        print 'New Prefs = ' + str(prefBox.result)
         if prefBox.result:
             self.appPrefs = prefBox.result
 
@@ -2605,14 +2590,14 @@ class MiniEdit( Frame ):
 
         ctrlrBox = ControllerDialog(self, title='Controller Details', ctrlrDefaults=self.controllers[name])
         if ctrlrBox.result:
-            # debug( 'Controller is ' + ctrlrBox.result[0], '\n' )
+            #print 'Controller is ' + ctrlrBox.result[0]
             if len(ctrlrBox.result['hostname']) > 0:
                 name = ctrlrBox.result['hostname']
                 widget[ 'text' ] = name
             else:
                 ctrlrBox.result['hostname'] = name
             self.controllers[name] = ctrlrBox.result
-            info( 'New controller details for ' + name + ' = ' + str(self.controllers[name]), '\n' )
+            print 'New controller details for ' + name + ' = ' + str(self.controllers[name])
             # Find references to controller and change name
             if oldName != name:
                 for widget in self.widgetToItem:
@@ -2713,15 +2698,15 @@ class MiniEdit( Frame ):
 
     def buildNodes( self, net):
         # Make nodes
-        info( "Getting Hosts and Switches.\n" )
+        print "Getting Hosts and Switches."
         for widget in self.widgetToItem:
             name = widget[ 'text' ]
             tags = self.canvas.gettags( self.widgetToItem[ widget ] )
-            # debug( name+' has '+str(tags), '\n' )
+            #print name+' has '+str(tags)
 
             if 'Switch' in tags:
                 opts = self.switchOpts[name]
-                # debug( str(opts), '\n' )
+                #print str(opts)
 
                 # Create the correct switch class
                 switchClass = customOvs
@@ -2787,7 +2772,7 @@ class MiniEdit( Frame ):
                 newSwitch = net.addHost( name , cls=LegacyRouter)
             elif 'Host' in tags:
                 opts = self.hostOpts[name]
-                # debug( str(opts), '\n' )
+                #print str(opts)
                 ip = None
                 defaultRoute = None
                 if 'defaultRoute' in opts and len(opts['defaultRoute']) > 0:
@@ -2812,7 +2797,7 @@ class MiniEdit( Frame ):
                                            privateDirs=opts['privateDirectory'] )
                     else:
                         hostCls=Host
-                debug( hostCls, '\n' )
+                print hostCls
                 newHost = net.addHost( name,
                                        cls=hostCls,
                                        ip=ip,
@@ -2832,7 +2817,7 @@ class MiniEdit( Frame ):
                             Intf( extInterface, node=newHost )
                 if 'vlanInterfaces' in opts:
                     if len(opts['vlanInterfaces']) > 0:
-                        info( 'Checking that OS is VLAN prepared\n' )
+                        print 'Checking that OS is VLAN prepared'
                         self.pathCheck('vconfig', moduleName='vlan package')
                         moduleDeps( add='8021q' )
             elif 'Controller' in tags:
@@ -2849,7 +2834,7 @@ class MiniEdit( Frame ):
                 controllerPort = opts['remotePort']
 
                 # Make controller
-                info( 'Getting controller selection:'+controllerType, '\n' )
+                print 'Getting controller selection:'+controllerType
                 if controllerType == 'remote':
                     net.addController(name=name,
                                       controller=RemoteController,
@@ -2889,8 +2874,8 @@ class MiniEdit( Frame ):
 
     def buildLinks( self, net):
         # Make links
-        info( "Getting Links.\n" )
-        for key,link in self.links.items():
+        print "Getting Links."
+        for key,link in self.links.iteritems():
             tags = self.canvas.gettags(key)
             if 'data' in tags:
                 src=link['src']
@@ -2901,14 +2886,14 @@ class MiniEdit( Frame ):
                 if linkopts:
                     net.addLink(srcNode, dstNode, cls=TCLink, **linkopts)
                 else:
-                    # debug( str(srcNode) )
-                    # debug( str(dstNode), '\n' )
+                    #print str(srcNode)
+                    #print str(dstNode)
                     net.addLink(srcNode, dstNode)
                 self.canvas.itemconfig(key, dash=())
 
 
     def build( self ):
-        "Build network based on our topology."
+        print "Build network based on our topology."
 
         dpctl = None
         if len(self.appPrefs['dpctl']) > 0:
@@ -2939,7 +2924,7 @@ class MiniEdit( Frame ):
                 # Attach vlan interfaces
                 if 'vlanInterfaces' in opts:
                     for vlanInterface in opts['vlanInterfaces']:
-                        info( 'adding vlan interface '+vlanInterface[1], '\n' )
+                        print 'adding vlan interface '+vlanInterface[1]
                         newHost.cmdPrint('ifconfig '+name+'-eth0.'+vlanInterface[1]+' '+vlanInterface[0])
                 # Run User Defined Start Command
                 if 'startCommand' in opts:
@@ -2965,7 +2950,7 @@ class MiniEdit( Frame ):
                     opts = self.switchOpts[name]
                     if 'netflow' in opts:
                         if opts['netflow'] == '1':
-                            info( name+' has Netflow enabled\n' )
+                            print name+' has Netflow enabled'
                             nflowSwitches = nflowSwitches+' -- set Bridge '+name+' netflow=@MiniEditNF'
                             nflowEnabled=True
             if nflowEnabled:
@@ -2974,13 +2959,13 @@ class MiniEdit( Frame ):
                     nflowCmd = nflowCmd + ' add_id_to_interface=true'
                 else:
                     nflowCmd = nflowCmd + ' add_id_to_interface=false'
-                info( 'cmd = '+nflowCmd+nflowSwitches, '\n' )
+                print 'cmd = '+nflowCmd+nflowSwitches
                 call(nflowCmd+nflowSwitches, shell=True)
 
             else:
-                info( 'No switches with Netflow\n' )
+                print 'No switches with Netflow'
         else:
-            info( 'No NetFlow targets specified.\n' )
+            print 'No NetFlow targets specified.'
 
         # Configure sFlow
         sflowValues = self.appPrefs['sflow']
@@ -2995,18 +2980,18 @@ class MiniEdit( Frame ):
                     opts = self.switchOpts[name]
                     if 'sflow' in opts:
                         if opts['sflow'] == '1':
-                            info( name+' has sflow enabled\n' )
+                            print name+' has sflow enabled'
                             sflowSwitches = sflowSwitches+' -- set Bridge '+name+' sflow=@MiniEditSF'
                             sflowEnabled=True
             if sflowEnabled:
                 sflowCmd = 'ovs-vsctl -- --id=@MiniEditSF create sFlow '+ 'target=\\\"'+sflowValues['sflowTarget']+'\\\" '+ 'header='+sflowValues['sflowHeader']+' '+ 'sampling='+sflowValues['sflowSampling']+' '+ 'polling='+sflowValues['sflowPolling']
-                info( 'cmd = '+sflowCmd+sflowSwitches, '\n' )
+                print 'cmd = '+sflowCmd+sflowSwitches
                 call(sflowCmd+sflowSwitches, shell=True)
 
             else:
-                info( 'No switches with sflow\n' )
+                print 'No switches with sflow'
         else:
-            info( 'No sFlow targets specified.\n' )
+            print 'No sFlow targets specified.'
 
         ## NOTE: MAKE SURE THIS IS LAST THING CALLED
         # Start the CLI if enabled
@@ -3226,13 +3211,13 @@ class MiniEdit( Frame ):
         customs = {}
         if os.path.isfile( fileName ):
             execfile( fileName, customs, customs )
-            for name, val in customs.items():
+            for name, val in customs.iteritems():
                 self.setCustom( name, val )
         else:
             raise Exception( 'could not find custom file: %s' % fileName )
 
     def importTopo( self ):
-        info( 'topo='+self.options.topo, '\n' )
+        print 'topo='+self.options.topo
         if self.options.topo == 'none':
             return
         self.newTopology()
@@ -3246,7 +3231,7 @@ class MiniEdit( Frame ):
         currentY = 100
 
         # Add Controllers
-        info( 'controllers:'+str(len(importNet.controllers)), '\n' )
+        print 'controllers:'+str(len(importNet.controllers))
         for controller in importNet.controllers:
             name = controller.name
             x = self.controllerCount*100+100
@@ -3266,7 +3251,7 @@ class MiniEdit( Frame ):
         currentY = currentY + rowIncrement
 
         # Add switches
-        info( 'switches:'+str(len(importNet.switches)), '\n' )
+        print 'switches:'+str(len(importNet.switches))
         columnCount = 0
         for switch in importNet.switches:
             name = switch.name
@@ -3307,7 +3292,7 @@ class MiniEdit( Frame ):
 
         currentY = currentY + rowIncrement
         # Add hosts
-        info( 'hosts:'+str(len(importNet.hosts)), '\n' )
+        print 'hosts:'+str(len(importNet.hosts))
         columnCount = 0
         for host in importNet.hosts:
             name = host.name
@@ -3327,10 +3312,10 @@ class MiniEdit( Frame ):
             else:
                 columnCount =columnCount+1
 
-        info( 'links:'+str(len(topo.links())), '\n' )
+        print 'links:'+str(len(topo.links()))
         #[('h1', 's3'), ('h2', 's4'), ('s3', 's4')]
         for link in topo.links():
-            info( str(link), '\n' )
+            print str(link)
             srcNode = link[0]
             src = self.findWidgetByName(srcNode)
             sx, sy = self.canvas.coords( self.widgetToItem[ src ] )
@@ -3340,7 +3325,7 @@ class MiniEdit( Frame ):
             dx, dy = self.canvas.coords( self.widgetToItem[ dest]  )
 
             params = topo.linkInfo( srcNode, destNode )
-            info( 'Link Parameters='+str(params), '\n' )
+            print 'Link Parameters='+str(params)
 
             self.link = self.canvas.create_line( sx, sy, dx, dy, width=4,
                                              fill='blue', tag='link' )

examples/mobility.py

@@ -19,11 +19,10 @@ to-do:
 - think about clearing last hop - why doesn't that work?
 """
 
-
 from mininet.net import Mininet
 from mininet.node import OVSSwitch
 from mininet.topo import LinearTopo
-from mininet.log import info, output, warn, setLogLevel
+from mininet.log import output, warn
 
 from random import randint
 
@@ -106,31 +105,30 @@ def moveHost( host, oldSwitch, newSwitch, newPort=None ):
 
 def mobilityTest():
     "A simple test of mobility"
-    info( '* Simple mobility test\n' )
+    print '* Simple mobility test'
     net = Mininet( topo=LinearTopo( 3 ), switch=MobilitySwitch )
-    info( '* Starting network:\n' )
+    print '* Starting network:'
     net.start()
     printConnections( net.switches )
-    info( '* Testing network\n' )
+    print '* Testing network'
     net.pingAll()
-    info( '* Identifying switch interface for h1\n' )
+    print '* Identifying switch interface for h1'
     h1, old = net.get( 'h1', 's1' )
     for s in 2, 3, 1:
         new = net[ 's%d' % s ]
         port = randint( 10, 20 )
-        info( '* Moving', h1, 'from', old, 'to', new, 'port', port, '\n' )
+        print '* Moving', h1, 'from', old, 'to', new, 'port', port
         hintf, sintf = moveHost( h1, old, new, newPort=port )
-        info( '*', hintf, 'is now connected to', sintf, '\n' )
-        info( '* Clearing out old flows\n' )
+        print '*', hintf, 'is now connected to', sintf
+        print '* Clearing out old flows'
         for sw in net.switches:
             sw.dpctl( 'del-flows' )
-        info( '* New network:\n' )
+        print '* New network:'
         printConnections( net.switches )
-        info( '* Testing connectivity:\n' )
+        print '* Testing connectivity:'
         net.pingAll()
         old = new
     net.stop()
 
 if __name__ == '__main__':
-    setLogLevel( 'info' )
     mobilityTest()

examples/multilink.py

@@ -21,7 +21,9 @@ def runMultiLink():
 class simpleMultiLinkTopo( Topo ):
     "Simple topology with multiple links"
 
-    def build( self, n, **_kwargs ):
+    def __init__( self, n, **kwargs ):
+        Topo.__init__( self, **kwargs )
+
         h1, h2 = self.addHost( 'h1' ), self.addHost( 'h2' )
         s1 = self.addSwitch( 's1' )
 

examples/multiping.py

@@ -8,11 +8,10 @@ multiple hosts and monitor their output interactively for a period=
 of time.
 """
 
-
 from mininet.net import Mininet
 from mininet.node import Node
 from mininet.topo import SingleSwitchTopo
-from mininet.log import info, setLogLevel
+from mininet.log import setLogLevel
 
 from select import poll, POLLIN
 from time import time
@@ -35,8 +34,8 @@ def startpings( host, targetips ):
             ' done; '
             'done &' )
 
-    info( '*** Host %s (%s) will be pinging ips: %s\n' %
-          ( host.name, host.IP(), targetips ) )
+    print ( '*** Host %s (%s) will be pinging ips: %s' %
+            ( host.name, host.IP(), targetips ) )
 
     host.cmd( cmd )
 
@@ -45,7 +44,7 @@ def multiping( netsize, chunksize, seconds):
 
     # Create network and identify subnets
     topo = SingleSwitchTopo( netsize )
-    net = Mininet( topo=topo, waitConnected=True )
+    net = Mininet( topo=topo )
     net.start()
     hosts = net.hosts
     subnets = chunks( hosts, chunksize )
@@ -70,7 +69,7 @@ def multiping( netsize, chunksize, seconds):
         readable = poller.poll(1000)
         for fd, _mask in readable:
             node = Node.outToNode[ fd ]
-            info( '%s:' % node.name, node.monitor().strip(), '\n' )
+            print '%s:' % node.name, node.monitor().strip()
 
     # Stop pings
     for host in hosts:

examples/multipoll.py

@@ -5,22 +5,19 @@ Simple example of sending output to multiple files and
 monitoring them
 """
 
-
 from mininet.topo import SingleSwitchTopo
 from mininet.net import Mininet
-from mininet.log import info, setLogLevel
-from mininet.util import decode
+from mininet.log import setLogLevel
 
 from time import time
 from select import poll, POLLIN
 from subprocess import Popen, PIPE
 
-
 def monitorFiles( outfiles, seconds, timeoutms ):
     "Monitor set of files and return [(host, line)...]"
     devnull = open( '/dev/null', 'w' )
     tails, fdToFile, fdToHost = {}, {}, {}
-    for h, outfile in outfiles.items():
+    for h, outfile in outfiles.iteritems():
         tail = Popen( [ 'tail', '-f', outfile ],
                       stdout=PIPE, stderr=devnull )
         fd = tail.stdout.fileno()
@@ -41,7 +38,7 @@ def monitorFiles( outfiles, seconds, timeoutms ):
                 host = fdToHost[ fd ]
                 # Wait for a line of output
                 line = f.readline().strip()
-                yield host, decode( line )
+                yield host, line
         else:
             # If we timed out, return nothing
             yield None, ''
@@ -56,7 +53,7 @@ def monitorTest( N=3, seconds=3 ):
     net = Mininet( topo )
     net.start()
     hosts = net.hosts
-    info( "Starting test...\n" )
+    print "Starting test..."
     server = hosts[ 0 ]
     outfiles, errfiles = {}, {}
     for h in hosts:
@@ -70,10 +67,10 @@ def monitorTest( N=3, seconds=3 ):
                    '>', outfiles[ h ],
                    '2>', errfiles[ h ],
                    '&' )
-    info( "Monitoring output for", seconds, "seconds\n" )
+    print "Monitoring output for", seconds, "seconds"
     for h, line in monitorFiles( outfiles, seconds, timeoutms=500 ):
         if h:
-            info( '%s: %s\n' % ( h.name, line ) )
+            print '%s: %s' % ( h.name, line )
     for h in hosts:
         h.cmd('kill %ping')
     net.stop()

examples/nat.py

@@ -2,22 +2,111 @@
 
 """
 Example to create a Mininet topology and connect it to the internet via NAT
+through eth0 on the host.
+
+Glen Gibb, February 2011
+
+(slight modifications by BL, 5/13)
 """
 
-
 from mininet.cli import CLI
-from mininet.log import lg, info
+from mininet.log import lg
+from mininet.node import Node
 from mininet.topolib import TreeNet
 
+#################################
+def startNAT( root, inetIntf='eth0', subnet='10.0/8' ):
+    """Start NAT/forwarding between Mininet and external network
+    root: node to access iptables from
+    inetIntf: interface for internet access
+    subnet: Mininet subnet (default 10.0/8)="""
+
+    # Identify the interface connecting to the mininet network
+    localIntf = root.defaultIntf()
+
+    # Flush any currently active rules
+    root.cmd( 'iptables -F' )
+    root.cmd( 'iptables -t nat -F' )
+
+    # Create default entries for unmatched traffic
+    root.cmd( 'iptables -P INPUT ACCEPT' )
+    root.cmd( 'iptables -P OUTPUT ACCEPT' )
+    root.cmd( 'iptables -P FORWARD DROP' )
+
+    # Configure NAT
+    root.cmd( 'iptables -I FORWARD -i', localIntf, '-d', subnet, '-j DROP' )
+    root.cmd( 'iptables -A FORWARD -i', localIntf, '-s', subnet, '-j ACCEPT' )
+    root.cmd( 'iptables -A FORWARD -i', inetIntf, '-d', subnet, '-j ACCEPT' )
+    root.cmd( 'iptables -t nat -A POSTROUTING -o ', inetIntf, '-j MASQUERADE' )
+
+    # Instruct the kernel to perform forwarding
+    root.cmd( 'sysctl net.ipv4.ip_forward=1' )
+
+def stopNAT( root ):
+    """Stop NAT/forwarding between Mininet and external network"""
+    # Flush any currently active rules
+    root.cmd( 'iptables -F' )
+    root.cmd( 'iptables -t nat -F' )
+
+    # Instruct the kernel to stop forwarding
+    root.cmd( 'sysctl net.ipv4.ip_forward=0' )
+
+def fixNetworkManager( root, intf ):
+    """Prevent network-manager from messing with our interface,
+       by specifying manual configuration in /etc/network/interfaces
+       root: a node in the root namespace (for running commands)
+       intf: interface name"""
+    cfile = '/etc/network/interfaces'
+    line = '\niface %s inet manual\n' % intf
+    config = open( cfile ).read()
+    if line not in config:
+        print '*** Adding', line.strip(), 'to', cfile
+        with open( cfile, 'a' ) as f:
+            f.write( line )
+        # Probably need to restart network-manager to be safe -
+        # hopefully this won't disconnect you
+        root.cmd( 'service network-manager restart' )
+
+def connectToInternet( network, switch='s1', rootip='10.254', subnet='10.0/8'):
+    """Connect the network to the internet
+       switch: switch to connect to root namespace
+       rootip: address for interface in root namespace
+       subnet: Mininet subnet"""
+    switch = network.get( switch )
+    prefixLen = subnet.split( '/' )[ 1 ]
+
+    # Create a node in root namespace
+    root = Node( 'root', inNamespace=False )
+
+    # Prevent network-manager from interfering with our interface
+    fixNetworkManager( root, 'root-eth0' )
+
+    # Create link between root NS and switch
+    link = network.addLink( root, switch )
+    link.intf1.setIP( rootip, prefixLen )
+
+    # Start network that now includes link to root namespace
+    network.start()
+
+    # Start NAT and establish forwarding
+    startNAT( root )
+
+    # Establish routes from end hosts
+    for host in network.hosts:
+        host.cmd( 'ip route flush root 0/0' )
+        host.cmd( 'route add -net', subnet, 'dev', host.defaultIntf() )
+        host.cmd( 'route add default gw', rootip )
+
+    return root
 
 if __name__ == '__main__':
     lg.setLogLevel( 'info')
     net = TreeNet( depth=1, fanout=4 )
-    # Add NAT connectivity
-    net.addNAT().configDefault()
-    net.start()
-    info( "*** Hosts are running and should have internet connectivity\n" )
-    info( "*** Type 'exit' or control-D to shut down network\n" )
+    # Configure and start NATted connectivity
+    rootnode = connectToInternet( net )
+    print "*** Hosts are running and should have internet connectivity"
+    print "*** Type 'exit' or control-D to shut down network"
     CLI( net )
     # Shut down NAT
+    stopNAT( rootnode )
     net.stop()

examples/natnet.py

@@ -27,7 +27,9 @@ from mininet.util import irange
 
 class InternetTopo(Topo):
     "Single switch connected to n hosts."
-    def build(self, n=2, **_kwargs ):
+    def __init__(self, n=2, **opts):
+        Topo.__init__(self, **opts)
+
         # set up inet switch
         inetSwitch = self.addSwitch('s0')
         # add inet host

examples/numberedports.py

@@ -6,7 +6,6 @@ Validate that the port numbers match to the interface name,
 and that the ovs ports match the mininet ports.
 """
 
-
 from mininet.net import Mininet
 from mininet.node import Controller
 from mininet.log import setLogLevel, info, warn
@@ -66,13 +65,13 @@ def testPortNumbering():
                    'is actually on port', s1.ports[intfs], '... ' )
             if validatePort( s1, intfs ):
                 info( 'Validated.\n' )
-    info( '\n' )
+    print '\n'
 
     # test the network with pingall
     net.pingAll()
-    info( '\n' )
+    print '\n'
 
-    info( '*** Stopping network\n' )
+    info( '*** Stopping network' )
     net.stop()
 
 if __name__ == '__main__':

examples/popen.py

@@ -5,11 +5,10 @@ This example monitors a number of hosts using host.popen() and
 pmonitor()
 """
 
-
 from mininet.net import Mininet
 from mininet.node import CPULimitedHost
 from mininet.topo import SingleSwitchTopo
-from mininet.log import setLogLevel, info
+from mininet.log import setLogLevel
 from mininet.util import custom, pmonitor
 
 def monitorhosts( hosts=5, sched='cfs' ):
@@ -28,7 +27,7 @@ def monitorhosts( hosts=5, sched='cfs' ):
     # Monitor them and print output
     for host, line in pmonitor( popens ):
         if host:
-            info( "<%s>: %s" % ( host.name, line ) )
+            print "<%s>: %s" % ( host.name, line.strip() )
     # Done
     net.stop()
 

examples/popenpoll.py

@@ -5,8 +5,6 @@
 from mininet.net import Mininet
 from mininet.topo import SingleSwitchTopo
 from mininet.util import pmonitor
-from mininet.log import setLogLevel, info
-
 from time import time
 from signal import SIGINT
 
@@ -16,21 +14,20 @@ def pmonitorTest( N=3, seconds=10 ):
     net = Mininet( topo )
     net.start()
     hosts = net.hosts
-    info( "Starting test...\n" )
+    print "Starting test..."
     server = hosts[ 0 ]
     popens = {}
     for h in hosts:
         popens[ h ] = h.popen('ping', server.IP() )
-    info( "Monitoring output for", seconds, "seconds\n" )
+    print "Monitoring output for", seconds, "seconds"
     endTime = time() + seconds
     for h, line in pmonitor( popens, timeoutms=500 ):
         if h:
-            info( '<%s>: %s' % ( h.name, line ) )
+            print '<%s>: %s' % ( h.name, line ),
         if time() >= endTime:
             for p in popens.values():
                 p.send_signal( SIGINT )
     net.stop()
 
 if __name__ == '__main__':
-    setLogLevel( 'info' )
     pmonitorTest()

examples/scratchnet.py

@@ -8,7 +8,6 @@ but it exposes the configuration details and allows customization.
 For most tasks, the higher-level API will be preferable.
 """
 
-
 from mininet.net import Mininet
 from mininet.node import Node
 from mininet.link import Link
@@ -41,7 +40,7 @@ def scratchNet( cname='controller', cargs='-v ptcp:' ):
     switch.cmd( 'ovs-vsctl del-br dp0' )
     switch.cmd( 'ovs-vsctl add-br dp0' )
     for intf in switch.intfs.values():
-        switch.cmd( 'ovs-vsctl add-port dp0 %s\n' % intf )
+        print switch.cmd( 'ovs-vsctl add-port dp0 %s' % intf )
 
     # Note: controller and switch are in root namespace, and we
     # can connect via loopback interface

examples/scratchnetuser.py

@@ -52,7 +52,7 @@ def scratchNetUser( cname='controller', cargs='ptcp:' ):
     info( '*** Starting controller and user datapath\n' )
     controller.cmd( cname + ' ' + cargs + '&' )
     switch.cmd( 'ifconfig lo 127.0.0.1' )
-    intfs = str( sintf1 ), str( sintf2 )
+    intfs = [ str( i ) for i in sintf1, sintf2 ]
     switch.cmd( 'ofdatapath -i ' + ','.join( intfs ) + ' ptcp: &' )
     switch.cmd( 'ofprotocol tcp:' + controller.IP() + ' tcp:localhost &' )
 

examples/simpleperf.py

@@ -9,52 +9,40 @@ iperf will hang indefinitely if the TCP handshake fails
 to complete.
 """
 
-
 from mininet.topo import Topo
 from mininet.net import Mininet
 from mininet.node import CPULimitedHost
 from mininet.link import TCLink
 from mininet.util import dumpNodeConnections
-from mininet.log import setLogLevel, info
+from mininet.log import setLogLevel
 
-from sys import argv
-
-# It would be nice if we didn't have to do this:
-# pylint: disable=arguments-differ
-
-class SingleSwitchTopo( Topo ):
+class SingleSwitchTopo(Topo):
     "Single switch connected to n hosts."
-    def build( self, n=2, lossy=True ):
+    def __init__(self, n=2, **opts):
+        Topo.__init__(self, **opts)
         switch = self.addSwitch('s1')
         for h in range(n):
             # Each host gets 50%/n of system CPU
             host = self.addHost('h%s' % (h + 1),
                                 cpu=.5 / n)
-            if lossy:
-                # 10 Mbps, 5ms delay, 10% packet loss
-                self.addLink(host, switch,
-                             bw=10, delay='5ms', loss=10, use_htb=True)
-            else:
-                # 10 Mbps, 5ms delay, no packet loss
-                self.addLink(host, switch,
-                             bw=10, delay='5ms', loss=0, use_htb=True)
+            # 10 Mbps, 5ms delay, 10% loss
+            self.addLink(host, switch,
+                         bw=10, delay='5ms', loss=10, use_htb=True)
 
-
-def perfTest( lossy=True ):
+def perfTest():
     "Create network and run simple performance test"
-    topo = SingleSwitchTopo( n=4, lossy=lossy )
+    topo = SingleSwitchTopo( n=4 )
     net = Mininet( topo=topo,
                    host=CPULimitedHost, link=TCLink,
                    autoStaticArp=True )
     net.start()
-    info( "Dumping host connections\n" )
+    print "Dumping host connections"
     dumpNodeConnections(net.hosts)
-    info( "Testing bandwidth between h1 and h4\n" )
+    print "Testing bandwidth between h1 and h4"
     h1, h4 = net.getNodeByName('h1', 'h4')
     net.iperf( ( h1, h4 ), l4Type='UDP' )
     net.stop()
 
 if __name__ == '__main__':
-    setLogLevel( 'info' )
-    # Prevent test_simpleperf from failing due to packet loss
-    perfTest( lossy=( 'testmode' not in argv ) )
+    setLogLevel('info')
+    perfTest()

examples/sshd.py

@@ -20,12 +20,11 @@ import sys
 
 from mininet.net import Mininet
 from mininet.cli import CLI
-from mininet.log import lg, info
+from mininet.log import lg
 from mininet.node import Node
 from mininet.topolib import TreeTopo
 from mininet.util import waitListening
 
-
 def TreeNet( depth=1, fanout=2, **kwargs ):
     "Convenience function for creating tree networks."
     topo = TreeTopo( depth, fanout )
@@ -60,14 +59,17 @@ def sshd( network, cmd='/usr/sbin/sshd', opts='-D',
     connectToRootNS( network, switch, ip, routes )
     for host in network.hosts:
         host.cmd( cmd + ' ' + opts + '&' )
-    info( "*** Waiting for ssh daemons to start\n" )
+    print "*** Waiting for ssh daemons to start"
     for server in network.hosts:
         waitListening( server=server, port=22, timeout=5 )
 
-    info( "\n*** Hosts are running sshd at the following addresses:\n" )
+    print
+    print "*** Hosts are running sshd at the following addresses:"
+    print
     for host in network.hosts:
-        info( host.name, host.IP(), '\n' )
-    info( "\n*** Type 'exit' or control-D to shut down network\n" )
+        print host.name, host.IP()
+    print
+    print "*** Type 'exit' or control-D to shut down network"
     CLI( network )
     for host in network.hosts:
         host.cmd( 'kill %' + cmd )

examples/test/runner.py

@@ -32,8 +32,7 @@ def runTests( testDir, verbosity=1 ):
     # discover all tests in testDir
     testSuite = unittest.defaultTestLoader.discover( testDir )
     # run tests
-    success = MininetTestRunner( verbosity=verbosity ).run( testSuite ).wasSuccessful()
-    sys.exit( 0 if success else 1 )
+    MininetTestRunner( verbosity=verbosity ).run( testSuite )
 
 if __name__ == '__main__':
     # get the directory containing example tests

examples/test/test_baresshd.py

@@ -5,9 +5,8 @@ Tests for baresshd.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 from mininet.clean import cleanup, sh
-from sys import stdout
 
 class testBareSSHD( unittest.TestCase ):
 
@@ -15,9 +14,7 @@ class testBareSSHD( unittest.TestCase ):
 
     def connected( self ):
         "Log into ssh server, check banner, then exit"
-        p = pexpect.spawn( 'ssh 10.0.0.1 -o ConnectTimeout=1 '
-                           '-o StrictHostKeyChecking=no '
-                           '-i /tmp/ssh/test_rsa exit' )
+        p = pexpect.spawn( 'ssh 10.0.0.1 -o StrictHostKeyChecking=no -i /tmp/ssh/test_rsa exit' )
         while True:
             index = p.expect( self.opts )
             if index == 0:
@@ -25,7 +22,6 @@ class testBareSSHD( unittest.TestCase ):
             else:
                 return False
 
-
     def setUp( self ):
         # verify that sshd is not running
         self.assertFalse( self.connected() )
@@ -59,7 +55,7 @@ class testBareSSHD( unittest.TestCase ):
 
     def tearDown( self ):
         # kill the ssh process
-        sh( "ps aux | grep ssh |grep Banner| awk '{ print $2 }' | xargs kill" )
+        sh( "ps aux | grep 'ssh.*Banner' | awk '{ print $2 }' | xargs kill" )
         cleanup()
         # remove public key pair
         sh( 'rm -rf /tmp/ssh' )

examples/test/test_bind.py

@@ -5,7 +5,7 @@ Tests for bind.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 
 class testBind( unittest.TestCase ):
 

examples/test/test_clusterSanity.py

@@ -5,7 +5,7 @@ A simple sanity check test for cluster edition
 '''
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 
 class clusterSanityCheck( unittest.TestCase ):
 

examples/test/test_controllers.py

@@ -5,7 +5,7 @@ Tests for controllers.py and controllers2.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 
 class testControllers( unittest.TestCase ):
 

examples/test/test_controlnet.py

@@ -5,7 +5,7 @@ Test for controlnet.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 
 class testControlNet( unittest.TestCase ):
 

examples/test/test_cpu.py

@@ -5,17 +5,18 @@ Test for cpu.py
 
 results format:
 
-sched	cpu	received bits/sec
-cfs	50%	8.14e+09
-cfs	40%	6.48e+09
-cfs	30%	4.56e+09
-cfs	20%	2.84e+09
-cfs	10%	1.29e+09
+    sched   cpu client MB/s
+
+    cfs 45.00%  13254.669841
+    cfs 40.00%  11822.441399
+    cfs 30.00%  5112.963009
+    cfs 20.00%  3449.090009
+    cfs 10.00%  2271.741564
 
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 import sys
 
 class testCPU( unittest.TestCase ):
@@ -25,13 +26,13 @@ class testCPU( unittest.TestCase ):
     @unittest.skipIf( '-quick' in sys.argv, 'long test' )
     def testCPU( self ):
         "Verify that CPU utilization is monotonically decreasing for each scheduler"
-        p = pexpect.spawn( 'python -m mininet.examples.cpu', timeout=300 )
+        p = pexpect.spawn( 'python -m mininet.examples.cpu' )
         # matches each line from results( shown above )
-        opts = [ '([a-z]+)\t([\d\.]+)%\t([\d\.e\+]+)',
+        opts = [ '([a-z]+)\t([\d\.]+)%\t([\d\.]+)',
                  pexpect.EOF ]
         scheds = []
         while True:
-            index = p.expect( opts )
+            index = p.expect( opts, timeout=600 )
             if index == 0:
                 sched = p.match.group( 1 )
                 cpu = float( p.match.group( 2 ) )
@@ -39,9 +40,7 @@ class testCPU( unittest.TestCase ):
                 if sched not in scheds:
                     scheds.append( sched )
                 else:
-                    self.assertTrue( bw < previous_bw,
-                                     "%e should be less than %e\n" %
-                                     ( bw, previous_bw ) )
+                    self.assertTrue( bw < previous_bw )
                 previous_bw = bw
             else:
                 break

examples/test/test_emptynet.py

@@ -5,7 +5,7 @@ Test for emptynet.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 
 class testEmptyNet( unittest.TestCase ):
 

examples/test/test_hwintf.py

@@ -7,7 +7,7 @@ Test for hwintf.py
 import unittest
 import re
 
-from mininet.util import pexpect
+import pexpect
 
 from mininet.log import setLogLevel
 from mininet.node import Node
@@ -57,8 +57,8 @@ class testHwintf( unittest.TestCase ):
         p.wait()
 
     def tearDown( self ):
-        self.h3.stop( deleteIntfs=True )
-        self.n0.stop( deleteIntfs=True )
+        self.h3.terminate()
+        self.n0.terminate()
 
 if __name__ == '__main__':
     setLogLevel( 'warning' )

examples/test/test_intfoptions.py

@@ -5,7 +5,7 @@ Test for intfOptions.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 import sys
 
 class testIntfOptions( unittest.TestCase ):
@@ -13,29 +13,27 @@ class testIntfOptions( unittest.TestCase ):
     def testIntfOptions( self ):
         "verify that intf.config is correctly limiting traffic"
         p = pexpect.spawn( 'python -m mininet.examples.intfoptions ' )
-        tolerance = .2  # plus or minus 20%
+        tolerance = .8
         opts = [ "Results: \['([\d\.]+) .bits/sec",
                  "Results: \['10M', '([\d\.]+) .bits/sec",
-                 "h(\d+)->h(\d+): (\d)/(\d),"
-                 "rtt min/avg/max/mdev ([\d\.]+)/([\d\.]+)/([\d\.]+)/([\d\.]+) ms",
+                 "h(\d+)->h(\d+): (\d)/(\d), rtt min/avg/max/mdev ([\d\.]+)/([\d\.]+)/([\d\.]+)/([\d\.]+) ms",
                  pexpect.EOF ]
         while True:
             index = p.expect( opts, timeout=600 )
             if index == 0:
-                BW = 5
                 bw = float( p.match.group( 1 ) )
-                self.assertGreaterEqual( bw, BW * ( 1 - tolerance ) )
-                self.assertLessEqual( bw, BW * ( 1 + tolerance ) )
+                self.assertGreaterEqual( bw, float( 5 * tolerance ) )
+                self.assertLessEqual( bw, float( 5 + 5 * ( 1 - tolerance ) ) )
             elif index == 1:
                 BW = 10
                 measuredBw = float( p.match.group( 1 ) )
                 loss = ( measuredBw / BW ) * 100
-                self.assertGreaterEqual( loss, 50 * ( 1 - tolerance ) )
-                self.assertLessEqual( loss,  50 * ( 1 + tolerance ) )
+                self.assertGreaterEqual( loss, 50 * tolerance )
+                self.assertLessEqual( loss,  50 + 50 * ( 1 - tolerance ) )
             elif index == 2:
                 delay = float( p.match.group( 6 ) )
-                self.assertGreaterEqual( delay, 15 * ( 1 - tolerance ) )
-                self.assertLessEqual( delay,  15 * ( 1 + tolerance ) )
+                self.assertGreaterEqual( delay, 15 * tolerance )
+                self.assertLessEqual( delay,  15 + 15 * ( 1 - tolerance ) )
             else:
                 break
 

examples/test/test_limit.py

@@ -5,7 +5,7 @@ Test for limit.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 import sys
 
 class testLimit( unittest.TestCase ):

examples/test/test_linearbandwidth.py

@@ -5,7 +5,7 @@ Test for linearbandwidth.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 import sys
 
 class testLinearBandwidth( unittest.TestCase ):
@@ -34,8 +34,8 @@ class testLinearBandwidth( unittest.TestCase ):
                     bw *= 10 ** 9
                 # check that we have a previous result to compare to
                 if n != 1:
-                    info = ( 'bw: %.2e bits/s across %d switches, '
-                             'previous: %.2e bits/s across %d switches' %
+                    info = ( 'bw: %d bits/s across %d switches, '
+                             'previous: %d bits/s across %d switches' %
                              ( bw, n, previous_bw, previous_n ) )
                     self.assertTrue( bw < previous_bw, info )
                 previous_bw, previous_n = bw, n

examples/test/test_linuxrouter.py

@@ -5,7 +5,7 @@ Test for linuxrouter.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 from mininet.util import quietRun
 
 class testLinuxRouter( unittest.TestCase ):

examples/test/test_multilink.py

@@ -6,7 +6,7 @@ validates mininet interfaces against systems interfaces
 '''
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 
 class testMultiLink( unittest.TestCase ):
 

examples/test/test_multiping.py

@@ -5,7 +5,7 @@ Test for multiping.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 from collections import defaultdict
 
 class testMultiPing( unittest.TestCase ):
@@ -31,20 +31,18 @@ class testMultiPing( unittest.TestCase ):
                 target = p.match.group(3)
                 received = int( p.match.group(4) )
                 if target == '10.0.0.200':
-                    self.assertEqual( received, 0, p.match.group(0) + '\n' +
-                                      target + ' received %d != 0 packets' % received )
+                    self.assertEqual( received, 0 )
                 else:
-                    self.assertEqual( received, 1, p.match.group(0) + '\n' +
-                                      target + ' received %d != 1 packets' % received )
+                    self.assertEqual( received, 1 )
                 try:
                     pings[ name ].remove( target )
                 except:
                     pass
             else:
                 break
-        self.assertTrue( len( pings ) > 0, 'too few pings' )
+        self.assertTrue( len( pings ) > 0 )
         for t in pings.values():
-            self.assertEqual( len( t ), 0, 'missed ping target(s): %s' % t )
+            self.assertEqual( len( t ), 0 )
 
 if __name__ == '__main__':
     unittest.main()

examples/test/test_multipoll.py

@@ -5,7 +5,7 @@ Test for multipoll.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 
 class testMultiPoll( unittest.TestCase ):
 
@@ -16,7 +16,7 @@ class testMultiPoll( unittest.TestCase ):
                  "(h\d+): \d+ bytes from",
                  "Monitoring output for (\d+) seconds",
                  pexpect.EOF ]
-        pings, seconds = {}, -1
+        pings = {}
         while True:
             index = p.expect( opts )
             if index == 0:
@@ -32,8 +32,7 @@ class testMultiPoll( unittest.TestCase ):
         self.assertTrue( len( pings ) > 0 )
         # make sure we have received at least one ping per second
         for count in pings.values():
-            self.assertTrue( count >= seconds,
-                             '%d pings < %d seconds' % ( count, seconds ) )
+            self.assertTrue( count >= seconds )
 
 if __name__ == '__main__':
     unittest.main()

examples/test/test_multitest.py

@@ -5,7 +5,7 @@ Test for multitest.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 
 class testMultiTest( unittest.TestCase ):
 

examples/test/test_nat.py

@@ -5,7 +5,7 @@ Test for nat.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 from mininet.util import quietRun
 
 destIP = '8.8.8.8' # Google DNS

examples/test/test_natnet.py

@@ -5,7 +5,7 @@ Test for natnet.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 from mininet.util import quietRun
 
 class testNATNet( unittest.TestCase ):

examples/test/test_numberedports.py

@@ -5,7 +5,7 @@ Test for numberedports.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 from collections import defaultdict
 from mininet.node import OVSSwitch
 

examples/test/test_popen.py

@@ -5,7 +5,7 @@ Test for popen.py and popenpoll.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 
 class testPopen( unittest.TestCase ):
 

examples/test/test_scratchnet.py

@@ -5,7 +5,7 @@ Test for scratchnet.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 
 class testScratchNet( unittest.TestCase ):
 
@@ -14,7 +14,7 @@ class testScratchNet( unittest.TestCase ):
     def pingTest( self, name ):
         "Verify that no ping packets were dropped"
         p = pexpect.spawn( 'python -m %s' % name )
-        index = p.expect( self.opts, timeout=120 )
+        index = p.expect( self.opts )
         self.assertEqual( index, 0 )
 
     def testPingKernel( self ):

examples/test/test_simpleperf.py

@@ -5,7 +5,7 @@ Test for simpleperf.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 import sys
 from mininet.log import setLogLevel
 
@@ -16,15 +16,15 @@ class testSimplePerf( unittest.TestCase ):
     @unittest.skipIf( '-quick' in sys.argv, 'long test' )
     def testE2E( self ):
         "Run the example and verify iperf results"
-        # 10 Mb/s, plus or minus 20% tolerance
         BW = 10
-        TOLERANCE = .2
-        p = pexpect.spawn( 'python -m mininet.examples.simpleperf testmode' )
+        TOLERANCE = .8
+        expectedBw = BW * TOLERANCE
+        p = pexpect.spawn( 'python -m mininet.examples.simpleperf' )
         # check iperf results
         p.expect( "Results: \['10M', '([\d\.]+) .bits/sec", timeout=480 )
         measuredBw = float( p.match.group( 1 ) )
-        lowerBound = BW * ( 1 - TOLERANCE )
-        upperBound = BW + ( 1 + TOLERANCE )
+        lowerBound = expectedBw * TOLERANCE
+        upperBound = expectedBw + expectedBw * ( 1 - TOLERANCE )
         self.assertGreaterEqual( measuredBw, lowerBound )
         self.assertLessEqual( measuredBw, upperBound )
         p.wait()

examples/test/test_sshd.py

@@ -5,7 +5,7 @@ Test for sshd.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 from mininet.clean import sh
 
 class testSSHD( unittest.TestCase ):
@@ -20,7 +20,7 @@ class testSSHD( unittest.TestCase ):
         while True:
             index = p.expect( self.opts )
             if index == 0:
-                print( p.match.group(0) )
+                print p.match.group(0)
                 p.sendline( 'yes' )
             elif index == 1:
                 return False

examples/test/test_tree1024.py

@@ -5,7 +5,7 @@ Test for tree1024.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 import sys
 
 class testTree1024( unittest.TestCase ):
@@ -17,15 +17,13 @@ class testTree1024( unittest.TestCase ):
         "Run the example and do a simple ping test from h1 to h1024"
         p = pexpect.spawn( 'python -m mininet.examples.tree1024' )
         p.expect( self.prompt, timeout=6000 ) # it takes awhile to set up
-        p.sendline( 'h1 ping -c 20 h1024' )
+        p.sendline( 'h1 ping -c 1 h1024' )
         p.expect ( '(\d+)% packet loss' )
-        packetLossPercent = int( p.match.group( 1 ) ) if p.match else -1
+        percent = int( p.match.group( 1 ) ) if p.match else -1
         p.expect( self.prompt )
         p.sendline( 'exit' )
         p.wait()
-        # Tolerate slow startup on some systems - we should revisit this
-        # and determine the root cause.
-        self.assertLess( packetLossPercent, 60 )
+        self.assertEqual( percent, 0 )
 
 if __name__ == '__main__':
     unittest.main()

examples/test/test_treeping64.py

@@ -5,7 +5,7 @@ Test for treeping64.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 import sys
 
 class testTreePing64( unittest.TestCase ):

examples/test/test_vlanhost.py

@@ -5,7 +5,7 @@ Test for vlanhost.py
 """
 
 import unittest
-from mininet.util import pexpect
+import pexpect
 import sys
 from mininet.util import quietRun
 

examples/treeping64.py

@@ -2,8 +2,7 @@
 
 "Create a 64-node tree network, and test connectivity using ping."
 
-
-from mininet.log import setLogLevel, info
+from mininet.log import setLogLevel
 from mininet.node import UserSwitch, OVSKernelSwitch  # , KernelSwitch
 from mininet.topolib import TreeNet
 
@@ -16,16 +15,17 @@ def treePing64():
                   'Open vSwitch kernel': OVSKernelSwitch }
 
     for name in switches:
-        info( "*** Testing", name, "datapath\n" )
+        print "*** Testing", name, "datapath"
         switch = switches[ name ]
         network = TreeNet( depth=2, fanout=8, switch=switch )
         result = network.run( network.pingAll )
         results[ name ] = result
 
-    info( "\n*** Tree network ping results:\n" )
+    print
+    print "*** Tree network ping results:"
     for name in switches:
-        info( "%s: %d%% packet loss\n" % ( name, results[ name ] ) )
-    info( '\n' )
+        print "%s: %d%% packet loss" % ( name, results[ name ] )
+    print
 
 if __name__ == '__main__':
     setLogLevel( 'info' )

mininet/clean.py

@@ -16,13 +16,12 @@ import time
 
 from mininet.log import info
 from mininet.term import cleanUpScreens
-from mininet.util import decode
+
 
 def sh( cmd ):
     "Print a command and send it to the shell"
     info( cmd + '\n' )
-    result = Popen( [ '/bin/sh', '-c', cmd ], stdout=PIPE ).communicate()[ 0 ]
-    return decode( result )
+    return Popen( [ '/bin/sh', '-c', cmd ], stdout=PIPE ).communicate()[ 0 ]
 
 def killprocs( pattern ):
     "Reliably terminate processes matching a pattern (including args)"
@@ -51,9 +50,8 @@ class Cleanup( object ):
 
         info( "*** Removing excess controllers/ofprotocols/ofdatapaths/"
               "pings/noxes\n" )
-        zombies = ( 'controller ofprotocol ofdatapath ping nox_core'
-                    'lt-nox_core ovs-openflowd ovs-controller'
-                    'ovs-testcontroller udpbwtest mnexec ivs ryu-manager' )
+        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.
@@ -77,6 +75,7 @@ class Cleanup( object ):
         for dp in dps:
             if dp:
                 sh( 'dpctl deldp ' + dp )
+
         info( "***  Removing OVS datapaths\n" )
         dps = sh("ovs-vsctl --timeout=1 list-br").strip().splitlines()
         if dps:
@@ -93,7 +92,7 @@ class Cleanup( object ):
                     ).splitlines()
         # Delete blocks of links
         n = 1000  # chunk size
-        for i in range( 0, len( links ), n ):
+        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 )

mininet/cli.py

@@ -29,8 +29,6 @@ from subprocess import call
 from cmd import Cmd
 from os import isatty
 from select import poll, POLLIN
-import select
-import errno
 import sys
 import time
 import os
@@ -79,15 +77,13 @@ class CLI( Cmd ):
             return
         cls.readlineInited = True
         try:
-            from readline import ( read_history_file, write_history_file,
-                                   set_history_length )
+            from readline import read_history_file, write_history_file
         except ImportError:
             pass
         else:
             history_path = os.path.expanduser( '~/.mininet_history' )
             if os.path.isfile( history_path ):
                 read_history_file( history_path )
-                set_history_length( 1000 )
             atexit.register( lambda: write_history_file( history_path ) )
 
     def run( self ):
@@ -180,7 +176,7 @@ class CLI( Cmd ):
                 output( result + '\n' )
             else:
                 output( repr( result ) + '\n' )
-        except Exception as e:
+        except Exception, e:
             output( str( e ) + '\n' )
 
     # We are in fact using the exec() pseudo-function
@@ -191,7 +187,7 @@ class CLI( Cmd ):
             Node names may be used, e.g.: px print h1.cmd('ls')"""
         try:
             exec( line, globals(), self.getLocals() )
-        except Exception as e:
+        except Exception, e:
             output( str( e ) + '\n' )
 
     # pylint: enable=broad-except,exec-used
@@ -375,7 +371,7 @@ class CLI( Cmd ):
     def do_links( self, _line ):
         "Report on links"
         for link in self.mn.links:
-            output( link, link.status(), '\n' )
+            print link, link.status()
 
     def do_switch( self, line ):
         "Starts or stops a switch"
@@ -401,16 +397,15 @@ class CLI( Cmd ):
 
     def default( self, line ):
         """Called on an input line when the command prefix is not recognized.
-           Overridden to run shell commands when a node is the first
-           CLI argument.  Past the first CLI argument, node names are
-           automatically replaced with corresponding IP addrs."""
+        Overridden to run shell commands when a node is the first CLI argument.
+        Past the first CLI argument, node names are automatically replaced with
+        corresponding IP addrs."""
 
         first, args, line = self.parseline( line )
 
         if first in self.mn:
             if not args:
-                error( '*** Please enter a command for node: %s <cmd>\n'
-                       % first )
+                print "*** Enter a command for node: %s <cmd>" % first
                 return
             node = self.mn[ first ]
             rest = args.split( ' ' )
@@ -461,13 +456,6 @@ class CLI( Cmd ):
                 # it's possible to interrupt ourselves after we've
                 # read data but before it has been printed.
                 node.sendInt()
-            except select.error as e:
-                # pylint: disable=unpacking-non-sequence
-                errno_, errmsg = e.args
-                # pylint: enable=unpacking-non-sequence
-                if errno_ != errno.EINTR:
-                    error( "select.error: %d, %s" % (errno_, errmsg) )
-                    node.sendInt()
 
     def precmd( self, line ):
         "allow for comments in the cli"

mininet/link.py

@@ -26,6 +26,7 @@ Link: basic link class for creating veth pairs
 
 from mininet.log import info, error, debug
 from mininet.util import makeIntfPair
+import mininet.node
 import re
 
 class Intf( object ):
@@ -48,14 +49,12 @@ class Intf( object ):
         # This saves an ifconfig command per node
         if self.name == 'lo':
             self.ip = '127.0.0.1'
-            self.prefixLen = 8
         # Add to node (and move ourselves if necessary )
-        if node:
-            moveIntfFn = params.pop( 'moveIntfFn', None )
-            if moveIntfFn:
-                node.addIntf( self, port=port, moveIntfFn=moveIntfFn )
-            else:
-                node.addIntf( self, port=port )
+        moveIntfFn = params.pop( 'moveIntfFn', None )
+        if moveIntfFn:
+            node.addIntf( self, port=port, moveIntfFn=moveIntfFn )
+        else:
+            node.addIntf( self, port=port )
         # Save params for future reference
         self.params = params
         self.config( **params )
@@ -68,19 +67,36 @@ class Intf( object ):
         "Configure ourselves using ifconfig"
         return self.cmd( 'ifconfig', self.name, *args )
 
-    def setIP( self, ipstr, prefixLen=None ):
-        """Set our IP address"""
+    def setIP( self, ip, prefixLen=8, action='add' ):
+        """Set our IP address(es) and bring interface up
+           ip: IP address string or list
+           prefixLen: optional default prefix length if '/' not in addr (8)
+           action: optional action for IPv6 addrs (default 'add')"""
+        if isinstance( ip, basestring ):
+            ip = ( ip, )
+        ipstr = ip[ 0 ]
         # This is a sign that we should perhaps rethink our prefix
         # mechanism and/or the way we specify IP addresses
-        if '/' in ipstr:
-            self.ip, self.prefixLen = ipstr.split( '/' )
-            return self.ifconfig( ipstr, 'up' )
-        else:
-            if prefixLen is None:
-                raise Exception( 'No prefix length set for IP address %s'
-                                 % ( ipstr, ) )
-            self.ip, self.prefixLen = ipstr, prefixLen
-            return self.ifconfig( '%s/%s' % ( ipstr, prefixLen ) )
+        result = ''
+        self.ips = []
+        for index, ipstr in enumerate( ip ):
+            if '/' in ipstr:
+                ip, prefixLen = ipstr.split( '/' )
+            else:
+                ipstr = '%s/%s' % ( ipstr, prefixLen )
+            if index == 0:
+                dev = self.name
+                self.ip, self.prefixLen = ip, prefixLen
+            else:
+                dev = '%s:%d' % ( self, index )
+            if ':' not in ipstr:
+                result += self.cmd( 'ifconfig', dev, ipstr, 'up' )
+            else:
+                # IPv6
+                result += self.cmd( 'ifconfig', dev, 'inet6', action, ipstr,
+                                    'up' )
+            self.ips += [ ipstr ]
+        return result
 
     def setMAC( self, macstr ):
         """Set the MAC address for an interface.
@@ -90,18 +106,23 @@ class Intf( object ):
                  self.ifconfig( 'hw', 'ether', macstr ) +
                  self.ifconfig( 'up' ) )
 
-    _ipMatchRegex = re.compile( r'\d+\.\d+\.\d+\.\d+' )
+    _ipMatchRegex = re.compile( r'inet.? (.*)/' )
     _macMatchRegex = re.compile( r'..:..:..:..:..:..' )
 
-    def updateIP( self ):
-        "Return updated IP address based on ifconfig"
+    def updateIP( self, all=False ):
+        """Return updated IP address based on ifconfig
+           all: return list of all IP addresses for this interface"""
         # use pexec instead of node.cmd so that we dont read
         # backgrounded output from the cli.
-        ifconfig, _err, _exitCode = self.node.pexec(
-            'ifconfig %s' % self.name )
-        ips = self._ipMatchRegex.findall( ifconfig )
+        ipaddr, _err, _exitCode = self.node.pexec(
+            'ip', 'addr', 'show', self.name )
+        ips = self._ipMatchRegex.findall( ipaddr )
         self.ip = ips[ 0 ] if ips else None
-        return self.ip
+        self.ips = ips
+        if all:
+            return self.ips
+        else:
+            return self.ip
 
     def updateMAC( self ):
         "Return updated MAC address based on ifconfig"
@@ -123,9 +144,10 @@ class Intf( object ):
         self.mac = macs[ 0 ] if macs else None
         return self.ip, self.mac
 
-    def IP( self ):
-        "Return IP address"
-        return self.ip
+    def IP( self, all=False):
+        """Return IP address
+           all: return list of IP addresses for this interface (False)"""
+        return self.ips if all else self.ip
 
     def MAC( self ):
         "Return MAC address"
@@ -146,9 +168,6 @@ class Intf( object ):
 
     def rename( self, newname ):
         "Rename interface"
-        if self.node and self.name in self.node.nameToIntf:
-            # rename intf in node's nameToIntf
-            self.node.nameToIntf[newname] = self.node.nameToIntf.pop(self.name)
         self.ifconfig( 'down' )
         result = self.cmd( 'ip link set', self.name, 'name', newname )
         self.name = newname
@@ -167,7 +186,7 @@ class Intf( object ):
            method: config method name
            param: arg=value (ignore if value=None)
            value may also be list or dict"""
-        name, value = list( param.items() )[ 0 ]
+        name, value = param.items()[ 0 ]
         f = getattr( self, method, None )
         if not f or value is None:
             return
@@ -205,8 +224,6 @@ class Intf( object ):
         # if self.node.inNamespace:
         # Link may have been dumped into root NS
         # quietRun( 'ip link del ' + self.name )
-        self.node.delIntf( self )
-        self.link = None
 
     def status( self ):
         "Return intf status as a string"
@@ -256,7 +273,7 @@ class TCIntf( Intf ):
                           + 'rate %fMbit ul rate %fMbit' % ( bw, bw ) ]
             elif use_tbf:
                 if latency_ms is None:
-                    latency_ms = 15.0 * 8 / bw
+                    latency_ms = 15 * 8 / bw
                 cmds += [ '%s qdisc add dev %s root handle 5: tbf ' +
                           'rate %fMbit burst 15000 latency %fms' %
                           ( bw, latency_ms ) ]
@@ -288,14 +305,18 @@ class TCIntf( Intf ):
                    loss=None, max_queue_size=None ):
         "Internal method: return tc commands for delay and loss"
         cmds = []
-        if loss and ( loss < 0 or loss > 100 ):
+        if delay and delay < 0:
+            error( 'Negative delay', delay, '\n' )
+        elif jitter and jitter < 0:
+            error( 'Negative jitter', jitter, '\n' )
+        elif loss and ( loss < 0 or loss > 100 ):
             error( 'Bad loss percentage', loss, '%%\n' )
         else:
             # Delay/jitter/loss/max queue size
             netemargs = '%s%s%s%s' % (
                 'delay %s ' % delay if delay is not None else '',
                 '%s ' % jitter if jitter is not None else '',
-                'loss %.5f ' % loss if loss is not None else '',
+                'loss %d ' % loss if loss is not None else '',
                 'limit %d' % max_queue_size if max_queue_size is not None
                 else '' )
             if netemargs:
@@ -312,40 +333,16 @@ class TCIntf( Intf ):
         return self.cmd( c )
 
     def config( self, bw=None, delay=None, jitter=None, loss=None,
-                gro=False, txo=True, rxo=True,
-                speedup=0, use_hfsc=False, use_tbf=False,
+                disable_gro=True, speedup=0, use_hfsc=False, use_tbf=False,
                 latency_ms=None, enable_ecn=False, enable_red=False,
                 max_queue_size=None, **params ):
-        """Configure the port and set its properties.
-           bw: bandwidth in b/s (e.g. '10m')
-           delay: transmit delay (e.g. '1ms' )
-           jitter: jitter (e.g. '1ms')
-           loss: loss (e.g. '1%' )
-           gro: enable GRO (False)
-           txo: enable transmit checksum offload (True)
-           rxo: enable receive checksum offload (True)
-           speedup: experimental switch-side bw option
-           use_hfsc: use HFSC scheduling
-           use_tbf: use TBF scheduling
-           latency_ms: TBF latency parameter
-           enable_ecn: enable ECN (False)
-           enable_red: enable RED (False)
-           max_queue_size: queue limit parameter for netem"""
-
-        # Support old names for parameters
-        gro = not params.pop( 'disable_gro', not gro )
+        "Configure the port and set its properties."
 
         result = Intf.config( self, **params)
 
-        def on( isOn ):
-            "Helper method: bool -> 'on'/'off'"
-            return 'on' if isOn else 'off'
-
-        # Set offload parameters with ethool
-        self.cmd( 'ethtool -K', self,
-                  'gro', on( gro ),
-                  'tx', on( txo ),
-                  'rx', on( rxo ) )
+        # Disable GRO
+        if disable_gro:
+            self.cmd( 'ethtool -K %s gro off' % self )
 
         # Optimization: return if nothing else to configure
         # Question: what happens if we want to reset things?
@@ -355,7 +352,7 @@ class TCIntf( Intf ):
 
         # Clear existing configuration
         tcoutput = self.tc( '%s qdisc show dev %s' )
-        if "priomap" not in tcoutput and "noqueue" not in tcoutput:
+        if "priomap" not in tcoutput:
             cmds = [ '%s qdisc del dev %s root' ]
         else:
             cmds = []
@@ -379,7 +376,7 @@ class TCIntf( Intf ):
         stuff = ( ( [ '%.2fMbit' % bw ] if bw is not None else [] ) +
                   ( [ '%s delay' % delay ] if delay is not None else [] ) +
                   ( [ '%s jitter' % jitter ] if jitter is not None else [] ) +
-                  ( ['%.5f%% loss' % loss ] if loss is not None else [] ) +
+                  ( ['%d%% loss' % loss ] if loss is not None else [] ) +
                   ( [ 'ECN' ] if enable_ecn else [ 'RED' ]
                     if enable_red else [] ) )
         info( '(' + ' '.join( stuff ) + ') ' )
@@ -407,7 +404,7 @@ class Link( object ):
     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, **params ):
+                  params2=None, fast=True ):
         """Create veth link to another node, making two new interfaces.
            node1: first node
            node2: second node
@@ -417,15 +414,18 @@ class Link( object ):
            cls1, cls2: optional interface-specific constructors
            intfName1: node1 interface name (optional)
            intfName2: node2  interface name (optional)
-           params1: parameters for interface 1 (optional)
-           params2: parameters for interface 2 (optional)
-           **params: additional parameters for both interfaces"""
-
+           params1: parameters for interface 1
+           params2: parameters for interface 2"""
         # This is a bit awkward; it seems that having everything in
         # params is more orthogonal, but being able to specify
         # in-line arguments is more convenient! So we support both.
-        params1 = dict( params1 ) if params1 else {}
-        params2 = dict( params2 ) if params2 else {}
+        if params1 is None:
+            params1 = {}
+        if params2 is None:
+            params2 = {}
+        # Allow passing in params1=params2
+        if params2 is params1:
+            params2 = dict( params1 )
         if port1 is not None:
             params1[ 'port' ] = port1
         if port2 is not None:
@@ -439,10 +439,6 @@ class Link( object ):
         if not intfName2:
             intfName2 = self.intfName( node2, params2[ 'port' ] )
 
-        # Update with remaining parameter list
-        params1.update( params )
-        params2.update( params )
-
         self.fast = fast
         if fast:
             params1.setdefault( 'moveIntfFn', self._ignore )
@@ -464,7 +460,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
@@ -498,9 +493,9 @@ class Link( object ):
     def delete( self ):
         "Delete this link"
         self.intf1.delete()
-        self.intf1 = None
-        self.intf2.delete()
-        self.intf2 = None
+        # We only need to delete one side, though this doesn't seem to
+        # cost us much and might help subclasses.
+        # self.intf2.delete()
 
     def stop( self ):
         "Override to stop and clean up link as needed"
@@ -533,10 +528,9 @@ class OVSLink( Link ):
 
     def __init__( self, node1, node2, **kwargs ):
         "See Link.__init__() for options"
-        from mininet.node import OVSSwitch
         self.isPatchLink = False
-        if ( isinstance( node1, OVSSwitch ) and
-             isinstance( node2, OVSSwitch ) ):
+        if ( isinstance( node1, mininet.node.OVSSwitch ) and
+             isinstance( node2, mininet.node.OVSSwitch ) ):
             self.isPatchLink = True
             kwargs.update( cls1=OVSIntf, cls2=OVSIntf )
         Link.__init__( self, node1, node2, **kwargs )
@@ -550,23 +544,14 @@ class OVSLink( Link ):
 
 
 class TCLink( Link ):
-    "Link with TC interfaces"
-    def __init__( self, *args, **kwargs):
-        kwargs.setdefault( 'cls1', TCIntf )
-        kwargs.setdefault( 'cls2', TCIntf )
-        Link.__init__( self, *args, **kwargs)
-
-
-class TCULink( TCLink ):
-    """TCLink with default settings optimized for UserSwitch
-       (txo=rxo=0/False).  Unfortunately with recent Linux kernels,
-       enabling TX and RX checksum offload on veth pairs doesn't work
-       well with UserSwitch: either it gets terrible performance or
-       TCP packets with bad checksums are generated, forwarded, and
-       *dropped* due to having bad checksums! OVS and LinuxBridge seem
-       to cope with this somehow, but it is likely to be an issue with
-       many software Ethernet bridges."""
-
-    def __init__( self, *args, **kwargs ):
-        kwargs.update( txo=False, rxo=False )
-        TCLink.__init__( self, *args, **kwargs )
+    "Link with symmetric TC interfaces configured via opts"
+    def __init__( self, node1, node2, port1=None, port2=None,
+                  intfName1=None, intfName2=None,
+                  addr1=None, addr2=None, **params ):
+        Link.__init__( self, node1, node2, port1=port1, port2=port2,
+                       intfName1=intfName1, intfName2=intfName2,
+                       cls1=TCIntf,
+                       cls2=TCIntf,
+                       addr1=addr1, addr2=addr2,
+                       params1=params,
+                       params2=params )

mininet/log.py

@@ -160,7 +160,7 @@ def makeListCompatible( fn ):
         "Generated function. Closure-ish."
         if len( args ) == 1:
             return fn( *args )
-        args = ' '.join( str( arg ) for arg in args )
+        args = ' '.join( [ str( arg ) for arg in args ] )
         return fn( args )
 
     # Fix newfn's name and docstring
@@ -168,10 +168,9 @@ def makeListCompatible( fn ):
     setattr( newfn, '__doc__', fn.__doc__ )
     return newfn
 
-_loggers = lg.info, lg.output, lg.warn, lg.error, lg.debug
-_loggers = tuple( makeListCompatible( logger )
-                  for logger in _loggers )
-lg.info, lg.output, lg.warn, lg.error, lg.debug = _loggers
-info, output, warn, error, debug = _loggers
+info, output, warn, error, debug = (
+    lg.info, lg.output, lg.warn, lg.error, lg.debug ) = [
+        makeListCompatible( f ) for f in
+            lg.info, lg.output, lg.warn, lg.error, lg.debug ]
 
 setLogLevel = lg.setLogLevel

mininet/moduledeps.py

@@ -1,6 +1,6 @@
 "Module dependency utility functions for Mininet."
 
-from mininet.util import quietRun, BaseString
+from mininet.util import quietRun
 from mininet.log import info, error, debug
 from os import environ
 
@@ -28,9 +28,9 @@ def moduleDeps( subtract=None, add=None ):
        add: string or list of module names to add, if not already loaded"""
     subtract = subtract if subtract is not None else []
     add = add if add is not None else []
-    if isinstance( subtract, BaseString ):
+    if isinstance( subtract, basestring ):
         subtract = [ subtract ]
-    if isinstance( add, BaseString ):
+    if isinstance( add, basestring ):
         add = [ add ]
     for mod in subtract:
         if mod in lsmod():

mininet/net.py

@@ -104,11 +104,11 @@ 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, BaseString )
+                           waitListening )
 from mininet.term import cleanUpScreens, makeTerms
 
 # Mininet version: should be consistent with README and LICENSE
-VERSION = "2.3.0d5"
+VERSION = "2.2.1d2"
 
 class Mininet( object ):
     "Network emulation with hosts spawned in network namespaces."
@@ -144,9 +144,7 @@ class Mininet( object ):
         self.intf = intf
         self.ipBase = ipBase
         self.ipBaseNum, self.prefixLen = netParse( self.ipBase )
-        hostIP = ( 0xffffffff >> self.prefixLen ) & self.ipBaseNum
-        # Start for address allocation
-        self.nextIP = hostIP if hostIP > 0 else 1
+        self.nextIP = 1  # start for address allocation
         self.inNamespace = inNamespace
         self.xterms = xterms
         self.cleanup = cleanup
@@ -190,7 +188,7 @@ class Mininet( object ):
             if not remaining:
                 info( '\n' )
                 return True
-            if timeout is not None and time > timeout:
+            if time > timeout and timeout is not None:
                 break
             sleep( delay )
             time += delay
@@ -228,24 +226,6 @@ class Mininet( object ):
         self.nameToNode[ name ] = h
         return h
 
-    def delNode( self, node, nodes=None):
-        """Delete node
-           node: node to delete
-           nodes: optional list to delete from (e.g. self.hosts)"""
-        if nodes is None:
-            nodes = ( self.hosts if node in self.hosts else
-                      ( self.switches if node in self.switches else
-                        ( self.controllers if node in self.controllers else
-                          [] ) ) )
-        node.stop( deleteIntfs=True )
-        node.terminate()
-        nodes.remove( node )
-        del self.nameToNode[ node.name ]
-
-    def delHost( self, host ):
-        "Delete a host"
-        self.delNode( host, nodes=self.hosts )
-
     def addSwitch( self, name, cls=None, **params ):
         """Add switch.
            name: name of switch to add
@@ -264,10 +244,6 @@ class Mininet( object ):
         self.nameToNode[ name ] = sw
         return sw
 
-    def delSwitch( self, switch ):
-        "Delete a switch"
-        self.delNode( switch, nodes=self.switches )
-
     def addController( self, name='c0', controller=None, **params ):
         """Add controller.
            controller: Controller class"""
@@ -289,12 +265,6 @@ class Mininet( object ):
             self.nameToNode[ name ] = controller_new
         return controller_new
 
-    def delController( self, controller ):
-        """Delete a controller
-           Warning - does not reconfigure switches, so they
-           may still attempt to connect to it!"""
-        self.delNode( controller )
-
     def addNAT( self, name='nat0', connect=True, inNamespace=False,
                 **params):
         """Add a NAT to the Mininet network
@@ -311,7 +281,7 @@ class Mininet( object ):
                 # Use first switch if not specified
                 connect = self.switches[ 0 ]
             # Connect the nat to the switch
-            self.addLink( nat, connect )
+            self.addLink( nat, self.switches[ 0 ] )
             # Set the default route on hosts
             natIP = nat.params[ 'ip' ].split('/')[ 0 ]
             for host in self.hosts:
@@ -333,13 +303,9 @@ class Mininet( object ):
 
     # Even more convenient syntax for node lookup and iteration
     def __getitem__( self, key ):
-        "net[ name ] operator: Return node with given name"
+        """net [ name ] operator: Return node(s) with given name(s)"""
         return self.nameToNode[ key ]
 
-    def __delitem__( self, key ):
-        "del net[ name ] operator - delete node with given name"
-        self.delNode( self.nameToNode[ key ] )
-
     def __iter__( self ):
         "return iterator over node names"
         for node in chain( self.hosts, self.switches, self.controllers ):
@@ -383,16 +349,14 @@ class Mininet( object ):
             params: additional link params (optional)
             returns: link object"""
         # Accept node objects or names
-        node1 = node1 if not isinstance( node1, BaseString ) else self[ node1 ]
-        node2 = node2 if not isinstance( node2, BaseString ) else self[ node2 ]
+        node1 = node1 if not isinstance( node1, basestring ) else self[ node1 ]
+        node2 = node2 if not isinstance( node2, basestring ) else self[ node2 ]
         options = dict( params )
         # Port is optional
         if port1 is not None:
             options.setdefault( 'port1', port1 )
         if port2 is not None:
             options.setdefault( 'port2', port2 )
-        if self.intf is not None:
-            options.setdefault( 'intf', self.intf )
         # Set default MAC - this should probably be in Link
         options.setdefault( 'addr1', self.randMac() )
         options.setdefault( 'addr2', self.randMac() )
@@ -401,30 +365,6 @@ class Mininet( object ):
         self.links.append( link )
         return link
 
-    def delLink( self, link ):
-        "Remove a link from this network"
-        link.delete()
-        self.links.remove( link )
-
-    def linksBetween( self, node1, node2 ):
-        "Return Links between node1 and node2"
-        return [ link for link in self.links
-                 if ( node1, node2 ) in (
-                    ( link.intf1.node, link.intf2.node ),
-                    ( link.intf2.node, link.intf1.node ) ) ]
-
-    def delLinkBetween( self, node1, node2, index=0, allLinks=False ):
-        """Delete link(s) between node1 and node2
-           index: index of link to delete if multiple links (0)
-           allLinks: ignore index and delete all such links (False)
-           returns: deleted link(s)"""
-        links = self.linksBetween( node1, node2 )
-        if not allLinks:
-            links = [ links[ index ] ]
-        for link in links:
-            self.delLink( link )
-        return links
-
     def configHosts( self ):
         "Configure a set of hosts."
         for host in self.hosts:
@@ -549,8 +489,7 @@ class Mininet( object ):
             switch.start( self.controllers )
         started = {}
         for swclass, switches in groupby(
-                sorted( self.switches,
-                        key=lambda s: str( type( s ) ) ), type ):
+                sorted( self.switches, key=type ), type ):
             switches = tuple( switches )
             if hasattr( swclass, 'batchStartup' ):
                 success = swclass.batchStartup( switches )
@@ -577,8 +516,7 @@ class Mininet( object ):
         info( '*** Stopping %i switches\n' % len( self.switches ) )
         stopped = {}
         for swclass, switches in groupby(
-                sorted( self.switches,
-                        key=lambda s: str( type( s ) ) ), type ):
+                sorted( self.switches, key=type ), type ):
             switches = tuple( switches )
             if hasattr( swclass, 'batchShutdown' ):
                 success = swclass.batchShutdown( switches )
@@ -636,7 +574,7 @@ class Mininet( object ):
         # Check for downed link
         if 'connect: Network is unreachable' in pingOutput:
             return 1, 0
-        r = r'(\d+) packets transmitted, (\d+)( packets)? received'
+        r = r'(\d+) packets transmitted, (\d+) received'
         m = re.search( r, pingOutput )
         if m is None:
             error( '*** Error: could not parse ping output: %s\n' %
@@ -698,7 +636,7 @@ class Mininet( object ):
         m = re.search( r, pingOutput )
         if m is not None:
             return errorTuple
-        r = r'(\d+) packets transmitted, (\d+)( packets)? received'
+        r = r'(\d+) packets transmitted, (\d+) received'
         m = re.search( r, pingOutput )
         if m is None:
             error( '*** Error: could not parse ping output: %s\n' %
@@ -827,14 +765,8 @@ class Mininet( object ):
         cliout = client.cmd( iperfArgs + '-t %d -c ' % seconds +
                              server.IP() + ' ' + bwArgs )
         debug( 'Client output: %s\n' % cliout )
-        servout = ''
-        # We want the last *b/sec from the iperf server output
-        # for TCP, there are two of them because of waitListening
-        count = 2 if l4Type == 'TCP' else 1
-        while len( re.findall( '/sec', servout ) ) < count:
-            servout += server.monitor( timeoutms=5000 )
         server.sendInt()
-        servout += server.waitOutput()
+        servout = server.waitOutput()
         debug( 'Server output: %s\n' % servout )
         result = [ self._parseIperf( servout ), self._parseIperf( cliout ) ]
         if l4Type == 'UDP':
@@ -848,6 +780,7 @@ class Mininet( object ):
         duration: test duration in seconds (integer)
         returns a single list of measured CPU fractions as floats.
         """
+        cores = int( quietRun( 'nproc' ) )
         pct = cpu * 100
         info( '*** Testing CPU %.0f%% bandwidth limit\n' % pct )
         hosts = self.hosts
@@ -899,8 +832,10 @@ class Mininet( object ):
         elif dst not in self.nameToNode:
             error( 'dst not in network: %s\n' % dst )
         else:
-            src = self.nameToNode[ src ]
-            dst = self.nameToNode[ dst ]
+            if isinstance( src, basestring ):
+                src = self.nameToNode[ src ]
+            if isinstance( dst, basestring ):
+                dst = self.nameToNode[ dst ]
             connections = src.connectionsTo( dst )
             if len( connections ) == 0:
                 error( 'src and dst not connected: %s %s\n' % ( src, dst) )

mininet/node.py

@@ -62,8 +62,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, BaseString, decode,
-                           encode, Python3 )
+                           numCores, retry, mountCgroups )
 from mininet.moduledeps import moduleDeps, pathCheck, TUN
 from mininet.link import Link, Intf, TCIntf, OVSIntf
 from re import findall
@@ -88,9 +87,6 @@ class Node( object ):
         self.privateDirs = params.get( 'privateDirs', [] )
         self.inNamespace = params.get( 'inNamespace', inNamespace )
 
-        # Python 3 complains if we don't wait for shell exit
-        self.waitExited = params.get( 'waitExited', Python3 )
-
         # Stash configuration parameters for future reference
         self.params = params
 
@@ -107,7 +103,6 @@ class Node( object ):
         self.readbuf = ''
 
         # Start command interpreter shell
-        self.master, self.slave = None, None  # pylint
         self.startShell()
         self.mountPrivateDirs()
 
@@ -140,18 +135,14 @@ class Node( object ):
         # -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', '--noediting',
-                '-is', 'mininet:' + self.name ]
-
+                'bash', '--norc', '-is', '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
-        self.master, self.slave = pty.openpty()
-        self.shell = self._popen( cmd, stdin=self.slave, stdout=self.slave,
-                                  stderr=self.slave, close_fds=False )
-        # XXX BL: This doesn't seem right, and we should also probably
-        # close our files when we exit...
-        self.stdin = os.fdopen( self.master, 'r' )
+        master, slave = pty.openpty()
+        self.shell = self._popen( cmd, stdin=slave, stdout=slave, stderr=slave,
+                                  close_fds=False )
+        self.stdin = os.fdopen( master, 'rw' )
         self.stdout = self.stdin
         self.pid = self.shell.pid
         self.pollOut = select.poll()
@@ -177,8 +168,6 @@ class Node( object ):
 
     def mountPrivateDirs( self ):
         "mount private directories"
-        # Avoid expanding a string into a list of chars
-        assert not isinstance( self.privateDirs, BaseString )
         for directory in self.privateDirs:
             if isinstance( directory, tuple ):
                 # mount given private directory
@@ -207,9 +196,7 @@ class Node( object ):
             params: parameters to Popen()"""
         # Leave this is as an instance method for now
         assert self
-        popen = Popen( cmd, **params )
-        debug( '_popen', cmd, popen.pid )
-        return popen
+        return Popen( cmd, **params )
 
     def cleanup( self ):
         "Help python collect its garbage."
@@ -218,23 +205,16 @@ class Node( object ):
         # for intfName in self.intfNames():
         # if self.name in intfName:
         # quietRun( 'ip link del ' + intfName )
-        if self.shell:
-            # Close ptys
-            self.stdin.close()
-            os.close(self.slave)
-            if self.waitExited:
-                debug( 'waiting for', self.pid, 'to terminate\n' )
-                self.shell.wait()
         self.shell = None
 
     # Subshell I/O, commands and control
 
     def read( self, maxbytes=1024 ):
-        """Buffered read from node, potentially blocking.
+        """Buffered read from node, non-blocking.
            maxbytes: maximum number of bytes to return"""
         count = len( self.readbuf )
         if count < maxbytes:
-            data = decode( os.read( self.stdout.fileno(), maxbytes - count ) )
+            data = os.read( self.stdout.fileno(), maxbytes - count )
             self.readbuf += data
         if maxbytes >= len( self.readbuf ):
             result = self.readbuf
@@ -245,7 +225,7 @@ class Node( object ):
         return result
 
     def readline( self ):
-        """Buffered readline from node, potentially blocking.
+        """Buffered readline from node, non-blocking.
            returns: line (minus newline) or None"""
         self.readbuf += self.read( 1024 )
         if '\n' not in self.readbuf:
@@ -258,7 +238,7 @@ class Node( object ):
     def write( self, data ):
         """Write data to node.
            data: string"""
-        os.write( self.stdin.fileno(), encode( data ) )
+        os.write( self.stdin.fileno(), data )
 
     def terminate( self ):
         "Send kill signal to Node and clean up after it."
@@ -277,10 +257,9 @@ class Node( object ):
 
     def waitReadable( self, timeoutms=None ):
         """Wait until node's output is readable.
-           timeoutms: timeout in ms or None to wait indefinitely.
-           returns: result of poll()"""
+           timeoutms: timeout in ms or None to wait indefinitely."""
         if len( self.readbuf ) == 0:
-            return self.pollOut.poll( timeoutms )
+            self.pollOut.poll( timeoutms )
 
     def sendCmd( self, *args, **kwargs ):
         """Send a command, followed by a command to echo a sentinel,
@@ -322,9 +301,7 @@ class Node( object ):
            Set self.waiting to False if command has completed.
            timeoutms: timeout in ms or None to wait indefinitely
            findPid: look for PID from mnexec -p"""
-        ready = self.waitReadable( timeoutms )
-        if not ready:
-            return ''
+        self.waitReadable( timeoutms )
         data = self.read( 1024 )
         pidre = r'\[\d+\] \d+\r\n'
         # Look for PID
@@ -388,23 +365,23 @@ class Node( object ):
                      'mncmd':
                      [ 'mnexec', '-da', str( self.pid ) ] }
         defaults.update( kwargs )
-        shell = defaults.pop( 'shell', False )
         if len( args ) == 1:
             if isinstance( args[ 0 ], list ):
                 # popen([cmd, arg1, arg2...])
                 cmd = args[ 0 ]
-            elif isinstance( args[ 0 ], BaseString ):
+            elif isinstance( args[ 0 ], basestring ):
                 # popen("cmd arg1 arg2...")
-                cmd = [ args[ 0 ] ] if shell else args[ 0 ].split()
+                cmd = args[ 0 ].split()
             else:
                 raise Exception( 'popen() requires a string or list' )
         elif len( args ) > 0:
             # popen( cmd, arg1, arg2... )
             cmd = list( args )
-        if shell:
-            cmd = [ os.environ[ 'SHELL' ], '-c' ] + [ ' '.join( cmd ) ]
         # Attach to our namespace  using mnexec -a
         cmd = defaults.pop( 'mncmd' ) + cmd
+        # Shell requires a string, not a list!
+        if defaults.get( 'shell', False ):
+            cmd = ' '.join( cmd )
         popen = self._popen( cmd, **defaults )
         return popen
 
@@ -416,7 +393,7 @@ class Node( object ):
         # Warning: this can fail with large numbers of fds!
         out, err = popen.communicate()
         exitcode = popen.wait()
-        return decode( out ), decode( err ), exitcode
+        return out, err, exitcode
 
     # Interface management, configuration, and routing
 
@@ -449,15 +426,6 @@ class Node( object ):
             debug( 'moving', intf, 'into namespace for', self.name, '\n' )
             moveIntfFn( intf.name, self  )
 
-    def delIntf( self, intf ):
-        """Remove interface from Node's known interfaces
-           Note: to fully delete interface, call intf.delete() instead"""
-        port = self.ports.get( intf )
-        if port is not None:
-            del self.intfs[ port ]
-            del self.ports[ intf ]
-            del self.nameToIntf[ intf.name ]
-
     def defaultIntf( self ):
         "Return interface for lowest port"
         ports = self.intfs.keys()
@@ -478,7 +446,7 @@ class Node( object ):
         """
         if not intf:
             return self.defaultIntf()
-        elif isinstance( intf, BaseString):
+        elif isinstance( intf, basestring):
             return self.nameToIntf[ intf ]
         else:
             return intf
@@ -505,7 +473,7 @@ class Node( object ):
         # explicitly so that we won't get errors if we run before they
         # have been removed by the kernel. Unfortunately this is very slow,
         # at least with Linux kernels before 2.6.33
-        for intf in list( self.intfs.values() ):
+        for intf in self.intfs.values():
             # Protect against deleting hardware interfaces
             if ( self.name in intf.name ) or ( not checkName ):
                 intf.delete()
@@ -530,7 +498,7 @@ class Node( object ):
         """Set the default route to go through intf.
            intf: Intf or {dev <intfname> via <gw-ip> ...}"""
         # Note setParam won't call us if intf is none
-        if isinstance( intf, BaseString ) and ' ' in intf:
+        if isinstance( intf, basestring ) and ' ' in intf:
             params = intf
         else:
             params = 'dev %s' % intf
@@ -577,7 +545,7 @@ class Node( object ):
            method: config method name
            param: arg=value (ignore if value=None)
            value may also be list or dict"""
-        name, value = list( param.items() )[ 0 ]
+        name, value = param.items()[ 0 ]
         if value is None:
             return
         f = getattr( self, method, None )
@@ -626,7 +594,7 @@ class Node( object ):
 
     def intfList( self ):
         "List of our interfaces sorted by port number"
-        return [ self.intfs[ p ] for p in sorted( self.intfs.keys() ) ]
+        return [ self.intfs[ p ] for p in sorted( self.intfs.iterkeys() ) ]
 
     def intfNames( self ):
         "The names of our interfaces sorted by port number"
@@ -711,17 +679,15 @@ class CPULimitedHost( Host ):
         "Clean up our cgroup"
         # info( '*** deleting cgroup', self.cgroup, '\n' )
         _out, _err, exitcode = errRun( 'cgdelete -r ' + self.cgroup )
-        # Sometimes cgdelete returns a resource busy error but still
-        # deletes the group; next attempt will give "no such file"
-        return exitcode == 0 or ( 'no such file' in _err.lower() )
+        return exitcode == 0  # success condition
 
     def popen( self, *args, **kwargs ):
         """Return a Popen() object in node's namespace
            args: Popen() args, single list, or string
            kwargs: Popen() keyword args"""
         # Tell mnexec to execute command in our cgroup
-        mncmd = kwargs.pop( 'mncmd', [ 'mnexec', '-g', self.name,
-                                       '-da', str( self.pid ) ] )
+        mncmd = [ 'mnexec', '-g', self.name,
+                  '-da', str( self.pid ) ]
         # if our cgroup is not given any cpu time,
         # we cannot assign the RR Scheduler.
         if self.sched == 'rt':
@@ -735,7 +701,7 @@ class CPULimitedHost( Host ):
     def cleanup( self ):
         "Clean up Node, then clean up our cgroup"
         super( CPULimitedHost, self ).cleanup()
-        retry( retries=3, delaySecs=.1, fn=self.cgroupDel )
+        retry( retries=3, delaySecs=1, fn=self.cgroupDel )
 
     _rtGroupSched = False   # internal class var: Is CONFIG_RT_GROUP_SCHED set?
 
@@ -897,7 +863,7 @@ class Switch( Node ):
         "Return correctly formatted dpid from dpid or switch name (s1 -> 1)"
         if dpid:
             # Remove any colons and make sure it's a good hex number
-            dpid = dpid.replace( ':', '' )
+            dpid = dpid.translate( None, ':' )
             assert len( dpid ) <= self.dpidLen and int( dpid, 16 ) >= 0
         else:
             # Use hex of the first number in the switch name
@@ -905,7 +871,6 @@ class Switch( Node ):
             if nums:
                 dpid = hex( int( nums[ 0 ] ) )[ 2: ]
             else:
-                self.terminate()  # Python 3.6 crash workaround
                 raise Exception( 'Unable to derive default datapath ID - '
                                  'please either specify a dpid or use a '
                                  'canonical switch name such as s23.' )
@@ -936,12 +901,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() )
@@ -1056,7 +1015,7 @@ class OVSSwitch( Switch ):
                   inband=False, protocols=None,
                   reconnectms=1000, stp=False, batch=False, **params ):
         """name: name for switch
-           failMode: controller loss behavior (secure|standalone)
+           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)
@@ -1178,8 +1137,7 @@ class OVSSwitch( Switch ):
         if self.protocols and not self.isOldOVS():
             opts += ' protocols=%s' % self.protocols
         if self.stp and self.failMode == 'standalone':
-            opts += ' stp_enable=true'
-        opts += ' other-config:dp-desc=%s' % self.name
+            opts += ' stp_enable=true' % self
         return opts
 
     def start( self, controllers ):
@@ -1249,7 +1207,7 @@ class OVSSwitch( Switch ):
             run( cmds, shell=True )
         # Reapply link config if necessary...
         for switch in switches:
-            for intf in switch.intfs.values():
+            for intf in switch.intfs.itervalues():
                 if isinstance( intf, TCIntf ):
                     intf.config( **intf.params )
         return switches
@@ -1275,7 +1233,7 @@ class OVSSwitch( Switch ):
         pids = ' '.join( str( switch.pid ) for switch in switches )
         run( 'kill -HUP ' + pids )
         for switch in switches:
-            switch.terminate()
+            switch.shell = None
         return switches
 
 
@@ -1380,7 +1338,7 @@ class Controller( Node ):
 
     def __init__( self, name, inNamespace=False, command='controller',
                   cargs='-v ptcp:%d', cdir=None, ip="127.0.0.1",
-                  port=6653, protocol='tcp', **params ):
+                  port=6633, protocol='tcp', **params ):
         self.command = command
         self.cargs = cargs
         self.cdir = cdir
@@ -1452,16 +1410,15 @@ class Controller( Node ):
 
 class OVSController( Controller ):
     "Open vSwitch controller"
-    def __init__( self, name, **kwargs ):
-        kwargs.setdefault( 'command', self.isAvailable() or
-                           'ovs-controller' )
-        Controller.__init__( self, name, **kwargs )
+    def __init__( self, name, command='ovs-controller', **kwargs ):
+        if quietRun( 'which test-controller' ):
+            command = 'test-controller'
+        Controller.__init__( self, name, command=command, **kwargs )
 
     @classmethod
     def isAvailable( cls ):
         return ( quietRun( 'which ovs-controller' ) or
-                 quietRun( 'which test-controller' ) or
-                 quietRun( 'which ovs-testcontroller' ) ).strip()
+                 quietRun( 'which test-controller' ) )
 
 class NOX( Controller ):
     "Controller to run a NOX application."
@@ -1515,7 +1472,7 @@ class RemoteController( Controller ):
     "Controller running outside of Mininet's control."
 
     def __init__( self, name, ip='127.0.0.1',
-                  port=None, **kwargs):
+                  port=6633, **kwargs):
         """Init.
            name: name to give controller
            ip: the IP address where the remote controller is
@@ -1533,30 +1490,12 @@ class RemoteController( Controller ):
 
     def checkListening( self ):
         "Warn if remote controller is not accessible"
-        if self.port is not None:
-            self.isListening( self.ip, self.port )
-        else:
-            for port in 6653, 6633:
-                if self.isListening( self.ip, port ):
-                    self.port = port
-                    info( "Connecting to remote controller"
-                          " at %s:%d\n" % ( self.ip, self.port ))
-                    break
-
-        if self.port is None:
-            self.port = 6653
-            warn( "Setting remote controller"
-                  " to %s:%d\n" % ( self.ip, self.port ))
-
-    def isListening( self, ip, port ):
-        "Check if a remote controller is listening at a specific ip and port"
-        listening = self.cmd( "echo A | telnet -e A %s %d" % ( ip, port ) )
+        listening = self.cmd( "echo A | telnet -e A %s %d" %
+                              ( self.ip, self.port ) )
         if 'Connected' not in listening:
             warn( "Unable to contact the remote controller"
-                  " at %s:%d\n" % ( ip, port ) )
-            return False
-        else:
-            return True
+                  " at %s:%d\n" % ( self.ip, self.port ) )
+
 
 DefaultControllers = ( Controller, OVSController )
 
@@ -1572,7 +1511,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/nodelib.py

@@ -7,8 +7,8 @@ This contains additional Node types which you may find to be useful.
 from mininet.node import Node, Switch
 from mininet.log import info, warn
 from mininet.moduledeps import pathCheck
-from mininet.util import quietRun
 
+import re
 
 class LinuxBridge( Switch ):
     "Linux Bridge (with optional spanning tree)"
@@ -59,30 +59,23 @@ class LinuxBridge( Switch ):
 
     @classmethod
     def setup( cls ):
-        "Check dependencies and warn about firewalling"
+        "Make sure our class dependencies are available"
         pathCheck( 'brctl', moduleName='bridge-utils' )
-        # Disable Linux bridge firewalling so that traffic can flow!
-        for table in 'arp', 'ip', 'ip6':
-            cmd = 'sysctl net.bridge.bridge-nf-call-%stables' % table
-            out = quietRun( cmd ).strip()
-            if out.endswith( '1' ):
-                warn( 'Warning: Linux bridge may not work with', out, '\n' )
 
 
 class NAT( Node ):
     "NAT: Provides connectivity to external network"
 
-    def __init__( self, name, subnet='10.0/8',
-                  localIntf=None, flush=False, **params):
+    def __init__( self, name, inetIntf=None, subnet='10.0/8',
+                  localIntf=None, **params):
         """Start NAT/forwarding between Mininet and external network
-           subnet: Mininet subnet (default 10.0/8)
-           flush: flush iptables before installing NAT rules"""
+           inetIntf: interface for internet access
+           subnet: Mininet subnet (default 10.0/8)="""
         super( NAT, self ).__init__( name, **params )
 
+        self.inetIntf = inetIntf if inetIntf else self.getGatewayIntf()
         self.subnet = subnet
         self.localIntf = localIntf
-        self.flush = flush
-        self.forwardState = self.cmd( 'sysctl -n net.ipv4.ip_forward' ).strip()
 
     def config( self, **params ):
         """Configure the NAT and iptables"""
@@ -91,25 +84,27 @@ class NAT( Node ):
         if not self.localIntf:
             self.localIntf = self.defaultIntf()
 
-        if self.flush:
-            self.cmd( 'sysctl net.ipv4.ip_forward=0' )
-            self.cmd( 'iptables -F' )
-            self.cmd( 'iptables -t nat -F' )
-            # Create default entries for unmatched traffic
-            self.cmd( 'iptables -P INPUT ACCEPT' )
-            self.cmd( 'iptables -P OUTPUT ACCEPT' )
-            self.cmd( 'iptables -P FORWARD DROP' )
+        self.cmd( 'sysctl net.ipv4.ip_forward=0' )
 
-        # Install NAT rules
+        # Flush any currently active rules
+        # TODO: is this safe?
+        self.cmd( 'iptables -F' )
+        self.cmd( 'iptables -t nat -F' )
+
+        # Create default entries for unmatched traffic
+        self.cmd( 'iptables -P INPUT ACCEPT' )
+        self.cmd( 'iptables -P OUTPUT ACCEPT' )
+        self.cmd( 'iptables -P FORWARD DROP' )
+
+        # Configure NAT
         self.cmd( 'iptables -I FORWARD',
                   '-i', self.localIntf, '-d', self.subnet, '-j DROP' )
         self.cmd( 'iptables -A FORWARD',
                   '-i', self.localIntf, '-s', self.subnet, '-j ACCEPT' )
         self.cmd( 'iptables -A FORWARD',
-                  '-o', self.localIntf, '-d', self.subnet, '-j ACCEPT' )
+                  '-i', self.inetIntf, '-d', self.subnet, '-j ACCEPT' )
         self.cmd( 'iptables -t nat -A POSTROUTING',
-                  '-s', self.subnet, "'!'", '-d', self.subnet,
-                  '-j MASQUERADE' )
+                  '-o', self.inetIntf, '-s', self.subnet, '-j MASQUERADE' )
 
         # Instruct the kernel to perform forwarding
         self.cmd( 'sysctl net.ipv4.ip_forward=1' )
@@ -128,18 +123,26 @@ class NAT( Node ):
         # hopefully this won't disconnect you
         self.cmd( 'service network-manager restart' )
 
+    def getGatewayIntf( self, fallback='eth0' ):
+        """Return gateway interface name
+           fallback: default device to fall back to"""
+        routes = self.cmd( 'ip route show' )
+        match = re.search( r'default via \S+ dev (\S+)', routes )
+        if match:
+            return match.group( 1 )
+        else:
+            warn( 'There is no default route set.',
+                  'Using', fallback, 'as gateway interface...\n' )
+            return fallback
+
     def terminate( self ):
-        "Stop NAT/forwarding between Mininet and external network"
-        # Remote NAT rules
-        self.cmd( 'iptables -D FORWARD',
-                   '-i', self.localIntf, '-d', self.subnet, '-j DROP' )
-        self.cmd( 'iptables -D FORWARD',
-                  '-i', self.localIntf, '-s', self.subnet, '-j ACCEPT' )
-        self.cmd( 'iptables -D FORWARD',
-                  '-o', self.localIntf, '-d', self.subnet, '-j ACCEPT' )
-        self.cmd( 'iptables -t nat -D POSTROUTING',
-                  '-s', self.subnet, '\'!\'', '-d', self.subnet,
-                  '-j MASQUERADE' )
-        # Put the forwarding state back to what it was
-        self.cmd( 'sysctl net.ipv4.ip_forward=%s' % self.forwardState )
+        """Stop NAT/forwarding between Mininet and external network"""
+        # Flush any currently active rules
+        # TODO: is this safe?
+        self.cmd( 'iptables -F' )
+        self.cmd( 'iptables -t nat -F' )
+
+        # Instruct the kernel to stop forwarding
+        self.cmd( 'sysctl net.ipv4.ip_forward=0' )
+
         super( NAT, self ).terminate()

mininet/test/runner.py

@@ -21,9 +21,7 @@ def runTests( testDir, verbosity=1 ):
     # discover all tests in testDir
     testSuite = defaultTestLoader.discover( testDir )
     # run tests
-    success = ( TextTestRunner( verbosity=verbosity )
-                .run( testSuite ).wasSuccessful() )
-    sys.exit( 0 if success else 1 )
+    TextTestRunner( verbosity=verbosity ).run( testSuite )
 
 if __name__ == '__main__':
     setLogLevel( 'warning' )

mininet/test/test_ptyleak.py

@@ -1,31 +0,0 @@
-#!/usr/bin/env python
-
-"""
-Regression test for pty leak in Node()
-"""
-
-import unittest
-
-from mininet.net import Mininet
-from mininet.clean import cleanup
-from mininet.topo import SingleSwitchTopo
-
-class TestPtyLeak( unittest.TestCase ):
-    "Verify that there is no pty leakage"
-
-    @staticmethod
-    def testPtyLeak():
-        "Test for pty leakage"
-        net = Mininet( SingleSwitchTopo() )
-        net.start()
-        host = net[ 'h1' ]
-        for _ in range( 0, 10 ):
-            oldptys = host.slave, host.master
-            net.delHost( host )
-            host = net.addHost( 'h1' )
-            assert ( host.slave, host.master ) == oldptys
-        net.stop()
-
-if __name__ == '__main__':
-    unittest.main()
-    cleanup()

mininet/test/test_switchdpidassignment.py

@@ -30,10 +30,10 @@ class TestSwitchDpidAssignmentOVS( unittest.TestCase ):
     def testDefaultDpid( self ):
         """Verify that the default dpid is assigned using a valid provided
         canonical switchname if no dpid is passed in switch creation."""
-        net = Mininet( Topo(), self.switchClass, Host, Controller )
-        switch = net.addSwitch( 's1' )
+        switch = Mininet( Topo(),
+                          self.switchClass,
+                          Host, Controller ).addSwitch( 's1' )
         self.assertEqual( switch.defaultDpid(), switch.dpid )
-        net.stop()
 
     def dpidFrom( self, num ):
         "Compute default dpid from number"
@@ -44,34 +44,31 @@ class TestSwitchDpidAssignmentOVS( unittest.TestCase ):
         """Verify that Switch dpid is the actual dpid assigned if dpid is
         passed in switch creation."""
         dpid = self.dpidFrom( 0xABCD )
-        net = Mininet( Topo(), self.switchClass, Host, Controller )
-        switch = net.addSwitch( 's1', dpid=dpid )
+        switch = Mininet( Topo(), self.switchClass,
+                          Host, Controller ).addSwitch(
+                            's1', dpid=dpid )
         self.assertEqual( switch.dpid, dpid )
-        net.stop()
 
     def testDefaultDpidAssignmentFailure( self ):
         """Verify that Default dpid assignment raises an Exception if the
         name of the switch does not contin a digit. Also verify the
         exception message."""
-        net = Mininet( Topo(), self.switchClass, Host, Controller )
         with self.assertRaises( Exception ) as raises_cm:
-            net.addSwitch( 'A' )
-        self.assertTrue( 'Unable to derive '
+            Mininet( Topo(), self.switchClass,
+                     Host, Controller ).addSwitch( 'A' )
+        self.assertEqual(raises_cm.exception.message, 'Unable to derive '
                          'default datapath ID - please either specify a dpid '
-                         'or use a canonical switch name such as s23.'
-                         in str( raises_cm.exception ) )
-        net.stop()
+                         'or use a canonical switch name such as s23.')
 
     def testDefaultDpidLen( self ):
         """Verify that Default dpid length is 16 characters consisting of
         16 - len(hex of first string of contiguous digits passed in switch
         name) 0's followed by hex of first string of contiguous digits passed
         in switch name."""
-        net = Mininet( Topo(), self.switchClass, Host, Controller )
-        switch = net.addSwitch( 's123' )
-        self.assertEqual( switch.dpid, self.dpidFrom( 123 ) )
-        net.stop()
+        switch = Mininet( Topo(), self.switchClass,
+                          Host, Controller ).addSwitch( 's123' )
 
+        self.assertEqual( switch.dpid, self.dpidFrom( 123 ) )
 
 class OVSUser( OVSSwitch):
     "OVS User Switch convenience class"
@@ -98,4 +95,3 @@ class testSwitchUserspace( TestSwitchDpidAssignmentOVS ):
 if __name__ == '__main__':
     setLogLevel( 'warning' )
     unittest.main()
-    cleanup()

mininet/test/test_walkthrough.py

@@ -7,18 +7,17 @@ TODO: missing xterm test
 """
 
 import unittest
+import pexpect
 import os
 import re
-from mininet.util import quietRun, pexpect
+from mininet.util import quietRun
 from distutils.version import StrictVersion
-from time import sleep
-
 
 def tsharkVersion():
     "Return tshark version"
     versionStr = quietRun( 'tshark -v' )
-    versionMatch = re.findall( r'TShark[^\d]*(\d+.\d+.\d+)', versionStr )
-    return versionMatch[ 0 ]
+    versionMatch = re.findall( r'TShark \d+.\d+.\d+', versionStr )[0]
+    return versionMatch.split()[ 1 ]
 
 # pylint doesn't understand pexpect.match, unfortunately!
 # pylint:disable=maybe-no-member
@@ -48,8 +47,6 @@ class testWalkthrough( unittest.TestCase ):
         mn.expect( '0% dropped' )
         tshark.expect( [ '74 Hello', '74 of_hello', '74 Type: OFPT_HELLO' ] )
         tshark.sendintr()
-        mn.expect( pexpect.EOF )
-        tshark.expect( pexpect.EOF )
 
     def testBasic( self ):
         "Test basic CLI commands (help, nodes, net, dump)"
@@ -94,10 +91,7 @@ class testWalkthrough( unittest.TestCase ):
         "Test ifconfig and ps on h1 and s1"
         p = pexpect.spawn( 'mn' )
         p.expect( self.prompt )
-        # Third pattern is a local interface beginning with 'eth' or 'en'
-        interfaces = [ r'h1-eth0[:\s]', r's1-eth1[:\s]',
-                       r'[^-](eth|en)\w*\d[:\s]', r'lo[:\s]',
-                       self.prompt ]
+        interfaces = [ 'h1-eth0', 's1-eth1', '[^-]eth0', 'lo', self.prompt ]
         # h1 ifconfig
         p.sendline( 'h1 ifconfig -a' )
         ifcount = 0
@@ -123,7 +117,7 @@ class testWalkthrough( unittest.TestCase ):
                 ifcount += 1
             else:
                 break
-        self.assertTrue( ifcount <= 3, 'Missing interfaces on s1')
+        self.assertEqual( ifcount, 3, 'Missing interfaces on s1')
         # h1 ps
         p.sendline( "h1 ps -a | egrep -v 'ps|grep'" )
         p.expect( self.prompt )
@@ -132,13 +126,10 @@ class testWalkthrough( unittest.TestCase ):
         p.sendline( "s1 ps -a | egrep -v 'ps|grep'" )
         p.expect( self.prompt )
         s1Output = p.before
-        # strip command from ps output and compute diffs
-        h1Output = h1Output.split( '\n' )[ 1: ]
-        s1Output = s1Output.split( '\n' )[ 1: ]
-        diffs = set( h1Output ).difference( set( s1Output ) )
-        # allow up to two diffs to account for daemons, etc.
-        self.assertTrue( len( diffs ) <= 2,
-                         'h1 and s1 "ps" output differ too much: %s' % diffs )
+        # strip command from ps output
+        h1Output = h1Output.split( '\n', 1 )[ 1 ]
+        s1Output = s1Output.split( '\n', 1 )[ 1 ]
+        self.assertEqual( h1Output, s1Output, 'h1 and s1 "ps" output differs')
         p.sendline( 'exit' )
         p.wait()
 
@@ -157,18 +148,9 @@ class testWalkthrough( unittest.TestCase ):
 
     def testSimpleHTTP( self ):
         "Start an HTTP server on h1 and wget from h2"
-        if 'Python 2' in quietRun( 'python --version' ):
-            httpserver = 'SimpleHTTPServer'
-        else:
-            httpserver = 'http.server'
         p = pexpect.spawn( 'mn' )
         p.expect( self.prompt )
-        p.sendline( 'h1 python -m %s 80 &' % httpserver )
-        # The walkthrough doesn't specify a delay here, and
-        # we also don't read the output (also a possible problem),
-        # but for now let's wait a couple of seconds to make
-        # it less likely to fail due to the race condition.
-        sleep( 2 )
+        p.sendline( 'h1 python -m SimpleHTTPServer 80 &' )
         p.expect( self.prompt )
         p.sendline( ' h2 wget -O - h1' )
         p.expect( '200 OK' )
@@ -219,16 +201,16 @@ class testWalkthrough( unittest.TestCase ):
         p.sendline( 'iperf' )
         p.expect( r"Results: \['([\d\.]+) Mbits/sec'," )
         bw = float( p.match.group( 1 ) )
-        self.assertTrue( bw < 10.1, 'Bandwidth %.2f >= 10.1 Mb/s' % bw )
-        self.assertTrue( bw > 9.0, 'Bandwidth %.2f <= 9 Mb/s' % bw )
+        self.assertTrue( bw < 10.1, 'Bandwidth > 10 Mb/s')
+        self.assertTrue( bw > 9.0, 'Bandwidth < 9 Mb/s')
         p.expect( self.prompt )
         # test delay
         p.sendline( 'h1 ping -c 4 h2' )
         p.expect( r'rtt min/avg/max/mdev = '
                   r'([\d\.]+)/([\d\.]+)/([\d\.]+)/([\d\.]+) ms' )
         delay = float( p.match.group( 2 ) )
-        self.assertTrue( delay >= 40, 'Delay < 40ms' )
-        self.assertTrue( delay <= 50, 'Delay > 50ms' )
+        self.assertTrue( delay > 40, 'Delay < 40ms' )
+        self.assertTrue( delay < 45, 'Delay > 40ms' )
         p.expect( self.prompt )
         p.sendline( 'exit' )
         p.wait()
@@ -265,10 +247,8 @@ class testWalkthrough( unittest.TestCase ):
         p.expect( self.prompt )
         for i in range( 1, 3 ):
             p.sendline( 'h%d ifconfig' % i )
-            p.expect( r'\s00:00:00:00:00:0%d\s' % i )
+            p.expect( 'HWaddr 00:00:00:00:00:0%d' % i )
             p.expect( self.prompt )
-        p.sendline( 'exit' )
-        p.expect( pexpect.EOF )
 
     def testSwitches( self ):
         "Run iperf test using user and ovsk switches"
@@ -291,9 +271,7 @@ class testWalkthrough( unittest.TestCase ):
         "Test running user switch in its own namespace"
         p = pexpect.spawn( 'mn --innamespace --switch user' )
         p.expect( self.prompt )
-        interfaces = [ r'h1-eth0[:\s]', r's1-eth1[:\s]',
-                       r'[^-](eth|en)\w*\d[:\s]', r'lo[:\s]',
-                       self.prompt ]
+        interfaces = [ 'h1-eth0', 's1-eth1', '[^-]eth0', 'lo', self.prompt ]
         p.sendline( 's1 ifconfig -a' )
         ifcount = 0
         while True:

mininet/topo.py

@@ -56,13 +56,13 @@ class MultiGraph( object ):
         return self.node.items() if data else self.node.keys()
 
     def edges_iter( self, data=False, keys=False ):
-        "Iterator: return graph edges, optionally with data and keys"
-        for src, entry in self.edge.items():
-            for dst, entrykeys in entry.items():
+        "Iterator: return graph edges"
+        for src, entry in self.edge.iteritems():
+            for dst, keys in entry.iteritems():
                 if src > dst:
                     # Skip duplicate edges
                     continue
-                for k, attrs in entrykeys.items():
+                for k, attrs in keys.iteritems():
                     if data:
                         if keys:
                             yield( src, dst, k, attrs )
@@ -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/topolib.py

@@ -45,18 +45,10 @@ class TorusTopo( Topo ):
        without STP turned on! It can be used with STP, e.g.:
        # mn --topo torus,3,3 --switch lxbr,stp=1 --test pingall"""
 
-    def build( self, x, y, n=1 ):
-        """x: dimension of torus in x-direction
-           y: dimension of torus in y-direction
-           n: number of hosts per switch"""
+    def build( self, x, y ):
         if x < 3 or y < 3:
             raise Exception( 'Please use 3x3 or greater for compatibility '
                              'with 2.1' )
-        if n == 1:
-            genHostName = lambda loc, k: 'h%s' % ( loc )
-        else:
-            genHostName = lambda loc, k: 'h%sx%d' % ( loc, k )
-
         hosts, switches, dpid = {}, {}, 0
         # Create and wire interior
         for i in range( 0, x ):
@@ -65,11 +57,9 @@ class TorusTopo( Topo ):
                 # dpid cannot be zero for OVS
                 dpid = ( i + 1 ) * 256 + ( j + 1 )
                 switch = switches[ i, j ] = self.addSwitch(
-                    's' + loc, dpid='%x' % dpid )
-                for k in range( 0, n ):
-                    host = hosts[ i, j, k ] = self.addHost(
-                        genHostName( loc, k + 1 ) )
-                    self.addLink( host, switch )
+                    's' + loc, dpid='%016x' % dpid )
+                host = hosts[ i, j ] = self.addHost( 'h' + loc )
+                self.addLink( host, switch )
         # Connect switches
         for i in range( 0, x ):
             for j in range( 0, y ):

mininet/util.py

@@ -1,6 +1,5 @@
 "Utility functions for Mininet."
 
-
 from mininet.log import output, info, error, warn, debug
 
 from time import sleep
@@ -12,39 +11,6 @@ from fcntl import fcntl, F_GETFL, F_SETFL
 from os import O_NONBLOCK
 import os
 from functools import partial
-import sys
-
-# Python 2/3 compatibility
-Python3 = sys.version_info[0] == 3
-BaseString = str if Python3 else getattr( str, '__base__' )
-Encoding = 'utf-8' if Python3 else None
-def decode( s ):
-    "Decode a byte string if needed for Python 3"
-    return s.decode( Encoding ) if Python3 else s
-def encode( s ):
-    "Encode a byte string if needed for Python 3"
-    return s.encode( Encoding ) if Python3 else s
-try:
-    # pylint: disable=import-error
-    oldpexpect = None
-    import pexpect as oldpexpect
-    # pylint: enable=import-error
-
-    class Pexpect( object ):
-        "Custom pexpect that is compatible with str"
-        @staticmethod
-        def spawn( *args, **kwargs):
-            "pexpect.spawn that is compatible with str"
-            if Python3 and 'encoding' not in kwargs:
-                kwargs.update( encoding='utf-8'  )
-            return oldpexpect.spawn( *args, **kwargs )
-
-        def __getattr__( self, name ):
-            return getattr( oldpexpect, name )
-    pexpect = Pexpect()
-except ImportError:
-    pass
-
 
 # Command execution support
 
@@ -66,7 +32,7 @@ def oldQuietRun( *cmd ):
        cmd: list of command params"""
     if len( cmd ) == 1:
         cmd = cmd[ 0 ]
-        if isinstance( cmd, BaseString ):
+        if isinstance( cmd, str ):
             cmd = cmd.split( ' ' )
     popen = Popen( cmd, stdout=PIPE, stderr=STDOUT )
     # We can't use Popen.communicate() because it uses
@@ -90,7 +56,7 @@ 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,too-many-statements
+# 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
@@ -107,7 +73,7 @@ def errRun( *cmd, **kwargs ):
     if len( cmd ) == 1:
         cmd = cmd[ 0 ]
     # Allow passing in a list or a string
-    if isinstance( cmd, BaseString ) and not shell:
+    if isinstance( cmd, str ) and not shell:
         cmd = cmd.split( ' ' )
         cmd = [ str( arg ) for arg in cmd ]
     elif isinstance( cmd, list ) and shell:
@@ -131,8 +97,6 @@ def errRun( *cmd, **kwargs ):
             f = fdtofile[ fd ]
             if event & POLLIN:
                 data = f.read( 1024 )
-                if Python3:
-                    data = data.decode( Encoding )
                 if echo:
                     output( data )
                 if f == popen.stdout:
@@ -151,10 +115,6 @@ def errRun( *cmd, **kwargs ):
                 poller.unregister( fd )
 
     returncode = popen.wait()
-    # Python 3 complains if we don't explicitly close these
-    popen.stdout.close()
-    if stderr == PIPE:
-        popen.stderr.close()
     debug( out, err, returncode )
     return out, err, returncode
 # pylint: enable=too-many-branches
@@ -360,7 +320,7 @@ def ipParse( ip ):
     "Parse an IP address and return an unsigned int."
     args = [ int( arg ) for arg in ip.split( '.' ) ]
     while len(args) < 4:
-        args.insert( len(args) - 1, 0 )
+        args.append( 0 )
     return ipNum( *args )
 
 def netParse( ipstr ):
@@ -413,30 +373,30 @@ def pmonitor(popens, timeoutms=500, readline=True,
        terminates: when all EOFs received"""
     poller = poll()
     fdToHost = {}
-    for host, popen in popens.items():
+    for host, popen in popens.iteritems():
         fd = popen.stdout.fileno()
         fdToHost[ fd ] = host
-        poller.register( fd, POLLIN | POLLHUP )
-        flags = fcntl( fd, F_GETFL )
-        fcntl( fd, F_SETFL, flags | O_NONBLOCK )
+        poller.register( fd, POLLIN )
+        if not readline:
+            # Use non-blocking reads
+            flags = fcntl( fd, F_GETFL )
+            fcntl( fd, F_SETFL, flags | O_NONBLOCK )
     while popens:
         fds = poller.poll( timeoutms )
         if fds:
             for fd, event in fds:
                 host = fdToHost[ fd ]
                 popen = popens[ host ]
-                if event & POLLIN or event & POLLHUP:
-                    while True:
-                        try:
-                            f = popen.stdout
-                            line = decode( f.readline() if readline
-                                           else f.read( readmax ) )
-                        except IOError:
-                            line = ''
-                        if line == '':
-                            break
-                        yield host, line
-                if event & POLLHUP:
+                if event & POLLIN:
+                    if readline:
+                        # Attempt to read a line of output
+                        # This blocks until we receive a newline!
+                        line = popen.stdout.readline()
+                    else:
+                        line = popen.stdout.read( readmax )
+                    yield host, line
+                # Check for EOF
+                elif event & POLLHUP:
                     poller.unregister( fd )
                     del popens[ host ]
         else:
@@ -499,7 +459,7 @@ def fixLimits():
 
 def mountCgroups():
     "Make sure cgroups file system is mounted"
-    mounts = quietRun( 'grep cgroup /proc/mounts' )
+    mounts = quietRun( 'cat /proc/mounts' )
     cgdir = '/sys/fs/cgroup'
     csdir = cgdir + '/cpuset'
     if ('cgroup %s' % cgdir not in mounts and
@@ -627,7 +587,7 @@ def ensureRoot():
     Probably we should only sudo when needed as per Big Switch's patch.
     """
     if os.getuid() != 0:
-        error( '*** Mininet must run as root.\n' )
+        print "*** Mininet must run as root."
         exit( 1 )
     return
 
@@ -639,7 +599,7 @@ def waitListening( client=None, server='127.0.0.1', port=80, timeout=None ):
     if not runCmd( 'which telnet' ):
         raise Exception('Could not find telnet' )
     # pylint: disable=maybe-no-member
-    serverIP = server if isinstance( server, BaseString ) else server.IP()
+    serverIP = server if isinstance( server, basestring ) else server.IP()
     cmd = ( 'echo A | telnet -e A %s %s' % ( serverIP, port ) )
     time = 0
     result = runCmd( cmd )

mnexec.c

@@ -130,16 +130,6 @@ int main(int argc, char *argv[])
                 perror("unshare");
                 return 1;
             }
-
-            /* Mark our whole hierarchy recursively as private, so that our
-             * mounts do not propagate to other processes.
-             */
-
-            if (mount("none", "/", NULL, MS_REC|MS_PRIVATE, NULL) == -1) {
-                perror("remount");
-                return 1;
-            }
-
             /* mount sysfs to pick up the new network namespace */
             if (mount("sysfs", "/sys", "sysfs", MS_MGC_VAL, NULL) == -1) {
                 perror("mount");

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

@@ -13,7 +13,7 @@ set -o nounset
 MININET_DIR="$( cd -P "$( dirname "${BASH_SOURCE[0]}" )/../.." && pwd -P )"
 
 # Set up build directory, which by default is the working directory
-#  unless the working directory is a subdirectory of mininet,
+#  unless the working directory is a subdirectory of mininet, 
 #  in which case we use the directory containing mininet
 BUILD_DIR="$(pwd -P)"
 case $BUILD_DIR in
@@ -36,38 +36,24 @@ if [ "$ARCH" = "i686" ]; then ARCH="i386"; fi
 test -e /etc/debian_version && DIST="Debian"
 grep Ubuntu /etc/lsb-release &> /dev/null && DIST="Ubuntu"
 if [ "$DIST" = "Ubuntu" ] || [ "$DIST" = "Debian" ]; then
-    # Truly non-interactive apt-get installation
-    install='sudo DEBIAN_FRONTEND=noninteractive apt-get -y -q install'
-    remove='sudo DEBIAN_FRONTEND=noninteractive apt-get -y -q remove'
+    install='sudo apt-get -y install'
+    remove='sudo apt-get -y remove'
     pkginst='sudo dpkg -i'
-    update='sudo apt-get'
     # Prereqs for this script
     if ! which lsb_release &> /dev/null; then
         $install lsb-release
     fi
 fi
 test -e /etc/fedora-release && DIST="Fedora"
-test -e /etc/redhat-release && DIST="RedHatEnterpriseServer"
-if [ "$DIST" = "Fedora" -o "$DIST" = "RedHatEnterpriseServer" ]; then
+if [ "$DIST" = "Fedora" ]; then
     install='sudo yum -y install'
     remove='sudo yum -y erase'
     pkginst='sudo rpm -ivh'
-    update='sudo yum'
     # Prereqs for this script
     if ! which lsb_release &> /dev/null; then
         $install redhat-lsb-core
     fi
 fi
-test -e /etc/SuSE-release && DIST="SUSE Linux"
-if [ "$DIST" = "SUSE Linux" ]; then
-    install='sudo zypper --non-interactive install '
-    remove='sudo zypper --non-interactive  remove '
-    pkginst='sudo rpm -ivh'
-    # Prereqs for this script
-    if ! which lsb_release &> /dev/null; then
-		$install openSUSE-release
-    fi
-fi
 if which lsb_release &> /dev/null; then
     DIST=`lsb_release -is`
     RELEASE=`lsb_release -rs`
@@ -80,12 +66,8 @@ echo "Detected Linux distribution: $DIST $RELEASE $CODENAME $ARCH"
 KERNEL_NAME=`uname -r`
 KERNEL_HEADERS=kernel-headers-${KERNEL_NAME}
 
-# Treat Raspbian as Debian
-[ "$DIST" = 'Raspbian' ] && DIST='Debian'
-
-DISTS='Ubuntu|Debian|Fedora|RedHatEnterpriseServer|SUSE LINUX'
-if ! echo $DIST | egrep "$DISTS" >/dev/null; then
-    echo "Install.sh currently only supports $DISTS."
+if ! echo $DIST | egrep 'Ubuntu|Debian|Fedora'; then
+    echo "Install.sh currently only supports Ubuntu, Debian and Fedora."
     exit 1
 fi
 
@@ -102,14 +84,6 @@ function version_ge {
     [ "$1" == "$latest" ]
 }
 
-# Attempt to identify Python version
-PYTHON=${PYTHON:-python}
-if $PYTHON --version |& grep 'Python 2' > /dev/null; then
-    PYTHON_VERSION=2; PYPKG=python
-else
-    PYTHON_VERSION=3; PYPKG=python3
-fi
-echo "${PYTHON} is version ${PYTHON_VERSION}"
 
 # Kernel Deb pkg to be removed:
 KERNEL_IMAGE_OLD=linux-image-2.6.26-33-generic
@@ -127,7 +101,7 @@ OF13_SWITCH_REV=${OF13_SWITCH_REV:-""}
 
 function kernel {
     echo "Install Mininet-compatible kernel if necessary"
-    $update update
+    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."
@@ -149,25 +123,19 @@ function kernel_clean {
 # Install Mininet deps
 function mn_deps {
     echo "Installing Mininet dependencies"
-    if [ "$DIST" = "Fedora" -o "$DIST" = "RedHatEnterpriseServer" ]; then
+    if [ "$DIST" = "Fedora" ]; then
         $install gcc make socat psmisc xterm openssh-clients iperf \
             iproute telnet python-setuptools libcgroup-tools \
-            ethtool help2man pyflakes pylint python-pep8 python-pexpect
-    elif [ "$DIST" = "SUSE LINUX"  ]; then
-		$install gcc make socat psmisc xterm openssh iperf \
-			iproute telnet ${PYPKG}-setuptools libcgroup-tools \
-			ethtool help2man python-pyflakes python3-pylint \
-                        python-pep8 ${PYPKG}-pexpect ${PYPKG}-tk
-    else  # Debian/Ubuntu
-        $install gcc make socat psmisc xterm ssh iperf telnet \
-                 cgroup-bin ethtool help2man pyflakes pylint pep8 \
-                 ${PYPKG}-setuptools ${PYPKG}-pexpect ${PYPKG}-tk
-        $install iproute2 || $install iproute
+            ethtool help2man pyflakes pylint python-pep8
+    else
+        $install gcc make socat psmisc xterm ssh iperf iproute telnet \
+            python-setuptools cgroup-bin ethtool help2man \
+            pyflakes pylint pep8
     fi
 
     echo "Installing Mininet core"
     pushd $MININET_DIR/mininet
-    sudo PYTHON=${PYTHON} make install
+    sudo make install
     popd
 }
 
@@ -188,16 +156,12 @@ function of {
     echo "Installing OpenFlow reference implementation..."
     cd $BUILD_DIR
     $install autoconf automake libtool make gcc
-    if [ "$DIST" = "Fedora" -o "$DIST" = "RedHatEnterpriseServer" ]; then
+    if [ "$DIST" = "Fedora" ]; then
         $install git pkgconfig glibc-devel
-	elif [ "$DIST" = "SUSE LINUX"  ]; then
-       $install git pkgconfig glibc-devel
     else
         $install git-core autotools-dev pkg-config libc6-dev
     fi
-    # was: git clone git://openflowswitch.org/openflow.git
-    # Use our own fork on github for now:
-    git clone git://github.com/mininet/openflow
+    git clone git://openflowswitch.org/openflow.git
     cd $BUILD_DIR/openflow
 
     # Patch controller to handle more than 16 switches
@@ -214,14 +178,10 @@ function of {
 function of13 {
     echo "Installing OpenFlow 1.3 soft switch implementation..."
     cd $BUILD_DIR/
-    $install git-core autoconf automake autotools-dev pkg-config \
-        make gcc g++ libtool libc6-dev cmake libpcap-dev  \
+    $install  git-core autoconf automake autotools-dev pkg-config \
+        make gcc g++ libtool libc6-dev cmake libpcap-dev libxerces-c2-dev  \
         unzip libpcre3-dev flex bison libboost-dev
-    if [ "$DIST" = "Ubuntu" ] && version_le $RELEASE 16.04; then
-        $install libxerces-c2-dev
-    else
-        $install libxerces-c-dev
-    fi
+
     if [ ! -d "ofsoftswitch13" ]; then
         git clone https://github.com/CPqD/ofsoftswitch13.git
         if [[ -n "$OF13_SWITCH_REV" ]]; then
@@ -232,17 +192,17 @@ function of13 {
     fi
 
     # Install netbee
-    if [ ! -d "netbee" ]; then
-        git clone https://github.com/netgroup-polito/netbee.git
-    fi
-    cd netbee/src
+    NBEESRC="nbeesrc-jan-10-2013"
+    NBEEURL=${NBEEURL:-http://www.nbee.org/download/}
+    wget -nc ${NBEEURL}${NBEESRC}.zip
+    unzip ${NBEESRC}.zip
+    cd ${NBEESRC}/src
     cmake .
     make
-
-    cd $BUILD_DIR
-    sudo cp netbee/bin/libn*.so /usr/local/lib
+    cd $BUILD_DIR/
+    sudo cp ${NBEESRC}/bin/libn*.so /usr/local/lib
     sudo ldconfig
-    sudo cp -R netbee/include/ /usr/
+    sudo cp -R ${NBEESRC}/include/ /usr/
 
     # Resume the install:
     cd $BUILD_DIR/ofsoftswitch13
@@ -257,10 +217,8 @@ function of13 {
 function install_wireshark {
     if ! which wireshark; then
         echo "Installing Wireshark"
-        if [ "$DIST" = "Fedora" -o "$DIST" = "RedHatEnterpriseServer" ]; then
+        if [ "$DIST" = "Fedora" ]; then
             $install wireshark wireshark-gnome
-		elif [ "$DIST" = "SUSE LINUX"  ]; then
-			$install wireshark
         else
             $install wireshark tshark
         fi
@@ -332,36 +290,30 @@ function ubuntuOvs {
     fi
 
     # Remove any old packages
-
-    $remove openvswitch-common openvswitch-datapath-dkms openvswitch-pki openvswitch-switch \
-            openvswitch-controller || true
+    $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 dh-python dh-autoreconf \
-             uuid-runtime
+             python-zopeinterface python-twisted-conch dkms
 
     # Build OVS
-    parallel=`grep processor /proc/cpuinfo | wc -l`
     cd $BUILD_DIR/openvswitch/openvswitch-$OVS_RELEASE
-            DEB_BUILD_OPTIONS='parallel=$parallel nocheck' fakeroot debian/rules binary
+            DEB_BUILD_OPTIONS='parallel=2 nocheck' fakeroot debian/rules binary
     cd ..
-    for pkg in common datapath-dkms pki switch; do
-        pkg=openvswitch-${pkg}_$OVS_RELEASE*.deb
-        echo "Installing $pkg"
-        $pkginst $pkg
-    done
-    if $pkginst openvswitch-controller_$OVS_RELEASE*.deb 2>/dev/null; then
+    $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
 
-    /sbin/modinfo openvswitch
+    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 2>/dev/null; then
+    if sudo service openvswitch-controller stop; then
         echo "Stopped running controller"
     fi
     if [ -e /etc/init.d/openvswitch-controller ]; then
@@ -375,7 +327,7 @@ function ubuntuOvs {
 function ovs {
     echo "Installing Open vSwitch..."
 
-    if [ "$DIST" = "Fedora" -o "$DIST" = "RedHatEnterpriseServer" ]; then
+    if [ "$DIST" == "Fedora" ]; then
         $install openvswitch openvswitch-controller
         return
     fi
@@ -394,28 +346,23 @@ function ovs {
     fi
 
     $install openvswitch-switch
-    OVSC=""
     if $install openvswitch-controller; then
-        OVSC="openvswitch-controller"
-    else
-        echo "Attempting to install openvswitch-testcontroller"
-        if $install openvswitch-testcontroller; then
-            OVSC="openvswitch-testcontroller"
-        else
-            echo "Failed - skipping openvswitch-testcontroller"
-        fi
-    fi
-    if [ "$OVSC" ]; then
         # 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 $OVSC stop; then
+        if sudo service openvswitch-controller stop; then
             echo "Stopped running controller"
         fi
-        if [ -e /etc/init.d/$OVSC ]; then
-            sudo update-rc.d $OVSC disable
+        if [ -e /etc/init.d/openvswitch-controller ]; then
+            sudo update-rc.d openvswitch-controller disable
+        fi
+    else
+        echo "Attempting to install openvswitch-testcontroller"
+        if ! $install openvswitch-testcontroller; then
+            echo "Failed - skipping openvswitch-testcontroller"
         fi
     fi
+
 }
 
 function remove_ovs {
@@ -445,19 +392,12 @@ function ivs {
     IVS_SRC=$BUILD_DIR/ivs
 
     # Install dependencies
-    $install gcc make
-    if [ "$DIST" = "Fedora" -o "$DIST" = "RedHatEnterpriseServer" ]; then
-        $install git pkgconfig libnl3-devel libcap-devel openssl-devel
-    else
-        $install git-core pkg-config libnl-3-dev libnl-route-3-dev \
-            libnl-genl-3-dev
-    fi
+    $install git pkg-config gcc make libnl-3-dev libnl-route-3-dev libnl-genl-3-dev
 
     # Install IVS from source
     cd $BUILD_DIR
-    git clone git://github.com/floodlight/ivs $IVS_SRC
+    git clone git://github.com/floodlight/ivs $IVS_SRC --recursive
     cd $IVS_SRC
-    git submodule update --init
     make
     sudo make install
 }
@@ -468,20 +408,27 @@ function ryu {
 
     # install Ryu dependencies"
     $install autoconf automake g++ libtool python make
-    if [ "$DIST" = "Ubuntu" -o "$DIST" = "Debian" ]; then
-        $install gcc python-pip python-dev libffi-dev libssl-dev \
-            libxml2-dev libxslt1-dev zlib1g-dev
+    if [ "$DIST" = "Ubuntu" ]; then
+        $install libxml2 libxslt-dev python-pip python-dev
+        sudo pip install gevent
+    elif [ "$DIST" = "Debian" ]; then
+        $install libxml2 libxslt-dev python-pip python-dev
+        sudo pip install gevent
     fi
 
+    # if needed, update python-six
+    SIX_VER=`pip show six | grep Version | awk '{print $2}'`
+    if version_ge 1.7.0 $SIX_VER; then
+        echo "Installing python-six version 1.7.0..."
+        sudo pip install -I six==1.7.0
+    fi
     # fetch RYU
     cd $BUILD_DIR/
     git clone git://github.com/osrg/ryu.git ryu
     cd ryu
 
     # install ryu
-    sudo pip install -r tools/pip-requires -r tools/optional-requires \
-        -r tools/test-requires
-    sudo python setup.py install
+    sudo python ./setup.py install
 
     # Add symbolic link to /usr/bin
     sudo ln -s ./bin/ryu-manager /usr/local/bin/ryu-manager
@@ -592,17 +539,13 @@ function oftest {
 function cbench {
     echo "Installing cbench..."
 
-    if [ "$DIST" = "Fedora" -o "$DIST" = "RedHatEnterpriseServer" ]; then
+    if [ "$DIST" = "Fedora" ]; then
         $install net-snmp-devel libpcap-devel libconfig-devel
-	elif [ "$DIST" = "SUSE LINUX"  ]; then
-		$install net-snmp-devel libpcap-devel libconfig-devel
     else
         $install libsnmp-dev libpcap-dev libconfig-dev
     fi
     cd $BUILD_DIR/
-    # was:  git clone git://gitosis.stanford.edu/oflops.git
-    # Use our own fork on github for now:
-    git clone git://github.com/mininet/oflops
+    git clone git://gitosis.stanford.edu/oflops.git
     cd oflops
     sh boot.sh || true # possible error in autoreconf, so run twice
     sh boot.sh
@@ -666,7 +609,7 @@ net.ipv6.conf.lo.disable_ipv6 = 1' | sudo tee -a /etc/sysctl.conf > /dev/null
     $install ntp
 
     # Install vconfig for VLAN example
-    if [ "$DIST" = "Fedora" -o "$DIST" = "RedHatEnterpriseServer" ]; then
+    if [ "$DIST" = "Fedora" ]; then
         $install vconfig
     else
         $install vlan
@@ -747,20 +690,6 @@ function vm_clean {
     rm -f ~/.ssh/id_rsa* ~/.ssh/known_hosts
     sudo rm -f ~/.ssh/authorized_keys*
 
-    # Remove SSH keys and regenerate on boot
-    echo 'Removing SSH keys from /etc/ssh/'
-    sudo rm -f /etc/ssh/*key*
-    if ! grep mininet /etc/rc.local >& /dev/null; then
-        sudo sed -i -e "s/exit 0//" /etc/rc.local
-        echo '
-# mininet: regenerate ssh keys if we deleted them
-if ! stat -t /etc/ssh/*key* >/dev/null 2>&1; then
-    /usr/sbin/dpkg-reconfigure openssh-server
-fi
-exit 0
-' | sudo tee -a /etc/rc.local > /dev/null
-    fi
-
     # Remove Mininet files
     #sudo rm -f /lib/modules/python2.5/site-packages/mininet*
     #sudo rm -f /usr/bin/mnexec
@@ -775,7 +704,7 @@ exit 0
     # Note: you can shrink the .vmdk in vmware using
     # vmware-vdiskmanager -k *.vmdk
     echo "Zeroing out disk blocks for efficient compaction..."
-    time sudo dd if=/dev/zero of=/tmp/zero bs=1M || true
+    time sudo dd if=/dev/zero of=/tmp/zero bs=1M
     sync ; sleep 1 ; sync ; sudo rm -f /tmp/zero
 
 }

util/unpep8

@@ -40,7 +40,6 @@ Bob Lantz, rlantz@cs.stanford.edu
 1/24/2010
 """
 
-from __future__ import print_function
 import re, sys
 
 def fixUnderscoreTriplet( match ):
@@ -196,4 +195,4 @@ def convertFromPep8( program ):
    return program
 
 if __name__ == '__main__':
-   print( convertFromPep8( sys.stdin.read() ) )
+   print convertFromPep8( sys.stdin.read() )

util/versioncheck.py

@@ -1,19 +1,14 @@
 #!/usr/bin/python
 
 from subprocess import check_output as co
-from sys import exit, version_info
-
-def run(*args, **kwargs):
-    "Run co and decode for python3"
-    result = co(*args, **kwargs)
-    return result.decode() if version_info[ 0 ] >= 3 else result
+from sys import exit
 
 # Actually run bin/mn rather than importing via python path
-version = 'Mininet ' + run( 'PYTHONPATH=. bin/mn --version 2>&1', shell=True )
+version = 'Mininet ' + co( 'PYTHONPATH=. bin/mn --version', shell=True )
 version = version.strip()
 
 # Find all Mininet path references
-lines = run( "egrep -or 'Mininet [0-9\.\+]+\w*' *", shell=True )
+lines = co( "egrep -or 'Mininet [0-9\.\+]+\w*' *", shell=True )
 
 error = False
 
@@ -21,8 +16,8 @@ for line in lines.split( '\n' ):
     if line and 'Binary' not in line:
         fname, fversion = line.split( ':' )
         if version != fversion:
-            print( "%s: incorrect version '%s' (should be '%s')" % (
-                fname, fversion, version ) )
+            print "%s: incorrect version '%s' (should be '%s')" % (
+                fname, fversion, version )
             error = True
 
 if error:

util/vm/build.py

@@ -54,7 +54,6 @@ NoKVM = False               # Don't use kvm and use emulation instead
 Branch = None               # Branch to update and check out before testing
 Zip = False                 # Archive .ovf and .vmdk into a .zip file
 Forward = []                # VM port forwarding options (-redir)
-Chown = ''                  # Build directory owner
 
 VMImageDir = os.environ[ 'HOME' ] + '/vm-images'
 
@@ -67,24 +66,36 @@ isoURLs = {
     'precise64server':
     'http://mirrors.kernel.org/ubuntu-releases/12.04/'
     'ubuntu-12.04.5-server-amd64.iso',
+    'quantal32server':
+    'http://mirrors.kernel.org/ubuntu-releases/12.10/'
+    'ubuntu-12.10-server-i386.iso',
+    'quantal64server':
+    'http://mirrors.kernel.org/ubuntu-releases/12.10/'
+    'ubuntu-12.10-server-amd64.iso',
+    'raring32server':
+    'http://mirrors.kernel.org/ubuntu-releases/13.04/'
+    'ubuntu-13.04-server-i386.iso',
+    'raring64server':
+    'http://mirrors.kernel.org/ubuntu-releases/13.04/'
+    'ubuntu-13.04-server-amd64.iso',
+    'saucy32server':
+    'http://mirrors.kernel.org/ubuntu-releases/13.10/'
+    'ubuntu-13.10-server-i386.iso',
+    'saucy64server':
+    'http://mirrors.kernel.org/ubuntu-releases/13.10/'
+    'ubuntu-13.10-server-amd64.iso',
     'trusty32server':
     'http://mirrors.kernel.org/ubuntu-releases/14.04/'
-    'ubuntu-14.04.4-server-i386.iso',
+    'ubuntu-14.04-server-i386.iso',
     'trusty64server':
     'http://mirrors.kernel.org/ubuntu-releases/14.04/'
-    'ubuntu-14.04.4-server-amd64.iso',
-    'wily32server':
-    'http://mirrors.kernel.org/ubuntu-releases/15.10/'
-    'ubuntu-15.10-server-i386.iso',
-    'wily64server':
-    'http://mirrors.kernel.org/ubuntu-releases/15.10/'
-    'ubuntu-15.10-server-amd64.iso',
-    'xenial32server':
-    'http://mirrors.kernel.org/ubuntu-releases/16.04/'
-    'ubuntu-16.04.1-server-i386.iso',
-    'xenial64server':
-    'http://mirrors.kernel.org/ubuntu-releases/16.04/'
-    'ubuntu-16.04.1-server-amd64.iso',
+    'ubuntu-14.04-server-amd64.iso',
+    'utopic32server':
+    'http://mirrors.kernel.org/ubuntu-releases/14.10/'
+    'ubuntu-14.10-server-i386.iso',
+    'utopic64server':
+    'http://mirrors.kernel.org/ubuntu-releases/14.10/'
+    'ubuntu-14.10-server-amd64.iso',
 }
 
 
@@ -118,9 +129,9 @@ def log( *args, **kwargs ):
     msg = ' '.join( str( arg ) for arg in args )
     output = '%s [ %.3f ] %s' % ( clocktime, elapsed, msg )
     if cr:
-        print( output )
+        print output
     else:
-        print( output, )
+        print output,
     # Optionally mirror to LogFile
     if type( LogFile ) is file:
         if cr:
@@ -154,7 +165,7 @@ def depend():
     run( 'sudo apt-get -qy update' )
     run( 'sudo apt-get -qy install'
          ' kvm cloud-utils genisoimage qemu-kvm qemu-utils'
-         ' e2fsprogs curl'
+         ' e2fsprogs dnsmasq curl'
          ' python-setuptools mtools zip' )
     run( 'sudo easy_install pexpect' )
 
@@ -208,7 +219,7 @@ def attachNBD( cow, flags='' ):
             continue
         srun( 'modprobe nbd max-part=64' )
         srun( 'qemu-nbd %s -c %s %s' % ( flags, nbd, cow ) )
-        print()
+        print
         return nbd
     raise Exception( "Error: could not find unused /dev/nbdX device" )
 
@@ -227,10 +238,7 @@ def extractKernel( image, flavor, imageDir=VMImageDir ):
         return kernel, initrd
     log( '* Extracting kernel to', kernel )
     nbd = attachNBD( image, flags='-r' )
-    try:
-        print( srun( 'partx ' + nbd ) )
-    except:
-        log( 'Warning - partx failed with error' )
+    print srun( 'partx ' + nbd )
     # Assume kernel is in partition 1/boot/vmlinuz*generic for now
     part = nbd + 'p1'
     mnt = mkdtemp()
@@ -254,9 +262,8 @@ def findBaseImage( flavor, size='8G' ):
         # Detect race condition with multiple builds
         perms = stat( image )[ ST_MODE ] & 0777
         if perms != 0444:
-            raise Exception( 'Error - base image %s is writable.' % image +
-                             ' Are multiple builds running? if not,'
-                             ' remove %s and try again.' % image )
+            raise Exception( 'Error - %s is writable ' % image +
+                            '; are multiple builds running?' )
     else:
         # We create VMImageDir here since we are called first
         run( 'mkdir -p %s' % VMImageDir )
@@ -316,7 +323,7 @@ zerombr yes
 clearpart --all --initlabel
 #Automatic partitioning
 autopart
-#System authorization information
+#System authorization infomation
 auth  --useshadow  --enablemd5
 #Firewall configuration
 firewall --disabled
@@ -388,10 +395,6 @@ def installUbuntu( iso, image, logfilename='install.log', memory=1024 ):
         accel = 'tcg'
     else:
         accel = 'kvm'
-        try:
-            run( 'kvm-ok' )
-        except:
-            raise Exception( 'kvm-ok failed; try using --nokvm' )
     cmd = [ 'sudo', kvm,
            '-machine', 'accel=%s' % accel,
            '-nographic',
@@ -432,13 +435,12 @@ def installUbuntu( iso, image, logfilename='install.log', memory=1024 ):
     log( '* Ubuntu installation completed in %.2f seconds' % elapsed )
 
 
-def boot( cow, kernel, initrd, logfile, memory=1024, cpuCores=1 ):
+def boot( cow, kernel, initrd, logfile, memory=1024 ):
     """Boot qemu/kvm with a COW disk and local/user data store
        cow: COW disk path
        kernel: kernel path
        logfile: log file for pexpect object
        memory: memory size in MB
-       cpuCores: number of CPU cores to use
        returns: pexpect object to qemu process"""
     # pexpect might not be installed until after depend() is called
     global pexpect
@@ -467,8 +469,6 @@ def boot( cow, kernel, initrd, logfile, memory=1024, cpuCores=1 ):
             '-append "root=/dev/vda1 init=/sbin/init console=ttyS0" ' ]
     if Forward:
         cmd += sum( [ [ '-redir', f ] for f in Forward ], [] )
-    if cpuCores > 1:
-        cmd += [ '-smp cores=%s' % cpuCores ]
     cmd = ' '.join( cmd )
     log( '* BOOTING VM FROM', cow )
     log( cmd )
@@ -580,9 +580,6 @@ def useTest( vm, prompt=Prompt ):
         log( '* Restoring logging to stdout' )
         vm.logfile = stdout
 
-# A convenient alias for use - 'run'; we might want to allow
-# 'run' to take a parameter
-runTest = useTest
 
 def checkOutBranch( vm, branch, prompt=Prompt ):
     # This is a bit subtle; it will check out an existing branch (e.g. master)
@@ -792,20 +789,18 @@ def build( flavor='raring32server', tests=None, pre='', post='', memory=1024 ):
        post: command line to run in VM after tests
        prompt: shell prompt (default '$ ')
        memory: memory size in MB"""
-    global LogFile, Zip, Chown
+    global LogFile, Zip
     start = time()
     lstart = localtime()
     date = strftime( '%y%m%d-%H-%M-%S', lstart)
     ovfdate = strftime( '%y%m%d', lstart )
     dir = 'mn-%s-%s' % ( flavor, date )
     if Branch:
-        dirname = 'mn-%s-%s-%s' % ( Branch, flavor, date )
+        dir = 'mn-%s-%s-%s' % ( Branch, flavor, date )
     try:
-        os.mkdir( dir)
+        os.mkdir( dir )
     except:
         raise Exception( "Failed to create build directory %s" % dir )
-    if Chown:
-        run( 'chown %s %s' % ( Chown, dir ) )
     os.chdir( dir )
     LogFile = open( 'build.log', 'w' )
     log( '* Logging to', abspath( LogFile.name ) )
@@ -886,15 +881,14 @@ def getMininetVersion( vm ):
     return version
 
 
-def bootAndRun( image, prompt=Prompt, memory=1024, cpuCores=1, outputFile=None,
+def bootAndRun( image, prompt=Prompt, memory=1024, outputFile=None,
                 runFunction=None, **runArgs ):
     """Boot and test VM
        tests: list of tests to run
        pre: command line to run in VM before tests
        post: command line to run in VM after tests
        prompt: shell prompt (default '$ ')
-       memory: VM memory size in MB
-       cpuCores: number of CPU cores to use"""
+       memory: VM memory size in MB"""
     bootTestStart = time()
     basename = path.basename( image )
     image = abspath( image )
@@ -912,7 +906,7 @@ def bootAndRun( image, prompt=Prompt, memory=1024, cpuCores=1, outputFile=None,
                                       suffix='.testlog', delete=False )
     log( '* Logging VM output to', logfile.name )
     vm = boot( cow=cow, kernel=kernel, initrd=initrd, logfile=logfile,
-               memory=memory, cpuCores=cpuCores )
+               memory=memory )
     login( vm )
     log( '* Waiting for prompt after login' )
     vm.expect( prompt )
@@ -934,7 +928,7 @@ def bootAndRun( image, prompt=Prompt, memory=1024, cpuCores=1, outputFile=None,
 
 def buildFlavorString():
     "Return string listing valid build flavors"
-    return 'valid build flavors: %s' % ' '.join( sorted( isoURLs ) )
+    return 'valid build flavors: ( %s )' % ' '.join( sorted( isoURLs ) )
 
 
 def testDict():
@@ -950,16 +944,15 @@ def testDict():
 
 def testString():
     "Return string listing valid tests"
-    tests = [ '%s <%s>' % ( name, func.__doc__ )
-              for name, func in testDict().iteritems() ]
-    return 'valid tests: %s' % ', '.join( tests )
+    return 'valid tests: ( %s )' % ' '.join( testDict().keys() )
 
 
 def parseArgs():
     "Parse command line arguments and run"
-    global LogToConsole, NoKVM, Branch, Zip, TIMEOUT, Forward, Chown
+    global LogToConsole, NoKVM, Branch, Zip, TIMEOUT, Forward
     parser = argparse.ArgumentParser( description='Mininet VM build script',
-                                      epilog='' )
+                                      epilog=buildFlavorString() + ' ' +
+                                      testString() )
     parser.add_argument( '-v', '--verbose', action='store_true',
                         help='send VM output to console rather than log file' )
     parser.add_argument( '-d', '--depend', action='store_true',
@@ -979,7 +972,7 @@ def parseArgs():
                          help='Boot and test an existing VM image' )
     parser.add_argument( '-t', '--test', metavar='test', default=[],
                          action='append',
-                         help='specify a test to run; ' + testString() )
+                         help='specify a test to run' )
     parser.add_argument( '-w', '--timeout', metavar='timeout', type=int,
                             default=0, help='set expect timeout' )
     parser.add_argument( '-r', '--run', metavar='cmd', default='',
@@ -989,20 +982,18 @@ def parseArgs():
     parser.add_argument( '-b', '--branch', metavar='branch',
                          help='branch to install and/or check out and test' )
     parser.add_argument( 'flavor', nargs='*',
-                         help='VM flavor(s) to build; ' + buildFlavorString() )
+                         help='VM flavor(s) to build (e.g. raring32server)' )
     parser.add_argument( '-z', '--zip', action='store_true',
                          help='archive .ovf and .vmdk into .zip file' )
     parser.add_argument( '-o', '--out',
                          help='output file for test image (vmdk)' )
     parser.add_argument( '-f', '--forward', default=[], action='append',
                          help='forward VM ports to local server, e.g. tcp:5555::22' )
-    parser.add_argument( '-u', '--chown', metavar='user',
-                         help='specify an owner for build directory' )
     args = parser.parse_args()
     if args.depend:
         depend()
     if args.list:
-        print( buildFlavorString() )
+        print buildFlavorString()
     if args.clean:
         cleanup()
     if args.verbose:
@@ -1019,12 +1010,10 @@ def parseArgs():
         Forward = args.forward
     if not args.test and not args.run and not args.post:
         args.test = [ 'sanity', 'core' ]
-    if args.chown:
-        Chown = args.chown
     for flavor in args.flavor:
         if flavor not in isoURLs:
-            print( "Unknown build flavor:", flavor )
-            print( buildFlavorString() )
+            print "Unknown build flavor:", flavor
+            print buildFlavorString()
             break
         try:
             build( flavor, tests=args.test, pre=args.run, post=args.post,

util/vm/install-mininet-vm.sh

@@ -43,7 +43,7 @@ fi
 # Install Mininet
 time mininet/util/install.sh
 # Finalize VM
-time mininet/util/install.sh -tcd
+time mininet/util/install.sh -tc
 # Ignoring this since NOX classic is deprecated
 #if ! grep NOX_CORE_DIR .bashrc; then
 #  echo "export NOX_CORE_DIR=~/noxcore/build/src/" >> .bashrc