From: peusterm Date: Sat, 16 Apr 2016 15:39:40 +0000 (+0200) Subject: cleanup X-Git-Tag: v3.1~144^2 X-Git-Url: https://osm.etsi.org/gitweb/?a=commitdiff_plain;h=74df3cccdfe2e8171d38645ee8de961c57e26bbe;p=osm%2Fvim-emu.git cleanup --- diff --git a/src/emuvim/test/test_resourcemodel.py b/src/emuvim/test/test_resourcemodel.py new file mode 100644 index 0000000..a11bc8b --- /dev/null +++ b/src/emuvim/test/test_resourcemodel.py @@ -0,0 +1,263 @@ +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 + self.assertTrue(len(r._flavors) == 5) + # check addFlavor functionality + f = ResourceFlavor("test", {"testmetric": 42}) + r.addFlavour(f) + 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 + self.net.addLink(self.dc[0], self.h[0]) + self.net.addLink(self.h[1], self.dc[0]) + # add resource model + r = BaseResourceModel() + 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) + self.dc[0].startCompute("tc1") + time.sleep(1) + self.assertTrue(len(r._allocated_compute_instances) == 1) + # 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() + + +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() + + + diff --git a/src/emuvim/test/test_resourcemodel_api.py b/src/emuvim/test/test_resourcemodel_api.py deleted file mode 100644 index a11bc8b..0000000 --- a/src/emuvim/test/test_resourcemodel_api.py +++ /dev/null @@ -1,263 +0,0 @@ -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 - self.assertTrue(len(r._flavors) == 5) - # check addFlavor functionality - f = ResourceFlavor("test", {"testmetric": 42}) - r.addFlavour(f) - 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 - self.net.addLink(self.dc[0], self.h[0]) - self.net.addLink(self.h[1], self.dc[0]) - # add resource model - r = BaseResourceModel() - 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) - self.dc[0].startCompute("tc1") - time.sleep(1) - self.assertTrue(len(r._allocated_compute_instances) == 1) - # 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() - - -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() - - -