Rumba is a Python framework that enables large-scale experimentation with the Recursive InterNetwork Architecture (RINA). It provides plugins that interface with different testbeds and prototypes. The document shows an example script that defines nodes and DIFs using the Rumba and rlite prototypes, runs the experiment on a JFed testbed, and starts a rinaperf client-server performance test between two nodes.

1. Rumba
A Python framework enabling large scale
experimentation with the Recursive InterNetwork
Architecture (RINA)

2. IPC FACILITY
X Y
Applications X and Y are known (instantiated by kernel)
Part of OS

3. IPC FACILITY
X Y
Port ID Port ID
flow
Flow allocation: reserves resources in the IPC facility and assigns port ID’s ~ fd’s
Applications X and Y are known (instantiated by kernel)
Part of OS
<port_id> alloc (pid, …);
dealloc (port_id);
Implementation dependent
Message passing
shared memory

4. IPC FACILITY
X Y
Port ID Port ID
flow
Flow allocation: reserves resources in the IPC facility and assigns port ID’s ~ fd’s
Applications X and Y are known (instantiated by kernel)
Part of OS
<port_id> alloc (pid, …);
<port_id> accept (…);
dealloc (port_id);
read/write (port_id, sdu *, len);
Implementation dependent
Message passing
shared memory
APPLICATION FACILITY
Connection (application protocol)

5. X Y
Applications X and Y -> need to register a name that is unique over both systems!

6. X Y
IPC process: provides IPC service.
Not only locally, but over 2 systems
Requires an IPC process component that
manages the medium (MAC)
Applications X and Y -> need to register a name that is unique over both systems!
IPC Process
IRM IRM
IPC Resource Manager
basically creates/destroys IPC processes.
Ideally: part of the OS

7. DISTRIBUTED IPC FACILITY
X Y
Port ID Port ID
flow IPC Process
Locating an application
if it’s not here, it’s over there… or doesn’t
exist.
Applications X and Y -> need to register a name that is unique over both systems!
reg(pid, name);
unreg(pid);
alloc (name, …);
dealloc (port_id);
IRMIRM

8. DISTRIBUTED APPLICATION FACILITY
DISTRIBUTED IPC FACILITY
X Y
Port ID Port ID
flow IPC Process
Locating an application
if it’s not here, it’s over there… or doesn’t
exist.
Applications X and Y -> need to register a name that is unique over both systems!
reg(pid, name);
unreg(pid);
alloc (name, …);
dealloc (port_id);
IRM IRM

9. X Y
C2 C1
A1 A2 B1 B2
E1 E2

10. X Y
C2 C1
A1 A2 B1 B2
E1 E2
Normal IPC Process
(IPCP)
D1

11. X Y
C2 C1
A1 A2 B1 B2
E1 E2
Provides IPC to higher layers (DIFs/DAFs)
Uses IPC from lower layers (DIFs)
Normal IPC Process
(IPCP)
D1

12. X Y
A1 A2 B1 B2
C2 C1 E1 E2D1
IPCP D1 registers in 2 DIFs (A, B)
D1/A2 D1/B1

13. X Y
A1 A2 B1 B2
C2 C1 E1 E2D1D2
D1/A2
D2/A1
D1/B1
Create IPCP D2, can register in DIF A (optional)

14. X Y
A1 A2 B1 B2
C2 C1 E1 E2D1D2
IPCP D2 allocates a flow with D1
D2 can now send messages to D1
D1/A2
D2/A1
D1/B1

15. X Y
A1 A2 B1 B2
C2 C1 E1 E2D1D2
A new operation: enrollment: “joining a DIF”
authentication
exchanging some basic information
configuration parameters
addresses
current equivalent: joining a wifi network
D1D2
D1/A2
D2/A1
D1/B1

16. X Y
A1 A2 B1 B2
C2 C1 E1 E2
D3 performs the same procedures. DIF “D” now has 3 members
D1 D3D2
D1/A2
D2/A1
D1/B1

17. X Y
A1 A2 B1 B2
C2 C1 E1 E2
F1 F2F3 F4
D1 D3D2

19. Rumba core
jFed plugin
Emulab plugin
QEMU VMs
plugin
IRATI plugin
rlite plugin
Ouroboros
plugin
User program

21. Node A Node B
DIF e1
DIF n1
rinaperf
client
rinaperf
server

22. #!/usr/bin/env python
# An example script using the rumba package
from rumba.model import *
# import testbed plugins
import rumba.testbeds.emulab as emulab
import rumba.testbeds.jfed as jfed
import rumba.testbeds.qemu as qemu
# import prototype plugins
import rumba.prototypes.ouroboros as our
import rumba.prototypes.rlite as rl
import rumba.prototypes.irati as irati
import rumba.log as log
log.set_logging_level('DEBUG')
n1 = NormalDIF("n1")
n1.add_policy("rmt.pff", "lfa")
n1.add_policy("security-manager", "passwd")
e1 = ShimEthDIF("e1")
a = Node("A",
difs = [n1, e1],
dif_registrations = {n1 : [e1]})
b = Node("B",
difs = [e1, n1],
dif_registrations = {n1 : [e1]},
client = True)
tb = jfed.Testbed(exp_name = "example1",
username = "user1",
cert_file = "/home/user1/cert.pem")
exp = rl.Experiment(tb, nodes = [a, b])
print(exp)
try:
exp.swap_in()
exp.bootstrap_prototype()
c1 = Client("rinaperf",
options ="-t perf -s 1000 -c 10000")
s1 = Server("rinaperf", arrival_rate=2,
mean_duration=5,
options = "-l",
nodes = [a],
clients = [c1])
sb = StoryBoard(exp, 3600, servers = [s1])
sb.start()
finally:
exp.swap_out()

23. C2 C1 E1 E2
F1 F2F3 F4
D1 D3D2
A1 A2 B1 B2
IPCPs for node a: [{IPCP=c2,DIF=c,N-1-DIFs=(),bootstrapper}, {IPCP=f3,DIF=f,N-1-DIFs=(c),bootstrapper}]
IPCPs for node b: [{IPCP=c1,DIF=c,N-1-DIFs=(),bootstrapper}, {IPCP=a1,DIF=a,N-1-DIFs=(),bootstrapper},
{IPCP=d2,DIF=d,N-1-DIFs=(a),bootstrapper}, {IPCP=f1,DIF=f,N-1-DIFs=(c d)}]
IPCPs for node c: [{IPCP=b1,DIF=b,N-1-DIFs=(),bootstrapper}, {IPCP=a2,DIF=a,N-1-DIFs=(),bootstrapper}, {IPCP=d1,DIF=d,N-1-DIFs=(a b)}]
IPCPs for node d: [{IPCP=b2,DIF=b,N-1-DIFs=(),bootstrapper}, {IPCP=e1,DIF=e,N-1-DIFs=(),bootstrapper}, {IPCP=d3,DIF=d,N-1-DIFs=(b)},
{IPCP=f2,DIF=f,N-1-DIFs=(e d)}]
IPCPs for node e: [{IPCP=e2,DIF=e,N-1-DIFs=(),bootstrapper}, {IPCP=f4,DIF=f,N-1-DIFs=(e),bootstrapper}]
Node a Node b Node c Node d Node e

24. Client Server
Client
Client
Client
Server
Server
Server

27. Node DNode A Node B
DIF e1
Node C
DIF e2
DIF n1
DIF e3
DIF n2

28. Sander Vrijders (sander.vrijders@ugent.be)
Vincenzo Maffione (v.maffione@nextworks.it)
Marco Capitani (m.capitani@nextworks.it)