| #!/usr/bin/python |
| # |
| |
| # Copyright (C) 2008, 2011, 2012, 2013 Google Inc. |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are |
| # met: |
| # |
| # 1. Redistributions of source code must retain the above copyright notice, |
| # this list of conditions and the following disclaimer. |
| # |
| # 2. Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS |
| # IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED |
| # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR |
| # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| |
| """Tests for LUGroup* |
| |
| """ |
| |
| import itertools |
| |
| from ganeti import constants |
| from ganeti import opcodes |
| from ganeti import query |
| |
| from testsupport import * |
| |
| import testutils |
| |
| |
| class TestLUGroupAdd(CmdlibTestCase): |
| def testAddExistingGroup(self): |
| self.cfg.AddNewNodeGroup(name="existing_group") |
| |
| op = opcodes.OpGroupAdd(group_name="existing_group") |
| self.ExecOpCodeExpectOpPrereqError( |
| op, "Desired group name 'existing_group' already exists") |
| |
| def testAddNewGroup(self): |
| op = opcodes.OpGroupAdd(group_name="new_group") |
| |
| self.ExecOpCode(op) |
| |
| self.mcpu.assertLogIsEmpty() |
| |
| def testAddNewGroupParams(self): |
| ndparams = {constants.ND_EXCLUSIVE_STORAGE: True} |
| hv_state = {constants.HT_FAKE: {constants.HVST_CPU_TOTAL: 8}} |
| disk_state = { |
| constants.DT_PLAIN: { |
| "mock_vg": {constants.DS_DISK_TOTAL: 10} |
| } |
| } |
| diskparams = {constants.DT_RBD: {constants.RBD_POOL: "mock_pool"}} |
| ipolicy = constants.IPOLICY_DEFAULTS |
| op = opcodes.OpGroupAdd(group_name="new_group", |
| ndparams=ndparams, |
| hv_state=hv_state, |
| disk_state=disk_state, |
| diskparams=diskparams, |
| ipolicy=ipolicy) |
| |
| self.ExecOpCode(op) |
| |
| self.mcpu.assertLogIsEmpty() |
| |
| def testAddNewGroupInvalidDiskparams(self): |
| diskparams = {constants.DT_RBD: {constants.LV_STRIPES: 1}} |
| op = opcodes.OpGroupAdd(group_name="new_group", |
| diskparams=diskparams) |
| |
| self.ExecOpCodeExpectOpPrereqError( |
| op, "Provided option keys not supported") |
| |
| def testAddNewGroupInvalidIPolic(self): |
| ipolicy = {"invalid_key": "value"} |
| op = opcodes.OpGroupAdd(group_name="new_group", |
| ipolicy=ipolicy) |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "Invalid keys in ipolicy") |
| |
| |
| class TestLUGroupAssignNodes(CmdlibTestCase): |
| def __init__(self, methodName='runTest'): |
| super(TestLUGroupAssignNodes, self).__init__(methodName) |
| |
| self.op = opcodes.OpGroupAssignNodes(group_name="default", |
| nodes=[]) |
| |
| def testAssignSingleNode(self): |
| node = self.cfg.AddNewNode() |
| op = self.CopyOpCode(self.op, nodes=[node.name]) |
| |
| self.ExecOpCode(op) |
| |
| self.mcpu.assertLogIsEmpty() |
| |
| def _BuildSplitInstanceSituation(self): |
| node = self.cfg.AddNewNode() |
| self.cfg.AddNewInstance(disk_template=constants.DT_DRBD8, |
| primary_node=self.master, |
| secondary_node=node) |
| group = self.cfg.AddNewNodeGroup() |
| |
| return (node, group) |
| |
| def testSplitInstanceNoForce(self): |
| (node, group) = self._BuildSplitInstanceSituation() |
| op = opcodes.OpGroupAssignNodes(group_name=group.name, |
| nodes=[node.name]) |
| |
| self.ExecOpCodeExpectOpExecError( |
| op, "instances get split by this change and --force was not given") |
| |
| def testSplitInstanceForce(self): |
| (node, group) = self._BuildSplitInstanceSituation() |
| |
| node2 = self.cfg.AddNewNode(group=group) |
| self.cfg.AddNewInstance(disk_template=constants.DT_DRBD8, |
| primary_node=self.master, |
| secondary_node=node2) |
| |
| op = opcodes.OpGroupAssignNodes(group_name=group.name, |
| nodes=[node.name], |
| force=True) |
| |
| self.ExecOpCode(op) |
| |
| self.mcpu.assertLogContainsRegex("will split the following instances") |
| self.mcpu.assertLogContainsRegex( |
| "instances continue to be split across groups") |
| |
| |
| @withLockedLU |
| def testCheckAssignmentForSplitInstances(self, lu): |
| self.cfg._OpenConfig(True) |
| g1 = self.cfg.AddNewNodeGroup() |
| g2 = self.cfg.AddNewNodeGroup() |
| g3 = self.cfg.AddNewNodeGroup() |
| |
| for (n, g) in [("n1a", g1), ("n1b", g1), ("n2a", g2), ("n2b", g2), |
| ("n3a", g3), ("n3b", g3), ("n3c", g3)]: |
| self.cfg.AddNewNode(uuid=n, group=g.uuid) |
| |
| for uuid, pnode, snode in [("inst1a", "n1a", "n1b"), |
| ("inst1b", "n1b", "n1a"), |
| ("inst2a", "n2a", "n2b"), |
| ("inst3a", "n3a", None), |
| ("inst3b", "n3b", "n1b"), |
| ("inst3c", "n3b", "n2b")]: |
| dt = constants.DT_DISKLESS if snode is None else constants.DT_DRBD8 |
| self.cfg.AddNewInstance(uuid=uuid, |
| disk_template=dt, |
| primary_node=pnode, |
| secondary_node=snode) |
| |
| # Test first with the existing state. |
| (new, prev) = lu.CheckAssignmentForSplitInstances( |
| [], self.cfg.GetAllNodesInfo(), self.cfg.GetAllInstancesInfo()) |
| |
| self.assertEqual([], new) |
| self.assertEqual(set(["inst3b", "inst3c"]), set(prev)) |
| |
| # And now some changes. |
| (new, prev) = lu.CheckAssignmentForSplitInstances( |
| [("n1b", g3.uuid)], |
| self.cfg.GetAllNodesInfo(), |
| self.cfg.GetAllInstancesInfo()) |
| |
| self.assertEqual(set(["inst1a", "inst1b"]), set(new)) |
| self.assertEqual(set(["inst3c"]), set(prev)) |
| |
| |
| class TestLUGroupSetParams(CmdlibTestCase): |
| def testNoModifications(self): |
| op = opcodes.OpGroupSetParams(group_name=self.group.name) |
| |
| self.ExecOpCodeExpectOpPrereqError(op, |
| "Please pass at least one modification") |
| |
| def testModifyingAll(self): |
| ndparams = {constants.ND_EXCLUSIVE_STORAGE: True} |
| hv_state = {constants.HT_FAKE: {constants.HVST_CPU_TOTAL: 8}} |
| disk_state = { |
| constants.DT_PLAIN: { |
| "mock_vg": {constants.DS_DISK_TOTAL: 10} |
| } |
| } |
| diskparams = {constants.DT_RBD: {constants.RBD_POOL: "mock_pool"}} |
| ipolicy = {constants.IPOLICY_DTS: [constants.DT_DRBD8]} |
| op = opcodes.OpGroupSetParams(group_name=self.group.name, |
| ndparams=ndparams, |
| hv_state=hv_state, |
| disk_state=disk_state, |
| diskparams=diskparams, |
| ipolicy=ipolicy) |
| |
| self.ExecOpCode(op) |
| |
| self.mcpu.assertLogIsEmpty() |
| |
| def testInvalidDiskparams(self): |
| diskparams = {constants.DT_RBD: {constants.LV_STRIPES: 1}} |
| op = opcodes.OpGroupSetParams(group_name=self.group.name, |
| diskparams=diskparams) |
| |
| self.ExecOpCodeExpectOpPrereqError( |
| op, "Provided option keys not supported") |
| |
| def testIPolicyNewViolations(self): |
| self.cfg.AddNewInstance(beparams={constants.BE_VCPUS: 8}) |
| |
| min_max = dict(constants.ISPECS_MINMAX_DEFAULTS) |
| min_max[constants.ISPECS_MAX].update({constants.ISPEC_CPU_COUNT: 2}) |
| ipolicy = {constants.ISPECS_MINMAX: [min_max]} |
| op = opcodes.OpGroupSetParams(group_name=self.group.name, |
| ipolicy=ipolicy) |
| |
| self.ExecOpCode(op) |
| |
| self.assertLogContainsRegex( |
| "After the ipolicy change the following instances violate them") |
| |
| |
| class TestLUGroupRemove(CmdlibTestCase): |
| def testNonEmptyGroup(self): |
| group = self.cfg.AddNewNodeGroup() |
| self.cfg.AddNewNode(group=group) |
| op = opcodes.OpGroupRemove(group_name=group.name) |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "Group .* not empty") |
| |
| def testRemoveLastGroup(self): |
| self.master.group = "invalid_group" |
| op = opcodes.OpGroupRemove(group_name=self.group.name) |
| |
| self.ExecOpCodeExpectOpPrereqError( |
| op, "Group .* is the only group, cannot be removed") |
| |
| def testRemoveGroup(self): |
| group = self.cfg.AddNewNodeGroup() |
| op = opcodes.OpGroupRemove(group_name=group.name) |
| |
| self.ExecOpCode(op) |
| |
| self.mcpu.assertLogIsEmpty() |
| |
| |
| class TestLUGroupRename(CmdlibTestCase): |
| def testRenameToExistingName(self): |
| group = self.cfg.AddNewNodeGroup() |
| op = opcodes.OpGroupRename(group_name=group.name, |
| new_name=self.group.name) |
| |
| self.ExecOpCodeExpectOpPrereqError( |
| op, "Desired new name .* clashes with existing node group") |
| |
| def testRename(self): |
| group = self.cfg.AddNewNodeGroup() |
| op = opcodes.OpGroupRename(group_name=group.name, |
| new_name="new_group_name") |
| |
| self.ExecOpCode(op) |
| |
| self.mcpu.assertLogIsEmpty() |
| |
| |
| class TestLUGroupEvacuate(CmdlibTestCase): |
| def testEvacuateEmptyGroup(self): |
| group = self.cfg.AddNewNodeGroup() |
| op = opcodes.OpGroupEvacuate(group_name=group.name) |
| |
| self.iallocator_cls.return_value.result = ([], [], []) |
| |
| self.ExecOpCode(op) |
| |
| def testEvacuateOnlyGroup(self): |
| op = opcodes.OpGroupEvacuate(group_name=self.group.name) |
| |
| self.ExecOpCodeExpectOpPrereqError( |
| op, "There are no possible target groups") |
| |
| def testEvacuateWithTargetGroups(self): |
| group = self.cfg.AddNewNodeGroup() |
| self.cfg.AddNewNode(group=group) |
| self.cfg.AddNewNode(group=group) |
| |
| target_group1 = self.cfg.AddNewNodeGroup() |
| target_group2 = self.cfg.AddNewNodeGroup() |
| op = opcodes.OpGroupEvacuate(group_name=group.name, |
| target_groups=[target_group1.name, |
| target_group2.name]) |
| |
| self.iallocator_cls.return_value.result = ([], [], []) |
| |
| self.ExecOpCode(op) |
| |
| def testFailingIAllocator(self): |
| group = self.cfg.AddNewNodeGroup() |
| op = opcodes.OpGroupEvacuate(group_name=group.name) |
| |
| self.iallocator_cls.return_value.success = False |
| |
| self.ExecOpCodeExpectOpPrereqError( |
| op, "Can't compute group evacuation using iallocator") |
| |
| |
| class TestLUGroupVerifyDisks(CmdlibTestCase): |
| def testNoInstances(self): |
| op = opcodes.OpGroupVerifyDisks(group_name=self.group.name) |
| |
| self.ExecOpCode(op) |
| |
| self.mcpu.assertLogIsEmpty() |
| |
| def testOfflineAndFailingNode(self): |
| node = self.cfg.AddNewNode(offline=True) |
| self.cfg.AddNewInstance(primary_node=node, |
| admin_state=constants.ADMINST_UP) |
| self.cfg.AddNewInstance(admin_state=constants.ADMINST_UP) |
| self.rpc.call_lv_list.return_value = \ |
| self.RpcResultsBuilder() \ |
| .AddFailedNode(self.master) \ |
| .AddOfflineNode(node) \ |
| .Build() |
| |
| op = opcodes.OpGroupVerifyDisks(group_name=self.group.name) |
| |
| (nerrors, offline, missing) = self.ExecOpCode(op) |
| |
| self.assertEqual(1, len(nerrors)) |
| self.assertEqual(0, len(offline)) |
| self.assertEqual(2, len(missing)) |
| |
| def testValidNodeResult(self): |
| self.cfg.AddNewInstance( |
| disks=[self.cfg.CreateDisk(dev_type=constants.DT_PLAIN), |
| self.cfg.CreateDisk(dev_type=constants.DT_PLAIN) |
| ], |
| admin_state=constants.ADMINST_UP) |
| self.rpc.call_lv_list.return_value = \ |
| self.RpcResultsBuilder() \ |
| .AddSuccessfulNode(self.master, { |
| "mockvg/mock_disk_1": (None, None, True), |
| "mockvg/mock_disk_2": (None, None, False) |
| }) \ |
| .Build() |
| |
| op = opcodes.OpGroupVerifyDisks(group_name=self.group.name) |
| |
| (nerrors, offline, missing) = self.ExecOpCode(op) |
| |
| self.assertEqual(0, len(nerrors)) |
| self.assertEqual(1, len(offline)) |
| self.assertEqual(0, len(missing)) |
| |
| def testDrbdDisk(self): |
| node1 = self.cfg.AddNewNode() |
| node2 = self.cfg.AddNewNode() |
| node3 = self.cfg.AddNewNode() |
| node4 = self.cfg.AddNewNode() |
| |
| valid_disk = self.cfg.CreateDisk(dev_type=constants.DT_DRBD8, |
| primary_node=node1, |
| secondary_node=node2) |
| broken_disk = self.cfg.CreateDisk(dev_type=constants.DT_DRBD8, |
| primary_node=node1, |
| secondary_node=node2) |
| failing_node_disk = self.cfg.CreateDisk(dev_type=constants.DT_DRBD8, |
| primary_node=node3, |
| secondary_node=node4) |
| |
| self.cfg.AddNewInstance(disks=[valid_disk, broken_disk], |
| primary_node=node1, |
| admin_state=constants.ADMINST_UP) |
| self.cfg.AddNewInstance(disks=[failing_node_disk], |
| primary_node=node3, |
| admin_state=constants.ADMINST_UP) |
| |
| lv_list_result = dict(("/".join(disk.logical_id), (None, None, True)) |
| for disk in itertools.chain(valid_disk.children, |
| broken_disk.children)) |
| self.rpc.call_lv_list.return_value = \ |
| self.RpcResultsBuilder() \ |
| .AddSuccessfulNode(node1, lv_list_result) \ |
| .AddSuccessfulNode(node2, lv_list_result) \ |
| .AddFailedNode(node3) \ |
| .AddFailedNode(node4) \ |
| .Build() |
| |
| def GetDrbdNeedsActivationResult(node_uuid, *_): |
| if node_uuid == node1.uuid: |
| return self.RpcResultsBuilder() \ |
| .CreateSuccessfulNodeResult(node1, []) |
| elif node_uuid == node2.uuid: |
| return self.RpcResultsBuilder() \ |
| .CreateSuccessfulNodeResult(node2, [broken_disk.uuid]) |
| elif node_uuid == node3.uuid or node_uuid == node4.uuid: |
| return self.RpcResultsBuilder() \ |
| .CreateFailedNodeResult(node_uuid) |
| |
| self.rpc.call_drbd_needs_activation.side_effect = \ |
| GetDrbdNeedsActivationResult |
| |
| op = opcodes.OpGroupVerifyDisks(group_name=self.group.name) |
| |
| (nerrors, offline, missing) = self.ExecOpCode(op) |
| |
| self.assertEqual(2, len(nerrors)) |
| self.assertEqual(1, len(offline)) |
| self.assertEqual(1, len(missing)) |
| |
| |
| if __name__ == "__main__": |
| testutils.GanetiTestProgram() |
