This section describes how a user may set up the packet optical use case, or by extension, a multi-layer network topology. One of the key drivers for this use case is that network designers can spin up a relatively large emulated packet-optical network on their personal computer.
Installation
You should start with a fresh install of Ubuntu Server. Alternatively, you can start with the Mininet VM; this way you can skip the first step in following instructions.
- Install Mininet, for instance using the Native Installation from Source approach; this installs a lot of useful extra packages such as Wireshark and OpenFlow dissectors.
Install, configure and build LINC Switch: https://github.com/FlowForwarding/LINC-Switch
$ cd $ sudo apt-get install erlang git-core bridge-utils libpcap0.8 libpcap-dev libcap2-bin uml-utilities $ git clone https://github.com/FlowForwarding/LINC-Switch.git linc-oe $ cd linc-oe $ sed -i s/3000/300000/ rel/files/vm.args $ cp rel/files/sys.config.orig rel/files/sys.config $ make $ cd
Install LINC-config-generator: https://github.com/FlowForwarding/LINC-config-generator
$ cd $ git clone https://github.com/FlowForwarding/LINC-config-generator.git $ cd LINC-config-generator $ cp priv/* . $ make $ cd
Clone ONOS and compile the oecfg application. This requires you have installed Java 8 and Apache Maven; go here for instructions on how to do that.
$ cd $ git clone https://github.com/opennetworkinglab/onos $ cd onos/app/oecfg $ mci $ cd
Instantiate Multi-Layer Topologies
Before spawning the packet/optical topology, you should ensure ONOS has loaded the optical application. You can do so by including onos-app-optical
in your Karaf features.
The ONOS source tree comes with two example scripts that create a multi-layer topology. These can be found in onos/tools/test/topos/
and are called opticalTest.py
and opticalTestBig.py
.
First, make sure the ONOS_ROOT
environment variable is set. The easiest way is to set it in your cell definition, this way you'll also get OCx
environment variables that point to your ONOS instances. Then, to create spawn a large packet-optical topology, run the following command (note the -E
parameter passed to sudo
which preserves the environment variables):
sudo -E onos/tools/test/topos/opticalTestBig.py $OC1 $OC2 $OC3
In this example, three ONOS instances are running; feel free to change this to your setup. The script will ensure all switches (both packet and optical) will be configured to use the listed instances as their OpenFlow controller.
Both Mininet scripts rely on opticalUtils.py
, which has the following functionality:
- TBD
If, for some reason, the script failed to inject the optical topology in ONOS, you can re-run this step as follows:
$ ~/onos/tools/test/bin/onos-topo-cfg $OC1 Topology.json
LINC Optical ROADM Emulation Commands
You can attach to the console of a running LINC instance as follows:
$ sudo linc-oe/rel/linc/bin/linc attach
In the LINC console, the following commands are available.
Command | Description |
---|---|
| Get running config |
linc_logic:get_datapath_id(SwitchId). | Get DPID of logical switch |
linc:stop_switch(SwitchId). | Stop logical switch |
| Disable port |
linc:port_up(SwitchId, PortId). | Enable port |
linc:ports(SwitchId). | List ports on logical switch |
linc_us4_oe_flow:get_flow_table(switchId, tableId). | Get flow table of logical switch (use tableId 0) |
Background
OVS from (provide link : open source) is used by Mininet to emulate packet routers and switches. The packet switches are directly attached to hosts, which represent customers or data centers. In addition, the emulated packet switches are interconnected with optical ROADMs for transport. As shown below, the OpenFlow match/action tables for the ROADMs can be represented by cross-connecting the lambdas to establish paths at optical layer.
ROADM Description:
As shown below, the optical ROADMs represent the service provider's transport networks. The IP routers are connected physically to the ROADMs, and the chain of ROADMs establish the transport topology.
The ROADMs are responsible for passing all of the traffic through their cross connected optical paths.
The following diagram represents a very simplified environment for POCs. Both ONOS and Mininet are communicating to the network devices. Mininet as orchestrator for creating topology that includes switches, hosts, and link and tap interfaces will be used extensively for manipulating the POC environment and behaviors. For example you will utilize the Mininet to inject failures and or send traffic between hosts.