How to write a simple own POX component

POX is invoked by running pox.py and has a couple of optional command line arguments than can be used at the start of the command line

Eg : ./pox.py log.level --DEBUG samples.pretty_log openflow.keepalive --interval=15 forwarding.l2_pairs

POX functionality is provided by components(python modules) which are specified on the command line. In the above example forwarding.l2_pairs is the functionality of the openflow controller. We can invoke more then one component, especially when one component is dependent on the other

There are some of the components whcih come along with pox, but the main focus is to write our own component. Write your modules and place them where pox can find it(eg. PYTHONPATH) or in the "ext" directory ~/pox/ext/

POX has a core object to which components will register on the core object and other components  will query the core object.The POX OpenFlow component by default registers an instance of OpenFlowNexus as core.openflow, and other applications can then access a lot of the OpenFlow functionality from there.

#This component just monitors the connection up and down events
#when any switch connects and disconnections"



core.openflow.addListeners():
                  Registers MyComponent class to listen for multiple events defined in openflow object. Which means for any method in openflow defined as _handle_EventName is replaced by the same method defined under MyComponent class and set as the listner.

_handle_ConnectionUp():
                 Event raised when the connection to an OpenFlow switch has been established

_handle_ConnectionDown():
                 Event raised when the connection to an OpenFlow switch has been lost.


Each pox component should contain the launch() function via which pox initializes the component. Mainly used to pass the command line parameters for the component.
core.registerNew() registers a new component with the core object

Build your network topology in Mininet

In this post i will discuss about building a network topology without using default topology objects which come with Mininet.

Import all the modules as below.



Define a function myNet() which creates all the nodes and links them. The Mininet class returns a empty network object to which we add hosts, switches and controller. RemoteController class returns a controller object which runs outside Mininet. Assign the controller into our net object.


net.addHost() creates host nodes and adds to the network. net.addSwitch adds the openflow switch to the network
 

Connect the nodes by adding links between them as below. Then net.build() call will build the topology and net.start() will start all the nodes. CLI(net) will run the cli mode awaiting for user inputs.


Results :

Understanding Mininet Network Topology

Mininet has a set of default network topologies which can be chosen on the command line.

The below example creates a network topology with single openflow switch and 3 hosts connected to it.

Another example where mininet creates a linear network topology with each switch connected to one host and the switch adjacent to it.

In the above example mn is a launch script which executes the below python code.

The main class in the code snippet is Mininet which spawns hosts, switches and controller and add links between them. Mininet class takes topo parameter which describes the network topology.

The Topo class is the abstract class used to build custom topologies. One of the derived classes is LinearTopo which creates linear topology of k switches, with n hosts per switch.

net.start will start all the switches, controller and hosts. Next net.cli initiates a simple command line interface to talk to the nodes.

The other default topologies are SingleSwitchReversedTopo, SingleSwitchTopo  and TreeTopo

Getting Started With MININET & POX

In this article i will discuss about a virtual network simulator MININET and openflow controller POX

Mininet  

It is virtual network environment that can run a single PC. We can use this to write SDN/Openflow applications and experiment by creating our own network topology.

Mininet creates a realistic virtual network, running real kernel, switch and application code, on a single machine. It allows to build custom topology constituting hosts, openflow switch, controller and links between them.   

In a nut shell when mininet process(mn) kick starts it forks a process for each host and assign them to separate network namespace. Then create virtual ethernet pairs and assign one for each namespace. Next it creates a openflow switch which connects to each host. Finally creates a openflow controller which installs flow table into switch using openflow protocol. 

POX Controller

POX is a lightweight OpenFlow controller that is written completely in Python that is targeted for developers to spin up their own controllers. You can write your Openflow application/controller which connects to the openflow switch created by Mininet. 

Below steps will launch a simple network topology which comes with Mininet. The mininet itself starts a controller but here we will launch a POX controller in another terminal and the network connects this remote controller.  

1) VM : 

       Create a virtual machine running any linux version. I am using Ubuntu 12.04.2

2) MININET :

        Install mininet and clone mininet to current directory

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/sbin/ovs*
#sudo rm /usr/local/bin/ovs*

               

More Info on installation : https://github.com/mininet/mininet/blob/master/INSTALL

Mininet Tutorial              : https://github.com/mininet/mininet/wiki/Introduction-to-Mininet

3) POX :

GIT POX : https://github.com/noxrepo/pox

POX Tutorial : http://www.openflow.org/wk/index.php/OpenFlow_Tutorial#Start_Network

4) Kill all the controller and clear mininet 

5) Starting remote controller POX  

     

6) Launch Mininet to create a network in  a new terminal :

 7) Ping TEST :

     

Results :

SDN & OpenFlow Overview

SDN Overview 

Traditionally, every switch and router in a network has its own control and data plane, which means all routing decisions are made on the switch itself.

The idea behind SDNs is to abstract that control plane from the switches and routers and run it on a central controller. That leaves the switches with just the data plane that actually ships packets in and out; the decisions on where the packets will go is based on instructions coming from that central controller. 

The central controller helps in automatically adjusting the network architecture to deliver the fastest and most efficient data paths at the right time.

OpenFlow Overview 

OpenFlow is a new protocol implemented on an Ethernet switch that allows its forwarding plane to be managed by an external OpenFlow controller. 

OpenFlow exposes a switch’s forwarding plane as a set of Ethernet ports, flow tables, counters, queues, and capabilities. A flow table entry consists of a set of  L2/L3/L4 match conditions, which may be variously wildcarded or masked. Associated with each flow table rule is a set of one or more actions, including Forwarding (to a physical or virtual port, to the controller, or flooded), Enqueueing, and Packet Modification.

By default, packets arriving at an OpenFlow-managed port which do not match a flow entry are encapsulated and sent to the controller, which as a result may send a flow installation command to the switch and return the packet back to the switch for forwarding.