Revision 5b798711
b/test/py/ganeti.config_unittest.py | ||
---|---|---|
124 | 124 |
self.failUnlessEqual(1, len(cfg.GetNodeList())) |
125 | 125 |
self.failUnlessEqual(0, len(cfg.GetInstanceList())) |
126 | 126 |
|
127 |
def _GenericNodesCheck(self, inst, all_nodes, secondary_nodes): |
|
128 |
for i in [all_nodes, secondary_nodes]: |
|
129 |
self.assertTrue(isinstance(i, (list, tuple)), |
|
130 |
msg="Data type doesn't guarantee order") |
|
131 |
|
|
132 |
self.assertTrue(inst.primary_node not in secondary_nodes) |
|
133 |
self.assertEqual(all_nodes[0], inst.primary_node, |
|
134 |
msg="Primary node not first node in list") |
|
135 |
|
|
136 |
def testInstNodesNoDisks(self): |
|
137 |
"""Test all_nodes/secondary_nodes when there are no disks""" |
|
138 |
# construct instance |
|
139 |
cfg = self._get_object() |
|
140 |
inst = self._create_instance(cfg) |
|
141 |
cfg.AddInstance(inst, "my-job") |
|
142 |
|
|
143 |
# No disks |
|
144 |
all_nodes = cfg.GetInstanceNodes(inst) |
|
145 |
secondary_nodes = cfg.GetInstanceSecondaryNodes(inst) |
|
146 |
self._GenericNodesCheck(inst, all_nodes, secondary_nodes) |
|
147 |
self.assertEqual(len(secondary_nodes), 0) |
|
148 |
self.assertEqual(set(all_nodes), set([inst.primary_node])) |
|
149 |
self.assertEqual(cfg.GetInstanceLVsByNode(inst), { |
|
150 |
inst.primary_node: [], |
|
151 |
}) |
|
152 |
|
|
153 |
def testInstNodesPlainDisks(self): |
|
154 |
# construct instance |
|
155 |
cfg = self._get_object() |
|
156 |
inst = self._create_instance(cfg) |
|
157 |
disks = [ |
|
158 |
objects.Disk(dev_type=constants.DT_PLAIN, size=128, |
|
159 |
logical_id=("myxenvg", "disk25494")), |
|
160 |
objects.Disk(dev_type=constants.DT_PLAIN, size=512, |
|
161 |
logical_id=("myxenvg", "disk29071")), |
|
162 |
] |
|
163 |
inst.disks = disks |
|
164 |
cfg.AddInstance(inst, "my-job") |
|
165 |
|
|
166 |
# Plain disks |
|
167 |
all_nodes = cfg.GetInstanceNodes(inst) |
|
168 |
secondary_nodes = cfg.GetInstanceSecondaryNodes(inst) |
|
169 |
self._GenericNodesCheck(inst, all_nodes, secondary_nodes) |
|
170 |
self.assertEqual(len(secondary_nodes), 0) |
|
171 |
self.assertEqual(set(all_nodes), set([inst.primary_node])) |
|
172 |
self.assertEqual(cfg.GetInstanceLVsByNode(inst), { |
|
173 |
inst.primary_node: ["myxenvg/disk25494", "myxenvg/disk29071"], |
|
174 |
}) |
|
175 |
|
|
176 |
def testInstNodesDrbdDisks(self): |
|
177 |
# construct a second node |
|
178 |
cfg = self._get_object() |
|
179 |
node_group = cfg.LookupNodeGroup(None) |
|
180 |
master_uuid = cfg.GetMasterNode() |
|
181 |
node2 = objects.Node(name="node2.example.com", group=node_group, |
|
182 |
ndparams={}, uuid="node2-uuid") |
|
183 |
cfg.AddNode(node2, "my-job") |
|
184 |
|
|
185 |
# construct instance |
|
186 |
inst = self._create_instance(cfg) |
|
187 |
disks = [ |
|
188 |
objects.Disk(dev_type=constants.DT_DRBD8, size=786432, |
|
189 |
logical_id=(master_uuid, node2.uuid, |
|
190 |
12300, 0, 0, "secret"), |
|
191 |
children=[ |
|
192 |
objects.Disk(dev_type=constants.DT_PLAIN, size=786432, |
|
193 |
logical_id=("myxenvg", "disk0")), |
|
194 |
objects.Disk(dev_type=constants.DT_PLAIN, size=128, |
|
195 |
logical_id=("myxenvg", "meta0")) |
|
196 |
], |
|
197 |
iv_name="disk/0") |
|
198 |
] |
|
199 |
inst.disks = disks |
|
200 |
cfg.AddInstance(inst, "my-job") |
|
201 |
|
|
202 |
# Drbd Disks |
|
203 |
all_nodes = cfg.GetInstanceNodes(inst) |
|
204 |
secondary_nodes = cfg.GetInstanceSecondaryNodes(inst) |
|
205 |
self._GenericNodesCheck(inst, all_nodes, secondary_nodes) |
|
206 |
self.assertEqual(set(secondary_nodes), set([node2.uuid])) |
|
207 |
self.assertEqual(set(all_nodes), |
|
208 |
set([inst.primary_node, node2.uuid])) |
|
209 |
self.assertEqual(cfg.GetInstanceLVsByNode(inst), { |
|
210 |
master_uuid: ["myxenvg/disk0", "myxenvg/meta0"], |
|
211 |
node2.uuid: ["myxenvg/disk0", "myxenvg/meta0"], |
|
212 |
}) |
|
213 |
|
|
127 | 214 |
def testUpdateCluster(self): |
128 | 215 |
"""Test updates on the cluster object""" |
129 | 216 |
cfg = self._get_object() |
b/test/py/ganeti.objects_unittest.py | ||
---|---|---|
321 | 321 |
|
322 | 322 |
|
323 | 323 |
class TestInstance(unittest.TestCase): |
324 |
def _GenericCheck(self, inst): |
|
325 |
for i in [inst.all_nodes, inst.secondary_nodes]: |
|
326 |
self.assertTrue(isinstance(inst.all_nodes, (list, tuple)), |
|
327 |
msg="Data type doesn't guarantee order") |
|
328 |
|
|
329 |
self.assertTrue(inst.primary_node not in inst.secondary_nodes) |
|
330 |
self.assertEqual(inst.all_nodes[0], inst.primary_node, |
|
331 |
msg="Primary node not first node in list") |
|
332 |
|
|
333 |
def testNodesNoDisks(self): |
|
334 |
inst = objects.Instance(name="fakeinst.example.com", |
|
335 |
primary_node="pnode.example.com", |
|
336 |
disks=[ |
|
337 |
]) |
|
338 |
|
|
339 |
self._GenericCheck(inst) |
|
340 |
self.assertEqual(len(inst.secondary_nodes), 0) |
|
341 |
self.assertEqual(set(inst.all_nodes), set([inst.primary_node])) |
|
342 |
self.assertEqual(inst.MapLVsByNode(), { |
|
343 |
inst.primary_node: [], |
|
344 |
}) |
|
345 |
|
|
346 |
def testNodesPlainDisks(self): |
|
347 |
inst = objects.Instance(name="fakeinstplain.example.com", |
|
348 |
primary_node="node3.example.com", |
|
349 |
disks=[ |
|
350 |
objects.Disk(dev_type=constants.DT_PLAIN, size=128, |
|
351 |
logical_id=("myxenvg", "disk25494")), |
|
352 |
objects.Disk(dev_type=constants.DT_PLAIN, size=512, |
|
353 |
logical_id=("myxenvg", "disk29071")), |
|
354 |
]) |
|
355 |
|
|
356 |
self._GenericCheck(inst) |
|
357 |
self.assertEqual(len(inst.secondary_nodes), 0) |
|
358 |
self.assertEqual(set(inst.all_nodes), set([inst.primary_node])) |
|
359 |
self.assertEqual(inst.MapLVsByNode(), { |
|
360 |
inst.primary_node: ["myxenvg/disk25494", "myxenvg/disk29071"], |
|
361 |
}) |
|
362 |
|
|
363 |
def testNodesDrbdDisks(self): |
|
324 |
def testFindDisk(self): |
|
364 | 325 |
inst = objects.Instance(name="fakeinstdrbd.example.com", |
365 | 326 |
primary_node="node10.example.com", |
366 | 327 |
disks=[ |
... | ... | |
376 | 337 |
iv_name="disk/0") |
377 | 338 |
]) |
378 | 339 |
|
379 |
self._GenericCheck(inst) |
|
380 |
self.assertEqual(set(inst.secondary_nodes), set(["node15.example.com"])) |
|
381 |
self.assertEqual(set(inst.all_nodes), |
|
382 |
set([inst.primary_node, "node15.example.com"])) |
|
383 |
self.assertEqual(inst.MapLVsByNode(), { |
|
384 |
inst.primary_node: ["myxenvg/disk0", "myxenvg/meta0"], |
|
385 |
"node15.example.com": ["myxenvg/disk0", "myxenvg/meta0"], |
|
386 |
}) |
|
387 |
|
|
388 | 340 |
self.assertEqual(inst.FindDisk(0), inst.disks[0]) |
389 | 341 |
self.assertRaises(errors.OpPrereqError, inst.FindDisk, "hello") |
390 | 342 |
self.assertRaises(errors.OpPrereqError, inst.FindDisk, 100) |
Also available in: Unified diff