Further tests for resource model api

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

diff --git a/src/emuvim/dcemulator/resourcemodel/__init__.py b/src/emuvim/dcemulator/resourcemodel/__init__.py
index 6ddd459..52a35e5 100644 (file)
--- a/src/emuvim/dcemulator/resourcemodel/__init__.py
+++ b/src/emuvim/dcemulator/resourcemodel/__init__.py
@@ -8,6 +8,9 @@ LOG.setLevel(logging.DEBUG)
 
 
 class ResourceModelRegistrar(object):
+    """
+    Global registry to keep track of all existing resource models.
+    """
 
     def __init__(self, dc_emulation_max_cpu):
         self.e_cpu = dc_emulation_max_cpu
@@ -16,32 +19,57 @@ class ResourceModelRegistrar(object):
         LOG.info("Resource model registrar created with dc_emulation_max_cpu=%r" % dc_emulation_max_cpu)
 
     def register(self, dc, rm):
+        """
+        Register a new resource model.
+        :param dc: Data center to which it is assigned.
+        :param rm: The resource model object.
+        :return: None
+        """
         if dc in self._resource_models:
             raise Exception("There is already an resource model assigned to this DC.")
         self._resource_models[dc] = rm
+        rm.registrar = self
         LOG.info("Registrar: Added resource model: %r" % rm)
 
+    @property
+    def resource_models(self):
+        return list(self._resource_models.itervalues())
 
-class ResourceFlavor(object):
 
+class ResourceFlavor(object):
+    """
+    Simple class that represents resource flavors (c.f. OpenStack).
+    Can contain arbitrary metrics.
+    """
     def __init__(self, name, metrics):
         self.name = name
-        self.metrics = metrics
+        self._metrics = metrics
         LOG.debug("Create flavor %r with metrics: %r" % (name, metrics))
 
+    def get(self, metric_key):
+        return self._metrics.get(metric_key)
+
 
 class BaseResourceModel(object):
+    """
+    Base class for a resource limitation model.
+    Has to be extended by a real resource model implementtion.
+    """
 
     def __init__(self):
-        self._flavors=dict()
+        self._flavors = dict()
         self._initDefaultFlavors()
+        self.registrar = None  # pointer to registrar
+        self.allocated_compute_instances = dict()
         LOG.info("Resource model %r initialized" % self)
 
     def __repr__(self):
         return self.__class__.__name__
 
     def _initDefaultFlavors(self):
-        # initialize some default flavours (inspired by OpenStack)
+        """
+        initialize some default flavours (naming/sizes inspired by OpenStack)
+        """
         self.addFlavour(ResourceFlavor(
             "tiny",  {"compute": 1, "memory": 32, "disk": 1}))
         self.addFlavour(ResourceFlavor(
@@ -54,14 +82,32 @@ class BaseResourceModel(object):
             "xlarge",  {"compute": 32, "memory": 1024, "disk": 160}))
 
     def addFlavour(self, fl):
+        """
+        Add a new flavor to the resource model.
+        :param fl: flavor object
+        :return: None
+        """
         if fl.name in self._flavors:
             raise Exception("Flavor with name %r already exists!" % fl.name)
         self._flavors[fl.name] = fl
 
     def allocate(self, name, flavor_name):
-        LOG.info("RM-ALLOCATE: %r with flavor: %r" % (name, flavor_name))
-        return 0.0, 0.0, 0.0
+        """
+        This method has to be overwritten by a real resource model.
+        :param name: Name of the started compute instance.
+        :param flavor_name:  Name of the flavor to be allocated.
+        :return: 3-tuple: (CPU-fraction, Mem-limit, Disk-limit)
+        """
+        LOG.warning("Allocating in BaseResourceModel: %r with flavor: %r" % (name, flavor_name))
+        self.allocated_compute_instances[name] = flavor_name
+        return -1.0, -1.0, -1.0  # return invalid values to indicate that this RM is a dummy
 
     def free(self, name):
-        LOG.info("RM-FREE: %r" % name)
-
+        """
+        This method has to be overwritten by a real resource model.
+        :param name: Name of the compute instance that is stopped.
+        :return: True/False
+        """
+        LOG.warning("Free in BaseResourceModel: %r" % name)
+        del self.allocated_compute_instances[name]
+        return True