src/emuvim/test/test_resourcemodel_api.py

   1 import time
   2 from emuvim.test.base import SimpleTestTopology
   3 from emuvim.dcemulator.resourcemodel import BaseResourceModel, ResourceFlavor
   4 from emuvim.dcemulator.resourcemodel.upb.simple import UpbSimpleCloudDcRM
   5 from emuvim.dcemulator.resourcemodel import ResourceModelRegistrar
   6
   7
   8 class testResourceModel(SimpleTestTopology):
   9     """
  10     Test the general resource model API and functionality.
  11     """
  12
  13     def testBaseResourceModelApi(self):
  14         """
  15         Tast bare API without real resource madel.
  16         :return:
  17         """
  18         r = BaseResourceModel()
  19         # check if default flavors are there
  20         self.assertTrue(len(r._flavors) == 5)
  21         # check addFlavor functionality
  22         f = ResourceFlavor("test", {"testmetric": 42})
  23         r.addFlavour(f)
  24         self.assertTrue("test" in r._flavors)
  25         self.assertTrue(r._flavors.get("test").get("testmetric") == 42)
  26
  27     def testAddRmToDc(self):
  28         """
  29         Test is allocate/free is called when a RM is added to a DC.
  30         :return:
  31         """
  32         # create network
  33         self.createNet(nswitches=0, ndatacenter=1, nhosts=2, ndockers=0)
  34         # setup links
  35         self.net.addLink(self.dc[0], self.h[0])
  36         self.net.addLink(self.h[1], self.dc[0])
  37         # add resource model
  38         r = BaseResourceModel()
  39         self.dc[0].assignResourceModel(r)
  40         # start Mininet network
  41         self.startNet()
  42         # check number of running nodes
  43         self.assertTrue(len(self.getDockernetContainers()) == 0)
  44         self.assertTrue(len(self.net.hosts) == 2)
  45         self.assertTrue(len(self.net.switches) == 1)
  46         # check resource model and resource model registrar
  47         self.assertTrue(self.dc[0]._resource_model is not None)
  48         self.assertTrue(len(self.net.rm_registrar.resource_models) == 1)
  49
  50         # check if alloc was called during startCompute
  51         self.assertTrue(len(r._allocated_compute_instances) == 0)
  52         self.dc[0].startCompute("tc1")
  53         time.sleep(1)
  54         self.assertTrue(len(r._allocated_compute_instances) == 1)
  55         # check if free was called during stopCompute
  56         self.dc[0].stopCompute("tc1")
  57         self.assertTrue(len(r._allocated_compute_instances) == 0)
  58         # check connectivity by using ping
  59         self.assertTrue(self.net.ping([self.h[0], self.h[1]]) <= 0.0)
  60         # stop Mininet network
  61         self.stopNet()
  62
  63
  64 def createDummyContainerObject(name, flavor):
  65
  66     class DummyContainer(object):
  67
  68         def __init__(self):
  69             self.cpu_period = -1
  70             self.cpu_quota = -1
  71             self.mem_limit = -1
  72             self.memswap_limit = -1
  73
  74         def updateCpuLimit(self, cpu_period, cpu_quota):
  75             self.cpu_period = cpu_period
  76             self.cpu_quota = cpu_quota
  77
  78         def updateMemoryLimit(self, mem_limit):
  79             self.mem_limit = mem_limit
  80
  81     d = DummyContainer()
  82     d.name = name
  83     d.flavor_name = flavor
  84     return d
  85
  86
  87
  88
  89 class testUpbSimpleCloudDcRM(SimpleTestTopology):
  90     """
  91     Test the UpbSimpleCloudDc resource model.
  92     """
  93
  94     def testAllocation(self):
  95         """
  96         Test the allocation procedures and correct calculations.
  97         :return:
  98         """
  99         # config
 100         E_CPU = 1.0
 101         MAX_CU = 100
 102         E_MEM = 512
 103         MAX_MU = 2048
 104         # create dummy resource model environment
 105         reg = ResourceModelRegistrar(dc_emulation_max_cpu=E_CPU, dc_emulation_max_mem=E_MEM)
 106         rm = UpbSimpleCloudDcRM(max_cu=MAX_CU, max_mu=MAX_MU)
 107         reg.register("test_dc", rm)
 108
 109         c1 = createDummyContainerObject("c1", flavor="tiny")
 110         rm.allocate(c1)  # calculate allocation
 111         self.assertEqual(float(c1.cpu_quota) / c1.cpu_period, E_CPU / MAX_CU * 0.5)   # validate compute result
 112         self.assertEqual(float(c1.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 32)   # validate memory result
 113
 114         c2 = createDummyContainerObject("c2", flavor="small")
 115         rm.allocate(c2)  # calculate allocation
 116         self.assertEqual(float(c2.cpu_quota) / c2.cpu_period, E_CPU / MAX_CU * 1)   # validate compute result
 117         self.assertEqual(float(c2.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 128)   # validate memory result
 118
 119
 120         c3 = createDummyContainerObject("c3", flavor="medium")
 121         res = rm.allocate(c3)  # calculate allocation
 122         self.assertEqual(float(c3.cpu_quota) / c3.cpu_period, E_CPU / MAX_CU * 4)   # validate compute result
 123         self.assertEqual(float(c3.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 256)   # validate memory result
 124
 125
 126         c4 = createDummyContainerObject("c4", flavor="large")
 127         rm.allocate(c4)  # calculate allocation
 128         self.assertEqual(float(c4.cpu_quota) / c4.cpu_period, E_CPU / MAX_CU * 8)   # validate compute result
 129         self.assertEqual(float(c4.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 512)   # validate memory result
 130
 131
 132         c5 = createDummyContainerObject("c5", flavor="xlarge")
 133         rm.allocate(c5)  # calculate allocation
 134         self.assertEqual(float(c5.cpu_quota) / c5.cpu_period, E_CPU / MAX_CU * 16)   # validate compute result
 135         self.assertEqual(float(c5.mem_limit/1024/1024), float(E_MEM) / MAX_MU * 1024)   # validate memory result
 136
 137
 138     def testAllocationCpuLimit(self):
 139         """
 140         Test CPU allocation limit
 141         :return:
 142         """
 143         # config
 144         E_CPU = 1.0
 145         MAX_CU = 40
 146         E_MEM = 512
 147         MAX_MU = 4096
 148         # create dummy resource model environment
 149         reg = ResourceModelRegistrar(dc_emulation_max_cpu=E_CPU, dc_emulation_max_mem=E_MEM)
 150         rm = UpbSimpleCloudDcRM(max_cu=MAX_CU, max_mu=MAX_MU)
 151         reg.register("test_dc", rm)
 152
 153         # test over provisioning exeption
 154         exception = False
 155         try:
 156             c6 = createDummyContainerObject("c6", flavor="xlarge")
 157             c7 = createDummyContainerObject("c7", flavor="xlarge")
 158             c8 = createDummyContainerObject("c8", flavor="xlarge")
 159             c9 = createDummyContainerObject("c9", flavor="xlarge")
 160             rm.allocate(c6)  # calculate allocation
 161             rm.allocate(c7)  # calculate allocation
 162             rm.allocate(c8)  # calculate allocation
 163             rm.allocate(c9)  # calculate allocation
 164         except Exception as e:
 165             self.assertIn("Not enough compute", e.message)
 166             exception = True
 167         self.assertTrue(exception)
 168
 169     def testAllocationMemLimit(self):
 170         """
 171         Test MEM allocation limit
 172         :return:
 173         """
 174         # config
 175         E_CPU = 1.0
 176         MAX_CU = 500
 177         E_MEM = 512
 178         MAX_MU = 2048
 179         # create dummy resource model environment
 180         reg = ResourceModelRegistrar(dc_emulation_max_cpu=E_CPU, dc_emulation_max_mem=E_MEM)
 181         rm = UpbSimpleCloudDcRM(max_cu=MAX_CU, max_mu=MAX_MU)
 182         reg.register("test_dc", rm)
 183
 184         # test over provisioning exeption
 185         exception = False
 186         try:
 187             c6 = createDummyContainerObject("c6", flavor="xlarge")
 188             c7 = createDummyContainerObject("c7", flavor="xlarge")
 189             c8 = createDummyContainerObject("c8", flavor="xlarge")
 190             rm.allocate(c6)  # calculate allocation
 191             rm.allocate(c7)  # calculate allocation
 192             rm.allocate(c8)  # calculate allocation
 193         except Exception as e:
 194             self.assertIn("Not enough memory", e.message)
 195             exception = True
 196         self.assertTrue(exception)
 197
 198     def testFree(self):
 199         """
 200         Test the free procedure.
 201         :return:
 202         """
 203         # config
 204         E_CPU = 1.0
 205         MAX_CU = 100
 206         # create dummy resource model environment
 207         reg = ResourceModelRegistrar(dc_emulation_max_cpu=1.0, dc_emulation_max_mem=512)
 208         rm = UpbSimpleCloudDcRM(max_cu=100, max_mu=100)
 209         reg.register("test_dc", rm)
 210         c1 = createDummyContainerObject("c6", flavor="tiny")
 211         rm.allocate(c1)  # calculate allocation
 212         self.assertTrue(rm.dc_alloc_cu == 0.5)
 213         rm.free(c1)
 214         self.assertTrue(rm.dc_alloc_cu == 0)
 215
 216     def testInRealTopo(self):
 217         """
 218         Start a real container and check if limitations are really passed down to Dockernet.
 219         :return:
 220         """
 221         # create network
 222         self.createNet(nswitches=0, ndatacenter=1, nhosts=2, ndockers=0)
 223         # setup links
 224         self.net.addLink(self.dc[0], self.h[0])
 225         self.net.addLink(self.h[1], self.dc[0])
 226         # add resource model
 227         r = UpbSimpleCloudDcRM(max_cu=100, max_mu=100)
 228         self.dc[0].assignResourceModel(r)
 229         # start Mininet network
 230         self.startNet()
 231         # check number of running nodes
 232         self.assertTrue(len(self.getDockernetContainers()) == 0)
 233         self.assertTrue(len(self.net.hosts) == 2)
 234         self.assertTrue(len(self.net.switches) == 1)
 235         # check resource model and resource model registrar
 236         self.assertTrue(self.dc[0]._resource_model is not None)
 237         self.assertTrue(len(self.net.rm_registrar.resource_models) == 1)
 238
 239         # check if alloc was called during startCompute
 240         self.assertTrue(len(r._allocated_compute_instances) == 0)
 241         tc1 = self.dc[0].startCompute("tc1", flavor_name="tiny")
 242         time.sleep(1)
 243         self.assertTrue(len(r._allocated_compute_instances) == 1)
 244
 245         # check if there is a real limitation set for containers cgroup
 246         self.assertEqual(float(tc1.cpu_quota)/tc1.cpu_period, 0.005)
 247
 248         # check if free was called during stopCompute
 249         self.dc[0].stopCompute("tc1")
 250         self.assertTrue(len(r._allocated_compute_instances) == 0)
 251         # check connectivity by using ping
 252         self.assertTrue(self.net.ping([self.h[0], self.h[1]]) <= 0.0)
 253         # stop Mininet network
 254         self.stopNet()
 255
 256
 257