| #!/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. |
| |
| |
| """Tests for LUNode* |
| |
| """ |
| |
| from collections import defaultdict |
| import mock |
| |
| from ganeti import compat |
| from ganeti import constants |
| from ganeti import objects |
| from ganeti import opcodes |
| from ganeti.cmdlib import node |
| |
| from testsupport import * |
| |
| import testutils |
| |
| |
| # pylint: disable=W0613 |
| def _TcpPingFailSecondary(cfg, mock_fct, target, port, timeout=None, |
| live_port_needed=None, source=None): |
| # This will return True if target is in 192.0.2.0/24 (primary range) |
| # and False if not. |
| return "192.0.2." in target |
| |
| |
| class TestLUNodeAdd(CmdlibTestCase): |
| def setUp(self): |
| super(TestLUNodeAdd, self).setUp() |
| |
| # One node for testing readding: |
| self.node_readd = self.cfg.AddNewNode() |
| self.op_readd = opcodes.OpNodeAdd(node_name=self.node_readd.name, |
| readd=True, |
| primary_ip=self.node_readd.primary_ip, |
| secondary_ip=self.node_readd.secondary_ip) |
| |
| # One node for testing adding: |
| # don't add to configuration now! |
| self.node_add = objects.Node(name="node_add", |
| primary_ip="192.0.2.200", |
| secondary_ip="203.0.113.200") |
| |
| self.op_add = opcodes.OpNodeAdd(node_name=self.node_add.name, |
| primary_ip=self.node_add.primary_ip, |
| secondary_ip=self.node_add.secondary_ip) |
| |
| self.netutils_mod.TcpPing.return_value = True |
| |
| self.mocked_dns_rpc = self.rpc_mod.DnsOnlyRunner.return_value |
| |
| self.mocked_dns_rpc.call_version.return_value = \ |
| self.RpcResultsBuilder(use_node_names=True) \ |
| .AddSuccessfulNode(self.node_add, constants.CONFIG_VERSION) \ |
| .AddSuccessfulNode(self.node_readd, constants.CONFIG_VERSION) \ |
| .Build() |
| |
| node_verify_result = \ |
| self.RpcResultsBuilder() \ |
| .CreateSuccessfulNodeResult(self.node_add, {constants.NV_NODELIST: []}) |
| # we can't know the node's UUID in advance, so use defaultdict here |
| self.rpc.call_node_verify.return_value = \ |
| defaultdict(lambda: node_verify_result, {}) |
| self.rpc.call_node_crypto_tokens.return_value = \ |
| self.RpcResultsBuilder() \ |
| .CreateSuccessfulNodeResult(self.node_add, |
| [(constants.CRYPTO_TYPE_SSL_DIGEST, "IA:MA:FA:KE:DI:GE:ST")]) |
| |
| def testOvsNoLink(self): |
| ndparams = { |
| constants.ND_OVS: True, |
| constants.ND_OVS_NAME: "testswitch", |
| constants.ND_OVS_LINK: None, |
| } |
| |
| op = self.CopyOpCode(self.op_add, |
| ndparams=ndparams) |
| |
| self.ExecOpCode(op) |
| self.assertLogContainsRegex( |
| "No physical interface for OpenvSwitch was given." |
| " OpenvSwitch will not have an outside connection." |
| " This might not be what you want") |
| |
| created_node = self.cfg.GetNodeInfoByName(op.node_name) |
| self.assertEqual(ndparams[constants.ND_OVS], |
| created_node.ndparams.get(constants.ND_OVS, None)) |
| self.assertEqual(ndparams[constants.ND_OVS_NAME], |
| created_node.ndparams.get(constants.ND_OVS_NAME, None)) |
| self.assertEqual(ndparams[constants.ND_OVS_LINK], |
| created_node.ndparams.get(constants.ND_OVS_LINK, None)) |
| |
| def testAddCandidateCert(self): |
| self.ExecOpCode(self.op_add) |
| |
| created_node = self.cfg.GetNodeInfoByName(self.op_add.node_name) |
| cluster = self.cfg.GetClusterInfo() |
| self.assertTrue(created_node.uuid in cluster.candidate_certs) |
| |
| def testReAddCandidateCert(self): |
| cluster = self.cfg.GetClusterInfo() |
| self.ExecOpCode(self.op_readd) |
| created_node = self.cfg.GetNodeInfoByName(self.op_readd.node_name) |
| self.assertTrue(created_node.uuid in cluster.candidate_certs) |
| |
| def testAddNoCandidateCert(self): |
| op = self.CopyOpCode(self.op_add, |
| master_capable=False) |
| self.ExecOpCode(op) |
| |
| created_node = self.cfg.GetNodeInfoByName(self.op_add.node_name) |
| cluster = self.cfg.GetClusterInfo() |
| self.assertFalse(created_node.uuid in cluster.candidate_certs) |
| |
| def testWithoutOVS(self): |
| self.ExecOpCode(self.op_add) |
| |
| created_node = self.cfg.GetNodeInfoByName(self.op_add.node_name) |
| self.assertEqual(None, |
| created_node.ndparams.get(constants.ND_OVS, None)) |
| |
| def testWithOVS(self): |
| ndparams = { |
| constants.ND_OVS: True, |
| constants.ND_OVS_LINK: "eth2", |
| } |
| |
| op = self.CopyOpCode(self.op_add, |
| ndparams=ndparams) |
| |
| self.ExecOpCode(op) |
| |
| created_node = self.cfg.GetNodeInfoByName(op.node_name) |
| self.assertEqual(ndparams[constants.ND_OVS], |
| created_node.ndparams.get(constants.ND_OVS, None)) |
| self.assertEqual(ndparams[constants.ND_OVS_LINK], |
| created_node.ndparams.get(constants.ND_OVS_LINK, None)) |
| |
| def testReaddingMaster(self): |
| op = opcodes.OpNodeAdd(node_name=self.cfg.GetMasterNodeName(), |
| readd=True) |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "Cannot readd the master node") |
| |
| def testReaddNotVmCapableNode(self): |
| self.cfg.AddNewInstance(primary_node=self.node_readd) |
| self.netutils_mod.GetHostname.return_value = \ |
| HostnameMock(self.node_readd.name, self.node_readd.primary_ip) |
| |
| op = self.CopyOpCode(self.op_readd, vm_capable=False) |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "Node .* being re-added with" |
| " vm_capable flag set to false, but it" |
| " already holds instances") |
| |
| def testReaddAndPassNodeGroup(self): |
| op = self.CopyOpCode(self.op_readd,group="groupname") |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "Cannot pass a node group when a" |
| " node is being readded") |
| |
| def testPrimaryIPv6(self): |
| self.master.secondary_ip = self.master.primary_ip |
| |
| op = self.CopyOpCode(self.op_add, primary_ip="2001:DB8::1", |
| secondary_ip=self.REMOVE) |
| |
| self.ExecOpCode(op) |
| |
| def testInvalidSecondaryIP(self): |
| op = self.CopyOpCode(self.op_add, secondary_ip="333.444.555.777") |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "Secondary IP .* needs to be a valid" |
| " IPv4 address") |
| |
| def testNodeAlreadyInCluster(self): |
| op = self.CopyOpCode(self.op_readd, readd=False) |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "Node %s is already in the" |
| " configuration" % self.node_readd.name) |
| |
| def testReaddNodeNotInConfiguration(self): |
| op = self.CopyOpCode(self.op_add, readd=True) |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "Node %s is not in the" |
| " configuration" % self.node_add.name) |
| |
| def testPrimaryIpConflict(self): |
| # In LUNodeAdd, DNS will resolve the node name to an IP address, that is |
| # used to overwrite any given primary_ip value! |
| # Thus we need to mock this DNS resolver here! |
| self.netutils_mod.GetHostname.return_value = \ |
| HostnameMock(self.node_add.name, self.node_readd.primary_ip) |
| |
| op = self.CopyOpCode(self.op_add) |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "New node ip address.* conflict with" |
| " existing node") |
| |
| def testSecondaryIpConflict(self): |
| op = self.CopyOpCode(self.op_add, secondary_ip=self.node_readd.secondary_ip) |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "New node ip address.* conflict with" |
| " existing node") |
| |
| def testReaddWithDifferentIP(self): |
| op = self.CopyOpCode(self.op_readd, primary_ip="192.0.2.100", |
| secondary_ip="230.0.113.100") |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "Readded node doesn't have the same" |
| " IP address configuration as before") |
| |
| def testNodeHasSecondaryIpButNotMaster(self): |
| self.master.secondary_ip = self.master.primary_ip |
| |
| self.ExecOpCodeExpectOpPrereqError(self.op_add, "The master has no" |
| " secondary ip but the new node has one") |
| |
| def testMasterHasSecondaryIpButNotNode(self): |
| op = self.CopyOpCode(self.op_add, secondary_ip=None) |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "The master has a secondary ip but" |
| " the new node doesn't have one") |
| |
| def testNodeNotReachableByPing(self): |
| self.netutils_mod.TcpPing.return_value = False |
| |
| op = self.CopyOpCode(self.op_add) |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "Node not reachable by ping") |
| |
| def testNodeNotReachableByPingOnSecondary(self): |
| self.netutils_mod.GetHostname.return_value = \ |
| HostnameMock(self.node_add.name, self.node_add.primary_ip) |
| self.netutils_mod.TcpPing.side_effect = \ |
| compat.partial(_TcpPingFailSecondary, self.cfg, self.netutils_mod.TcpPing) |
| |
| op = self.CopyOpCode(self.op_add) |
| |
| self.ExecOpCodeExpectOpPrereqError(op, "Node secondary ip not reachable by" |
| " TCP based ping to node daemon port") |
| |
| def testCantGetVersion(self): |
| self.mocked_dns_rpc.call_version.return_value = \ |
| self.RpcResultsBuilder(use_node_names=True) \ |
| .AddErrorNode(self.node_add) \ |
| .Build() |
| |
| op = self.CopyOpCode(self.op_add) |
| self.ExecOpCodeExpectOpPrereqError(op, "Can't get version information from" |
| " node %s" % self.node_add.name) |
| |
| |
| class TestLUNodeSetParams(CmdlibTestCase): |
| def setUp(self): |
| super(TestLUNodeSetParams, self).setUp() |
| |
| self.MockOut(node, 'netutils', self.netutils_mod) |
| node.netutils.TcpPing.return_value = True |
| |
| self.node = self.cfg.AddNewNode( |
| primary_ip='192.168.168.191', |
| secondary_ip='192.168.168.192', |
| master_candidate=True, uuid='blue_bunny') |
| |
| self.snode = self.cfg.AddNewNode( |
| primary_ip='192.168.168.193', |
| secondary_ip='192.168.168.194', |
| master_candidate=True, uuid='pink_bunny') |
| |
| def testSetSecondaryIp(self): |
| self.instance = self.cfg.AddNewInstance(primary_node=self.node, |
| secondary_node=self.snode, |
| disk_template='drbd') |
| op = opcodes.OpNodeSetParams(node_name=self.node.name, |
| secondary_ip='254.254.254.254') |
| self.ExecOpCode(op) |
| |
| self.assertEqual('254.254.254.254', self.node.secondary_ip) |
| self.assertEqual(sorted(self.wconfd.all_locks.items()), [ |
| ('cluster/BGL', 'shared'), |
| ('instance/mock_inst_1.example.com', 'shared'), |
| ('node-res/blue_bunny', 'exclusive'), |
| ('node/blue_bunny', 'exclusive')]) |
| |
| def testSetSecondaryIpNoLock(self): |
| self.instance = self.cfg.AddNewInstance(primary_node=self.node, |
| secondary_node=self.snode, |
| disk_template='file') |
| op = opcodes.OpNodeSetParams(node_name=self.node.name, |
| secondary_ip='254.254.254.254') |
| self.ExecOpCode(op) |
| |
| self.assertEqual('254.254.254.254', self.node.secondary_ip) |
| self.assertEqual(sorted(self.wconfd.all_locks.items()), [ |
| ('cluster/BGL', 'shared'), |
| ('node-res/blue_bunny', 'exclusive'), |
| ('node/blue_bunny', 'exclusive')]) |
| |
| |
| if __name__ == "__main__": |
| testutils.GanetiTestProgram() |
