Remove setup/isOldOVS which have been merged into OVSSwitch

Pass rename correctly in moveSwitch()
Fix version check.
2014-09-22 12:27:49 -07:00 · 2014-08-26 19:55:48 -07:00 · 2014-08-26 19:55:48 -07:00 · 2014-08-26 19:55:48 -07:00 · 2014-08-26 19:55:48 -07:00 · 2014-08-26 19:55:48 -07:00
77 changed files with 8103 additions and 1008 deletions
@@ -0,0 +1,39 @@
+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
+
+Bob Lantz
+Brandon Heller
+Nikhil Handigol
+Vimal Jeyakumar
+Brian O'Connor
+
+Additional Mininet Contributors
+
+Gustavo Pantuza Coelho Pinto
+Ryan Cox
+Shaun Crampton
+David Erickson
+Glen Gibb
+Andrew Ferguson
+Eder Leao Fernandes
+Vitaly Ivanov
+Rich Lane
+Murphy McCauley
+José Pedro Oliveira
+James Page
+Angad Singh
+Piyush Srivastava
+Ed Swierk
+Isaku Yamahata
+
+Thanks also to everyone who has submitted issues and pull
+requests on github, and to our friendly mininet-discuss
+mailing list!
@@ -1,117 +1,173 @@

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

-Mininet 2.0.0
-
+Mininet 2.1.0+
 ---

-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, use:

-To install Mininet itself, the OpenFlow reference implementation, and
-Open vSwitch, you may use:
+        git clone git://github.com/mininet/mininet
+        git checkout -b 2.1.0 2.1.0

-$ mininet/util/install.sh -fnv
+   If you are running Ubuntu, you may be able to use our handy
+   `install.sh` script, which is in `mininet/util`.

-This should be reasonably quick and the following command should work
-after the installation:
+   *WARNING: USE AT YOUR OWN RISK!*

-$ sudo mn --test pingall
+   `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..
+   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 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
+   To install Mininet itself, the OpenFlow reference implementation, and
+   Open vSwitch, you may use:

-$ mininet/util/install.sh -a
+        mininet/util/install.sh -fnv

-This takes about 20 minutes on our test system.
+   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 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.

-* 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.1.0+ 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
+Version 2.1.0+

 ### What is Mininet?

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

  `mn -c`

-### New features in 2.0.0
+### New features in 2.1.0+

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

-* "Mininet-HiFi" functionality:
+* Convenient access to `Mininet()` as a dict of nodes
+* X11 tunneling (wireshark in Mininet hosts, finally!)
+* Accurate reflection of the `Mininet()` object in the CLI
+* Automatically detecting and adjusting resource limits
+* Automatic cleanup on failure of the `mn` command
+* Preliminary support for running OVS in user space mode
+* Preliminary support (`IVSSwitch()`) for the Indigo Virtual Switch
+* support for installing the OpenFlow 1.3 versions of the reference
+  user switch and NOX from CPqD
+* The ability to import modules from `mininet.examples`

-    * Link bandwidth limits using `tc` (`TCIntf` and `TCLink` classes)
+We have provided several new examples (which can easily be
+imported to provide useful functionality) including:

-    * CPU isolation and bandwidth limits (`CPULimitedHost` class)
+* Modeling separate control and data networks: `mininet.examples.controlnet`
+* Connecting Mininet hosts the internet (or a LAN) using NAT: `mininet.examples.nat`
+* Creating per-host custom directories using bind mounts: `mininet.examples.bind`

-* Support for Open vSwitch 1.4+ (including Ubuntu OVS packages)
-
-* Debian packaging (and `apt-get install mininet` in Ubuntu 12.10)
-
-* First-class Interface (`Intf`) and Link (`Link`) classes for easier
-  extensibility
-
-* An upgraded Topology (`Topo`) class which supports node and link
-  customization
-
-* 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 +102,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.)

@@ -116,19 +115,19 @@ Mininet mailing list, `mininet-discuss` at:

 ### Contributing

-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 to the project
+(see CONTRIBUTORS for more info!)

 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 2.1.0+ Team:

 * Bob Lantz
-* Brandon Heller
-* Nikhil Handigol
-* Vimal Jeyakumar
+* Brian O'Connor
@@ -22,14 +22,16 @@ 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, error
 from mininet.net import Mininet, MininetWithControlNet, VERSION
 from mininet.node import ( Host, CPULimitedHost, Controller, OVSController,
-                           NOX, RemoteController, UserSwitch, OVSKernelSwitch,
-                           OVSLegacyKernelSwitch )
+                           NOX, RemoteController, DefaultController,
+                           UserSwitch, OVSSwitch,
+                           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.topolib import TreeTopo, TorusTopo
 from mininet.util import custom, customConstructor
 from mininet.util import buildTopo

@@ -40,23 +42,29 @@ TOPOS = { 'minimal': lambda: SingleSwitchTopo( k=2 ),
          'linear': LinearTopo,
          'reversed': SingleSwitchReversedTopo,
          'single': SingleSwitchTopo,
-          'tree': TreeTopo }
+          'tree': TreeTopo,
+          'torus': TorusTopo }

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

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

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

 LINKDEF = 'default'
@@ -71,8 +79,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 ):
@@ -190,16 +197,21 @@ 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( '--nat', action='store_true',
+                         default=False, help="adds a NAT to the topology "
+                         "that connects Mininet to the physical network" )
        opts.add_option( '--version', action='callback', callback=version )

        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."

@@ -248,6 +260,10 @@ class MininetRunner( object ):
                  autoStaticArp=arp, autoPinCpus=pin,
                  listenPort=listenPort )

+        if self.options.nat:
+            nat = mn.addNAT()
+            nat.configDefault()
+
        if self.options.pre:
            CLI( mn, script=self.options.pre )

@@ -259,12 +275,14 @@ class MininetRunner( object ):
        if test == 'none':
            pass
        elif test == 'all':
+            mn.waitConnected()
            mn.start()
            mn.ping()
            mn.iperf()
        elif test == 'cli':
            CLI( mn )
        elif test != 'build':
+            mn.waitConnected()
            getattr( mn, test )()

        if self.options.post:
@@ -277,4 +295,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,129 @@
+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.
+
+#### 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`?"
+
+#### 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.
+
+#### 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
@@ -0,0 +1,4 @@
+"""
+Mininet Examples
+See README for details
+"""
@@ -2,6 +2,7 @@

 "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

@@ -27,6 +28,10 @@ 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 )

 print "*** You may now ssh into", h1.name, "at", h1.IP()
@@ -0,0 +1,72 @@
+#!/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, HostWithPrivateDirs
+from mininet.cli import CLI
+from mininet.topo import SingleSwitchTopo
+from mininet.log import setLogLevel, info, debug
+
+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( HostWithPrivateDirs,
+                    privateDirs=privateDirs )
+    net = Mininet( topo=topo, host=host )
+    net.start()
+    directories = []
+    for directory in privateDirs:
+        directories.append( directory[ 0 ]
+                            if isinstance( directory, tuple )
+                            else directory )
+    info( 'Private Directories:',  directories, '\n' )
+    CLI( net )
+    net.stop()
+
+if __name__ == '__main__':
+    setLogLevel( 'info' )
+    testHostWithPrivateDirs()
+    info( 'Done.\n')
+
+
@@ -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()
@@ -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 )

@@ -24,7 +24,7 @@ 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
@@ -76,7 +76,7 @@ def linearBandwidthTest( lengths ):
        print "*** testing", datapath, "datapath"
        Switch = switches[ datapath ]
        results[ datapath ] = []
-        net = Mininet( topo=topo, switch=Switch )
+        net = Mininet( topo=topo, switch=Switch, controller=Controller, waitConnected=True )
        net.start()
        print "*** testing basic connectivity"
        for n in lengths:
@@ -0,0 +1,136 @@
+#!/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.util import quietRun
+from mininet.log import output, warn
+
+from random import randint
+from re import findall
+
+
+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()
@@ -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,76 @@
+#!/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
+from mininet.node import Node
+
+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.
+
+    root = Node( 'root', inNamespace=False )
+    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 )
@@ -16,10 +16,12 @@ 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

@@ -28,29 +30,33 @@ def TreeNet( depth=1, fanout=2, **kwargs ):
    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
@@ -67,5 +73,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,29 @@
+#!/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
+
+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__':
+    # 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,62 @@
+#!/usr/bin/env python
+
+"""
+Tests for baresshd.py
+"""
+
+import unittest
+import pexpect
+from time import sleep
+from mininet.clean import cleanup, sh
+
+class testBareSSHD( unittest.TestCase ):
+
+    opts = [ '\(yes/no\)\?', 'Welcome to h1', 'refused', pexpect.EOF, pexpect.TIMEOUT ]
+
+    def connected( self ):
+        "Log into ssh server, check banner, then exit"
+        p = pexpect.spawn( 'ssh 10.0.0.1 -i /tmp/ssh/test_rsa exit' )
+        while True:
+            index = p.expect( self.opts )
+            if index == 0:
+                p.sendline( 'yes' )
+            elif index == 1:
+                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' )
+        sh( cmd )
+
+    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
+        for _ in range( 3 ):
+            result = self.connected()
+            if result:
+                break
+            else:
+                sleep( 1 )
+        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,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,38 @@
+#!/usr/bin/env python
+
+"""
+Test for cpu.py
+"""
+
+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' )
+        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 )
+                    previous_bw = 10 ** 4 # 10 GB/s
+                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,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,44 @@
+#!/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:
+                previous_bw = 10 ** 10 # 10 Gbits
+                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
+                self.assertTrue( bw < previous_bw )
+                previous_bw = bw
+            else:
+                break
+
+        self.assertTrue( count > 0 )
+
+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,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,53 @@
+#!/usr/bin/env python
+
+"""
+Test for simpleperf.py
+"""
+
+import unittest
+import pexpect
+import re
+import sys
+from mininet.log import setLogLevel
+from mininet.net import Mininet
+from mininet.node import CPULimitedHost
+from mininet.link import TCLink
+
+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 ping and iperf results"
+        p = pexpect.spawn( 'python -m mininet.examples.simpleperf' )
+        # check ping results
+        p.expect( "Results: (\d+)% dropped", timeout=120 )
+        loss = int( p.match.group( 1 ) )
+        self.assertTrue( 0 < loss < 100 )
+        # check iperf results
+        p.expect( "Results: \['([\d\.]+) .bits/sec", timeout=480 )
+        bw = float( p.match.group( 1 ) )
+        self.assertTrue( bw > 0 )
+        p.wait()
+
+    def testTopo( self ):
+        """Import SingleSwitchTopo from example and test connectivity between two hosts
+           Note: this test may fail very rarely because it is non-deterministic
+           i.e. links are configured with 10% packet loss, but if we get unlucky and 
+           none or all of the packets are dropped, the test will fail"""
+        topo = SingleSwitchTopo( n=4 )
+        net = Mininet( topo=topo, host=CPULimitedHost, link=TCLink )
+        net.start()
+        h1, h4 = net.get( 'h1', 'h4' )
+        # have h1 ping h4 ten times
+        expectStr = '(\d+) packets transmitted, (\d+) received, (\d+)% packet loss'
+        output = h1.cmd( 'ping -c 10 %s' % h4.IP() )
+        m = re.search( expectStr, output )
+        loss = int( m.group( 3 ) )
+        net.stop()
+        self.assertTrue( 0 < loss < 100 )
+
+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()
@@ -10,7 +10,8 @@ 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
@@ -27,34 +28,59 @@ 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" )
+    sh( 'pkill -9 -f mininet:' )
+    # Make sure they are gone
+    while True:
+        try:
+            pids = co( 'pgrep -f mininet:'.split() )
+        except:
+            pids = ''
+        if pids:
+            sh( 'pkill -f 9 mininet:' )
+            sleep( .5 )
+        else:
+            break
+
    info( "*** Cleanup complete.\n" )
@@ -31,9 +31,11 @@ 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.term import makeTerms, runX11
 from mininet.util import quietRun, isShellBuiltin, dumpNodeConnections

 class CLI( Cmd ):
@@ -43,13 +45,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 +54,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()
                if self.isatty():
-                    quietRun( 'stty sane' )
+                    quietRun( 'stty echo sane intr "^C"' )
                self.cmdloop()
                break
            except KeyboardInterrupt:
@@ -78,6 +87,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 +124,25 @@ 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_net( self, _line ):
        "List network connections."
-        dumpNodeConnections( self.nodelist )
+        dumpNodeConnections( self.mn.values() )

    def do_sh( self, line ):
        "Run an external shell command"
        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 +152,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 ):
@@ -165,18 +190,18 @@ 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."
        args = line.split()
        if not args:
            self.mn.iperf( l4Type='UDP' )
@@ -185,11 +210,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,13 +223,13 @@ 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 ):
@@ -224,12 +249,23 @@ class CLI( Cmd ):
            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."""
+        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)."
        self.do_xterm( line, term='gterm' )
@@ -275,10 +311,11 @@ 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."
        args = line.split()
        if len(args) < 1:
            error( 'usage: dpctl command [arg1] [arg2] ...\n' )
@@ -301,30 +338,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 +378,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 +390,12 @@ 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()

+
 # Helper functions

 def isReadable( poller ):
@@ -0,0 +1 @@
+../examples
@@ -25,8 +25,7 @@ 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 ):
@@ -162,8 +161,9 @@ class Intf( object ):
    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 __repr__( self ):
        return '<%s %s>' % ( self.__class__.__name__, self.name )
@@ -196,36 +196,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 +251,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 +279,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 +294,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 +311,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

@@ -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 ):
@@ -90,28 +90,31 @@ import os
 import re
 import select
 import signal
+import copy
 from time import sleep
+from itertools import chain, groupby

 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.1.0+"

 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,6 +150,7 @@ 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 = []
@@ -162,6 +166,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 +209,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 +243,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,6 +287,37 @@ 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() )
+
    def addLink( self, node1, node2, port1=None, port2=None,
                 cls=None, **params ):
        """"Add a link from node1 to node2
@@ -250,7 +340,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 )
@@ -275,14 +365,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:
                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():
@@ -313,7 +407,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 +419,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' )
@@ -356,26 +453,31 @@ class Mininet( object ):
            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()
+        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 +520,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

@@ -458,27 +560,39 @@ 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:
+            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 +632,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,7 +670,7 @@ 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 ):
        """Run iperf between two hosts.
           hosts: list of hosts; if None, uses opposite hosts
           l4Type: string, one of [ TCP, UDP ]
@@ -579,6 +693,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,7 +702,7 @@ 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 )
@@ -16,6 +16,11 @@ Host: a virtual host. By default, a host is simply a shell; commands
 CPULimitedHost: a virtual host whose CPU bandwidth is limited by
    RT or CFS bandwidth limiting.

+HostWithPrivateDirs: a virtual host that has user-specified private
+    directories. These may be temporary directories stored as a tmpfs,
+    or persistent directories that are mounted from another directory in
+    the root filesystem.
+
 Switch: superclass for switch nodes.

 UserSwitch: a switch using the user-space switch from the OpenFlow
@@ -45,16 +50,21 @@ Future enhancements:
 """

 import os
+import pty
 import re
 import signal
 import select
 from subprocess import Popen, PIPE, STDOUT
+from operator import or_
+from time import sleep

 from mininet.log import info, error, warn, debug
 from mininet.util import ( quietRun, errRun, errFail, moveIntf, isShellBuiltin,
                           numCores, retry, mountCgroups )
 from mininet.moduledeps import moduleDeps, pathCheck, OVS_KMOD, OF_KMOD, TUN
 from mininet.link import Link, Intf, TCIntf
+from re import findall
+from distutils.version import StrictVersion

 class Node( object ):
    """A virtual network node is simply a shell in a network namespace.
@@ -114,15 +124,22 @@ class Node( object ):
            return
        # mnexec: (c)lose descriptors, (d)etach from tty,
        # (p)rint pid, and run in (n)amespace
-        opts = '-cdp'
+        opts = '-cd'
        if self.inNamespace:
            opts += 'n'
-        # bash -m: enable job control
-        cmd = [ 'mnexec', opts, 'bash', '-m' ]
-        self.shell = Popen( cmd, stdin=PIPE, stdout=PIPE, stderr=STDOUT,
-                            close_fds=True )
-        self.stdin = self.shell.stdin
-        self.stdout = self.shell.stdout
+        # bash -m: enable job control, i: force interactive
+        # -s: pass $* to shell, and make process easy to find in ps
+        # prompt is set to sentinel chr( 127 )
+        os.environ[ 'PS1' ] = chr( 127 )
+        cmd = [ 'mnexec', opts, 'bash', '--norc', '-mis', 'mininet:' + self.name ]
+        # Spawn a shell subprocess in a pseudo-tty, to disable buffering
+        # in the subprocess and insulate it from signals (e.g. SIGINT)
+        # received by the parent
+        master, slave = pty.openpty()
+        self.shell = Popen( cmd, stdin=slave, stdout=slave, stderr=slave,
+                                  close_fds=False )
+        self.stdin = os.fdopen( master )
+        self.stdout = self.stdin
        self.pid = self.shell.pid
        self.pollOut = select.poll()
        self.pollOut.register( self.stdout )
@@ -135,14 +152,21 @@ class Node( object ):
        self.lastCmd = None
        self.lastPid = None
        self.readbuf = ''
+        # Wait for prompt
+        while True:
+            data = self.read( 1024 )
+            if data[ -1 ] == chr( 127 ):
+                break
+            self.pollOut.poll()
        self.waiting = False
+        self.cmd( 'stty -echo' )

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

    # Subshell I/O, commands and control
@@ -180,7 +204,8 @@ class Node( object ):

    def terminate( self ):
        "Send kill signal to Node and clean up after it."
-        os.kill( self.pid, signal.SIGKILL )
+        if self.shell:
+            os.killpg( self.pid, signal.SIGHUP )
        self.cleanup()

    def stop( self ):
@@ -213,36 +238,32 @@ class Node( object ):
            # Replace empty commands with something harmless
            cmd = 'echo -n'
        self.lastCmd = cmd
-        printPid = printPid and not isShellBuiltin( cmd )
-        if len( cmd ) > 0 and cmd[ -1 ] == '&':
-            # print ^A{pid}\n{sentinel}
-            cmd += ' printf "\\001%d\n\\177" $! \n'
-        else:
-            # print sentinel
-            cmd += '; printf "\\177"'
-            if printPid and not isShellBuiltin( cmd ):
+        if printPid and not isShellBuiltin( cmd ):
+            if len( cmd ) > 0 and cmd[ -1 ] == '&':
+                # print ^A{pid}\n so monitor() can set lastPid
+                cmd += ' printf "\\001%d\n" $! \n'
+            else:
                cmd = 'mnexec -p ' + cmd
        self.write( cmd + '\n' )
        self.lastPid = None
        self.waiting = True

-    def sendInt( self, sig=signal.SIGINT ):
+    def sendInt( self, intr=chr( 3 ) ):
        "Interrupt running command."
-        if self.lastPid:
-            try:
-                os.kill( self.lastPid, sig )
-            except OSError:
-                pass
+        self.write( intr )

-    def monitor( self, timeoutms=None ):
+    def monitor( self, timeoutms=None, findPid=True ):
        """Monitor and return the output of a command.
           Set self.waiting to False if command has completed.
           timeoutms: timeout in ms or None to wait indefinitely."""
        self.waitReadable( timeoutms )
        data = self.read( 1024 )
        # Look for PID
-        marker = chr( 1 ) + r'\d+\n'
-        if chr( 1 ) in data:
+        marker = chr( 1 ) + r'\d+\r\n'
+        if findPid and chr( 1 ) in data:
+            # Marker can be read in chunks; continue until all of it is read
+            while not re.findall( marker, data ):
+                data += self.read( 1024 )
            markers = re.findall( marker, data )
            if markers:
                self.lastPid = int( markers[ 0 ][ 1: ] )
@@ -290,7 +311,7 @@ class Node( object ):
           kwargs: Popen() keyword args"""
        defaults = { 'stdout': PIPE, 'stderr': PIPE,
                     'mncmd':
-                     [ 'mnexec', '-a', str( self.pid ) ] }
+                     [ 'mnexec', '-da', str( self.pid ) ] }
        defaults.update( kwargs )
        if len( args ) == 1:
            if type( args[ 0 ] ) is list:
@@ -370,7 +391,7 @@ class Node( object ):
        """
        if not intf:
            return self.defaultIntf()
-        elif type( intf) is str:
+        elif type( intf ) is str:
            return self.nameToIntf[ intf ]
        else:
            return intf
@@ -389,16 +410,19 @@ class Node( object ):
                    connections += [ ( intf, link.intf1 ) ]
        return connections

-    def deleteIntfs( self ):
-        "Delete all of our interfaces."
+    def deleteIntfs( self, checkName=True ):
+        """Delete all of our interfaces.
+           checkName: only delete interfaces that contain our name"""
        # In theory the interfaces should go away after we shut down.
        # However, this takes time, so we're better off removing them
        # explicitly so that we won't get errors if we run before they
        # have been removed by the kernel. Unfortunately this is very slow,
        # at least with Linux kernels before 2.6.33
        for intf in self.intfs.values():
-            intf.delete()
-            info( '.' )
+            # Protect against deleting hardware interfaces
+            if ( self.name in intf.name ) or ( not checkName ):
+                intf.delete()
+                info( '.' )

    # Routing support

@@ -417,11 +441,14 @@ class Node( object ):

    def setDefaultRoute( self, intf=None ):
        """Set the default route to go through intf.
-           intf: string, interface name"""
-        if not intf:
-            intf = self.defaultIntf()
-        self.cmd( 'ip route flush root 0/0' )
-        return self.cmd( 'route add default %s' % intf )
+           intf: Intf or {dev <intfname> via <gw-ip> ...}"""
+        # Note setParam won't call us if intf is none
+        if type( intf ) is str and ' ' in intf:
+            params = intf
+        else:
+            params = 'dev %s' % intf
+        self.cmd( 'ip route del default' )
+        return self.cmd( 'ip route add default', params )

    # Convenience and configuration methods

@@ -447,7 +474,7 @@ class Node( object ):

    def MAC( self, intf=None ):
        "Return MAC address of a node or specific interface."
-        return self.intf( intf ).IP()
+        return self.intf( intf ).MAC()

    def intfIsUp( self, intf=None ):
        "Check if an interface is up."
@@ -492,7 +519,7 @@ class Node( object ):
        r = {}
        self.setParam( r, 'setMAC', mac=mac )
        self.setParam( r, 'setIP', ip=ip )
-        self.setParam( r, 'defaultRoute', defaultRoute=defaultRoute )
+        self.setParam( r, 'setDefaultRoute', defaultRoute=defaultRoute )
        # This should be examined
        self.cmd( 'ifconfig lo ' + lo )
        return r
@@ -604,14 +631,15 @@ class CPULimitedHost( Host ):
           args: Popen() args, single list, or string
           kwargs: Popen() keyword args"""
        # Tell mnexec to execute command in our cgroup
-        mncmd = [ 'mnexec', '-a', str( self.pid ),
+        mncmd = [ 'mnexec', '-da', str( self.pid ),
                  '-g', self.name ]
        if self.sched == 'rt':
            mncmd += [ '-r', str( self.rtprio ) ]
        return Host.popen( self, *args, mncmd=mncmd, **kwargs )

    def cleanup( self ):
-        "Clean up our cgroup"
+        "Clean up Node, then clean up our cgroup"
+        super( CPULimitedHost, self ).cleanup()
        retry( retries=3, delaySecs=1, fn=self.cgroupDel )

    def chrt( self ):
@@ -712,6 +740,33 @@ class CPULimitedHost( Host ):
        mountCgroups()
        cls.inited = True

+class HostWithPrivateDirs( Host ):
+    "Host with private directories"
+
+    def __init__( self, name, *args, **kwargs ):
+        "privateDirs: list of private directory strings or tuples"
+        self.name = name
+        self.privateDirs = kwargs.pop( 'privateDirs', [] )
+        Host.__init__( self, name, *args, **kwargs )
+        self.mountPrivateDirs()
+
+    def mountPrivateDirs( self ):
+        "mount private directories"
+        for directory in self.privateDirs:
+            if isinstance( directory, tuple ):
+                # mount given private directory
+                privateDir = directory[ 1 ] % self.__dict__ 
+                mountPoint = directory[ 0 ]
+                self.cmd( 'mkdir -p %s' % privateDir )
+                self.cmd( 'mkdir -p %s' % mountPoint )
+                self.cmd( 'mount --bind %s %s' %
+                               ( privateDir, mountPoint ) )
+            else:
+                # mount temporary filesystem on directory
+                self.cmd( 'mkdir -p %s' % directory ) 
+                self.cmd( 'mount -n -t tmpfs tmpfs %s' % directory )
+
+

 # Some important things to note:
 #
@@ -741,27 +796,32 @@ class Switch( Node ):
    dpidLen = 16  # digits in dpid passed to switch

    def __init__( self, name, dpid=None, opts='', listenPort=None, **params):
-        """dpid: dpid for switch (or None to derive from name, e.g. s1 -> 1)
+        """dpid: dpid hex string (or None to derive from name, e.g. s1 -> 1)
           opts: additional switch options
           listenPort: port to listen on for dpctl connections"""
        Node.__init__( self, name, **params )
-        self.dpid = dpid if dpid else self.defaultDpid()
+        self.dpid = self.defaultDpid( dpid )
        self.opts = opts
        self.listenPort = listenPort
        if not self.inNamespace:
            self.controlIntf = Intf( 'lo', self, port=0 )

-    def defaultDpid( self ):
-        "Derive dpid from switch name, s1 -> 1"
-        try:
-            dpid = int( re.findall( '\d+', self.name )[ 0 ] )
-            dpid = hex( dpid )[ 2: ]
-            dpid = '0' * ( self.dpidLen - len( dpid ) ) + dpid
-            return dpid
-        except IndexError:
-            raise Exception( 'Unable to derive default datapath ID - '
-                             'please either specify a dpid or use a '
-                             'canonical switch name such as s23.' )
+    def defaultDpid( self, dpid=None ):
+        "Return correctly formatted dpid from dpid or switch name (s1 -> 1)"
+        if dpid:
+            # Remove any colons and make sure it's a good hex number
+            dpid = dpid.translate( None, ':' )
+            assert len( dpid ) <= self.dpidLen and int( dpid, 16 ) >= 0
+        else:
+            # Use hex of the first number in the switch name
+            nums = re.findall( r'\d+', self.name )
+            if nums:
+                dpid = hex( int( nums[ 0 ] ) )[ 2: ]
+            else:
+                raise Exception( 'Unable to derive default datapath ID - '
+                                 'please either specify a dpid or use a '
+                                 'canonical switch name such as s23.' )
+        return '0' * ( self.dpidLen - len( dpid ) ) + dpid

    def defaultIntf( self ):
        "Return control interface"
@@ -780,6 +840,10 @@ class Switch( Node ):
            error( '*** Error: %s has execed and cannot accept commands' %
                   self.name )

+    def connected( self ):
+        "Is the switch connected to a controller? (override this method)"
+        return False and self  # satisfy pylint
+
    def __repr__( self ):
        "More informative string representation"
        intfs = ( ','.join( [ '%s:%s' % ( i.name, i.IP() )
@@ -792,15 +856,19 @@ class UserSwitch( Switch ):

    dpidLen = 12

-    def __init__( self, name, **kwargs ):
+    def __init__( self, name, dpopts='--no-slicing', **kwargs ):
        """Init.
-           name: name for the switch"""
+           name: name for the switch
+           dpopts: additional arguments to ofdatapath (--no-slicing)"""
        Switch.__init__( self, name, **kwargs )
        pathCheck( 'ofdatapath', 'ofprotocol',
                   moduleName='the OpenFlow reference user switch' +
                              '(openflow.org)' )
        if self.listenPort:
            self.opts += ' --listen=ptcp:%i ' % self.listenPort
+        else:
+            self.opts += ' --listen=punix:/tmp/%s.listen' % self.name
+        self.dpopts = dpopts

    @classmethod
    def setup( cls ):
@@ -810,10 +878,42 @@ class UserSwitch( Switch ):

    def dpctl( self, *args ):
        "Run dpctl command"
+        listenAddr = None
        if not self.listenPort:
-            return "can't run dpctl without passive listening port"
+            listenAddr = 'unix:/tmp/%s.listen' % self.name
+        else:
+            listenAddr = 'tcp:127.0.0.1:%i' % self.listenPort
        return self.cmd( 'dpctl ' + ' '.join( args ) +
-                         ' tcp:127.0.0.1:%i' % self.listenPort )
+                         ' ' + listenAddr )
+
+    def connected( self ):
+        "Is the switch connected to a controller?"
+        return 'remote.is-connected=true' in self.dpctl( 'status' )
+
+    @staticmethod
+    def TCReapply( intf ):
+        """Unfortunately user switch and Mininet are fighting
+           over tc queuing disciplines. To resolve the conflict,
+           we re-create the user switch's configuration, but as a
+           leaf of the TCIntf-created configuration."""
+        if type( intf ) is TCIntf:
+            ifspeed = 10000000000 # 10 Gbps
+            minspeed = ifspeed * 0.001
+
+            res = intf.config( **intf.params )
+
+            if res is None: # link may not have TC parameters
+                return
+
+            # Re-add qdisc, root, and default classes user switch created, but
+            # with new parent, as setup by Mininet's TCIntf
+            parent = res['parent']
+            intf.tc( "%s qdisc add dev %s " + parent +
+                     " handle 1: htb default 0xfffe" )
+            intf.tc( "%s class add dev %s classid 1:0xffff parent 1: htb rate "
+                     + str(ifspeed) )
+            intf.tc( "%s class add dev %s classid 1:0xfffe parent 1:0xffff " +
+                     "htb rate " + str(minspeed) + " ceil " + str(ifspeed) )

    def start( self, controllers ):
        """Start OpenFlow reference user datapath.
@@ -827,12 +927,19 @@ class UserSwitch( Switch ):
        self.cmd( 'ifconfig lo up' )
        intfs = [ str( i ) for i in self.intfList() if not i.IP() ]
        self.cmd( 'ofdatapath -i ' + ','.join( intfs ) +
-                  ' punix:/tmp/' + self.name + ' -d ' + self.dpid +
+                  ' punix:/tmp/' + self.name + ' -d %s ' % self.dpid +
+                  self.dpopts +
                  ' 1> ' + ofdlog + ' 2> ' + ofdlog + ' &' )
        self.cmd( 'ofprotocol unix:/tmp/' + self.name +
                  ' ' + clist +
                  ' --fail=closed ' + self.opts +
                  ' 1> ' + ofplog + ' 2>' + ofplog + ' &' )
+        if "no-slicing" not in self.dpopts:
+            # Only TCReapply if slicing is enable
+            sleep(1) # Allow ofdatapath to start before re-arranging qdisc's
+            for intf in self.intfList():
+                if not intf.IP():
+                    self.TCReapply( intf )

    def stop( self ):
        "Stop OpenFlow reference user datapath."
@@ -895,12 +1002,18 @@ class OVSLegacyKernelSwitch( Switch ):
 class OVSSwitch( Switch ):
    "Open vSwitch switch. Depends on ovs-vsctl."

-    def __init__( self, name, failMode='secure', **params ):
+    def __init__( self, name, failMode='secure', datapath='kernel',
+                 inband=False, protocols=None, **params ):
        """Init.
           name: name for switch
-           failMode: controller loss behavior (secure|open)"""
+           failMode: controller loss behavior (secure|open)
+           datapath: userspace or kernel mode (kernel|user)
+           inband: use in-band control (False)"""
        Switch.__init__( self, name, **params )
        self.failMode = failMode
+        self.datapath = datapath
+        self.inband = inband
+        self.protocols = protocols

    @classmethod
    def setup( cls ):
@@ -921,10 +1034,24 @@ class OVSSwitch( Switch ):
                   'You may wish to try '
                   '"service openvswitch-switch start".\n' )
            exit( 1 )
+        info = quietRun( 'ovs-vsctl --version' )
+        cls.OVSVersion =  findall( '\d+\.\d+', info )[ 0 ]
+
+    @classmethod
+    def isOldOVS( cls ):
+        return ( StrictVersion( cls.OVSVersion ) <
+             StrictVersion( '1.10' ) )
+
+    @classmethod
+    def batchShutdown( cls, switches ):
+        "Call ovs-vsctl del-br on all OVSSwitches in a list"
+        quietRun( 'ovs-vsctl ' +
+                  ' -- '.join( '--if-exists del-br %s' % s
+                               for s in switches ) )

    def dpctl( self, *args ):
-        "Run ovs-dpctl command"
-        return self.cmd( 'ovs-dpctl', args[ 0 ], self, *args[ 1: ] )
+        "Run ovs-ofctl command"
+        return self.cmd( 'ovs-ofctl', args[ 0 ], self, *args[ 1: ] )

    @staticmethod
    def TCReapply( intf ):
@@ -944,6 +1071,23 @@ class OVSSwitch( Switch ):
        "Disconnect a data port"
        self.cmd( 'ovs-vsctl del-port', self, intf )

+    def controllerUUIDs( self ):
+        "Return ovsdb UUIDs for our controllers"
+        uuids = []
+        controllers = self.cmd( 'ovs-vsctl -- get Bridge', self,
+                               'Controller' ).strip()
+        if controllers.startswith( '[' ) and controllers.endswith( ']' ):
+            controllers = controllers[ 1 : -1 ]
+            uuids = [ c.strip() for c in controllers.split( ',' ) ]
+        return uuids
+
+    def connected( self ):
+        "Are we connected to at least one of our controllers?"
+        results = [ 'true' in self.cmd( 'ovs-vsctl -- get Controller',
+                                         uuid, 'is_connected' )
+                    for uuid in self.controllerUUIDs() ]
+        return reduce( or_, results, False )
+
    def start( self, controllers ):
        "Start up a new OVS OpenFlow switch using ovs-vsctl"
        if self.inNamespace:
@@ -954,40 +1098,146 @@ class OVSSwitch( Switch ):
        self.cmd( 'ifconfig lo up' )
        # Annoyingly, --if-exists option seems not to work
        self.cmd( 'ovs-vsctl del-br', self )
-        self.cmd( 'ovs-vsctl add-br', self )
-        self.cmd( 'ovs-vsctl -- set Bridge', self,
-                  'other_config:datapath-id=' + self.dpid )
-        self.cmd( 'ovs-vsctl set-fail-mode', self, self.failMode )
-        for intf in self.intfList():
-            if not intf.IP():
-                self.attach( intf )
-        # Add controllers
-        clist = ' '.join( [ 'tcp:%s:%d' % ( c.IP(), c.port )
-                            for c in controllers ] )
+        int( self.dpid, 16 ) # DPID must be a hex string
+        # Interfaces and controllers
+        intfs = ' '.join( '-- add-port %s %s ' % ( self, intf ) +
+                          '-- set Interface %s ' % intf +
+                          'ofport_request=%s ' % self.ports[ intf ]
+                         for intf in self.intfList() if not intf.IP() )
+        clist = ' '.join( '%s:%s:%d' % ( c.protocol, c.IP(), c.port )
+                         for c in controllers )
        if self.listenPort:
            clist += ' ptcp:%s' % self.listenPort
-        self.cmd( 'ovs-vsctl set-controller', self, clist )
+        # Construct big ovs-vsctl command for new versions of OVS
+        if not self.isOldOVS():
+            cmd = ( 'ovs-vsctl add-br %s ' % self +
+                    '-- set Bridge %s ' % self +
+                    'other_config:datapath-id=%s ' % self.dpid +
+                    '-- set-fail-mode %s %s ' % ( self, self.failMode ) +
+                    intfs +
+                    '-- set-controller %s %s ' % ( self, clist ) )
+        # Construct ovs-vsctl commands for old versions of OVS
+        else:
+            self.cmd( 'ovs-vsctl add-br', self )
+            for intf in self.intfList():
+                if not intf.IP():
+                    self.cmd( 'ovs-vsctl add-port', self, intf )
+            cmd = ( 'ovs-vsctl set Bridge %s ' % self +
+                    'other_config:datapath-id=%s ' % self.dpid +
+                    '-- set-fail-mode %s %s ' % ( self, self.failMode ) +
+                    '-- set-controller %s %s ' % ( self, clist ) )
+        if not self.inband:
+            cmd += ( '-- set bridge %s '
+                     'other-config:disable-in-band=true ' % self )
+        if self.datapath == 'user':
+            cmd += '-- set bridge %s datapath_type=netdev ' % self
+        if self.protocols:
+            cmd += '-- set bridge %s protocols=%s' % ( self, self.protocols )
+        # Reconnect quickly to controllers (1s vs. 15s max_backoff)
+        for uuid in self.controllerUUIDs():
+            if uuid.count( '-' ) != 4:
+                # Doesn't look like a UUID
+                continue
+            uuid = uuid.strip()
+            cmd += '-- set Controller %smax_backoff=1000 ' % uuid
+        # Do it!!
+        self.cmd( cmd )
+        for intf in self.intfList():
+            self.TCReapply( intf )
+

    def stop( self ):
        "Terminate OVS switch."
        self.cmd( 'ovs-vsctl del-br', self )
+        if self.datapath == 'user':
+            self.cmd( 'ip link del', self )
        self.deleteIntfs()

 OVSKernelSwitch = OVSSwitch


+class IVSSwitch(Switch):
+    """IVS virtual switch"""
+
+    def __init__( self, name, verbose=True, **kwargs ):
+        Switch.__init__( self, name, **kwargs )
+        self.verbose = verbose
+
+    @classmethod
+    def setup( cls ):
+        "Make sure IVS is installed"
+        pathCheck( 'ivs-ctl', 'ivs',
+                   moduleName="Indigo Virtual Switch (projectfloodlight.org)" )
+        out, err, exitcode = errRun( 'ivs-ctl show' )
+        if exitcode:
+            error( out + err +
+                   'ivs-ctl exited with code %d\n' % exitcode +
+                   '*** The openvswitch kernel module might '
+                   'not be loaded. Try modprobe openvswitch.\n' )
+            exit( 1 )
+
+    @classmethod
+    def batchShutdown( cls, switches ):
+        "Kill each IVS switch, to be waited on later in stop()"
+        for switch in switches:
+            switch.cmd( 'kill %ivs' )
+
+    def start( self, controllers ):
+        "Start up a new IVS switch"
+        args = ['ivs']
+        args.extend( ['--name', self.name] )
+        args.extend( ['--dpid', self.dpid] )
+        if self.verbose:
+            args.extend( ['--verbose'] )
+        for intf in self.intfs.values():
+            if not intf.IP():
+                args.extend( ['-i', intf.name] )
+        for c in controllers:
+            args.extend( ['-c', '%s:%d' % (c.IP(), c.port)] )
+        if self.listenPort:
+            args.extend( ['--listen', '127.0.0.1:%i' % self.listenPort] )
+        args.append( self.opts )
+
+        logfile = '/tmp/ivs.%s.log' % self.name
+
+        self.cmd( 'ifconfig lo up' )
+        self.cmd( ' '.join(args) + ' >' + logfile + ' 2>&1 </dev/null &' )
+
+    def stop( self ):
+        "Terminate IVS switch."
+        self.cmd( 'kill %ivs' )
+        self.cmd( 'wait' )
+        self.deleteIntfs()
+
+    def attach( self, intf ):
+        "Connect a data port"
+        self.cmd( 'ivs-ctl', 'add-port', '--datapath', self.name, intf )
+
+    def detach( self, intf ):
+        "Disconnect a data port"
+        self.cmd( 'ivs-ctl', 'del-port', '--datapath', self.name, intf )
+
+    def dpctl( self, *args ):
+        "Run dpctl command"
+        if not self.listenPort:
+            return "can't run dpctl without passive listening port"
+        return self.cmd( 'ovs-ofctl ' + ' '.join( args ) +
+                         ' tcp:127.0.0.1:%i' % self.listenPort )
+
+
 class Controller( Node ):
    """A Controller is a Node that is running (or has execed?) an
       OpenFlow controller."""

    def __init__( self, name, inNamespace=False, command='controller',
                  cargs='-v ptcp:%d', cdir=None, ip="127.0.0.1",
-                  port=6633, **params ):
+                  port=6633, protocol='tcp', **params ):
        self.command = command
        self.cargs = cargs
        self.cdir = cdir
        self.ip = ip
        self.port = port
+        self.protocol = protocol
        Node.__init__( self, name, inNamespace=inNamespace,
                       ip=ip, **params  )
        self.cmd( 'ifconfig lo up' )  # Shouldn't be necessary
@@ -1003,8 +1253,8 @@ class Controller( Node ):
                             "installed." )
        listening = self.cmd( "echo A | telnet -e A %s %d" %
                              ( self.ip, self.port ) )
-        if 'Unable' not in listening:
-            servers = self.cmd( 'netstat -atp' ).split( '\n' )
+        if 'Connected' in listening:
+            servers = self.cmd( 'netstat -natp' ).split( '\n' )
            pstr = ':%d ' % self.port
            clist = servers[ 0:1 ] + [ s for s in servers if pstr in s ]
            raise Exception( "Please shut down the controller which is"
@@ -1040,13 +1290,19 @@ class Controller( Node ):
        return '<%s %s: %s:%s pid=%s> ' % (
            self.__class__.__name__, self.name,
            self.IP(), self.port, self.pid )
-
+    @classmethod
+    def isAvailable( self ):
+        return quietRun( 'which controller' )

 class OVSController( Controller ):
    "Open vSwitch controller"
    def __init__( self, name, command='ovs-controller', **kwargs ):
+        if quietRun( 'which test-controller' ):
+            command = 'test-controller'
        Controller.__init__( self, name, command=command, **kwargs )
-
+    @classmethod
+    def isAvailable( self ):
+        return quietRun( 'which ovs-controller' ) or quietRun( 'which test-controller' )

 class NOX( Controller ):
    "Controller to run a NOX application."
@@ -1098,6 +1354,12 @@ class RemoteController( Controller ):
        "Warn if remote controller is not accessible"
        listening = self.cmd( "echo A | telnet -e A %s %d" %
                              ( self.ip, self.port ) )
-        if 'Unable' in listening:
+        if 'Connected' not in listening:
            warn( "Unable to contact the remote controller"
                  " at %s:%d\n" % ( self.ip, self.port ) )
+
+def DefaultController( name, order=[ Controller, OVSController ], **kwargs ):
+    "find any controller that is available and run it"
+    for controller in order:
+        if controller.isAvailable():
+            return controller( name, **kwargs )
@@ -0,0 +1,115 @@
+"""
+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 setLogLevel, info
+
+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 ):
+        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 ):
+        self.cmd( 'ifconfig', self, 'down' )
+        self.cmd( 'brctl delbr', self )
+
+class NAT( Node ):
+    """NAT: Provides connectivity to external network"""
+
+    def __init__( self, name, inetIntf='eth0', 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
+        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, '-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 )
+            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 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"""
+       returns: two Popen objects, tunnel and terminal"""
    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,15 +31,21 @@ 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)."""
+
+    switchClass = None # overridden in subclasses

    def runOptionsTopoTest( self, n, 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 )
        dropped = mn.run( mn.ping )
        self.assertEqual( dropped, 0 )

@@ -47,8 +53,11 @@ class testOptionsTopo( unittest.TestCase ):
        """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 )
+        self.assertGreaterEqual( float(measured),
+                                 float(expected) * tolerance_frac )
+        self.assertLessEqual( float( measured ),
+                                 float(expected) + (1-tolerance_frac)
+                                 * float( expected ) )

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

        mn = Mininet( SingleSwitchOptionsTopo( n=N, hopts=hopts ),
-                      host=CPULimitedHost )
+                      host=CPULimitedHost, switch=self.switchClass )
        mn.start()
        results = mn.runCpuLimitTest( cpu=CPU_FRACTION )
        mn.stop()
-        for cpu in results:
-            self.assertWithinTolerance( cpu, CPU_FRACTION, CPU_TOLERANCE )
+        for pct in results:
+            #divide cpu by 100 to convert from percentage to fraction
+            self.assertWithinTolerance( pct/100, CPU_FRACTION, CPU_TOLERANCE )

    def testLinkBandwidth( self ):
        "Verify that link bandwidths are accurate within a bound."
-        BW = 5  # Mbps
+        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 )
+                      link=TCLink, switch=self.switchClass )
+        bw_strs = mn.run( mn.iperf, format='m' )
        for bw_str in bw_strs:
            bw = float( bw_str.split(' ')[0] )
            self.assertWithinTolerance( bw, BW, BW_TOLERANCE )
@@ -85,7 +95,7 @@ class testOptionsTopo( unittest.TestCase ):
        DELAY_TOLERANCE = 0.8  # Delay fraction below which test should fail
        lopts = { 'delay': '%sms' % DELAY_MS, 'use_htb': True }
        mn = Mininet( SingleSwitchOptionsTopo( n=N, lopts=lopts ),
-                      link=TCLink )
+                      link=TCLink, switch=self.switchClass, autoStaticArp=True )
        ping_delays = mn.run( mn.pingFull )
        test_outputs = ping_delays[0]
        # Ignore unused variables below
@@ -96,16 +106,18 @@ class testOptionsTopo( unittest.TestCase ):
        # pylint: enable-msg=W0612
        for rttval in [rttmin, rttavg, rttmax]:
            # Multiply delay by 4 to cover there & back on two links
-            self.assertWithinTolerance( rttval, DELAY_MS * 4.0,
+            self.assertWithinTolerance( rttval, DELAY_MS * 4.0, 
                                        DELAY_TOLERANCE)

+
    def testLinkLoss( self ):
        "Verify that we see packet drops with a high configured loss rate."
        LOSS_PERCENT = 99
        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 )
        # 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,7 +125,7 @@ class testOptionsTopo( unittest.TestCase ):
        for _ in range(REPS):
            dropped_total += mn.ping(timeout='1')
        mn.stop()
-        self.assertTrue(dropped_total > 0)
+        self.assertGreater( dropped_total, 0 )

    def testMostOptions( self ):
        "Verify topology creation with most link options and CPU limits."
@@ -121,6 +133,29 @@ class testOptionsTopo( unittest.TestCase ):
        hopts = { 'cpu': 0.5 / N }
        self.runOptionsTopoTest( N, 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)."""
+    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)."""
+    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)."
+    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)."
+    switchClass = UserSwitch

 if __name__ == '__main__':
    setLogLevel( 'warning' )
@@ -4,45 +4,93 @@
   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 )
+        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 )
+        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,331 @@
+#!/usr/bin/env python
+
+"""
+Tests for the Mininet Walkthrough
+
+TODO: missing xterm test
+"""
+
+import unittest
+import pexpect
+import os
+from mininet.util import quietRun
+
+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"
+        tshark = pexpect.spawn( 'tshark -i lo -R of' )
+        tshark.expect( 'Capturing on lo' )
+        mn = pexpect.spawn( 'mn --test pingall' )
+        mn.expect( '0% dropped' )
+        tshark.expect( 'OFP 74 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' )
+        p.expect( self.prompt )
+        h1Output = p.before
+        # s1 ps
+        p.sendline( 's1 ps -a' )
+        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 ) > 100, "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()
@@ -11,28 +11,62 @@ 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 MultiGraph( object ):
+    "Utility class to track nodes and edges - replaces networkx.Graph"
+
+    def __init__( self ):
+        self.data = {}
+
+    def add_node( self, node ):
+        "Add node to graph"
+        self.data.setdefault( node, [] )
+
+    def add_edge( self, src, dest ):
+        "Add edge to graph"
+        src, dest = sorted( ( src, dest ) )
+        self.add_node( src )
+        self.add_node( dest )
+        self.data[ src ].append( dest )
+
+    def nodes( self ):
+        "Return list of graph nodes"
+        return self.data.keys()
+
+    def edges( self ):
+        "Iterator: return graph edges"
+        for src in self.data.keys():
+            for dest in self.data[ src ]:
+                yield ( src, dest )
+
+    def __getitem__( self, node ):
+        "Return link dict for the given node"
+        return self.data[node]
+
+
 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()
+           lopts: default link options
+           calls build()"""
+        self.g = MultiGraph()
        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.hopts = params.pop( 'hopts', {} )
+        self.sopts = params.pop( 'sopts', {} )
+        self.lopts = params.pop( 'lopts', {} )
        self.ports = {}  # ports[src][dst] is port on src that connects to dst
+        self.build( *args, **params )
+
+    def build( self, *args, **params ):
+        "Override this method to build your topology."
+        pass

    def addNode(self, name, **opts):
        """Add Node to graph.
@@ -141,7 +175,7 @@ class Topo(object):
        '''
        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])
+            return self.ports[src][dst], self.ports[dst][src]

    def linkInfo( self, src, dst ):
        "Return link metadata"
@@ -167,64 +201,56 @@ class Topo(object):
        "Items sorted in natural (i.e. alphabetical) order"
        return sorted(items, key=natural)

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

-    def __init__(self, k=2, **opts):
-        '''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,10 +1,10 @@
 "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
@@ -155,7 +155,12 @@ def makeIntfPair( intf1, intf2 ):
    quietRun( 'ip link del ' + intf2 )
    # Create new pair
    cmd = 'ip link add name ' + intf1 + ' type veth peer name ' + intf2
-    return quietRun( cmd )
+    cmdOutput = quietRun( 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 +176,34 @@ 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, srcNode=None, 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
+        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, dstNode.pid )
+    if srcNode:
+        srcNode.cmd( cmd )
+    else:
+        quietRun( cmd )
+    if ( ' %s:' % intf ) not in dstNode.cmd( 'ip link show', intf ):
        if printError:
            error( '*** Error: moveIntf: ' + intf +
-                   ' not successfully moved to ' + node.name + '\n' )
+                   ' not successfully moved to ' + dstNode.name + '\n' )
        return False
    return True

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

 # Support for dumping network

@@ -242,9 +254,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 +272,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 +292,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 +343,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 type( limit ) is 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 )

@@ -419,7 +478,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

@@ -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,8 +21,9 @@
 #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)"
@@ -34,9 +36,9 @@ void usage(char *name)
           "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,7 +94,7 @@ int cgroup(char *gname)

 int main(int argc, char *argv[])
 {
-    char c;
+    int c;
    int fd;
    char path[PATH_MAX];
    int nsid;
@@ -112,20 +114,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 +140,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 +152,17 @@ 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 into pid's root file system */
+                sprintf(path, "/proc/%d/root", pid);
+                if (chroot(path) < 0) {
+                    perror(path);
+                    return 1;
+                }
+            }
            break;
        case 'g':
            /* Attach to cgroup */
@@ -176,4 +194,6 @@ int main(int argc, char *argv[])
    }
    
    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,
 )
@@ -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,19 +63,11 @@ 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

@@ -72,39 +83,19 @@ 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})
+
+# Command-line versions overrides that simplify custom VM creation
+# To use, pass in the vars on the cmd line before install.sh, e.g.
+# WS_DISSECTOR_REV=pre-ws-1.10.0 install.sh -w
+WS_DISSECTOR_REV=${WS_DISSECTOR_REV:-""}
+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 +107,250 @@ 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
+}
+
 # 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
+    cd $BUILD_DIR
+}

-    # Remove avahi-daemon, which may cause unwanted discovery packets to be
-    # sent during tests, near link status changes:
-    $remove avahi-daemon
+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

-    # Disable IPv6.  Add to /etc/modprobe.d/blacklist:
-    if [ "$DIST" = "Ubuntu" ]; then
-        BLACKLIST=/etc/modprobe.d/blacklist.conf
-    else
-        BLACKLIST=/etc/modprobe.d/blacklist
+    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
+
+    # 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 wireshark_version_check {
+    # Check Wireshark version
+    WS=$(which wireshark)
+    WS_VER_PATCH=(1 10) # targetting wireshark 1.10.0
+    WS_VER=($($WS --version | sed 's/[a-z ]*\([0-9]*\).\([0-9]*\).\([0-9]*\).*/\1 \2 \3/'))
+    if [ "${WS_VER[0]}" -lt "${WS_VER_PATCH[0]}" ] ||
+       [[ "${WS_VER[0]}" -le "${WS_VER_PATCH[0]}" && "${WS_VER[1]}" -lt "${WS_VER_PATCH[1]}" ]]
+    then
+        # pre-1.10.0 wireshark
+        echo "Setting revision: pre-ws-1.10.0"
+        WS_DISSECTOR_REV="pre-ws-1.10.0" 
    fi
-    sudo sh -c "echo 'blacklist net-pf-10\nblacklist ipv6' >> $BLACKLIST"
-    cd ~
 }

 function wireshark {
    echo "Installing Wireshark dissector..."

-    sudo apt-get install -y wireshark libgtk2.0-dev
+    if [ "$DIST" = "Fedora" ]; then
+        # Just install Fedora's wireshark RPMS
+        # Fedora's wirehark >= 1.10.2-2 includes an OF dissector
+        # (it has been backported from the future Wireshark 1.12 code base)
+        $install wireshark wireshark-gnome
+        return
+    fi
+
+    $install wireshark tshark libgtk2.0-dev

    if [ "$DIST" = "Ubuntu" ] && [ "$RELEASE" != "10.04" ]; then
        # Install newer version
-        sudo apt-get install -y scons mercurial libglib2.0-dev
-        sudo apt-get install -y libwiretap-dev libwireshark-dev
-        cd ~
+        $install scons mercurial libglib2.0-dev
+        $install libwiretap-dev libwireshark-dev
+        cd $BUILD_DIR
        hg clone https://bitbucket.org/barnstorm/of-dissector
-        cd of-dissector/src
+        if [[ -z "$WS_DISSECTOR_REV" ]]; then
+            wireshark_version_check
+        fi
+        cd of-dissector
+        if [[ -n "$WS_DISSECTOR_REV" ]]; then
+            hg checkout ${WS_DISSECTOR_REV}
+        fi
+        # Build dissector
+        cd src
        export WIRESHARK=/usr/include/wireshark
        scons
        # libwireshark0/ on 11.04; libwireshark1/ on later
-        WSDIR=`ls -d /usr/lib/wireshark/libwireshark* | head -1`
+        WSDIR=`find /usr/lib -type d -name '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
+        cd $BUILD_DIR/openflow/utilities/wireshark_dissectors/openflow
        make
        sudo make install
    fi

    # Copy coloring rules: OF is white-on-blue:
-    mkdir -p ~/.wireshark
-    cp ~/mininet/util/colorfilters ~/.wireshark
+    mkdir -p $HOME/.wireshark
+    cp $MININET_DIR/mininet/util/colorfilters $HOME/.wireshark
+}
+
+
+# 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" ] && [ `expr $RELEASE '>=' 12.04` = 1 ]; 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
-
-    $install pkg-config gcc make python-dev libssl-dev libtool
-
-    if [ "$DIST" = "Debian" ]; then
-        if [ "$CODENAME" = "lenny" ]; then
-            $install git-core
-            # Install Autoconf 2.63+ backport from Debian Backports repo:
-            # Instructions from http://backports.org/dokuwiki/doku.php?id=instructions
-            sudo su -c "echo 'deb http://www.backports.org/debian lenny-backports main contrib non-free' >> /etc/apt/sources.list"
-            sudo apt-get update
-            sudo apt-get -y --force-yes install debian-backports-keyring
-            sudo apt-get -y --force-yes -t lenny-backports install autoconf
-        fi
-    else
-        $install git
+    # 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 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
+    $install openvswitch-switch openvswitch-controller

-    modprobe
+    # 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
 }

 function remove_ovs {
@@ -330,6 +374,22 @@ 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 NOX with tutorial files
 function nox {
    echo "Installing NOX w/tutorial files..."
@@ -348,7 +408,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 +417,9 @@ function nox {

    # Apply patches
    git checkout -b tutorial-destiny
-    git am ~/mininet/util/nox-patches/*tutorial-port-nox-destiny*.patch
+    git am $MININET_DIR/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/*nox-ubuntu12-hacks.patch
    fi

    # Build
@@ -371,17 +431,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 +487,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
@@ -454,25 +580,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
    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 +622,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 +643,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 [-abcdfhikmnprtvVwx03]\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 +665,67 @@ 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 -- ' -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:wx03' 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;;
+      V)    OVS_RELEASE=$OPTARG;
+            ubuntuOvs;;
      w)    wireshark;;
-      x)    nox;;
+      x)    case $OF_VERSION in
+            1.0) nox;;
+            1.3) nox13;;
+            *)  echo "Invalid OpenFlow version $OF_VERSION";;
+            esac;;
+      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 | 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 -a $pid $cg $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( "grep -or 'Mininet \w\+\.\w\+\.\w\+[+]*' *", shell=True )

 error = False

@@ -0,0 +1,972 @@
+#!/usr/bin/python
+
+"""
+build.py: build a Mininet VM
+
+Basic idea:
+
+    prepare
+    -> create base install image if it's missing
+        - download iso if it's missing
+        - install from iso onto image
+
+    build
+    -> create cow disk for new VM, based on base image
+    -> boot it in qemu/kvm with text /serial console
+    -> install Mininet
+
+    test
+    -> sudo mn --test pingall
+    -> make test
+
+    release
+    -> shut down VM
+    -> shrink-wrap VM
+    -> upload to storage
+
+"""
+
+import os
+from os import stat, path
+from stat import ST_MODE, ST_SIZE
+from os.path import abspath
+from sys import exit, stdout, argv, modules
+import re
+from glob import glob
+from subprocess import check_output, call, Popen
+from tempfile import mkdtemp, NamedTemporaryFile
+from time import time, strftime, localtime
+import argparse
+from distutils.spawn import find_executable
+import inspect
+
+pexpect = None  # For code check - imported dynamically
+
+# boot can be slooooow!!!! need to debug/optimize somehow
+TIMEOUT=600
+
+# Some configuration options
+# Possibly change this to use the parsed arguments instead!
+
+LogToConsole = False        # VM output to console rather than log file
+SaveQCOW2 = False           # Save QCOW2 image rather than deleting it
+NoKVM = False               # Don't use kvm and use emulation instead
+Branch = None               # Branch to update and check out before testing
+Zip = False                  # Archive .ovf and .vmdk into a .zip file
+
+VMImageDir = os.environ[ 'HOME' ] + '/vm-images'
+
+Prompt = '\$ '              # Shell prompt that pexpect will wait for
+
+isoURLs = {
+    'precise32server':
+    'http://mirrors.kernel.org/ubuntu-releases/12.04/'
+    'ubuntu-12.04.5-server-i386.iso',
+    'precise64server':
+    'http://mirrors.kernel.org/ubuntu-releases/12.04/'
+    'ubuntu-12.04.5-server-amd64.iso',
+    'quantal32server':
+    'http://mirrors.kernel.org/ubuntu-releases/12.10/'
+    'ubuntu-12.10-server-i386.iso',
+    'quantal64server':
+    'http://mirrors.kernel.org/ubuntu-releases/12.10/'
+    'ubuntu-12.10-server-amd64.iso',
+    'raring32server':
+    'http://mirrors.kernel.org/ubuntu-releases/13.04/'
+    'ubuntu-13.04-server-i386.iso',
+    'raring64server':
+    'http://mirrors.kernel.org/ubuntu-releases/13.04/'
+    'ubuntu-13.04-server-amd64.iso',
+    'saucy32server':
+    'http://mirrors.kernel.org/ubuntu-releases/13.10/'
+    'ubuntu-13.10-server-i386.iso',
+    'saucy64server':
+    'http://mirrors.kernel.org/ubuntu-releases/13.10/'
+    'ubuntu-13.10-server-amd64.iso',
+    'trusty32server':
+    'http://mirrors.kernel.org/ubuntu-releases/14.04/'
+    'ubuntu-14.04-server-i386.iso',
+    'trusty64server':
+    'http://mirrors.kernel.org/ubuntu-releases/14.04/'
+    'ubuntu-14.04-server-amd64.iso',
+    'utopic32server':
+    'http://mirrors.kernel.org/ubuntu-releases/14.10/'
+    'ubuntu-14.10-server-i386.iso',
+    'utopic64server':
+    'http://mirrors.kernel.org/ubuntu-releases/14.10/'
+    'ubuntu-14.10-server-amd64.iso',
+}
+
+
+def OSVersion( flavor ):
+    "Return full OS version string for build flavor"
+    urlbase = path.basename( isoURLs.get( flavor, 'unknown' ) )
+    return path.splitext( urlbase )[ 0 ]
+
+def OVFOSNameID( flavor ):
+    "Return OVF-specified ( OS Name, ID ) for flavor"
+    version = OSVersion( flavor )
+    arch = archFor( flavor )
+    if 'ubuntu' in version:
+        map = { 'i386': ( 'Ubuntu', 93 ),
+                'x86_64': ( 'Ubuntu 64-bit', 94 ) }
+    else:
+        map = { 'i386': ( 'Linux', 36 ),
+                'x86_64': ( 'Linux 64-bit', 101 ) }
+    osname, osid = map[ arch ]
+    return osname, osid
+
+LogStartTime = time()
+LogFile = None
+
+def log( *args, **kwargs ):
+    """Simple log function: log( message along with local and elapsed time
+       cr: False/0 for no CR"""
+    cr = kwargs.get( 'cr', True )
+    elapsed = time() - LogStartTime
+    clocktime = strftime( '%H:%M:%S', localtime() )
+    msg = ' '.join( str( arg ) for arg in args )
+    output = '%s [ %.3f ] %s' % ( clocktime, elapsed, msg )
+    if cr:
+        print output
+    else:
+        print output,
+    # Optionally mirror to LogFile
+    if type( LogFile ) is file:
+        if cr:
+            output += '\n'
+        LogFile.write( output )
+        LogFile.flush()
+
+
+def run( cmd, **kwargs ):
+    "Convenient interface to check_output"
+    log( '-', cmd )
+    cmd = cmd.split()
+    arg0 = cmd[ 0 ]
+    if not find_executable( arg0 ):
+        raise Exception( 'Cannot find executable "%s";' % arg0 +
+                         'you might try %s --depend' % argv[ 0 ] )
+    return check_output( cmd, **kwargs )
+
+
+def srun( cmd, **kwargs ):
+    "Run + sudo"
+    return run( 'sudo ' + cmd, **kwargs )
+
+
+# BL: we should probably have a "checkDepend()" which
+# checks to make sure all dependencies are satisfied!
+
+def depend():
+    "Install package dependencies"
+    log( '* Installing package dependencies' )
+    run( 'sudo apt-get -y update' )
+    run( 'sudo apt-get install -y'
+         ' kvm cloud-utils genisoimage qemu-kvm qemu-utils'
+         ' e2fsprogs dnsmasq curl'
+         ' python-setuptools mtools zip' )
+    run( 'sudo easy_install pexpect' )
+
+
+def popen( cmd ):
+    "Convenient interface to popen"
+    log( cmd )
+    cmd = cmd.split()
+    return Popen( cmd )
+
+
+def remove( fname ):
+    "Remove a file, ignoring errors"
+    try:
+        os.remove( fname )
+    except OSError:
+        pass
+
+
+def findiso( flavor ):
+    "Find iso, fetching it if it's not there already"
+    url = isoURLs[ flavor ]
+    name = path.basename( url )
+    iso = path.join( VMImageDir, name )
+    if not path.exists( iso ) or ( stat( iso )[ ST_MODE ] & 0777 != 0444 ):
+        log( '* Retrieving', url )
+        run( 'curl -C - -o %s %s' % ( iso, url ) )
+        if 'ISO' not in run( 'file ' + iso ):
+            os.remove( iso )
+            raise Exception( 'findiso: could not download iso from ' + url )
+        # Write-protect iso, signaling it is complete
+        log( '* Write-protecting iso', iso)
+        os.chmod( iso, 0444 )
+    log( '* Using iso', iso )
+    return iso
+
+
+def attachNBD( cow, flags='' ):
+    """Attempt to attach a COW disk image and return its nbd device
+        flags: additional flags for qemu-nbd (e.g. -r for readonly)"""
+    # qemu-nbd requires an absolute path
+    cow = abspath( cow )
+    log( '* Checking for unused /dev/nbdX device ' )
+    for i in range ( 0, 63 ):
+        nbd = '/dev/nbd%d' % i
+        # Check whether someone's already messing with that device
+        if call( [ 'pgrep', '-f', nbd ] ) == 0:
+            continue
+        srun( 'modprobe nbd max-part=64' )
+        srun( 'qemu-nbd %s -c %s %s' % ( flags, nbd, cow ) )
+        print
+        return nbd
+    raise Exception( "Error: could not find unused /dev/nbdX device" )
+
+
+def detachNBD( nbd ):
+    "Detatch an nbd device"
+    srun( 'qemu-nbd -d ' + nbd )
+
+
+def extractKernel( image, flavor, imageDir=VMImageDir ):
+    "Extract kernel and initrd from base image"
+    kernel = path.join( imageDir, flavor + '-vmlinuz' )
+    initrd = path.join( imageDir, flavor + '-initrd' )
+    if path.exists( kernel ) and ( stat( image )[ ST_MODE ] & 0777 ) == 0444:
+        # If kernel is there, then initrd should also be there
+        return kernel, initrd
+    log( '* Extracting kernel to', kernel )
+    nbd = attachNBD( image, flags='-r' )
+    print srun( 'partx ' + nbd )
+    # Assume kernel is in partition 1/boot/vmlinuz*generic for now
+    part = nbd + 'p1'
+    mnt = mkdtemp()
+    srun( 'mount -o ro,noload %s %s' % ( part, mnt  ) )
+    kernsrc = glob( '%s/boot/vmlinuz*generic' % mnt )[ 0 ]
+    initrdsrc = glob( '%s/boot/initrd*generic' % mnt )[ 0 ]
+    srun( 'cp %s %s' % ( initrdsrc, initrd ) )
+    srun( 'chmod 0444 ' + initrd )
+    srun( 'cp %s %s' % ( kernsrc, kernel ) )
+    srun( 'chmod 0444 ' + kernel )
+    srun( 'umount ' + mnt )
+    run( 'rmdir ' + mnt )
+    detachNBD( nbd )
+    return kernel, initrd
+
+
+def findBaseImage( flavor, size='8G' ):
+    "Return base VM image and kernel, creating them if needed"
+    image = path.join( VMImageDir, flavor + '-base.qcow2' )
+    if path.exists( image ):
+        # Detect race condition with multiple builds
+        perms = stat( image )[ ST_MODE ] & 0777
+        if perms != 0444:
+            raise Exception( 'Error - %s is writable ' % image +
+                            '; are multiple builds running?' )
+    else:
+        # We create VMImageDir here since we are called first
+        run( 'mkdir -p %s' % VMImageDir )
+        iso = findiso( flavor )
+        log( '* Creating image file', image )
+        run( 'qemu-img create -f qcow2 %s %s' % ( image, size ) )
+        installUbuntu( iso, image )
+        # Write-protect image, also signaling it is complete
+        log( '* Write-protecting image', image)
+        os.chmod( image, 0444 )
+    kernel, initrd = extractKernel( image, flavor )
+    log( '* Using base image', image, 'and kernel', kernel )
+    return image, kernel, initrd
+
+
+# Kickstart and Preseed files for Ubuntu/Debian installer
+#
+# Comments: this is really clunky and painful. If Ubuntu
+# gets their act together and supports kickstart a bit better
+# then we can get rid of preseed and even use this as a
+# Fedora installer as well.
+#
+# Another annoying thing about Ubuntu is that it can't just
+# install a normal system from the iso - it has to download
+# junk from the internet, making this house of cards even
+# more precarious.
+
+KickstartText ="""
+#Generated by Kickstart Configurator
+#platform=x86
+
+#System language
+lang en_US
+#Language modules to install
+langsupport en_US
+#System keyboard
+keyboard us
+#System mouse
+mouse
+#System timezone
+timezone America/Los_Angeles
+#Root password
+rootpw --disabled
+#Initial user
+user mininet --fullname "mininet" --password "mininet"
+#Use text mode install
+text
+#Install OS instead of upgrade
+install
+#Use CDROM installation media
+cdrom
+#System bootloader configuration
+bootloader --location=mbr
+#Clear the Master Boot Record
+zerombr yes
+#Partition clearing information
+clearpart --all --initlabel
+#Automatic partitioning
+autopart
+#System authorization infomation
+auth  --useshadow  --enablemd5
+#Firewall configuration
+firewall --disabled
+#Do not configure the X Window System
+skipx
+"""
+
+# Tell the Ubuntu/Debian installer to stop asking stupid questions
+
+PreseedText = """
+d-i mirror/country string manual
+d-i mirror/http/hostname string mirrors.kernel.org
+d-i mirror/http/directory string /ubuntu
+d-i mirror/http/proxy string
+d-i partman/confirm_write_new_label boolean true
+d-i partman/choose_partition select finish
+d-i partman/confirm boolean true
+d-i partman/confirm_nooverwrite boolean true
+d-i user-setup/allow-password-weak boolean true
+d-i finish-install/reboot_in_progress note
+d-i debian-installer/exit/poweroff boolean true
+"""
+
+def makeKickstartFloppy():
+    "Create and return kickstart floppy, kickstart, preseed"
+    kickstart = 'ks.cfg'
+    with open( kickstart, 'w' ) as f:
+        f.write( KickstartText )
+    preseed = 'ks.preseed'
+    with open( preseed, 'w' ) as f:
+        f.write( PreseedText )
+    # Create floppy and copy files to it
+    floppy = 'ksfloppy.img'
+    run( 'qemu-img create %s 1440k' % floppy )
+    run( 'mkfs -t msdos ' + floppy )
+    run( 'mcopy -i %s %s ::/' % ( floppy, kickstart ) )
+    run( 'mcopy -i %s %s ::/' % ( floppy, preseed ) )
+    return floppy, kickstart, preseed
+
+
+def archFor( filepath ):
+    "Guess architecture for file path"
+    name = path.basename( filepath )
+    if 'amd64' in name or 'x86_64' in name:
+        arch = 'x86_64'
+    # Beware of version 64 of a 32-bit OS
+    elif 'i386' in name or '32' in name or 'x86' in name:
+        arch = 'i386'
+    elif '64' in name:
+        arch = 'x86_64'
+    else:
+        log( "Error: can't discern CPU for name", name )
+        exit( 1 )
+    return arch
+
+
+def installUbuntu( iso, image, logfilename='install.log', memory=1024 ):
+    "Install Ubuntu from iso onto image"
+    kvm = 'qemu-system-' + archFor( iso )
+    floppy, kickstart, preseed = makeKickstartFloppy()
+    # Mount iso so we can use its kernel
+    mnt = mkdtemp()
+    srun( 'mount %s %s' % ( iso, mnt ) )
+    kernel = path.join( mnt, 'install/vmlinuz' )
+    initrd = path.join( mnt, 'install/initrd.gz' )
+    if NoKVM:
+        accel = 'tcg'
+    else:
+        accel = 'kvm'
+    cmd = [ 'sudo', kvm,
+           '-machine', 'accel=%s' % accel,
+           '-nographic',
+           '-netdev', 'user,id=mnbuild',
+           '-device', 'virtio-net,netdev=mnbuild',
+           '-m', str( memory ),
+           '-k', 'en-us',
+           '-fda', floppy,
+           '-drive', 'file=%s,if=virtio' % image,
+           '-cdrom', iso,
+           '-kernel', kernel,
+           '-initrd', initrd,
+           '-append',
+           ' ks=floppy:/' + kickstart +
+           ' preseed/file=floppy://' + preseed +
+           ' console=ttyS0' ]
+    ubuntuStart = time()
+    log( '* INSTALLING UBUNTU FROM', iso, 'ONTO', image )
+    log( ' '.join( cmd ) )
+    log( '* logging to', abspath( logfilename ) )
+    params = {}
+    if not LogToConsole:
+        logfile = open( logfilename, 'w' )
+        params = { 'stdout': logfile, 'stderr': logfile }
+    vm = Popen( cmd, **params )
+    log( '* Waiting for installation to complete')
+    vm.wait()
+    if not LogToConsole:
+        logfile.close()
+    elapsed = time() - ubuntuStart
+    # Unmount iso and clean up
+    srun( 'umount ' + mnt )
+    run( 'rmdir ' + mnt )
+    if vm.returncode != 0:
+        raise Exception( 'Ubuntu installation returned error %d' %
+                          vm.returncode )
+    log( '* UBUNTU INSTALLATION COMPLETED FOR', image )
+    log( '* Ubuntu installation completed in %.2f seconds' % elapsed )
+
+
+def boot( cow, kernel, initrd, logfile, memory=1024 ):
+    """Boot qemu/kvm with a COW disk and local/user data store
+       cow: COW disk path
+       kernel: kernel path
+       logfile: log file for pexpect object
+       memory: memory size in MB
+       returns: pexpect object to qemu process"""
+    # pexpect might not be installed until after depend() is called
+    global pexpect
+    import pexpect
+    arch = archFor( kernel )
+    log( '* Detected kernel architecture', arch )
+    if NoKVM:
+        accel = 'tcg'
+    else:
+        accel = 'kvm'
+    cmd = [ 'sudo', 'qemu-system-' + arch,
+            '-machine accel=%s' % accel,
+            '-nographic',
+            '-netdev user,id=mnbuild',
+            '-device virtio-net,netdev=mnbuild',
+            '-m %s' % memory,
+            '-k en-us',
+            '-kernel', kernel,
+            '-initrd', initrd,
+            '-drive file=%s,if=virtio' % cow,
+            '-append "root=/dev/vda1 init=/sbin/init console=ttyS0" ' ]
+    cmd = ' '.join( cmd )
+    log( '* BOOTING VM FROM', cow )
+    log( cmd )
+    vm = pexpect.spawn( cmd, timeout=TIMEOUT, logfile=logfile )
+    return vm
+
+
+def login( vm, user='mininet', password='mininet' ):
+    "Log in to vm (pexpect object)"
+    log( '* Waiting for login prompt' )
+    vm.expect( 'login: ' )
+    log( '* Logging in' )
+    vm.sendline( user )
+    log( '* Waiting for password prompt' )
+    vm.expect( 'Password: ' )
+    log( '* Sending password' )
+    vm.sendline( password )
+    log( '* Waiting for login...' )
+
+
+def sanityTest( vm ):
+    "Run Mininet sanity test (pingall) in vm"
+    vm.sendline( 'sudo mn --test pingall' )
+    if vm.expect( [ ' 0% dropped', pexpect.TIMEOUT ], timeout=45 ) == 0:
+        log( '* Sanity check OK' )
+    else:
+        log( '* Sanity check FAILED' )
+        log( '* Sanity check output:' )
+        log( vm.before )
+
+
+def coreTest( vm, prompt=Prompt ):
+    "Run core tests (make test) in VM"
+    log( '* Making sure cgroups are mounted' )
+    vm.sendline( 'sudo service cgroup-lite restart' )
+    vm.expect( prompt )
+    vm.sendline( 'sudo cgroups-mount' )
+    vm.expect( prompt )
+    log( '* Running make test' )
+    vm.sendline( 'cd ~/mininet; sudo make test' )
+    # We should change "make test" to report the number of
+    # successful and failed tests. For now, we have to
+    # know the time for each test, which means that this
+    # script will have to change as we add more tests.
+    for test in range( 0, 2 ):
+        if vm.expect( [ 'OK', 'FAILED', pexpect.TIMEOUT ], timeout=180 ) == 0:
+            log( '* Test', test, 'OK' )
+        else:
+            log( '* Test', test, 'FAILED' )
+            log( '* Test', test, 'output:' )
+            log( vm.before )
+
+def noneTest( vm ):
+    "This test does nothing"
+    vm.sendline( 'echo' )
+
+def examplesquickTest( vm, prompt=Prompt ):
+    "Quick test of mininet examples"
+    vm.sendline( 'sudo apt-get install python-pexpect' )
+    vm.expect( prompt )
+    vm.sendline( 'sudo python ~/mininet/examples/test/runner.py -v -quick' )
+
+
+def examplesfullTest( vm, prompt=Prompt ):
+    "Full (slow) test of mininet examples"
+    vm.sendline( 'sudo apt-get install python-pexpect' )
+    vm.expect( prompt )
+    vm.sendline( 'sudo python ~/mininet/examples/test/runner.py -v' )
+
+
+def walkthroughTest( vm, prompt=Prompt ):
+    "Test mininet walkthrough"
+    vm.sendline( 'sudo apt-get install python-pexpect' )
+    vm.expect( prompt )
+    vm.sendline( 'sudo python ~/mininet/mininet/test/test_walkthrough.py -v' )
+
+
+def checkOutBranch( vm, branch, prompt=Prompt ):
+    # This is a bit subtle; it will check out an existing branch (e.g. master)
+    # if it exists; otherwise it will create a detached branch.
+    # The branch will be rebased to its parent on origin.
+    # This probably doesn't matter since we're running on a COW disk
+    # anyway.
+    vm.sendline( 'cd ~/mininet; git fetch --all; git checkout '
+                 + branch + '; git pull --rebase origin ' + branch )
+    vm.expect( prompt )
+    vm.sendline( 'sudo make install' )
+
+
+def interact( vm, tests, pre='', post='', prompt=Prompt ):
+    "Interact with vm, which is a pexpect object"
+    login( vm )
+    log( '* Waiting for login...' )
+    vm.expect( prompt )
+    log( '* Sending hostname command' )
+    vm.sendline( 'hostname' )
+    log( '* Waiting for output' )
+    vm.expect( prompt )
+    log( '* Fetching Mininet VM install script' )
+    branch = Branch if Branch else 'master'
+    vm.sendline( 'wget '
+                 'https://raw.github.com/mininet/mininet/%s/util/vm/'
+                 'install-mininet-vm.sh' % branch )
+    vm.expect( prompt )
+    log( '* Running VM install script' )
+    installcmd = 'bash install-mininet-vm.sh'
+    if Branch:
+        installcmd += ' ' + Branch
+    vm.sendline( installcmd )
+    vm.expect ( 'password for mininet: ' )
+    vm.sendline( 'mininet' )
+    log( '* Waiting for script to complete... ' )
+    # Gigantic timeout for now ;-(
+    vm.expect( 'Done preparing Mininet', timeout=3600 )
+    log( '* Completed successfully' )
+    vm.expect( prompt )
+    version = getMininetVersion( vm )
+    vm.expect( prompt )
+    log( '* Mininet version: ', version )
+    log( '* Testing Mininet' )
+    runTests( vm, tests=tests, pre=pre, post=post )
+    # Ubuntu adds this because we install via a serial console,
+    # but we want the VM to boot via the VM console. Otherwise
+    # we get the message 'error: terminal "serial" not found'
+    log( '* Disabling serial console' )
+    vm.sendline( "sudo sed -i -e 's/^GRUB_TERMINAL=serial/#GRUB_TERMINAL=serial/' "
+                "/etc/default/grub; sudo update-grub" )
+    vm.expect( prompt )
+    log( '* Shutting down' )
+    vm.sendline( 'sync; sudo shutdown -h now' )
+    log( '* Waiting for EOF/shutdown' )
+    vm.read()
+    log( '* Interaction complete' )
+    return version
+
+
+def cleanup():
+    "Clean up leftover qemu-nbd processes and other junk"
+    call( [ 'sudo', 'pkill', '-9', 'qemu-nbd' ] )
+
+
+def convert( cow, basename ):
+    """Convert a qcow2 disk to a vmdk and put it a new directory
+       basename: base name for output vmdk file"""
+    vmdk = basename + '.vmdk'
+    log( '* Converting qcow2 to vmdk' )
+    run( 'qemu-img convert -f qcow2 -O vmdk %s %s' % ( cow, vmdk ) )
+    return vmdk
+
+
+# Template for OVF - a very verbose format!
+# In the best of all possible worlds, we might use an XML
+# library to generate this, but a template is easier and
+# possibly more concise!
+# Warning: XML file cannot begin with a newline!
+
+OVFTemplate = """<?xml version="1.0"?>
+<Envelope ovf:version="1.0" xml:lang="en-US"
+    xmlns="http://schemas.dmtf.org/ovf/envelope/1"
+    xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"
+    xmlns:rasd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData"
+    xmlns:vssd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+<References>
+<File ovf:href="%(diskname)s" ovf:id="file1" ovf:size="%(filesize)d"/>
+</References>
+<DiskSection>
+<Info>Virtual disk information</Info>
+<Disk ovf:capacity="%(disksize)d" ovf:capacityAllocationUnits="byte"
+    ovf:diskId="vmdisk1" ovf:fileRef="file1"
+    ovf:format="http://www.vmware.com/interfaces/specifications/vmdk.html#streamOptimized"/>
+</DiskSection>
+<NetworkSection>
+<Info>The list of logical networks</Info>
+<Network ovf:name="nat">
+<Description>The nat  network</Description>
+</Network>
+</NetworkSection>
+<VirtualSystem ovf:id="%(vmname)s">
+<Info>%(vminfo)s (%(name)s)</Info>
+<Name>%(vmname)s</Name>
+<OperatingSystemSection ovf:id="%(osid)d">
+<Info>The kind of installed guest operating system</Info>
+<Description>%(osname)s</Description>
+</OperatingSystemSection>
+<VirtualHardwareSection>
+<Info>Virtual hardware requirements</Info>
+<Item>
+<rasd:AllocationUnits>hertz * 10^6</rasd:AllocationUnits>
+<rasd:Description>Number of Virtual CPUs</rasd:Description>
+<rasd:ElementName>%(cpus)s virtual CPU(s)</rasd:ElementName>
+<rasd:InstanceID>1</rasd:InstanceID>
+<rasd:ResourceType>3</rasd:ResourceType>
+<rasd:VirtualQuantity>%(cpus)s</rasd:VirtualQuantity>
+</Item>
+<Item>
+<rasd:AllocationUnits>byte * 2^20</rasd:AllocationUnits>
+<rasd:Description>Memory Size</rasd:Description>
+<rasd:ElementName>%(mem)dMB of memory</rasd:ElementName>
+<rasd:InstanceID>2</rasd:InstanceID>
+<rasd:ResourceType>4</rasd:ResourceType>
+<rasd:VirtualQuantity>%(mem)d</rasd:VirtualQuantity>
+</Item>
+<Item>
+<rasd:Address>0</rasd:Address>
+<rasd:Caption>scsiController0</rasd:Caption>
+<rasd:Description>SCSI Controller</rasd:Description>
+<rasd:ElementName>scsiController0</rasd:ElementName>
+<rasd:InstanceID>4</rasd:InstanceID>
+<rasd:ResourceSubType>lsilogic</rasd:ResourceSubType>
+<rasd:ResourceType>6</rasd:ResourceType>
+</Item>
+<Item>
+<rasd:AddressOnParent>0</rasd:AddressOnParent>
+<rasd:ElementName>disk1</rasd:ElementName>
+<rasd:HostResource>ovf:/disk/vmdisk1</rasd:HostResource>
+<rasd:InstanceID>11</rasd:InstanceID>
+<rasd:Parent>4</rasd:Parent>
+<rasd:ResourceType>17</rasd:ResourceType>
+</Item>
+<Item>
+<rasd:AddressOnParent>2</rasd:AddressOnParent>
+<rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
+<rasd:Connection>nat</rasd:Connection>
+<rasd:Description>E1000 ethernet adapter on nat</rasd:Description>
+<rasd:ElementName>ethernet0</rasd:ElementName>
+<rasd:InstanceID>12</rasd:InstanceID>
+<rasd:ResourceSubType>E1000</rasd:ResourceSubType>
+<rasd:ResourceType>10</rasd:ResourceType>
+</Item>
+<Item>
+<rasd:Address>0</rasd:Address>
+<rasd:Caption>usb</rasd:Caption>
+<rasd:Description>USB Controller</rasd:Description>
+<rasd:ElementName>usb</rasd:ElementName>
+<rasd:InstanceID>9</rasd:InstanceID>
+<rasd:ResourceType>23</rasd:ResourceType>
+</Item>
+</VirtualHardwareSection>
+</VirtualSystem>
+</Envelope>
+"""
+
+
+def generateOVF( name, osname, osid, diskname, disksize, mem=1024, cpus=1,
+                 vmname='Mininet-VM', vminfo='A Mininet Virtual Machine' ):
+    """Generate (and return) OVF file "name.ovf"
+       name: root name of OVF file to generate
+       osname: OS name for OVF (Ubuntu | Ubuntu 64-bit)
+       osid: OS ID for OVF (93 | 94 )
+       diskname: name of disk file
+       disksize: size of virtual disk in bytes
+       mem: VM memory size in MB
+       cpus: # of virtual CPUs
+       vmname: Name for VM (default name when importing)
+       vmimfo: Brief description of VM for OVF"""
+    ovf = name + '.ovf'
+    filesize = stat( diskname )[ ST_SIZE ]
+    params = dict( osname=osname, osid=osid, diskname=diskname,
+                   filesize=filesize, disksize=disksize, name=name,
+                   mem=mem, cpus=cpus, vmname=vmname, vminfo=vminfo )
+    xmltext = OVFTemplate % params
+    with open( ovf, 'w+' ) as f:
+        f.write( xmltext )
+    return ovf
+
+
+def qcow2size( qcow2 ):
+    "Return virtual disk size (in bytes) of qcow2 image"
+    output = check_output( [ 'file', qcow2 ] )
+    assert 'QCOW' in output
+    bytes = int( re.findall( '(\d+) bytes', output )[ 0 ] )
+    return bytes
+
+
+def build( flavor='raring32server', tests=None, pre='', post='', memory=1024 ):
+    """Build a Mininet VM; return vmdk and vdisk size
+       tests: tests to run
+       pre: command line to run in VM before tests
+       post: command line to run in VM after tests
+       prompt: shell prompt (default '$ ')
+       memory: memory size in MB"""
+    global LogFile, Zip
+    start = time()
+    lstart = localtime()
+    date = strftime( '%y%m%d-%H-%M-%S', lstart)
+    ovfdate = strftime( '%y%m%d', lstart )
+    dir = 'mn-%s-%s' % ( flavor, date )
+    if Branch:
+        dir = 'mn-%s-%s-%s' % ( Branch, flavor, date )
+    try:
+        os.mkdir( dir )
+    except:
+        raise Exception( "Failed to create build directory %s" % dir )
+    os.chdir( dir )
+    LogFile = open( 'build.log', 'w' )
+    log( '* Logging to', abspath( LogFile.name ) )
+    log( '* Created working directory', dir )
+    image, kernel, initrd = findBaseImage( flavor )
+    basename = 'mininet-' + flavor
+    volume = basename + '.qcow2'
+    run( 'qemu-img create -f qcow2 -b %s %s' % ( image, volume ) )
+    log( '* VM image for', flavor, 'created as', volume )
+    if LogToConsole:
+        logfile = stdout
+    else:
+        logfile = open( flavor + '.log', 'w+' )
+    log( '* Logging results to', abspath( logfile.name ) )
+    vm = boot( volume, kernel, initrd, logfile, memory=memory )
+    version = interact( vm, tests=tests, pre=pre, post=post )
+    size = qcow2size( volume )
+    arch = archFor( flavor )
+    vmdk = convert( volume, basename='mininet-vm-' + arch )
+    if not SaveQCOW2:
+        log( '* Removing qcow2 volume', volume )
+        os.remove( volume )
+    log( '* Converted VM image stored as', abspath( vmdk ) )
+    ovfname = 'mininet-%s-%s-%s' % ( version, ovfdate, OSVersion( flavor ) )
+    osname, osid = OVFOSNameID( flavor )
+    ovf = generateOVF( name=ovfname, osname=osname, osid=osid,
+                       diskname=vmdk, disksize=size )
+    log( '* Generated OVF descriptor file', ovf )
+    if Zip:
+        log( '* Generating .zip file' )
+        run( 'zip %s-ovf.zip %s %s' % ( ovfname, ovf, vmdk ) )
+    end = time()
+    elapsed = end - start
+    log( '* Results logged to', abspath( logfile.name ) )
+    log( '* Completed in %.2f seconds' % elapsed )
+    log( '* %s VM build DONE!!!!! :D' % flavor )
+    os.chdir( '..' )
+
+
+def runTests( vm, tests=None, pre='', post='', prompt=Prompt ):
+    "Run tests (list) in vm (pexpect object)"
+    if Branch:
+        checkOutBranch( vm, branch=Branch )
+        vm.expect( prompt )
+    if not tests:
+        tests = []
+    if pre:
+        log( '* Running command', pre )
+        vm.sendline( pre )
+        vm.expect( prompt )
+    testfns = testDict()
+    if tests:
+        log( '* Running tests' )
+    for test in tests:
+        if test not in testfns:
+            raise Exception( 'Unknown test: ' + test )
+        log( '* Running test', test )
+        fn = testfns[ test ]
+        fn( vm )
+        vm.expect( prompt )
+    if post:
+        log( '* Running post-test command', post )
+        vm.sendline( post )
+        vm.expect( prompt )
+
+def getMininetVersion( vm ):
+    "Run mn to find Mininet version in VM"
+    vm.sendline( '~/mininet/bin/mn --version' )
+    # Eat command line echo, then read output line
+    vm.readline()
+    version = vm.readline().strip()
+    return version
+
+
+def bootAndRun( image, prompt=Prompt, memory=1024, outputFile=None, 
+                runFunction=None, **runArgs ):
+    """Boot and test VM
+       tests: list of tests to run
+       pre: command line to run in VM before tests
+       post: command line to run in VM after tests
+       prompt: shell prompt (default '$ ')
+       memory: VM memory size in MB"""
+    bootTestStart = time()
+    basename = path.basename( image )
+    image = abspath( image )
+    tmpdir = mkdtemp( prefix='test-' + basename )
+    log( '* Using tmpdir', tmpdir )
+    cow = path.join( tmpdir, basename + '.qcow2' )
+    log( '* Creating COW disk', cow )
+    run( 'qemu-img create -f qcow2 -b %s %s' % ( image, cow ) )
+    log( '* Extracting kernel and initrd' )
+    kernel, initrd = extractKernel( image, flavor=basename, imageDir=tmpdir )
+    if LogToConsole:
+        logfile = stdout
+    else:
+        logfile = NamedTemporaryFile( prefix=basename,
+                                      suffix='.testlog', delete=False )
+    log( '* Logging VM output to', logfile.name )
+    vm = boot( cow=cow, kernel=kernel, initrd=initrd, logfile=logfile,
+               memory=memory )
+    login( vm )
+    log( '* Waiting for prompt after login' )
+    vm.expect( prompt )
+    # runFunction should begin with sendline and should eat its last prompt
+    if runFunction:
+        runFunction( vm, **runArgs )
+    log( '* Shutting down' )
+    vm.sendline( 'sudo shutdown -h now ' )
+    log( '* Waiting for shutdown' )
+    vm.wait()
+    if outputFile:
+        log( '* Saving temporary image to %s' % outputFile )
+        convert( cow, outputFile )
+    log( '* Removing temporary dir', tmpdir )
+    srun( 'rm -rf ' + tmpdir )
+    elapsed = time() - bootTestStart
+    log( '* Boot and test completed in %.2f seconds' % elapsed )
+
+
+def buildFlavorString():
+    "Return string listing valid build flavors"
+    return 'valid build flavors: ( %s )' % ' '.join( sorted( isoURLs ) )
+
+
+def testDict():
+    "Return dict of tests in this module"
+    suffix = 'Test'
+    trim = len( suffix )
+    fdict = dict( [ ( fname[ : -trim ], f ) for fname, f in
+                    inspect.getmembers( modules[ __name__ ],
+                                    inspect.isfunction )
+                  if fname.endswith( suffix ) ] )
+    return fdict
+
+
+def testString():
+    "Return string listing valid tests"
+    return 'valid tests: ( %s )' % ' '.join( testDict().keys() )
+
+
+def parseArgs():
+    "Parse command line arguments and run"
+    global LogToConsole, NoKVM, Branch, Zip, TIMEOUT
+    parser = argparse.ArgumentParser( description='Mininet VM build script',
+                                      epilog=buildFlavorString() + ' ' +
+                                      testString() )
+    parser.add_argument( '-v', '--verbose', action='store_true',
+                        help='send VM output to console rather than log file' )
+    parser.add_argument( '-d', '--depend', action='store_true',
+                         help='install dependencies for this script' )
+    parser.add_argument( '-l', '--list', action='store_true',
+                         help='list valid build flavors and tests' )
+    parser.add_argument( '-c', '--clean', action='store_true',
+                         help='clean up leftover build junk (e.g. qemu-nbd)' )
+    parser.add_argument( '-q', '--qcow2', action='store_true',
+                         help='save qcow2 image rather than deleting it' )
+    parser.add_argument( '-n', '--nokvm', action='store_true',
+                         help="Don't use kvm - use tcg emulation instead" )
+    parser.add_argument( '-m', '--memory', metavar='MB', type=int,
+                        default=1024, help='VM memory size in MB' )
+    parser.add_argument( '-i', '--image', metavar='image', default=[],
+                         action='append',
+                         help='Boot and test an existing VM image' )
+    parser.add_argument( '-t', '--test', metavar='test', default=[],
+                         action='append',
+                         help='specify a test to run' )
+    parser.add_argument( '-w', '--timeout', metavar='timeout', type=int,
+                            default=0, help='set expect timeout' )
+    parser.add_argument( '-r', '--run', metavar='cmd', default='',
+                         help='specify a command line to run before tests' )
+    parser.add_argument( '-p', '--post', metavar='cmd', default='',
+                         help='specify a command line to run after tests' )
+    parser.add_argument( '-b', '--branch', metavar='branch',
+                         help='branch to install and/or check out and test' )
+    parser.add_argument( 'flavor', nargs='*',
+                         help='VM flavor(s) to build (e.g. raring32server)' )
+    parser.add_argument( '-z', '--zip', action='store_true',
+                         help='archive .ovf and .vmdk into .zip file' )
+    parser.add_argument( '-o', '--out',
+                         help='output file for test image (vmdk)' )
+    args = parser.parse_args()
+    if args.depend:
+        depend()
+    if args.list:
+        print buildFlavorString()
+    if args.clean:
+        cleanup()
+    if args.verbose:
+        LogToConsole = True
+    if args.nokvm:
+        NoKVM = True
+    if args.branch:
+        Branch = args.branch
+    if args.zip:
+        Zip = True
+    if args.timeout:
+        TIMEOUT = args.timeout
+    if not args.test and not args.run and not args.post:
+        args.test = [ 'sanity', 'core' ]
+    for flavor in args.flavor:
+        if flavor not in isoURLs:
+            print "Unknown build flavor:", flavor
+            print buildFlavorString()
+            break
+        try:
+            build( flavor, tests=args.test, pre=args.run, post=args.post,
+                   memory=args.memory )
+        except Exception as e:
+            log( '* BUILD FAILED with exception: ', e )
+            exit( 1 )
+    for image in args.image:
+        bootAndRun( image, runFunction=runTests, tests=args.test, pre=args.run,
+                    post=args.post, memory=args.memory, outputFile=args.out )
+    if not ( args.depend or args.list or args.clean or args.flavor
+             or args.image ):
+        parser.print_help()
+
+
+if __name__ == '__main__':
+    parseArgs()
@@ -3,16 +3,22 @@
 # 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=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
+# 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
 sudo apt-get update
 # Clean up vmware easy install junk if present
 if [ -e /etc/issue.backup ]; then
@@ -21,20 +27,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."