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
8 class testResourceModel(SimpleTestTopology
):
10 Test the general resource model API and functionality.
13 def testBaseResourceModelApi(self
):
15 Tast bare API without real resource madel.
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})
24 self
.assertTrue("test" in r
._flavors
)
25 self
.assertTrue(r
._flavors
.get("test").get("testmetric") == 42)
27 def testAddRmToDc(self
):
29 Test is allocate/free is called when a RM is added to a DC.
33 self
.createNet(nswitches
=0, ndatacenter
=1, nhosts
=2, ndockers
=0)
35 self
.net
.addLink(self
.dc
[0], self
.h
[0])
36 self
.net
.addLink(self
.h
[1], self
.dc
[0])
38 r
= BaseResourceModel()
39 self
.dc
[0].assignResourceModel(r
)
40 # start Mininet network
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)
50 # check if alloc was called during startCompute
51 self
.assertTrue(len(r
._allocated
_compute
_instances
) == 0)
52 self
.dc
[0].startCompute("tc1")
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
64 def createDummyContainerObject(name
, flavor
):
66 class DummyContainer(object):
72 self
.memswap_limit
= -1
74 def updateCpuLimit(self
, cpu_period
, cpu_quota
):
75 self
.cpu_period
= cpu_period
76 self
.cpu_quota
= cpu_quota
78 def updateMemoryLimit(self
, mem_limit
):
79 self
.mem_limit
= mem_limit
83 d
.flavor_name
= flavor
89 class testUpbSimpleCloudDcRM(SimpleTestTopology
):
91 Test the UpbSimpleCloudDc resource model.
94 def testAllocation(self
):
96 Test the allocation procedures and correct calculations.
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
)
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
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
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
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
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
138 def testAllocationCpuLimit(self
):
140 Test CPU allocation limit
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
)
153 # test over provisioning exeption
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
)
167 self
.assertTrue(exception
)
169 def testAllocationMemLimit(self
):
171 Test MEM allocation limit
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
)
184 # test over provisioning exeption
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
)
196 self
.assertTrue(exception
)
200 Test the free procedure.
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)
214 self
.assertTrue(rm
.dc_alloc_cu
== 0)
216 def testInRealTopo(self
):
218 Start a real container and check if limitations are really passed down to Dockernet.
222 self
.createNet(nswitches
=0, ndatacenter
=1, nhosts
=2, ndockers
=0)
224 self
.net
.addLink(self
.dc
[0], self
.h
[0])
225 self
.net
.addLink(self
.h
[1], self
.dc
[0])
227 r
= UpbSimpleCloudDcRM(max_cu
=100, max_mu
=100)
228 self
.dc
[0].assignResourceModel(r
)
229 # start Mininet network
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)
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")
243 self
.assertTrue(len(r
._allocated
_compute
_instances
) == 1)
245 # check if there is a real limitation set for containers cgroup
246 self
.assertEqual(float(tc1
.cpu_quota
)/tc1
.cpu_period
, 0.005)
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