fixing no --nat issue

Updating NAT class to use gateway interface
Also, passing CLI args to NAT constructor fixes #437
2014-11-24 18:36:57 -08:00 · 2014-11-24 18:16:57 -08:00 · 2014-11-24 12:30:52 -08:00 · 2014-11-23 17:32:11 -08:00 · 2014-11-23 17:31:43 -08:00 · 2014-11-23 17:17:21 -08:00
96 changed files with 10924 additions and 1352 deletions
@@ -0,0 +1,50 @@
+Mininet Contributors
+
+Mininet is an open source project and we gratefully acknowledge
+the many contributions to the project! If you have contributed
+code into the project and are not on this list, please let us know
+or send a pull request.
+
+Contributors include:
+
+Mininet Core Team (and alumni)
+
+Bob Lantz
+Brandon Heller
+Nikhil Handigol
+Vimal Jeyakumar
+Brian O'Connor
+Cody Burkard
+
+Additional Mininet Contributors
+
+Tomasz Buchert
+Gustavo Pantuza Coelho Pinto
+Fernando Cappi
+Ryan Cox
+Shaun Crampton
+David Erickson
+Glen Gibb
+Andrew Ferguson
+Eder Leao Fernandes
+Gregory Gee
+Jon Hall
+Vitaly Ivanov
+Rich Lane
+Zi Shen Lim
+Murphy McCauley
+José Pedro Oliveira
+James Page
+Rich Lane
+Rémy Léone
+Angad Singh
+Piyush Srivastava
+Ed Swierk
+Darshan Thaker
+Andreas Wundsam
+Isaku Yamahata
+Baohua Yang
+
+Thanks also to everyone who has submitted issues and pull
+requests on github, and to our friendly mininet-discuss
+mailing list!
@@ -1,117 +1,179 @@

 Mininet Installation/Configuration Notes
+----------------------------------------

-Mininet 2.0.0
-
+Mininet 2.2.0b1
 ---

-The supported installation methods for Mininet are 1) using
-a pre-built VM image, and 2) native installation on Ubuntu. You
-can also easily create your own Mininet VM image (3).
+The supported installation methods for Mininet are 1) using a
+pre-built VM image, and 2) native installation on Ubuntu. You can also
+easily create your own Mininet VM image (4).

 (Other distributions may be supported in the future - if you would
 like to contribute an installation script, we would welcome it!)

 1. Easiest "installation" - use our pre-built VM image!

-The easiest way to get Mininet running is to start with one of our pre-built 
-virtual machine images from http://openflow.org/mininet
+   The easiest way to get Mininet running is to start with one of our
+   pre-built virtual machine images from <http://mininet.org/>

-Boot up the VM image, log in, and follow the instructions on the wiki page.
+   Boot up the VM image, log in, and follow the instructions on the
+   Mininet web site.

-One advantage of using the VM image is that it doesn't mess with
-your native OS installation or damage it in any way.
+   One advantage of using the VM image is that it doesn't mess with
+   your native OS installation or damage it in any way.

-Although a single Mininet instance can simulate multiple networks with
-multiple controllers, only one Mininet instance may currently be run at
-a time, and Mininet requires root access in the machine it's running on.
-Therefore, if you have a multiuser system, you may wish to consider
-running Mininet in a VM.
+   Although a single Mininet instance can simulate multiple networks
+   with multiple controllers, only one Mininet instance may currently
+   be run at a time, and Mininet requires root access in the machine
+   it's running on.  Therefore, if you have a multiuser system, you
+   may wish to consider running Mininet in a VM.

 2. Next-easiest option: use our Ubuntu package!

-To install Mininet itself (i.e. mn and the Python API) on Ubuntu 12.10+
+   To install Mininet itself (i.e. `mn` and the Python API) on Ubuntu
+   12.10+:

-  sudo apt-get install mininet
+        sudo apt-get install mininet

-Note: if you are upgrading from an older version of Mininet, make sure you
-remove the old OVS from /usr/local:
+   Note: if you are upgrading from an older version of Mininet, make
+   sure you remove the old OVS from `/usr/local`:

-  sudo rm /usr/local/bin/ovs*
-  sudo rm /usr/local/sbin/ovs*
+        sudo rm /usr/local/bin/ovs*
+        sudo rm /usr/local/sbin/ovs*

-3. Native installation from source on Ubuntu 11.10+
+3. Native installation from source

-If you're reading this, you've probably already done so, but the command to
-download the Mininet source code is;
-   
-  git clone git://openflow.org/mininet.git
+3.1. Native installation from source on Ubuntu 12.04+

-If you are running Ubuntu, you may be able to use our handy install.sh script,
-which is in mininet/util.
+   If you're reading this, you've probably already done so, but the
+   command to download the Mininet source code is:

-WARNING: USE AT YOUR OWN RISK!
+        git clone git://github.com/mininet/mininet.git

-install.sh is a bit intrusive and may possibly damage your OS and/or
-home directory, by creating/modifying several directories such as
-mininet, openflow, openvswitch and noxcore. Although we hope it won't
-do anything completely terrible, you may want to look at the script
-before you run it, and you should make sure your system and home
-directory are backed up just in case!
+   Note that the above git command will check out the latest and greatest
+   Mininet (which we recommend!) If you want to run the last tagged/released
+   version of Mininet, you can look at the release tags using

-To install Mininet itself, the OpenFlow reference implementation, and
-Open vSwitch, you may use:
+        cd mininet
+        git tag

-$ mininet/util/install.sh -fnv
+    and then

-This should be reasonably quick and the following command should work
-after the installation:
+        git checkout <release tag>

-$ sudo mn --test pingall
+   where <release tag> is the release you want to check out.

-To install ALL of the software which we use for OpenFlow tutorials,
-including NOX classic, the OpenFlow WireShark dissector, the oftest
-framework, and other potentially useful software (and to add some stuff
-to /etc/sysctl.conf which may or may not be useful) you may use
+   If you are running Ubuntu, Debian, or Fedora, you may be able to use
+   our handy `install.sh` script, which is in `mininet/util`.

-$ mininet/util/install.sh -a
+   *WARNING: USE AT YOUR OWN RISK!*

-This takes about 20 minutes on our test system.
+   `install.sh` is a bit intrusive and may possibly damage your OS
+   and/or home directory, by creating/modifying several directories
+   such as `mininet`, `openflow`, `oftest`, `pox`, etc.. We recommend
+   trying it in a VM before trying it on a system you use from day to day.
+
+   Although we hope it won't do anything completely terrible, you may
+   want to look at the script before you run it, and you should make
+   sure your system and home directory are backed up just in case!
+
+   To install Mininet itself, the OpenFlow reference implementation, and
+   Open vSwitch, you may use:
+
+        mininet/util/install.sh -fnv
+
+   This should be reasonably quick, and the following command should
+   work after the installation:
+
+        sudo mn --test pingall
+
+   To install ALL of the software which we use for OpenFlow tutorials,
+   including POX, the OpenFlow WireShark dissector, the `oftest`
+   framework, and other potentially useful software, you may use:
+
+        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.
+
+        mininet/util/install.sh -s <directory> -a
+
+3.2. Native installation from source on Fedora 18+.
+
+   As root execute the following operations:
+
+    * install git
+
+        yum install git
+
+    * create an user account (e.g. mininet) and add it to the wheel group
+
+        useradd [...] mininet
+        usermod -a -G wheel mininet
+
+    * change the SElinux setting to permissive. It can be done
+      temporarily with:
+
+        setenforce 0
+
+   then login with the new account (e.g. mininet) and do the following:
+
+    * clone the Mininet repository
+
+        git clone git://github.com/mininet/mininet.git
+
+    * install Mininet, the OpenFlow reference implementation, and
+      Open vSwitch
+
+        mininet/util/install.sh -fnv
+
+    * enable and start openvswitch
+
+        sudo systemctl enable openvswitch
+        sudo systemctl start openvswitch
+
+    * test the mininet installation
+
+        sudo mn --test pingall

 4. Creating your own Mininet/OpenFlow tutorial VM

-Creating your own Ubuntu Mininet VM for use with the OpenFlow tutorial
-is easy! First, create a new Ubuntu VM. Then, run
+   Creating your own Ubuntu Mininet VM for use with the OpenFlow tutorial
+   is easy! First, create a new Ubuntu VM. Next, run two commands in it:

-$ wget https://raw.github.com/mininet/mininet/util/vm/install-mininet-vm.sh
-$ time install-mininet-vm.sh
+        wget https://raw.github.com/mininet/mininet/master/util/vm/install-mininet-vm.sh
+        time install-mininet-vm.sh
+
+   Finally, verify that Mininet is installed and working in the VM:
+
+        sudo mn --test pingall

 5. Installation on other Linux distributions

-Although we don't support other Linux distributions directly, it should be
-possible to install and run Mininet with some degree of manual effort.
+   Although we don't support other Linux distributions directly, it
+   should be possible to install and run Mininet with some degree of
+   manual effort.

-In general, you must have:
+   In general, you must have:

-* A Linux kernel compiled with network namespace support enabled
+   * A Linux kernel compiled with network namespace support enabled

-* An OpenFlow implementation (either the reference user or kernel
-  space implementations, or Open vSwitch.) Appropriate kernel modules
-  (e.g. tun and ofdatapath for the reference kernel implementation) must
-  be loaded.
+   * An compatible software switch such as Open vSwitch or
+     the Linux bridge.

-* Python, `bash`, `ping`, `iperf`, etc.
+   * Python, `bash`, `ping`, `iperf`, etc.

-* Root privileges (required for network device access)
+   * Root privileges (required for network device access)
+
+   We encourage contribution of patches to the `install.sh` script to
+   support other Linux distributions.

-We encourage contribution of patches to the `install.sh` script to support
-other Linux distributions.

 Good luck!

 Mininet Team

 ---
-
-  
-  
@@ -1,6 +1,6 @@
-Mininet 2.0.0 License
+Mininet 2.2.0b1 License

-Copyright (c) 2012 Open Networking Laboratory
+Copyright (c) 2013 Open Networking Laboratory
 Copyright (c) 2009-2012 Bob Lantz and The Board of Trustees of
 The Leland Stanford Junior University

@@ -1,6 +1,6 @@
 MININET = mininet/*.py
 TEST = mininet/test/*.py
-EXAMPLES = examples/*.py
+EXAMPLES = mininet/examples/*.py
 MN = bin/mn
 BIN = $(MN)
 PYSRC = $(MININET) $(TEST) $(EXAMPLES) $(BIN)
@@ -12,6 +12,8 @@ MANDIR = /usr/share/man/man1
 DOCDIRS = doc/html doc/latex
 PDF = doc/latex/refman.pdf

+CFLAGS += -Wall -Wextra
+
 all: codecheck test

 clean:
@@ -1,10 +1,9 @@
-
 Mininet: Rapid Prototyping for Software Defined Networks
 ========================================================

 *The best way to emulate almost any network on your laptop!*

-Version 2.0.0
+Mininet 2.2.0b1

 ### What is Mininet?

@@ -67,32 +66,37 @@ Mininet includes:

  `mn -c`

-### New features in 2.0.0
+### New features in this release

-Mininet 2.0.0 is a major upgrade and provides
-a number of enhancements and new features, including:
+This release provides a number of bug fixes as well as
+several new features, including:

-* "Mininet-HiFi" functionality:
+* Improved OpenFlow 1.3 support

-    * Link bandwidth limits using `tc` (`TCIntf` and `TCLink` classes)
+	- `mn --switch ovs,protocols=openflow13` starts OVS in 1.3 mode
+	- `install.sh -w` installs 1.3-compatible Wireshark dissector using
+	  Loxigen
+	- `install.sh -y` installs Ryu 1.3-compatible controller

-    * CPU isolation and bandwidth limits (`CPULimitedHost` class)
+* A new `nodelib.py` node library, and new `Node` types including
+  `LinuxBridge`, `OVSBridge`, `LinuxRouter` and `NAT`

-* Support for Open vSwitch 1.4+ (including Ubuntu OVS packages)
+* An improved MiniEdit GUI (`examples/miniedit.py`) - thanks to
+  Gregory Gee

-* Debian packaging (and `apt-get install mininet` in Ubuntu 12.10)
+* Support for multiple `--custom` arguments to `mn`

-* First-class Interface (`Intf`) and Link (`Link`) classes for easier
-  extensibility
+* Experimental cluster support - consult the 
+  [documentation](http://docs.mininet.org) for details -
+  as well as `examples/cluster.py` and an experimental `--cluster`
+  option for topologies built with the default `Host` and `OVSSwitch`
+  classes:

-* An upgraded Topology (`Topo`) class which supports node and link
-  customization
+  `mn --cluster localhost,server1,server2`

-* Man pages for the `mn` and `mnexec` utilities.
-
-[Since the API (most notably the topology) has changed, existing code
-that runs in Mininet 1.0 will need to be changed to run with Mininet
-2.0. This is the primary reason for the major version number change.]
+Note that examples contain experimental features which might
+"graduate" into mainline Mininet in the future, but they should 
+not be considered a stable part of the Mininet API!

 ### Installation

@@ -103,7 +107,7 @@ See `INSTALL` for installation instructions and details.
 In addition to the API documentation (`make doc`), much useful
 information, including a Mininet walkthrough and an introduction
 to the Python API, is available on the
-[Mininet Web Site](http://openflow.org/mininet).
+[Mininet Web Site](http://mininet.org).
 There is also a wiki which you are encouraged to read and to
 contribute to, particularly the Frequently Asked Questions (FAQ.)

@@ -114,21 +118,27 @@ Mininet mailing list, `mininet-discuss` at:

 <https://mailman.stanford.edu/mailman/listinfo/mininet-discuss>

-### Contributing
+### Join Us

-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, feature
-requests, and enhancements!
+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,
+feature requests, new features and other issues and pull requests.
+Thanks to everyone who has contributed code to the Mininet project
+(see CONTRIBUTORS for more info!) It is because of everyone's
+hard work that Mininet continues to grow and improve.
+
+### Enjoy Mininet

 Best wishes, and we look forward to seeing what you can do with
 Mininet to change the networking world!

-### Credits
-
-The Mininet Team:
+The Mininet Core Team:

 * Bob Lantz
-* Brandon Heller
-* Nikhil Handigol
-* Vimal Jeyakumar
+* Brian O'Connor
+* Cody Burkard
+
+Thanks again to all of the Mininet contributors, particularly Gregory
+Gee for his work on MiniEdit.
+
@@ -22,17 +22,28 @@ if 'PYTHONPATH' in os.environ:

 from mininet.clean import cleanup
 from mininet.cli import CLI
-from mininet.log import lg, LEVELS, info
+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,
-                           NOX, RemoteController, UserSwitch, OVSKernelSwitch,
-                           OVSLegacyKernelSwitch )
+                           RYU, NOX, RemoteController, findController, DefaultController,
+                           UserSwitch, OVSSwitch, OVSBridge,
+                           OVSLegacyKernelSwitch, IVSSwitch )
+from mininet.nodelib import LinuxBridge
 from mininet.link import Link, TCLink
 from mininet.topo import SingleSwitchTopo, LinearTopo, SingleSwitchReversedTopo
-from mininet.topolib import TreeTopo
-from mininet.util import custom, customConstructor
+from mininet.topolib import TreeTopo, TorusTopo
+from mininet.util import customConstructor, splitArgs
 from mininet.util import buildTopo

+from functools import partial
+
+# Experimental! cluster edition prototype
+from mininet.examples.cluster import ( MininetCluster, RemoteHost,
+                                       RemoteOVSSwitch, RemoteLink,
+                                       SwitchBinPlacer, RandomPlacer )
+from mininet.examples.clustercli import ClusterCLI
+
+PLACEMENT = { 'block': SwitchBinPlacer, 'random': RandomPlacer }

 # built in topologies, created only when run
 TOPODEF = 'minimal'
@@ -40,23 +51,32 @@ TOPOS = { 'minimal': lambda: SingleSwitchTopo( k=2 ),
          'linear': LinearTopo,
          'reversed': SingleSwitchReversedTopo,
          'single': SingleSwitchTopo,
-          'tree': TreeTopo }
+          'tree': TreeTopo,
+          'torus': TorusTopo }

-SWITCHDEF = 'ovsk'
+SWITCHDEF = 'default'
 SWITCHES = { 'user': UserSwitch,
-             'ovsk': OVSKernelSwitch,
-             'ovsl': OVSLegacyKernelSwitch }
+             'ovs':  OVSSwitch,
+             'ovsbr' : OVSBridge,
+             # Keep ovsk for compatibility with 2.0
+             'ovsk': OVSSwitch,
+             'ovsl': OVSLegacyKernelSwitch,
+             'ivs': IVSSwitch,
+             'lxbr': LinuxBridge,
+             'default': OVSSwitch }

 HOSTDEF = 'proc'
 HOSTS = { 'proc': Host,
-          'rt': custom( CPULimitedHost, sched='rt' ),
-          'cfs': custom( CPULimitedHost, sched='cfs' ) }
+          'rt': partial( CPULimitedHost, sched='rt' ),
+          'cfs': partial( CPULimitedHost, sched='cfs' ) }

-CONTROLLERDEF = 'ovsc'
+CONTROLLERDEF = 'default'
 CONTROLLERS = { 'ref': Controller,
                'ovsc': OVSController,
                'nox': NOX,
                'remote': RemoteController,
+                'ryu': RYU,
+                'default': DefaultController,  # Note: replaced below
                'none': lambda name: None }

 LINKDEF = 'default'
@@ -71,8 +91,7 @@ TESTS = [ 'cli', 'build', 'pingall', 'pingpair', 'iperf', 'all', 'iperfudp',
 ALTSPELLING = { 'pingall': 'pingAll',
                'pingpair': 'pingPair',
                'iperfudp': 'iperfUdp',
-                'iperfUDP': 'iperfUdp',
-                'prefixlen': 'prefixLen' }
+                'iperfUDP': 'iperfUdp' }


 def addDictOption( opts, choicesDict, default, name, helpStr=None ):
@@ -99,6 +118,7 @@ def version( *_args ):
    print "%s" % VERSION
    exit()

+
 class MininetRunner( object ):
    "Build, setup, and run Mininet."

@@ -112,6 +132,29 @@ class MininetRunner( object ):
        self.setup()
        self.begin()

+    def custom( self, option, opt_str, value, parser ):
+        """Parse custom file and add params.
+           option: option e.g. --custom
+           opt_str: option string e.g. --custom
+           value: the value the follows the option
+           parser: option parser instance"""
+        files = []
+        if os.path.isfile( value ):
+            # Accept any single file (including those with commas)
+            files.append( value )
+        else:
+            # Accept a comma-separated list of filenames
+            files += value.split(',')
+        
+        for fileName in files:
+            customs = {}
+            if os.path.isfile( fileName ):
+                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' ):
@@ -125,26 +168,20 @@ class MininetRunner( object ):
            # Add or modify global variable or class
            globals()[ name ] = value

-    def parseCustomFile( self, fileName ):
-        "Parse custom file and add params before parsing cmd-line options."
-        customs = {}
-        if os.path.isfile( fileName ):
-            execfile( fileName, customs, customs )
-            for name, val in customs.iteritems():
-                self.setCustom( name, val )
+    def setNat( self, option, opt_str, value, parser ):
+        parser.values.nat = True
+        if parser.rargs and parser.rargs[ 0 ][ 0 ] != '-': #first arg, first char != '-'
+            value = parser.rargs.pop( 0 )
+            _, args, kwargs = splitArgs( opt_str + ',' + value )
+            parser.values.nat_args = args
+            parser.values.nat_kwargs = kwargs
        else:
-            raise Exception( 'could not find custom file: %s' % fileName )
+            parser.values.nat_args = []
+            parser.values.nat_kwargs = {}

    def parseArgs( self ):
        """Parse command-line args and return options object.
           returns: opts parse options dict"""
-        if '--custom' in sys.argv:
-            index = sys.argv.index( '--custom' )
-            if len( sys.argv ) > index + 1:
-                filename = sys.argv[ index + 1 ]
-                self.parseCustomFile( filename )
-            else:
-                raise Exception( 'Custom file name not found' )

        desc = ( "The %prog utility creates Mininet network from the\n"
                 "command line. It can create parametrized topologies,\n"
@@ -162,9 +199,9 @@ class MininetRunner( object ):

        opts.add_option( '--clean', '-c', action='store_true',
                         default=False, help='clean and exit' )
-        opts.add_option( '--custom', type='string', default=None,
-                         help='read custom topo and node params from .py' +
-                         'file' )
+        opts.add_option( '--custom', action='callback',
+                         callback=self.custom,
+                         type='string', help='read custom classes or params from .py file(s)' )
        opts.add_option( '--test', type='choice', choices=TESTS,
                         default=TESTS[ 0 ],
                         help='|'.join( TESTS ) )
@@ -190,16 +227,33 @@ class MininetRunner( object ):
                         help='CLI script to run before tests' )
        opts.add_option( '--post', type='string', default=None,
                         help='CLI script to run after tests' )
-        opts.add_option( '--prefixlen', type='int', default=8,
-                         help='prefix length (e.g. /8) for automatic '
-                         'network configuration' )
        opts.add_option( '--pin', action='store_true',
                         default=False, help="pin hosts to CPU cores "
                         "(requires --host cfs or --host rt)" )
-        opts.add_option( '--version', action='callback', callback=version )
+        opts.add_option( '--nat', action='callback', callback=self.setNat,
+                         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"
+                         " IP subnet into the Mininet network. If you need to change"
+                         " Mininet's IP subnet, see the --ipbase option." )
+        opts.add_option( '--version', action='callback', callback=version,
+                         help='prints the version and exits' )
+        opts.add_option( '--cluster', type='string', default=None,
+                         metavar='server1,server2...',
+                         help=( 'run on multiple servers (experimental!)' ) )
+        opts.add_option( '--placement', type='choice',
+                         choices=PLACEMENT.keys(), default='block',
+                         metavar='block|random',
+                         help=( 'node placement for --cluster '
+                                '(experimental!) ' ) )

        self.options, self.args = opts.parse_args()

+        # We don't accept extra arguments after the options
+        if self.args:
+            opts.print_help()
+            exit()
+
    def setup( self ):
        "Setup and validate environment."

@@ -220,6 +274,22 @@ class MininetRunner( object ):

        start = time.time()

+        if self.options.controller == 'default':
+            # Update default based on available controllers
+            CONTROLLERS[ 'default' ] = findController()
+            if CONTROLLERS[ 'default' ] is None:
+                if self.options.switch == 'default':
+                    # Fall back to OVS Bridge, which does not use an OF controller
+                    info( '*** No default OpenFlow controller found for default switch!\n' )
+                    info( '*** Falling back to OVS Bridge\n' )
+                    self.options.switch = 'ovsbr'
+                    self.options.controller = 'none'
+                elif self.options.switch in ( 'ovsbr', 'lxbr' ):
+                    self.options.controller = 'none'
+                else:
+                    raise Exception( "Could not find a default controller for switch %s" %
+                                     self.options.switch )
+        
        topo = buildTopo( TOPOS, self.options.topo )
        switch = customConstructor( SWITCHES, self.options.switch )
        host = customConstructor( HOSTS, self.options.host )
@@ -229,8 +299,6 @@ class MininetRunner( object ):
        if self.validate:
            self.validate( self.options )

-        inNamespace = self.options.innamespace
-        Net = MininetWithControlNet if inNamespace else Mininet
        ipBase = self.options.ipbase
        xterms = self.options.xterms
        mac = self.options.mac
@@ -239,6 +307,22 @@ class MininetRunner( object ):
        listenPort = None
        if not self.options.nolistenport:
            listenPort = self.options.listenport
+
+        # 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 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=cluster.split( ',' ),
+                           placement=PLACEMENT[ self.options.placement ] )
+
        mn = Net( topo=topo,
                  switch=switch, host=host, controller=controller,
                  link=link,
@@ -248,8 +332,12 @@ class MininetRunner( object ):
                  autoStaticArp=arp, autoPinCpus=pin,
                  listenPort=listenPort )

+        if self.options.ensure_value( 'nat', False ):
+            nat = mn.addNAT( *self.options.nat_args, **self.options.nat_kwargs )
+            nat.configDefault()
+
        if self.options.pre:
-            CLI( mn, script=self.options.pre )
+            cli( mn, script=self.options.pre )

        test = self.options.test
        test = ALTSPELLING.get( test, test )
@@ -259,16 +347,18 @@ class MininetRunner( object ):
        if test == 'none':
            pass
        elif test == 'all':
+            mn.waitConnected()
            mn.start()
            mn.ping()
            mn.iperf()
        elif test == 'cli':
-            CLI( mn )
+            cli( mn )
        elif test != 'build':
+            mn.waitConnected()
            getattr( mn, test )()

        if self.options.post:
-            CLI( mn, script=self.options.post )
+            cli( mn, script=self.options.post )

        mn.stop()

@@ -277,4 +367,21 @@ class MininetRunner( object ):


 if __name__ == "__main__":
-    MininetRunner()
+    try:
+        MininetRunner()
+    except KeyboardInterrupt:
+        info( "\n\nKeyboard Interrupt. Shutting down and cleaning up...\n\n")
+        cleanup()
+    except Exception:
+        # Print exception
+        type_, val_, trace_ = sys.exc_info()
+        errorMsg = ( "-"*80 + "\n" +
+                     "Caught exception. Cleaning up...\n\n" +
+                     "%s: %s\n" % ( type_.__name__, val_ ) +
+                     "-"*80 + "\n" )
+        error( errorMsg )
+        # Print stack trace to debug log
+        import traceback
+        stackTrace = traceback.format_exc()
+        debug( stackTrace + "\n" )
+        cleanup()
@@ -1,3 +1,23 @@
+mininet (2.1.0-0ubuntu1) saucy; urgency=low
+
+  * Add 2.1.0 final packaging
+
+ -- Bob Lantz <rlantz@cs.stanford.edu>  Wed, 18 Sep 2013 22:43:47 -0700
+
+mininet (2.1.0~rc1-0ubuntu1) saucy; urgency=low
+
+  * New upstream release candidate:
+    - d/control: Drop dependency on python-networkx, add iperf, socat
+      and cgroup-bin to Depends.
+
+ -- James Page <james.page@ubuntu.com>  Wed, 28 Aug 2013 10:10:20 +0100
+
+mininet (2.0.0-0ubuntu1) raring; urgency=low
+
+  * New upstream release.
+
+ -- James Page <james.page@ubuntu.com>  Wed, 19 Dec 2012 15:48:01 +0000
+
 mininet (2.0.0~rc1-0ubuntu1) quantal; urgency=low

  * New upstream release.
@@ -9,20 +9,21 @@ Build-Depends:
 help2man,
 python-dev,
 python-pkg-resources,
- python-setuptools,
- python-networkx
+ python-setuptools
 Homepage: http://openflow.org/mininet

 Package: mininet
 Architecture: any
 Depends:
 openvswitch-switch,
- python-networkx,
 telnet,
+ socat,
+ iperf,
+ cgroup-bin,
 ${misc:Depends},
 ${python:Depends},
 ${shlibs:Depends}
-Recommends: iperf, openvswitch-controller
+Recommends: openvswitch-controller
 Description: Process-based network emulator
 Mininet is a network emulator which uses lightweight
 virtualization to create virtual networks for rapid
@@ -3,7 +3,7 @@ Upstream-Name: mininet
 Source: https://github.com/mininet/mininet

 Files: *
-Copyright: 2012 Open Networking Laboratory,
+Copyright: 2012-2013 Open Networking Laboratory,
           2009-2012 Bob Lantz,
           2009-2012 The Board of Trustees of the Leland Stanford Junior
           University
@@ -1,102 +0,0 @@
-
-Mininet Examples
-
-These examples are intended to help you get started using
-Mininet's Python API.
-
---
-
-baresshd.py:
-
-This example uses Mininet's medium-level API to create an sshd
-process running in a namespace. Doesn't use OpenFlow.
-
-consoles.py:
-
-This example creates a grid of console windows, one for each node, 
-and allows interaction with and monitoring of each console, including
-graphical monitoring.
-
-controllers.py:
-
-This example creates a network and adds multiple controllers to it.
-
-cpu.py:
-
-This example tests iperf bandwidth for varying CPU limits.
-
-emptynet.py:
-
-This example demonstrates creating an empty network (i.e. with no
-topology object) and adding nodes to it.
-
-hwintf.py:
-
-This example shows how to add an interface (for example a real
-hardware interface) to a network after the network is created.
-
-limit.py:
-
-This example shows how to use link and CPU limits.
-
-linearbandwidth.py:
-
-This example shows how to create a custom topology programatically
-by subclassing Topo, and how to run a series of tests on it.
-
-miniedit.py:
-
-This example demonstrates creating a network via a graphical editor.
-
-multiping.py:
-
-This example demonstrates one method for 
-monitoring output from multiple hosts, using node.monitor().
-
-multipoll.py:
-
-This example demonstrates monitoring output files from multiple hosts.
-
-multitest.py:
-
-This example creates a network and runs multiple tests on it.
-
-popen.py:
-
-This example monitors a number of hosts using host.popen() and
-pmonitor().
-
-popenpoll.py:
-
-This example demonstrates monitoring output from multiple hosts using
-the node.popen() interface (which returns Popen objects) and pmonitor().
-
-scratchnet.py, scratchnetuser.py:
-
-These two examples demonstrate how to create a network by using the lowest-
-level Mininet functions. Generally the higher-level API is easier to use,
-but scratchnet shows what is going on behind the scenes.
-
-simpleperf.py:
-
-A simple example of configuring network and CPU bandwidth limits.
-
-sshd.py:
-
-This example shows how to run an sshd process in each host, allowing
-you to log in via ssh. This requires connecting the Mininet data network
-to an interface in the root namespace (generaly the control network
-already lives in the root namespace, so it does not need to be explicitly
-connected.)
-
-treeping64.py:
-
-This example creates a 64-host tree network, and attempts to check full
-connectivity using ping, for different switch/datapath types.
-
-tree1024.py:
-
-This example attempts to create a 1024-host network, and then runs the
-CLI on it. It may run into scalability limits, depending on available
-memory and sysctl configuration (see INSTALL.)
-
@@ -0,0 +1,139 @@
+Mininet Examples
+========================================================
+
+These examples are intended to help you get started using
+Mininet's Python API.
+
+========================================================
+
+#### baresshd.py:
+
+This example uses Mininet's medium-level API to create an sshd
+process running in a namespace. Doesn't use OpenFlow.
+
+#### consoles.py:
+
+This example creates a grid of console windows, one for each node,
+and allows interaction with and monitoring of each console, including
+graphical monitoring.
+
+#### controllers.py:
+
+This example creates a network with multiple controllers, by
+using a custom `Switch()` subclass.
+
+#### controllers2.py:
+
+This example creates a network with multiple controllers by
+creating an empty network, adding nodes to it, and manually
+starting the switches.
+
+#### controlnet.py:
+
+This examples shows how you can model the control network as well
+as the data network, by actually creating two Mininet objects.
+
+#### cpu.py:
+
+This example tests iperf bandwidth for varying CPU limits.
+
+#### emptynet.py:
+
+This example demonstrates creating an empty network (i.e. with no
+topology object) and adding nodes to it.
+
+#### hwintf.py:
+
+This example shows how to add an interface (for example a real
+hardware interface) to a network after the network is created.
+
+#### limit.py:
+
+This example shows how to use link and CPU limits.
+
+#### linearbandwidth.py:
+
+This example shows how to create a custom topology programatically
+by subclassing Topo, and how to run a series of tests on it.
+
+### linuxrouter.py:
+
+This example shows how to create and configure a router in Mininet
+that uses Linux IP forwarding.
+
+#### miniedit.py:
+
+This example demonstrates creating a network via a graphical editor.
+
+#### mobility.py
+
+This example demonstrates detaching an interface from one switch and
+attaching it another as a basic way to move a host around a network.
+
+#### multiping.py:
+
+This example demonstrates one method for
+monitoring output from multiple hosts, using `node.monitor()`.
+
+#### multipoll.py:
+
+This example demonstrates monitoring output files from multiple hosts.
+
+#### multitest.py:
+
+This example creates a network and runs multiple tests on it.
+
+#### nat.py:
+
+This example shows how to connect a Mininet network to the Internet
+using NAT. It also answers the eternal question "why can't I ping
+`google.com`?"
+
+#### numberedports.py
+
+This example verifies the mininet ofport numbers match up to the ovs port numbers.
+It also verifies that the port numbers match up to the interface numbers
+
+#### popen.py:
+
+This example monitors a number of hosts using `host.popen()` and
+`pmonitor()`.
+
+#### popenpoll.py:
+
+This example demonstrates monitoring output from multiple hosts using
+the `node.popen()` interface (which returns `Popen` objects) and `pmonitor()`.
+
+#### scratchnet.py, scratchnetuser.py:
+
+These two examples demonstrate how to create a network by using the lowest-
+level Mininet functions. Generally the higher-level API is easier to use,
+but scratchnet shows what is going on behind the scenes.
+
+#### simpleperf.py:
+
+A simple example of configuring network and CPU bandwidth limits.
+
+#### sshd.py:
+
+This example shows how to run an `sshd` process in each host, allowing
+you to log in via `ssh`. This requires connecting the Mininet data network
+to an interface in the root namespace (generaly the control network
+already lives in the root namespace, so it does not need to be explicitly
+connected.)
+
+#### tree1024.py:
+
+This example attempts to create a 1024-host network, and then runs the
+CLI on it. It may run into scalability limits, depending on available
+memory and `sysctl` configuration (see `INSTALL`.)
+
+#### treeping64.py:
+
+This example creates a 64-host tree network, and attempts to check full
+connectivity using `ping`, for different switch/datapath types.
+
+#### vlanhost.py:
+
+An example of how to subclass Host to use a VLAN on its primary interface.
+
@@ -0,0 +1,4 @@
+"""
+Mininet Examples
+See README for details
+"""
@@ -2,10 +2,12 @@

 "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
+from mininet.util import ensureRoot, waitListening

 ensureRoot()
+timeout = 5

 print "*** Creating nodes"
 h1 = Host( 'h1' )
@@ -27,6 +29,15 @@ f.write( 'Welcome to %s at %s\n' % ( h1.name, h1.IP() ) )
 f.close()

 print "*** Running sshd"
-h1.cmd( '/usr/sbin/sshd -o "Banner /tmp/%s.banner"' % h1.name )
+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:
+    cmd += ' ' + ' '.join( sys.argv[ 1: ] )
+h1.cmd( cmd )
+listening = waitListening( server=h1, port=22, timeout=timeout )

-print "*** You may now ssh into", h1.name, "at", h1.IP()
+if listening:
+    print "*** You may now ssh into", h1.name, "at", h1.IP()
+else:
+    print ( "*** Warning: after %s seconds, %s is not listening on port 22"
+            % ( timeout, h1.name ) )
@@ -0,0 +1,69 @@
+#!/usr/bin/python
+
+"""
+bind.py: Bind mount example
+
+This creates hosts with private directories that the user specifies.
+These hosts may have persistent directories that will be available
+across multiple mininet session, or temporary directories that will
+only last for one mininet session. To specify a persistent
+directory, add a tuple to a list of private directories:
+
+    [ ( 'directory to be mounted on', 'directory to be mounted' ) ]
+
+String expansion may be used to create a directory template for
+each host. To do this, add a %(name)s in place of the host name
+when creating your list of directories:
+
+    [ ( '/var/run', '/tmp/%(name)s/var/run' ) ]
+
+If no persistent directory is specified, the directories will default
+to temporary private directories. To do this, simply create a list of
+directories to be made private. A tmpfs will then be mounted on them.
+
+You may use both temporary and persistent directories at the same
+time. In the following privateDirs string, each host will have a 
+persistent directory in the root filesystem at
+"/tmp/(hostname)/var/run" mounted on "/var/run". Each host will also
+have a temporary private directory mounted on "/var/log".
+
+    [ ( '/var/run', '/tmp/%(name)s/var/run' ), '/var/log' ]
+
+This example has both persistent directories mounted on '/var/log'
+and '/var/run'. It also has a temporary private directory mounted
+on '/var/mn'
+"""
+
+from mininet.net import Mininet
+from mininet.node import Host
+from mininet.cli import CLI
+from mininet.topo import SingleSwitchTopo
+from mininet.log import setLogLevel, info
+
+from functools import partial
+
+
+# Sample usage
+
+def testHostWithPrivateDirs():
+    "Test bind mounts"
+    topo = SingleSwitchTopo( 10 )
+    privateDirs = [ ( '/var/log', '/tmp/%(name)s/var/log' ), 
+                    ( '/var/run', '/tmp/%(name)s/var/run' ), 
+                      '/var/mn' ]
+    host = partial( Host,
+                    privateDirs=privateDirs )
+    net = Mininet( topo=topo, host=host )
+    net.start()
+    directories = [ directory[ 0 ] if isinstance( directory, tuple )
+                    else directory for directory in privateDirs ]
+    info( 'Private Directories:',  directories, '\n' )
+    CLI( net )
+    net.stop()
+
+if __name__ == '__main__':
+    setLogLevel( 'info' )
+    testHostWithPrivateDirs()
+    info( 'Done.\n')
+
+
@@ -0,0 +1,853 @@
+#!/usr/bin/python
+
+"""
+cluster.py: prototyping/experimentation for distributed Mininet,
+            aka Mininet: Cluster Edition
+
+Author: Bob Lantz
+
+Core classes:
+
+    RemoteNode: a Node() running on a remote server
+    RemoteOVSSwitch(): an OVSSwitch() running on a remote server
+    RemoteLink: a Link() on a remote server
+    Tunnel: a Link() between a local Node() and a RemoteNode()
+
+These are largely interoperable with local objects.
+
+- One Mininet to rule them all
+
+It is important that the same topologies, APIs, and CLI can be used
+with minimal or no modification in both local and distributed environments.
+
+- Multiple placement models
+
+Placement should be as easy as possible. We should provide basic placement
+support and also allow for explicit placement.
+
+Questions:
+
+What is the basic communication mechanism?
+
+To start with? Probably a single multiplexed ssh connection between each
+pair of mininet servers that needs to communicate.
+
+How are tunnels created?
+
+We have several options including ssh, GRE, OF capsulator, socat, VDE, l2tp,
+etc..  It's not clear what the best one is.  For now, we use ssh tunnels since
+they are encrypted and semi-automatically shared.  We will probably want to
+support GRE as well because it's very easy to set up with OVS.
+
+How are tunnels destroyed?
+
+They are destroyed when the links are deleted in Mininet.stop()
+
+How does RemoteNode.popen() work?
+
+It opens a shared ssh connection to the remote server and attaches to
+the namespace using mnexec -a -g.
+
+Is there any value to using Paramiko vs. raw ssh?
+
+Maybe, but it doesn't seem to support L2 tunneling.
+
+Should we preflight the entire network, including all server-to-server
+connections?
+
+Yes! We don't yet do this with remote server-to-server connections yet.
+
+Should we multiplex the link ssh connections?
+
+Yes, this is done automatically with ControlMaster=auto.
+
+Note on ssh and DNS:
+Please add UseDNS: no to your /etc/ssh/sshd_config!!!
+
+Things to do:
+
+- asynchronous/pipelined/parallel startup
+- ssh debugging/profiling
+- make connections into real objects
+- support for other tunneling schemes
+- tests and benchmarks
+- 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
+from mininet.topo import LinearTopo
+from mininet.topolib import TreeTopo
+from mininet.util import quietRun, makeIntfPair, errRun, retry
+from mininet.examples.clustercli import CLI
+from mininet.log import setLogLevel, debug, info, error
+
+from signal import signal, SIGINT, SIG_IGN
+from subprocess import Popen, PIPE, STDOUT
+import os
+from random import randrange
+from sys import exit
+import re
+
+from distutils.version import StrictVersion
+
+# BL note: so little code is required for remote nodes,
+# we will probably just want to update the main Node()
+# class to enable it for remote access! However, there
+# are a large number of potential failure conditions with
+# remote nodes which we may want to detect and handle.
+# Another interesting point is that we could put everything
+# in a mix-in class and easily add cluster mode to 2.0.
+
+class RemoteMixin( object ):
+
+    "A mix-in class to turn local nodes into remote nodes"
+
+    # ssh base command
+    # -q: don't print stupid diagnostic messages
+    # BatchMode yes: don't ask for password
+    # ForwardAgent yes: forward authentication credentials
+    sshbase = [ 'ssh', '-q',
+                '-o', 'BatchMode=yes',
+                '-o', 'ForwardAgent=yes', '-tt' ]
+
+    def __init__( self, name, server='localhost', user=None, serverIP=None,
+                  controlPath=False, splitInit=False, **kwargs):
+        """Instantiate a remote node
+           name: name of remote node
+           server: remote server (optional)
+           user: user on remote server (optional)
+           controlPath: specify shared ssh control path (optional)
+           splitInit: split initialization?
+           **kwargs: see Node()"""
+        # We connect to servers by IP address
+        self.server = server if server else 'localhost'
+        self.serverIP = serverIP if serverIP else self.findServerIP( self.server )
+        self.user = user if user else self.findUser()
+        if controlPath is True:
+            # Set a default control path for shared SSH connections
+            controlPath = '/tmp/mn-%r@%h:%p'
+        self.controlPath = controlPath
+        self.splitInit = splitInit
+        if self.user and self.server != 'localhost':
+            self.dest = '%s@%s' % ( self.user, self.serverIP )
+            self.sshcmd = [ 'sudo', '-E', '-u', self.user ] + self.sshbase
+            if self.controlPath:
+                self.sshcmd += [ '-o', 'ControlPath=' + self.controlPath,
+                                 '-o', 'ControlMaster=auto',
+                                 '-o', 'ControlPersist=' + '1' ]
+            self.sshcmd = self.sshcmd + [ self.dest ]
+            self.isRemote = True
+        else:
+            self.dest = None
+            self.sshcmd = []
+            self.isRemote = False
+        super( RemoteMixin, self ).__init__( name, **kwargs )
+
+    @staticmethod
+    def findUser():
+        "Try to return logged-in (usually non-root) user"
+        try:
+            # If we're running sudo
+            return os.environ[ 'SUDO_USER' ]
+        except:
+            try:
+                # Logged-in user (if we have a tty)
+                return quietRun( 'who am i' ).split()[ 0 ]
+            except:
+                # Give up and return effective user
+                return quietRun( 'whoami' )
+
+    # Determine IP address of local host
+    _ipMatchRegex = re.compile( r'\d+\.\d+\.\d+\.\d+' )
+
+    @classmethod
+    def findServerIP( cls, server ):
+        "Return our server's IP address"
+        # First, check for an IP address
+        ipmatch = cls._ipMatchRegex.findall( server )
+        if ipmatch:
+            return ipmatch[ 0 ]
+        # Otherwise, look up remote server
+        output = quietRun( 'getent ahostsv4 %s' % server )
+        ips = cls._ipMatchRegex.findall( output )
+        ip = ips[ 0 ] if ips else None
+        return ip
+
+    # Command support via shell process in namespace
+    def startShell( self, *args, **kwargs ):
+        "Start a shell process for running commands"
+        if self.isRemote:
+            kwargs.update( mnopts='-c' )
+        super( RemoteMixin, self ).startShell( *args, **kwargs )
+        if self.splitInit:
+            self.sendCmd( 'echo $$' )
+        else:
+            self.pid = int( self.cmd( 'echo $$' ) )
+
+    def finishInit( self ):
+        self.pid = int( self.waitOutput() )
+
+    def rpopen( self, *cmd, **opts ):
+        "Return a Popen object on underlying server in root namespace"
+        params = { 'stdin': PIPE,
+                   'stdout': PIPE,
+                   'stderr': STDOUT,
+                   'sudo': True }
+        params.update( opts )
+        return self._popen( *cmd, **params )
+
+    def rcmd( self, *cmd, **opts):
+        """rcmd: run a command on underlying server
+           in root namespace
+           args: string or list of strings
+           returns: stdout and stderr"""
+        popen = self.rpopen( *cmd, **opts )
+        # print 'RCMD: POPEN:', popen
+        # These loops are tricky to get right.
+        # Once the process exits, we can read
+        # EOF twice if necessary.
+        result = ''
+        while True:
+            poll = popen.poll()
+            result += popen.stdout.read()
+            if poll is not None:
+                break
+        return result
+
+    @staticmethod
+    def _ignoreSignal():
+        "Detach from process group to ignore all signals"
+        os.setpgrp()
+
+    def _popen( self, cmd, sudo=True, tt=True, **params):
+        """Spawn a process on a remote node
+            cmd: remote command to run (list)
+            **params: parameters to Popen()
+            returns: Popen() object"""
+        if type( cmd ) is str:
+            cmd = cmd.split()
+        if self.isRemote:
+            if sudo:
+                cmd = [ 'sudo', '-E' ] + cmd
+            if tt:
+                cmd = self.sshcmd + cmd
+            else:
+                # Hack: remove -tt
+                sshcmd = list( self.sshcmd )
+                sshcmd.remove( '-tt' )
+                cmd = sshcmd + cmd
+        else:
+            if self.user and not sudo:
+                # Drop privileges
+                cmd = [ 'sudo', '-E', '-u', self.user ] + cmd
+        params.update( preexec_fn=self._ignoreSignal )
+        debug( '_popen', ' '.join(cmd), params )
+        popen = super( RemoteMixin, self )._popen( cmd, **params )
+        return popen
+
+    def popen( self, *args, **kwargs ):
+        "Override: disable -tt"
+        return super( RemoteMixin, self).popen( *args, tt=False, **kwargs )
+
+    def addIntf( self, *args, **kwargs ):
+        "Override: use RemoteLink.moveIntf"
+        return super( RemoteMixin, self).addIntf( *args,
+                        moveIntfFn=RemoteLink.moveIntf, **kwargs )
+
+    def cleanup( self ):
+        "Help python collect its garbage."
+        # Intfs may end up in root NS
+        for intfName in self.intfNames():
+            if self.name in intfName:
+                self.rcmd( 'ip link del ' + intfName )
+        self.shell = None
+
+class RemoteNode( RemoteMixin, Node ):
+    "A node on a remote server"
+    pass
+
+
+class RemoteHost( RemoteNode ):
+    "A RemoteHost is simply a RemoteNode"
+    pass
+
+
+class RemoteOVSSwitch( RemoteMixin, OVSSwitch ):
+    "Remote instance of Open vSwitch"
+    OVSVersions = {}
+    def isOldOVS( self ):
+        "Is remote switch using an old OVS version?"
+        cls = type( self )
+        if self.server not in cls.OVSVersions:
+            vers = self.cmd( 'ovs-vsctl --version' )
+            cls.OVSVersions[ self.server ] = re.findall( '\d+\.\d+', vers )[ 0 ]
+        return ( StrictVersion( cls.OVSVersions[ self.server ] ) <
+                StrictVersion( '1.10' ) )
+
+
+
+class RemoteLink( Link ):
+
+    "A RemoteLink is a link between nodes which may be on different servers"
+
+    def __init__( self, node1, node2, **kwargs ):
+        """Initialize a RemoteLink
+           see Link() for parameters"""
+        # Create links on remote node
+        self.node1 = node1
+        self.node2 = node2
+        self.tunnel = None
+        kwargs.setdefault( 'params1', {} )
+        kwargs.setdefault( 'params2', {} )
+        Link.__init__( self, node1, node2, **kwargs )
+
+    def stop( self ):
+        "Stop this link"
+        if self.tunnel:
+            self.tunnel.terminate()
+        self.tunnel = None
+
+    def makeIntfPair( self, intfname1, intfname2, addr1=None, addr2=None ):
+        """Create pair of interfaces
+            intfname1: name of interface 1
+            intfname2: name of interface 2
+            (override this method [and possibly delete()]
+            to change link type)"""
+        node1, node2 = self.node1, self.node2
+        server1 = getattr( node1, 'server', 'localhost' )
+        server2 = getattr( node2, 'server', 'localhost' )
+        if server1 == 'localhost' and server2 == 'localhost':
+            # Local link
+            return makeIntfPair( intfname1, intfname2, addr1, addr2 )
+        elif server1 == server2:
+            # Remote link on same remote server
+            return makeIntfPair( intfname1, intfname2, addr1, addr2,
+                                 run=node1.rcmd )
+        # Otherwise, make a tunnel
+        self.tunnel = self.makeTunnel( node1, node2, intfname1, intfname2, addr1, addr2 )
+        return self.tunnel
+
+    @staticmethod
+    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
+            printError: if true, print error"""
+        intf = str( intf )
+        cmd = 'ip link set %s netns %s' % ( intf, node.pid )
+        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 != '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 )
+        # 1. Create tap interfaces
+        for node in node1, node2:
+            # For now we are hard-wiring tap9, which we will rename
+            node.rcmd( 'ip link delete tap9', stderr=PIPE )
+            cmd = 'ip tuntap add dev tap9 mode tap user ' + node.user
+            node.rcmd( cmd )
+            links = node.rcmd( 'ip link show' )
+            # print 'after add, links =', links
+            assert 'tap9' in links
+        # 2. Create ssh tunnel between tap interfaces
+        # -n: close stdin
+        dest = '%s@%s' % ( node2.user, node2.serverIP )
+        cmd = [ 'ssh', '-n', '-o', 'Tunnel=Ethernet', '-w', '9:9',
+                dest, 'echo @' ]
+        self.cmd = cmd
+        tunnel = node1.rpopen( cmd, sudo=False )
+        # When we receive the character '@', it means that our
+        # tunnel should be set up
+        debug( 'Waiting for tunnel to come up...\n' )
+        ch = tunnel.stdout.read( 1 )
+        if ch != '@':
+            error( 'makeTunnel:\n',
+                   'Tunnel setup failed for',
+                   '%s:%s' % ( node1, node1.dest ), 'to', 
+                   '%s:%s\n' % ( node2, node2.dest ),
+                  'command was:', cmd, '\n' )
+            tunnel.terminate()
+            tunnel.wait()
+            error( ch + tunnel.stdout.read() )
+            error( tunnel.stderr.read() )
+            exit( 1 )
+        # 3. Move interfaces if necessary
+        for node in node1, node2:
+            if node.inNamespace:
+                retry( 3, .01, RemoteLink.moveIntf, 'tap9', node )
+        # 4. Rename tap interfaces to desired names
+        for node, intf, addr in ( ( node1, intfname1, addr1 ),
+                            ( node2, intfname2, addr2 ) ):
+            if not addr:
+                node.cmd( 'ip link set tap9 name', intf )
+            else:
+                node.cmd( 'ip link set tap9 name', intf, 'address', addr )
+        for node, intf in ( ( node1, intfname1 ), ( node2, intfname2 ) ):
+            assert intf in node.cmd( 'ip link show' )
+        return tunnel
+
+    def status( self ):
+        "Detailed representation of link"
+        if self.tunnel:
+            if self.tunnel.poll() is not None:
+                status = "Tunnel EXITED %s" % self.tunnel.returncode
+            else:
+                status = "Tunnel Running (%s: %s)" % (
+                    self.tunnel.pid, self.cmd )
+        else:
+            status = "OK"
+        result = "%s %s" % ( Link.status( self ), status )
+        return result
+
+
+# Some simple placement algorithms for MininetCluster
+
+class Placer( object ):
+    "Node placement algorithm for MininetCluster"
+    
+    def __init__( self, servers=None, nodes=None, hosts=None,
+                 switches=None, controllers=None, links=None ):
+        """Initialize placement object
+           servers: list of servers
+           nodes: list of all nodes
+           hosts: list of hosts
+           switches: list of switches
+           controllers: list of controllers
+           links: list of links
+           (all arguments are optional)
+           returns: server"""
+        self.servers = servers or []
+        self.nodes = nodes or []
+        self.hosts = hosts or []
+        self.switches = switches or []
+        self.controllers = controllers or []
+        self.links = links or []
+
+    def place( self, node ):
+        "Return server for a given node"
+        # Default placement: run locally
+        return None
+
+
+class RandomPlacer( Placer ):
+    "Random placement"
+    def place( self, nodename ):
+        """Random placement function
+            nodename: node name"""
+        # This may be slow with lots of servers
+        return self.servers[ randrange( 0, len( self.servers ) ) ]
+
+
+class RoundRobinPlacer( Placer ):
+    """Round-robin placement
+       Note this will usually result in cross-server links between
+       hosts and switches"""
+    
+    def __init__( self, *args, **kwargs ):
+        Placer.__init__( self, *args, **kwargs )
+        self.next = 0
+
+    def place( self, nodename ):
+        """Round-robin placement function
+            nodename: node name"""
+        # This may be slow with lots of servers
+        server = self.servers[ self.next ]
+        self.next = ( self.next + 1 ) % len( self.servers )
+        return server
+
+
+class SwitchBinPlacer( Placer ):
+    """Place switches (and controllers) into evenly-sized bins,
+       and attempt to co-locate hosts and switches"""
+
+    def __init__( self, *args, **kwargs ):
+        Placer.__init__( self, *args, **kwargs )
+        # Easy lookup for servers and node sets
+        self.servdict = dict( enumerate( self.servers ) )
+        self.hset = frozenset( self.hosts )
+        self.sset = frozenset( self.switches )
+        self.cset = frozenset( self.controllers )
+        # Server and switch placement indices
+        self.placement =  self.calculatePlacement()
+
+    @staticmethod
+    def bin( nodes, servers ):
+        "Distribute nodes evenly over servers"
+        # Calculate base bin size
+        nlen = len( nodes )
+        slen = len( servers )
+        # Basic bin size
+        quotient = int( nlen / slen )
+        binsizes = { server: quotient for server in servers }
+        # Distribute remainder
+        remainder = nlen % slen
+        for server in servers[ 0 : remainder ]:
+            binsizes[ server ] += 1
+        # Create binsize[ server ] tickets for each server
+        tickets = sum( [ binsizes[ server ] * [ server ]
+                         for server in servers ], [] )
+        # And assign one ticket to each node
+        return { node: ticket for node, ticket in zip( nodes, tickets ) }
+
+    def calculatePlacement( self ):
+        "Pre-calculate node placement"
+        placement = {}
+        # Create host-switch connectivity map,
+        # associating host with last switch that it's
+        # connected to
+        switchFor = {}
+        for src, dst in self.links:
+            if src in self.hset and dst in self.sset:
+                switchFor[ src ] = dst
+            if dst in self.hset and src in self.sset:
+                switchFor[ dst ] = src
+        # Place switches
+        placement = self.bin( self.switches, self.servers )
+        # Place controllers and merge into placement dict
+        placement.update( self.bin( self.controllers, self.servers ) )
+        # Co-locate hosts with their switches
+        for h in self.hosts:
+            if h in placement:
+                # Host is already placed - leave it there
+                continue
+            if h in switchFor:
+                placement[ h ] = placement[ switchFor[ h ] ]
+            else:
+                raise Exception(
+                        "SwitchBinPlacer: cannot place isolated host " + h )
+        return placement
+
+    def place( self, node ):
+        """Simple placement algorithm:
+           place switches into evenly sized bins,
+           and place hosts near their switches"""
+        return self.placement[ node ]
+
+
+class HostSwitchBinPlacer( Placer ):
+    """Place switches *and hosts* into evenly-sized bins
+       Note that this will usually result in cross-server
+       links between hosts and switches"""
+
+    def __init__( self, *args, **kwargs ):
+        Placer.__init__( self, *args, **kwargs )
+        # Calculate bin sizes
+        scount = len( self.servers )
+        self.hbin = max( int( len( self.hosts ) / scount ), 1 )
+        self.sbin = max( int( len( self.switches ) / scount ), 1 )
+        self.cbin = max( int( len( self.controllers ) / scount ) , 1 )
+        info( 'scount:', scount )
+        info( 'bins:', self.hbin, self.sbin, self.cbin, '\n' )
+        self.servdict = dict( enumerate( self.servers ) )
+        self.hset = frozenset( self.hosts )
+        self.sset = frozenset( self.switches )
+        self.cset = frozenset( self.controllers )
+        self.hind, self.sind, self.cind = 0, 0, 0
+    
+    def place( self, nodename ):
+        """Simple placement algorithm:
+            place nodes into evenly sized bins"""
+        # Place nodes into bins
+        if nodename in self.hset:
+            server = self.servdict[ self.hind / self.hbin ]
+            self.hind += 1
+        elif nodename in self.sset:
+            server = self.servdict[ self.sind / self.sbin ]
+            self.sind += 1
+        elif nodename in self.cset:
+            server = self.servdict[ self.cind / self.cbin ]
+            self.cind += 1
+        else:
+            info( 'warning: unknown node', nodename )
+            server = self.servdict[ 0 ]
+        return server
+
+
+
+# The MininetCluster class is not strictly necessary.
+# However, it has several purposes:
+# 1. To set up ssh connection sharing/multiplexing
+# 2. To pre-flight the system so that everything is more likely to work
+# 3. To allow connection/connectivity monitoring
+# 4. To support pluggable placement algorithms
+
+class MininetCluster( Mininet ):
+
+    "Cluster-enhanced version of Mininet class"
+
+    # Default ssh command
+    # BatchMode yes: don't ask for password
+    # ForwardAgent yes: forward authentication credentials
+    sshcmd = [ 'ssh', '-o', 'BatchMode=yes', '-o', 'ForwardAgent=yes' ]
+
+    def __init__( self, *args, **kwargs ):
+        """servers: a list of servers to use (note: include
+           localhost or None to use local system as well)
+           user: user name for server ssh
+           placement: Placer() subclass"""
+        params = { 'host': RemoteHost,
+                   'switch': RemoteOVSSwitch,
+                   'link': RemoteLink,
+                   'precheck': True }
+        params.update( kwargs )
+        servers = params.pop( 'servers', [ 'localhost' ] )
+        servers = [ s if s else 'localhost' for s in servers ]
+        self.servers = servers
+        self.serverIP = params.pop( 'serverIP', {} )
+        if not self.serverIP:
+            self.serverIP = { server: RemoteMixin.findServerIP( server )
+                              for server in self.servers }
+        self.user = params.pop( 'user', RemoteMixin.findUser() )
+        if params.pop( 'precheck' ):
+            self.precheck()
+        self.connections = {}
+        self.placement = params.pop( 'placement', SwitchBinPlacer )
+        # Make sure control directory exists
+        self.cdir = os.environ[ 'HOME' ] + '/.ssh/mn'
+        errRun( [ 'mkdir', '-p', self.cdir ] )
+        Mininet.__init__( self, *args, **params )
+
+    def popen( self, cmd ):
+        "Popen() for server connections"
+        old = signal( SIGINT, SIG_IGN )
+        conn = Popen( cmd, stdin=PIPE, stdout=PIPE, close_fds=True )
+        signal( SIGINT, old )
+        return conn
+
+    def baddLink( self, *args, **kwargs ):
+        "break addlink for testing"
+        pass
+
+    def precheck( self ):
+        """Pre-check to make sure connection works and that
+           we can call sudo without a password"""
+        result = 0
+        info( '*** Checking servers\n' )
+        for server in self.servers:
+            ip = self.serverIP[ server ]
+            if not server or server == 'localhost':
+                 continue
+            info( server, '' )
+            dest = '%s@%s' % ( self.user, ip )
+            cmd = [ 'sudo', '-E', '-u', self.user ]
+            cmd += self.sshcmd + [ '-n', dest, 'sudo true' ]
+            debug( ' '.join( cmd ), '\n' )
+            out, err, code = errRun( cmd )
+            if code != 0:
+                error( '\nstartConnection: server connection check failed '
+                       'to %s using command:\n%s\n'
+                        % ( server, ' '.join( cmd ) ) )
+            result |= code
+        if result:
+            error( '*** Server precheck failed.\n'
+                   '*** Make sure that the above ssh command works correctly.\n'
+                   '*** You may also need to run mn -c on all nodes, and/or\n'
+                   '*** use sudo -E.\n' )
+            exit( 1 )
+        info( '\n' )
+
+    def modifiedaddHost( self, *args, **kwargs ):
+        "Slightly modify addHost"
+        kwargs[ 'splitInit' ] = True
+        return Mininet.addHost( *args, **kwargs )
+
+
+    def placeNodes( self ):
+        """Place nodes on servers (if they don't have a server), and
+           start shell processes"""
+        if not self.servers or not self.topo:
+            # No shirt, no shoes, no service
+            return
+        nodes = self.topo.nodes()
+        placer = self.placement( servers=self.servers,
+                                 nodes=self.topo.nodes(),
+                                 hosts=self.topo.hosts(),
+                                 switches=self.topo.switches(),
+                                 links=self.topo.links() )
+        for node in nodes:
+            config = self.topo.nodeInfo( node )
+            # keep local server name consistent accross nodes
+            if 'server' in config.keys() and config[ 'server' ] == None:
+                config[ 'server' ] = 'localhost'
+            server = config.setdefault( 'server', placer.place( node ) )
+            if server:
+                config.setdefault( 'serverIP', self.serverIP[ server ] )
+            info( '%s:%s ' % ( node, server ) )
+            key = ( None, server )
+            _dest, cfile, _conn = self.connections.get(
+                        key, ( None, None, None ) )
+            if cfile:
+                config.setdefault( 'controlPath', cfile )
+
+    def addController( self, *args, **kwargs ):
+        "Patch to update IP address to global IP address"
+        controller = Mininet.addController( self, *args, **kwargs )
+        # 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 ):
+        "Start network"
+        info( '*** Placing nodes\n' )
+        self.placeNodes()
+        info( '\n' )
+        Mininet.buildFromTopo( self, *args, **kwargs )
+
+
+def testNsTunnels():
+    "Test tunnels between nodes in namespaces"
+    net = Mininet( host=RemoteHost, link=RemoteLink )
+    h1 = net.addHost( 'h1' )
+    h2 = net.addHost( 'h2', server='ubuntu2' )
+    net.addLink( h1, h2 )
+    net.start()
+    net.pingAll()
+    net.stop()
+
+# Manual topology creation with net.add*()
+#
+# This shows how node options may be used to manage
+# cluster placement using the net.add*() API
+
+def testRemoteNet( remote='ubuntu2' ):
+    "Test remote Node classes"
+    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()
+    print "*** Creating local h1"
+    h1 = net.addHost( 'h1' )
+    print "*** Creating remote h2"
+    h2 = net.addHost( 'h2', server=remote )
+    print "*** Creating local s1"
+    s1 = net.addSwitch( 's1' )
+    print "*** Creating remote s2"
+    s2 = net.addSwitch( 's2', server=remote )
+    print "*** Adding links"
+    net.addLink( h1, s1 )
+    net.addLink( s1, s2 )
+    net.addLink( h2, s2 )
+    net.start()
+    print 'Mininet is running on', quietRun( 'hostname' ).strip()
+    for node in c0, h1, h2, s1, s2:
+        print 'Node', node, 'is running on', node.cmd( 'hostname' ).strip()
+    net.pingAll()
+    CLI( net )
+    net.stop()
+
+
+# High-level/Topo API example
+#
+# This shows how existing Mininet topologies may be used in cluster
+# mode by creating node placement functions and a controller which
+# can be accessed remotely. This implements a very compatible version
+# of cluster edition with a minimum of code!
+
+remoteHosts = [ 'h2' ]
+remoteSwitches = [ 's2' ]
+remoteServer = 'ubuntu2'
+
+def HostPlacer( name, *args, **params ):
+    "Custom Host() constructor which places hosts on servers"
+    if name in remoteHosts:
+        return RemoteHost( name, *args, server=remoteServer, **params )
+    else:
+        return Host( name, *args, **params )
+
+def SwitchPlacer( name, *args, **params ):
+    "Custom Switch() constructor which places switches on servers"
+    if name in remoteSwitches:
+        return RemoteOVSSwitch( name, *args, server=remoteServer, **params )
+    else:
+        return RemoteOVSSwitch( name, *args, **params )
+
+def ClusterController( *args, **kwargs):
+    "Custom Controller() constructor which updates its eth0 IP address"
+    controller = Controller( *args, **kwargs )
+    # Find out its IP address so that cluster switches can connect
+    Intf( 'eth0', node=controller ).updateIP()
+    return controller
+
+def testRemoteTopo():
+    "Test remote Node classes using Mininet()/Topo() API"
+    topo = LinearTopo( 2 )
+    net = Mininet( topo=topo, host=HostPlacer, switch=SwitchPlacer,
+                  link=RemoteLink, controller=ClusterController )
+    net.start()
+    net.pingAll()
+    net.stop()
+
+# Need to test backwards placement, where each host is on
+# a server other than its switch!! But seriously we could just
+# do random switch placement rather than completely random
+# host placement.
+
+def testRemoteSwitches():
+    "Test with local hosts and remote switches"
+    servers = [ 'localhost', 'ubuntu2']
+    topo = TreeTopo( depth=4, fanout=2 )
+    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.
+
+# The MininetCluster() class integrates pluggable placement
+# functions, for maximum ease of use. MininetCluster() also
+# pre-flights and multiplexes server connections.
+
+def testMininetCluster():
+    "Test MininetCluster()"
+    servers = [ 'localhost', 'ubuntu2' ]
+    topo = TreeTopo( depth=3, fanout=3 )
+    net = MininetCluster( topo=topo, servers=servers,
+                          placement=SwitchBinPlacer )
+    net.start()
+    net.pingAll()
+    net.stop()
+
+def signalTest():
+    "Make sure hosts are robust to signals"
+    h = RemoteHost( 'h0', server='ubuntu1' )
+    h.shell.send_signal( SIGINT )
+    h.shell.poll()
+    if h.shell.returncode is None:
+        print 'OK: ', h, 'has not exited'
+    else:
+        print 'FAILURE:', h, 'exited with code', h.shell.returncode
+    h.stop()
+
+if __name__ == '__main__':
+    setLogLevel( 'info' )
+    # testRemoteTopo()
+    # testRemoteNet()
+    # testMininetCluster()
+    # testRemoteSwitches()
+    signalTest()
@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+
+'''
+A sanity check for cluster edition
+'''
+
+from mininet.examples.cluster import MininetCluster
+from mininet.log import setLogLevel
+from mininet.examples.clustercli import ClusterCLI as CLI
+from mininet.topo import SingleSwitchTopo
+
+def clusterSanity():
+    "Sanity check for cluster mode"
+    topo = SingleSwitchTopo()
+    net = MininetCluster( topo=topo ) 
+    net.start()
+    CLI( net )
+    net.stop()
+
+if __name__  == '__main__':
+    setLogLevel( 'info' )
+    clusterSanity()
@@ -0,0 +1,93 @@
+#!/usr/bin/python
+
+"CLI for Mininet Cluster Edition prototype demo"
+
+from mininet.cli import CLI
+from mininet.log import output, error
+
+nx, graphviz_layout, plt = None, None, None  # Will be imported on demand
+
+
+class ClusterCLI( CLI ):
+    "CLI with additional commands for Cluster Edition demo"
+
+    @staticmethod
+    def colorsFor( seq ):
+        "Return a list of background colors for a sequence"
+        colors = [ 'red', 'lightgreen', 'cyan', 'yellow', 'orange',
+                  'magenta', 'pink', 'grey', 'brown',
+                  'white' ]
+        slen, clen = len( seq ), len( colors )
+        reps = max( 1, slen / clen )
+        colors = colors * reps
+        colors = colors[ 0 : slen ]
+        return colors
+    
+    def do_plot( self, line ):
+        "Plot topology colored by node placement"
+        # Import networkx if needed
+        global nx, plt
+        if not nx:
+            try:
+                import networkx as nx
+                import matplotlib.pyplot as plt
+                import pygraphviz
+                assert pygraphviz  # silence pyflakes
+            except:
+                error( 'plot requires networkx, matplotlib and pygraphviz - '
+                       'please install them and try again\n' )
+                return
+        # Make a networkx Graph
+        g = nx.Graph()
+        mn = self.mn
+        servers, hosts, switches = mn.servers, mn.hosts, mn.switches
+        nodes = hosts + switches
+        g.add_nodes_from( nodes )
+        links = [ ( link.intf1.node, link.intf2.node )
+                  for link in self.mn.links ]
+        g.add_edges_from( links )
+        # Pick some shapes and colors
+        # shapes = hlen * [ 's' ] + slen * [ 'o' ]
+        color = dict( zip( servers, self.colorsFor( servers ) ) )
+        # Plot it!
+        pos = nx.graphviz_layout( g )
+        opts = { 'ax': None, 'font_weight': 'bold',
+		 'width': 2, 'edge_color': 'darkblue' }
+        hcolors = [ color[ getattr( h, 'server', 'localhost' ) ] for h in hosts ]
+        scolors = [ color[ getattr( s, 'server', 'localhost' ) ] for s in switches ]
+        nx.draw_networkx( g, pos=pos, nodelist=hosts, node_size=800, label='host',
+                          node_color=hcolors, node_shape='s', **opts )
+        nx.draw_networkx( g, pos=pos, nodelist=switches, node_size=1000,
+                          node_color=scolors, node_shape='o', **opts )
+        # Get rid of axes, add title, and show
+        fig = plt.gcf()
+        ax = plt.gca()
+        ax.get_xaxis().set_visible( False )
+        ax.get_yaxis().set_visible( False )
+        fig.canvas.set_window_title( 'Mininet')
+        plt.title( 'Node Placement', fontweight='bold' )
+        plt.show()
+
+    def do_status( self, line ):
+        "Report on node shell status"
+        nodes = self.mn.hosts + self.mn.switches
+        for node in nodes:
+            node.shell.poll()
+        exited = [ node for node in nodes
+                   if node.shell.returncode is not None ]
+        if exited:
+            for node in exited:
+                output( '%s has exited with code %d\n'
+                        % ( node, node.shell.returncode ) )
+        else:
+            output( 'All nodes are still running.\n' )
+
+
+    def do_placement( self, line ):
+        "Describe node placement"
+        mn = self.mn
+        nodes = mn.hosts + mn.switches + mn.controllers
+        for server in mn.servers:
+            names = [ n.name for n in nodes if hasattr( n, 'server' )
+                      and n.server == server ]
+            output( '%s: %s\n' % ( server, ' '.join( names ) ) )
@@ -0,0 +1,23 @@
+#!/usr/bin/python
+
+"clusterdemo.py: demo of Mininet Cluster Edition prototype"
+
+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
+
+def demo():
+    "Simple Demo of Cluster Mode"
+    servers = [ 'localhost', 'ubuntu2', 'ubuntu3' ]
+    topo = TreeTopo( depth=3, fanout=3 )
+    net = MininetCluster( topo=topo, servers=servers,
+                          placement=SwitchBinPlacer )
+    net.start()
+    CLI( net )
+    net.stop()
+
+if __name__ == '__main__':
+    setLogLevel( 'info' )
+    demo()
+
@@ -315,11 +315,19 @@ class ConsoleApp( Frame ):

    def updateGraph( self, _console, output ):
        "Update our graph."
-        m = re.search( r'(\d+) Mbits/sec', output )
+        m = re.search( r'(\d+.?\d*) ([KMG]?bits)/sec', output )
        if not m:
            return
+        val, units = float( m.group( 1 ) ), m.group( 2 )
+        #convert to Gbps
+        if units[0] == 'M':
+            val *= 10 ** -3
+        elif units[0] == 'K':
+            val *= 10 ** -6
+        elif units[0] == 'b':
+            val *= 10 ** -9
        self.updates += 1
-        self.bw += .001 * float( m.group( 1 ) )
+        self.bw +=  val
        if self.updates >= self.hostCount:
            self.graph.addBar( self.bw )
            self.bw = 0
@@ -410,7 +418,9 @@ class ConsoleApp( Frame ):
        count = len( consoles )
        self.setOutputHook( self.updateGraph )
        for console in consoles:
-            console.node.cmd( 'iperf -sD' )
+            # Sometimes iperf -sD doesn't return,
+            # so we run it in the background instead
+            console.node.cmd( 'iperf -s &' )
        i = 0
        for console in consoles:
            i = ( i + 1 ) % count
@@ -1,64 +1,36 @@
 #!/usr/bin/python

 """
-This example creates a multi-controller network from
-semi-scratch; note a topo object could also be used and
-would be passed into the Mininet() constructor.
+Create a network where different switches are connected to
+different controllers, by creating a custom Switch() subclass.
 """

 from mininet.net import Mininet
-from mininet.node import Controller, OVSKernelSwitch
-from mininet.cli import CLI
+from mininet.node import OVSSwitch, Controller, RemoteController
+from mininet.topolib import TreeTopo
 from mininet.log import setLogLevel
+from mininet.cli import CLI

-Switch = OVSKernelSwitch
+setLogLevel( 'info' )

-def addHost( net, N ):
-    "Create host hN and add to net."
-    name = 'h%d' % N
-    ip = '10.0.0.%d' % N
-    return net.addHost( name, ip=ip )
+# Two local and one "external" controller (which is actually c0)
+# 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' )

-def multiControllerNet():
-    "Create a network with multiple controllers."
+cmap = { 's1': c0, 's2': c1, 's3': c2 }

-    net = Mininet( controller=Controller, switch=Switch)
+class MultiSwitch( OVSSwitch ):
+    "Custom Switch() subclass that connects to different controllers"
+    def start( self, controllers ):
+        return OVSSwitch.start( self, [ cmap[ self.name ] ] )

-    print "*** Creating controllers"
-    c1 = net.addController( 'c1', port=6633 )
-    c2 = net.addController( 'c2', port=6634 )
-
-    print "*** Creating switches"
-    s1 = net.addSwitch( 's1' )
-    s2 = net.addSwitch( 's2' )
-
-    print "*** Creating hosts"
-    hosts1 = [ addHost( net, n ) for n in 3, 4 ]
-    hosts2 = [ addHost( net, n ) for n in 5, 6 ]
-
-    print "*** Creating links"
-    for h in hosts1:
-        s1.linkTo( h )
-    for h in hosts2:
-        s2.linkTo( h )
-    s1.linkTo( s2 )
-
-    print "*** Starting network"
-    net.build()
-    c1.start()
-    c2.start()
-    s1.start( [ c1 ] )
-    s2.start( [ c2 ] )
-
-    print "*** Testing network"
-    net.pingAll()
-
-    print "*** Running CLI"
-    CLI( net )
-
-    print "*** Stopping network"
-    net.stop()
-
-if __name__ == '__main__':
-    setLogLevel( 'info' )  # for CLI output
-    multiControllerNet()
+topo = TreeTopo( depth=2, fanout=2 )
+net = Mininet( topo=topo, switch=MultiSwitch, build=False )
+for c in [ c0, c1 ]:
+    net.addController(c)
+net.build()
+net.start()
+CLI( net )
+net.stop()
@@ -0,0 +1,61 @@
+#!/usr/bin/python
+
+"""
+This example creates a multi-controller network from semi-scratch by
+using the net.add*() API and manually starting the switches and controllers.
+
+This is the "mid-level" API, which is an alternative to the "high-level"
+Topo() API which supports parametrized topology classes.
+
+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
+
+def multiControllerNet():
+    "Create a network from semi-scratch with multiple controllers."
+
+    net = Mininet( controller=Controller, switch=OVSSwitch )
+
+    print "*** Creating (reference) controllers"
+    c1 = net.addController( 'c1', port=6633 )
+    c2 = net.addController( 'c2', port=6634 )
+
+    print "*** Creating switches"
+    s1 = net.addSwitch( 's1' )
+    s2 = net.addSwitch( 's2' )
+
+    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 ]
+
+    print "*** Creating links"
+    for h in hosts1:
+        net.addLink( s1, h )
+    for h in hosts2:
+        net.addLink( s2, h )
+    net.addLink( s1, s2 )
+
+    print "*** Starting network"
+    net.build()
+    c1.start()
+    c2.start()
+    s1.start( [ c1 ] )
+    s2.start( [ c2 ] )
+
+    print "*** Testing network"
+    net.pingAll()
+
+    print "*** Running CLI"
+    CLI( net )
+
+    print "*** Stopping network"
+    net.stop()
+
+if __name__ == '__main__':
+    setLogLevel( 'info' )  # for CLI output
+    multiControllerNet()
@@ -0,0 +1,151 @@
+#!/usr/bin/python
+
+"""
+controlnet.py: Mininet with a custom control network
+
+We create two Mininet() networks, a control network
+and a data network, running four DataControllers on the
+control network to control the data network.
+
+Since we're using UserSwitch on the data network,
+it should correctly fail over to a backup controller.
+
+We also use a Mininet Facade to talk to both the
+control and data networks from a single CLI.
+"""
+
+from functools import partial
+
+from mininet.net import Mininet
+from mininet.node import Controller, UserSwitch
+from mininet.cli import CLI
+from mininet.topo import Topo
+from mininet.topolib import TreeTopo
+from mininet.log import setLogLevel, info
+
+# Some minor hacks
+
+class DataController( Controller ):
+    """Data Network Controller.
+       patched to avoid checkListening error"""
+    def checkListening( self ):
+        "Ignore spurious error"
+        pass
+
+class MininetFacade( object ):
+    """Mininet object facade that allows a single CLI to
+       talk to one or more networks"""
+    
+    def __init__( self, net, *args, **kwargs ):
+        """Create MininetFacade object.
+           net: Primary Mininet object
+           args: unnamed networks passed as arguments
+           kwargs: named networks passed as arguments"""
+        self.net = net
+        self.nets = [ net ] + list( args ) + kwargs.values()
+        self.nameToNet = kwargs
+        self.nameToNet['net'] = net
+
+    def __getattr__( self, name ):
+        "returns attribute from Primary Mininet object"
+        return getattr( self.net, name )
+
+    def __getitem__( self, key ):
+        "returns primary/named networks or node from any net"
+        #search kwargs for net named key
+        if key in self.nameToNet:
+            return self.nameToNet[ key ]
+        #search each net for node named key
+        for net in self.nets:
+            if key in net:
+                return net[ key ]
+
+    def __iter__( self ):
+        "Iterate through all nodes in all Mininet objects"
+        for net in self.nets:
+            for node in net:
+                yield node
+
+    def __len__( self ):
+        "returns aggregate number of nodes in all nets"
+        count = 0
+        for net in self.nets:
+            count += len(net)
+        return count
+
+    def __contains__( self, key ):
+        "returns True if node is a member of any net"
+        return key in self.keys()
+
+    def keys( self ):
+        "returns a list of all node names in all networks"
+        return list( self )
+
+    def values( self ):
+        "returns a list of all nodes in all networks"
+        return [ self[ key ] for key in self ]
+
+    def items( self ):
+        "returns (key,value) tuple list for every node in all networks"
+        return zip( self.keys(), self.values() )
+
+# A real control network!
+
+class ControlNetwork( Topo ):
+    "Control Network Topology"
+    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
+        for i in range( 0, n ):
+            c = self.addHost( 'c%s' % i, cls=dataController,
+                              inNamespace=True )
+            self.addLink( c, cs0 )
+        # Connect switch to root namespace so that data network
+        # switches will be able to talk to us
+        root = self.addHost( 'root', inNamespace=False )
+        self.addLink( root, cs0 )
+
+
+# Make it Happen!!
+
+def run():
+    "Create control and data networks, and invoke the CLI"
+    
+    info( '* Creating Control Network\n' )
+    ctopo = ControlNetwork( n=4, dataController=DataController )
+    cnet = Mininet( topo=ctopo, ipBase='192.168.123.0/24', controller=None )
+    info( '* Adding Control Network Controller\n')
+    cnet.addController( 'cc0', controller=Controller )
+    info( '* Starting Control Network\n')
+    cnet.start()
+
+    info( '* Creating Data Network\n' )
+    topo = TreeTopo( depth=2, fanout=2 )
+    # UserSwitch so we can easily test failover
+    sw = partial( UserSwitch, opts='--inactivity-probe=1 --max-backoff=1' )
+    net = Mininet( topo=topo, switch=sw, controller=None )
+    info( '* Adding Controllers to Data Network\n' )
+    for host in cnet.hosts:
+        if isinstance(host, Controller):
+            net.addController( host )
+    info( '* Starting Data Network\n')
+    net.start()
+
+    mn = MininetFacade( net, cnet=cnet )
+
+    CLI( mn )
+
+    info( '* Stopping Data Network\n' )
+    net.stop()
+
+    info( '* Stopping Control Network\n' )
+    cnet.stop()
+
+
+if __name__ == '__main__':
+    setLogLevel( 'info' )
+    run()
@@ -7,21 +7,8 @@ cpu.py: test iperf bandwidth for varying cpu limits
 from mininet.net import Mininet
 from mininet.node import CPULimitedHost
 from mininet.topolib import TreeTopo
-from mininet.util import custom
-from mininet.log import setLogLevel, output
-
-from time import sleep
-
-def waitListening(client, server, port):
-    "Wait until server is listening on port"
-    if not client.cmd('which telnet'):
-        raise Exception('Could not find telnet')
-    cmd = ('sh -c "echo A | telnet -e A %s %s"' %
-           (server.IP(), port))
-    while 'Connected' not in client.cmd(cmd):
-        output('waiting for', server,
-               'to listen on port', port, '\n')
-        sleep(.5)
+from mininet.util import custom, waitListening
+from mininet.log import setLogLevel, info


 def bwtest( cpuLimits, period_us=100000, seconds=5 ):
@@ -38,7 +25,11 @@ def bwtest( cpuLimits, period_us=100000, seconds=5 ):
            host = custom( CPULimitedHost, sched=sched,
                           period_us=period_us,
                           cpu=cpu )
-            net = Mininet( topo=topo, host=host )
+            try:
+                net = Mininet( topo=topo, host=host )
+            except:
+                info( '*** Skipping host %s\n' % sched )
+                break
            net.start()
            net.pingAll()
            hosts = [ net.getNodeByName( h ) for h in topo.hosts() ]
@@ -27,8 +27,8 @@ def emptyNet():
    s3 = net.addSwitch( 's3' )

    info( '*** Creating links\n' )
-    h1.linkTo( s3 )
-    h2.linkTo( s3 )
+    net.addLink( h1, s3 )
+    net.addLink( h2, s3 )

    info( '*** Starting network\n')
    net.start()
@@ -5,7 +5,7 @@ This example shows how to add an interface (for example a real
 hardware interface) to a network after the network is created.
 """

-import re
+import re, sys

 from mininet.cli import CLI
 from mininet.log import setLogLevel, info, error
@@ -28,7 +28,10 @@ def checkIntf( intf ):
 if __name__ == '__main__':
    setLogLevel( 'info' )

-    intfName = 'eth1'
+    # try to get hw intf from the command line; by default, use eth1
+    intfName = sys.argv[ 1 ] if len( sys.argv ) > 1 else 'eth1'
+    info( '*** Connecting to hw intf: %s' % intfName )
+
    info( '*** Checking', intfName, '\n' )
    checkIntf( intfName )

@@ -0,0 +1,48 @@
+#!/usr/bin/python
+
+'''
+example of using various TCIntf options.
+reconfigures a single interface using intf.config()
+to use different traffic control commands to test
+bandwidth, loss, and delay
+'''
+
+from mininet.net import Mininet
+from mininet.log import setLogLevel, info
+from mininet.link import TCLink
+
+def intfOptions():
+    "run various traffic control commands on a single interface"
+    net = Mininet( autoStaticArp=True )
+    net.addController( 'c0' )
+    h1 = net.addHost( 'h1' )
+    h2 = net.addHost( 'h2' )
+    s1 = net.addSwitch( 's1' )
+    link1 = net.addLink( h1, s1, cls=TCLink )
+    net.addLink( h2, s1 )
+    net.start()
+    
+    # flush out latency from reactive forwarding delay
+    net.pingAll()
+
+    info( '\n*** Configuring one intf with bandwidth of 5 Mb\n' )
+    link1.intf1.config( bw=5 )
+    info( '\n*** Running iperf to test\n' )
+    net.iperf()
+
+    info( '\n*** Configuring one intf with loss of 50%\n' )
+    link1.intf1.config( loss=50 )
+    info( '\n' )
+    net.iperf( ( h1, h2 ), l4Type='UDP' )
+    
+    info( '\n*** Configuring one intf with delay of 15ms\n' )
+    link1.intf1.config( delay='15ms' )
+    info( '\n*** Run a ping to confirm delay\n' )
+    net.pingPairFull()
+    
+    info( '\n*** Done testing\n' )
+    net.stop()
+
+if __name__ == '__main__':
+    setLogLevel( 'info' )
+    intfOptions()
@@ -8,15 +8,14 @@ from mininet.net import Mininet
 from mininet.link import TCIntf
 from mininet.node import CPULimitedHost
 from mininet.topolib import TreeTopo
-from mininet.util import custom
-from mininet.log import setLogLevel
+from mininet.util import custom, quietRun
+from mininet.log import setLogLevel, info


 def testLinkLimit( net, bw ):
    "Run bandwidth limit test"
-    print '*** Testing network %.2f Mbps bandwidth limit' % bw
-    net.iperf( )
-
+    info( '*** Testing network %.2f Mbps bandwidth limit\n' % bw )
+    net.iperf()

 def limit( bw=10, cpu=.1 ):
    """Example/test of link and CPU bandwidth limits
@@ -25,7 +24,13 @@ def limit( bw=10, cpu=.1 ):
    intf = custom( TCIntf, bw=bw )
    myTopo = TreeTopo( depth=1, fanout=2 )
    for sched in 'rt', 'cfs':
-        print '*** Testing with', sched, 'bandwidth limiting'
+        info( '*** Testing with', sched, 'bandwidth limiting\n' )
+        if sched == 'rt':
+            release = quietRun( 'uname -r' ).strip('\r\n')
+            output = quietRun( 'grep CONFIG_RT_GROUP_SCHED /boot/config-%s' % release )
+            if output == '# CONFIG_RT_GROUP_SCHED is not set\n':
+                info( '*** RT Scheduler is not enabled in your kernel. Skipping this test\n' )
+                continue
        host = custom( CPULimitedHost, sched=sched, cpu=cpu )
        net = Mininet( topo=myTopo, intf=intf, host=host )
        net.start()
@@ -24,10 +24,12 @@ of switches, this example demonstrates:
 """

 from mininet.net import Mininet
-from mininet.node import UserSwitch, OVSKernelSwitch
+from mininet.node import UserSwitch, OVSKernelSwitch, Controller
 from mininet.topo import Topo
 from mininet.log import lg
-from mininet.util import irange
+from mininet.util import irange, quietRun
+from mininet.link import TCLink
+from functools import partial

 import sys
 flush = sys.stdout.flush
@@ -70,13 +72,24 @@ def linearBandwidthTest( lengths ):
    switches = { 'reference user': UserSwitch,
                 'Open vSwitch kernel': OVSKernelSwitch }

+    # UserSwitch is horribly slow with recent kernels.
+    # We can reinstate it once its performance is fixed
+    del switches[ 'reference user' ]
+
    topo = LinearTestTopo( hostCount )

+    # Select TCP Reno
+    output = quietRun( 'sysctl -w net.ipv4.tcp_congestion_control=reno' )
+    assert 'reno' in output
+
    for datapath in switches.keys():
        print "*** testing", datapath, "datapath"
        Switch = switches[ datapath ]
        results[ datapath ] = []
-        net = Mininet( topo=topo, switch=Switch )
+        link = partial( TCLink, delay='1ms' )
+        net = Mininet( topo=topo, switch=Switch,
+                       controller=Controller, waitConnected=True,
+                       link=link )
        net.start()
        print "*** testing basic connectivity"
        for n in lengths:
@@ -84,8 +97,11 @@ def linearBandwidthTest( lengths ):
        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' )
            print "testing", src.name, "<->", dst.name,
-            bandwidth = net.iperf( [ src, dst ] )
+            bandwidth = net.iperf( [ src, dst ], seconds=10 )
            print bandwidth
            flush()
            results[ datapath ] += [ ( n, bandwidth ) ]
@@ -0,0 +1,67 @@
+#!/usr/bin/python
+
+"""
+linuxrouter.py: Example network with Linux IP router
+ 
+This example converts a Node into a router using IP forwarding
+already built into Linux.
+
+The topology contains a router with three IP subnets:
+ - 192.168.1.0/24 (interface IP: 192.168.1.1)
+ - 172.16.0.0/12 (interface IP: 172.16.0.1)
+ - 10.0.0.0/8 (interface IP: 10.0.0.1)
+
+ It also contains three hosts, one in each subnet:
+ - h1 (IP: 192.168.1.100)
+ - h2 (IP: 172.16.0.100)
+ - h3 (IP: 10.0.0.100)
+
+ Routing entries can be added to the routing tables of the 
+ hosts or router using the "ip route add" or "route add" command.
+ See the man pages for more details.
+
+"""
+
+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."
+
+    def config( self, **params ):
+        super( LinuxRouter, self).config( **params )
+        # Enable forwarding on the router
+        self.cmd( 'sysctl net.ipv4.ip_forward=1' )
+
+    def terminate( self ):
+        self.cmd( 'sysctl net.ipv4.ip_forward=0' )
+        super( LinuxRouter, self ).terminate()
+
+
+class NetworkTopo( Topo ):
+    "A simple topology of a router with three subnets (one host in each)."
+
+    def build( self, n=2, h=1, **opts ):
+        router = self.addNode( 'r0', cls=LinuxRouter, ip='192.168.1.1/24' )
+        h1 = self.addHost( 'h1', ip='192.168.1.100/24', defaultRoute='via 192.168.1.1' )
+        h2 = self.addHost( 'h2', ip='172.16.0.100/12', defaultRoute='via 172.16.0.1' )
+        h3 = self.addHost( 'h3', ip='10.0.0.100/8', defaultRoute='via 10.0.0.1' )
+        self.addLink( h1, router, intfName2='r0-eth1', params2={ 'ip' : '192.168.1.1/24' } )
+        self.addLink( h2, router, intfName2='r0-eth2', params2={ 'ip' : '172.16.0.1/12' } )
+        self.addLink( h3, router, intfName2='r0-eth3', params2={ 'ip' : '10.0.0.1/8' } )
+
+def run():
+    topo = NetworkTopo()
+    net = Mininet( topo=topo, controller=None ) # no controller needed
+    net.start()
+    info( '*** Routing Table on Router\n' )
+    print net[ 'r0' ].cmd( 'route' )
+    CLI( net )
+    net.stop()
+
+if __name__ == '__main__':
+    setLogLevel( 'info' )
+    run()
@@ -0,0 +1,134 @@
+#!/usr/bin/python
+
+"""
+Simple example of Mobility with Mininet
+(aka enough rope to hang yourself.)
+
+We move a host from s1 to s2, s2 to s3, and then back to s1.
+
+Gotchas:
+
+The reference controller doesn't support mobility, so we need to
+manually flush the switch flow tables!
+
+Good luck!
+
+to-do:
+
+- think about wifi/hub behavior
+- 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 output, warn
+
+from random import randint
+
+
+class MobilitySwitch( OVSSwitch ):
+    "Switch that can reattach and rename interfaces"
+
+    def delIntf( self, intf ):
+        "Remove (and detach) an interface"
+        port = self.ports[ intf ]
+        del self.ports[ intf ]
+        del self.intfs[ port ]
+        del self.nameToIntf[ intf.name ]
+
+    def addIntf( self, intf, rename=False, **kwargs ):
+        "Add (and reparent) an interface"
+        OVSSwitch.addIntf( self, intf, **kwargs )
+        intf.node = self
+        if rename:
+            self.renameIntf( intf )
+
+    def attach( self, intf ):
+        "Attach an interface and set its port"
+        port = self.ports[ intf ]
+        if port:
+            if self.isOldOVS():
+                self.cmd( 'ovs-vsctl add-port', self, intf )
+            else:
+                self.cmd( 'ovs-vsctl add-port', self, intf,
+                          '-- set Interface', intf,
+                          'ofport_request=%s' % port )
+            self.validatePort( intf )
+
+    def validatePort( self, intf ):
+        "Validate intf's OF port number"
+        ofport = int( self.cmd( 'ovs-vsctl get Interface', intf,
+                              'ofport' ) )
+        if ofport != self.ports[ intf ]:
+            warn( 'WARNING: ofport for', intf, 'is actually', ofport,
+                  '\n' )
+
+    def renameIntf( self, intf, newname='' ):
+        "Rename an interface (to its canonical name)"
+        intf.ifconfig( 'down' )
+        if not newname:
+            newname = '%s-eth%d' % ( self.name, self.ports[ intf ] )
+        intf.cmd( 'ip link set', intf, 'name', newname )
+        del self.nameToIntf[ intf.name ]
+        intf.name = newname
+        self.nameToIntf[ intf.name ] = intf
+        intf.ifconfig( 'up' )
+
+    def moveIntf( self, intf, switch, port=None, rename=True ):
+        "Move one of our interfaces to another switch"
+        self.detach( intf )
+        self.delIntf( intf )
+        switch.addIntf( intf, port=port, rename=rename )
+        switch.attach( intf )
+
+
+def printConnections( switches ):
+    "Compactly print connected nodes to each switch"
+    for sw in switches:
+        output( '%s: ' % sw )
+        for intf in sw.intfList():
+            link = intf.link
+            if link:
+                intf1, intf2 = link.intf1, link.intf2
+                remote = intf1 if intf1.node != sw else intf2
+                output( '%s(%s) ' % ( remote.node, sw.ports[ intf ] ) )
+        output( '\n' )
+
+
+def moveHost( host, oldSwitch, newSwitch, newPort=None ):
+    "Move a host from old switch to new switch"
+    hintf, sintf = host.connectionsTo( oldSwitch )[ 0 ]
+    oldSwitch.moveIntf( sintf, newSwitch, port=newPort )
+    return hintf, sintf
+
+
+def mobilityTest():
+    "A simple test of mobility"
+    print '* Simple mobility test'
+    net = Mininet( topo=LinearTopo( 3 ), switch=MobilitySwitch )
+    print '* Starting network:'
+    net.start()
+    printConnections( net.switches )
+    print '* Testing network'
+    net.pingAll()
+    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 )
+        print '* Moving', h1, 'from', old, 'to', new, 'port', port
+        hintf, sintf = moveHost( h1, old, new, newPort=port )
+        print '*', hintf, 'is now connected to', sintf
+        print '* Clearing out old flows'
+        for sw in net.switches:
+            sw.dpctl( 'del-flows' )
+        print '* New network:'
+        printConnections( net.switches )
+        print '* Testing connectivity:'
+        net.pingAll()
+        old = new
+    net.stop()
+
+if __name__ == '__main__':
+    mobilityTest()
@@ -0,0 +1,35 @@
+#!/usr/bin/python
+
+"""
+This is a simple example that demonstrates multiple links
+between nodes.
+"""
+
+from mininet.cli import CLI
+from mininet.log import setLogLevel
+from mininet.net import Mininet
+from mininet.topo import Topo
+    
+def runMultiLink():
+    
+    topo = simpleMultiLinkTopo( n=2 )
+    net = Mininet( topo=topo )
+    net.start()
+    CLI( net )
+    net.stop()
+
+class simpleMultiLinkTopo( Topo ):
+
+    def __init__( self, n, **kwargs ):
+        Topo.__init__( self, **kwargs )
+
+        h1, h2 = self.addHost( 'h1' ), self.addHost( 'h2' )
+        s1 = self.addSwitch( 's1' )
+        
+        for _ in range( n ):
+            self.addLink( s1, h1 )
+            self.addLink( s1, h2 )
+
+if __name__ == '__main__':
+    setLogLevel( 'info' )
+    runMultiLink()
@@ -23,13 +23,8 @@ def chunks( l, n ):
 def startpings( host, targetips ):
    "Tell host to repeatedly ping targets"

-    targetips.append( '10.0.0.200' )
-
    targetips = ' '.join( targetips )

-    # BL: Not sure why loopback intf isn't up!
-    host.cmd( 'ifconfig lo up' )
-
    # Simple ping loop
    cmd = ( 'while true; do '
            ' for ip in %s; do ' % targetips +
@@ -63,6 +58,8 @@ def multiping( netsize, chunksize, seconds):
    # Start pings
    for subnet in subnets:
        ips = [ host.IP() for host in subnet ]
+        #adding bogus to generate packet loss
+        ips.append( '10.0.0.200' )
        for host in subnet:
            startpings( host, ips )

@@ -22,7 +22,7 @@ if __name__ == '__main__':
    info( "*** Initializing Mininet and kernel modules\n" )
    OVSKernelSwitch.setup()
    info( "*** Creating network\n" )
-    network = Mininet( TreeTopo( depth=2, fanout=2 ), switch=OVSKernelSwitch)
+    network = Mininet( TreeTopo( depth=2, fanout=2 ), switch=OVSKernelSwitch )
    info( "*** Starting network\n" )
    network.start()
    info( "*** Running ping test\n" )
@@ -0,0 +1,112 @@
+#!/usr/bin/python
+
+"""
+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
+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 )
+    # 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()
@@ -0,0 +1,70 @@
+#!/usr/bin/python
+
+"""
+natnet.py: Example network with NATs
+
+
+           h0
+           |
+           s0
+           |
+    ----------------
+    |              |
+   nat1           nat2
+    |              |
+   s1              s2
+    |              |
+   h1              h2 
+
+"""
+
+from mininet.topo import Topo
+from mininet.net import Mininet
+from mininet.nodelib import NAT
+from mininet.log import setLogLevel
+from mininet.cli import CLI
+from mininet.util import irange
+
+class InternetTopo(Topo):
+    "Single switch connected to n hosts."
+    def __init__(self, n=2, h=1, **opts):
+        Topo.__init__(self, **opts)
+
+        # set up inet switch
+        inetSwitch = self.addSwitch('s0')
+        # add inet host
+        inetHost = self.addHost('h0')
+        self.addLink(inetSwitch, inetHost)
+
+        # add local nets
+        for i in irange(1, n):
+            inetIntf = 'nat%d-eth0' % i
+            localIntf = 'nat%d-eth1' % i
+            localIP = '192.168.%d.1' % i
+            localSubnet = '192.168.%d.0/24' % i
+            natParams = { 'ip' : '%s/24' % localIP }
+            # add NAT to topology
+            nat = self.addNode('nat%d' % i, cls=NAT, subnet=localSubnet, 
+                               inetIntf=inetIntf, localIntf=localIntf)
+            switch = self.addSwitch('s%d' % i)
+            # connect NAT to inet and local switches
+            self.addLink(nat, inetSwitch, intfName1=inetIntf)
+            self.addLink(nat, switch, intfName1=localIntf, params1=natParams)
+            # add host and connect to local switch
+            host = self.addHost('h%d' % i, 
+                                ip='192.168.%d.100/24' % i, 
+                                defaultRoute='via %s' % localIP)
+            self.addLink(host, switch)
+
+def run():
+    "Create network and run the CLI"
+    topo = InternetTopo()
+    net = Mininet(topo=topo)
+    net.start()
+    CLI(net)
+    net.stop()
+
+if __name__ == '__main__':
+    setLogLevel('info')
+    run()
+    
@@ -0,0 +1,74 @@
+#!/usr/bin/python
+
+"""
+Create a network with 5 hosts, numbered 1-4 and 9. 
+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
+
+def validatePort( switch, intf ):
+    "Validate intf's OF port number"
+    ofport = int( switch.cmd( 'ovs-vsctl get Interface', intf,
+                          'ofport' ) )
+    if ofport != switch.ports[ intf ]:
+        warn( 'WARNING: ofport for', intf, 'is actually', ofport, '\n' )
+        return 0
+    else:
+        return 1
+
+def net():
+
+    "Create a network with 5 hosts."
+
+    net = Mininet( controller=Controller )
+
+    info( '*** Adding controller\n' )
+    net.addController( 'c0' )
+
+    info( '*** Adding hosts\n' )
+    h1 = net.addHost( 'h1', ip='10.0.0.1' )
+    h2 = net.addHost( 'h2', ip='10.0.0.2' )
+    h3 = net.addHost( 'h3', ip='10.0.0.3' )
+    h4 = net.addHost( 'h4', ip='10.0.0.4' )
+    h5 = net.addHost( 'h5', ip='10.0.0.5' )
+
+    info( '*** Adding switch\n' )
+    s1 = net.addSwitch( 's1' )
+
+    info( '*** Creating links\n' )
+    # host 1-4 connect to ports 1-4 on the switch
+    net.addLink( h1, s1 )
+    net.addLink( h2, s1 )
+    net.addLink( h3, s1 )
+    net.addLink( h4, s1 )
+    net.addLink( h5, s1, port1 = 1, port2 = 9 ) # specify a different port to connect host 5 to on the switch.
+
+    info( '*** Starting network\n' )
+    net.start()
+
+    # print the interfaces and their port numbers
+    info( '\n*** printing and validating the ports running on each interface\n' )
+    for intfs in s1.intfList():
+        if not intfs.name == "lo":
+            info( intfs, ': ', s1.ports[intfs], 
+            '\n' )
+            info ( 'Validating that', intfs, 'is actually on port', s1.ports[intfs], '... ' )
+            if validatePort( s1, intfs ):
+                info( 'Validated.\n' )
+    print '\n'
+        
+    # test the network with pingall
+    net.pingAll()
+    print '\n'
+
+    info( '*** Stopping network' )
+    net.stop()
+
+if __name__ == '__main__':
+    setLogLevel( 'info' )
+    net()
+
@@ -23,7 +23,7 @@ def pmonitorTest( N=3, seconds=10 ):
    endTime = time() + seconds
    for h, line in pmonitor( popens, timeoutms=500 ):
        if h:
-            print '%s: %s' % ( h.name, line ),
+            print '<%s>: %s' % ( h.name, line ),
        if time() >= endTime:
            for p in popens.values():
                p.send_signal( SIGINT )
@@ -31,17 +31,16 @@ class SingleSwitchTopo(Topo):

 def perfTest():
    "Create network and run simple performance test"
-    topo = SingleSwitchTopo(n=4)
-    net = Mininet(topo=topo,
-                  host=CPULimitedHost, link=TCLink)
+    topo = SingleSwitchTopo( n=4 )
+    net = Mininet( topo=topo,
+                  host=CPULimitedHost, link=TCLink,
+                  autoStaticArp=True )
    net.start()
    print "Dumping host connections"
    dumpNodeConnections(net.hosts)
-    print "Testing network connectivity"
-    net.pingAll()
    print "Testing bandwidth between h1 and h4"
    h1, h4 = net.getNodeByName('h1', 'h4')
-    net.iperf((h1, h4))
+    net.iperf( ( h1, h4 ), l4Type='UDP' )
    net.stop()

 if __name__ == '__main__':
@@ -16,43 +16,54 @@ demonstrates:
 - running server processes (sshd in this case) on hosts
 """

+import sys
+
 from mininet.net import Mininet
 from mininet.cli import CLI
 from mininet.log import lg
-from mininet.node import Node, OVSKernelSwitch
+from mininet.node import Node
 from mininet.topolib import TreeTopo
 from mininet.link import Link
+from mininet.util import waitListening

 def TreeNet( depth=1, fanout=2, **kwargs ):
    "Convenience function for creating tree networks."
    topo = TreeTopo( depth, fanout )
    return Mininet( topo, **kwargs )

-def connectToRootNS( network, switch, ip, prefixLen, routes ):
+def connectToRootNS( network, switch, ip, routes ):
    """Connect hosts to root namespace via switch. Starts network.
      network: Mininet() network object
      switch: switch to connect to root namespace
      ip: IP address for root namespace node
-      prefixLen: IP address prefix length (e.g. 8, 16, 24)
      routes: host networks to route to"""
    # Create a node in root namespace and link to switch 0
    root = Node( 'root', inNamespace=False )
    intf = Link( root, switch ).intf1
-    root.setIP( ip, prefixLen, intf )
+    root.setIP( ip, intf=intf )
    # Start network that now includes link to root namespace
    network.start()
    # Add routes from root ns to hosts
    for route in routes:
        root.cmd( 'route add -net ' + route + ' dev ' + str( intf ) )

-def sshd( network, cmd='/usr/sbin/sshd', opts='-D' ):
-    "Start a network, connect it to root ns, and run sshd on all hosts."
-    switch = network.switches[ 0 ]  # switch to use
-    ip = '10.123.123.1'  # our IP address on host network
-    routes = [ '10.0.0.0/8' ]  # host networks to route to
-    connectToRootNS( network, switch, ip, 8, routes )
+def sshd( network, cmd='/usr/sbin/sshd', opts='-D',
+          ip='10.123.123.1/32', routes=None, switch=None ):
+    """Start a network, connect it to root ns, and run sshd on all hosts.
+       ip: root-eth0 IP address in root namespace (10.123.123.1/32)
+       routes: Mininet host networks to route to (10.0/24)
+       switch: Mininet switch to connect to root namespace (s1)"""
+    if not switch:
+        switch = network[ 's1' ]  # switch to use
+    if not routes:
+        routes = [ '10.0.0.0/24' ]
+    connectToRootNS( network, switch, ip, routes )
    for host in network.hosts:
        host.cmd( cmd + ' ' + opts + '&' )
+    print "*** Waiting for ssh daemons to start"
+    for server in network.hosts:
+        waitListening( server=server, port=22, timeout=5 )
+
    print
    print "*** Hosts are running sshd at the following addresses:"
    print
@@ -67,5 +78,9 @@ def sshd( network, cmd='/usr/sbin/sshd', opts='-D' ):

 if __name__ == '__main__':
    lg.setLogLevel( 'info')
-    net = TreeNet( depth=1, fanout=4, switch=OVSKernelSwitch )
-    sshd( net )
+    net = TreeNet( depth=1, fanout=4 )
+    # get sshd args from the command line or use default args
+    # useDNS=no -u0 to avoid reverse DNS lookup timeout
+    opts = ' '.join( sys.argv[ 1: ] ) if len( sys.argv ) > 1 else (
+        '-D -o UseDNS=no -u0' )
+    sshd( net, opts=opts )
@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+
+"""
+Run all mininet.examples tests
+ -v : verbose output
+ -quick : skip tests that take more than ~30 seconds
+"""
+
+import unittest
+import os
+import sys
+from mininet.util import ensureRoot
+from mininet.clean import cleanup
+
+class MininetTestResult( unittest.TextTestResult ):
+    def addFailure( self, test, err ):
+        super( MininetTestResult, self ).addFailure( test, err )
+        cleanup()
+    def addError( self,test, err ):
+        super( MininetTestResult, self ).addError( test, err )
+        cleanup()
+
+class MininetTestRunner( unittest.TextTestRunner ):
+    def _makeResult( self ):
+        return MininetTestResult( self.stream, self.descriptions, self.verbosity )
+
+def runTests( testDir, verbosity=1 ):
+    "discover and run all tests in testDir"
+    # ensure root and cleanup before starting tests
+    ensureRoot()
+    cleanup()
+    # discover all tests in testDir
+    testSuite = unittest.defaultTestLoader.discover( testDir )
+    # run tests
+    MininetTestRunner( verbosity=verbosity ).run( testSuite )
+
+if __name__ == '__main__':
+    # get the directory containing example tests
+    testDir = os.path.dirname( os.path.realpath( __file__ ) )
+    verbosity = 2 if '-v' in sys.argv else 1
+    runTests( testDir, verbosity )
@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+
+"""
+Tests for baresshd.py
+"""
+
+import unittest
+import pexpect
+from mininet.clean import cleanup, sh
+
+class testBareSSHD( unittest.TestCase ):
+
+    opts = [ 'Welcome to h1', pexpect.EOF, pexpect.TIMEOUT ]
+
+    def connected( self ):
+        "Log into ssh server, check banner, then 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:
+                return True
+            else:
+                return False
+
+    def setUp( self ):
+        # verify that sshd is not running
+        self.assertFalse( self.connected() )
+        # create public key pair for testing
+        sh( 'rm -rf /tmp/ssh' )
+        sh( 'mkdir /tmp/ssh' )
+        sh( "ssh-keygen -t rsa -P '' -f /tmp/ssh/test_rsa" )
+        sh( 'cat /tmp/ssh/test_rsa.pub >> /tmp/ssh/authorized_keys' )
+        # run example with custom sshd args
+        cmd = ( 'python -m mininet.examples.baresshd '
+                '-o AuthorizedKeysFile=/tmp/ssh/authorized_keys '
+                '-o StrictModes=no' )
+        p = pexpect.spawn( cmd )
+        runOpts = [ 'You may now ssh into h1 at 10.0.0.1',
+                    'after 5 seconds, h1 is not listening on port 22', 
+                    pexpect.EOF, pexpect.TIMEOUT ]
+        while True:
+            index = p.expect( runOpts )
+            if index == 0:
+                break
+            else:
+                self.tearDown()
+                self.fail( 'sshd failed to start in host h1' )
+
+    def testSSH( self ):
+        "Simple test to verify that we can ssh into h1"
+        result = False
+        # try to connect up to 3 times; sshd can take a while to start
+        result = self.connected()
+        self.assertTrue( result )
+
+    def tearDown( self ):
+        # kill the ssh process
+        sh( "ps aux | grep 'ssh.*Banner' | awk '{ print $2 }' | xargs kill" )
+        cleanup()
+        # remove public key pair
+        sh( 'rm -rf /tmp/ssh' )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+
+"""
+Tests for bind.py
+"""
+
+import unittest
+import pexpect
+
+class testBind( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    def setUp( self ):
+        self.net = pexpect.spawn( 'python -m mininet.examples.bind' )
+        self.net.expect( "Private Directories: \[([\w\s,'/]+)\]" )
+        self.directories = []
+        # parse directories from mn output
+        for d in self.net.match.group(1).split(', '):
+            self.directories.append( d.strip("'") )
+        self.net.expect( self.prompt )
+        self.assertTrue( len( self.directories ) > 0 )
+
+    def testCreateFile( self ):
+        "Create a file, a.txt, in the first private directory and verify"
+        fileName = 'a.txt'
+        directory = self.directories[ 0 ]
+        path = directory + '/' + fileName
+        self.net.sendline( 'h1 touch %s; ls %s' % ( path, directory ) )
+        index = self.net.expect( [ fileName, self.prompt ] )
+        self.assertTrue( index == 0 )
+        self.net.expect( self.prompt )
+        self.net.sendline( 'h1 rm %s' % path )
+        self.net.expect( self.prompt )
+
+    def testIsolation( self ):
+        "Create a file in two hosts and verify that contents are different"
+        fileName = 'b.txt'
+        directory = self.directories[ 0 ]
+        path = directory + '/' + fileName
+        contents = { 'h1' : '1', 'h2' : '2' }
+        # Verify file doesn't exist, then write private copy of file
+        for host in contents:
+            value = contents[ host ]
+            self.net.sendline( '%s cat %s' % ( host, path ) )
+            self.net.expect( 'No such file' )
+            self.net.expect( self.prompt )
+            self.net.sendline( '%s echo %s > %s' % ( host, value, path ) )
+            self.net.expect( self.prompt )
+        # Verify file contents
+        for host in contents:
+            value = contents[ host ]
+            self.net.sendline( '%s cat %s' % ( host, path ) )
+            self.net.expect( value )
+            self.net.expect( self.prompt )
+            self.net.sendline( '%s rm %s' % ( host, path ) )
+            self.net.expect( self.prompt )
+
+    # TODO: need more tests
+
+    def tearDown( self ):
+        self.net.sendline( 'exit' )
+        self.net.wait()
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+
+'''
+A simple sanity check test for cluster edition
+'''
+
+import unittest
+import pexpect
+
+class clusterSanityCheck( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    def testClusterPingAll( self ):
+        p = pexpect.spawn( 'python -m mininet.examples.clusterSanity' )
+        p.expect( self.prompt )
+        p.sendline( 'pingall' )
+        p.expect ( '(\d+)% dropped' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        self.assertEqual( percent, 0 )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+
+if __name__  == '__main__':
+    unittest.main()
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+"""
+Tests for controllers.py and controllers2.py
+"""
+
+import unittest
+import pexpect
+
+class testControllers( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    def connectedTest( self, name, cmap ):
+        "Verify that switches are connected to the controller specified by cmap"
+        p = pexpect.spawn( 'python -m %s' % name )
+        p.expect( self.prompt )
+        # but first a simple ping test
+        p.sendline( 'pingall' )
+        p.expect ( '(\d+)% dropped' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        self.assertEqual( percent, 0 )
+        p.expect( self.prompt )
+        # verify connected controller
+        for switch in cmap:
+            p.sendline( 'sh ovs-vsctl get-controller %s' % switch )
+            p.expect( 'tcp:([\d.:]+)')
+            actual = p.match.group(1)
+            expected = cmap[ switch ]
+            self.assertEqual( actual, expected )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    def testControllers( self ):
+        c0 = '127.0.0.1:6633'
+        c1 = '127.0.0.1:6634'
+        cmap = { 's1': c0, 's2': c1, 's3': c0 }
+        self.connectedTest( 'mininet.examples.controllers', cmap )
+
+    def testControllers2( self ):
+        c0 = '127.0.0.1:6633'
+        c1 = '127.0.0.1:6634'
+        cmap = { 's1': c0, 's2': c1 }
+        self.connectedTest( 'mininet.examples.controllers2', cmap )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+
+"""
+Test for controlnet.py
+"""
+
+import unittest
+import pexpect
+
+class testControlNet( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    def testPingall( self ):
+        "Simple pingall test that verifies 0% packet drop in data network"
+        p = pexpect.spawn( 'python -m mininet.examples.controlnet' )
+        p.expect( self.prompt )
+        p.sendline( 'pingall' )
+        p.expect ( '(\d+)% dropped' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        self.assertEqual( percent, 0 )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    def testFailover( self ):
+        "Kill controllers and verify that switch, s1, fails over properly"
+        count = 1
+        p = pexpect.spawn( 'python -m mininet.examples.controlnet' )
+        p.expect( self.prompt )
+        lp = pexpect.spawn( 'tail -f /tmp/s1-ofp.log' )
+        lp.expect( 'tcp:\d+\.\d+\.\d+\.(\d+):\d+: connected' )
+        ip = int( lp.match.group( 1 ) )
+        self.assertEqual( count, ip )
+        count += 1
+        for c in [ 'c0', 'c1' ]:
+            p.sendline( '%s ifconfig %s-eth0 down' % ( c, c) )
+            p.expect( self.prompt )
+            lp.expect( 'tcp:\d+\.\d+\.\d+\.(\d+):\d+: connected' )
+            ip = int( lp.match.group( 1 ) )
+            self.assertEqual( count, ip )
+            count += 1
+        p.sendline( 'exit' )
+        p.wait()
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+
+"""
+Test for cpu.py
+
+results format:
+
+    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
+import pexpect
+import sys
+
+class testCPU( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    @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' )
+        # matches each line from results( shown above )
+        opts = [ '([a-z]+)\t([\d\.]+)%\t([\d\.]+)', 
+                 pexpect.EOF ]
+        scheds = []
+        while True:
+            index = p.expect( opts, timeout=600 )
+            if index == 0:
+                sched = p.match.group( 1 ) 
+                cpu = float( p.match.group( 2 ) )
+                bw = float( p.match.group( 3 ) )
+                if sched not in scheds:
+                    scheds.append( sched )
+                else:
+                    self.assertTrue( bw < previous_bw )
+                previous_bw = bw
+            else:
+                break
+
+        self.assertTrue( len( scheds ) > 0 )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+"""
+Test for emptynet.py
+"""
+
+import unittest
+import pexpect
+
+class testEmptyNet( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    def testEmptyNet( self ):
+        "Run simple CLI tests: pingall (verify 0% drop) and iperf (sanity)"
+        p = pexpect.spawn( 'python -m mininet.examples.emptynet' )
+        p.expect( self.prompt )
+        # pingall test
+        p.sendline( 'pingall' )
+        p.expect ( '(\d+)% dropped' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        self.assertEqual( percent, 0 ) 
+        p.expect( self.prompt )
+        # iperf test
+        p.sendline( 'iperf' )
+        p.expect( "Results: \['[\d.]+ .bits/sec', '[\d.]+ .bits/sec'\]" )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+
+"""
+Test for hwintf.py
+"""
+
+import unittest
+import re
+
+import pexpect
+
+from mininet.log import setLogLevel
+from mininet.node import Node
+from mininet.link import Link
+
+
+class testHwintf( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    def setUp( self ):
+        self.h3 = Node( 't0', ip='10.0.0.3/8' )
+        self.n0 = Node( 't1', inNamespace=False )
+        Link( self.h3, self.n0 )
+        self.h3.configDefault()
+
+    def testLocalPing( self ):
+        "Verify connectivity between virtual hosts using pingall"
+        p = pexpect.spawn( 'python -m mininet.examples.hwintf %s' % self.n0.intf() )
+        p.expect( self.prompt )
+        p.sendline( 'pingall' )
+        p.expect ( '(\d+)% dropped' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        self.assertEqual( percent, 0 )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    def testExternalPing( self ):
+        "Verify connnectivity between virtual host and virtual-physical 'external' host "
+        p = pexpect.spawn( 'python -m mininet.examples.hwintf %s' % self.n0.intf() )
+        p.expect( self.prompt )
+        # test ping external to internal
+        expectStr = '(\d+) packets transmitted, (\d+) received'
+        m = re.search( expectStr, self.h3.cmd( 'ping -v -c 1 10.0.0.1' ) )
+        tx = m.group( 1 )
+        rx = m.group( 2 )
+        self.assertEqual( tx, rx )
+        # test ping internal to external
+        p.sendline( 'h1 ping -c 1 10.0.0.3')
+        p.expect( expectStr )
+        tx = p.match.group( 1 )
+        rx = p.match.group( 2 )
+        self.assertEqual( tx, rx )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    def tearDown( self ):
+        self.h3.terminate()
+        self.n0.terminate()
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+
+"""
+Test for intfOptions.py
+"""
+
+import unittest
+import pexpect
+import sys
+
+class testIntfOptions( unittest.TestCase ):
+
+    def testIntfOptions( self ):
+        "verify that intf.config is correctly limiting traffic"
+        p = pexpect.spawn( 'python -m mininet.examples.intfoptions ' )
+        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",
+                 pexpect.EOF ]
+        while True:
+            index = p.expect( opts, timeout=600 )
+            if index == 0:
+                bw = float( p.match.group( 1 ) )
+                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 * tolerance )
+                self.assertLessEqual( loss,  50 + 50 * ( 1 - tolerance ) )
+            elif index == 2:
+                delay = float( p.match.group( 6 ) )
+                self.assertGreaterEqual( delay, 15 * tolerance )
+                self.assertLessEqual( delay,  15 + 15 * ( 1 - tolerance ) )
+            else:
+                break
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+
+"""
+Test for limit.py
+"""
+
+import unittest
+import pexpect
+import sys
+
+class testLimit( unittest.TestCase ):
+
+    @unittest.skipIf( '-quick' in sys.argv, 'long test' )
+    def testLimit( self ):
+        "Verify that CPU limits are within a 2% tolerance of limit for each scheduler"
+        p = pexpect.spawn( 'python -m mininet.examples.limit' )
+        opts = [ '\*\*\* Testing network ([\d\.]+) Mbps', 
+                 '\*\*\* Results: \[([\d\., ]+)\]', 
+                 pexpect.EOF ]
+        count = 0
+        bw = 0
+        tolerance = 2
+        while True:
+            index = p.expect( opts )
+            if index == 0:
+                bw = float( p.match.group( 1 ) )
+                count += 1
+            elif index == 1:
+                results = p.match.group( 1 )
+                for x in results.split( ',' ):
+                    result = float( x )
+                    self.assertTrue( result < bw + tolerance )
+                    self.assertTrue( result > bw - tolerance )
+            else:
+                break
+
+        self.assertTrue( count > 0 )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+
+"""
+Test for linearbandwidth.py
+"""
+
+import unittest
+import pexpect
+import sys
+
+class testLinearBandwidth( unittest.TestCase ):
+
+    @unittest.skipIf( '-quick' in sys.argv, 'long test' )
+    def testLinearBandwidth( self ):
+        "Verify that bandwidth is monotonically decreasing as # of hops increases"
+        p = pexpect.spawn( 'python -m mininet.examples.linearbandwidth' )
+        count = 0
+        opts = [ '\*\*\* Linear network results', 
+                 '(\d+)\s+([\d\.]+) (.bits)', 
+                 pexpect.EOF ]
+        while True:
+            index = p.expect( opts, timeout=600 )
+            if index == 0:
+                count += 1
+            elif index == 1:
+                n = int( p.match.group( 1 ) )
+                bw = float( p.match.group( 2 ) )
+                unit = p.match.group( 3 )
+                if unit[ 0 ] == 'K':
+                    bw *= 10 ** 3
+                elif unit[ 0 ] == 'M':
+                    bw *= 10 ** 6
+                elif unit[ 0 ] == 'G':
+                    bw *= 10 ** 9
+                # check that we have a previous result to compare to
+                if n != 1:
+                    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
+            else:
+                break
+
+        # verify that we received results from at least one switch
+        self.assertTrue( count > 0 )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+
+"""
+Test for linuxrouter.py
+"""
+
+import unittest
+import pexpect
+from mininet.util import quietRun
+
+class testLinuxRouter( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    def testPingall( self ):
+        "Test connectivity between hosts"
+        p = pexpect.spawn( 'python -m mininet.examples.linuxrouter' )
+        p.expect( self.prompt )
+        p.sendline( 'pingall' )
+        p.expect ( '(\d+)% dropped' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+        self.assertEqual( percent, 0 )
+
+    def testRouterPing( self ):
+        "Test connectivity from h1 to router"
+        p = pexpect.spawn( 'python -m mininet.examples.linuxrouter' )
+        p.expect( self.prompt )
+        p.sendline( 'h1 ping -c 1 r0' )
+        p.expect ( '(\d+)% packet loss' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+        self.assertEqual( percent, 0 )
+
+    def testTTL( self ):
+        "Verify that the TTL is decremented"
+        p = pexpect.spawn( 'python -m mininet.examples.linuxrouter' )
+        p.expect( self.prompt )
+        p.sendline( 'h1 ping -c 1 h2' )
+        p.expect ( 'ttl=(\d+)' )
+        ttl = int( p.match.group( 1 ) ) if p.match else -1
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+        self.assertEqual( ttl, 63 ) # 64 - 1
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+
+"""
+Test for mobility.py
+"""
+
+import unittest
+from subprocess import check_output
+
+class testMobility( unittest.TestCase ):
+
+    def testMobility( self ):
+        "Run the example and verify its 4 ping results"
+        cmd = 'python -m mininet.examples.mobility 2>&1'
+        grep = ' | grep -c " 0% dropped" '
+        result = check_output( cmd + grep, shell=True )
+        assert int( result ) == 4
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+
+'''
+Test for multiple links between nodes
+validates mininet interfaces against systems interfaces
+'''
+
+import unittest
+import pexpect
+
+class testMultiLink( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    def testMultiLink(self):
+        p = pexpect.spawn( 'python -m mininet.examples.multilink' )
+        p.expect( self.prompt )
+        p.sendline( 'intfs' )
+        p.expect( 's(\d): lo' )
+        intfsOutput = p.before
+        # parse interfaces from mininet intfs, and store them in a list
+        hostToIntfs = intfsOutput.split( '\r\n' )[ 1:3 ]
+        intfList = []
+        for hostToIntf in hostToIntfs:
+            intfList += [ intf for intf in 
+                          hostToIntf.split()[1].split(',') ]
+
+        # get interfaces from system by running ifconfig on every host
+        sysIntfList = []
+        opts = [ 'h(\d)-eth(\d)', self.prompt ]
+        p.expect( self.prompt )
+        
+        p.sendline( 'h1 ifconfig' )
+        while True:
+            p.expect( opts )
+            if p.after == self.prompt:
+                break
+            sysIntfList.append( p.after )
+
+        p.sendline( 'h2 ifconfig' )
+        while True:
+            p.expect( opts )
+            if p.after == self.prompt:
+                break
+            sysIntfList.append( p.after )
+
+        failMsg = ( 'The systems interfaces and mininet interfaces\n'
+                    'are not the same' )
+
+        self.assertEqual( sysIntfList, intfList, msg=failMsg )
+        p.sendline( 'exit' )
+        p.wait()
+
+if __name__ == '__main__':
+        unittest.main()
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+"""
+Test for multiping.py
+"""
+
+import unittest
+import pexpect
+from collections import defaultdict
+
+class testMultiPing( unittest.TestCase ):
+
+    def testMultiPing( self ):
+        """Verify that each target is pinged at least once, and 
+           that pings to 'real' targets are successful and unknown targets fail"""
+        p = pexpect.spawn( 'python -m mininet.examples.multiping' )
+        opts = [ "Host (h\d+) \(([\d.]+)\) will be pinging ips: ([\d\. ]+)",
+                 "(h\d+): ([\d.]+) -> ([\d.]+) \d packets transmitted, (\d) received",
+                 pexpect.EOF ]
+        pings = defaultdict( list )
+        while True:
+            index = p.expect( opts )
+            if index == 0:
+                name = p.match.group(1)
+                ip = p.match.group(2)
+                targets = p.match.group(3).split()
+                pings[ name ] += targets
+            elif index == 1:
+                name = p.match.group(1)
+                ip = p.match.group(2)
+                target = p.match.group(3)
+                received = int( p.match.group(4) )
+                if target == '10.0.0.200':
+                    self.assertEqual( received, 0 )
+                else:
+                    self.assertEqual( received, 1 )
+                try:
+                    pings[ name ].remove( target )
+                except:
+                    pass
+            else:
+                break
+        self.assertTrue( len( pings ) > 0 )
+        for t in pings.values():
+            self.assertEqual( len( t ), 0 )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+
+"""
+Test for multipoll.py
+"""
+
+import unittest
+import pexpect
+
+class testMultiPoll( unittest.TestCase ):
+
+    def testMultiPoll( self ):
+        "Verify that we receive one ping per second per host"
+        p = pexpect.spawn( 'python -m mininet.examples.multipoll' )
+        opts = [ "\*\*\* (h\d) :" ,
+                 "(h\d+): \d+ bytes from",
+                 "Monitoring output for (\d+) seconds",
+                 pexpect.EOF ]
+        pings = {}
+        while True:
+            index = p.expect( opts )
+            if index == 0:
+                name = p.match.group( 1 )
+                pings[ name ] = 0
+            elif index == 1:
+                name = p.match.group( 1 )
+                pings[ name ] += 1
+            elif index == 2:
+                seconds = int( p.match.group( 1 ) )
+            else:
+                break
+        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 )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+"""
+Test for multitest.py
+"""
+
+import unittest
+import pexpect
+
+class testMultiTest( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    def testMultiTest( self ):
+        "Verify pingall (0% dropped) and hX-eth0 interface for each host (ifconfig)"
+        p = pexpect.spawn( 'python -m mininet.examples.multitest' )
+        p.expect( '(\d+)% dropped' )
+        dropped = int( p.match.group( 1 ) )
+        self.assertEqual( dropped, 0 )
+        ifCount = 0
+        while True:
+            index = p.expect( [ 'h\d-eth0', self.prompt ] )
+            if index == 0:
+                ifCount += 1
+            elif index == 1:
+                p.sendline( 'exit' )
+                break
+        p.wait()
+        self.assertEqual( ifCount, 4 )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+"""
+Test for nat.py
+"""
+
+import unittest
+import pexpect
+from mininet.util import quietRun
+
+destIP = '8.8.8.8' # Google DNS
+
+class testNAT( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    @unittest.skipIf( '0 received' in quietRun( 'ping -c 1 %s' % destIP ), 
+                      'Destination IP is not reachable' )
+    def testNAT( self ):
+        "Attempt to ping an IP on the Internet and verify 0% packet loss"
+        p = pexpect.spawn( 'python -m mininet.examples.nat' )
+        p.expect( self.prompt )
+        p.sendline( 'h1 ping -c 1 %s' % destIP )
+        p.expect ( '(\d+)% packet loss' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+        self.assertEqual( percent, 0 )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+
+"""
+Test for natnet.py
+"""
+
+import unittest
+import pexpect
+from mininet.util import quietRun
+
+class testNATNet( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    def setUp( self ):
+        self.net = pexpect.spawn( 'python -m mininet.examples.natnet' )
+        self.net.expect( self.prompt )
+
+    def testPublicPing( self ):
+        "Attempt to ping the public server (h0) from h1 and h2"
+        self.net.sendline( 'h1 ping -c 1 h0' )
+        self.net.expect ( '(\d+)% packet loss' )
+        percent = int( self.net.match.group( 1 ) ) if self.net.match else -1
+        self.assertEqual( percent, 0 )
+        self.net.expect( self.prompt )
+
+        self.net.sendline( 'h2 ping -c 1 h0' )
+        self.net.expect ( '(\d+)% packet loss' )
+        percent = int( self.net.match.group( 1 ) ) if self.net.match else -1
+        self.assertEqual( percent, 0 )
+        self.net.expect( self.prompt )
+
+    def testPrivatePing( self ):
+        "Attempt to ping h1 and h2 from public server"
+        self.net.sendline( 'h0 ping -c 1 -t 1 h1' )
+        result = self.net.expect ( [ 'unreachable', 'loss' ] )
+        self.assertEqual( result, 0 )
+        self.net.expect( self.prompt )
+
+        self.net.sendline( 'h0 ping -c 1 -t 1 h2' )
+        result = self.net.expect ( [ 'unreachable', 'loss' ] )
+        self.assertEqual( result, 0 )
+        self.net.expect( self.prompt )
+
+    def testPrivateToPrivatePing( self ):
+        "Attempt to ping from NAT'ed host h1 to NAT'ed host h2"
+        self.net.sendline( 'h1 ping -c 1 -t 1 h2' )
+        result = self.net.expect ( [ '[Uu]nreachable', 'loss' ] )
+        self.assertEqual( result, 0 )
+        self.net.expect( self.prompt )
+
+    def tearDown( self ):
+        self.net.sendline( 'exit' )
+        self.net.wait()
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+
+"""
+Test for numberedports.py
+"""
+
+import unittest
+import pexpect
+from collections import defaultdict
+from mininet.node import OVSSwitch
+
+class testNumberedports( unittest.TestCase ):
+
+    @unittest.skipIf( OVSSwitch.setup() or OVSSwitch.isOldOVS(), "old version of OVS" )
+    def testConsistency( self ):
+        """verify consistency between mininet and ovs ports"""
+        p = pexpect.spawn( 'python -m mininet.examples.numberedports' )
+        opts = [ 'Validating that s1-eth\d is actually on port \d ... Validated.', 
+                 'Validating that s1-eth\d is actually on port \d ... WARNING', 
+                 pexpect.EOF ]
+        correct_ports = True
+        count = 0
+        while True:
+            index = p.expect( opts )
+            if index == 0:
+                count += 1
+            elif index == 1:
+                correct_ports = False
+            elif index == 2:
+                self.assertNotEqual( 0, count )
+                break
+        self.assertTrue( correct_ports )
+
+    def testNumbering( self ):
+        """verify that all of the port numbers are printed correctly and consistent with their interface"""
+        p = pexpect.spawn( 'python -m mininet.examples.numberedports' )
+        opts = [ 's1-eth(\d+) :  (\d+)', 
+                 pexpect.EOF ]
+        count_intfs = 0
+        while True:
+            index = p.expect( opts )
+            if index == 0:
+                count_intfs += 1
+                intfport = p.match.group( 1 )
+                ofport = p.match.group( 2 )
+                self.assertEqual( intfport, ofport )
+            elif index == 1:
+                break
+                self.assertNotEqual( 0, count_intfs )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+
+"""
+Test for popen.py and popenpoll.py
+"""
+
+import unittest
+import pexpect
+
+class testPopen( unittest.TestCase ):
+
+    def pingTest( self, name ):
+        "Verify that there are no dropped packets for each host"
+        p = pexpect.spawn( 'python -m %s' % name )
+        opts = [ "<(h\d+)>: PING ",
+                 "<(h\d+)>: (\d+) packets transmitted, (\d+) received",
+                 pexpect.EOF ]
+        pings = {}
+        while True:
+            index = p.expect( opts )
+            if index == 0:
+                name = p.match.group(1)
+                pings[ name ] = 0
+            elif index == 1:
+                name = p.match.group(1)
+                transmitted = p.match.group(2)
+                received = p.match.group(3)
+                # verify no dropped packets
+                self.assertEqual( received, transmitted )
+                pings[ name ] += 1
+            else:
+                break
+        self.assertTrue( len(pings) > 0 )
+        # verify that each host has gotten results
+        for count in pings.values():
+            self.assertEqual( count, 1 )
+
+    def testPopen( self ):
+        self.pingTest( 'mininet.examples.popen' )
+
+    def testPopenPoll( self ):
+        self.pingTest( 'mininet.examples.popenpoll' )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+
+"""
+Test for scratchnet.py
+"""
+
+import unittest
+import pexpect
+
+class testScratchNet( unittest.TestCase ):
+
+    opts = [ "1 packets transmitted, 1 received, 0% packet loss", pexpect.EOF ]
+
+    def pingTest( self, name ):
+        "Verify that no ping packets were dropped"
+        p = pexpect.spawn( 'python -m %s' % name )
+        index = p.expect( self.opts )
+        self.assertEqual( index, 0 )
+
+    def testPingKernel( self ):
+        self.pingTest( 'mininet.examples.scratchnet' )
+
+    def testPingUser( self ):
+        self.pingTest( 'mininet.examples.scratchnetuser' )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+
+"""
+Test for simpleperf.py
+"""
+
+import unittest
+import pexpect
+import sys
+from mininet.log import setLogLevel
+
+from mininet.examples.simpleperf import SingleSwitchTopo
+
+class testSimplePerf( unittest.TestCase ):
+
+    @unittest.skipIf( '-quick' in sys.argv, 'long test' )
+    def testE2E( self ):
+        "Run the example and verify iperf results"
+        BW = 10
+        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 = expectedBw * TOLERANCE
+        upperBound = expectedBw + expectedBw * ( 1 - TOLERANCE )
+        self.assertGreaterEqual( measuredBw, lowerBound )
+        self.assertLessEqual( measuredBw, upperBound )
+        p.wait()
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+
+"""
+Test for sshd.py
+"""
+
+import unittest
+import pexpect
+from mininet.clean import sh
+
+class testSSHD( unittest.TestCase ):
+
+    opts = [ '\(yes/no\)\?', 'refused', 'Welcome|\$|#', pexpect.EOF, pexpect.TIMEOUT ]
+
+    def connected( self, ip ):
+        "Log into ssh server, check banner, then exit"
+        # Note: this test will fail if "Welcome" is not in the sshd banner 
+        # and '#'' or '$'' are not in the prompt
+        p = pexpect.spawn( 'ssh -i /tmp/ssh/test_rsa %s' % ip, timeout=10 )
+        while True:
+            index = p.expect( self.opts )
+            if index == 0:
+                print p.match.group(0)
+                p.sendline( 'yes' )
+            elif index == 1:
+                return False
+            elif index == 2:
+                p.sendline( 'exit' )
+                p.wait()    
+                return True
+            else:
+                return False
+
+    def setUp( self ):
+        # create public key pair for testing
+        sh( 'rm -rf /tmp/ssh' )
+        sh( 'mkdir /tmp/ssh' )
+        sh( "ssh-keygen -t rsa -P '' -f /tmp/ssh/test_rsa" )
+        sh( 'cat /tmp/ssh/test_rsa.pub >> /tmp/ssh/authorized_keys' )
+        cmd = ( 'python -m mininet.examples.sshd -D '
+                '-o AuthorizedKeysFile=/tmp/ssh/authorized_keys '
+                '-o StrictModes=no -o UseDNS=no -u0' )
+        # run example with custom sshd args
+        self.net = pexpect.spawn( cmd )
+        self.net.expect( 'mininet>' )
+
+    def testSSH( self ):
+        "Verify that we can ssh into all hosts (h1 to h4)"
+        for h in range( 1, 5 ):
+            self.assertTrue( self.connected( '10.0.0.%d' % h ) )
+
+    def tearDown( self ):
+        self.net.sendline( 'exit' )
+        self.net.wait()
+        # remove public key pair
+        sh( 'rm -rf /tmp/ssh' )
+
+if __name__ == '__main__':
+    unittest.main()
+
@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+
+"""
+Test for tree1024.py
+"""
+
+import unittest
+import pexpect
+import sys
+
+class testTree1024( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    @unittest.skipIf( '-quick' in sys.argv, 'long test' )
+    def testTree1024( self ):
+        "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 1 h1024' )
+        p.expect ( '(\d+)% packet loss' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+        self.assertEqual( percent, 0 )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+"""
+Test for treeping64.py
+"""
+
+import unittest
+import pexpect
+import sys
+
+class testTreePing64( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    @unittest.skipIf( '-quick' in sys.argv, 'long test' )
+    def testTreePing64( self ):
+        "Run the example and verify ping results"
+        p = pexpect.spawn( 'python -m mininet.examples.treeping64' )
+        p.expect( 'Tree network ping results:', timeout=6000 )
+        count = 0
+        while True:
+            index = p.expect( [ '(\d+)% packet loss', pexpect.EOF ] )
+            if index == 0:
+                percent = int( p.match.group( 1 ) ) if p.match else -1
+                self.assertEqual( percent, 0 )
+                count += 1
+            else:
+                break
+        self.assertTrue( count > 0 )
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+
+"""
+Test for vlanhost.py
+"""
+
+import unittest
+import pexpect
+import sys
+from mininet.util import quietRun
+
+class testVLANHost( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    @unittest.skipIf( '-quick' in sys.argv, 'long test' )
+    def testVLANTopo( self ):
+        "Test connectivity (or lack thereof) between hosts in VLANTopo"
+        p = pexpect.spawn( 'python -m mininet.examples.vlanhost' )
+        p.expect( self.prompt )
+        p.sendline( 'pingall 1' ) #ping timeout=1
+        p.expect( '(\d+)% dropped', timeout=30  ) # there should be 24 failed pings
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+        self.assertEqual( percent, 80 )
+
+    def testSpecificVLAN( self ):
+        "Test connectivity between hosts on a specific VLAN"
+        vlan = 1001
+        p = pexpect.spawn( 'python -m mininet.examples.vlanhost %d' % vlan )
+        p.expect( self.prompt )
+
+        p.sendline( 'h1 ping -c 1 h2' )
+        p.expect ( '(\d+)% packet loss' )
+        percent = int( p.match.group( 1 ) ) if p.match else -1
+        p.expect( self.prompt )
+
+        p.sendline( 'h1 ifconfig' )
+        i = p.expect( ['h1-eth0.%d' % vlan, pexpect.TIMEOUT ], timeout=2 )
+        p.expect( self.prompt )
+
+        p.sendline( 'exit' )
+        p.wait()
+        self.assertEqual( percent, 0 ) # no packet loss on ping
+        self.assertEqual( i, 0 ) # check vlan intf is present
+
+if __name__ == '__main__':
+    unittest.main()
@@ -0,0 +1,125 @@
+#!/usr/bin/env python
+"""
+vlanhost.py: Host subclass that uses a VLAN tag for the default interface.
+
+Dependencies:
+    This class depends on the "vlan" package
+    $ sudo apt-get install vlan
+
+Usage (example uses VLAN ID=1000):
+    From the command line:
+        sudo mn --custom vlanhost.py --host vlan,vlan=1000
+
+    From a script (see exampleUsage function below):
+        from functools import partial
+        from vlanhost import VLANHost
+
+        ....
+
+        host = partial( VLANHost, vlan=1000 )
+        net = Mininet( host=host, ... )
+
+    Directly running this script:
+        sudo python vlanhost.py 1000
+
+"""
+
+from mininet.node import Host
+from mininet.topo import Topo
+from mininet.util import quietRun
+from mininet.log import error
+
+class VLANHost( Host ):
+
+   def config( self, vlan=100, **params ):
+        """Configure VLANHost according to (optional) parameters:
+           vlan: VLAN ID for default interface"""
+
+        r = super( Host, self ).config( **params )
+
+        intf = self.defaultIntf()
+        # remove IP from default, "physical" interface
+        self.cmd( 'ifconfig %s inet 0' % intf )
+        # create VLAN interface 
+        self.cmd( 'vconfig add %s %d' % ( intf, vlan ) )
+        # assign the host's IP to the VLAN interface
+        self.cmd( 'ifconfig %s.%d inet %s' % ( intf, vlan, params['ip'] ) )
+        # update the intf name and host's intf map
+        newName = '%s.%d' % ( intf, vlan )
+        # update the (Mininet) interface to refer to VLAN interface name
+        intf.name = newName
+        # add VLAN interface to host's name to intf map
+        self.nameToIntf[ newName ] = intf
+
+        return r
+
+hosts = { 'vlan': VLANHost }
+
+
+def exampleAllHosts( vlan ):
+    """Simple example of how VLANHost can be used in a script"""
+    # This is where the magic happens...
+    host = partial( VLANHost, vlan=vlan )
+    # vlan (type: int): VLAN ID to be used by all hosts
+
+    # Start a basic network using our VLANHost
+    topo = SingleSwitchTopo( k=2 )
+    net = Mininet( host=host, topo=topo )
+    net.start()
+    CLI( net )
+    net.stop()
+
+class VLANStarTopo( Topo ):
+    """Example topology that uses host in multiple VLANs
+
+       The topology has a single switch. There are k VLANs with
+       n hosts in each, all connected to the single switch. There
+       are also n hosts that are not in any VLAN, also connected to
+       the switch."""
+
+    def build( self, k=2, n=2, vlanBase=100 ):
+        s1 = self.addSwitch( 's1' )
+        for i in range( k ):
+            vlan = vlanBase + i
+            for j in range(n):
+                name = 'h%d-%d' % ( j+1, vlan )
+                h = self.addHost( name, cls=VLANHost, vlan=vlan )
+                self.addLink( h, s1 )
+        for j in range( n ):
+            h = self.addHost( 'h%d' % (j+1) )
+            self.addLink( h, s1 )
+
+
+def exampleCustomTags( vlan ):
+    """Simple example that exercises VLANStarTopo"""
+
+    net = Mininet( topo=VLANStarTopo() )
+    net.start()
+    CLI( net )
+    net.stop()
+
+if __name__ == '__main__':
+    import sys
+    from functools import partial
+
+    from mininet.net import Mininet
+    from mininet.cli import CLI
+    from mininet.topo import SingleSwitchTopo
+    from mininet.log import setLogLevel
+
+    setLogLevel( 'info' )
+
+    if not quietRun( 'which vconfig' ):
+        error( "Cannot find command 'vconfig'\nThe packge",
+               "'vlan' is required in Ubuntu or Debian,",
+               "or 'vconfig' in Fedora\n" )
+        exit()
+    try:
+        vlan = int( sys.argv[ 1 ] )
+    except Exception:
+        vlan = None
+
+    if vlan:
+        exampleAllHosts( vlan )
+    else:
+        exampleCustomTags( vlan )
@@ -10,16 +10,33 @@ It may also get rid of 'false positives', but hopefully
 nothing irreplaceable!
 """

-from subprocess import Popen, PIPE
+from subprocess import Popen, PIPE, check_output as co
+import time

 from mininet.log import info
 from mininet.term import cleanUpScreens

+
 def sh( cmd ):
    "Print a command and send it to the shell"
    info( cmd + '\n' )
    return Popen( [ '/bin/sh', '-c', cmd ], stdout=PIPE ).communicate()[ 0 ]

+def killprocs( pattern ):
+    "Reliably terminate processes matching a pattern (including args)"
+    sh( 'pkill -9 -f %s' % pattern )
+    # Make sure they are gone
+    while True:
+        try:
+            pids = co( 'pgrep -f %s' % pattern )
+        except:
+            pids = ''
+        if pids:
+            sh( 'pkill -f 9 mininet:' )
+            time.sleep( .5 )
+        else:
+            break
+
 def cleanup():
    """Clean up junk which might be left over from old runs;
       do fast stuff before slow dp and link removal!"""
@@ -27,34 +44,53 @@ def cleanup():
    info("*** Removing excess controllers/ofprotocols/ofdatapaths/pings/noxes"
         "\n")
    zombies = 'controller ofprotocol ofdatapath ping nox_core lt-nox_core '
-    zombies += 'ovs-openflowd udpbwtest'
+    zombies += 'ovs-openflowd ovs-controller udpbwtest mnexec ivs'
    # Note: real zombie processes can't actually be killed, since they
    # are already (un)dead. Then again,
    # you can't connect to them either, so they're mostly harmless.
+    # Send SIGTERM first to give processes a chance to shutdown cleanly.
+    sh( 'killall ' + zombies + ' 2> /dev/null' )
+    time.sleep( 1 )
    sh( 'killall -9 ' + zombies + ' 2> /dev/null' )

+    # And kill off sudo mnexec
+    sh( 'pkill -9 -f "sudo mnexec"')
+
    info( "*** Removing junk from /tmp\n" )
    sh( 'rm -f /tmp/vconn* /tmp/vlogs* /tmp/*.out /tmp/*.log' )

-    info( "*** Removing old screen sessions\n" )
+    info( "*** Removing old X11 tunnels\n" )
    cleanUpScreens()

    info( "*** Removing excess kernel datapaths\n" )
-    dps = sh( "ps ax | egrep -o 'dp[0-9]+' | sed 's/dp/nl:/'" ).split( '\n' )
+    dps = sh( "ps ax | egrep -o 'dp[0-9]+' | sed 's/dp/nl:/'" ).splitlines()
    for dp in dps:
-        if dp != '':
+        if dp:
            sh( 'dpctl deldp ' + dp )

    info( "***  Removing OVS datapaths" )
-    dps = sh("ovs-vsctl list-br").split( '\n' )
+    dps = sh("ovs-vsctl --timeout=1 list-br").strip().splitlines()
+    if dps:
+        sh( "ovs-vsctl " + " -- ".join( "--if-exists del-br " + dp
+                                       for dp in dps if dp ) )
+    # And in case the above didn't work...
+    dps = sh("ovs-vsctl --timeout=1 list-br").strip().splitlines()
    for dp in dps:
-        if dp:
-            sh( 'ovs-vsctl del-br ' + dp )
+        sh( 'ovs-vsctl del-br ' + dp )

    info( "*** Removing all links of the pattern foo-ethX\n" )
-    links = sh( "ip link show | egrep -o '(\w+-eth\w+)'" ).split( '\n' )
+    links = sh( "ip link show | "
+                "egrep -o '([-_.[:alnum:]]+-eth[[:digit:]]+)'" ).splitlines()
    for link in links:
-        if link != '':
+        if link:
            sh( "ip link del " + link )

+    info( "*** Killing stale mininet node processes\n" )
+    killprocs( 'mininet:' )
+
+    info ( "*** Shutting down stale tunnels\n" )
+    killprocs( 'Tunnel=Ethernet' )
+    killprocs( '.ssh/mn')
+    sh( 'rm -f ~/.ssh/mn/*' )
+    
    info( "*** Cleanup complete.\n" )
@@ -31,10 +31,13 @@ from os import isatty
 from select import poll, POLLIN
 import sys
 import time
+import os
+import atexit

 from mininet.log import info, output, error
-from mininet.term import makeTerms
-from mininet.util import quietRun, isShellBuiltin, dumpNodeConnections
+from mininet.term import makeTerms, runX11
+from mininet.util import ( quietRun, dumpNodeConnections,
+                         dumpPorts )

 class CLI( Cmd ):
    "Simple command-line interface to talk to nodes."
@@ -43,13 +46,8 @@ class CLI( Cmd ):

    def __init__( self, mininet, stdin=sys.stdin, script=None ):
        self.mn = mininet
-        self.nodelist = self.mn.controllers + self.mn.switches + self.mn.hosts
-        self.nodemap = {}  # map names to Node objects
-        for node in self.nodelist:
-            self.nodemap[ node.name ] = node
        # Local variable bindings for py command
        self.locals = { 'net': mininet }
-        self.locals.update( self.nodemap )
        # Attempt to handle input
        self.stdin = stdin
        self.inPoller = poll()
@@ -57,18 +55,30 @@ class CLI( Cmd ):
        self.inputFile = script
        Cmd.__init__( self )
        info( '*** Starting CLI:\n' )
+
+        # Set up history if readline is available
+        try:
+            import readline
+        except ImportError:
+            pass
+        else:
+            history_path = os.path.expanduser('~/.mininet_history')
+            if os.path.isfile(history_path):
+                readline.read_history_file(history_path)
+            atexit.register(lambda: readline.write_history_file(history_path))
+
        if self.inputFile:
            self.do_source( self.inputFile )
            return
        while True:
            try:
                # Make sure no nodes are still waiting
-                for node in self.nodelist:
+                for node in self.mn.values():
                    while node.waiting:
                        node.sendInt()
-                        node.monitor()
+                        node.waitOutput()
                if self.isatty():
-                    quietRun( 'stty sane' )
+                    quietRun( 'stty echo sane intr "^C"' )
                self.cmdloop()
                break
            except KeyboardInterrupt:
@@ -78,6 +88,11 @@ class CLI( Cmd ):
        "Don't repeat last command when you hit return."
        pass

+    def getLocals( self ):
+        "Local variable bindings for py command"
+        self.locals.update( self.mn )
+        return self.locals
+
    # Disable pylint "Unused argument: 'arg's'" messages, as well as
    # "method could be a function" warning, since each CLI function
    # must have the same interface
@@ -110,25 +125,30 @@ class CLI( Cmd ):

    def do_nodes( self, _line ):
        "List all nodes."
-        nodes = ' '.join( [ node.name for node in sorted( self.nodelist ) ] )
+        nodes = ' '.join( sorted( self.mn ) )
        output( 'available nodes are: \n%s\n' % nodes )

+    def do_ports( self, line ):
+        "display ports and interfaces for each switch"
+        dumpPorts( self.mn.switches )
+
    def do_net( self, _line ):
        "List network connections."
-        dumpNodeConnections( self.nodelist )
+        dumpNodeConnections( self.mn.values() )

    def do_sh( self, line ):
-        "Run an external shell command"
+        """Run an external shell command
+           Usage: sh [cmd args]"""
        call( line, shell=True )

-    # do_py() needs to catch any exception during eval()
+    # do_py() and do_px() need to catch any exception during eval()/exec()
    # pylint: disable-msg=W0703

    def do_py( self, line ):
        """Evaluate a Python expression.
-           Node names may be used, e.g.: h1.cmd('ls')"""
+           Node names may be used, e.g.: py h1.cmd('ls')"""
        try:
-            result = eval( line, globals(), self.locals )
+            result = eval( line, globals(), self.getLocals() )
            if not result:
                return
            elif isinstance( result, str ):
@@ -138,18 +158,29 @@ class CLI( Cmd ):
        except Exception, e:
            output( str( e ) + '\n' )

-    # pylint: enable-msg=W0703
+    # We are in fact using the exec() pseudo-function
+    # pylint: disable-msg=W0122

-    def do_pingall( self, _line ):
+    def do_px( self, line ):
+        """Execute a Python statement.
+            Node names may be used, e.g.: px print h1.cmd('ls')"""
+        try:
+            exec( line, globals(), self.getLocals() )
+        except Exception, e:
+            output( str( e ) + '\n' )
+
+    # pylint: enable-msg=W0703,W0122
+
+    def do_pingall( self, line ):
        "Ping between all hosts."
-        self.mn.pingAll()
+        self.mn.pingAll( line )

    def do_pingpair( self, _line ):
        "Ping between first two hosts, useful for testing."
        self.mn.pingPair()

    def do_pingallfull( self, _line ):
-        "Ping between first two hosts, returns all ping results."
+        "Ping between all hosts, returns all ping results."
        self.mn.pingAllFull()

    def do_pingpairfull( self, _line ):
@@ -157,7 +188,8 @@ class CLI( Cmd ):
        self.mn.pingPairFull()

    def do_iperf( self, line ):
-        "Simple iperf TCP test between two (optionally specified) hosts."
+        """Simple iperf TCP test between two (optionally specified) hosts.
+           Usage: iperf node1 node2"""
        args = line.split()
        if not args:
            self.mn.iperf()
@@ -165,18 +197,19 @@ class CLI( Cmd ):
            hosts = []
            err = False
            for arg in args:
-                if arg not in self.nodemap:
+                if arg not in self.mn:
                    err = True
                    error( "node '%s' not in network\n" % arg )
                else:
-                    hosts.append( self.nodemap[ arg ] )
+                    hosts.append( self.mn[ arg ] )
            if not err:
                self.mn.iperf( hosts )
        else:
            error( 'invalid number of args: iperf src dst\n' )

    def do_iperfudp( self, line ):
-        "Simple iperf TCP test between two (optionally specified) hosts."
+        """Simple iperf UDP test between two (optionally specified) hosts.
+           Usage: iperfudp bw node1 node2"""
        args = line.split()
        if not args:
            self.mn.iperf( l4Type='UDP' )
@@ -185,11 +218,11 @@ class CLI( Cmd ):
            hosts = []
            err = False
            for arg in args[ 1:3 ]:
-                if arg not in self.nodemap:
+                if arg not in self.mn:
                    err = True
                    error( "node '%s' not in network\n" % arg )
                else:
-                    hosts.append( self.nodemap[ arg ] )
+                    hosts.append( self.mn[ arg ] )
            if not err:
                self.mn.iperf( hosts, l4Type='UDP', udpBw=udpBw )
        else:
@@ -198,17 +231,18 @@ class CLI( Cmd ):

    def do_intfs( self, _line ):
        "List interfaces."
-        for node in self.nodelist:
+        for node in self.mn.values():
            output( '%s: %s\n' %
                    ( node.name, ','.join( node.intfNames() ) ) )

    def do_dump( self, _line ):
        "Dump node info."
-        for node in self.nodelist:
+        for node in self.mn.values():
            output( '%s\n' % repr( node ) )

    def do_link( self, line ):
-        "Bring link(s) between two nodes up or down."
+        """Bring link(s) between two nodes up or down.
+           Usage: link node1 node2 [up/down]"""
        args = line.split()
        if len(args) != 3:
            error( 'invalid number of args: link end1 end2 [up down]\n' )
@@ -218,20 +252,34 @@ class CLI( Cmd ):
            self.mn.configLinkStatus( *args )

    def do_xterm( self, line, term='xterm' ):
-        "Spawn xterm(s) for the given node(s)."
+        """Spawn xterm(s) for the given node(s).
+           Usage: xterm node1 node2 ..."""
        args = line.split()
        if not args:
            error( 'usage: %s node1 node2 ...\n' % term )
        else:
            for arg in args:
-                if arg not in self.nodemap:
+                if arg not in self.mn:
                    error( "node '%s' not in network\n" % arg )
                else:
-                    node = self.nodemap[ arg ]
+                    node = self.mn[ arg ]
                    self.mn.terms += makeTerms( [ node ], term = term )

+    def do_x( self, line ):
+        """Create an X11 tunnel to the given node,
+           optionally starting a client.
+           Usage: x node [cmd args]"""
+        args = line.split()
+        if not args:
+            error( 'usage: x node [cmd args]...\n' )
+        else:
+            node = self.mn[ args[ 0 ] ]
+            cmd = args[ 1: ]
+            self.mn.terms += runX11( node, cmd )
+
    def do_gterm( self, line ):
-        "Spawn gnome-terminal(s) for the given node(s)."
+        """Spawn gnome-terminal(s) for the given node(s).
+           Usage: gterm node1 node2 ..."""
        self.do_xterm( line, term='gterm' )

    def do_exit( self, _line ):
@@ -252,7 +300,8 @@ class CLI( Cmd ):
        return isatty( self.stdin.fileno() )

    def do_noecho( self, line ):
-        "Run an interactive command with echoing turned off."
+        """Run an interactive command with echoing turned off.
+           Usage: noecho [cmd args]"""
        if self.isatty():
            quietRun( 'stty -echo' )
        self.default( line )
@@ -260,7 +309,8 @@ class CLI( Cmd ):
            quietRun( 'stty echo' )

    def do_source( self, line ):
-        "Read commands from an input file."
+        """Read commands from an input file.
+           Usage: source <file>"""
        args = line.split()
        if len(args) != 1:
            error( 'usage: source <file>\n' )
@@ -275,10 +325,12 @@ class CLI( Cmd ):
                    break
        except IOError:
            error( 'error reading file %s\n' % args[ 0 ] )
+        self.inputFile.close()
        self.inputFile = None

    def do_dpctl( self, line ):
-        "Run dpctl command on all switches."
+        """Run dpctl (or ovs-ofctl) command on all switches.
+           Usage: dpctl command [arg1] [arg2] ..."""
        args = line.split()
        if len(args) < 1:
            error( 'usage: dpctl command [arg1] [arg2] ...\n' )
@@ -294,6 +346,31 @@ class CLI( Cmd ):
        elapsed = time.time() - start
        self.stdout.write("*** Elapsed time: %0.6f secs\n" % elapsed)

+    def do_links( self, line ):
+        "Report on links"
+        for link in self.mn.links:
+            print link, link.status()
+
+    def do_switch( self, line ):
+        "Starts or stops a switch"
+        args = line.split()
+        if len(args) != 2:
+            error( 'invalid number of args: switch <switch name> {start, stop}\n' )
+            return
+        sw = args[ 0 ]
+        command = args[ 1 ]
+        if sw not in self.mn or self.mn.get( sw ) not in self.mn.switches :
+            error( 'invalid switch: %s\n' % args[ 1 ] )
+        else:
+            sw = args[ 0 ]
+            command = args[ 1 ]
+            if command == 'start':
+                self.mn.get( sw ).start( self.mn.controllers )
+            elif command == 'stop':
+                self.mn.get( sw ).stop( deleteIntfs=False )
+            else:
+                error( 'invalid command: switch <switch name> {start, stop}\n' )
+
    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.
@@ -301,30 +378,29 @@ class CLI( Cmd ):
        corresponding IP addrs."""

        first, args, line = self.parseline( line )
-        if not args:
-            return
-        if args and len(args) > 0 and args[ -1 ] == '\n':
-            args = args[ :-1 ]
-        rest = args.split( ' ' )

-        if first in self.nodemap:
-            node = self.nodemap[ first ]
+        if first in self.mn:
+            if not args:
+                print "*** Enter a command for node: %s <cmd>" % first
+                return
+            node = self.mn[ first ]
+            rest = args.split( ' ' )
            # Substitute IP addresses for node names in command
-            rest = [ self.nodemap[ arg ].IP()
-                     if arg in self.nodemap else arg
+            # If updateIP() returns None, then use node name
+            rest = [ self.mn[ arg ].defaultIntf().updateIP() or arg
+                     if arg in self.mn else arg
                     for arg in rest ]
            rest = ' '.join( rest )
            # Run cmd on node:
-            builtin = isShellBuiltin( first )
-            node.sendCmd( rest, printPid=( not builtin ) )
+            node.sendCmd( rest )
            self.waitForNode( node )
        else:
-            error( '*** Unknown command: %s\n' % first )
+            error( '*** Unknown command: %s\n' % line )

    # pylint: enable-msg=R0201

    def waitForNode( self, node ):
-        "Wait for a node to finish, and  print its output."
+        "Wait for a node to finish, and print its output."
        # Pollers
        nodePoller = poll()
        nodePoller.register( node.stdout )
@@ -342,7 +418,7 @@ class CLI( Cmd ):
                if False and self.inputFile:
                    key = self.inputFile.read( 1 )
                    if key is not '':
-                        node.write(key)
+                        node.write( key )
                    else:
                        self.inputFile = None
                if isReadable( self.inPoller ):
@@ -354,8 +430,18 @@ class CLI( Cmd ):
                if not node.waiting:
                    break
            except KeyboardInterrupt:
+                # There is an at least one race condition here, since
+                # it's possible to interrupt ourselves after we've
+                # read data but before it has been printed.
                node.sendInt()

+    def precmd( self, line ):
+        "allow for comments in the cli"
+        if '#' in line:
+            line = line.split( '#' )[ 0 ]
+        return line
+
+
 # Helper functions

 def isReadable( poller ):
@@ -0,0 +1 @@
+../examples
@@ -25,15 +25,15 @@ Link: basic link class for creating veth pairs
 """

 from mininet.log import info, error, debug
-from mininet.util import makeIntfPair
-from time import sleep
+from mininet.util import makeIntfPair, quietRun
 import re

 class Intf( object ):

    "Basic interface object that can configure itself."

-    def __init__( self, name, node=None, port=None, link=None, **params ):
+    def __init__( self, name, node=None, port=None, link=None,
+                  mac=None, srcNode=None, **params ):
        """name: interface name (e.g. h1-eth0)
           node: owning node (where this intf most likely lives)
           link: parent link if we're part of a link
@@ -41,7 +41,13 @@ class Intf( object ):
        self.node = node
        self.name = name
        self.link = link
-        self.mac, self.ip, self.prefixLen = None, None, None
+        self.mac = mac
+        self.ip, self.prefixLen = None, None
+        
+        # if interface is lo, we know the ip is 127.0.0.1.
+        # This saves an ifconfig command per node
+        if self.name == 'lo':
+            self.ip = '127.0.0.1'
        # Add to node (and move ourselves if necessary )
        node.addIntf( self, port=port )
        # Save params for future reference
@@ -64,6 +70,8 @@ class Intf( object ):
            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 ) )

@@ -80,7 +88,9 @@ class Intf( object ):

    def updateIP( self ):
        "Return updated IP address based on ifconfig"
-        ifconfig = self.ifconfig()
+        # 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 )
        self.ip = ips[ 0 ] if ips else None
        return self.ip
@@ -92,6 +102,19 @@ class Intf( object ):
        self.mac = macs[ 0 ] if macs else None
        return self.mac

+    # Instead of updating ip and mac separately,
+    # use one ifconfig call to do it simultaneously.
+    # This saves an ifconfig command, which improves performance.
+
+    def updateAddr( self ):
+        "Return IP address and MAC address based on ifconfig."
+        ifconfig = self.ifconfig()
+        ips = self._ipMatchRegex.findall( ifconfig )
+        macs = self._macMatchRegex.findall( ifconfig )
+        self.ip = ips[ 0 ] if ips else None
+        self.mac = macs[ 0 ] if macs else None
+        return self.ip, self.mac
+
    def IP( self ):
        "Return IP address"
        return self.ip
@@ -103,8 +126,15 @@ class Intf( object ):
    def isUp( self, setUp=False ):
        "Return whether interface is up"
        if setUp:
-            self.ifconfig( 'up' )
-        return "UP" in self.ifconfig()
+            cmdOutput = self.ifconfig( 'up' )
+            # no output indicates success
+            if cmdOutput:
+                error( "Error setting %s up: %s " % ( self.name, cmdOutput ) )
+                return False
+            else:
+                return True
+        else:
+            return "UP" in self.ifconfig()

    def rename( self, newname ):
        "Rename interface"
@@ -130,9 +160,9 @@ class Intf( object ):
        f = getattr( self, method, None )
        if not f or value is None:
            return
-        if type( value ) is list:
+        if isinstance( value, list ):
            result = f( *value )
-        elif type( value ) is dict:
+        elif isinstance( value, dict ):
            result = f( **value )
        else:
            result = f( value )
@@ -155,15 +185,22 @@ class Intf( object ):
        self.setParam( r, 'setIP', ip=ip )
        self.setParam( r, 'isUp', up=up )
        self.setParam( r, 'ifconfig', ifconfig=ifconfig )
-        self.updateIP()
-        self.updateMAC()
        return r

    def delete( self ):
        "Delete interface"
        self.cmd( 'ip link del ' + self.name )
-        # Does it help to sleep to let things run?
-        sleep( 0.001 )
+        if self.node.inNamespace:
+            # Link may have been dumped into root NS
+            quietRun( 'ip link del ' + self.name )
+
+    def status( self ):
+        "Return intf status as a string"
+        links, err_, result_ = self.node.pexec( 'ip link show' )
+        if self.name in links:
+            return "OK"
+        else:
+            return "MISSING"

    def __repr__( self ):
        return '<%s %s>' % ( self.__class__.__name__, self.name )
@@ -196,36 +233,36 @@ class TCIntf( Intf ):
            # are specifying the correct sizes. For now I have used
            # the same settings we had in the mininet-hifi code.
            if use_hfsc:
-                cmds += [ '%s qdisc add dev %s root handle 1:0 hfsc default 1',
-                          '%s class add dev %s parent 1:0 classid 1:1 hfsc sc '
+                cmds += [ '%s qdisc add dev %s root handle 5:0 hfsc default 1',
+                          '%s class add dev %s parent 5:0 classid 5:1 hfsc sc '
                          + 'rate %fMbit ul rate %fMbit' % ( bw, bw ) ]
            elif use_tbf:
                if latency_ms is None:
                    latency_ms = 15 * 8 / bw
-                cmds += [ '%s qdisc add dev %s root handle 1: tbf ' +
+                cmds += [ '%s qdisc add dev %s root handle 5: tbf ' +
                          'rate %fMbit burst 15000 latency %fms' %
                          ( bw, latency_ms ) ]
            else:
-                cmds += [ '%s qdisc add dev %s root handle 1:0 htb default 1',
-                          '%s class add dev %s parent 1:0 classid 1:1 htb ' +
+                cmds += [ '%s qdisc add dev %s root handle 5:0 htb default 1',
+                          '%s class add dev %s parent 5:0 classid 5:1 htb ' +
                          'rate %fMbit burst 15k' % bw ]
-            parent = ' parent 1:1 '
+            parent = ' parent 5:1 '

            # ECN or RED
            if enable_ecn:
                cmds += [ '%s qdisc add dev %s' + parent +
-                          'handle 10: red limit 1000000 ' +
+                          'handle 6: red limit 1000000 ' +
                          'min 30000 max 35000 avpkt 1500 ' +
                          'burst 20 ' +
                          'bandwidth %fmbit probability 1 ecn' % bw ]
-                parent = ' parent 10: '
+                parent = ' parent 6: '
            elif enable_red:
                cmds += [ '%s qdisc add dev %s' + parent +
-                          'handle 10: red limit 1000000 ' +
+                          'handle 6: red limit 1000000 ' +
                          'min 30000 max 35000 avpkt 1500 ' +
                          'burst 20 ' +
                          'bandwidth %fmbit probability 1' % bw ]
-                parent = ' parent 10: '
+                parent = ' parent 6: '
        return cmds, parent

    @staticmethod
@@ -251,7 +288,8 @@ class TCIntf( Intf ):
                cmds = [ '%s qdisc add dev %s ' + parent +
                         ' handle 10: netem ' +
                         netemargs ]
-        return cmds
+                parent = ' parent 10:1 '
+        return cmds, parent

    def tc( self, cmd, tc='tc' ):
        "Execute tc command for our interface"
@@ -278,7 +316,11 @@ class TCIntf( Intf ):
            return

        # Clear existing configuration
-        cmds = [ '%s qdisc del dev %s root' ]
+        tcoutput = self.tc( '%s qdisc show dev %s' )
+        if "priomap" not in tcoutput:
+            cmds = [ '%s qdisc del dev %s root' ]
+        else:
+            cmds = []

        # Bandwidth limits via various methods
        bwcmds, parent = self.bwCmds( bw=bw, speedup=speedup,
@@ -289,9 +331,10 @@ class TCIntf( Intf ):
        cmds += bwcmds

        # Delay/jitter/loss/max_queue_size using netem
-        cmds += self.delayCmds( delay=delay, jitter=jitter, loss=loss,
-                                max_queue_size=max_queue_size,
+        delaycmds, parent = self.delayCmds( delay=delay, jitter=jitter,
+                                loss=loss, max_queue_size=max_queue_size,
                                parent=parent )
+        cmds += delaycmds

        # Ugly but functional: display configuration info
        stuff = ( ( [ '%.2fMbit' % bw ] if bw is not None else [] ) +
@@ -305,9 +348,13 @@ class TCIntf( Intf ):
        # Execute all the commands in our node
        debug("at map stage w/cmds: %s\n" % cmds)
        tcoutputs = [ self.tc(cmd) for cmd in cmds ]
+        for output in tcoutputs:
+            if output != '':
+                error( "*** Error: %s" % output )
        debug( "cmds:", cmds, '\n' )
        debug( "outputs:", tcoutputs, '\n' )
        result[ 'tcoutputs'] = tcoutputs
+        result[ 'parent' ] = parent

        return result

@@ -318,7 +365,7 @@ class Link( object ):
       Other types of links could be tunnels, link emulators, etc.."""

    def __init__( self, node1, node2, port1=None, port2=None,
-                  intfName1=None, intfName2=None,
+                  intfName1=None, intfName2=None, addr1=None, addr2=None,
                  intf=Intf, cls1=None, cls2=None, params1=None,
                  params2=None ):
        """Create veth link to another node, making two new interfaces.
@@ -333,65 +380,81 @@ class Link( object ):
           params1: parameters for interface 1
           params2: parameters for interface 2"""
        # This is a bit awkward; it seems that having everything in
-        # params would be more orthogonal, but being able to specify
-        # in-line arguments is more convenient!
-        if port1 is None:
-            port1 = node1.newPort()
-        if port2 is None:
-            port2 = node2.newPort()
+        # params is more orthogonal, but being able to specify
+        # in-line arguments is more convenient! So we support both.
+        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:
+            params2[ 'port' ] = port2
+        if 'port' not in params1:
+            params1[ 'port' ] = node1.newPort()
+        if 'port' not in params2:
+            params2[ 'port' ] = node2.newPort()
        if not intfName1:
-            intfName1 = self.intfName( node1, port1 )
+            intfName1 = self.intfName( node1, params1[ 'port' ] )
        if not intfName2:
-            intfName2 = self.intfName( node2, port2 )
+            intfName2 = self.intfName( node2, params2[ 'port' ] )

-        self.makeIntfPair( intfName1, intfName2 )
+        self.makeIntfPair( intfName1, intfName2, addr1, addr2 )

        if not cls1:
            cls1 = intf
        if not cls2:
            cls2 = intf
-        if not params1:
-            params1 = {}
-        if not params2:
-            params2 = {}

-        intf1 = cls1( name=intfName1, node=node1, port=port1,
-                      link=self, **params1  )
-        intf2 = cls2( name=intfName2, node=node2, port=port2,
-                      link=self, **params2 )
+        intf1 = cls1( name=intfName1, node=node1,
+                      link=self, mac=addr1, **params1  )
+        intf2 = cls2( name=intfName2, node=node2,
+                      link=self, mac=addr2, **params2 )

        # All we are is dust in the wind, and our two interfaces
        self.intf1, self.intf2 = intf1, intf2

-    @classmethod
-    def intfName( cls, node, n ):
+    def intfName( self, node, n ):
        "Construct a canonical interface name node-ethN for interface n."
        return node.name + '-eth' + repr( n )

    @classmethod
-    def makeIntfPair( cls, intf1, intf2 ):
+    def makeIntfPair( _cls, intfname1, intfname2, addr1=None, addr2=None ):
        """Create pair of interfaces
-           intf1: name of interface 1
-           intf2: name of interface 2
-           (override this class method [and possibly delete()]
+           intfname1: name of interface 1
+           intfname2: name of interface 2
+           (override this method [and possibly delete()]
           to change link type)"""
-        makeIntfPair( intf1, intf2  )
+        return makeIntfPair( intfname1, intfname2, addr1, addr2 )

    def delete( self ):
        "Delete this link"
        self.intf1.delete()
        self.intf2.delete()

+    def stop( self ):
+        "Override to stop and clean up link as needed"
+        pass
+
+    def status( self ):
+        "Return link status as a string"
+        return "(%s %s)" % ( self.intf1.status(), self.intf2.status() )
+
    def __str__( self ):
        return '%s<->%s' % ( self.intf1, self.intf2 )

 class TCLink( Link ):
    "Link with symmetric TC interfaces configured via opts"
    def __init__( self, node1, node2, port1=None, port2=None,
-                  intfName1=None, intfName2=None, **params ):
+                  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)
+                       params2=params )
@@ -57,21 +57,19 @@ class StreamHandlerNoNewline( logging.StreamHandler ):

 class Singleton( type ):
    """Singleton pattern from Wikipedia
-       See http://en.wikipedia.org/wiki/SingletonPattern#Python
+       See http://en.wikipedia.org/wiki/Singleton_Pattern

       Intended to be used as a __metaclass_ param, as shown for the class
-       below.
+       below."""

-       Changed cls first args to mcs to satisfy pylint."""
+    def __init__( cls, name, bases, dict_ ):
+        super( Singleton, cls ).__init__( name, bases, dict_ )
+        cls.instance = None

-    def __init__( mcs, name, bases, dict_ ):
-        super( Singleton, mcs ).__init__( name, bases, dict_ )
-        mcs.instance = None
-
-    def __call__( mcs, *args, **kw ):
-        if mcs.instance is None:
-            mcs.instance = super( Singleton, mcs ).__call__( *args, **kw )
-            return mcs.instance
+    def __call__( cls, *args, **kw ):
+        if cls.instance is None:
+            cls.instance = super( Singleton, cls ).__call__( *args, **kw )
+        return cls.instance


 class MininetLogger( Logger, object ):
@@ -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 type( subtract ) is str:
+    if isinstance( subtract, basestring ):
        subtract = [ subtract ]
-    if type( add ) is str:
+    if isinstance( add, basestring ):
        add = [ add ]
    for mod in subtract:
        if mod in lsmod():
@@ -90,28 +90,33 @@ import os
 import re
 import select
 import signal
+import random
+
 from time import sleep
+from itertools import chain, groupby
+from math import ceil

 from mininet.cli import CLI
-from mininet.log import info, error, debug, output
-from mininet.node import Host, OVSKernelSwitch, Controller
+from mininet.log import info, error, debug, output, warn
+from mininet.node import Host, OVSKernelSwitch, DefaultController, Controller
+from mininet.nodelib import NAT
 from mininet.link import Link, Intf
 from mininet.util import quietRun, fixLimits, numCores, ensureRoot
 from mininet.util import macColonHex, ipStr, ipParse, netParse, ipAdd
 from mininet.term import cleanUpScreens, makeTerms

 # Mininet version: should be consistent with README and LICENSE
-VERSION = "2.0.0"
+VERSION = "2.2.0b1"

 class Mininet( object ):
    "Network emulation with hosts spawned in network namespaces."

    def __init__( self, topo=None, switch=OVSKernelSwitch, host=Host,
-                  controller=Controller, link=Link, intf=Intf,
+                  controller=DefaultController, link=Link, intf=Intf,
                  build=True, xterms=False, cleanup=False, ipBase='10.0.0.0/8',
                  inNamespace=False,
                  autoSetMacs=False, autoStaticArp=False, autoPinCpus=False,
-                  listenPort=None ):
+                  listenPort=None, waitConnected=False ):
        """Create Mininet object.
           topo: Topo (topology) object or None
           switch: default Switch class
@@ -147,10 +152,12 @@ class Mininet( object ):
        self.numCores = numCores()
        self.nextCore = 0  # next core for pinning hosts to CPUs
        self.listenPort = listenPort
+        self.waitConn = waitConnected

        self.hosts = []
        self.switches = []
        self.controllers = []
+        self.links = []

        self.nameToNode = {}  # name to Node (Host/Switch) objects

@@ -162,6 +169,37 @@ class Mininet( object ):
        if topo and build:
            self.build()

+
+    def waitConnected( self, timeout=None, delay=.5 ):
+        """wait for each switch to connect to a controller,
+           up to 5 seconds
+           timeout: time to wait, or None to wait indefinitely
+           delay: seconds to sleep per iteration
+           returns: True if all switches are connected"""
+        info( '*** Waiting for switches to connect\n' )
+        time = 0
+        remaining = list( self.switches )
+        while True:
+            for switch in tuple( remaining ):
+                if switch.connected():
+                    info( '%s ' % switch )
+                    remaining.remove( switch )
+            if not remaining:
+                info( '\n' )
+                return True
+            if time > timeout and timeout is not None:
+                break
+            sleep( delay )
+            time += delay
+        warn( 'Timed out after %d seconds\n' % time )
+        for switch in remaining:
+            if not switch.connected():
+                warn( 'Warning: %s is not connected to a controller\n'
+                      % switch.name )
+            else:
+                remaining.remove( switch )
+        return not remaining
+
    def addHost( self, name, cls=None, **params ):
        """Add host.
           name: name of host to add
@@ -174,7 +212,7 @@ class Mininet( object ):
                                  prefixLen=self.prefixLen ) +
                                  '/%s' % self.prefixLen }
        if self.autoSetMacs:
-            defaults[ 'mac'] = macColonHex( self.nextIP )
+            defaults[ 'mac' ] = macColonHex( self.nextIP )
        if self.autoPinCpus:
            defaults[ 'cores' ] = self.nextCore
            self.nextCore = ( self.nextCore + 1 ) % self.numCores
@@ -208,16 +246,40 @@ class Mininet( object ):
    def addController( self, name='c0', controller=None, **params ):
        """Add controller.
           controller: Controller class"""
+        # Get controller class
        if not controller:
            controller = self.controller
-        controller_new = controller( name, **params )
-        if controller_new:  # allow controller-less setups
+        # Construct new controller if one is not given
+        if isinstance( name, Controller ):
+            controller_new = name
+            # Pylint thinks controller is a str()
+            # pylint: disable=E1103
+            name = controller_new.name
+            # pylint: enable=E1103
+        else:
+            controller_new = controller( name, **params )
+        # Add new controller to net
+        if controller_new: # allow controller-less setups
            self.controllers.append( controller_new )
            self.nameToNode[ name ] = controller_new
        return controller_new

-    # BL: is this better than just using nameToNode[] ?
-    # Should it have a better name?
+    def addNAT( self, name='nat0', connect=True, inNamespace=False, **params ):
+        nat = self.addHost( name, cls=NAT, inNamespace=inNamespace,
+                            subnet=self.ipBase, **params )
+        # find first switch and create link
+        if connect:
+            # connect the nat to the first switch
+            self.addLink( nat, self.switches[ 0 ] )
+            # set the default route on hosts
+            natIP = nat.params[ 'ip' ].split('/')[ 0 ]
+            for host in self.hosts:
+                if host.inNamespace:
+                    host.setDefaultRoute( 'via %s' % natIP )
+        return nat
+
+    # BL: We now have four ways to look up nodes
+    # This may (should?) be cleaned up in the future.
    def getNodeByName( self, *args ):
        "Return node(s) with given name(s)"
        if len( args ) == 1:
@@ -228,21 +290,69 @@ class Mininet( object ):
        "Convenience alias for getNodeByName"
        return self.getNodeByName( *args )

+    # Even more convenient syntax for node lookup and iteration
+    def __getitem__( self, key ):
+        """net [ name ] operator: Return node(s) with given name(s)"""
+        return self.nameToNode[ key ]
+
+    def __iter__( self ):
+        "return iterator over node names"
+        for node in chain( self.hosts, self.switches, self.controllers ):
+            yield node.name
+
+    def __len__( self ):
+        "returns number of nodes in net"
+        return ( len( self.hosts ) + len( self.switches ) +
+                 len( self.controllers ) )
+
+    def __contains__( self, item ):
+        "returns True if net contains named node"
+        return item in self.nameToNode
+
+    def keys( self ):
+        "return a list of all node names or net's keys"
+        return list( self )
+
+    def values( self ):
+        "return a list of all nodes or net's values"
+        return [ self[name] for name in self ]
+
+    def items( self ):
+        "return (key,value) tuple list for every node in net"
+        return zip( self.keys(), self.values() )
+
+    @staticmethod
+    def randMac():
+        "Return a random, non-multicast MAC address"
+        return macColonHex( random.randint(1, 2**48 - 1) & 0xfeffffffffff  |
+                            0x020000000000 )
+
    def addLink( self, node1, node2, port1=None, port2=None,
                 cls=None, **params ):
        """"Add a link from node1 to node2
-            node1: source node
-            node2: dest node
-            port1: source port
-            port2: dest port
+            node1: source node (or name)
+            node2: dest node (or name)
+            port1: source port (optional)
+            port2: dest port (optional)
+            cls: link class (optional)
+            params: additional link params (optional)
            returns: link object"""
-        defaults = { 'port1': port1,
-                     'port2': port2,
-                     'intf': self.intf }
-        defaults.update( params )
-        if not cls:
-            cls = self.link
-        return cls( node1, node2, **defaults )
+        # 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 ]
+        options = dict( params )
+        # Port is optional
+        if port1 is not None:
+            options.setdefault( 'port1', port1 )
+        if port2 is not None:
+            options.setdefault( 'port2', port2 )
+        # Set default MAC - this should probably be in Link
+        options.setdefault( 'addr1', self.randMac() )
+        options.setdefault( 'addr2', self.randMac() )
+        cls = self.link if cls is None else cls
+        link = cls( node1, node2, **options )
+        self.links.append( link )
+        return link

    def configHosts( self ):
        "Configure a set of hosts."
@@ -250,7 +360,7 @@ class Mininet( object ):
            info( host.name + ' ' )
            intf = host.defaultIntf()
            if intf:
-                host.configDefault( defaultRoute=intf )
+                host.configDefault()
            else:
                # Don't configure nonexistent intf
                host.configDefault( ip=None, mac=None )
@@ -260,7 +370,6 @@ class Mininet( object ):
            # quietRun( 'renice +18 -p ' + repr( host.pid ) )
            # This may not be the right place to do this, but
            # it needs to be done somewhere.
-            host.cmd( 'ifconfig lo up' )
        info( '\n' )

    def buildFromTopo( self, topo=None ):
@@ -275,14 +384,18 @@ class Mininet( object ):

        info( '*** Creating network\n' )

-        if not self.controllers:
+        if not self.controllers and self.controller:
            # Add a default controller
            info( '*** Adding controller\n' )
            classes = self.controller
-            if type( classes ) is not list:
+            if not isinstance( classes, list ):
                classes = [ classes ]
            for i, cls in enumerate( classes ):
-                self.addController( 'c%d' % i, cls )
+                # Allow Controller objects because nobody understands currying
+                if isinstance( cls, Controller ):
+                    self.addController( cls )
+                else:
+                    self.addController( 'c%d' % i, cls )

        info( '*** Adding hosts:\n' )
        for hostName in topo.hosts():
@@ -295,12 +408,10 @@ class Mininet( object ):
            info( switchName + ' ' )

        info( '\n*** Adding links:\n' )
-        for srcName, dstName in topo.links(sort=True):
-            src, dst = self.nameToNode[ srcName ], self.nameToNode[ dstName ]
-            params = topo.linkInfo( srcName, dstName )
-            srcPort, dstPort = topo.port( srcName, dstName )
-            self.addLink( src, dst, srcPort, dstPort, **params )
-            info( '(%s, %s) ' % ( src.name, dst.name ) )
+        for srcName, dstName, params in topo.links(
+                sort=True, withInfo=True ):
+            self.addLink( **params )
+            info( '(%s, %s) ' % ( srcName, dstName ) )

        info( '\n' )

@@ -313,7 +424,7 @@ class Mininet( object ):
        "Build mininet."
        if self.topo:
            self.buildFromTopo( self.topo )
-        if ( self.inNamespace ):
+        if self.inNamespace:
            self.configureControlNetwork()
        info( '*** Configuring hosts\n' )
        self.configHosts()
@@ -325,6 +436,9 @@ class Mininet( object ):

    def startTerms( self ):
        "Start a terminal for each node."
+        if 'DISPLAY' not in os.environ:
+            error( "Error starting terms: Cannot connect to display\n" )
+            return
        info( "*** Running terms on %s\n" % os.environ[ 'DISPLAY' ] )
        cleanUpScreens()
        self.terms += makeTerms( self.controllers, 'controller' )
@@ -350,32 +464,44 @@ class Mininet( object ):
            self.build()
        info( '*** Starting controller\n' )
        for controller in self.controllers:
+            info( controller.name + ' ')
            controller.start()
+        info( '\n' )
        info( '*** Starting %s switches\n' % len( self.switches ) )
        for switch in self.switches:
            info( switch.name + ' ')
            switch.start( self.controllers )
        info( '\n' )
+        if self.waitConn:
+            self.waitConnected()

    def stop( self ):
        "Stop the controller(s), switches and hosts"
-        if self.terms:
-            info( '*** Stopping %i terms\n' % len( self.terms ) )
-            self.stopXterms()
-        info( '*** Stopping %i hosts\n' % len( self.hosts ) )
-        for host in self.hosts:
-            info( host.name + ' ' )
-            host.terminate()
-        info( '\n' )
-        info( '*** Stopping %i switches\n' % len( self.switches ) )
-        for switch in self.switches:
-            info( switch.name + ' ' )
-            switch.stop()
-        info( '\n' )
        info( '*** Stopping %i controllers\n' % len( self.controllers ) )
        for controller in self.controllers:
            info( controller.name + ' ' )
            controller.stop()
+        info( '\n' )
+        if self.terms:
+            info( '*** Stopping %i terms\n' % len( self.terms ) )
+            self.stopXterms()
+        info( '*** Stopping %i switches\n' % len( self.switches ) )
+        for swclass, switches in groupby( sorted( self.switches, key=type ), type ):
+            if hasattr( swclass, 'batchShutdown' ):
+                swclass.batchShutdown( switches )
+        for switch in self.switches:
+            info( switch.name + ' ' )
+            switch.stop()
+            switch.terminate()
+        info( '\n' )
+        info( '*** Stopping %i links\n' % len( self.links ) )
+        for link in self.links:
+            link.stop()
+        info( '\n' )
+        info( '*** Stopping %i hosts\n' % len( self.hosts ) )
+        for host in self.hosts:
+            info( host.name + ' ' )
+            host.terminate()
        info( '\n*** Done\n' )

    def run( self, test, *args, **kwargs ):
@@ -418,13 +544,13 @@ class Mininet( object ):
        "Parse ping output and return packets sent, received."
        # Check for downed link
        if 'connect: Network is unreachable' in pingOutput:
-            return (1, 0)
+            return 1, 0
        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' %
                   pingOutput )
-            return (1, 0)
+            return 1, 0
        sent, received = int( m.group( 1 ) ), int( m.group( 2 ) )
        return sent, received

@@ -447,8 +573,11 @@ class Mininet( object ):
                    opts = ''
                    if timeout:
                        opts = '-W %s' % timeout
-                    result = node.cmd( 'ping -c1 %s %s' % (opts, dest.IP()) )
-                    sent, received = self._parsePing( result )
+                    if dest.intfs:
+                        result = node.cmd( 'ping -c1 %s %s' % (opts, dest.IP()) )
+                        sent, received = self._parsePing( result )
+                    else:
+                        sent, received = 0, 0
                    packets += sent
                    if received > sent:
                        error( '*** Error: received too many packets' )
@@ -458,27 +587,41 @@ class Mininet( object ):
                    lost += sent - received
                    output( ( '%s ' % dest.name ) if received else 'X ' )
            output( '\n' )
-            ploss = 100 * lost / packets
-        output( "*** Results: %i%% dropped (%d/%d lost)\n" %
-                ( ploss, lost, packets ) )
+        if packets > 0:
+            ploss = 100.0 * lost / packets
+            received = packets - lost
+            output( "*** Results: %i%% dropped (%d/%d received)\n" %
+                    ( ploss, received, packets ) )
+        else:
+            ploss = 0
+            output( "*** Warning: No packets sent\n" )
        return ploss

    @staticmethod
    def _parsePingFull( pingOutput ):
        "Parse ping output and return all data."
+        errorTuple = (1, 0, 0, 0, 0, 0)
        # Check for downed link
-        if 'connect: Network is unreachable' in pingOutput:
-            return (1, 0)
+        r = r'[uU]nreachable'
+        m = re.search( r, pingOutput )
+        if m is not None:
+            return errorTuple
        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' %
                   pingOutput )
-            return (1, 0, 0, 0, 0, 0)
+            return errorTuple
        sent, received = int( m.group( 1 ) ), int( m.group( 2 ) )
        r = r'rtt min/avg/max/mdev = '
        r += r'(\d+\.\d+)/(\d+\.\d+)/(\d+\.\d+)/(\d+\.\d+) ms'
        m = re.search( r, pingOutput )
+        if m is None:
+            if received == 0:
+                return errorTuple
+            error( '*** Error: could not parse ping output: %s\n' %
+                   pingOutput )
+            return errorTuple
        rttmin = float( m.group( 1 ) )
        rttavg = float( m.group( 2 ) )
        rttmax = float( m.group( 3 ) )
@@ -518,10 +661,10 @@ class Mininet( object ):
                    (rttmin, rttavg, rttmax, rttdev) )
        return all_outputs

-    def pingAll( self ):
+    def pingAll( self, timeout=None ):
        """Ping between all hosts.
           returns: ploss packet loss percentage"""
-        return self.ping()
+        return self.ping( timeout=timeout )

    def pingPair( self ):
        """Ping between first two hosts, useful for testing.
@@ -556,11 +699,18 @@ class Mininet( object ):

    # XXX This should be cleaned up

-    def iperf( self, hosts=None, l4Type='TCP', udpBw='10M' ):
+    def iperf( self, hosts=None, l4Type='TCP', udpBw='10M', format=None,
+               seconds=5):
        """Run iperf between two hosts.
           hosts: list of hosts; if None, uses opposite hosts
           l4Type: string, one of [ TCP, UDP ]
-           returns: results two-element array of server and client speeds"""
+           udpBw: bandwidth target for UDP test
+           format: iperf format argument if any
+           seconds: iperf time to transmit
+           returns: two-element array of [ server, client ] speeds
+           note: send() is buffered, so client rate can be much higher than
+           the actual transmission rate; on an unloaded system, server
+           rate should be much closer to the actual receive rate"""
        if not quietRun( 'which telnet' ):
            error( 'Cannot find telnet in $PATH - required for iperf test' )
            return
@@ -579,6 +729,8 @@ class Mininet( object ):
            bwArgs = '-b ' + udpBw + ' '
        elif l4Type != 'TCP':
            raise Exception( 'Unexpected l4 type: %s' % l4Type )
+        if format:
+          iperfArgs += '-f %s ' %format
        server.sendCmd( iperfArgs + '-s', printPid=True )
        servout = ''
        while server.lastPid is None:
@@ -586,10 +738,10 @@ class Mininet( object ):
        if l4Type == 'TCP':
            while 'Connected' not in client.cmd(
                    'sh -c "echo A | telnet -e A %s 5001"' % server.IP()):
-                output('waiting for iperf to start up...')
+                info( 'Waiting for iperf to start up...' )
                sleep(.5)
-        cliout = client.cmd( iperfArgs + '-t 5 -c ' + server.IP() + ' ' +
-                             bwArgs )
+        cliout = client.cmd( iperfArgs + '-t %d -c ' % seconds +
+                             server.IP() + ' ' + bwArgs )
        debug( 'Client output: %s\n' % cliout )
        server.sendInt()
        servout += server.waitOutput()
@@ -606,33 +758,41 @@ class Mininet( object ):
        duration: test duration in seconds
        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)
+        info( '*** Testing CPU %.0f%% bandwidth limit\n' % pct )
        hosts = self.hosts
+        cores = int( quietRun( 'nproc' ) )
+        # number of processes to run a while loop on per host
+        num_procs = int( ceil( cores * cpu ) )
+        pids = {}
        for h in hosts:
-            h.cmd( 'while true; do a=1; done &' )
-        pids = [h.cmd( 'echo $!' ).strip() for h in hosts]
-        pids_str = ",".join(["%s" % pid for pid in pids])
-        cmd = 'ps -p %s -o pid,%%cpu,args' % pids_str
-        # It's a shame that this is what pylint prefers
-        outputs = []
-        for _ in range( duration ):
+            pids[ h ] = []
+            for _core in range( num_procs ):
+                h.cmd( 'while true; do a=1; done &' )
+                pids[ h ].append( h.cmd( 'echo $!' ).strip() )
+        outputs = {}
+        time = {}
+        # get the initial cpu time for each host
+        for host in hosts:
+            outputs[ host ] = []
+            with open( '/sys/fs/cgroup/cpuacct/%s/cpuacct.usage' % host, 'r' ) as f:
+                time[ host ] = float( f.read() )
+        for _ in range( 5 ):
            sleep( 1 )
-            outputs.append( quietRun( cmd ).strip() )
-        for h in hosts:
-            h.cmd( 'kill %1' )
+            for host in hosts:
+                with open( '/sys/fs/cgroup/cpuacct/%s/cpuacct.usage' % host, 'r' ) as f:
+                    readTime = float( f.read() )
+                outputs[ host ].append( ( ( readTime - time[ host ] )
+                                        / 1000000000 ) / cores * 100 )
+                time[ host ] = readTime
+        for h, pids in pids.items():
+            for pid in pids:
+                h.cmd( 'kill -9 %s' % pid )
        cpu_fractions = []
-        for test_output in outputs:
-            # Split by line.  Ignore first line, which looks like this:
-            # PID %CPU COMMAND\n
-            for line in test_output.split('\n')[1:]:
-                r = r'\d+\s*(\d+\.\d+)'
-                m = re.search( r, line )
-                if m is None:
-                    error( '*** Error: could not extract CPU fraction: %s\n' %
-                           line )
-                    return None
-                cpu_fractions.append( float( m.group( 1 ) ) )
+        for _host, outputs in outputs.items():
+            for pct in outputs:
+                cpu_fractions.append( pct )
        output( '*** Results: %s\n' % cpu_fractions )
        return cpu_fractions

@@ -648,9 +808,9 @@ class Mininet( object ):
        elif dst not in self.nameToNode:
            error( 'dst not in network: %s\n' % dst )
        else:
-            if type( src ) is str:
+            if isinstance( src, basestring ):
                src = self.nameToNode[ src ]
-            if type( dst ) is str:
+            if isinstance( dst, basestring ):
                dst = self.nameToNode[ dst ]
            connections = src.connectionsTo( dst )
            if len( connections ) == 0:
@@ -0,0 +1,139 @@
+"""
+Node Library for Mininet
+
+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
+
+import re
+
+class LinuxBridge( Switch ):
+    "Linux Bridge (with optional spanning tree)"
+
+    nextPrio = 100  # next bridge priority for spanning tree
+
+    def __init__( self, name, stp=False, prio=None, **kwargs ):
+        """stp: use spanning tree protocol? (default False)
+           prio: optional explicit bridge priority for STP"""
+        self.stp = stp
+        if prio:
+            self.prio = prio
+        else:
+            self.prio = LinuxBridge.nextPrio
+            LinuxBridge.nextPrio += 1
+        Switch.__init__( self, name, **kwargs )
+
+    def connected( self ):
+        "Are we forwarding yet?"
+        if self.stp:
+            return 'forwarding' in self.cmd( 'brctl showstp', self )
+        else:
+            return True
+    
+    def start( self, controllers ):
+        "Start Linux bridge"
+        self.cmd( 'ifconfig', self, 'down' )
+        self.cmd( 'brctl delbr', self )
+        self.cmd( 'brctl addbr', self )
+        if self.stp:
+            self.cmd( 'brctl setbridgeprio', self.prio )
+            self.cmd( 'brctl stp', self, 'on' )
+        for i in self.intfList():
+            if self.name in i.name:
+                self.cmd( 'brctl addif', self, i )
+        self.cmd( 'ifconfig', self, 'up' )
+
+    def stop( self ):
+        "Stop Linux bridge"
+        self.cmd( 'ifconfig', self, 'down' )
+        self.cmd( 'brctl delbr', self )
+
+    def dpctl( self, *args ):
+        "Run brctl command"
+        return self.cmd( 'brctl', *args )
+
+    @classmethod
+    def setup( cls ):
+        "Make sure our class dependencies are available"
+        pathCheck( 'brctl', moduleName='bridge-utils' )
+
+
+class NAT( Node ):
+    """NAT: Provides connectivity to external network"""
+
+    def __init__( self, name, inetIntf=None, subnet='10.0/8', localIntf=None, **params):
+        super( NAT, self ).__init__( name, **params )
+
+        """Start NAT/forwarding between Mininet and external network
+        inetIntf: interface for internet access
+        subnet: Mininet subnet (default 10.0/8)="""
+        self.inetIntf = inetIntf if inetIntf else self.getGatewayIntf()
+        self.subnet = subnet
+        self.localIntf = localIntf
+
+    def config( self, **params ):
+        super( NAT, self).config( **params )
+        """Configure the NAT and iptables"""
+
+        if not self.localIntf:
+            self.localIntf =  self.defaultIntf()
+
+        self.cmd( 'sysctl net.ipv4.ip_forward=0' )
+
+        # 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 -i', self.inetIntf, '-d', self.subnet, '-j ACCEPT' )
+        self.cmd( 'iptables -t nat -A POSTROUTING -o ', self.inetIntf, '-s', self.subnet, '-j MASQUERADE' )
+
+        # Instruct the kernel to perform forwarding
+        self.cmd( 'sysctl net.ipv4.ip_forward=1' )
+
+        # Prevent network-manager from messing with our interface
+        # by specifying manual configuration in /etc/network/interfaces
+        intf = self.localIntf
+        cfile = '/etc/network/interfaces'
+        line = '\niface %s inet manual\n' % intf
+        config = open( cfile ).read()
+        if ( line ) not in config:
+            info( '*** Adding "' + line.strip() + '" to ' + cfile + '\n' )
+            with open( cfile, 'a' ) as f:
+                f.write( line )
+        # Probably need to restart network-manager to be safe -
+        # hopefully this won't disconnect you
+        self.cmd( 'service network-manager restart' )
+
+    def getGatewayIntf( self ):
+        routes = self.cmd( 'ip route show' )
+        match = re.search('default via \S+ dev (\S+)', routes )
+        if match:
+            return match.group( 1 )
+        else:
+            warn( 'There is no default route set. Using eth0 as gateway interface...\n' )
+            return 'eth0'
+
+    def terminate( self ):
+        """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()
+
@@ -1,60 +1,80 @@
 """
 Terminal creation and cleanup.
-Utility functions to run a term (connected via screen(1)) on each host.
+Utility functions to run a terminal (connected via socat(1)) on each host.

-Requires GNU screen(1) and xterm(1).
+Requires socat(1) and xterm(1).
 Optionally uses gnome-terminal.
 """

-import re
-from subprocess import Popen
+from os import environ

 from mininet.log import error
-from mininet.util import quietRun
+from mininet.util import quietRun, errRun

-def quoteArg( arg ):
-    "Quote an argument if it contains spaces."
-    return repr( arg ) if ' ' in arg else arg
+def tunnelX11( node, display=None):
+    """Create an X11 tunnel from node:6000 to the root host
+       display: display on root host (optional)
+       returns: node $DISPLAY, Popen object for tunnel"""
+    if display is None and 'DISPLAY' in environ:
+        display = environ[ 'DISPLAY' ]
+    if display is None:
+        error( "Error: Cannot connect to display\n" )
+        return None, None
+    host, screen = display.split( ':' )
+    # Unix sockets should work
+    if not host or host == 'unix':
+        # GDM3 doesn't put credentials in .Xauthority,
+        # so allow root to just connect
+        quietRun( 'xhost +si:localuser:root' )
+        return display, None
+    else:
+        # Create a tunnel for the TCP connection
+        port = 6000 + int( float( screen ) )
+        connection = r'TCP\:%s\:%s' % ( host, port )
+        cmd = [ "socat", "TCP-LISTEN:%d,fork,reuseaddr" % port,
+               "EXEC:'mnexec -a 1 socat STDIO %s'" % connection ]
+    return 'localhost:' + screen, node.popen( cmd )

-def makeTerm( node, title='Node', term='xterm' ):
-    """Run screen on a node, and hook up a terminal.
+def makeTerm( node, title='Node', term='xterm', display=None ):
+    """Create an X11 tunnel to the node and start up a terminal.
       node: Node object
       title: base title
       term: 'xterm' or 'gterm'
-       returns: process created"""
-    title += ': ' + node.name
+       returns: two Popen objects, tunnel and terminal"""
+    title = '"%s: %s"' % ( title, node.name )
    if not node.inNamespace:
        title += ' (root)'
    cmds = {
-        'xterm': [ 'xterm', '-title', title, '-e' ],
-        'gterm': [ 'gnome-terminal', '--title', title, '-e' ]
+        'xterm': [ 'xterm', '-title', title, '-display' ],
+        'gterm': [ 'gnome-terminal', '--title', title, '--display' ]
    }
    if term not in cmds:
        error( 'invalid terminal type: %s' % term )
        return
-    if not node.execed:
-        node.cmd( 'screen -dmS ' + 'mininet.' + node.name)
-        args = [ 'screen', '-D', '-RR', '-S', 'mininet.' + node.name ]
-    else:
-        args = [ 'sh', '-c', 'exec tail -f /tmp/' + node.name + '*.log' ]
-    if term == 'gterm':
-        # Compress these for gnome-terminal, which expects one token
-        # to follow the -e option
-        args = [ ' '.join( [ quoteArg( arg ) for arg in args ] ) ]
-    return Popen( cmds[ term ] + args )
+    display, tunnel = tunnelX11( node, display )
+    if display is None:
+        return []
+    term = node.popen( cmds[ term ] + [ display, '-e', 'env TERM=ansi bash'] )
+    return [ tunnel, term ] if tunnel else [ term ]
+
+def runX11( node, cmd ):
+    "Run an X11 client on a node"
+    _display, tunnel = tunnelX11( node )
+    if _display is None:
+        return []
+    popen = node.popen( cmd )
+    return [ tunnel, popen ]

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

 def makeTerms( nodes, title='Node', term='xterm' ):
    """Create terminals.
       nodes: list of Node objects
       title: base title for each
-       returns: list of created terminal processes"""
-    return [ makeTerm( node, title, term ) for node in nodes ]
+       returns: list of created tunnel/terminal processes"""
+    terms = []
+    for node in nodes:
+        terms += makeTerm( node, title, term )
+    return terms
@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+
+"""
+Run all mininet core tests
+ -v : verbose output
+ -quick : skip tests that take more than ~30 seconds
+"""
+
+import unittest
+import os
+import sys
+from mininet.util import ensureRoot
+from mininet.clean import cleanup
+from mininet.log import setLogLevel
+
+def runTests( testDir, verbosity=1 ):
+    "discover and run all tests in testDir"
+    # ensure root and cleanup before starting tests
+    ensureRoot()
+    cleanup()
+    # discover all tests in testDir
+    testSuite = unittest.defaultTestLoader.discover( testDir )
+    # run tests
+    unittest.TextTestRunner( verbosity=verbosity ).run( testSuite )
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    # get the directory containing example tests
+    testDir = os.path.dirname( os.path.realpath( __file__ ) )
+    verbosity = 2 if '-v' in sys.argv else 1
+    runTests( testDir, verbosity )
@@ -4,16 +4,16 @@
   Test creation and pings for topologies with link and/or CPU options."""

 import unittest
+from functools import partial

 from mininet.net import Mininet
-from mininet.node import OVSKernelSwitch
+from mininet.node import OVSSwitch, UserSwitch, IVSSwitch
 from mininet.node import CPULimitedHost
 from mininet.link import TCLink
 from mininet.topo import Topo
 from mininet.log import setLogLevel
+from mininet.util import quietRun

-
-SWITCH = OVSKernelSwitch
 # Number of hosts for each test
 N = 2

@@ -31,24 +31,56 @@ class SingleSwitchOptionsTopo(Topo):
            host = self.addHost('h%s' % (h + 1))
            self.addLink(host, switch)

+# Tell pylint not to complain about calls to other class
+# pylint: disable=E1101

-class testOptionsTopo( unittest.TestCase ):
-    "Verify ability to create networks with host and link options."
+class testOptionsTopoCommon( object ):
+    """Verify ability to create networks with host and link options
+       (common code)."""

-    def runOptionsTopoTest( self, n, hopts=None, lopts=None ):
+    switchClass = None # overridden in subclasses
+
+    def runOptionsTopoTest( self, n, msg, hopts=None, lopts=None ):
        "Generic topology-with-options test runner."
        mn = Mininet( topo=SingleSwitchOptionsTopo( n=n, hopts=hopts,
                                                    lopts=lopts ),
-                      host=CPULimitedHost, link=TCLink )
+                      host=CPULimitedHost, link=TCLink,
+                      switch=self.switchClass, waitConnected=True )
        dropped = mn.run( mn.ping )
-        self.assertEqual( dropped, 0 )
+        hoptsStr = ', '.join( '%s: %s' % ( opt, value )
+                              for opt, value in hopts.items() )
+        loptsStr = ', '.join( '%s: %s' % ( opt, value )
+                              for opt, value in lopts.items() )
+        msg += ( '%s%% of pings were dropped during mininet.ping().\n'
+                 'Topo = SingleSwitchTopo, %s hosts\n'
+                 'hopts = %s\n'
+                 'lopts = %s\n'
+                 'host = CPULimitedHost\n'
+                 'link = TCLink\n'
+                 'Switch = %s\n'
+                 % ( dropped, n, hoptsStr, loptsStr, self.switchClass ) )

-    def assertWithinTolerance(self, measured, expected, tolerance_frac):
+        self.assertEqual( dropped, 0, msg=msg )
+
+    def assertWithinTolerance( self, measured, expected, tolerance_frac, msg ):
        """Check that a given value is within a tolerance of expected
        tolerance_frac: less-than-1.0 value; 0.8 would yield 20% tolerance.
        """
-        self.assertTrue( float(measured) >= float(expected) * tolerance_frac )
-        self.assertTrue( float(measured) >= float(expected) * tolerance_frac )
+        upperBound = ( float( expected ) + ( 1 - tolerance_frac ) *
+                       float( expected ) )
+        lowerBound = float( expected ) * tolerance_frac
+        info = ( 'measured value is out of bounds\n'
+                 'expected value: %s\n'
+                 'measured value: %s\n'
+                 'failure tolerance: %s\n'
+                 'upper bound: %s\n'
+                 'lower bound: %s\n'
+                 % ( expected, measured, tolerance_frac,
+                     upperBound, lowerBound ) )
+        msg += info
+
+        self.assertGreaterEqual( float( measured ),lowerBound, msg=msg )
+        self.assertLessEqual( float( measured ), upperBound, msg=msg )

    def testCPULimits( self ):
        "Verify topology creation with CPU limits set for both schedulers."
@@ -58,46 +90,100 @@ class testOptionsTopo( unittest.TestCase ):
        #self.runOptionsTopoTest( N, hopts=hopts )

        mn = Mininet( SingleSwitchOptionsTopo( n=N, hopts=hopts ),
-                      host=CPULimitedHost )
+                      host=CPULimitedHost, switch=self.switchClass,
+                      waitConnected=True )
        mn.start()
        results = mn.runCpuLimitTest( cpu=CPU_FRACTION )
        mn.stop()
-        for cpu in results:
-            self.assertWithinTolerance( cpu, CPU_FRACTION, CPU_TOLERANCE )
+        hostUsage = '\n'.join( 'h%s: %s' %
+                               ( n + 1, results[ ( n - 1 ) * 5: ( n * 5 ) - 1 ] )
+                               for n in range( N ) )
+        hoptsStr = ', '.join( '%s: %s' % ( opt, value )
+                              for opt, value in hopts.items() )
+        msg = ( '\nTesting cpu limited to %d%% of cpu per host\n'
+                'cpu usage percent per host:\n%s\n'
+                'Topo = SingleSwitchTopo, %s hosts\n'
+                'hopts = %s\n'
+                'host = CPULimitedHost\n'
+                'Switch = %s\n'
+                % ( CPU_FRACTION * 100, hostUsage, N, hoptsStr, self.switchClass ) )
+        for pct in results:
+            #divide cpu by 100 to convert from percentage to fraction
+            self.assertWithinTolerance( pct/100, CPU_FRACTION,
+                                        CPU_TOLERANCE, msg )

    def testLinkBandwidth( self ):
        "Verify that link bandwidths are accurate within a bound."
+        if self.switchClass is UserSwitch:
+            self.skipTest ( 'UserSwitch has very poor performance, so skip for now' )
        BW = 5  # Mbps
        BW_TOLERANCE = 0.8  # BW fraction below which test should fail
        # Verify ability to create limited-link topo first;
        lopts = { 'bw': BW, 'use_htb': True }
        # Also verify correctness of limit limitng within a bound.
        mn = Mininet( SingleSwitchOptionsTopo( n=N, lopts=lopts ),
-                      link=TCLink )
-        bw_strs = mn.run( mn.iperf )
-        for bw_str in bw_strs:
-            bw = float( bw_str.split(' ')[0] )
-            self.assertWithinTolerance( bw, BW, BW_TOLERANCE )
+                      link=TCLink, switch=self.switchClass,
+                      waitConnected=True )
+        bw_strs = mn.run( mn.iperf, format='m' )
+        loptsStr = ', '.join( '%s: %s' % ( opt, value )
+                              for opt, value in lopts.items() )
+        msg = ( '\nTesting link bandwidth limited to %d Mbps per link\n'
+                'iperf results[ client, server ]: %s\n'
+                'Topo = SingleSwitchTopo, %s hosts\n'
+                'Link = TCLink\n'
+                'lopts = %s\n'
+                'host = default\n'
+                'switch = %s\n'
+                % ( BW, bw_strs, N, loptsStr, self.switchClass ) )
+
+        # On the client side, iperf doesn't wait for ACKs - it simply
+        # reports how long it took to fill up the TCP send buffer.
+        # As long as the kernel doesn't wait a long time before
+        # delivering bytes to the iperf server, its reported data rate
+        # should be close to the actual receive rate.
+        serverRate, clientRate = bw_strs
+        bw = float( serverRate.split(' ')[0] )
+        self.assertWithinTolerance( bw, BW, BW_TOLERANCE, msg )

    def testLinkDelay( self ):
        "Verify that link delays are accurate within a bound."
        DELAY_MS = 15
        DELAY_TOLERANCE = 0.8  # Delay fraction below which test should fail
+        REPS = 3
        lopts = { 'delay': '%sms' % DELAY_MS, 'use_htb': True }
        mn = Mininet( SingleSwitchOptionsTopo( n=N, lopts=lopts ),
-                      link=TCLink )
-        ping_delays = mn.run( mn.pingFull )
+                      link=TCLink, switch=self.switchClass, autoStaticArp=True,
+                      waitConnected=True )
+        mn.start()
+        for _ in range( REPS ):
+            ping_delays = mn.pingFull()
+        mn.stop()
        test_outputs = ping_delays[0]
        # Ignore unused variables below
        # pylint: disable-msg=W0612
        node, dest, ping_outputs = test_outputs
        sent, received, rttmin, rttavg, rttmax, rttdev = ping_outputs
-        self.assertEqual( sent, received )
+        pingFailMsg = 'sent %s pings, only received %s' % ( sent, received )
+        self.assertEqual( sent, received, msg=pingFailMsg )
        # pylint: enable-msg=W0612
+        loptsStr = ', '.join( '%s: %s' % ( opt, value )
+                              for opt, value in lopts.items() )
+        msg = ( '\nTesting Link Delay of %s ms\n'
+                'ping results across 4 links:\n'
+                '(Sent, Received, rttmin, rttavg, rttmax, rttdev)\n'
+                '%s\n'
+                'Topo = SingleSwitchTopo, %s hosts\n'
+                'Link = TCLink\n'
+                'lopts = %s\n'
+                'host = default'
+                'switch = %s\n'
+                % ( DELAY_MS, ping_outputs, N, loptsStr, self.switchClass ) )
+
        for rttval in [rttmin, rttavg, rttmax]:
            # Multiply delay by 4 to cover there & back on two links
-            self.assertWithinTolerance( rttval, DELAY_MS * 4.0,
-                                        DELAY_TOLERANCE)
+            self.assertWithinTolerance( rttval, DELAY_MS * 4.0, 
+                                        DELAY_TOLERANCE, msg )
+

    def testLinkLoss( self ):
        "Verify that we see packet drops with a high configured loss rate."
@@ -105,7 +191,9 @@ class testOptionsTopo( unittest.TestCase ):
        REPS = 1
        lopts = { 'loss': LOSS_PERCENT, 'use_htb': True }
        mn = Mininet( topo=SingleSwitchOptionsTopo( n=N, lopts=lopts ),
-                      host=CPULimitedHost, link=TCLink )
+                      host=CPULimitedHost, link=TCLink,
+                      switch=self.switchClass,
+                      waitConnected=True )
        # Drops are probabilistic, but the chance of no dropped packets is
        # 1 in 100 million with 4 hops for a link w/99% loss.
        dropped_total = 0
@@ -113,14 +201,55 @@ class testOptionsTopo( unittest.TestCase ):
        for _ in range(REPS):
            dropped_total += mn.ping(timeout='1')
        mn.stop()
-        self.assertTrue(dropped_total > 0)
+
+        loptsStr = ', '.join( '%s: %s' % ( opt, value )
+                              for opt, value in lopts.items() )
+        msg = ( '\nTesting packet loss with %d%% loss rate\n'
+                'number of dropped pings during mininet.ping(): %s\n'
+                'expected number of dropped packets: 1\n'
+                'Topo = SingleSwitchTopo, %s hosts\n'
+                'Link = TCLink\n'
+                'lopts = %s\n'
+                'host = default\n'
+                'switch = %s\n'
+                % ( LOSS_PERCENT, dropped_total, N, loptsStr, self.switchClass ) )
+
+        self.assertGreater( dropped_total, 0, msg )

    def testMostOptions( self ):
        "Verify topology creation with most link options and CPU limits."
        lopts = { 'bw': 10, 'delay': '5ms', 'use_htb': True }
        hopts = { 'cpu': 0.5 / N }
-        self.runOptionsTopoTest( N, hopts=hopts, lopts=lopts )
+        msg = '\nTesting many cpu and link options\n'
+        self.runOptionsTopoTest( N, msg, hopts=hopts, lopts=lopts )

+# pylint: enable=E1101
+
+class testOptionsTopoOVSKernel( testOptionsTopoCommon, unittest.TestCase ):
+    """Verify ability to create networks with host and link options
+       (OVS kernel switch)."""
+    longMessage = True
+    switchClass = OVSSwitch
+
+@unittest.skip( 'Skipping OVS user switch test for now' )
+class testOptionsTopoOVSUser( testOptionsTopoCommon, unittest.TestCase ):
+    """Verify ability to create networks with host and link options
+       (OVS user switch)."""
+    longMessage = True
+    switchClass = partial( OVSSwitch, datapath='user' )
+
+@unittest.skipUnless( quietRun( 'which ivs-ctl' ), 'IVS is not installed' )
+class testOptionsTopoIVS( testOptionsTopoCommon, unittest.TestCase ):
+    "Verify ability to create networks with host and link options (IVS)."
+    longMessage = True
+    switchClass = IVSSwitch
+
+@unittest.skipUnless( quietRun( 'which ofprotocol' ),
+                     'Reference user switch is not installed' )
+class testOptionsTopoUserspace( testOptionsTopoCommon, unittest.TestCase ):
+    "Verify ability to create networks with host and link options (UserSwitch)."
+    longMessage = True
+    switchClass = UserSwitch

 if __name__ == '__main__':
    setLogLevel( 'warning' )
@@ -4,45 +4,94 @@
   Test creation and all-pairs ping for each included mininet topo type."""

 import unittest
+from functools import partial

 from mininet.net import Mininet
 from mininet.node import Host, Controller
-from mininet.node import UserSwitch, OVSKernelSwitch
+from mininet.node import UserSwitch, OVSSwitch, IVSSwitch
 from mininet.topo import SingleSwitchTopo, LinearTopo
 from mininet.log import setLogLevel
+from mininet.util import quietRun

-SWITCHES = { 'user': UserSwitch,
-             'ovsk': OVSKernelSwitch,
-}
+# Tell pylint not to complain about calls to other class
+# pylint: disable=E1101

+class testSingleSwitchCommon( object ):
+    "Test ping with single switch topology (common code)."

-class testSingleSwitch( unittest.TestCase ):
-    "For each datapath type, test ping with single switch topologies."
+    switchClass = None # overridden in subclasses

    def testMinimal( self ):
-        "Ping test with both datapaths on minimal topology"
-        for switch in SWITCHES.values():
-            mn = Mininet( SingleSwitchTopo(), switch, Host, Controller )
-            dropped = mn.run( mn.ping )
-            self.assertEqual( dropped, 0 )
+        "Ping test on minimal topology"
+        mn = Mininet( SingleSwitchTopo(), self.switchClass, Host, Controller,
+                      waitConnected=True )
+        dropped = mn.run( mn.ping )
+        self.assertEqual( dropped, 0 )

    def testSingle5( self ):
-        "Ping test with both datapaths on 5-host single-switch topology"
-        for switch in SWITCHES.values():
-            mn = Mininet( SingleSwitchTopo( k=5 ), switch, Host, Controller )
-            dropped = mn.run( mn.ping )
-            self.assertEqual( dropped, 0 )
+        "Ping test on 5-host single-switch topology"
+        mn = Mininet( SingleSwitchTopo( k=5 ), self.switchClass, Host,
+                      Controller, waitConnected=True )
+        dropped = mn.run( mn.ping )
+        self.assertEqual( dropped, 0 )
+
+# pylint: enable=E1101
+
+class testSingleSwitchOVSKernel( testSingleSwitchCommon, unittest.TestCase ):
+    "Test ping with single switch topology (OVS kernel switch)."
+    switchClass = OVSSwitch
+
+class testSingleSwitchOVSUser( testSingleSwitchCommon, unittest.TestCase ):
+    "Test ping with single switch topology (OVS user switch)."
+    switchClass = partial( OVSSwitch, datapath='user' )
+
+@unittest.skipUnless( quietRun( 'which ivs-ctl' ), 'IVS is not installed' )
+class testSingleSwitchIVS( testSingleSwitchCommon, unittest.TestCase ):
+    "Test ping with single switch topology (IVS switch)."
+    switchClass = IVSSwitch
+
+@unittest.skipUnless( quietRun( 'which ofprotocol' ),
+                     'Reference user switch is not installed' )
+class testSingleSwitchUserspace( testSingleSwitchCommon, unittest.TestCase ):
+    "Test ping with single switch topology (Userspace switch)."
+    switchClass = UserSwitch


-class testLinear( unittest.TestCase ):
-    "For each datapath type, test all-pairs ping with LinearNet."
+# Tell pylint not to complain about calls to other class
+# pylint: disable=E1101
+
+class testLinearCommon( object ):
+    "Test all-pairs ping with LinearNet (common code)."
+
+    switchClass = None # overridden in subclasses

    def testLinear5( self ):
-        "Ping test with both datapaths on a 5-switch topology"
-        for switch in SWITCHES.values():
-            mn = Mininet( LinearTopo( k=5 ), switch, Host, Controller )
-            dropped = mn.run( mn.ping )
-            self.assertEqual( dropped, 0 )
+        "Ping test on a 5-switch topology"
+        mn = Mininet( LinearTopo( k=5 ), self.switchClass, Host, Controller, waitConnected=True )
+        dropped = mn.run( mn.ping )
+        self.assertEqual( dropped, 0 )
+
+# pylint: enable=E1101
+
+
+class testLinearOVSKernel( testLinearCommon, unittest.TestCase ):
+    "Test all-pairs ping with LinearNet (OVS kernel switch)."
+    switchClass = OVSSwitch
+
+class testLinearOVSUser( testLinearCommon, unittest.TestCase ):
+    "Test all-pairs ping with LinearNet (OVS user switch)."
+    switchClass = partial( OVSSwitch, datapath='user' )
+
+@unittest.skipUnless( quietRun( 'which ivs-ctl' ), 'IVS is not installed' )
+class testLinearIVS( testLinearCommon, unittest.TestCase ):
+    "Test all-pairs ping with LinearNet (IVS switch)."
+    switchClass = IVSSwitch
+
+@unittest.skipUnless( quietRun( 'which ofprotocol' ),
+                      'Reference user switch is not installed' )
+class testLinearUserspace( testLinearCommon, unittest.TestCase ):
+    "Test all-pairs ping with LinearNet (Userspace switch)."
+    switchClass = UserSwitch


 if __name__ == '__main__':
@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+
+"""Package: mininet
+   Regression tests for switch dpid assignment."""
+
+import unittest
+from functools import partial
+import re
+
+from mininet.net import Mininet
+from mininet.node import Host, Controller
+from mininet.node import UserSwitch, OVSSwitch, OVSLegacyKernelSwitch, IVSSwitch
+from mininet.topo import Topo
+from mininet.log import setLogLevel
+from mininet.util import quietRun
+
+
+class testSwitchDpidAssignmentCommon ( object ):
+    """Verify Switch dpid assignment."""
+
+    switchClass = None # overridden in subclasses
+
+    def testDefaultDpid ( self ):
+        """Verify that the default dpid is assigned using a valid provided
+        canonical switchname if no dpid is passed in switch creation."""
+        switch = Mininet( Topo(), self.switchClass, Host, Controller ).addSwitch( 's1' )
+        self.assertEqual( switch.defaultDpid(), switch.dpid )
+
+    def testActualDpidAssignment( self ):
+        """Verify that Switch dpid is the actual dpid assigned if dpid is 
+        passed in switch creation."""
+        switch = Mininet( Topo(), self.switchClass, Host, Controller ).addSwitch( 'A', dpid = '000000000000ABCD' )
+        self.assertEqual( switch.dpid, '000000000000ABCD' )
+
+    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."""
+        with self.assertRaises( Exception ) as raises_cm:
+            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.')
+
+    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."""
+        switch = Mininet( Topo(), self.switchClass, Host, Controller ).addSwitch( 's123' )
+        dpid = hex( int(re.findall( r'\d+', switch.name ) [0]) ) [ 2: ]
+        try:
+            if issubclass(UserSwitch, self.switchClass):
+                # Dpid lenght of UserSwitch = 12
+                self.assertEqual( switch.dpid, '0' * (12 - len(dpid)) + str(dpid) )
+            else:
+                self.assertEqual( switch.dpid, '0' * (16 - len(dpid)) + str(dpid) )
+        except TypeError:
+            # Switch is OVS User Switch
+            self.assertEqual( switch.dpid, '0' * (16 - len(dpid)) + str(dpid) )
+            
+
+class testSwitchOVSKernel( testSwitchDpidAssignmentCommon, unittest.TestCase ):
+    """Test dpid assignnment of OVS Kernel Switch."""
+    switchClass = OVSSwitch
+
+class testSwitchOVSUser( testSwitchDpidAssignmentCommon, unittest.TestCase ):
+    """Test dpid assignnment of OVS User Switch."""
+    switchClass = partial(OVSSwitch, datapath = 'user')
+    
+@unittest.skipUnless( quietRun( 'which ovs-openflowd' ), 'OVS Legacy Kernel switch is not installed' )
+class testSwitchOVSLegacyKernel( testSwitchDpidAssignmentCommon, unittest.TestCase ):
+    """Test dpid assignnment of OVS Legacy Kernel Switch."""
+    switchClass = OVSLegacyKernelSwitch
+    
+@unittest.skipUnless( quietRun( 'which ivs-ctl' ), 'IVS switch is not installed' )
+class testSwitchIVS( testSwitchDpidAssignmentCommon, unittest.TestCase ):
+    """Test dpid assignment of IVS switch."""
+    switchClass = IVSSwitch
+
+@unittest.skipUnless( quietRun( 'which ofprotocol' ), 'Reference user switch is not installed' )
+class testSwitchUserspace( testSwitchDpidAssignmentCommon, unittest.TestCase ):
+    """Test dpid assignment of Userspace switch."""
+    switchClass = UserSwitch
+
+
+if __name__ == '__main__':
+    setLogLevel( 'warning' )
+    unittest.main()
@@ -0,0 +1,342 @@
+#!/usr/bin/env python
+
+"""
+Tests for the Mininet Walkthrough
+
+TODO: missing xterm test
+"""
+
+import unittest
+import pexpect
+import os
+import re
+from mininet.util import quietRun
+from distutils.version import StrictVersion
+
+def tsharkVersion():
+    versionStr = quietRun( 'tshark -v' )
+    versionMatch = re.findall( 'TShark \d+.\d+.\d+', versionStr )[0]
+    return versionMatch.split()[ 1 ]
+
+class testWalkthrough( unittest.TestCase ):
+
+    prompt = 'mininet>'
+
+    # PART 1
+    def testHelp( self ):
+        "Check the usage message"
+        p = pexpect.spawn( 'mn -h' )
+        index = p.expect( [ 'Usage: mn', pexpect.EOF ] )
+        self.assertEqual( index, 0 )
+
+    def testWireshark( self ):
+        "Use tshark to test the of dissector"
+        if StrictVersion( tsharkVersion() ) < StrictVersion( '1.12.0' ):
+            tshark = pexpect.spawn( 'tshark -i lo -R of' )
+        else:
+            tshark = pexpect.spawn( 'tshark -i lo -Y openflow_v1' )
+        tshark.expect( [ 'Capturing on lo', "Capturing on 'Loopback'" ] )
+        mn = pexpect.spawn( 'mn --test pingall' )
+        mn.expect( '0% dropped' )
+        tshark.expect( [ '74 Hello', '74 of_hello', '74 Type: OFPT_HELLO' ] )
+        tshark.sendintr()
+
+    def testBasic( self ):
+        "Test basic CLI commands (help, nodes, net, dump)"
+        p = pexpect.spawn( 'mn' )
+        p.expect( self.prompt )
+        # help command
+        p.sendline( 'help' )
+        index = p.expect( [ 'commands', self.prompt ] )
+        self.assertEqual( index, 0, 'No output for "help" command')
+        # nodes command
+        p.sendline( 'nodes' )
+        p.expect( '([chs]\d ?){4}' )
+        nodes = p.match.group( 0 ).split()
+        self.assertEqual( len( nodes ), 4, 'No nodes in "nodes" command')
+        p.expect( self.prompt )
+        # net command
+        p.sendline( 'net' )
+        expected = [ x for x in nodes ]
+        while len( expected ) > 0:
+            index = p.expect( expected )
+            node = p.match.group( 0 )
+            expected.remove( node )
+            p.expect( '\n' )
+        self.assertEqual( len( expected ), 0, '"nodes" and "net" differ')
+        p.expect( self.prompt )
+        # dump command
+        p.sendline( 'dump' )
+        expected = [ '<\w+ (%s)' % n for n in nodes ]
+        actual = []
+        for _ in nodes:
+            index = p.expect( expected )
+            node = p.match.group( 1 )
+            actual.append( node )
+            p.expect( '\n' )
+        self.assertEqual( actual.sort(), nodes.sort(), '"nodes" and "dump" differ' )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    def testHostCommands( self ):
+        "Test ifconfig and ps on h1 and s1"
+        p = pexpect.spawn( 'mn' )
+        p.expect( self.prompt )
+        interfaces = [ 'h1-eth0', 's1-eth1', '[^-]eth0', 'lo', self.prompt ]
+        # h1 ifconfig
+        p.sendline( 'h1 ifconfig -a' )
+        ifcount = 0
+        while True:
+            index = p.expect( interfaces )
+            if index == 0 or index == 3:
+                ifcount += 1
+            elif index == 1:
+                self.fail( 's1 interface displayed in "h1 ifconfig"' )
+            elif index == 2:
+                self.fail( 'eth0 displayed in "h1 ifconfig"' )
+            else:
+                break
+        self.assertEqual( ifcount, 2, 'Missing interfaces on h1')
+        # s1 ifconfig
+        p.sendline( 's1 ifconfig -a' )
+        ifcount = 0
+        while True:
+            index = p.expect( interfaces )
+            if index == 0:
+                self.fail( 'h1 interface displayed in "s1 ifconfig"' )
+            elif index == 1 or index == 2 or index == 3:
+                ifcount += 1
+            else:
+                break
+        self.assertEqual( ifcount, 3, 'Missing interfaces on s1')
+        # h1 ps
+        p.sendline( "h1 ps -a | egrep -v 'ps|grep'" )
+        p.expect( self.prompt )
+        h1Output = p.before
+        # s1 ps
+        p.sendline( "s1 ps -a | egrep -v 'ps|grep'" )
+        p.expect( self.prompt )
+        s1Output = p.before
+        # 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()
+
+    def testConnectivity( self ):
+        "Test ping and pingall"
+        p = pexpect.spawn( 'mn' )
+        p.expect( self.prompt )
+        p.sendline( 'h1 ping -c 1 h2' )
+        p.expect( '1 packets transmitted, 1 received' )
+        p.expect( self.prompt )
+        p.sendline( 'pingall' )
+        p.expect( '0% dropped' )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    def testSimpleHTTP( self ):
+        "Start an HTTP server on h1 and wget from h2"
+        p = pexpect.spawn( 'mn' )
+        p.expect( self.prompt )
+        p.sendline( 'h1 python -m SimpleHTTPServer 80 &' )
+        p.expect( self.prompt )
+        p.sendline( ' h2 wget -O - h1' )
+        p.expect( '200 OK' )
+        p.expect( self.prompt )
+        p.sendline( 'h1 kill %python' )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    # PART 2
+    def testRegressionRun( self ):
+        "Test pingpair (0% drop) and iperf (bw > 0) regression tests"
+        # test pingpair
+        p = pexpect.spawn( 'mn --test pingpair' )
+        p.expect( '0% dropped' )
+        p.expect( pexpect.EOF )
+        # test iperf
+        p = pexpect.spawn( 'mn --test iperf' )
+        p.expect( "Results: \['([\d\.]+) .bits/sec'," )
+        bw = float( p.match.group( 1 ) )
+        self.assertTrue( bw > 0 )
+        p.expect( pexpect.EOF )
+
+    def testTopoChange( self ):
+        "Test pingall on single,3 and linear,4 topos"
+        # testing single,3
+        p = pexpect.spawn( 'mn --test pingall --topo single,3' )
+        p.expect( '(\d+)/(\d+) received')
+        received = int( p.match.group( 1 ) )
+        sent = int( p.match.group( 2 ) )
+        self.assertEqual( sent, 6, 'Wrong number of pings sent in single,3' )
+        self.assertEqual( sent, received, 'Dropped packets in single,3')
+        p.expect( pexpect.EOF )
+        # testing linear,4
+        p = pexpect.spawn( 'mn --test pingall --topo linear,4' )
+        p.expect( '(\d+)/(\d+) received')
+        received = int( p.match.group( 1 ) )
+        sent = int( p.match.group( 2 ) )
+        self.assertEqual( sent, 12, 'Wrong number of pings sent in linear,4' )
+        self.assertEqual( sent, received, 'Dropped packets in linear,4')
+        p.expect( pexpect.EOF )
+
+    def testLinkChange( self ):
+        "Test TCLink bw and delay"
+        p = pexpect.spawn( 'mn --link tc,bw=10,delay=10ms' )
+        # test bw
+        p.expect( self.prompt )
+        p.sendline( 'iperf' )
+        p.expect( "Results: \['([\d\.]+) Mbits/sec'," )
+        bw = float( p.match.group( 1 ) )
+        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( 'rtt min/avg/max/mdev = ([\d\.]+)/([\d\.]+)/([\d\.]+)/([\d\.]+) ms' )
+        delay = float( p.match.group( 2 ) )
+        self.assertTrue( delay > 40, 'Delay < 40ms' )
+        self.assertTrue( delay < 45, 'Delay > 40ms' )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    def testVerbosity( self ):
+        "Test debug and output verbosity"
+        # test output
+        p = pexpect.spawn( 'mn -v output' )
+        p.expect( self.prompt )
+        self.assertEqual( len( p.before ), 0, 'Too much output for "output"' )
+        p.sendline( 'exit' )
+        p.wait()
+        # test debug
+        p = pexpect.spawn( 'mn -v debug --test none' )
+        p.expect( pexpect.EOF )
+        lines = p.before.split( '\n' )
+        self.assertTrue( len( lines ) > 70, "Debug output is too short" )
+
+    def testCustomTopo( self ):
+        "Start Mininet using a custom topo, then run pingall"
+        custom = os.path.dirname( os.path.realpath( __file__ ) )
+        custom = os.path.join( custom, '../../custom/topo-2sw-2host.py' )
+        custom = os.path.normpath( custom )
+        p = pexpect.spawn( 'mn --custom %s --topo mytopo --test pingall' % custom )
+        p.expect( '0% dropped' )
+        p.expect( pexpect.EOF )
+
+    def testStaticMAC( self ):
+        "Verify that MACs are set to easy to read numbers"
+        p = pexpect.spawn( 'mn --mac' )
+        p.expect( self.prompt )
+        for i in range( 1, 3 ):
+            p.sendline( 'h%d ifconfig' % i )
+            p.expect( 'HWaddr 00:00:00:00:00:0%d' % i )
+            p.expect( self.prompt )
+
+    def testSwitches( self ):
+        "Run iperf test using user and ovsk switches"
+        switches = [ 'user', 'ovsk' ]
+        for sw in switches:
+            p = pexpect.spawn( 'mn --switch %s --test iperf' % sw )
+            p.expect( "Results: \['([\d\.]+) .bits/sec'," )
+            bw = float( p.match.group( 1 ) )
+            self.assertTrue( bw > 0 )
+            p.expect( pexpect.EOF )
+
+    def testBenchmark( self ):
+        "Run benchmark and verify that it takes less than 2 seconds"
+        p = pexpect.spawn( 'mn --test none' )
+        p.expect( 'completed in ([\d\.]+) seconds' )
+        time = float( p.match.group( 1 ) )
+        self.assertTrue( time < 2, 'Benchmark takes more than 2 seconds' )
+
+    def testOwnNamespace( self ):
+        "Test running user switch in its own namespace"
+        p = pexpect.spawn( 'mn --innamespace --switch user' )
+        p.expect( self.prompt )
+        interfaces = [ 'h1-eth0', 's1-eth1', '[^-]eth0', 'lo', self.prompt ]
+        p.sendline( 's1 ifconfig -a' )
+        ifcount = 0
+        while True:
+            index = p.expect( interfaces )
+            if index == 1 or index == 3:
+                ifcount += 1
+            elif index == 0:
+                self.fail( 'h1 interface displayed in "s1 ifconfig"' )
+            elif index == 2:
+                self.fail( 'eth0 displayed in "s1 ifconfig"' )
+            else:
+                break
+        self.assertEqual( ifcount, 2, 'Missing interfaces on s1' )
+        # verify that all hosts a reachable
+        p.sendline( 'pingall' )
+        p.expect( '(\d+)% dropped' )
+        dropped = int( p.match.group( 1 ) )
+        self.assertEqual( dropped, 0, 'pingall failed')
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    # PART 3
+    def testPythonInterpreter( self ):
+        "Test py and px by checking IP for h1 and adding h3"
+        p = pexpect.spawn( 'mn' )
+        p.expect( self.prompt )
+        # test host IP
+        p.sendline( 'py h1.IP()' )
+        p.expect( '10.0.0.1' )
+        p.expect( self.prompt )
+        # test adding host
+        p.sendline( "px net.addHost('h3')" )
+        p.expect( self.prompt )
+        p.sendline( "px net.addLink(s1, h3)" )
+        p.expect( self.prompt )
+        p.sendline( 'net' )
+        p.expect( 'h3' )
+        p.expect( self.prompt )
+        p.sendline( 'py h3.MAC()' )
+        p.expect( '([a-f0-9]{2}:?){6}' )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    def testLink( self ):
+        "Test link CLI command using ping"
+        p = pexpect.spawn( 'mn' )
+        p.expect( self.prompt )
+        p.sendline( 'link s1 h1 down' )
+        p.expect( self.prompt )
+        p.sendline( 'h1 ping -c 1 h2' )
+        p.expect( 'unreachable' )
+        p.expect( self.prompt )
+        p.sendline( 'link s1 h1 up' )
+        p.expect( self.prompt )
+        p.sendline( 'h1 ping -c 1 h2' )
+        p.expect( '0% packet loss' )
+        p.expect( self.prompt )
+        p.sendline( 'exit' )
+        p.wait()
+
+    @unittest.skipUnless( os.path.exists( '/tmp/pox' ) or
+                          '1 received' in quietRun( 'ping -c 1 github.com' ),
+                          'Github is not reachable; cannot download Pox' )
+    def testRemoteController( self ):
+        "Test Mininet using Pox controller"
+        if not os.path.exists( '/tmp/pox' ):
+            p = pexpect.spawn( 'git clone https://github.com/noxrepo/pox.git /tmp/pox' )
+            p.expect( pexpect.EOF )
+        pox = pexpect.spawn( '/tmp/pox/pox.py forwarding.l2_learning' )
+        net = pexpect.spawn( 'mn --controller=remote,ip=127.0.0.1,port=6633 --test pingall' )
+        net.expect( '0% dropped' )
+        net.expect( pexpect.EOF )
+        pox.sendintr()
+        pox.wait()
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-'''@package topo
+"""@package topo

 Network topology creation.

@@ -9,222 +9,334 @@ This package includes code to represent network topologies.

 A Topo object can be a topology database for NOX, can represent a physical
 setup for testing, and can even be emulated with the Mininet package.
-'''
+"""

-# BL: we may have to fix compatibility here.
-# networkx is also a fairly heavyweight dependency
-# from networkx.classes.graph import Graph
-
-from networkx import Graph
 from mininet.util import irange, natural, naturalSeq

-class Topo(object):
+class MultiGraph( object ):
+    "Utility class to track nodes and edges - replaces networkx.MultiGraph"
+
+    def __init__( self ):
+        self.node = {}
+        self.edge = {}
+
+    def add_node( self, node, attr_dict=None, **attrs):
+        """Add node to graph
+           attr_dict: attribute dict (optional)
+           attrs: more attributes (optional)
+           warning: updates attr_dict with attrs"""
+        attr_dict = {} if attr_dict is None else attr_dict
+        attr_dict.update( attrs )
+        self.node[ node ] = attr_dict
+
+    def add_edge( self, src, dst, key=None, attr_dict=None, **attrs ):
+        """Add edge to graph
+           key: optional key
+           attr_dict: optional attribute dict
+           attrs: more attributes
+           warning: udpates attr_dict with attrs"""
+        attr_dict = {} if attr_dict is None else attr_dict
+        attr_dict.update( attrs )
+        self.node.setdefault( src, {} )
+        self.node.setdefault( dst, {} )
+        self.edge.setdefault( src, {} )
+        self.edge.setdefault( dst, {} )
+        self.edge[ src ].setdefault( dst, {} )
+        entry = self.edge[ dst ][ src ] = self.edge[ src ][ dst ]
+        # If no key, pick next ordinal number
+        if key is None:
+            keys = [ k for k in entry.keys() if isinstance( k, int ) ]
+            key = max( [ 0 ] + keys ) + 1
+        entry[ key ] = attr_dict
+        return key
+
+    def nodes( self, data=False):
+        """Return list of graph nodes
+           data: return list of ( node, attrs)"""
+        return self.node.items() if data else self.node.keys()
+
+    def edges_iter( self, data=False, keys=False ):
+        "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 keys.iteritems():
+                    if data:
+                        if keys:
+                            yield( src, dst, k, attrs )
+                        else:
+                            yield( src, dst, attrs )
+                    else:
+                        if keys:
+                            yield( src, dst, k )
+                        else:
+                            yield( src, dst )
+
+    def edges( self, data=False, keys=False ):
+        "Return list of graph edges"
+        return list( self.edges_iter( data=data, keys=keys ) )
+
+
+    def __getitem__( self, node ):
+        "Return link dict for given src node"
+        return self.edge[ node ]
+
+    def __len__( self ):
+        "Return the number of nodes"
+        return len( self.node )
+
+    def convertTo( self, cls, data=False, keys=False ):
+        """Convert to a new object of networkx.MultiGraph-like class cls
+           data: include node and edge data
+           keys: include edge keys as well as edge data"""
+        g = cls()
+        g.add_nodes_from( self.nodes( data=data ) )
+        g.add_edges_from( self.edges( data=( data or keys ), keys=keys ) )
+        return g
+
+
+class Topo( object ):
    "Data center network representation for structured multi-trees."

-    def __init__(self, hopts=None, sopts=None, lopts=None):
-        """Topo object:
+    def __init__( self, *args, **params ):
+        """Topo object. 
+           Optional named parameters:
           hinfo: default host options
           sopts: default switch options
-           lopts: default link options"""
-        self.g = Graph()
-        self.node_info = {}
-        self.link_info = {}  # (src, dst) tuples hash to EdgeInfo objects
-        self.hopts = {} if hopts is None else hopts
-        self.sopts = {} if sopts is None else sopts
-        self.lopts = {} if lopts is None else lopts
-        self.ports = {}  # ports[src][dst] is port on src that connects to dst
+           lopts: default link options
+           calls build()"""
+        self.g = MultiGraph()
+        self.hopts = params.pop( 'hopts', {} )
+        self.sopts = params.pop( 'sopts', {} )
+        self.lopts = params.pop( 'lopts', {} )
+        self.ports = {}  # ports[src][dst][sport] is port on dst that connects to src
+        self.build( *args, **params )

-    def addNode(self, name, **opts):
+    def build( self, *args, **params ):
+        "Override this method to build your topology."
+        pass
+
+    def addNode( self, name, **opts ):
        """Add Node to graph.
           name: name
           opts: node options
           returns: node name"""
-        self.g.add_node(name)
-        self.node_info[name] = opts
+        self.g.add_node( name, **opts )
        return name

-    def addHost(self, name, **opts):
+    def addHost( self, name, **opts ):
        """Convenience method: Add host to graph.
           name: host name
           opts: host options
           returns: host name"""
        if not opts and self.hopts:
            opts = self.hopts
-        return self.addNode(name, **opts)
+        return self.addNode( name, **opts )

-    def addSwitch(self, name, **opts):
+    def addSwitch( self, name, **opts ):
        """Convenience method: Add switch to graph.
           name: switch name
           opts: switch options
           returns: switch name"""
        if not opts and self.sopts:
            opts = self.sopts
-        result = self.addNode(name, isSwitch=True, **opts)
+        result = self.addNode( name, isSwitch=True, **opts )
        return result

-    def addLink(self, node1, node2, port1=None, port2=None,
-                **opts):
+    def addLink( self, node1, node2, port1=None, port2=None,
+                key=None, **opts ):
        """node1, node2: nodes to link together
           port1, port2: ports (optional)
           opts: link options (optional)
           returns: link info key"""
        if not opts and self.lopts:
            opts = self.lopts
-        self.addPort(node1, node2, port1, port2)
-        key = tuple(self.sorted([node1, node2]))
-        self.link_info[key] = opts
-        self.g.add_edge(*key)
+        port1, port2 = self.addPort( node1, node2, port1, port2 )
+        opts = dict( opts )
+        opts.update( node1=node1, node2=node2, port1=port1, port2=port2 )
+        self.g.add_edge(node1, node2, key, opts )
        return key

-    def addPort(self, src, dst, sport=None, dport=None):
-        '''Generate port mapping for new edge.
-        @param src source switch name
-        @param dst destination switch name
-        '''
-        self.ports.setdefault(src, {})
-        self.ports.setdefault(dst, {})
-        # New port: number of outlinks + base
-        src_base = 1 if self.isSwitch(src) else 0
-        dst_base = 1 if self.isSwitch(dst) else 0
-        if sport is None:
-            sport = len(self.ports[src]) + src_base
-        if dport is None:
-            dport = len(self.ports[dst]) + dst_base
-        self.ports[src][dst] = sport
-        self.ports[dst][src] = dport
-
-    def nodes(self, sort=True):
+    def nodes( self, sort=True ):
        "Return nodes in graph"
        if sort:
            return self.sorted( self.g.nodes() )
        else:
            return self.g.nodes()

-    def isSwitch(self, n):
-        '''Returns true if node is a switch.'''
-        info = self.node_info[n]
-        return info and info.get('isSwitch', False)
+    def isSwitch( self, n ):
+        "Returns true if node is a switch."
+        return self.g.node[ n ].get( 'isSwitch', False )

-    def switches(self, sort=True):
-        '''Return switches.
-        sort: sort switches alphabetically
-        @return dpids list of dpids
-        '''
-        return [n for n in self.nodes(sort) if self.isSwitch(n)]
+    def switches( self, sort=True ):
+        """Return switches.
+           sort: sort switches alphabetically
+           returns: dpids list of dpids"""
+        return [ n for n in self.nodes( sort ) if self.isSwitch( n ) ]

-    def hosts(self, sort=True):
-        '''Return hosts.
-        sort: sort hosts alphabetically
-        @return dpids list of dpids
-        '''
-        return [n for n in self.nodes(sort) if not self.isSwitch(n)]
+    def hosts( self, sort=True ):
+        """Return hosts.
+           sort: sort hosts alphabetically
+           returns: list of hosts"""
+        return [ n for n in self.nodes( sort ) if not self.isSwitch( n ) ]

-    def links(self, sort=True):
-        '''Return links.
-        sort: sort links alphabetically
-        @return links list of name pairs
-        '''
-        if not sort:
-            return self.g.edges()
-        else:
-            links = [tuple(self.sorted(e)) for e in self.g.edges()]
-            return sorted( links, key=naturalSeq )
+    def iterLinks( self, withKeys=False, withInfo=False ):
+        """Return links (iterator)
+           withKeys: return link keys
+           withInfo: return link info
+           returns: list of ( src, dst [,key, info ] )"""
+        for src, dst, key, info in self.g.edges_iter( data=True, keys=True ):
+            node1, node2 = info[ 'node1' ], info[ 'node2' ]
+            if withKeys:
+                if withInfo:
+                    yield( node1, node2, key, info )
+                else:
+                    yield( node1, node2, key )
+            else:
+                if withInfo:
+                    yield( node1, node2, info )
+                else:
+                    yield( node1, node2 )

-    def port(self, src, dst):
-        '''Get port number.
+    def links( self, sort=False, withKeys=False, withInfo=False ):
+        """Return links
+           sort: sort links alphabetically, preserving (src, dst) order
+           withKeys: return link keys
+           withInfo: return link info
+           returns: list of ( src, dst [,key, info ] )"""
+        links = list( self.iterLinks( withKeys, withInfo ) )
+        if not sorted:
+            return links
+        # Ignore info when sorting
+        tupleSize = 3 if withKeys else 2
+        return sorted( links, key=( lambda l: naturalSeq( l[ :tupleSize ] ) ) )

-        @param src source switch name
-        @param dst destination switch name
-        @return tuple (src_port, dst_port):
-            src_port: port on source switch leading to the destination switch
-            dst_port: port on destination switch leading to the source switch
-        '''
-        if src in self.ports and dst in self.ports[src]:
-            assert dst in self.ports and src in self.ports[dst]
-            return (self.ports[src][dst], self.ports[dst][src])
+    # This legacy port management mechanism is clunky and will probably
+    # be removed at some point.

-    def linkInfo( self, src, dst ):
-        "Return link metadata"
-        src, dst = self.sorted([src, dst])
-        return self.link_info[(src, dst)]
+    def addPort( self, src, dst, sport=None, dport=None ):
+        """Generate port mapping for new edge.
+            src: source switch name
+            dst: destination switch name"""
+        # Initialize if necessary
+        ports = self.ports
+        ports.setdefault( src, {} )
+        ports.setdefault( dst, {} )
+        # New port: number of outlinks + base
+        if sport is None:
+            src_base = 1 if self.isSwitch( src ) else 0
+            sport = len( ports[ src ] ) + src_base
+        if dport is None:
+            dst_base = 1 if self.isSwitch( dst ) else 0
+            dport = len( ports[ dst ] ) + dst_base
+        ports[ src ][ sport ] = ( dst, dport )
+        ports[ dst ][ dport ] = ( src, sport )
+        return sport, dport

-    def setlinkInfo( self, src, dst, info ):
-        "Set link metadata"
-        src, dst = self.sorted([src, dst])
-        self.link_info[(src, dst)] = info
+    def port( self, src, dst ):
+        """Get port numbers.
+            src: source switch name
+            dst: destination switch name
+            sport: optional source port (otherwise use lowest src port)
+            returns: tuple (sport, dport), where
+                sport = port on source switch leading to the destination switch
+                dport = port on destination switch leading to the source switch
+            Note that you can also look up ports using linkInfo()"""
+        # A bit ugly and slow vs. single-link implementation ;-(
+        ports = [ ( sport, entry[ 1 ] )
+                  for sport, entry in self.ports[ src ].items()
+                  if entry[ 0 ] == dst ]
+        return ports if len( ports ) != 1 else ports[ 0 ]
+
+    def _linkEntry( self, src, dst, key=None ):
+        "Helper function: return link entry and key"
+        entry = self.g[ src ][ dst ]
+        if key is None:
+            key = min( entry )
+        return entry, key
+    
+    def linkInfo( self, src, dst, key=None ):
+        "Return link metadata dict"
+        entry, key = self._linkEntry( src, dst, key )
+        return entry[ key ]
+
+    def setlinkInfo( self, src, dst, info, key=None ):
+        "Set link metadata dict"
+        entry, key = self._linkEntry( src, dst, key )
+        entry[ key ] = info

    def nodeInfo( self, name ):
        "Return metadata (dict) for node"
-        info = self.node_info[ name ]
-        return info if info is not None else {}
+        return self.g.node[ name ]

    def setNodeInfo( self, name, info ):
        "Set metadata (dict) for node"
-        self.node_info[ name ] = info
+        self.g.node[ name ] = info
+
+    def convertTo( self, cls, data=True, keys=True ):
+        """Convert to a new object of networkx.MultiGraph-like class cls
+           data: include node and edge data (default True)
+           keys: include edge keys as well as edge data (default True)"""
+        return self.g.convertTo( cls, data=data, keys=keys )

    @staticmethod
    def sorted( items ):
        "Items sorted in natural (i.e. alphabetical) order"
-        return sorted(items, key=natural)
+        return sorted( items, key=natural )

-class SingleSwitchTopo(Topo):
-    '''Single switch connected to k hosts.'''

-    def __init__(self, k=2, **opts):
-        '''Init.
-
-        @param k number of hosts
-        @param enable_all enables all nodes and switches?
-        '''
-        super(SingleSwitchTopo, self).__init__(**opts)
+class SingleSwitchTopo( Topo ):
+    "Single switch connected to k hosts."

+    def build( self, k=2, **opts ):
+        "k: number of hosts"
        self.k = k
-
-        switch = self.addSwitch('s1')
-        for h in irange(1, k):
-            host = self.addHost('h%s' % h)
-            self.addLink(host, switch)
+        switch = self.addSwitch( 's1' )
+        for h in irange( 1, k ):
+            host = self.addHost( 'h%s' % h )
+            self.addLink( host, switch )


-class SingleSwitchReversedTopo(Topo):
-    '''Single switch connected to k hosts, with reversed ports.
+class SingleSwitchReversedTopo( Topo ):
+    """Single switch connected to k hosts, with reversed ports.
+       The lowest-numbered host is connected to the highest-numbered port.
+       Useful to verify that Mininet properly handles custom port numberings."""

-    The lowest-numbered host is connected to the highest-numbered port.
-
-    Useful to verify that Mininet properly handles custom port numberings.
-    '''
-    def __init__(self, k=2, **opts):
-        '''Init.
-
-        @param k number of hosts
-        @param enable_all enables all nodes and switches?
-        '''
-        super(SingleSwitchReversedTopo, self).__init__(**opts)
+    def build( self, k=2 ):
+        "k: number of hosts"
        self.k = k
-        switch = self.addSwitch('s1')
-        for h in irange(1, k):
-            host = self.addHost('h%s' % h)
-            self.addLink(host, switch,
-                         port1=0, port2=(k - h + 1))
+        switch = self.addSwitch( 's1' )
+        for h in irange( 1, k ):
+            host = self.addHost( 'h%s' % h )
+            self.addLink( host, switch,
+                          port1=0, port2=( k - h + 1 ) )

-class LinearTopo(Topo):
-    "Linear topology of k switches, with one host per switch."

-    def __init__(self, k=2, **opts):
-        """Init.
-           k: number of switches (and hosts)
-           hconf: host configuration options
-           lconf: link configuration options"""
-
-        super(LinearTopo, self).__init__(**opts)
+class LinearTopo( Topo ):
+    "Linear topology of k switches, with n hosts per switch."

+    def build( self, k=2, n=1, **opts):
+        """k: number of switches
+           n: number of hosts per switch"""
        self.k = k
+        self.n = n
+
+        if n == 1:
+            genHostName = lambda i, j: 'h%s' % i
+        else:
+            genHostName = lambda i, j: 'h%ss%d' % ( j, i )

        lastSwitch = None
-        for i in irange(1, k):
-            host = self.addHost('h%s' % i)
-            switch = self.addSwitch('s%s' % i)
-            self.addLink( host, switch)
+        for i in irange( 1, k ):
+            # Add switch
+            switch = self.addSwitch( 's%s' % i )
+            # Add hosts to switch
+            for j in irange( 1, n ):
+                host = self.addHost( genHostName( i, j ) )
+                self.addLink( host, switch )
+            # Connect switch to previous
            if lastSwitch:
-                self.addLink( switch, lastSwitch)
+                self.addLink( switch, lastSwitch )
            lastSwitch = switch
@@ -6,8 +6,7 @@ from mininet.net import Mininet
 class TreeTopo( Topo ):
    "Topology for a tree network with a given depth and fanout."

-    def __init__( self, depth=1, fanout=2 ):
-        super( TreeTopo, self ).__init__()
+    def build( self, depth=1, fanout=2 ):
        # Numbering:  h1..N, s1..M
        self.hostNum = 1
        self.switchNum = 1
@@ -34,3 +33,37 @@ def TreeNet( depth=1, fanout=2, **kwargs ):
    "Convenience function for creating tree networks."
    topo = TreeTopo( depth, fanout )
    return Mininet( topo, **kwargs )
+
+
+class TorusTopo( Topo ):
+    """2-D Torus topology
+       WARNING: this topology has LOOPS and WILL NOT WORK
+       with the default controller or any Ethernet bridge
+       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 ):
+        if x < 3 or y < 3:
+            raise Exception( 'Please use 3x3 or greater for compatibility '
+                            'with 2.1' )
+        hosts, switches, dpid = {}, {}, 0
+        # Create and wire interior
+        for i in range( 0, x ):
+            for j in range( 0, y ):
+                loc = '%dx%d' % ( i + 1, j + 1 )
+                # dpid cannot be zero for OVS
+                dpid = ( i + 1 ) * 256 + ( j + 1 )
+                switch = switches[ i, j ] = self.addSwitch( '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 ):
+                sw1 = switches[ i, j ]
+                sw2 = switches[ i, ( j + 1 ) % y ]
+                sw3 = switches[ ( i + 1 ) % x, j ]
+                self.addLink( sw1, sw2 )
+                self.addLink( sw1, sw3 )
+
+    
+
@@ -1,15 +1,16 @@
 "Utility functions for Mininet."

-from mininet.log import output, info, error, warn
+from mininet.log import output, info, error, warn, debug

 from time import sleep
-from resource import setrlimit, RLIMIT_NPROC, RLIMIT_NOFILE
-from select import poll, POLLIN
+from resource import getrlimit, setrlimit, RLIMIT_NPROC, RLIMIT_NOFILE
+from select import poll, POLLIN, POLLHUP
 from subprocess import call, check_call, Popen, PIPE, STDOUT
 import re
 from fcntl import fcntl, F_GETFL, F_SETFL
 from os import O_NONBLOCK
 import os
+from functools import partial

 # Command execution support

@@ -61,12 +62,6 @@ def errRun( *cmd, **kwargs ):
       stderr: STDOUT to merge stderr with stdout
       shell: run command using shell
       echo: monitor output to console"""
-    # Allow passing in a list or a string
-    if len( cmd ) == 1:
-        cmd = cmd[ 0 ]
-        if isinstance( cmd, str ):
-            cmd = cmd.split( ' ' )
-    cmd = [ str( arg ) for arg in cmd ]
    # By default we separate stderr, don't run in a shell, and don't echo
    stderr = kwargs.get( 'stderr', PIPE )
    shell = kwargs.get( 'shell', False )
@@ -74,6 +69,14 @@ def errRun( *cmd, **kwargs ):
    if echo:
        # cmd goes to stderr, output goes to stdout
        info( cmd, '\n' )
+    if len( cmd ) == 1:
+        cmd = cmd[ 0 ]
+    # Allow passing in a list or a string
+    if isinstance( cmd, str ) and not shell:
+        cmd = cmd.split( ' ' )
+        cmd = [ str( arg ) for arg in cmd ]
+    elif isinstance( cmd, list ) and shell:
+        cmd = " ".join( arg for arg in cmd )
    popen = Popen( cmd, stdout=PIPE, stderr=stderr, shell=shell )
    # We use poll() because select() doesn't work with large fd numbers,
    # and thus communicate() doesn't work either
@@ -145,17 +148,27 @@ isShellBuiltin.builtIns = None
 # live in the root namespace and thus do not have to be
 # explicitly moved.

-def makeIntfPair( intf1, intf2 ):
+def makeIntfPair( intf1, intf2, addr1=None, addr2=None, run=quietRun ):
    """Make a veth pair connecting intf1 and intf2.
       intf1: string, interface
       intf2: string, interface
-       returns: success boolean"""
+       node: node to run on or None (default)
+       returns: ip link add result"""
    # Delete any old interfaces with the same names
-    quietRun( 'ip link del ' + intf1 )
-    quietRun( 'ip link del ' + intf2 )
+    run( 'ip link del ' + intf1 )
+    run( 'ip link del ' + intf2 )
    # Create new pair
-    cmd = 'ip link add name ' + intf1 + ' type veth peer name ' + intf2
-    return quietRun( cmd )
+    if addr1 is None and addr2 is None:
+        cmd = 'ip link add name ' + intf1 + ' type veth peer name ' + intf2
+    else:
+        cmd = ( 'ip link add name ' + intf1 + ' address ' + addr1 +
+                ' type veth peer name ' + intf2 + ' address ' + addr2 )
+    cmdOutput = run( cmd )
+    if cmdOutput == '':
+        return True
+    else:
+        error( "Error creating interface pair: %s " % cmdOutput )
+        return False

 def retry( retries, delaySecs, fn, *args, **keywords ):
    """Try something several times before giving up.
@@ -171,27 +184,32 @@ def retry( retries, delaySecs, fn, *args, **keywords ):
        error( "*** gave up after %i retries\n" % tries )
        exit( 1 )

-def moveIntfNoRetry( intf, node, printError=False ):
+def moveIntfNoRetry( intf, dstNode, printError=False ):
    """Move interface to node, without retrying.
       intf: string, interface
-       node: Node object
-       printError: if true, print error"""
-    cmd = 'ip link set ' + intf + ' netns ' + repr( node.pid )
-    quietRun( cmd )
-    links = node.cmd( 'ip link show' )
-    if not ( ' %s:' % intf ) in links:
+        dstNode: destination Node
+        printError: if true, print error"""
+    intf = str( intf )
+    cmd = 'ip link set %s netns %s' % ( intf, dstNode.pid )
+    cmdOutput = quietRun( cmd )
+    # If ip link set does not produce any output, then we can assume
+    # that the link has been moved successfully.
+    if cmdOutput:
        if printError:
            error( '*** Error: moveIntf: ' + intf +
-                   ' not successfully moved to ' + node.name + '\n' )
+                   ' not successfully moved to ' + dstNode.name + ':\n',
+                   cmdOutput )
        return False
    return True

-def moveIntf( intf, node, printError=False, retries=3, delaySecs=0.001 ):
+def moveIntf( intf, dstNode, srcNode=None, printError=True,
+             retries=3, delaySecs=0.001 ):
    """Move interface to node, retrying on failure.
       intf: string, interface
-       node: Node object
+       dstNode: destination Node
       printError: if true, print error"""
-    retry( retries, delaySecs, moveIntfNoRetry, intf, node, printError )
+    retry( retries, delaySecs, moveIntfNoRetry, intf, dstNode,
+           printError=printError )

 # Support for dumping network

@@ -219,6 +237,15 @@ def dumpNetConnections( net ):
    nodes = net.controllers + net.switches + net.hosts
    dumpNodeConnections( nodes )

+def dumpPorts( switches ):
+    "dump interface to openflow port mappings for each switch"
+    for switch in switches:
+        output( '%s ' % switch.name )
+        for intf in switch.intfList():
+            port = switch.ports[ intf ]
+            output( '%s:%d ' % ( intf, port ) )
+        output( '\n' )
+
 # IP and Mac address formatting and parsing

 def _colonHex( val, bytecount ):
@@ -242,9 +269,8 @@ def macColonHex( mac ):
 def ipStr( ip ):
    """Generate IP address string from an unsigned int.
       ip: unsigned int of form w << 24 | x << 16 | y << 8 | z
-       returns: ip address string w.x.y.z, or 10.x.y.z if w==0"""
+       returns: ip address string w.x.y.z"""
    w = ( ip >> 24 ) & 0xff
-    w = 10 if w == 0 else w
    x = ( ip >> 16 ) & 0xff
    y = ( ip >> 8 ) & 0xff
    z = ip & 0xff
@@ -261,15 +287,17 @@ def ipAdd( i, prefixLen=8, ipBaseNum=0x0a000000 ):
       prefixLen: optional IP prefix length
       ipBaseNum: option base IP address as int
       returns IP address as string"""
-    # Ugly but functional
-    assert i < ( 1 << ( 32 - prefixLen ) )
-    mask = 0xffffffff ^ ( ( 1 << prefixLen ) - 1 )
-    ipnum = i + ( ipBaseNum & mask )
+    imax = 0xffffffff >> prefixLen
+    assert i <= imax, 'Not enough IP addresses in the subnet'
+    mask = 0xffffffff ^ imax
+    ipnum = ( ipBaseNum & mask ) + i
    return ipStr( ipnum )

 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.append( 0 )
    return ipNum( *args )

 def netParse( ipstr ):
@@ -279,6 +307,10 @@ def netParse( ipstr ):
    if '/' in ipstr:
        ip, pf = ipstr.split( '/' )
        prefixLen = int( pf )
+    #if no prefix is specified, set the prefix to 24
+    else:
+        ip = ipstr
+        prefixLen = 24
    return ipParse( ip ), prefixLen

 def checkInt( s ):
@@ -326,46 +358,88 @@ def pmonitor(popens, timeoutms=500, readline=True,
            # Use non-blocking reads
            flags = fcntl( fd, F_GETFL )
            fcntl( fd, F_SETFL, flags | O_NONBLOCK )
-    while True:
+    while popens:
        fds = poller.poll( timeoutms )
        if fds:
-            for fd, _event in fds:
+            for fd, event in fds:
                host = fdToHost[ fd ]
                popen = popens[ host ]
-                if readline:
-                    # Attempt to read a line of output
-                    # This blocks until we receive a newline!
-                    line = popen.stdout.readline()
-                else:
-                    line = popen.stdout.read( readmax )
-                yield host, line
+                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
-                if not line:
-                    popen.poll()
-                    if popen.returncode is not None:
-                        poller.unregister( fd )
-                        del popens[ host ]
-                        if not popens:
-                            return
+                elif event & POLLHUP:
+                    poller.unregister( fd )
+                    del popens[ host ]
        else:
            yield None, ''

 # Other stuff we use
+def sysctlTestAndSet( name, limit ):
+    "Helper function to set sysctl limits"
+    #convert non-directory names into directory names
+    if '/' not in name:
+        name = '/proc/sys/' + name.replace( '.', '/' )
+    #read limit
+    with open( name, 'r' ) as readFile:
+        oldLimit = readFile.readline()
+        if isinstance( limit, int ):
+            #compare integer limits before overriding
+            if int( oldLimit ) < limit:
+                with open( name, 'w' ) as writeFile:
+                    writeFile.write( "%d" % limit )
+        else:
+            #overwrite non-integer limits
+            with open( name, 'w' ) as writeFile:
+                writeFile.write( limit )
+
+def rlimitTestAndSet( name, limit ):
+    "Helper function to set rlimits"
+    soft, hard = getrlimit( name )
+    if soft < limit:
+        hardLimit = hard if limit < hard else limit
+        setrlimit( name, ( limit, hardLimit ) )

 def fixLimits():
    "Fix ridiculously small resource limits."
-    setrlimit( RLIMIT_NPROC, ( 8192, 8192 ) )
-    setrlimit( RLIMIT_NOFILE, ( 16384, 16384 ) )
+    debug( "*** Setting resource limits\n" )
+    try:
+        rlimitTestAndSet( RLIMIT_NPROC, 8192 )
+        rlimitTestAndSet( RLIMIT_NOFILE, 16384 )
+        #Increase open file limit
+        sysctlTestAndSet( 'fs.file-max', 10000 )
+        #Increase network buffer space
+        sysctlTestAndSet( 'net.core.wmem_max', 16777216 )
+        sysctlTestAndSet( 'net.core.rmem_max', 16777216 )
+        sysctlTestAndSet( 'net.ipv4.tcp_rmem', '10240 87380 16777216' )
+        sysctlTestAndSet( 'net.ipv4.tcp_wmem', '10240 87380 16777216' )
+        sysctlTestAndSet( 'net.core.netdev_max_backlog', 5000 )
+        #Increase arp cache size
+        sysctlTestAndSet( 'net.ipv4.neigh.default.gc_thresh1', 4096 )
+        sysctlTestAndSet( 'net.ipv4.neigh.default.gc_thresh2', 8192 )
+        sysctlTestAndSet( 'net.ipv4.neigh.default.gc_thresh3', 16384 )
+        #Increase routing table size
+        sysctlTestAndSet( 'net.ipv4.route.max_size', 32768 )
+        #Increase number of PTYs for nodes
+        sysctlTestAndSet( 'kernel.pty.max', 20000 )
+    except:
+        warn( "*** Error setting resource limits. "
+              "Mininet's performance may be affected.\n" )

 def mountCgroups():
    "Make sure cgroups file system is mounted"
-    mounts = quietRun( 'mount' )
+    mounts = quietRun( 'cat /proc/mounts' )
    cgdir = '/sys/fs/cgroup'
    csdir = cgdir + '/cpuset'
-    if ('cgroup on %s' % cgdir not in mounts and
-            'cgroups on %s' % cgdir not in mounts):
+    if ('cgroup %s' % cgdir not in mounts and
+            'cgroups %s' % cgdir not in mounts):
        raise Exception( "cgroups not mounted on " + cgdir )
-    if 'cpuset on %s' % csdir not in mounts:
+    if 'cpuset %s' % csdir not in mounts:
        errRun( 'mkdir -p ' + csdir )
        errRun( 'mount -t cgroup -ocpuset cpuset ' + csdir )

@@ -374,7 +448,7 @@ def natural( text ):
    def num( s ):
        "Convert text segment to int if necessary"
        return int( s ) if s.isdigit() else s
-    return [  num( s ) for s in re.split( r'(\d+)', text ) ]
+    return [  num( s ) for s in re.split( r'(\d+)', str( text ) ) ]

 def naturalSeq( t ):
    "Natural sort key function for sequences"
@@ -419,7 +493,7 @@ def splitArgs( argstr ):
    args = [ makeNumeric( s ) for s in params if '=' not in s ]
    kwargs = {}
    for s in [ p for p in params if '=' in p ]:
-        key, val = s.split( '=' )
+        key, val = s.split( '=', 1 )
        kwargs[ key ] = makeNumeric( val )
    return fn, args, kwargs

@@ -467,3 +541,27 @@ def ensureRoot():
        print "*** Mininet must run as root."
        exit( 1 )
    return
+
+def waitListening( client=None, server='127.0.0.1', port=80, timeout=None ):
+    """Wait until server is listening on port.
+       returns True if server is listening"""
+    run = ( client.cmd if client else
+                partial( quietRun, shell=True ) )
+    if not run( 'which telnet' ):
+        raise Exception('Could not find telnet' )
+    serverIP = server if isinstance( server, basestring ) else server.IP()
+    cmd = ( 'sh -c "echo A | telnet -e A %s %s"' %
+           ( serverIP, port ) )
+    time = 0
+    while 'Connected' not in run( cmd ):
+        if timeout:
+            print time
+            if time >= timeout:
+                error( 'could not connect to %s on port %d\n'
+                       % ( server, port ) )
+                return False
+        output('waiting for', server,
+               'to listen on port', port, '\n')
+        sleep( .5 )
+        time += .5
+    return True
@@ -5,7 +5,7 @@
 *
 *  - closing all file descriptors except stdin/out/error
 *  - detaching from a controlling tty using setsid
- *  - running in a network namespace
+ *  - running in network and mount namespaces
 *  - printing out the pid of a process so we can identify it later
 *  - attaching to a namespace and cgroup
 *  - setting RT scheduling
@@ -13,6 +13,7 @@
 * Partially based on public domain setsid(1)
 */

+#define _GNU_SOURCE
 #include <stdio.h>
 #include <linux/sched.h>
 #include <unistd.h>
@@ -20,23 +21,24 @@
 #include <syscall.h>
 #include <fcntl.h>
 #include <stdlib.h>
-#include <limits.h>
 #include <sched.h>
+#include <ctype.h>
+#include <sys/mount.h>

 #if !defined(VERSION)
 #define VERSION "(devel)"
 #endif

-void usage(char *name) 
+void usage(char *name)
 {
    printf("Execution utility for Mininet\n\n"
           "Usage: %s [-cdnp] [-a pid] [-g group] [-r rtprio] cmd args...\n\n"
           "Options:\n"
           "  -c: close all file descriptors except stdin/out/error\n"
           "  -d: detach from tty by calling setsid()\n"
-           "  -n: run in new network namespace\n"
+           "  -n: run in new network and mount namespaces\n"
           "  -p: print ^A + pid\n"
-           "  -a pid: attach to pid's network namespace\n"
+           "  -a pid: attach to pid's network and mount namespaces\n"
           "  -g group: add to cgroup\n"
           "  -r rtprio: run with SCHED_RR (usually requires -g)\n"
           "  -v: print version\n",
@@ -46,7 +48,7 @@ void usage(char *name)

 int setns(int fd, int nstype)
 {
-	return syscall(308, fd, nstype);
+    return syscall(__NR_setns, fd, nstype);
 }

 /* Validate alphanumeric path foo1/bar2/baz */
@@ -62,7 +64,7 @@ void validate(char *path)
 }

 /* Add our pid to cgroup */
-int cgroup(char *gname)
+void cgroup(char *gname)
 {
    static char path[PATH_MAX];
    static char *groups[] = {
@@ -92,11 +94,13 @@ int cgroup(char *gname)

 int main(int argc, char *argv[])
 {
-    char c;
+    int c;
    int fd;
    char path[PATH_MAX];
    int nsid;
    int pid;
+    char *cwd = get_current_dir_name();
+
    static struct sched_param sp;
    while ((c = getopt(argc, argv, "+cdnpa:g:r:vh")) != -1)
        switch(c) {
@@ -112,20 +116,25 @@ int main(int argc, char *argv[])
                    case -1:
                        perror("fork");
                        return 1;
-                    case 0:		/* child */
+                    case 0:     /* child */
                        break;
-                    default:	/* parent */
+                    default:    /* parent */
                        return 0;
                }
            }
            setsid();
            break;
        case 'n':
-            /* run in network namespace */
-            if (unshare(CLONE_NEWNET) == -1) {
+            /* run in network and mount namespaces */
+            if (unshare(CLONE_NEWNET|CLONE_NEWNS) == -1) {
                perror("unshare");
                return 1;
            }
+            /* mount sysfs to pick up the new network namespace */
+            if (mount("sysfs", "/sys", "sysfs", MS_MGC_VAL, NULL) == -1) {
+                perror("mount");
+                return 1;
+            }
            break;
        case 'p':
            /* print pid */
@@ -133,9 +142,9 @@ int main(int argc, char *argv[])
            fflush(stdout);
            break;
        case 'a':
-            /* Attach to pid's network namespace */
+            /* Attach to pid's network namespace and mount namespace */
            pid = atoi(optarg);
-            sprintf(path, "/proc/%d/ns/net", pid );
+            sprintf(path, "/proc/%d/ns/net", pid);
            nsid = open(path, O_RDONLY);
            if (nsid < 0) {
                perror(path);
@@ -145,6 +154,22 @@ int main(int argc, char *argv[])
                perror("setns");
                return 1;
            }
+            /* Plan A: call setns() to attach to mount namespace */
+            sprintf(path, "/proc/%d/ns/mnt", pid);
+            nsid = open(path, O_RDONLY);
+            if (nsid < 0 || setns(nsid, 0) != 0) {
+                /* Plan B: chroot/chdir into pid's root file system */
+                sprintf(path, "/proc/%d/root", pid);
+                if (chroot(path) < 0) {
+                    perror(path);
+                    return 1;
+                }
+            }
+            /* chdir to correct working directory */
+            if (chdir(cwd) != 0) {
+                perror(cwd);
+                return 1;
+            }
            break;
        case 'g':
            /* Attach to cgroup */
@@ -166,7 +191,7 @@ int main(int argc, char *argv[])
            exit(0);
        default:
            usage(argv[0]);
-            exit(1); 
+            exit(1);
        }

    if (optind < argc) {
@@ -174,6 +199,8 @@ int main(int argc, char *argv[])
        perror(argv[optind]);
        return 1;
    }
-    
+
    usage(argv[0]);
+
+    return 0;
 }
@@ -20,25 +20,24 @@ setup(
    description='Process-based OpenFlow emulator',
    author='Bob Lantz',
    author_email='rlantz@cs.stanford.edu',
-    packages=find_packages(exclude='test'),
+    packages=[ 'mininet', 'mininet.examples' ],
    long_description="""
        Mininet is a network emulator which uses lightweight
        virtualization to create virtual networks for rapid
        prototyping of Software-Defined Network (SDN) designs
-        using OpenFlow. http://openflow.org/mininet
+        using OpenFlow. http://mininet.org
        """,
    classifiers=[
          "License :: OSI Approved :: BSD License",
          "Programming Language :: Python",
-          "Development Status :: 2 - Pre-Alpha",
+          "Development Status :: 5 - Production/Stable",
          "Intended Audience :: Developers",
-          "Topic :: Internet",
+          "Topic :: System :: Emulators",
    ],
    keywords='networking emulator protocol Internet OpenFlow SDN',
    license='BSD',
    install_requires=[
-        'setuptools',
-        'networkx'
+        'setuptools'
    ],
    scripts=scripts,
 )
@@ -0,0 +1,182 @@
+#!/usr/bin/env bash
+
+# Mininet ssh authentication script for cluster edition
+# This script will create a single key pair, which is then
+# propagated throughout the entire cluster.
+# There are two options for setup; temporary setup
+# persistent setup. If no options are specified, and the script
+# is only given ip addresses or host names, it will default to
+# the temporary setup. An ssh directory is then created in
+# /tmp/mn/ssh on each node, and mounted with the keys over the
+# user's ssh directory. This setup can easily be torn down by running
+# clustersetup with the -c option.
+# If the -p option is used, the setup will be persistent. In this
+# case, the key pair will be be distributed directly to each node's
+# ssh directory, but will be called cluster_key. An option to
+# specify this key for use will be added to the config file in each
+# user's ssh directory.
+
+
+set -e
+num_options=0
+persistent=false
+showHelp=false
+clean=false
+declare -a hosts=()
+user=$(whoami)
+SSHDIR=/tmp/mn/ssh
+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
+        /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
+                    /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"
+    ssh-keygen -t rsa -C "Cluster_Edition_Key" -f $USERDIR/cluster_key -N '' &> /dev/null
+    cat $USERDIR/cluster_key.pub >> $USERDIR/authorized_keys
+    echo "***configuring ssh"
+    echo "IdentityFile $USERDIR/cluster_key" >> $USERDIR/config
+    echo "IdentityFile $USERDIR/id_rsa" >> $USERDIR/config
+
+    for host in $hosts; do
+        echo "***copying public key to $host"
+        ssh-copy-id  -i $USERDIR/cluster_key.pub $user@$host &> /dev/null
+        echo "***copying key pair to remote host"
+        scp $USERDIR/cluster_key $user@$host:$USERDIR
+        scp $USERDIR/cluster_key.pub $user@$host:$USERDIR
+        echo "***configuring remote host"
+        ssh -o ForwardAgent=yes  $user@$host "
+        echo 'IdentityFile $USERDIR/cluster_key' >> $USERDIR/config
+        echo 'IdentityFile $USERDIR/id_rsa' >> $USERDIR/config"
+    done
+
+    for host in $hosts; do
+        echo "***copying known_hosts to $host"
+        scp $USERDIR/known_hosts $user@$host:$USERDIR/cluster_known_hosts
+        ssh $user@$host "
+        cat $USERDIR/cluster_known_hosts >> $USERDIR/known_hosts
+        rm $USERDIR/cluster_known_hosts"
+    done
+}
+
+tempSetup() {
+    
+    echo "***creating temporary ssh directory"
+    mkdir -p $SSHDIR 
+    echo "***creating key pair"
+    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 /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 /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
+}
+
+cleanup() {
+    
+    for host in $hosts; do
+    echo "***cleaning up $host"
+    ssh $user@$host "sudo umount /home/$user/.ssh
+                          sudo rm -rf $SSHDIR"
+    done
+
+    echo "**unmounting local directories"
+    sudo umount /home/$user/.ssh
+    echo "***removing temporary ssh directory"
+    sudo rm -rf $SSHDIR
+    echo "done!"
+
+}
+
+
+if [ $# -eq 0 ]; then
+    echo "ERROR: No Arguments"
+    echo "$usage"
+    exit
+else
+    while getopts 'hpc' OPTION
+    do
+        ((num_options+=1))
+        case $OPTION in
+        h)  showHelp=true;;
+        p)  persistent=true;;
+        c)  clean=true;;
+        ?)  showHelp=true;;
+        esac
+    done
+    shift $(($OPTIND - 1))
+fi
+
+if [ "$num_options" -gt 1 ]; then
+    echo "ERROR: Too Many Options"
+    echo "$usage"
+    exit
+fi
+
+if $showHelp; then
+    echo "$usage"
+    exit
+fi
+
+for i in "$@"; do
+    output=$(getent ahostsv4 "$i")
+    if [ -z "$output" ]; then
+        echo '***WARNING: could not find hostname "$i"'
+        echo ""
+    else
+        hosts+="$i "
+    fi
+done
+
+if $clean; then
+    cleanup
+    exit
+fi
+
+echo "***authenticating to:"
+for host in $hosts; do
+    echo "$host"
+done
+
+echo
+
+if $persistent; then
+    echo '***Setting up persistent SSH configuration between all nodes'
+    persistentSetup
+    echo $'\n*** Sucessfully set up ssh throughout the cluster!'
+
+else
+    echo '*** Setting up temporary SSH configuration between all nodes'
+    tempSetup
+    echo $'\n***Finished temporary setup. When you are done with your cluster'
+    echo $'   session, tear down the SSH connections with'
+    echo $'   ./clustersetup.sh -c '$hosts''
+fi
+
+echo
@@ -9,6 +9,18 @@ set -e
 # Fail on unset var usage
 set -o nounset

+# Get directory containing mininet folder
+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, 
+#  in which case we use the directory containing mininet
+BUILD_DIR="$(pwd -P)"
+case $BUILD_DIR in
+  $MININET_DIR/*) BUILD_DIR=$MININET_DIR;; # currect directory is a subdirectory
+  *) BUILD_DIR=$BUILD_DIR;;
+esac
+
 # Location of CONFIG_NET_NS-enabled kernel(s)
 KERNEL_LOC=http://www.openflow.org/downloads/mininet

@@ -31,8 +43,15 @@ if [ "$DIST" = "Ubuntu" ] || [ "$DIST" = "Debian" ]; then
    if ! which lsb_release &> /dev/null; then
        $install lsb-release
    fi
-    if ! which bc &> /dev/null; then
-        $install bc
+fi
+test -e /etc/fedora-release && DIST="Fedora"
+if [ "$DIST" = "Fedora" ]; then
+    install='sudo yum -y install'
+    remove='sudo yum -y erase'
+    pkginst='sudo rpm -ivh'
+    # Prereqs for this script
+    if ! which lsb_release &> /dev/null; then
+        $install redhat-lsb-core
    fi
 fi
 if which lsb_release &> /dev/null; then
@@ -44,25 +63,28 @@ echo "Detected Linux distribution: $DIST $RELEASE $CODENAME $ARCH"

 # Kernel params

-if [ "$DIST" = "Ubuntu" ]; then
-    if [ "$RELEASE" = "10.04" ]; then
-        KERNEL_NAME='3.0.0-15-generic'
-    else
-        KERNEL_NAME=`uname -r`
-    fi
-    KERNEL_HEADERS=linux-headers-${KERNEL_NAME}
-elif [ "$DIST" = "Debian" ] && [ "$ARCH" = "i386" ] && [ "$CODENAME" = "lenny" ]; then
-    KERNEL_NAME=2.6.33.1-mininet
-    KERNEL_HEADERS=linux-headers-${KERNEL_NAME}_${KERNEL_NAME}-10.00.Custom_i386.deb
-    KERNEL_IMAGE=linux-image-${KERNEL_NAME}_${KERNEL_NAME}-10.00.Custom_i386.deb
-else
-    echo "Install.sh currently only supports Ubuntu and Debian Lenny i386."
+KERNEL_NAME=`uname -r`
+KERNEL_HEADERS=kernel-headers-${KERNEL_NAME}
+
+if ! echo $DIST | egrep 'Ubuntu|Debian|Fedora'; then
+    echo "Install.sh currently only supports Ubuntu, Debian and Fedora."
    exit 1
 fi

 # More distribution info
 DIST_LC=`echo $DIST | tr [A-Z] [a-z]` # as lower case

+
+# Determine whether version $1 >= version $2
+# usage: if version_ge 1.20 1.2.3; then echo "true!"; fi
+function version_ge {
+    # sort -V sorts by *version number*
+    latest=`printf "$1\n$2" | sort -V | tail -1`
+    # If $1 is latest version, then $1 >= $2
+    [ "$1" == "$latest" ]
+}
+
+
 # Kernel Deb pkg to be removed:
 KERNEL_IMAGE_OLD=linux-image-2.6.26-33-generic

@@ -72,39 +94,15 @@ OVS_RELEASE=1.4.0
 OVS_PACKAGE_LOC=https://github.com/downloads/mininet/mininet
 OVS_BUILDSUFFIX=-ignore # was -2
 OVS_PACKAGE_NAME=ovs-$OVS_RELEASE-core-$DIST_LC-$RELEASE-$ARCH$OVS_BUILDSUFFIX.tar
-OVS_SRC=~/openvswitch
 OVS_TAG=v$OVS_RELEASE
-OVS_BUILD=$OVS_SRC/build-$KERNEL_NAME
-OVS_KMODS=($OVS_BUILD/datapath/linux/{openvswitch_mod.ko,brcompat_mod.ko})
+
+OF13_SWITCH_REV=${OF13_SWITCH_REV:-""}
+

 function kernel {
    echo "Install Mininet-compatible kernel if necessary"
    sudo apt-get update
-    if [ "$DIST" = "Ubuntu" ] &&  [ "$RELEASE" = "10.04" ]; then
-        $install linux-image-$KERNEL_NAME
-    elif [ "$DIST" = "Debian" ]; then
-        # The easy approach: download pre-built linux-image and linux-headers packages:
-        wget -c $KERNEL_LOC/$KERNEL_HEADERS
-        wget -c $KERNEL_LOC/$KERNEL_IMAGE
-
-        # Install custom linux headers and image:
-        $pkginst $KERNEL_IMAGE $KERNEL_HEADERS
-
-        # The next two steps are to work around a bug in newer versions of
-        # kernel-package, which fails to add initrd images with the latest kernels.
-        # See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=525032
-        # Generate initrd image if the .deb didn't install it:
-        if ! test -e /boot/initrd.img-${KERNEL_NAME}; then
-            sudo update-initramfs -c -k ${KERNEL_NAME}
-        fi
-
-        # Ensure /boot/grub/menu.lst boots with initrd image:
-        sudo update-grub
-
-        # The default should be the new kernel. Otherwise, you may need to modify
-        # /boot/grub/menu.lst to set the default to the entry corresponding to the
-        # kernel you just installed.
-    fi
+    $install linux-image-$KERNEL_NAME
 }

 function kernel_clean {
@@ -116,197 +114,239 @@ function kernel_clean {
    fi

    # Also remove downloaded packages:
-    rm -f ~/linux-headers-* ~/linux-image-*
+    rm -f $HOME/linux-headers-* $HOME/linux-image-*
 }

 # Install Mininet deps
 function mn_deps {
    echo "Installing Mininet dependencies"
-    $install gcc make screen psmisc xterm ssh iperf iproute telnet \
-        python-setuptools python-networkx cgroup-bin ethtool help2man \
-        pyflakes pylint pep8
-
-    if [ "$DIST" = "Ubuntu" ] && [ "$RELEASE" = "10.04" ]; then
-        echo "Upgrading networkx to avoid deprecation warning"
-        sudo easy_install --upgrade networkx
+    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
+    else
+        $install gcc make socat psmisc xterm ssh iperf iproute telnet \
+            python-setuptools cgroup-bin ethtool help2man \
+            pyflakes pylint pep8
    fi

-    # Add sysctl parameters as noted in the INSTALL file to increase kernel
-    # limits to support larger setups:
-    sudo su -c "cat $HOME/mininet/util/sysctl_addon >> /etc/sysctl.conf"
-
-    # Load new sysctl settings:
-    sudo sysctl -p
-
    echo "Installing Mininet core"
-    pushd ~/mininet
+    pushd $MININET_DIR/mininet
    sudo make install
    popd
 }

+# Install Mininet developer dependencies
+function mn_dev {
+    echo "Installing Mininet developer dependencies"
+    $install doxygen doxypy texlive-fonts-recommended
+    if ! $install doxygen-latex; then
+        echo "doxygen-latex not needed"
+    fi
+}
+
 # The following will cause a full OF install, covering:
 # -user switch
 # The instructions below are an abbreviated version from
 # http://www.openflowswitch.org/wk/index.php/Debian_Install
-# ... modified to use Debian Lenny rather than unstable.
 function of {
    echo "Installing OpenFlow reference implementation..."
-    cd ~/
-    $install git-core autoconf automake autotools-dev pkg-config \
-		make gcc libtool libc6-dev
+    cd $BUILD_DIR
+    $install autoconf automake libtool make gcc
+    if [ "$DIST" = "Fedora" ]; then
+        $install git pkgconfig glibc-devel
+    else
+        $install git-core autotools-dev pkg-config libc6-dev
+    fi
    git clone git://openflowswitch.org/openflow.git
-    cd ~/openflow
+    cd $BUILD_DIR/openflow

    # Patch controller to handle more than 16 switches
-    patch -p1 < ~/mininet/util/openflow-patches/controller.patch
+    patch -p1 < $MININET_DIR/mininet/util/openflow-patches/controller.patch

    # Resume the install:
    ./boot.sh
    ./configure
    make
    sudo make install
-
-    # Remove avahi-daemon, which may cause unwanted discovery packets to be
-    # sent during tests, near link status changes:
-    $remove avahi-daemon
-
-    # Disable IPv6.  Add to /etc/modprobe.d/blacklist:
-    if [ "$DIST" = "Ubuntu" ]; then
-        BLACKLIST=/etc/modprobe.d/blacklist.conf
-    else
-        BLACKLIST=/etc/modprobe.d/blacklist
-    fi
-    sudo sh -c "echo 'blacklist net-pf-10\nblacklist ipv6' >> $BLACKLIST"
-    cd ~
+    cd $BUILD_DIR
 }

-function wireshark {
-    echo "Installing Wireshark dissector..."
+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 libxerces-c2-dev  \
+        unzip libpcre3-dev flex bison libboost-dev

-    sudo apt-get install -y wireshark libgtk2.0-dev
+    if [ ! -d "ofsoftswitch13" ]; then
+        git clone https://github.com/CPqD/ofsoftswitch13.git
+        if [[ -n "$OF13_SWITCH_REV" ]]; then
+            cd ofsoftswitch13
+            git checkout ${OF13_SWITCH_REV}
+            cd ..
+        fi
+    fi

-    if [ "$DIST" = "Ubuntu" ] && [ "$RELEASE" != "10.04" ]; then
-        # Install newer version
-        sudo apt-get install -y scons mercurial libglib2.0-dev
-        sudo apt-get install -y libwiretap-dev libwireshark-dev
-        cd ~
-        hg clone https://bitbucket.org/barnstorm/of-dissector
-        cd of-dissector/src
-        export WIRESHARK=/usr/include/wireshark
-        scons
-        # libwireshark0/ on 11.04; libwireshark1/ on later
-        WSDIR=`ls -d /usr/lib/wireshark/libwireshark* | head -1`
-        WSPLUGDIR=$WSDIR/plugins/
-        sudo cp openflow.so $WSPLUGDIR
-        echo "Copied openflow plugin to $WSPLUGDIR"
-    else
-        # Install older version from reference source
-        cd ~/openflow/utilities/wireshark_dissectors/openflow
-        make
-        sudo make install
+    # Install netbee
+    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 ${NBEESRC}/bin/libn*.so /usr/local/lib
+    sudo ldconfig
+    sudo cp -R ${NBEESRC}/include/ /usr/
+
+    # Resume the install:
+    cd $BUILD_DIR/ofsoftswitch13
+    ./boot.sh
+    ./configure
+    make
+    sudo make install
+    cd $BUILD_DIR
+}
+
+
+function install_wireshark {
+    if ! which wireshark; then
+        echo "Installing Wireshark"
+        if [ "$DIST" = "Fedora" ]; then
+            $install wireshark wireshark-gnome
+        else
+            $install wireshark tshark
+        fi
    fi

    # Copy coloring rules: OF is white-on-blue:
-    mkdir -p ~/.wireshark
-    cp ~/mininet/util/colorfilters ~/.wireshark
+    echo "Optionally installing wireshark color filters"
+    mkdir -p $HOME/.wireshark
+    cp -n $MININET_DIR/mininet/util/colorfilters $HOME/.wireshark
+
+    echo "Checking Wireshark version"
+    WSVER=`wireshark -v | egrep -o '[0-9\.]+' | head -1`
+    if version_ge $WSVER 1.12; then
+        echo "Wireshark version $WSVER >= 1.12 - returning"
+        return
+    fi
+
+    echo "Cloning LoxiGen and building openflow.lua dissector"
+    cd $BUILD_DIR
+    git clone https://github.com/floodlight/loxigen.git
+    cd loxigen
+    make wireshark
+
+    # Copy into plugin directory
+    # libwireshark0/ on 11.04; libwireshark1/ on later
+    WSDIR=`find /usr/lib -type d -name 'libwireshark*' | head -1`
+    WSPLUGDIR=$WSDIR/plugins/
+    PLUGIN=loxi_output/wireshark/openflow.lua
+    sudo cp $PLUGIN $WSPLUGDIR
+    echo "Copied openflow plugin $PLUGIN to $WSPLUGDIR"
+
+    cd $BUILD_DIR
+}
+
+
+# Install Open vSwitch specific version Ubuntu package
+function ubuntuOvs {
+    echo "Creating and Installing Open vSwitch packages..."
+
+    OVS_SRC=$BUILD_DIR/openvswitch
+    OVS_TARBALL_LOC=http://openvswitch.org/releases
+
+    if [ "$DIST" = "Ubuntu" ] && version_ge $RELEASE 12.04; then
+        rm -rf $OVS_SRC
+        mkdir -p $OVS_SRC
+        cd $OVS_SRC
+
+        if wget $OVS_TARBALL_LOC/openvswitch-$OVS_RELEASE.tar.gz 2> /dev/null; then
+            tar xzf openvswitch-$OVS_RELEASE.tar.gz
+        else
+            echo "Failed to find OVS at $OVS_TARBALL_LOC/openvswitch-$OVS_RELEASE.tar.gz"
+            cd $BUILD_DIR
+            return
+        fi
+
+        # Remove any old packages
+        $remove openvswitch-common openvswitch-datapath-dkms openvswitch-controller \
+                openvswitch-pki openvswitch-switch
+
+        # Get build deps
+        $install build-essential fakeroot debhelper autoconf automake libssl-dev \
+                 pkg-config bzip2 openssl python-all procps python-qt4 \
+                 python-zopeinterface python-twisted-conch dkms
+
+        # Build OVS
+        cd $BUILD_DIR/openvswitch/openvswitch-$OVS_RELEASE
+                DEB_BUILD_OPTIONS='parallel=2 nocheck' fakeroot debian/rules binary
+        cd ..
+        $pkginst openvswitch-common_$OVS_RELEASE*.deb openvswitch-datapath-dkms_$OVS_RELEASE*.deb \
+                 openvswitch-pki_$OVS_RELEASE*.deb openvswitch-switch_$OVS_RELEASE*.deb
+        if $pkginst openvswitch-controller_$OVS_RELEASE*.deb; then
+            echo "Ignoring error installing openvswitch-controller"
+        fi
+
+        modinfo openvswitch
+        sudo ovs-vsctl show
+        # Switch can run on its own, but
+        # Mininet should control the controller
+        # This appears to only be an issue on Ubuntu/Debian
+        if sudo service openvswitch-controller stop; then
+            echo "Stopped running controller"
+        fi
+        if [ -e /etc/init.d/openvswitch-controller ]; then
+            sudo update-rc.d openvswitch-controller disable
+        fi
+    else
+        echo "Failed to install Open vSwitch.  OS must be Ubuntu >= 12.04"
+            cd $BUILD_DIR
+            return
+    fi
 }


 # Install Open vSwitch
-# Instructions derived from OVS INSTALL, INSTALL.OpenFlow and README files.

 function ovs {
    echo "Installing Open vSwitch..."

-    # Required for module build/dkms install
-    $install $KERNEL_HEADERS
-
-    ovspresent=0
-
-    # First see if we have packages
-    # XXX wget -c seems to fail from github/amazon s3
-    cd /tmp
-    if wget $OVS_PACKAGE_LOC/$OVS_PACKAGE_NAME 2> /dev/null; then
-	$install patch dkms fakeroot python-argparse
-        tar xf $OVS_PACKAGE_NAME
-        orig=`tar tf $OVS_PACKAGE_NAME`
-        # Now install packages in reasonable dependency order
-        order='dkms common pki openvswitch-switch brcompat controller'
-        pkgs=""
-        for p in $order; do
-            pkg=`echo "$orig" | grep $p`
-	    # Annoyingly, things seem to be missing without this flag
-            $pkginst --force-confmiss $pkg
-        done
-        ovspresent=1
-    fi
-
-    # Otherwise try distribution's OVS packages
-    if [ "$DIST" = "Ubuntu" ] && [ `expr $RELEASE '>=' 11.10` = 1 ]; then
-        if ! dpkg --get-selections | grep openvswitch-datapath; then
-            # If you've already installed a datapath, assume you
-            # know what you're doing and don't need dkms datapath.
-            # Otherwise, install it.
-            $install openvswitch-datapath-dkms
-        fi
-	if $install openvswitch-switch openvswitch-controller; then
-            echo "Ignoring error installing openvswitch-controller"
-        fi
-        ovspresent=1
-    fi
-
-    # Switch can run on its own, but
-    # Mininet should control the controller
-    if [ -e /etc/init.d/openvswitch-controller ]; then
-        if sudo service openvswitch-controller stop; then
-            echo "Stopped running controller"
-        fi
-        sudo update-rc.d openvswitch-controller disable
-    fi
-
-    if [ $ovspresent = 1 ]; then
-        echo "Done (hopefully) installing packages"
-        cd ~
+    if [ "$DIST" == "Fedora" ]; then
+        $install openvswitch openvswitch-controller
        return
    fi

-    # Otherwise attempt to install from source
+    # Manually installing openvswitch-datapath may be necessary
+    # for manually built kernel .debs using Debian's defective kernel
+    # packaging, which doesn't yield usable headers.
+    if ! dpkg --get-selections | grep openvswitch-datapath; then
+        # If you've already installed a datapath, assume you
+        # know what you're doing and don't need dkms datapath.
+        # Otherwise, install it.
+        $install openvswitch-datapath-dkms
+    fi

-    $install pkg-config gcc make python-dev libssl-dev libtool
-
-    if [ "$DIST" = "Debian" ]; then
-        if [ "$CODENAME" = "lenny" ]; then
-            $install git-core
-            # Install Autoconf 2.63+ backport from Debian Backports repo:
-            # Instructions from http://backports.org/dokuwiki/doku.php?id=instructions
-            sudo su -c "echo 'deb http://www.backports.org/debian lenny-backports main contrib non-free' >> /etc/apt/sources.list"
-            sudo apt-get update
-            sudo apt-get -y --force-yes install debian-backports-keyring
-            sudo apt-get -y --force-yes -t lenny-backports install autoconf
+    $install openvswitch-switch
+    if $install openvswitch-controller; 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 openvswitch-controller stop; then
+            echo "Stopped running controller"
+        fi
+        if [ -e /etc/init.d/openvswitch-controller ]; then
+            sudo update-rc.d openvswitch-controller disable
        fi
    else
-        $install git
+        echo "Attempting to install openvswitch-testcontroller"
+        if ! $install openvswitch-testcontroller; then
+            echo "Failed - giving up"
+        fi
    fi

-    # Install OVS from release
-    cd ~/
-    git clone git://openvswitch.org/openvswitch $OVS_SRC
-    cd $OVS_SRC
-    git checkout $OVS_TAG
-    ./boot.sh
-    BUILDDIR=/lib/modules/${KERNEL_NAME}/build
-    if [ ! -e $BUILDDIR ]; then
-        echo "Creating build sdirectory $BUILDDIR"
-        sudo mkdir -p $BUILDDIR
-    fi
-    opts="--with-linux=$BUILDDIR"
-    mkdir -p $OVS_BUILD
-    cd $OVS_BUILD
-    ../configure $opts
-    make
-    sudo make install
-
-    modprobe
 }

 function remove_ovs {
@@ -330,6 +370,54 @@ function remove_ovs {
    echo "Done removing OVS"
 }

+function ivs {
+    echo "Installing Indigo Virtual Switch..."
+
+    IVS_SRC=$BUILD_DIR/ivs
+
+    # Install dependencies
+    $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 --recursive
+    cd $IVS_SRC
+    make
+    sudo make install
+}
+
+# Install RYU
+function ryu {
+    echo "Installing RYU..."
+
+    # install Ryu dependencies"
+    $install autoconf automake g++ libtool python make
+    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 python ./setup.py install
+
+    # Add symbolic link to /usr/bin
+    sudo ln -s ./bin/ryu-manager /usr/local/bin/ryu-manager
+}
+
 # Install NOX with tutorial files
 function nox {
    echo "Installing NOX w/tutorial files..."
@@ -348,7 +436,7 @@ function nox {
    $install libsqlite3-dev python-simplejson

    # Fetch NOX destiny
-    cd ~/
+    cd $BUILD_DIR/
    git clone https://github.com/noxrepo/nox-classic.git noxcore
    cd noxcore
    if ! git checkout -b destiny remotes/origin/destiny ; then
@@ -357,9 +445,9 @@ function nox {

    # Apply patches
    git checkout -b tutorial-destiny
-    git am ~/mininet/util/nox-patches/*tutorial-port-nox-destiny*.patch
-    if [ "$DIST" = "Ubuntu" ] && [ `expr $RELEASE '>=' 12.04` = 1 ]; then
-        git am ~/mininet/util/nox-patches/*nox-ubuntu12-hacks.patch
+    git am $MININET_DIR/mininet/util/nox-patches/*tutorial-port-nox-destiny*.patch
+    if [ "$DIST" = "Ubuntu" ] && version_ge $RELEASE 12.04; then
+        git am $MININET_DIR/mininet/util/nox-patches/*nox-ubuntu12-hacks.patch
    fi

    # Build
@@ -371,17 +459,51 @@ function nox {
    #make check

    # Add NOX_CORE_DIR env var:
-    sed -i -e 's|# for examples$|&\nexport NOX_CORE_DIR=~/noxcore/build/src|' ~/.bashrc
+    sed -i -e 's|# for examples$|&\nexport NOX_CORE_DIR=$BUILD_DIR/noxcore/build/src|' ~/.bashrc

    # To verify this install:
    #cd ~/noxcore/build/src
    #./nox_core -v -i ptcp:
 }

+# Install NOX Classic/Zaku for OpenFlow 1.3
+function nox13 {
+    echo "Installing NOX w/tutorial files..."
+
+    # Install NOX deps:
+    $install autoconf automake g++ libtool python python-twisted \
+        swig libssl-dev make
+    if [ "$DIST" = "Debian" ]; then
+        $install libboost1.35-dev
+    elif [ "$DIST" = "Ubuntu" ]; then
+        $install python-dev libboost-dev
+        $install libboost-filesystem-dev
+        $install libboost-test-dev
+    fi
+
+    # Fetch NOX destiny
+    cd $BUILD_DIR/
+    git clone https://github.com/CPqD/nox13oflib.git
+    cd nox13oflib
+
+    # Build
+    ./boot.sh
+    mkdir build
+    cd build
+    ../configure
+    make -j3
+    #make check
+
+    # To verify this install:
+    #cd ~/nox13oflib/build/src
+    #./nox_core -v -i ptcp:
+}
+
+
 # "Install" POX
 function pox {
-    echo "Installing POX into $HOME/pox..."
-    cd ~
+    echo "Installing POX into $BUILD_DIR/pox..."
+    cd $BUILD_DIR
    git clone https://github.com/noxrepo/pox.git
 }

@@ -393,37 +515,69 @@ function oftest {
    $install tcpdump python-scapy

    # Install oftest:
-    cd ~/
+    cd $BUILD_DIR/
    git clone git://github.com/floodlight/oftest
-    cd oftest
-    cd tools/munger
-    sudo make install
 }

 # Install cbench
 function cbench {
    echo "Installing cbench..."

-    $install libsnmp-dev libpcap-dev libconfig-dev
-    cd ~/
-    git clone git://openflow.org/oflops.git
+    if [ "$DIST" = "Fedora" ]; then
+        $install net-snmp-devel libpcap-devel libconfig-devel
+    else
+        $install libsnmp-dev libpcap-dev libconfig-dev
+    fi
+    cd $BUILD_DIR/
+    git clone git://gitosis.stanford.edu/oflops.git
    cd oflops
    sh boot.sh || true # possible error in autoreconf, so run twice
    sh boot.sh
-    ./configure --with-openflow-src-dir=$HOME/openflow
+    ./configure --with-openflow-src-dir=$BUILD_DIR/openflow
    make
    sudo make install || true # make install fails; force past this
 }

-function other {
-    echo "Doing other setup tasks..."
+function vm_other {
+    echo "Doing other Mininet VM setup tasks..."
+
+    # Remove avahi-daemon, which may cause unwanted discovery packets to be
+    # sent during tests, near link status changes:
+    echo "Removing avahi-daemon"
+    $remove avahi-daemon
+
+    # was: Disable IPv6.  Add to /etc/modprobe.d/blacklist:
+    #echo "Attempting to disable IPv6"
+    #if [ "$DIST" = "Ubuntu" ]; then
+    #    BLACKLIST=/etc/modprobe.d/blacklist.conf
+    #else
+    #    BLACKLIST=/etc/modprobe.d/blacklist
+    #fi
+    #sudo sh -c "echo 'blacklist net-pf-10\nblacklist ipv6' >> $BLACKLIST"
+
+    # Disable IPv6
+    if ! grep 'disable IPv6' /etc/sysctl.conf; then
+        echo 'Disabling IPv6'
+        echo '
+# Mininet: disable IPv6
+net.ipv6.conf.all.disable_ipv6 = 1
+net.ipv6.conf.default.disable_ipv6 = 1
+net.ipv6.conf.lo.disable_ipv6 = 1' | sudo tee -a /etc/sysctl.conf > /dev/null
+    fi
+    # Disabling IPv6 breaks X11 forwarding via ssh
+    line='AddressFamily inet'
+    file='/etc/ssh/sshd_config'
+    echo "Adding $line to $file"
+    if ! grep "$line" $file > /dev/null; then
+        echo "$line" | sudo tee -a $file > /dev/null
+    fi

    # Enable command auto completion using sudo; modify ~/.bashrc:
    sed -i -e 's|# for examples$|&\ncomplete -cf sudo|' ~/.bashrc

-    # Install tcpdump and tshark, cmd-line packet dump tools.  Also install gitk,
+    # Install tcpdump, cmd-line packet dump tool.  Also install gitk,
    # a graphical git history viewer.
-    $install tcpdump tshark gitk
+    $install tcpdump gitk

    # Install common text editors
    $install vim nano emacs
@@ -431,6 +585,13 @@ function other {
    # Install NTP
    $install ntp

+    # Install vconfig for VLAN example
+    if [ "$DIST" = "Fedora" ]; then
+        $install vconfig
+    else
+        $install vlan
+    fi
+
    # Set git to colorize everything.
    git config --global color.diff auto
    git config --global color.status auto
@@ -454,25 +615,41 @@ function other {
 # a good idea to use a symbolic link in place of the copy below.
 function modprobe {
    echo "Setting up modprobe for OVS kmod..."
-
-    sudo cp $OVS_KMODS $DRIVERS_DIR
-    sudo depmod -a ${KERNEL_NAME}
+    set +o nounset
+    if [ -z "$OVS_KMODS" ]; then
+      echo "OVS_KMODS not set. Aborting."
+    else
+      sudo cp $OVS_KMODS $DRIVERS_DIR
+      sudo depmod -a ${KERNEL_NAME}
+    fi
+    set -o nounset
 }

 function all {
-    echo "Running all commands..."
+    if [ "$DIST" = "Fedora" ]; then
+        printf "\nFedora 18+ support (still work in progress):\n"
+        printf " * Fedora 18+ has kernel 3.10 RPMS in the updates repositories\n"
+        printf " * Fedora 18+ has openvswitch 1.10 RPMS in the updates repositories\n"
+        printf " * the install.sh script options [-bfnpvw] should work.\n"
+        printf " * for a basic setup just try:\n"
+        printf "       install.sh -fnpv\n\n"
+        exit 3
+    fi
+    echo "Installing all packages except for -eix (doxypy, ivs, nox-classic)..."
    kernel
    mn_deps
+    # Skip mn_dev (doxypy/texlive/fonts/etc.) because it's huge
+    # mn_dev
    of
-    wireshark
+    install_wireshark
    ovs
+    # We may add ivs once it's more mature
+    # ivs
    # NOX-classic is deprecated, but you can install it manually if desired.
    # nox
    pox
    oftest
    cbench
-    other
-    echo "Please reboot, then run ./mininet/util/install.sh -c to remove unneeded packages."
    echo "Enjoy Mininet!"
 }

@@ -480,6 +657,7 @@ function all {
 function vm_clean {
    echo "Cleaning VM..."
    sudo apt-get clean
+    sudo apt-get autoremove
    sudo rm -rf /tmp/*
    sudo rm -rf openvswitch*.tar.gz

@@ -500,16 +678,20 @@ function vm_clean {
    git config --global user.name "None"
    git config --global user.email "None"

-    # Remove mininet install script
-    rm -f install-mininet.sh
+    # 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
+    sync ; sleep 1 ; sync ; sudo rm -f /tmp/zero
+
 }

 function usage {
-    printf 'Usage: %s [-acdfhkmntvxy]\n\n' $(basename $0) >&2
+    printf '\nUsage: %s [-abcdfhikmnprtvVwxy03]\n\n' $(basename $0) >&2

    printf 'This install script attempts to install useful packages\n' >&2
-    printf 'for Mininet. It should (hopefully) work on Ubuntu 10.04, 11.10\n' >&2
-    printf 'and Debian 5.0 (Lenny). If you run into trouble, try\n' >&2
+    printf 'for Mininet. It should (hopefully) work on Ubuntu 11.10+\n' >&2
+    printf 'If you run into trouble, try\n' >&2
    printf 'installing one thing at a time, and looking at the \n' >&2
    printf 'specific installation function in this script.\n\n' >&2

@@ -518,43 +700,69 @@ function usage {
    printf -- ' -b: install controller (B)enchmark (oflops)\n' >&2
    printf -- ' -c: (C)lean up after kernel install\n' >&2
    printf -- ' -d: (D)elete some sensitive files from a VM image\n' >&2
-    printf -- ' -f: install open(F)low\n' >&2
+    printf -- ' -e: install Mininet d(E)veloper dependencies\n' >&2
+    printf -- ' -f: install Open(F)low\n' >&2
    printf -- ' -h: print this (H)elp message\n' >&2
+    printf -- ' -i: install (I)ndigo Virtual Switch\n' >&2
    printf -- ' -k: install new (K)ernel\n' >&2
    printf -- ' -m: install Open vSwitch kernel (M)odule from source dir\n' >&2
-    printf -- ' -n: install mini(N)et dependencies + core files\n' >&2
+    printf -- ' -n: install Mini(N)et dependencies + core files\n' >&2
+    printf -- ' -p: install (P)OX OpenFlow Controller\n' >&2
    printf -- ' -r: remove existing Open vSwitch packages\n' >&2
-    printf -- ' -t: install o(T)her stuff\n' >&2
-    printf -- ' -v: install open (V)switch\n' >&2
-    printf -- ' -w: install OpenFlow (w)ireshark dissector\n' >&2
-    printf -- ' -x: install NO(X) OpenFlow controller\n' >&2
-    printf -- ' -y: install (A)ll packages\n' >&2
-
+    printf -- ' -s <dir>: place dependency (S)ource/build trees in <dir>\n' >&2
+    printf -- ' -t: complete o(T)her Mininet VM setup tasks\n' >&2
+    printf -- ' -v: install Open (V)switch\n' >&2
+    printf -- ' -V <version>: install a particular version of Open (V)switch on Ubuntu\n' >&2
+    printf -- ' -w: install OpenFlow (W)ireshark dissector\n' >&2
+    printf -- ' -y: install R(y)u Controller\n' >&2
+    printf -- ' -x: install NO(X) Classic OpenFlow controller\n' >&2
+    printf -- ' -0: (default) -0[fx] installs OpenFlow 1.0 versions\n' >&2
+    printf -- ' -3: -3[fx] installs OpenFlow 1.3 versions\n' >&2
    exit 2
 }

+OF_VERSION=1.0
+
 if [ $# -eq 0 ]
 then
    all
 else
-    while getopts 'abcdfhkmnprtvwx' OPTION
+    while getopts 'abcdefhikmnprs:tvV:wxy03' OPTION
    do
      case $OPTION in
      a)    all;;
      b)    cbench;;
      c)    kernel_clean;;
      d)    vm_clean;;
-      f)    of;;
+      e)    mn_dev;;
+      f)    case $OF_VERSION in
+            1.0) of;;
+            1.3) of13;;
+            *)  echo "Invalid OpenFlow version $OF_VERSION";;
+            esac;;
      h)    usage;;
+      i)    ivs;;
      k)    kernel;;
      m)    modprobe;;
      n)    mn_deps;;
      p)    pox;;
      r)    remove_ovs;;
-      t)    other;;
+      s)    mkdir -p $OPTARG; # ensure the directory is created
+            BUILD_DIR="$( cd -P "$OPTARG" && pwd )"; # get the full path
+            echo "Dependency installation directory: $BUILD_DIR";;
+      t)    vm_other;;
      v)    ovs;;
-      w)    wireshark;;
-      x)    nox;;
+      V)    OVS_RELEASE=$OPTARG;
+            ubuntuOvs;;
+      w)    install_wireshark;;
+      x)    case $OF_VERSION in
+            1.0) nox;;
+            1.3) nox13;;
+            *)  echo "Invalid OpenFlow version $OF_VERSION";;
+            esac;;
+      y)    ryu;;
+      0)    OF_VERSION=1.0;;
+      3)    OF_VERSION=1.3;;
      ?)    usage;;
      esac
    done
@@ -0,0 +1,44 @@
+#!/bin/bash
+
+# Attach to a Mininet host and run a command
+
+if [ -z $1 ]; then
+  echo "usage: $0 host cmd [args...]"
+  exit 1
+else
+  host=$1
+fi
+
+pid=`ps ax | grep "mininet:$host$" | grep bash | grep -v mnexec | awk '{print $1};'`
+
+if echo $pid | grep -q ' '; then
+  echo "Error: found multiple mininet:$host processes"
+  exit 2
+fi
+
+if [ "$pid" == "" ]; then
+  echo "Could not find Mininet host $host"
+  exit 3
+fi
+
+if [ -z $2 ]; then
+  cmd='bash'
+else
+  shift
+  cmd=$*
+fi
+
+cgroup=/sys/fs/cgroup/cpu/$host
+if [ -d "$cgroup" ]; then
+  cg="-g $host"
+fi
+
+# Check whether host should be running in a chroot dir
+rootdir="/var/run/mn/$host/root"
+if [ -d $rootdir -a -x $rootdir/bin/bash ]; then
+    cmd="'cd `pwd`; exec $cmd'"
+    cmd="chroot $rootdir /bin/bash -c $cmd"
+fi
+
+cmd="exec sudo mnexec $cg -a $pid $cmd"
+eval $cmd
@@ -15,3 +15,4 @@ net.ipv4.neigh.default.gc_thresh3 = 16384

 # Mininet: increase routing table size
 net.ipv4.route.max_size=32768
+
@@ -8,7 +8,7 @@ version = 'Mininet ' + co( 'PYTHONPATH=. bin/mn --version', shell=True )
 version = version.strip()

 # Find all Mininet path references
-lines = co( "grep -or 'Mininet \w\.\w\.\w\w*' *", shell=True )
+lines = co( "egrep -or 'Mininet [0-9\.]+\w*' *", shell=True )

 error = False

@@ -3,17 +3,24 @@
 # This script is intended to install Mininet into
 # a brand-new Ubuntu virtual machine,
 # to create a fully usable "tutorial" VM.
+#
+# optional argument: Mininet branch to install
 set -e
-echo `whoami` ALL=NOPASSWD: ALL | sudo tee -a /etc/sudoers
+echo "$(whoami) ALL=(ALL) NOPASSWD:ALL" | sudo tee -a /etc/sudoers > /dev/null
 sudo sed -i -e 's/Default/#Default/' /etc/sudoers
-sudo sed -i -e 's/ubuntu/mininet-vm/' /etc/hostname
+echo mininet-vm | sudo tee /etc/hostname > /dev/null
 sudo sed -i -e 's/ubuntu/mininet-vm/g' /etc/hosts
 sudo hostname `cat /etc/hostname`
 sudo sed -i -e 's/quiet splash/text/' /etc/default/grub
 sudo update-grub
-sudo sed -i -e 's/us.archive.ubuntu.com/mirrors.kernel.org/' \
-	/etc/apt/sources.list
+# Update from official archive
 sudo apt-get update
+# 12.10 and earlier
+#sudo sed -i -e 's/us.archive.ubuntu.com/mirrors.kernel.org/' \
+#	/etc/apt/sources.list
+# 13.04 and later
+#sudo sed -i -e 's/\/archive.ubuntu.com/\/mirrors.kernel.org/' \
+#	/etc/apt/sources.list
 # Clean up vmware easy install junk if present
 if [ -e /etc/issue.backup ]; then
    sudo mv /etc/issue.backup /etc/issue
@@ -21,20 +28,21 @@ fi
 if [ -e /etc/rc.local.backup ]; then
    sudo mv /etc/rc.local.backup /etc/rc.local
 fi
-# Install Mininet
+# Fetch Mininet
 sudo apt-get -y install git-core openssh-server
 git clone git://github.com/mininet/mininet
-cd mininet
-cd
+# Optionally check out branch
+if [ "$1" != "" ]; then
+  pushd mininet
+  git checkout -b $1 $1
+  popd
+fi
+# Install Mininet
 time mininet/util/install.sh
+# Finalize VM
+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
 #fi
-echo <<EOF
-You may need to reboot and then:
-sudo dpkg-reconfigure openvswitch-datapath-dkms
-sudo service openvswitch-switch start
-EOF
-
-
+echo "Done preparing Mininet VM."