X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=src%2Femuvim%2Ftest%2Ftest_resourcemodel_api.py;h=a11bc8b96c7c9a0f7e0671a5cf86c6b25cc803a4;hb=3055e70eb50125372d5f7b8892b185f8e6e7349b;hp=f31f3e4e5cba7247e1940463eb1e35508e2a20b2;hpb=43485a2ebb3d8354511108b962caba41c16cc8de;p=osm%2Fvim-emu.git

diff --git a/src/emuvim/test/test_resourcemodel_api.py b/src/emuvim/test/test_resourcemodel_api.py
index f31f3e4..a11bc8b 100644
--- a/src/emuvim/test/test_resourcemodel_api.py
+++ b/src/emuvim/test/test_resourcemodel_api.py
@@ -1,24 +1,35 @@
 import time
+import os
 from emuvim.test.base import SimpleTestTopology
 from emuvim.dcemulator.resourcemodel import BaseResourceModel, ResourceFlavor
+from emuvim.dcemulator.resourcemodel.upb.simple import UpbSimpleCloudDcRM
+from emuvim.dcemulator.resourcemodel import ResourceModelRegistrar
 
 
 class testResourceModel(SimpleTestTopology):
+    """
+    Test the general resource model API and functionality.
+    """
 
     def testBaseResourceModelApi(self):
+        """
+        Tast bare API without real resource madel.
+        :return:
+        """
         r = BaseResourceModel()
         # check if default flavors are there
-        assert(len(r._flavors) == 5)
+        self.assertTrue(len(r._flavors) == 5)
         # check addFlavor functionality
         f = ResourceFlavor("test", {"testmetric": 42})
         r.addFlavour(f)
-        assert("test" in r._flavors)
-        assert(r._flavors.get("test").get("testmetric") == 42)
-        # test if allocate and free runs through
-        assert(len(r.allocate("testc", "tiny")) == 3)  # expected: 3tuple
-        assert(r.free("testc"))
+        self.assertTrue("test" in r._flavors)
+        self.assertTrue(r._flavors.get("test").get("testmetric") == 42)
 
     def testAddRmToDc(self):
+        """
+        Test is allocate/free is called when a RM is added to a DC.
+        :return:
+        """
         # create network
         self.createNet(nswitches=0, ndatacenter=1, nhosts=2, ndockers=0)
         # setup links
@@ -30,22 +41,223 @@ class testResourceModel(SimpleTestTopology):
         # start Mininet network
         self.startNet()
         # check number of running nodes
-        assert(len(self.getDockernetContainers()) == 0)
-        assert(len(self.net.hosts) == 2)
-        assert(len(self.net.switches) == 1)
+        self.assertTrue(len(self.getDockernetContainers()) == 0)
+        self.assertTrue(len(self.net.hosts) == 2)
+        self.assertTrue(len(self.net.switches) == 1)
         # check resource model and resource model registrar
-        assert(self.dc[0]._resource_model is not None)
-        assert(self.net.rm_registrar.num_models == 1)
+        self.assertTrue(self.dc[0]._resource_model is not None)
+        self.assertTrue(len(self.net.rm_registrar.resource_models) == 1)
 
         # check if alloc was called during startCompute
-        assert(len(r.allocated_compute_instances) == 0)
+        self.assertTrue(len(r._allocated_compute_instances) == 0)
         self.dc[0].startCompute("tc1")
         time.sleep(1)
-        assert(len(r.allocated_compute_instances) == 1)
+        self.assertTrue(len(r._allocated_compute_instances) == 1)
         # check if free was called during stopCompute
         self.dc[0].stopCompute("tc1")
-        assert(len(r.allocated_compute_instances) == 0)
+        self.assertTrue(len(r._allocated_compute_instances) == 0)
         # check connectivity by using ping
-        assert(self.net.ping([self.h[0], self.h[1]]) <= 0.0)
+        self.assertTrue(self.net.ping([self.h[0], self.h[1]]) <= 0.0)
         # stop Mininet network
         self.stopNet()
+
+
+def createDummyContainerObject(name, flavor):
+
+    class DummyContainer(object):
+
+        def __init__(self):
+            self.cpu_period = -1
+            self.cpu_quota = -1
+            self.mem_limit = -1
+            self.memswap_limit = -1
+
+        def updateCpuLimit(self, cpu_period, cpu_quota):
+            self.cpu_period = cpu_period
+            self.cpu_quota = cpu_quota
+
+        def updateMemoryLimit(self, mem_limit):
+            self.mem_limit = mem_limit
+
+    d = DummyContainer()
+    d.name = name
+    d.flavor_name = flavor
+    return d
+
+
+
+
+class testUpbSimpleCloudDcRM(SimpleTestTopology):
+    """
+    Test the UpbSimpleCloudDc resource model.
+    """
+
+    def testAllocation(self):
+        """
+        Test the allocation procedures and correct calculations.
+        :return:
+        """
+        # config
+        E_CPU = 1.0
+        MAX_CU = 100
+        E_MEM = 512
+        MAX_MU = 2048
+        # create dummy resource model environment
+        reg = ResourceModelRegistrar(dc_emulation_max_cpu=E_CPU, dc_emulation_max_mem=E_MEM)
+        rm = UpbSimpleCloudDcRM(max_cu=MAX_CU, max_mu=MAX_MU)
+        reg.register("test_dc", rm)
+
+        c1 = createDummyContainerObject("c1", flavor="tiny")
+        rm.allocate(c1)  # calculate allocation
+        self.assertEqual(float(c1.cpu_quota) / c1.cpu_period, E_CPU / MAX_CU * 0.5)   # validate compute result
+        self.assertEqual(float(c1.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 32)   # validate memory result
+
+        c2 = createDummyContainerObject("c2", flavor="small")
+        rm.allocate(c2)  # calculate allocation
+        self.assertEqual(float(c2.cpu_quota) / c2.cpu_period, E_CPU / MAX_CU * 1)   # validate compute result
+        self.assertEqual(float(c2.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128)   # validate memory result
+
+
+        c3 = createDummyContainerObject("c3", flavor="medium")
+        res = rm.allocate(c3)  # calculate allocation
+        self.assertEqual(float(c3.cpu_quota) / c3.cpu_period, E_CPU / MAX_CU * 4)   # validate compute result
+        self.assertEqual(float(c3.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 256)   # validate memory result
+
+
+        c4 = createDummyContainerObject("c4", flavor="large")
+        rm.allocate(c4)  # calculate allocation
+        self.assertEqual(float(c4.cpu_quota) / c4.cpu_period, E_CPU / MAX_CU * 8)   # validate compute result
+        self.assertEqual(float(c4.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 512)   # validate memory result
+
+
+        c5 = createDummyContainerObject("c5", flavor="xlarge")
+        rm.allocate(c5)  # calculate allocation
+        self.assertEqual(float(c5.cpu_quota) / c5.cpu_period, E_CPU / MAX_CU * 16)   # validate compute result
+        self.assertEqual(float(c5.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 1024)   # validate memory result
+
+
+    def testAllocationCpuLimit(self):
+        """
+        Test CPU allocation limit
+        :return:
+        """
+        # config
+        E_CPU = 1.0
+        MAX_CU = 40
+        E_MEM = 512
+        MAX_MU = 4096
+        # create dummy resource model environment
+        reg = ResourceModelRegistrar(dc_emulation_max_cpu=E_CPU, dc_emulation_max_mem=E_MEM)
+        rm = UpbSimpleCloudDcRM(max_cu=MAX_CU, max_mu=MAX_MU)
+        reg.register("test_dc", rm)
+
+        # test over provisioning exeption
+        exception = False
+        try:
+            c6 = createDummyContainerObject("c6", flavor="xlarge")
+            c7 = createDummyContainerObject("c7", flavor="xlarge")
+            c8 = createDummyContainerObject("c8", flavor="xlarge")
+            c9 = createDummyContainerObject("c9", flavor="xlarge")
+            rm.allocate(c6)  # calculate allocation
+            rm.allocate(c7)  # calculate allocation
+            rm.allocate(c8)  # calculate allocation
+            rm.allocate(c9)  # calculate allocation
+        except Exception as e:
+            self.assertIn("Not enough compute", e.message)
+            exception = True
+        self.assertTrue(exception)
+
+    def testAllocationMemLimit(self):
+        """
+        Test MEM allocation limit
+        :return:
+        """
+        # config
+        E_CPU = 1.0
+        MAX_CU = 500
+        E_MEM = 512
+        MAX_MU = 2048
+        # create dummy resource model environment
+        reg = ResourceModelRegistrar(dc_emulation_max_cpu=E_CPU, dc_emulation_max_mem=E_MEM)
+        rm = UpbSimpleCloudDcRM(max_cu=MAX_CU, max_mu=MAX_MU)
+        reg.register("test_dc", rm)
+
+        # test over provisioning exeption
+        exception = False
+        try:
+            c6 = createDummyContainerObject("c6", flavor="xlarge")
+            c7 = createDummyContainerObject("c7", flavor="xlarge")
+            c8 = createDummyContainerObject("c8", flavor="xlarge")
+            rm.allocate(c6)  # calculate allocation
+            rm.allocate(c7)  # calculate allocation
+            rm.allocate(c8)  # calculate allocation
+        except Exception as e:
+            self.assertIn("Not enough memory", e.message)
+            exception = True
+        self.assertTrue(exception)
+
+    def testFree(self):
+        """
+        Test the free procedure.
+        :return:
+        """
+        # config
+        E_CPU = 1.0
+        MAX_CU = 100
+        # create dummy resource model environment
+        reg = ResourceModelRegistrar(dc_emulation_max_cpu=1.0, dc_emulation_max_mem=512)
+        rm = UpbSimpleCloudDcRM(max_cu=100, max_mu=100)
+        reg.register("test_dc", rm)
+        c1 = createDummyContainerObject("c6", flavor="tiny")
+        rm.allocate(c1)  # calculate allocation
+        self.assertTrue(rm.dc_alloc_cu == 0.5)
+        rm.free(c1)
+        self.assertTrue(rm.dc_alloc_cu == 0)
+
+    def testInRealTopo(self):
+        """
+        Start a real container and check if limitations are really passed down to Dockernet.
+        :return:
+        """
+        # ATTENTION: This test should only be executed if emu runs not inside a Docker container,
+        # because it manipulates cgroups.
+        if os.environ.get("SON_EMU_IN_DOCKER") is not None:
+            return
+        # create network
+        self.createNet(nswitches=0, ndatacenter=1, nhosts=2, ndockers=0)
+        # setup links
+        self.net.addLink(self.dc[0], self.h[0])
+        self.net.addLink(self.h[1], self.dc[0])
+        # add resource model
+        r = UpbSimpleCloudDcRM(max_cu=100, max_mu=100)
+        self.dc[0].assignResourceModel(r)
+        # start Mininet network
+        self.startNet()
+        # check number of running nodes
+        self.assertTrue(len(self.getDockernetContainers()) == 0)
+        self.assertTrue(len(self.net.hosts) == 2)
+        self.assertTrue(len(self.net.switches) == 1)
+        # check resource model and resource model registrar
+        self.assertTrue(self.dc[0]._resource_model is not None)
+        self.assertTrue(len(self.net.rm_registrar.resource_models) == 1)
+
+        # check if alloc was called during startCompute
+        self.assertTrue(len(r._allocated_compute_instances) == 0)
+        tc1 = self.dc[0].startCompute("tc1", flavor_name="tiny")
+        time.sleep(1)
+        self.assertTrue(len(r._allocated_compute_instances) == 1)
+
+        # check if there is a real limitation set for containers cgroup
+        # deactivated for now, seems not to work in docker-in-docker setup used in CI
+        self.assertEqual(float(tc1.cpu_quota)/tc1.cpu_period, 0.005)
+
+        # check if free was called during stopCompute
+        self.dc[0].stopCompute("tc1")
+        self.assertTrue(len(r._allocated_compute_instances) == 0)
+        # check connectivity by using ping
+        self.assertTrue(self.net.ping([self.h[0], self.h[1]]) <= 0.0)
+        # stop Mininet network
+        self.stopNet()
+
+
+