"""
import logging
-from mininet.net import Mininet
-from mininet.node import Controller, OVSKernelSwitch, Switch
+from mininet.net import Dockernet
+from mininet.node import Controller, OVSKernelSwitch, Switch, Docker, Host
from mininet.cli import CLI
from mininet.log import setLogLevel, info
from mininet.link import TCLink, Link
-from node import Datacenter
+from node import Datacenter, EmulatorCompute
-class DCNetwork(object):
+class DCNetwork(Dockernet):
"""
- Wraps the original Mininet class and provides
+ Wraps the original Mininet/Dockernet class and provides
methods to add data centers, switches, etc.
This class is used by topology definition scripts.
"""
- def __init__(self):
+ def __init__(self, **kwargs):
self.dcs = {}
- self.switches = {}
- self.links = []
-
# create a Mininet/Dockernet network
- setLogLevel('info') # set Mininet loglevel
- self.mnet = Mininet(controller=Controller, switch=OVSKernelSwitch)
- self.mnet.addController('c0')
+ # call original Docker.__init__ and setup default controller
+ Dockernet.__init__(
+ self, controller=Controller, switch=OVSKernelSwitch, **kwargs)
+ self.addController('c0')
- def addDatacenter(self, name):
+ def addDatacenter(self, label, metadata={}):
"""
Create and add a logical cloud data center to the network.
"""
- if name in self.dcs:
- raise Exception("Data center name already exists: %s" % name)
- dc = Datacenter(name)
+ if label in self.dcs:
+ raise Exception("Data center label already exists: %s" % label)
+ dc = Datacenter(label, metadata=metadata)
dc.net = self # set reference to network
- self.dcs[name] = dc
+ self.dcs[label] = dc
dc.create() # finally create the data center in our Mininet instance
- logging.info("added data center: %s" % name)
+ logging.info("added data center: %s" % label)
return dc
- def addSwitch(self, name):
+ def addLink(self, node1, node2, **params):
"""
- We can also add additional SDN switches between data centers.
+ Able to handle Datacenter objects as link
+ end points.
"""
- s = self.mnet.addSwitch(name)
- self.switches[name] = s
- logging.info("added switch: %s" % name)
- return s
-
- def addLink(self, node1, node2):
assert node1 is not None
assert node2 is not None
+ logging.debug("addLink: n1=%s n2=%s" % (str(node1), str(node2)))
# ensure type of node1
if isinstance( node1, basestring ):
if node1 in self.dcs:
node1 = self.dcs[node1].switch
- elif node1 in self.switches:
- node1 = self.switches[node1]
if isinstance( node1, Datacenter ):
node1 = node1.switch
# ensure type of node2
if isinstance( node2, basestring ):
if node2 in self.dcs:
node2 = self.dcs[node2].switch
- elif node2 in self.switches:
- node2 = self.switches[node2]
if isinstance( node2, Datacenter ):
node2 = node2.switch
- # create link if everything is correct
- if (node1 is not None and isinstance(node1, OVSKernelSwitch)
- and node2 is not None and isinstance(node2, OVSKernelSwitch)):
- self.mnet.addLink(node1, node2) # TODO we need TCLinks with user defined performance here
- else:
- raise Exception(
- "one of the given nodes is not a Mininet switch or None")
+ # try to give containers a default IP
+ if isinstance( node1, Docker ):
+ if not "params1" in params:
+ params["params1"] = {}
+ if not "ip" in params["params1"]:
+ params["params1"]["ip"] = self.getNextIp()
+ if isinstance( node2, Docker ):
+ if not "params2" in params:
+ params["params2"] = {}
+ if not "ip" in params["params2"]:
+ params["params2"]["ip"] = self.getNextIp()
+
+ return Dockernet.addLink(self, node1, node2, **params) # TODO we need TCLinks with user defined performance here
+
+ def addDocker( self, label, **params ):
+ """
+ Wrapper for addDocker method to use custom container class.
+ """
+ return Dockernet.addDocker(self, label, cls=EmulatorCompute, **params)
+
+ def getAllContainers(self):
+ """
+ Returns a list with all containers within all data centers.
+ """
+ all_containers = []
+ for dc in self.dcs.itervalues():
+ all_containers += dc.listCompute()
+ return all_containers
def start(self):
# start
for dc in self.dcs.itervalues():
dc.start()
- self.mnet.start()
+ Dockernet.start(self)
def stop(self):
- self.mnet.stop()
+ Dockernet.stop(self)
def CLI(self):
- CLI(self.mnet)
+ CLI(self)