mirror of
https://github.com/opennetworkinglab/onos.git
synced 2025-10-17 02:11:38 +02:00
116 lines
4.0 KiB
Python
116 lines
4.0 KiB
Python
#!/usr/bin/env python
|
|
from mininet.cli import CLI
|
|
from mininet.net import Mininet
|
|
from mininet.node import RemoteController, OVSKernelSwitch
|
|
|
|
MAC = 12
|
|
DPID = 16
|
|
|
|
class CustomCLI(CLI):
|
|
"""Custom CLI to allow us to add our own commands."""
|
|
|
|
def __init__ (self, net):
|
|
"""Init method for our custom CLI."""
|
|
self.net = net
|
|
CLI.__init__(self, net)
|
|
|
|
class Solar(object):
|
|
""" Create a tiered topology from semi-scratch in Mininet """
|
|
|
|
def __init__(self, cname='onos', cip='192.168.56.1', islands=3, edges=2, hosts=2,
|
|
proto=None):
|
|
"""Create tower topology for mininet"""
|
|
|
|
# We are creating the controller with local-loopback on purpose to avoid
|
|
# having the switches connect immediately. Instead, we'll set controller
|
|
# explicitly for each switch after configuring it as we want.
|
|
self.flare = RemoteController(cname, cip, 6633)
|
|
self.net = Mininet(controller=self.flare, switch = OVSKernelSwitch,
|
|
build=False)
|
|
|
|
self.cip = cip
|
|
self.spines = []
|
|
self.leaves = []
|
|
self.hosts = []
|
|
self.proto = proto
|
|
|
|
# Create the two core switches and links between them
|
|
c1 = self.net.addSwitch('c1',dpid='1111000000000000')
|
|
c2 = self.net.addSwitch('c2',dpid='2222000000000000')
|
|
self.spines.append(c1)
|
|
self.spines.append(c2)
|
|
|
|
self.net.addLink(c1, c2)
|
|
self.net.addLink(c2, c1)
|
|
|
|
for i in range(1, islands + 1):
|
|
sc = self.createSpineClump(i, edges, hosts)
|
|
self.net.addLink(c1, sc[0])
|
|
self.net.addLink(c2, sc[0])
|
|
self.net.addLink(c1, sc[1])
|
|
self.net.addLink(c2, sc[1])
|
|
|
|
def createSpineClump(self, island, edges, hosts):
|
|
""" Creates a clump of spine and edge switches with hosts"""
|
|
s1 = self.net.addSwitch('s%1d1' % island,dpid='00000%1d0100000000' % island)
|
|
s2 = self.net.addSwitch('s%1d2' % island,dpid='00000%1d0200000000' % island)
|
|
self.net.addLink(s1, s2)
|
|
self.net.addLink(s2, s1)
|
|
|
|
for i in range(1, edges + 1):
|
|
es = self.createEdgeSwitch(island, i, hosts)
|
|
self.net.addLink(es, s1)
|
|
self.net.addLink(es, s2)
|
|
|
|
self.spines.append(s1)
|
|
self.spines.append(s2)
|
|
|
|
clump = []
|
|
clump.append(s1)
|
|
clump.append(s2)
|
|
return clump
|
|
|
|
def createEdgeSwitch(self, island, index, hosts):
|
|
""" Creates an edge switch in an island and ads hosts to it"""
|
|
sw = self.net.addSwitch('e%1d%1d' % (island, index),dpid='0000000%1d0000000%1d' % (island, index))
|
|
self.leaves.append(sw)
|
|
|
|
for j in range(1, hosts + 1):
|
|
host = self.net.addHost('h%d%d%d' % (island, index, j),ip='10.%d.%d.%d' % (island, index, j))
|
|
self.net.addLink(host, sw)
|
|
self.hosts.append(host)
|
|
return sw
|
|
|
|
def run(self):
|
|
""" Runs the created network topology and launches mininet cli"""
|
|
self.run_silent()
|
|
CustomCLI(self.net)
|
|
self.net.stop()
|
|
|
|
def run_silent(self):
|
|
""" Runs silently - for unit testing """
|
|
self.net.build()
|
|
|
|
# Start the switches, configure them with desired protocols and only
|
|
# then set the controller
|
|
for sw in self.spines:
|
|
sw.start([self.flare])
|
|
if self.proto:
|
|
sw.cmd('ovs-vsctl set bridge %(sw)s protocols=%(proto)s' % \
|
|
{ 'sw': sw.name, 'proto': self.proto})
|
|
sw.cmdPrint('ovs-vsctl set-controller %(sw)s tcp:%(ctl)s:6633' % \
|
|
{'sw': sw.name, 'ctl': self.cip})
|
|
|
|
for sw in self.leaves:
|
|
sw.start([self.flare])
|
|
sw.cmdPrint('ovs-vsctl set-controller %(sw)s tcp:%(ctl)s:6633' % \
|
|
{'sw': sw.name, 'ctl': self.cip})
|
|
|
|
def pingAll(self):
|
|
""" PingAll to create flows - for unit testing """
|
|
self.net.pingAll()
|
|
|
|
def stop(self):
|
|
"Stops the topology. You should call this after run_silent"
|
|
self.net.stop()
|