mirror of
https://github.com/opennetworkinglab/onos.git
synced 2025-10-28 14:51:37 +01:00
4f23b0a5e7
ref: https://wiki.onosproject.org/display/ONOS/Metro+Network+Emulation Change-Id: Icb8dd7a12587398af49e9acea23a7cb85fb84b88
218 lines
7.4 KiB
Python
Executable File
218 lines
7.4 KiB
Python
Executable File
#!/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)
|