aboutsummaryrefslogtreecommitdiff
path: root/README.md
blob: cbe1015d54a4d8f3f97d12b4715386de5e826f36 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
# Rumba: A framework to install, bootstrap a RINA network

Rumba is part of ARCFIRE 2020, Work Package 3. It is a framework in
Python which allows user to write a Python script to define a RINA
network. The physical graph needed for this RINA network is then
calculated and realised on one of the supported testbeds. Next, if the
user requests this, one of the supported RINA prototypes is
installed. The network is then bootstrapped on the available
nodes. Finally, the experiment can be swapped out of the testbed. For
an example of such a Python script, have a look at the examples/
folder.

## Workflow, both external and internal:

  1. User defines the network graph, creating instances of model.Node
     and model.DIF classes

  2. User creates an instance of a Testbed class. See below for
     testbed specific configuration

  3. User creates an instance of prototype.Experiment class, passing
     the testbed instance and a list of Node instances

    1. At the end of the base Experiment constructor, the
       generate function is called to generate information about
       per-node IPCPs, registrations and enrollment, ready to be
       used by the plugins

  4. User calls methods on the prototype.Experiment instance:

    1. swap_in() swaps the experiment in on the testbed, and fills in
       the missing information in the model.

    2. install_prototype() installs the chosen prototype on the
       testbed. Currently an Ubuntu image is assumed.

    3. bootstrap_prototype() calls a prototype-specific setup function,
       to create the required IPCPs, perform registrations,
       enrollments, etc.

    4. swap_out() swaps the experiment out of the testbed.

## Installation

   For Debian and Ubuntu, the following command will ensure that the
   required dependencies are installed (replace python-dev with python3-dev
   if using Python 3):

      # apt-get install build-essential libssl-dev libffi-dev python-dev

   Rumba can be found on the
   [PyPi](https://pypi.python.org/pypi/Rumba) and can thus be
   installed through pip, by using `pip install rumba`. However, to
   install the latest version, after cloning the repository, a user
   can also issue `python setup.py install`.


## Supported prototypes

 * [IRATI](https://github.com/IRATI/stack) is an open source
   implementation of the RINA architecture targeted at the OS/Linux
   system, initially developed by the FP7-IRATI project.

 * [rlite](https://github.com/vmaffione/rlite) is a lightweight Free
   and Open Source implementation of the Recursive InterNetwork
   Architecture (RINA) for GNU/Linux operating systems.

 * Ouroboros is a user-space implementation of RINA with a focus on
   portability. It is written in C89 and works on any POSIX.1-2008
   enabled system.

## Supported testbeds

 * [QEMU](http://wiki.qemu-project.org/Main_Page) is a generic and
   open source machine emulator and virtualizer.

   A minimal QEMU testbed is defined as follows:

       tb = qemu.Testbed(exp_name = "twolayers",
                         username = "root",
                         password = "root")

   A user can optionally also specify the path to a bzImage and to an
   initramfs. If they are not specified, the latest buildroot image
   for the specific prototype will be downloaded. (Around 40 MB in
   size) The login to those images is root/root.

 * [Emulab](https://www.emulab.net/) is a network testbed, giving
   researchers a wide range of environments in which to develop,
   debug, and evaluate their systems.

   An emulab testbed instance is defined as follows:

       tb = emulab.Testbed(exp_name = "rochefort10",
                           username = "ricksanchez")

   A password can also be provided but is not necessary when an SSH
   key has been added. Optionally, a project name, a different testbed
   URL and a custom image can be specified.

 * [jFed](http://jfed.iminds.be/) is a Java-based framework for
   testbed federation.

   In order to use the jFed testbed, a user first needs to download
   his/her key from
   [https://authority.ilabt.iminds.be/](https://authority.ilabt.iminds.be/)
   After logging in, click on *Download your certificate*. Save the
   contents in a file (for example cert.pem). A jFed testbed instance
   is defined as follows:

       tb = jfed.Testbed(exp_name = "rochefort10",
                         username = "ricksanchez",
                         cert_file = "/home/morty/cert.pem")

   Here the experiment name is rochefort10, the user's name is
   ricksanchez, and the certificate can be found in
   /home/morty/cert.pem. An absolute path must be used for
   cert_file. Optionally a custom image can be selected.

   Before running the rumba you must run an SSH agent in same terminal.
   This will also avoid you having to enter the passphrase for every
   login to a node by the framework if you are not on an IPv6 enabled network.
   (Apart from asking for the passphrase to login to the nodes, the framework
   will always ask for the passphrase since it is needed by the jFed
   CLI as well.) In order to start an SSH agent and to add the
   certificate, type the following commands:

       $ eval `ssh-agent`
       $ ssh-add /home/morty/cert.pem

   To access a node once the experiment swapped in, use the following
   command (in the same terminal where ssh-agent was run):

       $ ssh -A -oProxyCommand="ssh -i $CERTPATH
            -o StrictHostKeyChecking=no $USER@bastion.test.iminds.be
            nc $NODENAME.$EXP.wall2-ilabt-iminds-be.wall2.ilabt.iminds.be 22"
            $USER@$NODENAME.$EXP.wall2-ilabt-iminds-be.wall2.ilabt.iminds.be

   where $CERTPATH is the absolute path of the certificate (e.g.
   /home/morty/cert.pem), $USER is the jFed username (e.g. "ricksanchez"),
   $NODENAME is the name of the node you want to access (e.g. "a"),
   and $EXP is the name of the experiment (e.g. "rochefort10").