NePA TesT: Community Network Emulator

Mininet Installation/Configuration Notes

----------------------------------------

Mininet 2.2.0b2

---

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://mininet.org/>

   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.

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

        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`:

        sudo rm /usr/local/bin/ovs*

        sudo rm /usr/local/sbin/ovs*

3. Native installation from source

3.1. Native installation from source on Ubuntu 12.04+

   If you're reading this, you've probably already done so, but the

   command to download the Mininet source code is:

        git clone git://github.com/mininet/mininet.git

   Note that the above git command will check out the latest and greatest

   Mininet (which we recommend!) If you want to run the last tagged/released

   version of Mininet, you can look at the release tags using

        cd mininet

        git tag

    and then

        git checkout <release tag>

   where <release tag> is the release you want to check out.

   If you are running Ubuntu, Debian, or Fedora, you may be able to use

   our handy `install.sh` script, which is in `mininet/util`.

   *WARNING: USE AT YOUR OWN RISK!*

   `install.sh` is a bit intrusive and may possibly damage your OS

   and/or home directory, by creating/modifying several directories

   such as `mininet`, `openflow`, `oftest`, `pox`, etc.. We recommend

   trying it in a VM before trying it on a system you use from day to day.

   Although we hope it won't do anything completely terrible, you may

   want to look at the script before you run it, and you should make

   sure your system and home directory are backed up just in case!

   To install Mininet itself, the OpenFlow reference implementation, and

   Open vSwitch, you may use:

        mininet/util/install.sh -fnv

   This should be reasonably quick, and the following command should

   work after the installation:

        sudo mn --test pingall

   To install ALL of the software which we use for OpenFlow tutorials,

   including POX, the OpenFlow WireShark dissector, the `oftest`

   framework, and other potentially useful software, you may use:

        mininet/util/install.sh -a

   This takes about 4 minutes on our test system.

   You can change the directory where the dependencies are installed using

   the -s <directory> flag.

        mininet/util/install.sh -s <directory> -a

3.2. Native installation from source on Fedora 18+.

   As root execute the following operations:

    * install git

        yum install git

    * create an user account (e.g. mininet) and add it to the wheel group

        useradd [...] mininet

        usermod -a -G wheel mininet

    * change the SElinux setting to permissive. It can be done

      temporarily with:

        setenforce 0

   then login with the new account (e.g. mininet) and do the following:

    * clone the Mininet repository

        git clone git://github.com/mininet/mininet.git

    * install Mininet, the OpenFlow reference implementation, and

      Open vSwitch

        mininet/util/install.sh -fnv

    * enable and start openvswitch

        sudo systemctl enable openvswitch

        sudo systemctl start openvswitch

    * test the mininet installation

        sudo mn --test pingall

4. Creating your own Mininet/OpenFlow tutorial VM

   Creating your own Ubuntu Mininet VM for use with the OpenFlow tutorial

   is easy! First, create a new Ubuntu VM. Next, run two commands in it:

        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.

   In general, you must have:

   * A Linux kernel compiled with network namespace support enabled

   * An compatible software switch such as Open vSwitch or

     the Linux bridge.

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

   * Root privileges (required for network device access)

   We encourage contribution of patches to the `install.sh` script to

   support other Linux distributions.

Good luck!

Mininet Team

---