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 NotEnoughResourcesAvailable as e: self.assertIn("Not enough memory", e.message) exception = True self.assertTrue(exception)
def testFree(self): """ Test the free procedure. :return: """ # 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 _create_dcs(self): rm0 = UpbSimpleCloudDcRM(max_cu=100, max_mu=2048) rm1 = ARORM(max_cu=4, max_mu=512) rm2 = ARORM(max_cu=6, max_mu=512) self.dc1 = self.addDatacenter("dc1") self.dc1.assignResourceModel(rm0) self.dc2 = self.addDatacenter("dc2", topo='star', sw_param=3) self.dc2.assignResourceModel(rm0)
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 NotEnoughResourcesAvailable as e: self.assertIn("Not enough memory", str(e)) exception = True self.assertTrue(exception)
def testInRealTopo(self): """ Start a real container and check if limitations are really passed down to Conteinernet. :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.getContainernetContainers()) == 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.resources['cpu_quota']) / tc1.resources['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()
def create_topology1(): cleanup() # create topology # use a maximum of 50% cpu time for containers added to data centers net = DCNetwork(dc_emulation_max_cpu=0.5, controller=Controller) # add some data centers and create a topology dc1 = net.addDatacenter("dc1", resource_log_path=RESOURCE_LOG_PATH) dc2 = net.addDatacenter("dc2", resource_log_path=RESOURCE_LOG_PATH) s1 = net.addSwitch("s1") net.addLink(dc1, s1, delay="10ms") net.addLink(dc2, s1, delay="20ms") # create and assign resource models for each DC rm1 = UpbSimpleCloudDcRM(max_cu=4, max_mu=1024) rm2 = UpbOverprovisioningCloudDcRM(max_cu=4) dc1.assignResourceModel(rm1) dc2.assignResourceModel(rm2) # add the command line interface endpoint to each DC zapi1 = ZeroRpcApiEndpoint("0.0.0.0", 4242) zapi1.connectDatacenter(dc1) zapi1.connectDatacenter(dc2) # run API endpoint server (in another thread, don't block) zapi1.start() # start the emulation platform net.start() print "Wait a moment and allocate some compute start some compute resources..." time.sleep(2) dc1.startCompute("vnf1") dc1.startCompute("vnf2", flavor_name="tiny") dc1.startCompute("vnf3", flavor_name="small") dc2.startCompute("vnf4", flavor_name="medium") dc2.startCompute("vnf5", flavor_name="medium") dc2.startCompute("vnf6", flavor_name="medium") print "... done." time.sleep(5) print "Removing instances ..." dc1.stopCompute("vnf1") dc2.stopCompute("vnf4") print "... done" net.CLI() net.stop()
def testFree(self): """ Test the free procedure. :return: """ # 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 testAllocationComputations(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 # validate compute result self.assertEqual( float(c1.resources['cpu_quota']) / c1.resources['cpu_period'], E_CPU / MAX_CU * 0.5) # validate memory result self.assertEqual(float(c1.resources['mem_limit'] / 1024 / 1024), float(E_MEM) / MAX_MU * 32) c2 = createDummyContainerObject("c2", flavor="small") rm.allocate(c2) # calculate allocation # validate compute result self.assertEqual( float(c2.resources['cpu_quota']) / c2.resources['cpu_period'], E_CPU / MAX_CU * 1) # validate memory result self.assertEqual(float(c2.resources['mem_limit'] / 1024 / 1024), float(E_MEM) / MAX_MU * 128) c3 = createDummyContainerObject("c3", flavor="medium") rm.allocate(c3) # calculate allocation # validate compute result self.assertEqual( float(c3.resources['cpu_quota']) / c3.resources['cpu_period'], E_CPU / MAX_CU * 4) # validate memory result self.assertEqual(float(c3.resources['mem_limit'] / 1024 / 1024), float(E_MEM) / MAX_MU * 256) c4 = createDummyContainerObject("c4", flavor="large") rm.allocate(c4) # calculate allocation # validate compute result self.assertEqual( float(c4.resources['cpu_quota']) / c4.resources['cpu_period'], E_CPU / MAX_CU * 8) # validate memory result self.assertEqual(float(c4.resources['mem_limit'] / 1024 / 1024), float(E_MEM) / MAX_MU * 512) c5 = createDummyContainerObject("c5", flavor="xlarge") rm.allocate(c5) # calculate allocation # validate compute result self.assertEqual( float(c5.resources['cpu_quota']) / c5.resources['cpu_period'], E_CPU / MAX_CU * 16) # validate memory result self.assertEqual(float(c5.resources['mem_limit'] / 1024 / 1024), float(E_MEM) / MAX_MU * 1024)
def testAllocationComputations(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.resources['cpu_quota']) / c1.resources['cpu_period'], E_CPU / MAX_CU * 0.5) # validate compute result self.assertEqual(float(c1.resources['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.resources['cpu_quota']) / c2.resources['cpu_period'], E_CPU / MAX_CU * 1) # validate compute result self.assertEqual(float(c2.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 128) # validate memory result c3 = createDummyContainerObject("c3", flavor="medium") rm.allocate(c3) # calculate allocation self.assertEqual(float(c3.resources['cpu_quota']) / c3.resources['cpu_period'], E_CPU / MAX_CU * 4) # validate compute result self.assertEqual(float(c3.resources['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.resources['cpu_quota']) / c4.resources['cpu_period'], E_CPU / MAX_CU * 8) # validate compute result self.assertEqual(float(c4.resources['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.resources['cpu_quota']) / c5.resources['cpu_period'], E_CPU / MAX_CU * 16) # validate compute result self.assertEqual(float(c5.resources['mem_limit']/1024/1024), float(E_MEM) / MAX_MU * 1024) # validate memory result