X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=src%2Femuvim%2Ftest%2Ftest_resourcemodel_api.py;h=0836c6831d757adf4c4783c6b8b58d231ab82f19;hb=972a9f04442e4bb7f7271e998e3893f0fa737fc1;hp=3412ec47c6ef22e8a46ef215b99dbb93258f8dda;hpb=644b319afbe785ecf05cad40dcbc118d57204c2d;p=osm%2Fvim-emu.git diff --git a/src/emuvim/test/test_resourcemodel_api.py b/src/emuvim/test/test_resourcemodel_api.py index 3412ec4..0836c68 100644 --- a/src/emuvim/test/test_resourcemodel_api.py +++ b/src/emuvim/test/test_resourcemodel_api.py @@ -6,21 +6,32 @@ 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) + self.assertTrue("test" in r._flavors) + self.assertTrue(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(len(r.allocate("testc", "tiny")) == 3) # expected: 3tuple + self.assertTrue(r.free("testc")) 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 @@ -32,23 +43,23 @@ 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(len(self.net.rm_registrar.resource_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() @@ -57,39 +68,61 @@ 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=1.0) - rm = UpbSimpleCloudDcRM(max_cu=100, max_mu=100) + 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) res = rm.allocate("c1", "tiny") # calculate allocation - assert(res[0] == E_CPU / MAX_CU * 1) # validate compute result - assert(res[1] < 0) # validate memory result - assert(res[2] < 0) # validate disk result + self.assertEqual(res[0], E_CPU / MAX_CU * 1) # validate compute result + self.assertEqual(res[1], float(E_MEM) / MAX_MU * 32) # validate memory result + self.assertTrue(res[2] < 0) # validate disk result res = rm.allocate("c2", "small") # calculate allocation - assert(res[0] == E_CPU / MAX_CU * 4) # validate compute result - assert(res[1] < 0) # validate memory result - assert(res[2] < 0) # validate disk result + self.assertEqual(res[0], E_CPU / MAX_CU * 4) # validate compute result + self.assertEqual(res[1], float(E_MEM) / MAX_MU * 128) # validate memory result + self.assertTrue(res[2] < 0) # validate disk result res = rm.allocate("c3", "medium") # calculate allocation - assert(res[0] == E_CPU / MAX_CU * 8) # validate compute result - assert(res[1] < 0) # validate memory result - assert(res[2] < 0) # validate disk result + self.assertEqual(res[0], E_CPU / MAX_CU * 8) # validate compute result + self.assertEqual(res[1], float(E_MEM) / MAX_MU * 256) # validate memory result + self.assertTrue(res[2] < 0) # validate disk result res = rm.allocate("c4", "large") # calculate allocation - assert(res[0] == E_CPU / MAX_CU * 16) # validate compute result - assert(res[1] < 0) # validate memory result - assert(res[2] < 0) # validate disk result + self.assertEqual(res[0], E_CPU / MAX_CU * 16) # validate compute result + self.assertEqual(res[1], float(E_MEM) / MAX_MU * 512) # validate memory result + self.assertTrue(res[2] < 0) # validate disk result res = rm.allocate("c5", "xlarge") # calculate allocation - assert(res[0] == E_CPU / MAX_CU * 32) # validate compute result - assert(res[1] < 0) # validate memory result - assert(res[2] < 0) # validate disk result + self.assertEqual(res[0], E_CPU / MAX_CU * 32) # validate compute result + self.assertEqual(res[1], float(E_MEM) / MAX_MU * 1024) # validate memory result + self.assertTrue(res[2] < 0) # validate disk result + + def testAllocationCpuLimit(self): + """ + Test CPU allocation limit + :return: + """ + # config + E_CPU = 1.0 + MAX_CU = 100 + 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 @@ -99,22 +132,92 @@ class testUpbSimpleCloudDcRM(SimpleTestTopology): rm.allocate("c8", "xlarge") # calculate allocation rm.allocate("c9", "xlarge") # calculate allocation except Exception as e: - assert("Not enough compute" in e.message) + 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: + rm.allocate("c6", "xlarge") # calculate allocation + rm.allocate("c7", "xlarge") # calculate allocation + rm.allocate("c8", "xlarge") # calculate allocation + except Exception as e: + self.assertIn("Not enough memory", e.message) exception = True - assert(exception) + 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) + 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) rm.allocate("c1", "tiny") # calculate allocation - assert(rm.dc_alloc_cu == 1) + self.assertTrue(rm.dc_alloc_cu == 1) rm.free("c1") - assert(rm.dc_alloc_cu == 0) + 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: + """ + # 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 + self.assertEqual(tc1.cpu_period/tc1.cpu_quota, 100) + + # 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()