| #!/usr/bin/python |
| # |
| |
| # Copyright (C) 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. |
| |
| |
| """Script for unittesting the cmdlib module 'instance_storage'""" |
| |
| |
| import unittest |
| |
| from ganeti import constants |
| from ganeti.cmdlib import instance_storage |
| from ganeti import errors |
| from ganeti import objects |
| from ganeti import opcodes |
| |
| import testutils |
| import mock |
| import time |
| |
| from testsupport import CmdlibTestCase |
| |
| |
| class TestCheckNodesFreeDiskOnVG(unittest.TestCase): |
| |
| def setUp(self): |
| self.node_uuid = "12345" |
| self.node_uuids = [self.node_uuid] |
| |
| self.node_info = mock.Mock() |
| |
| self.es = True |
| self.ndparams = {constants.ND_EXCLUSIVE_STORAGE: self.es} |
| |
| mock_rpc = mock.Mock() |
| mock_rpc.call_node_info = mock.Mock() |
| |
| mock_cfg = mock.Mock() |
| mock_cfg.GetNodeInfo = mock.Mock(return_value=self.node_info) |
| mock_cfg.GetNdParams = mock.Mock(return_value=self.ndparams) |
| |
| self.hvname = "myhv" |
| self.hvparams = mock.Mock() |
| self.clusterinfo = mock.Mock() |
| self.clusterinfo.hvparams = {self.hvname: self.hvparams} |
| |
| mock_cfg.GetHypervisorType = mock.Mock(return_value=self.hvname) |
| mock_cfg.GetClusterInfo = mock.Mock(return_value=self.clusterinfo) |
| |
| self.lu = mock.Mock() |
| self.lu.rpc = mock_rpc |
| self.lu.cfg = mock_cfg |
| |
| self.vg = "myvg" |
| |
| self.node_name = "mynode" |
| self.space_info = [{"type": constants.ST_LVM_VG, |
| "name": self.vg, |
| "storage_free": 125, |
| "storage_size": 666}] |
| |
| def testPerformNodeInfoCall(self): |
| expected_hv_arg = [(self.hvname, self.hvparams)] |
| expected_storage_arg = {self.node_uuid: |
| [(constants.ST_LVM_VG, self.vg, [self.es]), |
| (constants.ST_LVM_PV, self.vg, [self.es])]} |
| instance_storage._PerformNodeInfoCall(self.lu, self.node_uuids, self.vg) |
| self.lu.rpc.call_node_info.assert_called_with( |
| self.node_uuids, expected_storage_arg, expected_hv_arg) |
| |
| def testCheckVgCapacityForNode(self): |
| requested = 123 |
| node_info = (None, self.space_info, None) |
| instance_storage._CheckVgCapacityForNode(self.node_name, node_info, |
| self.vg, requested) |
| |
| def testCheckVgCapacityForNodeNotEnough(self): |
| requested = 250 |
| node_info = (None, self.space_info, None) |
| self.assertRaises( |
| errors.OpPrereqError, |
| instance_storage._CheckVgCapacityForNode, |
| self.node_name, node_info, self.vg, requested) |
| |
| def testCheckVgCapacityForNodeNoStorageData(self): |
| node_info = (None, [], None) |
| self.assertRaises( |
| errors.OpPrereqError, |
| instance_storage._CheckVgCapacityForNode, |
| self.node_name, node_info, self.vg, NotImplemented) |
| |
| def testCheckVgCapacityForNodeBogusSize(self): |
| broken_space_info = [{"type": constants.ST_LVM_VG, |
| "name": self.vg, |
| "storage_free": "greenbunny", |
| "storage_size": "redbunny"}] |
| node_info = (None, broken_space_info, None) |
| self.assertRaises( |
| errors.OpPrereqError, |
| instance_storage._CheckVgCapacityForNode, |
| self.node_name, node_info, self.vg, NotImplemented) |
| |
| |
| class TestCheckComputeDisksInfo(unittest.TestCase): |
| """Tests for instance_storage.ComputeDisksInfo() |
| |
| """ |
| def setUp(self): |
| """Set up input data""" |
| self.disks = [ |
| objects.Disk(dev_type=constants.DT_PLAIN, size=1024, |
| logical_id=("ganeti", "disk01234"), |
| name="disk-0", mode="rw", params={}, |
| children=[], uuid="disk0"), |
| objects.Disk(dev_type=constants.DT_PLAIN, size=2048, |
| logical_id=("ganeti", "disk56789"), |
| name="disk-1", mode="ro", params={}, |
| children=[], uuid="disk1") |
| ] |
| |
| self.ext_params = { |
| "provider": "pvdr", |
| "param1" : "value1", |
| "param2" : "value2" |
| } |
| |
| self.default_vg = "ganeti-vg" |
| |
| def testComputeDisksInfo(self): |
| """Test instance_storage.ComputeDisksInfo() method""" |
| disks_info = instance_storage.ComputeDisksInfo(self.disks, |
| constants.DT_EXT, |
| self.default_vg, |
| self.ext_params) |
| |
| for disk, d in zip(disks_info, self.disks): |
| self.assertEqual(disk.get("size"), d.size) |
| self.assertEqual(disk.get("mode"), d.mode) |
| self.assertEqual(disk.get("name"), d.name) |
| self.assertEqual(disk.get("param1"), self.ext_params.get("param1")) |
| self.assertEqual(disk.get("param2"), self.ext_params.get("param2")) |
| self.assertEqual(disk.get("provider"), self.ext_params.get("provider")) |
| |
| def testComputeDisksInfoPlainToDrbd(self): |
| disks = [{constants.IDISK_TYPE: constants.DT_DRBD8, |
| constants.IDISK_SIZE: d.size, |
| constants.IDISK_MODE: d.mode, |
| constants.IDISK_VG: d.logical_id[0], |
| constants.IDISK_NAME: d.name} |
| for d in self.disks] |
| |
| disks_info = instance_storage.ComputeDisksInfo(self.disks, |
| constants.DT_DRBD8, |
| self.default_vg, {}) |
| self.assertEqual(disks, disks_info) |
| |
| def testComputeDisksInfoFails(self): |
| """Test instance_storage.ComputeDisksInfo() method fails""" |
| self.assertRaises( |
| errors.OpPrereqError, instance_storage.ComputeDisksInfo, |
| self.disks, constants.DT_EXT, self.default_vg, {}) |
| self.assertRaises( |
| errors.OpPrereqError, instance_storage.ComputeDisksInfo, |
| self.disks, constants.DT_DRBD8, self.default_vg, self.ext_params) |
| |
| self.ext_params.update({"size": 128}) |
| self.assertRaises( |
| AssertionError, instance_storage.ComputeDisksInfo, |
| self.disks, constants.DT_EXT, self.default_vg, self.ext_params) |
| |
| |
| class TestLUInstanceReplaceDisks(CmdlibTestCase): |
| """Tests for LUInstanceReplaceDisks.""" |
| |
| def setUp(self): |
| super(TestLUInstanceReplaceDisks, self).setUp() |
| |
| self.MockOut(time, 'sleep') |
| |
| self.node1 = self.cfg.AddNewNode() |
| self.node2 = self.cfg.AddNewNode() |
| |
| def MakeOpCode(self, disks, early_release=False, ignore_ipolicy=False, |
| remote_node=False, mode='replace_auto', iallocator=None): |
| return opcodes.OpInstanceReplaceDisks( |
| instance_name=self.instance.name, |
| instance_uuid=self.instance.uuid, |
| early_release=early_release, |
| ignore_ipolicy=ignore_ipolicy, |
| mode=mode, |
| disks=disks, |
| remote_node=self.node2.name if remote_node else None, |
| remote_node_uuid=self.node2.uuid if remote_node else None, |
| iallocator=iallocator) |
| |
| def testInvalidTemplate(self): |
| self.instance = self.cfg.AddNewInstance(admin_state=constants.ADMINST_UP, |
| disk_template='diskless', |
| primary_node=self.node1) |
| |
| opcode = self.MakeOpCode([]) |
| self.ExecOpCodeExpectOpPrereqError( |
| opcode, 'strange layout') |
| |
| def SimulateDiskFailure(self, node, disk): |
| def Faulty(node_uuid): |
| disks = self.cfg.GetInstanceDisks(node_uuid) |
| return [i for i,d in enumerate(disks) |
| if i == disk and node.uuid == node_uuid] |
| self.MockOut(instance_storage.TLReplaceDisks, '_FindFaultyDisks', |
| side_effect=Faulty) |
| self.MockOut(instance_storage.TLReplaceDisks, '_CheckDevices') |
| self.MockOut(instance_storage.TLReplaceDisks, '_CheckVolumeGroup') |
| self.MockOut(instance_storage.TLReplaceDisks, '_CheckDisksExistence') |
| self.MockOut(instance_storage.TLReplaceDisks, '_CheckDisksConsistency') |
| self.MockOut(instance_storage.LUInstanceReplaceDisks, 'AssertReleasedLocks') |
| self.MockOut(instance_storage, 'WaitForSync') |
| self.rpc.call_blockdev_addchildren().fail_msg = None |
| |
| def testReplacePrimary(self): |
| self.instance = self.cfg.AddNewInstance(admin_state=constants.ADMINST_UP, |
| disk_template='drbd', |
| primary_node=self.node1, |
| secondary_node=self.node2) |
| |
| self.SimulateDiskFailure(self.node1, 0) |
| |
| opcode = self.MakeOpCode([0], mode='replace_on_primary') |
| self.ExecOpCode(opcode) |
| self.rpc.call_blockdev_rename.assert_any_call(self.node1.uuid, []) |
| |
| def testReplaceSecondary(self): |
| self.instance = self.cfg.AddNewInstance(admin_state=constants.ADMINST_UP, |
| disk_template='drbd', |
| primary_node=self.node1, |
| secondary_node=self.node2) |
| |
| self.SimulateDiskFailure(self.node2, 0) |
| |
| opcode = self.MakeOpCode([0], mode='replace_on_secondary') |
| self.ExecOpCode(opcode) |
| self.rpc.call_blockdev_rename.assert_any_call(self.node2.uuid, []) |
| |
| def testReplaceSecondaryNew(self): |
| disk = self.cfg.CreateDisk(dev_type=constants.DT_DRBD8, |
| primary_node=self.node1, |
| secondary_node=self.node2) |
| self.instance = self.cfg.AddNewInstance(admin_state=constants.ADMINST_UP, |
| disk_template='drbd', |
| disks=[disk], |
| primary_node=self.node1, |
| secondary_node=self.node2) |
| |
| self.SimulateDiskFailure(self.node2, 0) |
| node3 = self.cfg.AddNewNode() |
| self.MockOut(instance_storage.TLReplaceDisks, '_RunAllocator', |
| return_value=node3.uuid) |
| self.rpc.call_drbd_disconnect_net().__getitem__().fail_msg = None |
| self.rpc.call_blockdev_shutdown().fail_msg = None |
| self.rpc.call_drbd_attach_net().fail_msg = None |
| |
| opcode = self.MakeOpCode([], mode='replace_new_secondary', |
| iallocator='hail') |
| self.ExecOpCode(opcode) |
| self.rpc.call_blockdev_shutdown.assert_any_call( |
| self.node2.uuid, (disk, self.instance)) |
| self.rpc.call_drbd_attach_net.assert_any_call( |
| [self.node1.uuid, node3.uuid], ([disk], self.instance), |
| False) |
| |
| if __name__ == "__main__": |
| testutils.GanetiTestProgram() |
