Nox was a first generation open flow controller. It is open source, stable, and
widely used. There are two flavors of Nox. Classic Nox, and the New Nox.
Classic Nox was written in C++ and Python and is no longer supported.
The new Nox is C++ only. The Code base is fast, clean and well supported.
More information about Nox is available at noxrepo.org. In a Nox network,
there may be a set of switches and various network-attached servers. The
controller maintains a network view and the controller may also run several
applications that operate on that network
view. The basic abstraction that NOX supports
is a switch control abstraction where open flow is the prevailing protocol.
Control is defined at the granularity of flows which are defined. By a ten-tuple
in the original OpenFlow specification. So
depending on whether a particular packet matches
a subset of values specified as a flow rule, the controller may make
different decisions for packets that belong to different parts of
flow space. Or packets that match different subsets, of the
fields defined by a flow. A flow is defined
by the header or the 10-tuple which I distoluted to.
A counter which maintains statistics and actions
that should be performed. On packets that
match this particular flow definition. Actions might
include forwarding the packet. Dropping it or
sending it to the controller. When a switch
recives a packet, it updates it's counters
for counting packets that belong to that
flow and applies the correspondence actions for
that flow, which include forwarding, dropping or sending
to a controller. The basic programatic interface.
For the [UNKNOWN] controller is based on
events. The controller knows how to process
different types of events, such as a switch,
join or leave a packet in or packet received event should the switch redirect
packet to controller as well as various
statistics. The controller also keeps tracks of a
network view. Which includes a view of the underlying network topology, and it
also speaks a control protocol to the
switches in the network. That control protocol
effectively allows the controller to update the
state in the network switches. The Nox
controller implements the open flow protocol. Nox
has implemented in C++ And it supports
opaflow 1.0, a fork of nox called CPQD supports versions 1.1,
1.2 and 1.3. The programming is event based and a programmer can write an
application by writing even handlers for
the nox controller. NOX provides good performance
but requires you to understand and
be comfortable with the facilities and semantics
of low level open flow commands. Later
in this module, we will explore controllers
based on pyretic and frenetic that do
not have this characteristic. NOX also requires the
programmer to write the control application in
C++, which can be slow for development and
debugging. To address the shortcomings that are
associated with development in C++, Pox was developed.
Pox is widely used, maintained, and supported. It's also easy to
use, and easy to read and write the control programs. Of
course, as might come with implementing a controller in python, the
performance of Pox is not as good as the performance of Nox.