+ clfactory = _FakeClientFactory(_FakeClient)
+
+ for value in ["True", "False"]:
+ handler = _CreateHandler(rlib2.R_2_instances_name_export, ["err1"], {}, {
+ "remove_instance": value,
+ }, clfactory)
+ self.assertRaises(http.HttpBadRequest, handler.PUT)
+
+
+class TestInstanceMigrate(testutils.GanetiTestCase):
+ def test(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "instYooho6ek"
+
+ for cleanup in [False, True]:
+ for mode in constants.HT_MIGRATION_MODES:
+ data = {
+ "cleanup": cleanup,
+ "mode": mode,
+ }
+
+ handler = _CreateHandler(rlib2.R_2_instances_name_migrate, [name], {},
+ data, clfactory)
+ job_id = handler.PUT()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+ self.assertTrue(isinstance(op, opcodes.OpInstanceMigrate))
+ self.assertEqual(op.instance_name, name)
+ self.assertEqual(op.mode, mode)
+ self.assertEqual(op.cleanup, cleanup)
+ self.assertFalse(hasattr(op, "dry_run"))
+ self.assertFalse(hasattr(op, "force"))
+
+ self.assertRaises(IndexError, cl.GetNextSubmittedJob)
+
+ def testDefaults(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "instnohZeex0"
+
+ handler = _CreateHandler(rlib2.R_2_instances_name_migrate, [name], {}, {},
+ clfactory)
+ job_id = handler.PUT()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+ self.assertTrue(isinstance(op, opcodes.OpInstanceMigrate))
+ self.assertEqual(op.instance_name, name)
+ self.assertFalse(hasattr(op, "mode"))
+ self.assertFalse(hasattr(op, "cleanup"))
+ self.assertFalse(hasattr(op, "dry_run"))
+ self.assertFalse(hasattr(op, "force"))
+
+ self.assertRaises(IndexError, cl.GetNextSubmittedJob)
+
+
+class TestParseRenameInstanceRequest(testutils.GanetiTestCase):
+ def test(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "instij0eeph7"
+
+ for new_name in ["ua0aiyoo", "fai3ongi"]:
+ for ip_check in [False, True]:
+ for name_check in [False, True]:
+ data = {
+ "new_name": new_name,
+ "ip_check": ip_check,
+ "name_check": name_check,
+ }
+
+ handler = _CreateHandler(rlib2.R_2_instances_name_rename, [name],
+ {}, data, clfactory)
+ job_id = handler.PUT()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+ self.assertTrue(isinstance(op, opcodes.OpInstanceRename))
+ self.assertEqual(op.instance_name, name)
+ self.assertEqual(op.new_name, new_name)
+ self.assertEqual(op.ip_check, ip_check)
+ self.assertEqual(op.name_check, name_check)
+ self.assertFalse(hasattr(op, "dry_run"))
+ self.assertFalse(hasattr(op, "force"))
+
+ self.assertRaises(IndexError, cl.GetNextSubmittedJob)
+
+ def testDefaults(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "instahchie3t"
+
+ for new_name in ["thag9mek", "quees7oh"]:
+ data = {
+ "new_name": new_name,
+ }
+
+ handler = _CreateHandler(rlib2.R_2_instances_name_rename, [name],
+ {}, data, clfactory)
+ job_id = handler.PUT()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+ self.assertTrue(isinstance(op, opcodes.OpInstanceRename))
+ self.assertEqual(op.instance_name, name)
+ self.assertEqual(op.new_name, new_name)
+ self.assertFalse(hasattr(op, "ip_check"))
+ self.assertFalse(hasattr(op, "name_check"))
+ self.assertFalse(hasattr(op, "dry_run"))
+ self.assertFalse(hasattr(op, "force"))
+
+ self.assertRaises(IndexError, cl.GetNextSubmittedJob)
+
+
+class TestParseModifyInstanceRequest(unittest.TestCase):
+ def test(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "instush8gah"
+
+ test_disks = [
+ [],
+ [(1, { constants.IDISK_MODE: constants.DISK_RDWR, })],
+ ]
+
+ for osparams in [{}, { "some": "value", "other": "Hello World", }]:
+ for hvparams in [{}, { constants.HV_KERNEL_PATH: "/some/kernel", }]:
+ for beparams in [{}, { constants.BE_MAXMEM: 128, }]:
+ for force in [False, True]:
+ for nics in [[], [(0, { constants.INIC_IP: "192.0.2.1", })]]:
+ for disks in test_disks:
+ for disk_template in constants.DISK_TEMPLATES:
+ data = {
+ "osparams": osparams,
+ "hvparams": hvparams,
+ "beparams": beparams,
+ "nics": nics,
+ "disks": disks,
+ "force": force,
+ "disk_template": disk_template,
+ }
+
+ handler = _CreateHandler(rlib2.R_2_instances_name_modify,
+ [name], {}, data, clfactory)
+ job_id = handler.PUT()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+ self.assertTrue(isinstance(op, opcodes.OpInstanceSetParams))
+ self.assertEqual(op.instance_name, name)
+ self.assertEqual(op.hvparams, hvparams)
+ self.assertEqual(op.beparams, beparams)
+ self.assertEqual(op.osparams, osparams)
+ self.assertEqual(op.force, force)
+ self.assertEqual(op.nics, nics)
+ self.assertEqual(op.disks, disks)
+ self.assertEqual(op.disk_template, disk_template)
+ self.assertFalse(hasattr(op, "remote_node"))
+ self.assertFalse(hasattr(op, "os_name"))
+ self.assertFalse(hasattr(op, "force_variant"))
+ self.assertFalse(hasattr(op, "dry_run"))
+
+ self.assertRaises(IndexError, cl.GetNextSubmittedJob)
+
+ def testDefaults(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "instir8aish31"
+
+ handler = _CreateHandler(rlib2.R_2_instances_name_modify,
+ [name], {}, {}, clfactory)
+ job_id = handler.PUT()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+ self.assertTrue(isinstance(op, opcodes.OpInstanceSetParams))
+ self.assertEqual(op.instance_name, name)
+
+ for i in ["hvparams", "beparams", "osparams", "force", "nics", "disks",
+ "disk_template", "remote_node", "os_name", "force_variant"]:
+ self.assertFalse(hasattr(op, i))
+
+
+class TestParseInstanceReinstallRequest(testutils.GanetiTestCase):
+ def setUp(self):
+ testutils.GanetiTestCase.setUp(self)
+
+ self.Parse = rlib2._ParseInstanceReinstallRequest
+
+ def _Check(self, ops, name):
+ expcls = [
+ opcodes.OpInstanceShutdown,
+ opcodes.OpInstanceReinstall,
+ opcodes.OpInstanceStartup,
+ ]
+
+ self.assert_(compat.all(isinstance(op, exp)
+ for op, exp in zip(ops, expcls)))
+ self.assert_(compat.all(op.instance_name == name for op in ops))
+
+ def test(self):
+ name = "shoo0tihohma"
+
+ ops = self.Parse(name, {"os": "sys1", "start": True,})
+ self.assertEqual(len(ops), 3)
+ self._Check(ops, name)
+ self.assertEqual(ops[1].os_type, "sys1")
+ self.assertFalse(ops[1].osparams)
+
+ ops = self.Parse(name, {"os": "sys2", "start": False,})
+ self.assertEqual(len(ops), 2)
+ self._Check(ops, name)
+ self.assertEqual(ops[1].os_type, "sys2")
+
+ osparams = {
+ "reformat": "1",
+ }
+ ops = self.Parse(name, {"os": "sys4035", "start": True,
+ "osparams": osparams,})
+ self.assertEqual(len(ops), 3)
+ self._Check(ops, name)
+ self.assertEqual(ops[1].os_type, "sys4035")
+ self.assertEqual(ops[1].osparams, osparams)
+
+ def testDefaults(self):
+ name = "noolee0g"
+
+ ops = self.Parse(name, {"os": "linux1"})
+ self.assertEqual(len(ops), 3)
+ self._Check(ops, name)
+ self.assertEqual(ops[1].os_type, "linux1")
+ self.assertFalse(ops[1].osparams)
+
+ def testErrors(self):
+ self.assertRaises(http.HttpBadRequest, self.Parse,
+ "foo", "not a dictionary")
+
+
+class TestGroupRename(unittest.TestCase):
+ def test(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "group608242564"
+ data = {
+ "new_name": "ua0aiyoo15112",
+ }
+
+ handler = _CreateHandler(rlib2.R_2_groups_name_rename, [name], {}, data,
+ clfactory)
+ job_id = handler.PUT()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+
+ self.assertTrue(isinstance(op, opcodes.OpGroupRename))
+ self.assertEqual(op.group_name, name)
+ self.assertEqual(op.new_name, "ua0aiyoo15112")
+ self.assertFalse(op.dry_run)
+ self.assertRaises(IndexError, cl.GetNextSubmittedJob)
+
+ def testDryRun(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "group28548"
+ data = {
+ "new_name": "ua0aiyoo",
+ }
+
+ handler = _CreateHandler(rlib2.R_2_groups_name_rename, [name], {
+ "dry-run": ["1"],
+ }, data, clfactory)
+ job_id = handler.PUT()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+
+ self.assertTrue(isinstance(op, opcodes.OpGroupRename))
+ self.assertEqual(op.group_name, name)
+ self.assertEqual(op.new_name, "ua0aiyoo")
+ self.assertTrue(op.dry_run)
+ self.assertRaises(IndexError, cl.GetNextSubmittedJob)
+
+
+class TestInstanceReplaceDisks(unittest.TestCase):
+ def test(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "inst22568"
+
+ for disks in [range(1, 4), "1,2,3", "1, 2, 3"]:
+ data = {
+ "mode": constants.REPLACE_DISK_SEC,
+ "disks": disks,
+ "iallocator": "myalloc",
+ }
+
+ handler = _CreateHandler(rlib2.R_2_instances_name_replace_disks,
+ [name], {}, data, clfactory)
+ job_id = handler.POST()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+
+ self.assertTrue(isinstance(op, opcodes.OpInstanceReplaceDisks))
+ self.assertEqual(op.instance_name, name)
+ self.assertEqual(op.mode, constants.REPLACE_DISK_SEC)
+ self.assertEqual(op.disks, [1, 2, 3])
+ self.assertEqual(op.iallocator, "myalloc")
+ self.assertRaises(IndexError, cl.GetNextSubmittedJob)
+
+ def testDefaults(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "inst11413"
+ data = {
+ "mode": constants.REPLACE_DISK_AUTO,
+ }
+
+ handler = _CreateHandler(rlib2.R_2_instances_name_replace_disks,
+ [name], {}, data, clfactory)
+ job_id = handler.POST()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+
+ self.assertTrue(isinstance(op, opcodes.OpInstanceReplaceDisks))
+ self.assertEqual(op.instance_name, name)
+ self.assertEqual(op.mode, constants.REPLACE_DISK_AUTO)
+ self.assertFalse(hasattr(op, "iallocator"))
+ self.assertFalse(hasattr(op, "disks"))
+ self.assertRaises(IndexError, cl.GetNextSubmittedJob)
+
+ def testNoDisks(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ handler = _CreateHandler(rlib2.R_2_instances_name_replace_disks,
+ ["inst20661"], {}, {}, clfactory)
+ self.assertRaises(http.HttpBadRequest, handler.POST)
+
+ for disks in [None, "", {}]:
+ handler = _CreateHandler(rlib2.R_2_instances_name_replace_disks,
+ ["inst20661"], {}, {
+ "disks": disks,
+ }, clfactory)
+ self.assertRaises(http.HttpBadRequest, handler.POST)
+
+ def testWrong(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ data = {
+ "mode": constants.REPLACE_DISK_AUTO,
+ "disks": "hello world",
+ }
+
+ handler = _CreateHandler(rlib2.R_2_instances_name_replace_disks,
+ ["foo"], {}, data, clfactory)
+ self.assertRaises(http.HttpBadRequest, handler.POST)
+
+
+class TestGroupModify(unittest.TestCase):
+ def test(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "group6002"
+
+ for policy in constants.VALID_ALLOC_POLICIES:
+ data = {
+ "alloc_policy": policy,
+ }
+
+ handler = _CreateHandler(rlib2.R_2_groups_name_modify, [name], {}, data,
+ clfactory)
+ job_id = handler.PUT()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+
+ self.assertTrue(isinstance(op, opcodes.OpGroupSetParams))
+ self.assertEqual(op.group_name, name)
+ self.assertEqual(op.alloc_policy, policy)
+ self.assertFalse(hasattr(op, "dry_run"))
+ self.assertRaises(IndexError, cl.GetNextSubmittedJob)
+
+ def testUnknownPolicy(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ data = {
+ "alloc_policy": "_unknown_policy_",
+ }
+
+ handler = _CreateHandler(rlib2.R_2_groups_name_modify, ["xyz"], {}, data,
+ clfactory)
+ self.assertRaises(http.HttpBadRequest, handler.PUT)
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ def testDefaults(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "group6679"
+
+ handler = _CreateHandler(rlib2.R_2_groups_name_modify, [name], {}, {},
+ clfactory)
+ job_id = handler.PUT()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+
+ self.assertTrue(isinstance(op, opcodes.OpGroupSetParams))
+ self.assertEqual(op.group_name, name)
+ self.assertFalse(hasattr(op, "alloc_policy"))
+ self.assertFalse(hasattr(op, "dry_run"))
+ self.assertRaises(IndexError, cl.GetNextSubmittedJob)
+
+
+class TestGroupAdd(unittest.TestCase):
+ def test(self):
+ name = "group3618"
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ for policy in constants.VALID_ALLOC_POLICIES:
+ data = {
+ "group_name": name,
+ "alloc_policy": policy,
+ }
+
+ handler = _CreateHandler(rlib2.R_2_groups, [], {}, data,
+ clfactory)
+ job_id = handler.POST()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+
+ self.assertTrue(isinstance(op, opcodes.OpGroupAdd))
+ self.assertEqual(op.group_name, name)
+ self.assertEqual(op.alloc_policy, policy)
+ self.assertFalse(op.dry_run)
+ self.assertRaises(IndexError, cl.GetNextSubmittedJob)
+
+ def testUnknownPolicy(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ data = {
+ "alloc_policy": "_unknown_policy_",
+ }
+
+ handler = _CreateHandler(rlib2.R_2_groups, [], {}, data, clfactory)
+ self.assertRaises(http.HttpBadRequest, handler.POST)
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ def testDefaults(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "group15395"
+ data = {
+ "group_name": name,
+ }
+
+ handler = _CreateHandler(rlib2.R_2_groups, [], {}, data, clfactory)
+ job_id = handler.POST()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+
+ self.assertTrue(isinstance(op, opcodes.OpGroupAdd))
+ self.assertEqual(op.group_name, name)
+ self.assertFalse(hasattr(op, "alloc_policy"))
+ self.assertFalse(op.dry_run)
+
+ def testLegacyName(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ name = "group29852"
+ data = {
+ "name": name,
+ }
+
+ handler = _CreateHandler(rlib2.R_2_groups, [], {
+ "dry-run": ["1"],
+ }, data, clfactory)
+ job_id = handler.POST()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+
+ self.assertTrue(isinstance(op, opcodes.OpGroupAdd))
+ self.assertEqual(op.group_name, name)
+ self.assertFalse(hasattr(op, "alloc_policy"))
+ self.assertTrue(op.dry_run)
+
+
+class TestNodeRole(unittest.TestCase):
+ def test(self):
+ clfactory = _FakeClientFactory(_FakeClient)
+
+ for role in rlib2._NR_MAP.values():
+ handler = _CreateHandler(rlib2.R_2_nodes_name_role,
+ ["node-z"], {}, role, clfactory)
+ if role == rlib2._NR_MASTER:
+ self.assertRaises(http.HttpBadRequest, handler.PUT)
+ else:
+ job_id = handler.PUT()
+
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+
+ (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
+ self.assertEqual(job_id, exp_job_id)
+ self.assertTrue(isinstance(op, opcodes.OpNodeSetParams))
+ self.assertEqual(op.node_name, "node-z")
+ self.assertFalse(op.force)
+ self.assertFalse(hasattr(op, "dry_run"))
+
+ if role == rlib2._NR_REGULAR:
+ self.assertFalse(op.drained)
+ self.assertFalse(op.offline)
+ self.assertFalse(op.master_candidate)
+ elif role == rlib2._NR_MASTER_CANDIDATE:
+ self.assertFalse(op.drained)
+ self.assertFalse(op.offline)
+ self.assertTrue(op.master_candidate)
+ elif role == rlib2._NR_DRAINED:
+ self.assertTrue(op.drained)
+ self.assertFalse(op.offline)
+ self.assertFalse(op.master_candidate)
+ elif role == rlib2._NR_OFFLINE:
+ self.assertFalse(op.drained)
+ self.assertTrue(op.offline)
+ self.assertFalse(op.master_candidate)
+ else:
+ self.fail("Unknown role '%s'" % role)
+
+ self.assertRaises(IndexError, cl.GetNextSubmittedJob)
+
+
+class TestSimpleResources(unittest.TestCase):
+ def setUp(self):
+ self.clfactory = _FakeClientFactory(_FakeClient)
+
+ def tearDown(self):
+ self.assertRaises(IndexError, self.clfactory.GetNextClient)
+
+ def testFeatures(self):
+ handler = _CreateHandler(rlib2.R_2_features, [], {}, None, self.clfactory)
+ self.assertEqual(set(handler.GET()), rlib2.ALL_FEATURES)
+
+ def testEmpty(self):
+ for cls in [rlib2.R_root, rlib2.R_2]:
+ handler = _CreateHandler(cls, [], {}, None, self.clfactory)
+ self.assertTrue(handler.GET() is None)
+
+ def testVersion(self):
+ handler = _CreateHandler(rlib2.R_version, [], {}, None, self.clfactory)
+ self.assertEqual(handler.GET(), constants.RAPI_VERSION)
+
+
+class TestClusterInfo(unittest.TestCase):
+ class _ClusterInfoClient:
+ def __init__(self):
+ self.cluster_info = None
+
+ def QueryClusterInfo(self):
+ assert self.cluster_info is None
+ self.cluster_info = object()
+ return self.cluster_info
+
+ def test(self):
+ clfactory = _FakeClientFactory(self._ClusterInfoClient)
+ handler = _CreateHandler(rlib2.R_2_info, [], {}, None, clfactory)
+ result = handler.GET()
+ cl = clfactory.GetNextClient()
+ self.assertRaises(IndexError, clfactory.GetNextClient)
+ self.assertEqual(result, cl.cluster_info)