In this work we create virtual network topologies in Mininet, implement Fast Re-Routing (FRR) and Fast Recovery Mechanisms (FRM) and evaluate them in a test framework created in python, using the Mininet Python API.
In this repository you will find all implementations and test data used in the bachelor thesis.
## Browsing the Repository
The repository is divided into three main folders:
- thesis
- implementation
- test data
Under *thesis* you will find all .tex files and images for parsing a new version of the bachelor thesis. *implementation* contains all scripts that were written in context of the test framework and under *test data* you will find the output files for all measurements used in our thesis.
In the following sections we will explain how to set up a Virtual Machine (VM) with Mininet and install all dependencies to use our test framework.
### Setup Mininet VM
The creators of Mininet offer a pre-configured [VM](http://mininet.org/download/) that can be used with a virtualization software like [VirtualBox](https://www.virtualbox.org/). If you want to run Mininet on a native system, you will need to install Mininet according to the instructions on the mininet [homepage](http://mininet.org/).
The Mininet VM uses the Ubuntu distribution. The Mininet VM with Ubuntu 20.04 was used in our tests.
### Install dependencies
After we got a running version of Mininet we are now required to install dependencies which will be used by our test framework.
#### [GnuPlot](http://www.gnuplot.info/)
A library for creating plots using a Command Line Interface (CLI) with extensive configuration capabilities.
The NetfilterQueue python library is a module that enables python to hook into events of the Netfilter Queue, a component storing packets that were redirected by software like *nftables*.
You can either use *git* to checkout this repository or download a .zip archive directly in your browser. After you have an extracted version of this repository on your Mininet instance, you can start using the framework.
The main entry point for any interaction with the framework is the *mininet_controller.py*. It can be executed using *python3*. In our instance of the Mininet VM we had to use *sudo* for all executions of python3. We assume the *implementation* directory as current working directory.
```
sudo python3 mininet_controller.py --help
```
Executing this command will result in the following output:
--limit_bw LIMIT_BW limit bandwith of links in MBits
--delay DELAY add delay in ms to each link
--produce_set will execute the test with and without ShortCut
--full_suite will execute the test with and without ShortCut on all
defined topologies
```
### Selecting a topology
Using ``` sudo python3 mininet_controller.py --topos ``` will list all available topologies.
An examplary output would be:
```
{'Minimal': '2 hosts connected to a switch', '4R4H': 'A topology using 4 routers and 3 hosts', '6R4H': 'A topology using 6 routers and 3 hosts', '8R4H': 'A topology using 8 routers and 3 hosts'}
```
Using the identifier of a topology, in this case the key in the dictionary that was returned, we can tell our test framework to build said topology. A command building a topology using 4 routers and 3 hosts would be:
```
sudo python3 mininet_controller.py --topo 4R4H
```
The test framework will create the topology and start the Mininet CLI which can then be used for manual configuration and testing.
### Executing tests
For each topology tests can be implemented. These are unique to each topology and are implemented inside the topology class. To list all available tests for a topology simply use
Currently available tests are: ['tcp_bandwidth_intermediate', 'udp_bandwidth_intermediate', 'bandwidth_link_usage_intermediate', 'bandwidth_link_usage_concurrent', 'bandwidth_failure_concurrent', 'latency_failure_concurrent', 'latency_failure_intermediate', 'tcp_packet_flow_intermediate', 'udp_packet_flow_intermediate', 'udp_packet_flow_concurrent', 'tcp_packet_flow_concurrent']
```
Using the name of a test we can start the automatic execution of the test. Most tests log their results directly to the **/tmp** directory.
**Warning**: Some tests use the same file names for every executed test. This might cause multiple runs of a test to overwrite old results. Please make sure to save any results that are worth preserving in a separate directory.
The test will execute all defined steps and then shut down the created topology.
## Extending the framework
### Creating tests
Tests can be added to any topology in the ```get_tests(self)``` function. Please use already implemented tests as a guideline for creating tests.
### Adding topologies
Topologies in our framework need to inherit from the *CustomTopo* class. This class defines 3 abstract methods, namely ```get_policies()```, ```get_tests()``` and ```get_routings()```. These need to be implemented by any topology used by our framework. Please use already existing topologies as a guideline for configuration. In addition to this, each topology should implement the ```build()``` method containing the actual creation of the topology using the Mininet python API.
After the topology was created and configured, it can now be added to the set of known topologies. Because the framework is not yet able to scan for new topologies itself, new topologies should be added to the ```topos``` dictionary in *mininet_controller.py*, using an identifier as key and supplying the class name, the module name and a description.
The topology should now be listed when listing all topologies and can be used in the test framework.
### Adding functions for tests
The *mininet_controller.py* contains a ```functions``` dictionary which references functions test configurations in topologies should be able to use. Each function is listed by name as a key and contains an attribute called *callable*, which contains a lambda call to the corresponding function. This is done to enable test configurations in topologies to reference said functions using these identifiers and sets of arguments, without actually knowing about existing functions.
Any function added to this dictionary can then be used to run tests.
Check file listener.log in execution directory and /tmp/shortcut.log.
### Errors in data or empty graphs
Check /tmp/{test_name}.out (raw output), /tmp/{test_name}_pre_parsed.out (filtered output), /tmp/{test_name}_parsed.out (extended and filtered output) or separate test folders for data collected by tests.
