Rumba - a Python framework enabling large-scale experimentation with RINA

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)