Connected respurce model outputs for CPU limits to Dockernet API. Closes #47

[osm/vim-emu.git] / src / emuvim / dcemulator / node.py

diff --git a/src/emuvim/dcemulator/node.py b/src/emuvim/dcemulator/node.py
index 74540ab..7746e9e 100755 (executable)
--- a/src/emuvim/dcemulator/node.py
+++ b/src/emuvim/dcemulator/node.py
@@ -6,6 +6,9 @@ from mininet.node import Docker
 from mininet.link import Link
 import logging
 
+LOG = logging.getLogger("dcemulator")
+LOG.setLevel(logging.DEBUG)
+
 
 DCDPID_BASE = 1000  # start of switch dpid's used for data center switches
 
@@ -21,9 +24,9 @@ class EmulatorCompute(Docker):
 
     def __init__(
             self, name, dimage, **kwargs):
-        logging.debug("Create EmulatorCompute instance: %s" % name)
-        self.datacenter = None  # pointer to current DC
-
+        self.datacenter = kwargs.get("datacenter")  # pointer to current DC
+        self.flavor_name = kwargs.get("flavor_name")
+        LOG.debug("Starting compute instance %r in data center %r" % (name, str(self.datacenter)))
         # call original Docker.__init__
         Docker.__init__(self, name, dimage, **kwargs)
 
@@ -77,8 +80,15 @@ class Datacenter(object):
         self.label = label  
         # dict to store arbitrary metadata (e.g. latitude and longitude)
         self.metadata = metadata
-        self.switch = None  # first prototype assumes one "bigswitch" per DC
-        self.containers = {}  # keep track of running containers
+        # first prototype assumes one "bigswitch" per DC
+        self.switch = None
+        # keep track of running containers
+        self.containers = {}
+        # pointer to assigned resource model
+        self._resource_model = None
+
+    def __repr__(self):
+        return self.label
 
     def _get_next_dc_dpid(self):
         global DCDPID_BASE
@@ -95,12 +105,12 @@ class Datacenter(object):
         """
         self.switch = self.net.addSwitch(
             "%s.s1" % self.name, dpid=hex(self._get_next_dc_dpid())[2:])
-        logging.debug("created data center switch: %s" % str(self.switch))
+        LOG.debug("created data center switch: %s" % str(self.switch))
 
     def start(self):
         pass
 
-    def startCompute(self, name, image=None, command=None, network=None):
+    def startCompute(self, name, image=None, command=None, network=None, flavor_name="tiny"):
         """
         Create a new container as compute resource and connect it to this
         data center.
@@ -108,6 +118,7 @@ class Datacenter(object):
         :param image: image name (string)
         :param command: command (string)
         :param network: networks list({"ip": "10.0.0.254/8"}, {"ip": "11.0.0.254/24"})
+        :param flavor_name: name of the flavor for this compute container
         :return:
         """
         assert name is not None
@@ -125,15 +136,44 @@ class Datacenter(object):
             if len(network) < 1:
                 network.append({})
 
+        # allocate in resource resource model and compute resource limits for new container
+        cpu_limit = mem_limit = disk_limit = -1
+        cpu_period = cpu_quota = None
+        if self._resource_model is not None:
+            # call allocate in resource model to calculate resource limit for this container
+            (cpu_limit, mem_limit, disk_limit) = alloc = self._resource_model.allocate(name, flavor_name)
+            LOG.debug("Allocation result: %r" % str(alloc))
+            # check if we have a cpu_limit given by the used resource model
+            if cpu_limit > 0:
+                # calculate cpu period and quota for CFS
+                # (see: https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt)
+                # TODO consider multi core machines etc! non trivial!
+                # Attention minimum cpu_quota is 1ms (micro)
+                cpu_period = 100000  # lets consider a fixed period of 100000 microseconds for now
+                cpu_quota = cpu_period * cpu_limit  # calculate the fraction of cpu time for this container
+                LOG.debug(
+                    "CPU limit: cpu_quota = cpu_period * cpu_limit = %f * %f = %f" % (cpu_period, cpu_limit, cpu_quota))
+                # ATTENTION >= 1000 to avoid a invalid argument system error ... no idea why
+                if cpu_quota < 1000:
+                    cpu_quota = 1000
+                    LOG.warning("Increased CPU quota for %d to avoid system error." % name)
+            # TODO add memory and disc limitations
         # create the container
-        d = self.net.addDocker("%s" % (name), dimage=image, dcmd=command)
+        d = self.net.addDocker(
+            "%s" % (name),
+            dimage=image,
+            dcmd=command,
+            datacenter=self,
+            flavor_name=flavor_name,
+            cpu_period=int(cpu_period) if cpu_limit > 0 else None,  # set cpu limits if needed
+            cpu_quota=int(cpu_quota) if cpu_limit > 0 else None,
+        )
         # connect all given networks
         for nw in network:
             # TODO we cannot use TCLink here (see: https://github.com/mpeuster/dockernet/issues/3)
             self.net.addLink(d, self.switch, params1=nw, cls=Link)
         # do bookkeeping
         self.containers[name] = d
-        d.datacenter = self
         return d  # we might use UUIDs for naming later on
 
     def stopCompute(self, name):
@@ -147,6 +187,9 @@ class Datacenter(object):
             link=None, node1=self.containers[name], node2=self.switch)
         self.net.removeDocker("%s" % (name))
         del self.containers[name]
+        # call resource model and free resources
+        if self._resource_model is not None:
+            self._resource_model.free(name)
         return True
 
     def listCompute(self):
@@ -167,3 +210,16 @@ class Datacenter(object):
             "n_running_containers": len(self.containers),
             "metadata": self.metadata
         }
+
+    def assignResourceModel(self, rm):
+        """
+        Assign a resource model to this DC.
+        :param rm: a BaseResourceModel object
+        :return:
+        """
+        if self._resource_model is not None:
+            raise Exception("There is already an resource model assigned to this DC.")
+        self._resource_model = rm
+        self.net.rm_registrar.register(self, rm)
+        LOG.info("Assigned RM: %r to DC: %r" % (rm, self))
+