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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
#!/usr/bin/env python
from mininet.net import Mininet
from mininet.node import UserSwitch, DefaultController, RemoteController, Host
from mininet.topo import Topo
from mininet.log import setLogLevel, info
from mininet.cli import CLI
from mininet.link import OVSIntf
from opticalUtils import LINCSwitch, LINCLink
class Domain(object):
"""
A container for switch, host, link, and controller information to be dumped
into the Mininet mid-level API.
"""
def __init__ (self, did=0):
# each Domain has a numeric ID for sanity/convenience
self.__dId = did
# information about network elements - for calling the "mid-level" APIs
self.__ctrls = {}
self.__switches = {}
self.__hosts = {}
self.__links = {}
# maps of devices, hosts, and controller names to actual objects
self.__smap = {}
self.__hmap = {}
self.__cmap = {}
def addController(self, name, **args):
self.__ctrls[name] = args if args else {}
return name
def addSwitch(self, name, **args):
self.__switches[name] = args if args else {}
return name
def addHost(self, name, **args):
self.__hosts[name] = args if args else {}
return name
def addLink(self, src, dst, **args):
self.__links[(src, dst)] = args if args else {}
return (src, dst)
def getId( self):
return self.__dId
def getControllers(self, name=None):
return self.__cmap.values() if not name else self.__cmap.get(name)
def getSwitches(self, name=None):
return self.__smap.values() if not name else self.__smap.get(name)
def getHosts(self, name=None):
return self.__hmap.values() if not name else self.__hmap.get(name)
def injectInto(self, net):
""" Adds available topology info to a supplied Mininet object. """
# add switches, hosts, then links to mininet object
for sw, args in self.__switches.iteritems():
self.__smap[sw] = net.addSwitch(sw, **args)
for h, args in self.__hosts.iteritems():
self.__hmap[h] = net.addHost(h, **args)
for l, args in self.__links.iteritems():
src = self.__smap.get(l[0])
dst = self.__smap.get(l[1])
net.addLink(src if src else self.__hmap.get(l[0]),
dst if dst else self.__hmap.get(l[1]), **args)
# then controllers
for c, args in self.__ctrls.iteritems():
self.__cmap[c] = net.addController(c, **args)
def start(self):
""" starts the switches with the correct controller. """
map(lambda c: c.start(), self.__cmap.values())
map(lambda s: s.start(self.__cmap.values()), self.__smap.values())
def build(self, *args):
""" override for custom topology, similar to Topo """
pass
class OpticalDomain(Domain):
""" An emulated optical metro core. It is Domain 0. """
def build(self):
oean = { "optical.regens": 0 }
for i in range (1,4):
self.addSwitch('OE%s' % i, dpid='0000ffffffffff0%s' % i, annotations=oean, cls=LINCSwitch)
an = { "optical.waves": 80, "optical.type": "WDM", "optical.kms": 1000, "durable": "true" }
self.addLink('OE1', 'OE2', port1=50, port2=30, annotations=an, cls=LINCLink)
self.addLink('OE2', 'OE3', port1=50, port2=30, annotations=an, cls=LINCLink)
self.addLink('OE3', 'OE1', port1=50, port2=30, annotations=an, cls=LINCLink)
class FabricDomain(Domain):
"""
An emulated CO fabric, which is basically a K(n,m) bipartite graph.
Each FabricDomain should be given a unique Domain ID (did) to ensure unique
names and addressing.
"""
def __init__(self, did):
Domain.__init__(self, did)
def build(self, n=2, m=3, f=2):
# K(n,m) in bipartite graph
l_nsw=[]
l_msw=[]
# create n spine switches
for sw in range(n):
l_nsw.append(self.addSwitch('swn%s%s' % (self.getId(), sw+1), cls=UserSwitch))
# create connection point to optical core (a leaf switch)
tsw = self.addSwitch('swm%s01' % self.getId(), cls=UserSwitch)
self.addTether(tsw, 'sw000%s' % self.getId(), '0000ffffffff000%s' % self.getId())
l_msw.append(tsw)
# attach f hosts to last m-1 leaves
for sw in range(1, m):
msw = self.addSwitch('swm%s0%s' % (self.getId(), sw+1), cls=UserSwitch)
l_msw.append(msw)
for h in range(f):
host = self.addHost('h%s%s' % (self.getId(), sw * f+h+1), cls=IpHost,
ip='10.0.%s.%s/24' % ((self.getId()+sw+1), (f+1)),
gateway='10.0.%s.254' % (self.getId()+sw+1))
self.addLink(host, msw)
# link up spines and leaves
for nsw in l_nsw:
for msw in l_msw:
self.addLink(nsw, msw)
def addTether(self, name, tname, tdpid):
"""
add an OVS with name 'tname' and dpid 'tdpid' for connecting fabric
domains to the core. name: the UserSwitch to connect the OVS to.
"""
self.__tether = self.addSwitch(tname, dpid=tdpid)
self.addLink(tname, name, port1=1)
def getTether(self):
""" get connection point of this fabric to the core """
return self.__tether
class IpHost(Host):
def __init__(self, name, gateway, *args, **kwargs):
super(IpHost, self).__init__(name, *args, **kwargs)
self.gateway = gateway
def config(self, **kwargs):
Host.config(self, **kwargs)
mtu = "ifconfig "+self.name+"-eth0 mtu 1490"
self.cmd(mtu)
self.cmd('ip route add default via %s' % self.gateway)
# fixed port numbers for attachment points (APs) between CORD and metro domains
OVS_AP=2
OE_AP=10
def setup(argv):
domains = []
ctlsets = sys.argv[1:]
# the controllers for the optical domain
d0 = OpticalDomain()
domains.append(d0)
ctls = ctlsets[0].split(',')
for i in range (len(ctls)):
d0.addController('c0%s' % i, controller=RemoteController, ip=ctls[i])
# the fabric domains - position 1 for domain 1, 2 for 2 ...
for i in range (1,len(ctlsets)):
f = FabricDomain(i)
domains.append(f)
ctls = ctlsets[i].split(',')
for j in range (len(ctls)):
f.addController('c%s%s' % (i,j), controller=RemoteController, ip=ctls[j])
# make/setup Mininet object
net = Mininet()
for d in domains:
d.build()
d.injectInto(net)
# connect COs to core - sort of hard-wired at this moment
for i in range(1,len(domains)):
an = { "bandwidth": 100000, "optical.type": "cross-connect", "durable": "true" }
net.addLink(domains[i].getTether(), d0.getSwitches('OE%s' % i),
port1=OVS_AP, port2=OE_AP, speed=10000, annotations=an, cls=LINCLink)
# fire everything up
net.build()
map(lambda x: x.start(), domains)
# create a minimal copy of the network for configuring LINC.
cfgnet = Mininet()
cfgnet.switches = net.switches
cfgnet.links = net.links
cfgnet.controllers = d0.getControllers()
LINCSwitch.bootOE(cfgnet, d0.getSwitches())
CLI(net)
net.stop()
LINCSwitch.shutdownOE()
if __name__ == '__main__':
setLogLevel('info')
import sys
if len(sys.argv) < 5:
print ("Usage: sudo -E ./metro.py ctl-set1 ... ctl-set4\n\n",
"Where ctl-set are comma-separated controller IP's")
else:
setup(sys.argv)
|
