4 # Copyright (C) 2010 Google Inc.
6 # This program is free software; you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation; either version 2 of the License, or
9 # (at your option) any later version.
11 # This program is distributed in the hope that it will be useful, but
12 # WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # General Public License for more details.
16 # You should have received a copy of the GNU General Public License
17 # along with this program; if not, write to the Free Software
18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 """Script for unittesting the RAPI rlib2 module
31 from ganeti import constants
32 from ganeti import opcodes
33 from ganeti import compat
34 from ganeti import http
35 from ganeti import query
36 from ganeti import luxi
37 from ganeti import errors
39 from ganeti.rapi import rlib2
44 class _FakeRequestPrivateData:
45 def __init__(self, body_data):
46 self.body_data = body_data
50 def __init__(self, body_data):
51 self.private = _FakeRequestPrivateData(body_data)
54 def _CreateHandler(cls, items, queryargs, body_data, client_cls):
55 return cls(items, queryargs, _FakeRequest(body_data),
56 _client_cls=client_cls)
63 def GetNextSubmittedJob(self):
64 return self._jobs.pop(0)
66 def SubmitJob(self, ops):
67 job_id = str(1 + int(random.random() * 1000000))
68 self._jobs.append((job_id, ops))
72 class _FakeClientFactory:
73 def __init__(self, cls):
74 self._client_cls = cls
77 def GetNextClient(self):
78 return self._clients.pop(0)
81 cl = self._client_cls()
82 self._clients.append(cl)
86 class TestConstants(unittest.TestCase):
87 def testConsole(self):
88 # Exporting the console field without authentication might expose
90 assert "console" in query.INSTANCE_FIELDS
91 self.assertTrue("console" not in rlib2.I_FIELDS)
95 constants.QR_INSTANCE: rlib2.I_FIELDS,
96 constants.QR_NODE: rlib2.N_FIELDS,
97 constants.QR_GROUP: rlib2.G_FIELDS,
100 for (qr, fields) in checks.items():
101 self.assertFalse(set(fields) - set(query.ALL_FIELDS[qr].keys()))
104 class TestClientConnectError(unittest.TestCase):
106 def _FailingClient():
107 raise luxi.NoMasterError("test")
115 for cls in resources:
116 handler = _CreateHandler(cls, ["name"], [], None, self._FailingClient)
117 self.assertRaises(http.HttpBadGateway, handler.GET)
120 class TestJobSubmitError(unittest.TestCase):
121 class _SubmitErrorClient:
124 raise errors.JobQueueFull("test")
127 handler = _CreateHandler(rlib2.R_2_redist_config, [], [], None,
128 self._SubmitErrorClient)
129 self.assertRaises(http.HttpServiceUnavailable, handler.PUT)
132 class TestClusterModify(unittest.TestCase):
134 clfactory = _FakeClientFactory(_FakeClient)
135 handler = _CreateHandler(rlib2.R_2_cluster_modify, [], [], {
137 "candidate_pool_size": 100,
139 job_id = handler.PUT()
141 cl = clfactory.GetNextClient()
142 self.assertRaises(IndexError, clfactory.GetNextClient)
144 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
145 self.assertEqual(job_id, exp_job_id)
146 self.assertTrue(isinstance(op, opcodes.OpClusterSetParams))
147 self.assertEqual(op.vg_name, "testvg")
148 self.assertEqual(op.candidate_pool_size, 100)
150 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
152 def testInvalidValue(self):
153 for attr in ["vg_name", "candidate_pool_size", "beparams", "_-Unknown#"]:
154 clfactory = _FakeClientFactory(_FakeClient)
155 handler = _CreateHandler(rlib2.R_2_cluster_modify, [], [], {
158 self.assertRaises(http.HttpBadRequest, handler.PUT)
159 self.assertRaises(IndexError, clfactory.GetNextClient)
162 class TestRedistConfig(unittest.TestCase):
164 clfactory = _FakeClientFactory(_FakeClient)
165 handler = _CreateHandler(rlib2.R_2_redist_config, [], [], None, clfactory)
166 job_id = handler.PUT()
168 cl = clfactory.GetNextClient()
169 self.assertRaises(IndexError, clfactory.GetNextClient)
171 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
172 self.assertEqual(job_id, exp_job_id)
173 self.assertTrue(isinstance(op, opcodes.OpClusterRedistConf))
175 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
178 class TestNodeMigrate(unittest.TestCase):
180 clfactory = _FakeClientFactory(_FakeClient)
181 handler = _CreateHandler(rlib2.R_2_nodes_name_migrate, ["node1"], {}, {
182 "iallocator": "fooalloc",
184 job_id = handler.POST()
186 cl = clfactory.GetNextClient()
187 self.assertRaises(IndexError, clfactory.GetNextClient)
189 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
190 self.assertEqual(job_id, exp_job_id)
191 self.assertTrue(isinstance(op, opcodes.OpNodeMigrate))
192 self.assertEqual(op.node_name, "node1")
193 self.assertEqual(op.iallocator, "fooalloc")
195 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
197 def testQueryArgsConflict(self):
198 clfactory = _FakeClientFactory(_FakeClient)
199 handler = _CreateHandler(rlib2.R_2_nodes_name_migrate, ["node2"], {
201 "mode": constants.HT_MIGRATION_NONLIVE,
203 self.assertRaises(http.HttpBadRequest, handler.POST)
204 self.assertRaises(IndexError, clfactory.GetNextClient)
206 def testQueryArgsMode(self):
207 clfactory = _FakeClientFactory(_FakeClient)
209 "mode": [constants.HT_MIGRATION_LIVE],
211 handler = _CreateHandler(rlib2.R_2_nodes_name_migrate, ["node17292"],
212 queryargs, None, clfactory)
213 job_id = handler.POST()
215 cl = clfactory.GetNextClient()
216 self.assertRaises(IndexError, clfactory.GetNextClient)
218 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
219 self.assertEqual(job_id, exp_job_id)
220 self.assertTrue(isinstance(op, opcodes.OpNodeMigrate))
221 self.assertEqual(op.node_name, "node17292")
222 self.assertEqual(op.mode, constants.HT_MIGRATION_LIVE)
224 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
226 def testQueryArgsLive(self):
227 clfactory = _FakeClientFactory(_FakeClient)
229 for live in [False, True]:
231 "live": [str(int(live))],
233 handler = _CreateHandler(rlib2.R_2_nodes_name_migrate, ["node6940"],
234 queryargs, None, clfactory)
235 job_id = handler.POST()
237 cl = clfactory.GetNextClient()
238 self.assertRaises(IndexError, clfactory.GetNextClient)
240 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
241 self.assertEqual(job_id, exp_job_id)
242 self.assertTrue(isinstance(op, opcodes.OpNodeMigrate))
243 self.assertEqual(op.node_name, "node6940")
245 self.assertEqual(op.mode, constants.HT_MIGRATION_LIVE)
247 self.assertEqual(op.mode, constants.HT_MIGRATION_NONLIVE)
249 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
252 class TestNodeEvacuate(unittest.TestCase):
254 clfactory = _FakeClientFactory(_FakeClient)
255 handler = _CreateHandler(rlib2.R_2_nodes_name_evacuate, ["node92"], {
258 "mode": constants.IALLOCATOR_NEVAC_SEC,
260 job_id = handler.POST()
262 cl = clfactory.GetNextClient()
263 self.assertRaises(IndexError, clfactory.GetNextClient)
265 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
266 self.assertEqual(job_id, exp_job_id)
267 self.assertTrue(isinstance(op, opcodes.OpNodeEvacuate))
268 self.assertEqual(op.node_name, "node92")
269 self.assertEqual(op.mode, constants.IALLOCATOR_NEVAC_SEC)
270 self.assertTrue(op.dry_run)
272 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
275 class TestNodePowercycle(unittest.TestCase):
277 clfactory = _FakeClientFactory(_FakeClient)
278 handler = _CreateHandler(rlib2.R_2_nodes_name_powercycle, ["node20744"], {
281 job_id = handler.POST()
283 cl = clfactory.GetNextClient()
284 self.assertRaises(IndexError, clfactory.GetNextClient)
286 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
287 self.assertEqual(job_id, exp_job_id)
288 self.assertTrue(isinstance(op, opcodes.OpNodePowercycle))
289 self.assertEqual(op.node_name, "node20744")
290 self.assertTrue(op.force)
292 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
295 class TestGroupAssignNodes(unittest.TestCase):
297 clfactory = _FakeClientFactory(_FakeClient)
298 handler = _CreateHandler(rlib2.R_2_groups_name_assign_nodes, ["grp-a"], {
302 "nodes": ["n2", "n3"],
304 job_id = handler.PUT()
306 cl = clfactory.GetNextClient()
307 self.assertRaises(IndexError, clfactory.GetNextClient)
309 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
310 self.assertEqual(job_id, exp_job_id)
311 self.assertTrue(isinstance(op, opcodes.OpGroupAssignNodes))
312 self.assertEqual(op.group_name, "grp-a")
313 self.assertEqual(op.nodes, ["n2", "n3"])
314 self.assertTrue(op.dry_run)
315 self.assertTrue(op.force)
317 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
320 class TestInstanceDelete(unittest.TestCase):
322 clfactory = _FakeClientFactory(_FakeClient)
323 handler = _CreateHandler(rlib2.R_2_instances_name, ["inst30965"], {
326 job_id = handler.DELETE()
328 cl = clfactory.GetNextClient()
329 self.assertRaises(IndexError, clfactory.GetNextClient)
331 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
332 self.assertEqual(job_id, exp_job_id)
333 self.assertTrue(isinstance(op, opcodes.OpInstanceRemove))
334 self.assertEqual(op.instance_name, "inst30965")
335 self.assertTrue(op.dry_run)
336 self.assertFalse(op.ignore_failures)
338 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
341 class TestInstanceInfo(unittest.TestCase):
343 clfactory = _FakeClientFactory(_FakeClient)
344 handler = _CreateHandler(rlib2.R_2_instances_name_info, ["inst31217"], {
347 job_id = handler.GET()
349 cl = clfactory.GetNextClient()
350 self.assertRaises(IndexError, clfactory.GetNextClient)
352 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
353 self.assertEqual(job_id, exp_job_id)
354 self.assertTrue(isinstance(op, opcodes.OpInstanceQueryData))
355 self.assertEqual(op.instances, ["inst31217"])
356 self.assertTrue(op.static)
358 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
361 class TestInstanceReboot(unittest.TestCase):
363 clfactory = _FakeClientFactory(_FakeClient)
364 handler = _CreateHandler(rlib2.R_2_instances_name_reboot, ["inst847"], {
366 "ignore_secondaries": ["1"],
368 job_id = handler.POST()
370 cl = clfactory.GetNextClient()
371 self.assertRaises(IndexError, clfactory.GetNextClient)
373 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
374 self.assertEqual(job_id, exp_job_id)
375 self.assertTrue(isinstance(op, opcodes.OpInstanceReboot))
376 self.assertEqual(op.instance_name, "inst847")
377 self.assertEqual(op.reboot_type, constants.INSTANCE_REBOOT_HARD)
378 self.assertTrue(op.ignore_secondaries)
379 self.assertTrue(op.dry_run)
381 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
384 class TestInstanceStartup(unittest.TestCase):
386 clfactory = _FakeClientFactory(_FakeClient)
387 handler = _CreateHandler(rlib2.R_2_instances_name_startup, ["inst31083"], {
389 "no_remember": ["1"],
391 job_id = handler.PUT()
393 cl = clfactory.GetNextClient()
394 self.assertRaises(IndexError, clfactory.GetNextClient)
396 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
397 self.assertEqual(job_id, exp_job_id)
398 self.assertTrue(isinstance(op, opcodes.OpInstanceStartup))
399 self.assertEqual(op.instance_name, "inst31083")
400 self.assertTrue(op.no_remember)
401 self.assertTrue(op.force)
402 self.assertFalse(op.dry_run)
404 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
407 class TestInstanceShutdown(unittest.TestCase):
409 clfactory = _FakeClientFactory(_FakeClient)
410 handler = _CreateHandler(rlib2.R_2_instances_name_shutdown, ["inst26791"], {
411 "no_remember": ["0"],
413 job_id = handler.PUT()
415 cl = clfactory.GetNextClient()
416 self.assertRaises(IndexError, clfactory.GetNextClient)
418 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
419 self.assertEqual(job_id, exp_job_id)
420 self.assertTrue(isinstance(op, opcodes.OpInstanceShutdown))
421 self.assertEqual(op.instance_name, "inst26791")
422 self.assertFalse(op.no_remember)
423 self.assertFalse(op.dry_run)
425 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
428 class TestInstanceActivateDisks(unittest.TestCase):
430 clfactory = _FakeClientFactory(_FakeClient)
431 handler = _CreateHandler(rlib2.R_2_instances_name_activate_disks, ["xyz"], {
432 "ignore_size": ["1"],
434 job_id = handler.PUT()
436 cl = clfactory.GetNextClient()
437 self.assertRaises(IndexError, clfactory.GetNextClient)
439 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
440 self.assertEqual(job_id, exp_job_id)
441 self.assertTrue(isinstance(op, opcodes.OpInstanceActivateDisks))
442 self.assertEqual(op.instance_name, "xyz")
443 self.assertTrue(op.ignore_size)
444 self.assertFalse(hasattr(op, "dry_run"))
446 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
449 class TestInstanceDeactivateDisks(unittest.TestCase):
451 clfactory = _FakeClientFactory(_FakeClient)
452 handler = _CreateHandler(rlib2.R_2_instances_name_deactivate_disks,
453 ["inst22357"], {}, {}, clfactory)
454 job_id = handler.PUT()
456 cl = clfactory.GetNextClient()
457 self.assertRaises(IndexError, clfactory.GetNextClient)
459 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
460 self.assertEqual(job_id, exp_job_id)
461 self.assertTrue(isinstance(op, opcodes.OpInstanceDeactivateDisks))
462 self.assertEqual(op.instance_name, "inst22357")
463 self.assertFalse(hasattr(op, "dry_run"))
464 self.assertFalse(hasattr(op, "force"))
466 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
469 class TestInstanceRecreateDisks(unittest.TestCase):
471 clfactory = _FakeClientFactory(_FakeClient)
472 handler = _CreateHandler(rlib2.R_2_instances_name_recreate_disks,
473 ["inst22357"], {}, {}, clfactory)
474 job_id = handler.POST()
476 cl = clfactory.GetNextClient()
477 self.assertRaises(IndexError, clfactory.GetNextClient)
479 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
480 self.assertEqual(job_id, exp_job_id)
481 self.assertTrue(isinstance(op, opcodes.OpInstanceRecreateDisks))
482 self.assertEqual(op.instance_name, "inst22357")
483 self.assertFalse(hasattr(op, "dry_run"))
484 self.assertFalse(hasattr(op, "force"))
486 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
489 class TestInstanceFailover(unittest.TestCase):
491 clfactory = _FakeClientFactory(_FakeClient)
492 handler = _CreateHandler(rlib2.R_2_instances_name_failover,
493 ["inst12794"], {}, {}, clfactory)
494 job_id = handler.PUT()
496 cl = clfactory.GetNextClient()
497 self.assertRaises(IndexError, clfactory.GetNextClient)
499 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
500 self.assertEqual(job_id, exp_job_id)
501 self.assertTrue(isinstance(op, opcodes.OpInstanceFailover))
502 self.assertEqual(op.instance_name, "inst12794")
503 self.assertFalse(hasattr(op, "dry_run"))
504 self.assertFalse(hasattr(op, "force"))
506 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
509 class TestInstanceDiskGrow(unittest.TestCase):
511 clfactory = _FakeClientFactory(_FakeClient)
515 handler = _CreateHandler(rlib2.R_2_instances_name_disk_grow,
516 ["inst10742", "3"], {}, data, clfactory)
517 job_id = handler.POST()
519 cl = clfactory.GetNextClient()
520 self.assertRaises(IndexError, clfactory.GetNextClient)
522 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
523 self.assertEqual(job_id, exp_job_id)
524 self.assertTrue(isinstance(op, opcodes.OpInstanceGrowDisk))
525 self.assertEqual(op.instance_name, "inst10742")
526 self.assertEqual(op.disk, 3)
527 self.assertEqual(op.amount, 1024)
528 self.assertFalse(hasattr(op, "dry_run"))
529 self.assertFalse(hasattr(op, "force"))
531 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
534 class TestBackupPrepare(unittest.TestCase):
536 clfactory = _FakeClientFactory(_FakeClient)
538 "mode": constants.EXPORT_MODE_REMOTE,
540 handler = _CreateHandler(rlib2.R_2_instances_name_prepare_export,
541 ["inst17925"], queryargs, {}, clfactory)
542 job_id = handler.PUT()
544 cl = clfactory.GetNextClient()
545 self.assertRaises(IndexError, clfactory.GetNextClient)
547 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
548 self.assertEqual(job_id, exp_job_id)
549 self.assertTrue(isinstance(op, opcodes.OpBackupPrepare))
550 self.assertEqual(op.instance_name, "inst17925")
551 self.assertEqual(op.mode, constants.EXPORT_MODE_REMOTE)
552 self.assertFalse(hasattr(op, "dry_run"))
553 self.assertFalse(hasattr(op, "force"))
555 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
558 class TestGroupRemove(unittest.TestCase):
560 clfactory = _FakeClientFactory(_FakeClient)
561 handler = _CreateHandler(rlib2.R_2_groups_name,
562 ["grp28575"], {}, {}, clfactory)
563 job_id = handler.DELETE()
565 cl = clfactory.GetNextClient()
566 self.assertRaises(IndexError, clfactory.GetNextClient)
568 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
569 self.assertEqual(job_id, exp_job_id)
570 self.assertTrue(isinstance(op, opcodes.OpGroupRemove))
571 self.assertEqual(op.group_name, "grp28575")
572 self.assertFalse(op.dry_run)
573 self.assertFalse(hasattr(op, "force"))
575 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
578 class TestStorageQuery(unittest.TestCase):
580 clfactory = _FakeClientFactory(_FakeClient)
582 "storage_type": constants.ST_LVM_PV,
583 "output_fields": "name,other",
585 handler = _CreateHandler(rlib2.R_2_nodes_name_storage,
586 ["node21075"], queryargs, {}, clfactory)
587 job_id = handler.GET()
589 cl = clfactory.GetNextClient()
590 self.assertRaises(IndexError, clfactory.GetNextClient)
592 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
593 self.assertEqual(job_id, exp_job_id)
594 self.assertTrue(isinstance(op, opcodes.OpNodeQueryStorage))
595 self.assertEqual(op.nodes, ["node21075"])
596 self.assertEqual(op.storage_type, constants.ST_LVM_PV)
597 self.assertEqual(op.output_fields, ["name", "other"])
598 self.assertFalse(hasattr(op, "dry_run"))
599 self.assertFalse(hasattr(op, "force"))
601 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
603 def testErrors(self):
604 clfactory = _FakeClientFactory(_FakeClient)
607 "output_fields": "name,other",
609 handler = _CreateHandler(rlib2.R_2_nodes_name_storage,
610 ["node10538"], queryargs, {}, clfactory)
611 self.assertRaises(http.HttpBadRequest, handler.GET)
614 "storage_type": constants.ST_LVM_VG,
616 handler = _CreateHandler(rlib2.R_2_nodes_name_storage,
617 ["node21273"], queryargs, {}, clfactory)
618 self.assertRaises(http.HttpBadRequest, handler.GET)
621 "storage_type": "##unknown_storage##",
622 "output_fields": "name,other",
624 handler = _CreateHandler(rlib2.R_2_nodes_name_storage,
625 ["node10315"], queryargs, {}, clfactory)
626 self.assertRaises(http.HttpBadRequest, handler.GET)
629 class TestStorageModify(unittest.TestCase):
631 clfactory = _FakeClientFactory(_FakeClient)
633 for allocatable in [None, "1", "0"]:
635 "storage_type": constants.ST_LVM_VG,
639 if allocatable is not None:
640 queryargs["allocatable"] = allocatable
642 handler = _CreateHandler(rlib2.R_2_nodes_name_storage_modify,
643 ["node9292"], queryargs, {}, clfactory)
644 job_id = handler.PUT()
646 cl = clfactory.GetNextClient()
647 self.assertRaises(IndexError, clfactory.GetNextClient)
649 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
650 self.assertEqual(job_id, exp_job_id)
651 self.assertTrue(isinstance(op, opcodes.OpNodeModifyStorage))
652 self.assertEqual(op.node_name, "node9292")
653 self.assertEqual(op.storage_type, constants.ST_LVM_VG)
654 self.assertEqual(op.name, "pv-a")
655 if allocatable is None:
656 self.assertFalse(op.changes)
658 assert allocatable in ("0", "1")
659 self.assertEqual(op.changes, {
660 constants.SF_ALLOCATABLE: (allocatable == "1"),
662 self.assertFalse(hasattr(op, "dry_run"))
663 self.assertFalse(hasattr(op, "force"))
665 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
667 def testErrors(self):
668 clfactory = _FakeClientFactory(_FakeClient)
674 handler = _CreateHandler(rlib2.R_2_nodes_name_storage_modify,
675 ["node26016"], queryargs, {}, clfactory)
676 self.assertRaises(http.HttpBadRequest, handler.PUT)
680 "storage_type": constants.ST_LVM_VG,
682 handler = _CreateHandler(rlib2.R_2_nodes_name_storage_modify,
683 ["node21218"], queryargs, {}, clfactory)
684 self.assertRaises(http.HttpBadRequest, handler.PUT)
688 "storage_type": constants.ST_LVM_VG,
690 "allocatable": "noint",
692 handler = _CreateHandler(rlib2.R_2_nodes_name_storage_modify,
693 ["node30685"], queryargs, {}, clfactory)
694 self.assertRaises(http.HttpBadRequest, handler.PUT)
697 class TestStorageRepair(unittest.TestCase):
699 clfactory = _FakeClientFactory(_FakeClient)
701 "storage_type": constants.ST_LVM_PV,
704 handler = _CreateHandler(rlib2.R_2_nodes_name_storage_repair,
705 ["node19265"], queryargs, {}, clfactory)
706 job_id = handler.PUT()
708 cl = clfactory.GetNextClient()
709 self.assertRaises(IndexError, clfactory.GetNextClient)
711 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
712 self.assertEqual(job_id, exp_job_id)
713 self.assertTrue(isinstance(op, opcodes.OpRepairNodeStorage))
714 self.assertEqual(op.node_name, "node19265")
715 self.assertEqual(op.storage_type, constants.ST_LVM_PV)
716 self.assertEqual(op.name, "pv16611")
717 self.assertFalse(hasattr(op, "dry_run"))
718 self.assertFalse(hasattr(op, "force"))
720 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
722 def testErrors(self):
723 clfactory = _FakeClientFactory(_FakeClient)
729 handler = _CreateHandler(rlib2.R_2_nodes_name_storage_repair,
730 ["node11275"], queryargs, {}, clfactory)
731 self.assertRaises(http.HttpBadRequest, handler.PUT)
735 "storage_type": constants.ST_LVM_VG,
737 handler = _CreateHandler(rlib2.R_2_nodes_name_storage_repair,
738 ["node21218"], queryargs, {}, clfactory)
739 self.assertRaises(http.HttpBadRequest, handler.PUT)
742 class TestTags(unittest.TestCase):
744 rlib2.R_2_instances_name_tags,
745 rlib2.R_2_nodes_name_tags,
746 rlib2.R_2_groups_name_tags,
750 def testSetAndDelete(self):
751 clfactory = _FakeClientFactory(_FakeClient)
753 for method, opcls in [("PUT", opcodes.OpTagsSet),
754 ("DELETE", opcodes.OpTagsDel)]:
755 for idx, handler in enumerate(self.TAG_HANDLERS):
756 dry_run = bool(idx % 2)
757 name = "test%s" % idx
759 "tag": ["foo", "bar", "baz"],
760 "dry-run": str(int(dry_run)),
763 handler = _CreateHandler(handler, [name], queryargs, {}, clfactory)
764 job_id = getattr(handler, method)()
766 cl = clfactory.GetNextClient()
767 self.assertRaises(IndexError, clfactory.GetNextClient)
769 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
770 self.assertEqual(job_id, exp_job_id)
771 self.assertTrue(isinstance(op, opcls))
772 self.assertEqual(op.kind, handler.TAG_LEVEL)
773 if handler.TAG_LEVEL == constants.TAG_CLUSTER:
774 self.assertTrue(op.name is None)
776 self.assertEqual(op.name, name)
777 self.assertEqual(op.tags, ["foo", "bar", "baz"])
778 self.assertEqual(op.dry_run, dry_run)
779 self.assertFalse(hasattr(op, "force"))
781 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
784 class TestInstanceCreation(testutils.GanetiTestCase):
786 clfactory = _FakeClientFactory(_FakeClient)
788 name = "inst863.example.com"
795 [{"size": 5, }, {"size": 100, }],
798 [{"size": 123, "mode": constants.DISK_RDWR, }],
810 { "ip": "192.0.2.6", "mode": constants.NIC_MODE_ROUTED,
811 "mac": "01:23:45:67:68:9A",
813 { "mode": constants.NIC_MODE_BRIDGED, "link": "br1" },
820 { constants.BE_VCPUS: 2, },
821 { constants.BE_MAXMEM: 200, },
822 { constants.BE_MEMORY: 256, },
823 { constants.BE_VCPUS: 2,
824 constants.BE_MAXMEM: 1024,
825 constants.BE_MINMEM: 1024,
826 constants.BE_AUTO_BALANCE: True,
827 constants.BE_ALWAYS_FAILOVER: True, }
832 { constants.HV_BOOT_ORDER: "anc", },
833 { constants.HV_KERNEL_PATH: "/boot/fookernel",
834 constants.HV_ROOT_PATH: "/dev/hda1", },
837 for mode in [constants.INSTANCE_CREATE, constants.INSTANCE_IMPORT]:
838 for nics in nic_variants:
839 for disk_template in constants.DISK_TEMPLATES:
840 for disks in disk_variants:
841 for beparams in beparam_variants:
842 for hvparams in hvparam_variants:
843 for dry_run in [False, True]:
845 "dry-run": str(int(dry_run)),
849 rlib2._REQ_DATA_VERSION: 1,
851 "hypervisor": constants.HT_FAKE,
855 "disk_template": disk_template,
859 if beparams is not None:
860 data["beparams"] = beparams
862 if hvparams is not None:
863 data["hvparams"] = hvparams
865 handler = _CreateHandler(rlib2.R_2_instances, [],
866 queryargs, data, clfactory)
867 job_id = handler.POST()
869 cl = clfactory.GetNextClient()
870 self.assertRaises(IndexError, clfactory.GetNextClient)
872 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
873 self.assertEqual(job_id, exp_job_id)
874 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
876 self.assertTrue(isinstance(op, opcodes.OpInstanceCreate))
877 self.assertEqual(op.instance_name, name)
878 self.assertEqual(op.mode, mode)
879 self.assertEqual(op.disk_template, disk_template)
880 self.assertEqual(op.dry_run, dry_run)
881 self.assertEqual(len(op.disks), len(disks))
882 self.assertEqual(len(op.nics), len(nics))
884 for opdisk, disk in zip(op.disks, disks):
885 for key in constants.IDISK_PARAMS:
886 self.assertEqual(opdisk.get(key), disk.get(key))
887 self.assertFalse("unknown" in opdisk)
889 for opnic, nic in zip(op.nics, nics):
890 for key in constants.INIC_PARAMS:
891 self.assertEqual(opnic.get(key), nic.get(key))
892 self.assertFalse("unknown" in opnic)
893 self.assertFalse("foobar" in opnic)
896 self.assertFalse(hasattr(op, "beparams"))
898 self.assertEqualValues(op.beparams, beparams)
901 self.assertFalse(hasattr(op, "hvparams"))
903 self.assertEqualValues(op.hvparams, hvparams)
905 def testLegacyName(self):
906 clfactory = _FakeClientFactory(_FakeClient)
908 name = "inst29128.example.com"
910 rlib2._REQ_DATA_VERSION: 1,
914 "mode": constants.INSTANCE_CREATE,
915 "disk_template": constants.DT_PLAIN,
918 handler = _CreateHandler(rlib2.R_2_instances, [], {}, data, clfactory)
919 job_id = handler.POST()
921 cl = clfactory.GetNextClient()
922 self.assertRaises(IndexError, clfactory.GetNextClient)
924 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
925 self.assertEqual(job_id, exp_job_id)
926 self.assertTrue(isinstance(op, opcodes.OpInstanceCreate))
927 self.assertEqual(op.instance_name, name)
928 self.assertFalse(hasattr(op, "name"))
929 self.assertFalse(op.dry_run)
931 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
934 data["instance_name"] = "other.example.com"
935 assert "name" in data and "instance_name" in data
936 handler = _CreateHandler(rlib2.R_2_instances, [], {}, data, clfactory)
937 self.assertRaises(http.HttpBadRequest, handler.POST)
938 self.assertRaises(IndexError, clfactory.GetNextClient)
940 def testLegacyOs(self):
941 clfactory = _FakeClientFactory(_FakeClient)
943 name = "inst4673.example.com"
946 rlib2._REQ_DATA_VERSION: 1,
951 "mode": constants.INSTANCE_CREATE,
952 "disk_template": constants.DT_PLAIN,
955 handler = _CreateHandler(rlib2.R_2_instances, [], {}, data, clfactory)
956 job_id = handler.POST()
958 cl = clfactory.GetNextClient()
959 self.assertRaises(IndexError, clfactory.GetNextClient)
961 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
962 self.assertEqual(job_id, exp_job_id)
963 self.assertTrue(isinstance(op, opcodes.OpInstanceCreate))
964 self.assertEqual(op.instance_name, name)
965 self.assertEqual(op.os_type, os)
966 self.assertFalse(hasattr(op, "os"))
967 self.assertFalse(op.dry_run)
969 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
972 data["os"] = "linux9584"
973 assert "os" in data and "os_type" in data
974 handler = _CreateHandler(rlib2.R_2_instances, [], {}, data, clfactory)
975 self.assertRaises(http.HttpBadRequest, handler.POST)
977 def testErrors(self):
978 clfactory = _FakeClientFactory(_FakeClient)
980 # Test all required fields
982 rlib2._REQ_DATA_VERSION: 1,
983 "name": "inst1.example.com",
986 "mode": constants.INSTANCE_CREATE,
987 "disk_template": constants.DT_PLAIN,
990 for name in reqfields.keys():
991 data = dict(i for i in reqfields.iteritems() if i[0] != name)
993 handler = _CreateHandler(rlib2.R_2_instances, [], {}, data, clfactory)
994 self.assertRaises(http.HttpBadRequest, handler.POST)
995 self.assertRaises(IndexError, clfactory.GetNextClient)
997 # Invalid disks and nics
998 for field in ["disks", "nics"]:
999 invalid_values = [None, 1, "", {}, [1, 2, 3], ["hda1", "hda2"],
1000 [{"_unknown_": 999, }]]
1002 for invvalue in invalid_values:
1003 data = reqfields.copy()
1004 data[field] = invvalue
1005 handler = _CreateHandler(rlib2.R_2_instances, [], {}, data, clfactory)
1006 self.assertRaises(http.HttpBadRequest, handler.POST)
1007 self.assertRaises(IndexError, clfactory.GetNextClient)
1009 def testVersion(self):
1010 clfactory = _FakeClientFactory(_FakeClient)
1014 "name": "inst1.example.com",
1017 "mode": constants.INSTANCE_CREATE,
1018 "disk_template": constants.DT_PLAIN,
1021 handler = _CreateHandler(rlib2.R_2_instances, [], {}, data, clfactory)
1022 self.assertRaises(http.HttpBadRequest, handler.POST)
1024 # Old and incorrect versions
1025 for version in [0, -1, 10483, "Hello World"]:
1026 data[rlib2._REQ_DATA_VERSION] = version
1028 handler = _CreateHandler(rlib2.R_2_instances, [], {}, data, clfactory)
1029 self.assertRaises(http.HttpBadRequest, handler.POST)
1031 self.assertRaises(IndexError, clfactory.GetNextClient)
1034 data[rlib2._REQ_DATA_VERSION] = 1
1035 handler = _CreateHandler(rlib2.R_2_instances, [], {}, data, clfactory)
1036 job_id = handler.POST()
1038 cl = clfactory.GetNextClient()
1039 self.assertRaises(IndexError, clfactory.GetNextClient)
1041 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1042 self.assertEqual(job_id, exp_job_id)
1043 self.assertTrue(isinstance(op, opcodes.OpInstanceCreate))
1044 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1047 class TestBackupExport(unittest.TestCase):
1049 clfactory = _FakeClientFactory(_FakeClient)
1053 "mode": constants.EXPORT_MODE_REMOTE,
1054 "destination": [(1, 2, 3), (99, 99, 99)],
1056 "remove_instance": True,
1057 "x509_key_name": ["name", "hash"],
1058 "destination_x509_ca": "---cert---"
1061 handler = _CreateHandler(rlib2.R_2_instances_name_export, [name], {},
1063 job_id = handler.PUT()
1065 cl = clfactory.GetNextClient()
1066 self.assertRaises(IndexError, clfactory.GetNextClient)
1068 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1069 self.assertEqual(job_id, exp_job_id)
1070 self.assertTrue(isinstance(op, opcodes.OpBackupExport))
1071 self.assertEqual(op.instance_name, name)
1072 self.assertEqual(op.mode, constants.EXPORT_MODE_REMOTE)
1073 self.assertEqual(op.target_node, [(1, 2, 3), (99, 99, 99)])
1074 self.assertEqual(op.shutdown, True)
1075 self.assertEqual(op.remove_instance, True)
1076 self.assertEqual(op.x509_key_name, ["name", "hash"])
1077 self.assertEqual(op.destination_x509_ca, "---cert---")
1078 self.assertFalse(hasattr(op, "dry_run"))
1079 self.assertFalse(hasattr(op, "force"))
1081 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1083 def testDefaults(self):
1084 clfactory = _FakeClientFactory(_FakeClient)
1088 "destination": "node2",
1092 handler = _CreateHandler(rlib2.R_2_instances_name_export, [name], {},
1094 job_id = handler.PUT()
1096 cl = clfactory.GetNextClient()
1097 self.assertRaises(IndexError, clfactory.GetNextClient)
1099 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1100 self.assertEqual(job_id, exp_job_id)
1101 self.assertTrue(isinstance(op, opcodes.OpBackupExport))
1102 self.assertEqual(op.instance_name, name)
1103 self.assertEqual(op.target_node, "node2")
1104 self.assertFalse(hasattr(op, "mode"))
1105 self.assertFalse(hasattr(op, "remove_instance"))
1106 self.assertFalse(hasattr(op, "destination"))
1107 self.assertFalse(hasattr(op, "dry_run"))
1108 self.assertFalse(hasattr(op, "force"))
1110 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1112 def testErrors(self):
1113 clfactory = _FakeClientFactory(_FakeClient)
1115 for value in ["True", "False"]:
1116 handler = _CreateHandler(rlib2.R_2_instances_name_export, ["err1"], {}, {
1117 "remove_instance": value,
1119 self.assertRaises(http.HttpBadRequest, handler.PUT)
1122 class TestInstanceMigrate(testutils.GanetiTestCase):
1124 clfactory = _FakeClientFactory(_FakeClient)
1126 name = "instYooho6ek"
1128 for cleanup in [False, True]:
1129 for mode in constants.HT_MIGRATION_MODES:
1135 handler = _CreateHandler(rlib2.R_2_instances_name_migrate, [name], {},
1137 job_id = handler.PUT()
1139 cl = clfactory.GetNextClient()
1140 self.assertRaises(IndexError, clfactory.GetNextClient)
1142 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1143 self.assertEqual(job_id, exp_job_id)
1144 self.assertTrue(isinstance(op, opcodes.OpInstanceMigrate))
1145 self.assertEqual(op.instance_name, name)
1146 self.assertEqual(op.mode, mode)
1147 self.assertEqual(op.cleanup, cleanup)
1148 self.assertFalse(hasattr(op, "dry_run"))
1149 self.assertFalse(hasattr(op, "force"))
1151 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1153 def testDefaults(self):
1154 clfactory = _FakeClientFactory(_FakeClient)
1156 name = "instnohZeex0"
1158 handler = _CreateHandler(rlib2.R_2_instances_name_migrate, [name], {}, {},
1160 job_id = handler.PUT()
1162 cl = clfactory.GetNextClient()
1163 self.assertRaises(IndexError, clfactory.GetNextClient)
1165 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1166 self.assertEqual(job_id, exp_job_id)
1167 self.assertTrue(isinstance(op, opcodes.OpInstanceMigrate))
1168 self.assertEqual(op.instance_name, name)
1169 self.assertFalse(hasattr(op, "mode"))
1170 self.assertFalse(hasattr(op, "cleanup"))
1171 self.assertFalse(hasattr(op, "dry_run"))
1172 self.assertFalse(hasattr(op, "force"))
1174 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1177 class TestParseRenameInstanceRequest(testutils.GanetiTestCase):
1179 clfactory = _FakeClientFactory(_FakeClient)
1181 name = "instij0eeph7"
1183 for new_name in ["ua0aiyoo", "fai3ongi"]:
1184 for ip_check in [False, True]:
1185 for name_check in [False, True]:
1187 "new_name": new_name,
1188 "ip_check": ip_check,
1189 "name_check": name_check,
1192 handler = _CreateHandler(rlib2.R_2_instances_name_rename, [name],
1193 {}, data, clfactory)
1194 job_id = handler.PUT()
1196 cl = clfactory.GetNextClient()
1197 self.assertRaises(IndexError, clfactory.GetNextClient)
1199 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1200 self.assertEqual(job_id, exp_job_id)
1201 self.assertTrue(isinstance(op, opcodes.OpInstanceRename))
1202 self.assertEqual(op.instance_name, name)
1203 self.assertEqual(op.new_name, new_name)
1204 self.assertEqual(op.ip_check, ip_check)
1205 self.assertEqual(op.name_check, name_check)
1206 self.assertFalse(hasattr(op, "dry_run"))
1207 self.assertFalse(hasattr(op, "force"))
1209 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1211 def testDefaults(self):
1212 clfactory = _FakeClientFactory(_FakeClient)
1214 name = "instahchie3t"
1216 for new_name in ["thag9mek", "quees7oh"]:
1218 "new_name": new_name,
1221 handler = _CreateHandler(rlib2.R_2_instances_name_rename, [name],
1222 {}, data, clfactory)
1223 job_id = handler.PUT()
1225 cl = clfactory.GetNextClient()
1226 self.assertRaises(IndexError, clfactory.GetNextClient)
1228 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1229 self.assertEqual(job_id, exp_job_id)
1230 self.assertTrue(isinstance(op, opcodes.OpInstanceRename))
1231 self.assertEqual(op.instance_name, name)
1232 self.assertEqual(op.new_name, new_name)
1233 self.assertFalse(hasattr(op, "ip_check"))
1234 self.assertFalse(hasattr(op, "name_check"))
1235 self.assertFalse(hasattr(op, "dry_run"))
1236 self.assertFalse(hasattr(op, "force"))
1238 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1241 class TestParseModifyInstanceRequest(unittest.TestCase):
1243 clfactory = _FakeClientFactory(_FakeClient)
1245 name = "instush8gah"
1249 [(1, { constants.IDISK_MODE: constants.DISK_RDWR, })],
1252 for osparams in [{}, { "some": "value", "other": "Hello World", }]:
1253 for hvparams in [{}, { constants.HV_KERNEL_PATH: "/some/kernel", }]:
1254 for beparams in [{}, { constants.BE_MAXMEM: 128, }]:
1255 for force in [False, True]:
1256 for nics in [[], [(0, { constants.INIC_IP: "192.0.2.1", })]]:
1257 for disks in test_disks:
1258 for disk_template in constants.DISK_TEMPLATES:
1260 "osparams": osparams,
1261 "hvparams": hvparams,
1262 "beparams": beparams,
1266 "disk_template": disk_template,
1269 handler = _CreateHandler(rlib2.R_2_instances_name_modify,
1270 [name], {}, data, clfactory)
1271 job_id = handler.PUT()
1273 cl = clfactory.GetNextClient()
1274 self.assertRaises(IndexError, clfactory.GetNextClient)
1276 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1277 self.assertEqual(job_id, exp_job_id)
1278 self.assertTrue(isinstance(op, opcodes.OpInstanceSetParams))
1279 self.assertEqual(op.instance_name, name)
1280 self.assertEqual(op.hvparams, hvparams)
1281 self.assertEqual(op.beparams, beparams)
1282 self.assertEqual(op.osparams, osparams)
1283 self.assertEqual(op.force, force)
1284 self.assertEqual(op.nics, nics)
1285 self.assertEqual(op.disks, disks)
1286 self.assertEqual(op.disk_template, disk_template)
1287 self.assertFalse(hasattr(op, "remote_node"))
1288 self.assertFalse(hasattr(op, "os_name"))
1289 self.assertFalse(hasattr(op, "force_variant"))
1290 self.assertFalse(hasattr(op, "dry_run"))
1292 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1294 def testDefaults(self):
1295 clfactory = _FakeClientFactory(_FakeClient)
1297 name = "instir8aish31"
1299 handler = _CreateHandler(rlib2.R_2_instances_name_modify,
1300 [name], {}, {}, clfactory)
1301 job_id = handler.PUT()
1303 cl = clfactory.GetNextClient()
1304 self.assertRaises(IndexError, clfactory.GetNextClient)
1306 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1307 self.assertEqual(job_id, exp_job_id)
1308 self.assertTrue(isinstance(op, opcodes.OpInstanceSetParams))
1309 self.assertEqual(op.instance_name, name)
1311 for i in ["hvparams", "beparams", "osparams", "force", "nics", "disks",
1312 "disk_template", "remote_node", "os_name", "force_variant"]:
1313 self.assertFalse(hasattr(op, i))
1316 class TestParseInstanceReinstallRequest(testutils.GanetiTestCase):
1318 testutils.GanetiTestCase.setUp(self)
1320 self.Parse = rlib2._ParseInstanceReinstallRequest
1322 def _Check(self, ops, name):
1324 opcodes.OpInstanceShutdown,
1325 opcodes.OpInstanceReinstall,
1326 opcodes.OpInstanceStartup,
1329 self.assert_(compat.all(isinstance(op, exp)
1330 for op, exp in zip(ops, expcls)))
1331 self.assert_(compat.all(op.instance_name == name for op in ops))
1334 name = "shoo0tihohma"
1336 ops = self.Parse(name, {"os": "sys1", "start": True,})
1337 self.assertEqual(len(ops), 3)
1338 self._Check(ops, name)
1339 self.assertEqual(ops[1].os_type, "sys1")
1340 self.assertFalse(ops[1].osparams)
1342 ops = self.Parse(name, {"os": "sys2", "start": False,})
1343 self.assertEqual(len(ops), 2)
1344 self._Check(ops, name)
1345 self.assertEqual(ops[1].os_type, "sys2")
1350 ops = self.Parse(name, {"os": "sys4035", "start": True,
1351 "osparams": osparams,})
1352 self.assertEqual(len(ops), 3)
1353 self._Check(ops, name)
1354 self.assertEqual(ops[1].os_type, "sys4035")
1355 self.assertEqual(ops[1].osparams, osparams)
1357 def testDefaults(self):
1360 ops = self.Parse(name, {"os": "linux1"})
1361 self.assertEqual(len(ops), 3)
1362 self._Check(ops, name)
1363 self.assertEqual(ops[1].os_type, "linux1")
1364 self.assertFalse(ops[1].osparams)
1366 def testErrors(self):
1367 self.assertRaises(http.HttpBadRequest, self.Parse,
1368 "foo", "not a dictionary")
1371 class TestGroupRename(unittest.TestCase):
1373 clfactory = _FakeClientFactory(_FakeClient)
1375 name = "group608242564"
1377 "new_name": "ua0aiyoo15112",
1380 handler = _CreateHandler(rlib2.R_2_groups_name_rename, [name], {}, data,
1382 job_id = handler.PUT()
1384 cl = clfactory.GetNextClient()
1385 self.assertRaises(IndexError, clfactory.GetNextClient)
1387 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1388 self.assertEqual(job_id, exp_job_id)
1390 self.assertTrue(isinstance(op, opcodes.OpGroupRename))
1391 self.assertEqual(op.group_name, name)
1392 self.assertEqual(op.new_name, "ua0aiyoo15112")
1393 self.assertFalse(op.dry_run)
1394 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1396 def testDryRun(self):
1397 clfactory = _FakeClientFactory(_FakeClient)
1401 "new_name": "ua0aiyoo",
1404 handler = _CreateHandler(rlib2.R_2_groups_name_rename, [name], {
1407 job_id = handler.PUT()
1409 cl = clfactory.GetNextClient()
1410 self.assertRaises(IndexError, clfactory.GetNextClient)
1412 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1413 self.assertEqual(job_id, exp_job_id)
1415 self.assertTrue(isinstance(op, opcodes.OpGroupRename))
1416 self.assertEqual(op.group_name, name)
1417 self.assertEqual(op.new_name, "ua0aiyoo")
1418 self.assertTrue(op.dry_run)
1419 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1422 class TestInstanceReplaceDisks(unittest.TestCase):
1424 clfactory = _FakeClientFactory(_FakeClient)
1428 for disks in [range(1, 4), "1,2,3", "1, 2, 3"]:
1430 "mode": constants.REPLACE_DISK_SEC,
1432 "iallocator": "myalloc",
1435 handler = _CreateHandler(rlib2.R_2_instances_name_replace_disks,
1436 [name], {}, data, clfactory)
1437 job_id = handler.POST()
1439 cl = clfactory.GetNextClient()
1440 self.assertRaises(IndexError, clfactory.GetNextClient)
1442 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1443 self.assertEqual(job_id, exp_job_id)
1445 self.assertTrue(isinstance(op, opcodes.OpInstanceReplaceDisks))
1446 self.assertEqual(op.instance_name, name)
1447 self.assertEqual(op.mode, constants.REPLACE_DISK_SEC)
1448 self.assertEqual(op.disks, [1, 2, 3])
1449 self.assertEqual(op.iallocator, "myalloc")
1450 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1452 def testDefaults(self):
1453 clfactory = _FakeClientFactory(_FakeClient)
1457 "mode": constants.REPLACE_DISK_AUTO,
1460 handler = _CreateHandler(rlib2.R_2_instances_name_replace_disks,
1461 [name], {}, data, clfactory)
1462 job_id = handler.POST()
1464 cl = clfactory.GetNextClient()
1465 self.assertRaises(IndexError, clfactory.GetNextClient)
1467 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1468 self.assertEqual(job_id, exp_job_id)
1470 self.assertTrue(isinstance(op, opcodes.OpInstanceReplaceDisks))
1471 self.assertEqual(op.instance_name, name)
1472 self.assertEqual(op.mode, constants.REPLACE_DISK_AUTO)
1473 self.assertFalse(hasattr(op, "iallocator"))
1474 self.assertFalse(hasattr(op, "disks"))
1475 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1477 def testNoDisks(self):
1478 clfactory = _FakeClientFactory(_FakeClient)
1480 handler = _CreateHandler(rlib2.R_2_instances_name_replace_disks,
1481 ["inst20661"], {}, {}, clfactory)
1482 self.assertRaises(http.HttpBadRequest, handler.POST)
1484 for disks in [None, "", {}]:
1485 handler = _CreateHandler(rlib2.R_2_instances_name_replace_disks,
1486 ["inst20661"], {}, {
1489 self.assertRaises(http.HttpBadRequest, handler.POST)
1491 def testWrong(self):
1492 clfactory = _FakeClientFactory(_FakeClient)
1495 "mode": constants.REPLACE_DISK_AUTO,
1496 "disks": "hello world",
1499 handler = _CreateHandler(rlib2.R_2_instances_name_replace_disks,
1500 ["foo"], {}, data, clfactory)
1501 self.assertRaises(http.HttpBadRequest, handler.POST)
1504 class TestGroupModify(unittest.TestCase):
1506 clfactory = _FakeClientFactory(_FakeClient)
1510 for policy in constants.VALID_ALLOC_POLICIES:
1512 "alloc_policy": policy,
1515 handler = _CreateHandler(rlib2.R_2_groups_name_modify, [name], {}, data,
1517 job_id = handler.PUT()
1519 cl = clfactory.GetNextClient()
1520 self.assertRaises(IndexError, clfactory.GetNextClient)
1522 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1523 self.assertEqual(job_id, exp_job_id)
1525 self.assertTrue(isinstance(op, opcodes.OpGroupSetParams))
1526 self.assertEqual(op.group_name, name)
1527 self.assertEqual(op.alloc_policy, policy)
1528 self.assertFalse(hasattr(op, "dry_run"))
1529 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1531 def testUnknownPolicy(self):
1532 clfactory = _FakeClientFactory(_FakeClient)
1535 "alloc_policy": "_unknown_policy_",
1538 handler = _CreateHandler(rlib2.R_2_groups_name_modify, ["xyz"], {}, data,
1540 self.assertRaises(http.HttpBadRequest, handler.PUT)
1541 self.assertRaises(IndexError, clfactory.GetNextClient)
1543 def testDefaults(self):
1544 clfactory = _FakeClientFactory(_FakeClient)
1548 handler = _CreateHandler(rlib2.R_2_groups_name_modify, [name], {}, {},
1550 job_id = handler.PUT()
1552 cl = clfactory.GetNextClient()
1553 self.assertRaises(IndexError, clfactory.GetNextClient)
1555 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1556 self.assertEqual(job_id, exp_job_id)
1558 self.assertTrue(isinstance(op, opcodes.OpGroupSetParams))
1559 self.assertEqual(op.group_name, name)
1560 self.assertFalse(hasattr(op, "alloc_policy"))
1561 self.assertFalse(hasattr(op, "dry_run"))
1562 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1565 class TestGroupAdd(unittest.TestCase):
1568 clfactory = _FakeClientFactory(_FakeClient)
1570 for policy in constants.VALID_ALLOC_POLICIES:
1573 "alloc_policy": policy,
1576 handler = _CreateHandler(rlib2.R_2_groups, [], {}, data,
1578 job_id = handler.POST()
1580 cl = clfactory.GetNextClient()
1581 self.assertRaises(IndexError, clfactory.GetNextClient)
1583 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1584 self.assertEqual(job_id, exp_job_id)
1586 self.assertTrue(isinstance(op, opcodes.OpGroupAdd))
1587 self.assertEqual(op.group_name, name)
1588 self.assertEqual(op.alloc_policy, policy)
1589 self.assertFalse(op.dry_run)
1590 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1592 def testUnknownPolicy(self):
1593 clfactory = _FakeClientFactory(_FakeClient)
1596 "alloc_policy": "_unknown_policy_",
1599 handler = _CreateHandler(rlib2.R_2_groups, [], {}, data, clfactory)
1600 self.assertRaises(http.HttpBadRequest, handler.POST)
1601 self.assertRaises(IndexError, clfactory.GetNextClient)
1603 def testDefaults(self):
1604 clfactory = _FakeClientFactory(_FakeClient)
1611 handler = _CreateHandler(rlib2.R_2_groups, [], {}, data, clfactory)
1612 job_id = handler.POST()
1614 cl = clfactory.GetNextClient()
1615 self.assertRaises(IndexError, clfactory.GetNextClient)
1617 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1618 self.assertEqual(job_id, exp_job_id)
1620 self.assertTrue(isinstance(op, opcodes.OpGroupAdd))
1621 self.assertEqual(op.group_name, name)
1622 self.assertFalse(hasattr(op, "alloc_policy"))
1623 self.assertFalse(op.dry_run)
1625 def testLegacyName(self):
1626 clfactory = _FakeClientFactory(_FakeClient)
1633 handler = _CreateHandler(rlib2.R_2_groups, [], {
1636 job_id = handler.POST()
1638 cl = clfactory.GetNextClient()
1639 self.assertRaises(IndexError, clfactory.GetNextClient)
1641 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1642 self.assertEqual(job_id, exp_job_id)
1644 self.assertTrue(isinstance(op, opcodes.OpGroupAdd))
1645 self.assertEqual(op.group_name, name)
1646 self.assertFalse(hasattr(op, "alloc_policy"))
1647 self.assertTrue(op.dry_run)
1650 class TestNodeRole(unittest.TestCase):
1652 clfactory = _FakeClientFactory(_FakeClient)
1654 for role in rlib2._NR_MAP.values():
1655 handler = _CreateHandler(rlib2.R_2_nodes_name_role,
1656 ["node-z"], {}, role, clfactory)
1657 if role == rlib2._NR_MASTER:
1658 self.assertRaises(http.HttpBadRequest, handler.PUT)
1660 job_id = handler.PUT()
1662 cl = clfactory.GetNextClient()
1663 self.assertRaises(IndexError, clfactory.GetNextClient)
1665 (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
1666 self.assertEqual(job_id, exp_job_id)
1667 self.assertTrue(isinstance(op, opcodes.OpNodeSetParams))
1668 self.assertEqual(op.node_name, "node-z")
1669 self.assertFalse(op.force)
1670 self.assertFalse(hasattr(op, "dry_run"))
1672 if role == rlib2._NR_REGULAR:
1673 self.assertFalse(op.drained)
1674 self.assertFalse(op.offline)
1675 self.assertFalse(op.master_candidate)
1676 elif role == rlib2._NR_MASTER_CANDIDATE:
1677 self.assertFalse(op.drained)
1678 self.assertFalse(op.offline)
1679 self.assertTrue(op.master_candidate)
1680 elif role == rlib2._NR_DRAINED:
1681 self.assertTrue(op.drained)
1682 self.assertFalse(op.offline)
1683 self.assertFalse(op.master_candidate)
1684 elif role == rlib2._NR_OFFLINE:
1685 self.assertFalse(op.drained)
1686 self.assertTrue(op.offline)
1687 self.assertFalse(op.master_candidate)
1689 self.fail("Unknown role '%s'" % role)
1691 self.assertRaises(IndexError, cl.GetNextSubmittedJob)
1694 class TestSimpleResources(unittest.TestCase):
1696 self.clfactory = _FakeClientFactory(_FakeClient)
1699 self.assertRaises(IndexError, self.clfactory.GetNextClient)
1701 def testFeatures(self):
1702 handler = _CreateHandler(rlib2.R_2_features, [], {}, None, self.clfactory)
1703 self.assertEqual(set(handler.GET()), rlib2.ALL_FEATURES)
1705 def testEmpty(self):
1706 for cls in [rlib2.R_root, rlib2.R_2]:
1707 handler = _CreateHandler(cls, [], {}, None, self.clfactory)
1708 self.assertTrue(handler.GET() is None)
1710 def testVersion(self):
1711 handler = _CreateHandler(rlib2.R_version, [], {}, None, self.clfactory)
1712 self.assertEqual(handler.GET(), constants.RAPI_VERSION)
1715 class TestClusterInfo(unittest.TestCase):
1716 class _ClusterInfoClient:
1718 self.cluster_info = None
1720 def QueryClusterInfo(self):
1721 assert self.cluster_info is None
1722 self.cluster_info = object()
1723 return self.cluster_info
1726 clfactory = _FakeClientFactory(self._ClusterInfoClient)
1727 handler = _CreateHandler(rlib2.R_2_info, [], {}, None, clfactory)
1728 result = handler.GET()
1729 cl = clfactory.GetNextClient()
1730 self.assertRaises(IndexError, clfactory.GetNextClient)
1731 self.assertEqual(result, cl.cluster_info)
1734 if __name__ == '__main__':
1735 testutils.GanetiTestProgram()