| #!/usr/bin/python |
| # |
| |
| # Copyright (C) 2010, 2011, 2012, 2013 Google Inc. |
| # |
| # This program is free software; you can redistribute it and/or modify |
| # it under the terms of the GNU General Public License as published by |
| # the Free Software Foundation; either version 2 of the License, or |
| # (at your option) any later version. |
| # |
| # This program is distributed in the hope that it will be useful, but |
| # WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| # General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License |
| # along with this program; if not, write to the Free Software |
| # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| # 02110-1301, USA. |
| |
| |
| """Script for testing ganeti.rpc""" |
| |
| import os |
| import sys |
| import unittest |
| import random |
| import tempfile |
| |
| from ganeti import constants |
| from ganeti import compat |
| from ganeti import rpc |
| from ganeti import rpc_defs |
| from ganeti import http |
| from ganeti import errors |
| from ganeti import serializer |
| from ganeti import objects |
| from ganeti import backend |
| |
| import testutils |
| import mocks |
| |
| |
| class _FakeRequestProcessor: |
| def __init__(self, response_fn): |
| self._response_fn = response_fn |
| self.reqcount = 0 |
| |
| def __call__(self, reqs, lock_monitor_cb=None): |
| assert lock_monitor_cb is None or callable(lock_monitor_cb) |
| for req in reqs: |
| self.reqcount += 1 |
| self._response_fn(req) |
| |
| |
| def GetFakeSimpleStoreClass(fn): |
| class FakeSimpleStore: |
| GetNodePrimaryIPList = fn |
| GetPrimaryIPFamily = lambda _: None |
| |
| return FakeSimpleStore |
| |
| |
| def _RaiseNotImplemented(): |
| """Simple wrapper to raise NotImplementedError. |
| |
| """ |
| raise NotImplementedError |
| |
| |
| class TestRpcProcessor(unittest.TestCase): |
| def _FakeAddressLookup(self, map): |
| return lambda node_list: [map.get(node) for node in node_list] |
| |
| def _GetVersionResponse(self, req): |
| self.assertEqual(req.host, "127.0.0.1") |
| self.assertEqual(req.port, 24094) |
| self.assertEqual(req.path, "/version") |
| self.assertEqual(req.read_timeout, constants.RPC_TMO_URGENT) |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson((True, 123)) |
| |
| def testVersionSuccess(self): |
| resolver = rpc._StaticResolver(["127.0.0.1"]) |
| http_proc = _FakeRequestProcessor(self._GetVersionResponse) |
| proc = rpc._RpcProcessor(resolver, 24094) |
| result = proc(["localhost"], "version", {"localhost": ""}, 60, |
| NotImplemented, _req_process_fn=http_proc) |
| self.assertEqual(result.keys(), ["localhost"]) |
| lhresp = result["localhost"] |
| self.assertFalse(lhresp.offline) |
| self.assertEqual(lhresp.node, "localhost") |
| self.assertFalse(lhresp.fail_msg) |
| self.assertEqual(lhresp.payload, 123) |
| self.assertEqual(lhresp.call, "version") |
| lhresp.Raise("should not raise") |
| self.assertEqual(http_proc.reqcount, 1) |
| |
| def _ReadTimeoutResponse(self, req): |
| self.assertEqual(req.host, "192.0.2.13") |
| self.assertEqual(req.port, 19176) |
| self.assertEqual(req.path, "/version") |
| self.assertEqual(req.read_timeout, 12356) |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson((True, -1)) |
| |
| def testReadTimeout(self): |
| resolver = rpc._StaticResolver(["192.0.2.13"]) |
| http_proc = _FakeRequestProcessor(self._ReadTimeoutResponse) |
| proc = rpc._RpcProcessor(resolver, 19176) |
| host = "node31856" |
| body = {host: ""} |
| result = proc([host], "version", body, 12356, NotImplemented, |
| _req_process_fn=http_proc) |
| self.assertEqual(result.keys(), [host]) |
| lhresp = result[host] |
| self.assertFalse(lhresp.offline) |
| self.assertEqual(lhresp.node, host) |
| self.assertFalse(lhresp.fail_msg) |
| self.assertEqual(lhresp.payload, -1) |
| self.assertEqual(lhresp.call, "version") |
| lhresp.Raise("should not raise") |
| self.assertEqual(http_proc.reqcount, 1) |
| |
| def testOfflineNode(self): |
| resolver = rpc._StaticResolver([rpc._OFFLINE]) |
| http_proc = _FakeRequestProcessor(NotImplemented) |
| proc = rpc._RpcProcessor(resolver, 30668) |
| host = "n17296" |
| body = {host: ""} |
| result = proc([host], "version", body, 60, NotImplemented, |
| _req_process_fn=http_proc) |
| self.assertEqual(result.keys(), [host]) |
| lhresp = result[host] |
| self.assertTrue(lhresp.offline) |
| self.assertEqual(lhresp.node, host) |
| self.assertTrue(lhresp.fail_msg) |
| self.assertFalse(lhresp.payload) |
| self.assertEqual(lhresp.call, "version") |
| |
| # With a message |
| self.assertRaises(errors.OpExecError, lhresp.Raise, "should raise") |
| |
| # No message |
| self.assertRaises(errors.OpExecError, lhresp.Raise, None) |
| |
| self.assertEqual(http_proc.reqcount, 0) |
| |
| def _GetMultiVersionResponse(self, req): |
| self.assert_(req.host.startswith("node")) |
| self.assertEqual(req.port, 23245) |
| self.assertEqual(req.path, "/version") |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson((True, 987)) |
| |
| def testMultiVersionSuccess(self): |
| nodes = ["node%s" % i for i in range(50)] |
| body = dict((n, "") for n in nodes) |
| resolver = rpc._StaticResolver(nodes) |
| http_proc = _FakeRequestProcessor(self._GetMultiVersionResponse) |
| proc = rpc._RpcProcessor(resolver, 23245) |
| result = proc(nodes, "version", body, 60, NotImplemented, |
| _req_process_fn=http_proc) |
| self.assertEqual(sorted(result.keys()), sorted(nodes)) |
| |
| for name in nodes: |
| lhresp = result[name] |
| self.assertFalse(lhresp.offline) |
| self.assertEqual(lhresp.node, name) |
| self.assertFalse(lhresp.fail_msg) |
| self.assertEqual(lhresp.payload, 987) |
| self.assertEqual(lhresp.call, "version") |
| lhresp.Raise("should not raise") |
| |
| self.assertEqual(http_proc.reqcount, len(nodes)) |
| |
| def _GetVersionResponseFail(self, errinfo, req): |
| self.assertEqual(req.path, "/version") |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson((False, errinfo)) |
| |
| def testVersionFailure(self): |
| resolver = rpc._StaticResolver(["aef9ur4i.example.com"]) |
| proc = rpc._RpcProcessor(resolver, 5903) |
| for errinfo in [None, "Unknown error"]: |
| http_proc = \ |
| _FakeRequestProcessor(compat.partial(self._GetVersionResponseFail, |
| errinfo)) |
| host = "aef9ur4i.example.com" |
| body = {host: ""} |
| result = proc(body.keys(), "version", body, 60, NotImplemented, |
| _req_process_fn=http_proc) |
| self.assertEqual(result.keys(), [host]) |
| lhresp = result[host] |
| self.assertFalse(lhresp.offline) |
| self.assertEqual(lhresp.node, host) |
| self.assert_(lhresp.fail_msg) |
| self.assertFalse(lhresp.payload) |
| self.assertEqual(lhresp.call, "version") |
| self.assertRaises(errors.OpExecError, lhresp.Raise, "failed") |
| self.assertEqual(http_proc.reqcount, 1) |
| |
| def _GetHttpErrorResponse(self, httperrnodes, failnodes, req): |
| self.assertEqual(req.path, "/vg_list") |
| self.assertEqual(req.port, 15165) |
| |
| if req.host in httperrnodes: |
| req.success = False |
| req.error = "Node set up for HTTP errors" |
| |
| elif req.host in failnodes: |
| req.success = True |
| req.resp_status_code = 404 |
| req.resp_body = serializer.DumpJson({ |
| "code": 404, |
| "message": "Method not found", |
| "explain": "Explanation goes here", |
| }) |
| else: |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson((True, hash(req.host))) |
| |
| def testHttpError(self): |
| nodes = ["uaf6pbbv%s" % i for i in range(50)] |
| body = dict((n, "") for n in nodes) |
| resolver = rpc._StaticResolver(nodes) |
| |
| httperrnodes = set(nodes[1::7]) |
| self.assertEqual(len(httperrnodes), 7) |
| |
| failnodes = set(nodes[2::3]) - httperrnodes |
| self.assertEqual(len(failnodes), 14) |
| |
| self.assertEqual(len(set(nodes) - failnodes - httperrnodes), 29) |
| |
| proc = rpc._RpcProcessor(resolver, 15165) |
| http_proc = \ |
| _FakeRequestProcessor(compat.partial(self._GetHttpErrorResponse, |
| httperrnodes, failnodes)) |
| result = proc(nodes, "vg_list", body, |
| constants.RPC_TMO_URGENT, NotImplemented, |
| _req_process_fn=http_proc) |
| self.assertEqual(sorted(result.keys()), sorted(nodes)) |
| |
| for name in nodes: |
| lhresp = result[name] |
| self.assertFalse(lhresp.offline) |
| self.assertEqual(lhresp.node, name) |
| self.assertEqual(lhresp.call, "vg_list") |
| |
| if name in httperrnodes: |
| self.assert_(lhresp.fail_msg) |
| self.assertRaises(errors.OpExecError, lhresp.Raise, "failed") |
| elif name in failnodes: |
| self.assert_(lhresp.fail_msg) |
| self.assertRaises(errors.OpPrereqError, lhresp.Raise, "failed", |
| prereq=True, ecode=errors.ECODE_INVAL) |
| else: |
| self.assertFalse(lhresp.fail_msg) |
| self.assertEqual(lhresp.payload, hash(name)) |
| lhresp.Raise("should not raise") |
| |
| self.assertEqual(http_proc.reqcount, len(nodes)) |
| |
| def _GetInvalidResponseA(self, req): |
| self.assertEqual(req.path, "/version") |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson(("This", "is", "an", "invalid", |
| "response", "!", 1, 2, 3)) |
| |
| def _GetInvalidResponseB(self, req): |
| self.assertEqual(req.path, "/version") |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson("invalid response") |
| |
| def testInvalidResponse(self): |
| resolver = rpc._StaticResolver(["oqo7lanhly.example.com"]) |
| proc = rpc._RpcProcessor(resolver, 19978) |
| |
| for fn in [self._GetInvalidResponseA, self._GetInvalidResponseB]: |
| http_proc = _FakeRequestProcessor(fn) |
| host = "oqo7lanhly.example.com" |
| body = {host: ""} |
| result = proc([host], "version", body, 60, NotImplemented, |
| _req_process_fn=http_proc) |
| self.assertEqual(result.keys(), [host]) |
| lhresp = result[host] |
| self.assertFalse(lhresp.offline) |
| self.assertEqual(lhresp.node, host) |
| self.assert_(lhresp.fail_msg) |
| self.assertFalse(lhresp.payload) |
| self.assertEqual(lhresp.call, "version") |
| self.assertRaises(errors.OpExecError, lhresp.Raise, "failed") |
| self.assertEqual(http_proc.reqcount, 1) |
| |
| def _GetBodyTestResponse(self, test_data, req): |
| self.assertEqual(req.host, "192.0.2.84") |
| self.assertEqual(req.port, 18700) |
| self.assertEqual(req.path, "/upload_file") |
| self.assertEqual(serializer.LoadJson(req.post_data), test_data) |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson((True, None)) |
| |
| def testResponseBody(self): |
| test_data = { |
| "Hello": "World", |
| "xyz": range(10), |
| } |
| resolver = rpc._StaticResolver(["192.0.2.84"]) |
| http_proc = _FakeRequestProcessor(compat.partial(self._GetBodyTestResponse, |
| test_data)) |
| proc = rpc._RpcProcessor(resolver, 18700) |
| host = "node19759" |
| body = {host: serializer.DumpJson(test_data)} |
| result = proc([host], "upload_file", body, 30, NotImplemented, |
| _req_process_fn=http_proc) |
| self.assertEqual(result.keys(), [host]) |
| lhresp = result[host] |
| self.assertFalse(lhresp.offline) |
| self.assertEqual(lhresp.node, host) |
| self.assertFalse(lhresp.fail_msg) |
| self.assertEqual(lhresp.payload, None) |
| self.assertEqual(lhresp.call, "upload_file") |
| lhresp.Raise("should not raise") |
| self.assertEqual(http_proc.reqcount, 1) |
| |
| |
| class TestSsconfResolver(unittest.TestCase): |
| def testSsconfLookup(self): |
| addr_list = ["192.0.2.%d" % n for n in range(0, 255, 13)] |
| node_list = ["node%d.example.com" % n for n in range(0, 255, 13)] |
| node_addr_list = [" ".join(t) for t in zip(node_list, addr_list)] |
| ssc = GetFakeSimpleStoreClass(lambda _: node_addr_list) |
| result = rpc._SsconfResolver(True, node_list, NotImplemented, |
| ssc=ssc, nslookup_fn=NotImplemented) |
| self.assertEqual(result, zip(node_list, addr_list, node_list)) |
| |
| def testNsLookup(self): |
| addr_list = ["192.0.2.%d" % n for n in range(0, 255, 13)] |
| node_list = ["node%d.example.com" % n for n in range(0, 255, 13)] |
| ssc = GetFakeSimpleStoreClass(lambda _: []) |
| node_addr_map = dict(zip(node_list, addr_list)) |
| nslookup_fn = lambda name, family=None: node_addr_map.get(name) |
| result = rpc._SsconfResolver(True, node_list, NotImplemented, |
| ssc=ssc, nslookup_fn=nslookup_fn) |
| self.assertEqual(result, zip(node_list, addr_list, node_list)) |
| |
| def testDisabledSsconfIp(self): |
| addr_list = ["192.0.2.%d" % n for n in range(0, 255, 13)] |
| node_list = ["node%d.example.com" % n for n in range(0, 255, 13)] |
| ssc = GetFakeSimpleStoreClass(_RaiseNotImplemented) |
| node_addr_map = dict(zip(node_list, addr_list)) |
| nslookup_fn = lambda name, family=None: node_addr_map.get(name) |
| result = rpc._SsconfResolver(False, node_list, NotImplemented, |
| ssc=ssc, nslookup_fn=nslookup_fn) |
| self.assertEqual(result, zip(node_list, addr_list, node_list)) |
| |
| def testBothLookups(self): |
| addr_list = ["192.0.2.%d" % n for n in range(0, 255, 13)] |
| node_list = ["node%d.example.com" % n for n in range(0, 255, 13)] |
| n = len(addr_list) / 2 |
| node_addr_list = [" ".join(t) for t in zip(node_list[n:], addr_list[n:])] |
| ssc = GetFakeSimpleStoreClass(lambda _: node_addr_list) |
| node_addr_map = dict(zip(node_list[:n], addr_list[:n])) |
| nslookup_fn = lambda name, family=None: node_addr_map.get(name) |
| result = rpc._SsconfResolver(True, node_list, NotImplemented, |
| ssc=ssc, nslookup_fn=nslookup_fn) |
| self.assertEqual(result, zip(node_list, addr_list, node_list)) |
| |
| def testAddressLookupIPv6(self): |
| addr_list = ["2001:db8::%d" % n for n in range(0, 255, 11)] |
| node_list = ["node%d.example.com" % n for n in range(0, 255, 11)] |
| node_addr_list = [" ".join(t) for t in zip(node_list, addr_list)] |
| ssc = GetFakeSimpleStoreClass(lambda _: node_addr_list) |
| result = rpc._SsconfResolver(True, node_list, NotImplemented, |
| ssc=ssc, nslookup_fn=NotImplemented) |
| self.assertEqual(result, zip(node_list, addr_list, node_list)) |
| |
| |
| class TestStaticResolver(unittest.TestCase): |
| def test(self): |
| addresses = ["192.0.2.%d" % n for n in range(0, 123, 7)] |
| nodes = ["node%s.example.com" % n for n in range(0, 123, 7)] |
| res = rpc._StaticResolver(addresses) |
| self.assertEqual(res(nodes, NotImplemented), zip(nodes, addresses, nodes)) |
| |
| def testWrongLength(self): |
| res = rpc._StaticResolver([]) |
| self.assertRaises(AssertionError, res, ["abc"], NotImplemented) |
| |
| |
| class TestNodeConfigResolver(unittest.TestCase): |
| @staticmethod |
| def _GetSingleOnlineNode(uuid): |
| assert uuid == "node90-uuid" |
| return objects.Node(name="node90.example.com", |
| uuid=uuid, |
| offline=False, |
| primary_ip="192.0.2.90") |
| |
| @staticmethod |
| def _GetSingleOfflineNode(uuid): |
| assert uuid == "node100-uuid" |
| return objects.Node(name="node100.example.com", |
| uuid=uuid, |
| offline=True, |
| primary_ip="192.0.2.100") |
| |
| def testSingleOnline(self): |
| self.assertEqual(rpc._NodeConfigResolver(self._GetSingleOnlineNode, |
| NotImplemented, |
| ["node90-uuid"], None), |
| [("node90.example.com", "192.0.2.90", "node90-uuid")]) |
| |
| def testSingleOffline(self): |
| self.assertEqual(rpc._NodeConfigResolver(self._GetSingleOfflineNode, |
| NotImplemented, |
| ["node100-uuid"], None), |
| [("node100.example.com", rpc._OFFLINE, "node100-uuid")]) |
| |
| def testSingleOfflineWithAcceptOffline(self): |
| fn = self._GetSingleOfflineNode |
| assert fn("node100-uuid").offline |
| self.assertEqual(rpc._NodeConfigResolver(fn, NotImplemented, |
| ["node100-uuid"], |
| rpc_defs.ACCEPT_OFFLINE_NODE), |
| [("node100.example.com", "192.0.2.100", "node100-uuid")]) |
| for i in [False, True, "", "Hello", 0, 1]: |
| self.assertRaises(AssertionError, rpc._NodeConfigResolver, |
| fn, NotImplemented, ["node100.example.com"], i) |
| |
| def testUnknownSingleNode(self): |
| self.assertEqual(rpc._NodeConfigResolver(lambda _: None, NotImplemented, |
| ["node110.example.com"], None), |
| [("node110.example.com", "node110.example.com", |
| "node110.example.com")]) |
| |
| def testMultiEmpty(self): |
| self.assertEqual(rpc._NodeConfigResolver(NotImplemented, |
| lambda: {}, |
| [], None), |
| []) |
| |
| def testMultiSomeOffline(self): |
| nodes = dict(("node%s-uuid" % i, |
| objects.Node(name="node%s.example.com" % i, |
| offline=((i % 3) == 0), |
| primary_ip="192.0.2.%s" % i, |
| uuid="node%s-uuid" % i)) |
| for i in range(1, 255)) |
| |
| # Resolve no names |
| self.assertEqual(rpc._NodeConfigResolver(NotImplemented, |
| lambda: nodes, |
| [], None), |
| []) |
| |
| # Offline, online and unknown hosts |
| self.assertEqual(rpc._NodeConfigResolver(NotImplemented, |
| lambda: nodes, |
| ["node3-uuid", |
| "node92-uuid", |
| "node54-uuid", |
| "unknown.example.com",], |
| None), [ |
| ("node3.example.com", rpc._OFFLINE, "node3-uuid"), |
| ("node92.example.com", "192.0.2.92", "node92-uuid"), |
| ("node54.example.com", rpc._OFFLINE, "node54-uuid"), |
| ("unknown.example.com", "unknown.example.com", "unknown.example.com"), |
| ]) |
| |
| |
| class TestCompress(unittest.TestCase): |
| def test(self): |
| for data in ["", "Hello", "Hello World!\nnew\nlines"]: |
| self.assertEqual(rpc._Compress(data), |
| (constants.RPC_ENCODING_NONE, data)) |
| |
| for data in [512 * " ", 5242 * "Hello World!\n"]: |
| compressed = rpc._Compress(data) |
| self.assertEqual(len(compressed), 2) |
| self.assertEqual(backend._Decompress(compressed), data) |
| |
| def testDecompression(self): |
| self.assertRaises(AssertionError, backend._Decompress, "") |
| self.assertRaises(AssertionError, backend._Decompress, [""]) |
| self.assertRaises(AssertionError, backend._Decompress, |
| ("unknown compression", "data")) |
| self.assertRaises(Exception, backend._Decompress, |
| (constants.RPC_ENCODING_ZLIB_BASE64, "invalid zlib data")) |
| |
| |
| class TestRpcClientBase(unittest.TestCase): |
| def testNoHosts(self): |
| cdef = ("test_call", NotImplemented, None, constants.RPC_TMO_SLOW, [], |
| None, None, NotImplemented) |
| http_proc = _FakeRequestProcessor(NotImplemented) |
| client = rpc._RpcClientBase(rpc._StaticResolver([]), NotImplemented, |
| _req_process_fn=http_proc) |
| self.assertEqual(client._Call(cdef, [], []), {}) |
| |
| # Test wrong number of arguments |
| self.assertRaises(errors.ProgrammerError, client._Call, |
| cdef, [], [0, 1, 2]) |
| |
| def testTimeout(self): |
| def _CalcTimeout((arg1, arg2)): |
| return arg1 + arg2 |
| |
| def _VerifyRequest(exp_timeout, req): |
| self.assertEqual(req.read_timeout, exp_timeout) |
| |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson((True, hex(req.read_timeout))) |
| |
| resolver = rpc._StaticResolver([ |
| "192.0.2.1", |
| "192.0.2.2", |
| ]) |
| |
| nodes = [ |
| "node1.example.com", |
| "node2.example.com", |
| ] |
| |
| tests = [(100, None, 100), (30, None, 30)] |
| tests.extend((_CalcTimeout, i, i + 300) |
| for i in [0, 5, 16485, 30516]) |
| |
| for timeout, arg1, exp_timeout in tests: |
| cdef = ("test_call", NotImplemented, None, timeout, [ |
| ("arg1", None, NotImplemented), |
| ("arg2", None, NotImplemented), |
| ], None, None, NotImplemented) |
| |
| http_proc = _FakeRequestProcessor(compat.partial(_VerifyRequest, |
| exp_timeout)) |
| client = rpc._RpcClientBase(resolver, NotImplemented, |
| _req_process_fn=http_proc) |
| result = client._Call(cdef, nodes, [arg1, 300]) |
| self.assertEqual(len(result), len(nodes)) |
| self.assertTrue(compat.all(not res.fail_msg and |
| res.payload == hex(exp_timeout) |
| for res in result.values())) |
| |
| def testArgumentEncoder(self): |
| (AT1, AT2) = range(1, 3) |
| |
| resolver = rpc._StaticResolver([ |
| "192.0.2.5", |
| "192.0.2.6", |
| ]) |
| |
| nodes = [ |
| "node5.example.com", |
| "node6.example.com", |
| ] |
| |
| encoders = { |
| AT1: hex, |
| AT2: hash, |
| } |
| |
| cdef = ("test_call", NotImplemented, None, constants.RPC_TMO_NORMAL, [ |
| ("arg0", None, NotImplemented), |
| ("arg1", AT1, NotImplemented), |
| ("arg1", AT2, NotImplemented), |
| ], None, None, NotImplemented) |
| |
| def _VerifyRequest(req): |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson((True, req.post_data)) |
| |
| http_proc = _FakeRequestProcessor(_VerifyRequest) |
| |
| for num in [0, 3796, 9032119]: |
| client = rpc._RpcClientBase(resolver, encoders.get, |
| _req_process_fn=http_proc) |
| result = client._Call(cdef, nodes, ["foo", num, "Hello%s" % num]) |
| self.assertEqual(len(result), len(nodes)) |
| for res in result.values(): |
| self.assertFalse(res.fail_msg) |
| self.assertEqual(serializer.LoadJson(res.payload), |
| ["foo", hex(num), hash("Hello%s" % num)]) |
| |
| def testPostProc(self): |
| def _VerifyRequest(nums, req): |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson((True, nums)) |
| |
| resolver = rpc._StaticResolver([ |
| "192.0.2.90", |
| "192.0.2.95", |
| ]) |
| |
| nodes = [ |
| "node90.example.com", |
| "node95.example.com", |
| ] |
| |
| def _PostProc(res): |
| self.assertFalse(res.fail_msg) |
| res.payload = sum(res.payload) |
| return res |
| |
| cdef = ("test_call", NotImplemented, None, constants.RPC_TMO_NORMAL, [], |
| None, _PostProc, NotImplemented) |
| |
| # Seeded random generator |
| rnd = random.Random(20299) |
| |
| for i in [0, 4, 74, 1391]: |
| nums = [rnd.randint(0, 1000) for _ in range(i)] |
| http_proc = _FakeRequestProcessor(compat.partial(_VerifyRequest, nums)) |
| client = rpc._RpcClientBase(resolver, NotImplemented, |
| _req_process_fn=http_proc) |
| result = client._Call(cdef, nodes, []) |
| self.assertEqual(len(result), len(nodes)) |
| for res in result.values(): |
| self.assertFalse(res.fail_msg) |
| self.assertEqual(res.payload, sum(nums)) |
| |
| def testPreProc(self): |
| def _VerifyRequest(req): |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson((True, req.post_data)) |
| |
| resolver = rpc._StaticResolver([ |
| "192.0.2.30", |
| "192.0.2.35", |
| ]) |
| |
| nodes = [ |
| "node30.example.com", |
| "node35.example.com", |
| ] |
| |
| def _PreProc(node, data): |
| self.assertEqual(len(data), 1) |
| return data[0] + node |
| |
| cdef = ("test_call", NotImplemented, None, constants.RPC_TMO_NORMAL, [ |
| ("arg0", None, NotImplemented), |
| ], _PreProc, None, NotImplemented) |
| |
| http_proc = _FakeRequestProcessor(_VerifyRequest) |
| client = rpc._RpcClientBase(resolver, NotImplemented, |
| _req_process_fn=http_proc) |
| |
| for prefix in ["foo", "bar", "baz"]: |
| result = client._Call(cdef, nodes, [prefix]) |
| self.assertEqual(len(result), len(nodes)) |
| for (idx, (node, res)) in enumerate(result.items()): |
| self.assertFalse(res.fail_msg) |
| self.assertEqual(serializer.LoadJson(res.payload), prefix + node) |
| |
| def testResolverOptions(self): |
| def _VerifyRequest(req): |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson((True, req.post_data)) |
| |
| nodes = [ |
| "node30.example.com", |
| "node35.example.com", |
| ] |
| |
| def _Resolver(expected, hosts, options): |
| self.assertEqual(hosts, nodes) |
| self.assertEqual(options, expected) |
| return zip(hosts, nodes, hosts) |
| |
| def _DynamicResolverOptions((arg0, )): |
| return sum(arg0) |
| |
| tests = [ |
| (None, None, None), |
| (rpc_defs.ACCEPT_OFFLINE_NODE, None, rpc_defs.ACCEPT_OFFLINE_NODE), |
| (False, None, False), |
| (True, None, True), |
| (0, None, 0), |
| (_DynamicResolverOptions, [1, 2, 3], 6), |
| (_DynamicResolverOptions, range(4, 19), 165), |
| ] |
| |
| for (resolver_opts, arg0, expected) in tests: |
| cdef = ("test_call", NotImplemented, resolver_opts, |
| constants.RPC_TMO_NORMAL, [ |
| ("arg0", None, NotImplemented), |
| ], None, None, NotImplemented) |
| |
| http_proc = _FakeRequestProcessor(_VerifyRequest) |
| |
| client = rpc._RpcClientBase(compat.partial(_Resolver, expected), |
| NotImplemented, _req_process_fn=http_proc) |
| result = client._Call(cdef, nodes, [arg0]) |
| self.assertEqual(len(result), len(nodes)) |
| for (idx, (node, res)) in enumerate(result.items()): |
| self.assertFalse(res.fail_msg) |
| |
| |
| class _FakeConfigForRpcRunner: |
| GetAllNodesInfo = NotImplemented |
| |
| def __init__(self, cluster=NotImplemented): |
| self._cluster = cluster |
| |
| def GetNodeInfo(self, name): |
| return objects.Node(name=name) |
| |
| def GetClusterInfo(self): |
| return self._cluster |
| |
| def GetInstanceDiskParams(self, _): |
| return constants.DISK_DT_DEFAULTS |
| |
| |
| class TestRpcRunner(unittest.TestCase): |
| def testUploadFile(self): |
| data = 1779 * "Hello World\n" |
| |
| tmpfile = tempfile.NamedTemporaryFile() |
| tmpfile.write(data) |
| tmpfile.flush() |
| st = os.stat(tmpfile.name) |
| |
| def _VerifyRequest(req): |
| (uldata, ) = serializer.LoadJson(req.post_data) |
| self.assertEqual(len(uldata), 7) |
| self.assertEqual(uldata[0], tmpfile.name) |
| self.assertEqual(list(uldata[1]), list(rpc._Compress(data))) |
| self.assertEqual(uldata[2], st.st_mode) |
| self.assertEqual(uldata[3], "user%s" % os.getuid()) |
| self.assertEqual(uldata[4], "group%s" % os.getgid()) |
| self.assertTrue(uldata[5] is not None) |
| self.assertEqual(uldata[6], st.st_mtime) |
| |
| req.success = True |
| req.resp_status_code = http.HTTP_OK |
| req.resp_body = serializer.DumpJson((True, None)) |
| |
| http_proc = _FakeRequestProcessor(_VerifyRequest) |
| |
| std_runner = rpc.RpcRunner(_FakeConfigForRpcRunner(), None, |
| _req_process_fn=http_proc, |
| _getents=mocks.FakeGetentResolver) |
| |
| cfg_runner = rpc.ConfigRunner(None, ["192.0.2.13"], |
| _req_process_fn=http_proc, |
| _getents=mocks.FakeGetentResolver) |
| |
| nodes = [ |
| "node1.example.com", |
| ] |
| |
| for runner in [std_runner, cfg_runner]: |
| result = runner.call_upload_file(nodes, tmpfile.name) |
| self.assertEqual(len(result), len(nodes)) |
| for (idx, (node, res)) in enumerate(result.items()): |
| self.assertFalse(res.fail_msg) |
| |
| def testEncodeInstance(self): |
| cluster = objects.Cluster(hvparams={ |
| constants.HT_KVM: { |
| constants.HV_CDROM_IMAGE_PATH: "foo", |
| }, |
| }, |
| beparams={ |
| constants.PP_DEFAULT: { |
| constants.BE_MAXMEM: 8192, |
| }, |
| }, |
| os_hvp={}, |
| osparams={ |
| "linux": { |
| "role": "unknown", |
| }, |
| }) |
| cluster.UpgradeConfig() |
| |
| inst = objects.Instance(name="inst1.example.com", |
| hypervisor=constants.HT_KVM, |
| os="linux", |
| hvparams={ |
| constants.HV_CDROM_IMAGE_PATH: "bar", |
| constants.HV_ROOT_PATH: "/tmp", |
| }, |
| beparams={ |
| constants.BE_MINMEM: 128, |
| constants.BE_MAXMEM: 256, |
| }, |
| nics=[ |
| objects.NIC(nicparams={ |
| constants.NIC_MODE: "mymode", |
| }), |
| ], |
| disk_template=constants.DT_PLAIN, |
| disks=[ |
| objects.Disk(dev_type=constants.DT_PLAIN, size=4096, |
| logical_id=("vg", "disk6120")), |
| objects.Disk(dev_type=constants.DT_PLAIN, size=1024, |
| logical_id=("vg", "disk8508")), |
| ]) |
| inst.UpgradeConfig() |
| |
| cfg = _FakeConfigForRpcRunner(cluster=cluster) |
| runner = rpc.RpcRunner(cfg, None, |
| _req_process_fn=NotImplemented, |
| _getents=mocks.FakeGetentResolver) |
| |
| def _CheckBasics(result): |
| self.assertEqual(result["name"], "inst1.example.com") |
| self.assertEqual(result["os"], "linux") |
| self.assertEqual(result["beparams"][constants.BE_MINMEM], 128) |
| self.assertEqual(len(result["nics"]), 1) |
| self.assertEqual(result["nics"][0]["nicparams"][constants.NIC_MODE], |
| "mymode") |
| |
| # Generic object serialization |
| result = runner._encoder((rpc_defs.ED_OBJECT_DICT, inst)) |
| _CheckBasics(result) |
| self.assertEqual(len(result["hvparams"]), 2) |
| |
| result = runner._encoder((rpc_defs.ED_OBJECT_DICT_LIST, 5 * [inst])) |
| map(_CheckBasics, result) |
| map(lambda r: self.assertEqual(len(r["hvparams"]), 2), result) |
| |
| # Just an instance |
| result = runner._encoder((rpc_defs.ED_INST_DICT, inst)) |
| _CheckBasics(result) |
| self.assertEqual(result["beparams"][constants.BE_MAXMEM], 256) |
| self.assertEqual(result["hvparams"][constants.HV_CDROM_IMAGE_PATH], "bar") |
| self.assertEqual(result["hvparams"][constants.HV_ROOT_PATH], "/tmp") |
| self.assertEqual(result["osparams"], { |
| "role": "unknown", |
| }) |
| self.assertEqual(len(result["hvparams"]), |
| len(constants.HVC_DEFAULTS[constants.HT_KVM])) |
| |
| # Instance with OS parameters |
| result = runner._encoder((rpc_defs.ED_INST_DICT_OSP_DP, (inst, { |
| "role": "webserver", |
| "other": "field", |
| }))) |
| _CheckBasics(result) |
| self.assertEqual(result["beparams"][constants.BE_MAXMEM], 256) |
| self.assertEqual(result["hvparams"][constants.HV_CDROM_IMAGE_PATH], "bar") |
| self.assertEqual(result["hvparams"][constants.HV_ROOT_PATH], "/tmp") |
| self.assertEqual(result["osparams"], { |
| "role": "webserver", |
| "other": "field", |
| }) |
| |
| # Instance with hypervisor and backend parameters |
| result = runner._encoder((rpc_defs.ED_INST_DICT_HVP_BEP_DP, (inst, { |
| constants.HV_BOOT_ORDER: "xyz", |
| }, { |
| constants.BE_VCPUS: 100, |
| constants.BE_MAXMEM: 4096, |
| }))) |
| _CheckBasics(result) |
| self.assertEqual(result["beparams"][constants.BE_MAXMEM], 4096) |
| self.assertEqual(result["beparams"][constants.BE_VCPUS], 100) |
| self.assertEqual(result["hvparams"][constants.HV_BOOT_ORDER], "xyz") |
| self.assertEqual(result["disks"], [{ |
| "dev_type": constants.DT_PLAIN, |
| "size": 4096, |
| "logical_id": ("vg", "disk6120"), |
| "params": constants.DISK_DT_DEFAULTS[inst.disk_template], |
| }, { |
| "dev_type": constants.DT_PLAIN, |
| "size": 1024, |
| "logical_id": ("vg", "disk8508"), |
| "params": constants.DISK_DT_DEFAULTS[inst.disk_template], |
| }]) |
| |
| self.assertTrue(compat.all(disk.params == {} for disk in inst.disks), |
| msg="Configuration objects were modified") |
| |
| |
| class TestLegacyNodeInfo(unittest.TestCase): |
| KEY_BOOT = "bootid" |
| KEY_VG0 = "name" |
| KEY_VG1 = "storage_free" |
| KEY_VG2 = "storage_size" |
| KEY_HV = "cpu_count" |
| KEY_SP1 = "spindles_free" |
| KEY_SP2 = "spindles_total" |
| KEY_ST = "type" # key for storage type |
| VAL_BOOT = 0 |
| VAL_VG0 = "xy" |
| VAL_VG1 = 11 |
| VAL_VG2 = 12 |
| VAL_VG3 = "lvm-vg" |
| VAL_HV = 2 |
| VAL_SP0 = "ab" |
| VAL_SP1 = 31 |
| VAL_SP2 = 32 |
| VAL_SP3 = "lvm-pv" |
| DICT_VG = { |
| KEY_VG0: VAL_VG0, |
| KEY_VG1: VAL_VG1, |
| KEY_VG2: VAL_VG2, |
| KEY_ST: VAL_VG3, |
| } |
| DICT_HV = {KEY_HV: VAL_HV} |
| DICT_SP = { |
| KEY_ST: VAL_SP3, |
| KEY_VG0: VAL_SP0, |
| KEY_VG1: VAL_SP1, |
| KEY_VG2: VAL_SP2, |
| } |
| STD_LST = [VAL_BOOT, [DICT_VG, DICT_SP], [DICT_HV]] |
| STD_DICT = { |
| KEY_BOOT: VAL_BOOT, |
| KEY_VG0: VAL_VG0, |
| KEY_VG1: VAL_VG1, |
| KEY_VG2: VAL_VG2, |
| KEY_HV: VAL_HV, |
| } |
| |
| def testStandard(self): |
| result = rpc.MakeLegacyNodeInfo(self.STD_LST) |
| self.assertEqual(result, self.STD_DICT) |
| |
| def testSpindlesRequired(self): |
| my_lst = [self.VAL_BOOT, [], [self.DICT_HV]] |
| self.assertRaises(errors.OpExecError, rpc.MakeLegacyNodeInfo, my_lst, |
| require_spindles=True) |
| |
| def testNoSpindlesRequired(self): |
| my_lst = [self.VAL_BOOT, [], [self.DICT_HV]] |
| result = rpc.MakeLegacyNodeInfo(my_lst, require_spindles = False) |
| self.assertEqual(result, {self.KEY_BOOT: self.VAL_BOOT, |
| self.KEY_HV: self.VAL_HV}) |
| result = rpc.MakeLegacyNodeInfo(self.STD_LST, require_spindles = False) |
| self.assertEqual(result, self.STD_DICT) |
| |
| |
| class TestAddDefaultStorageInfoToLegacyNodeInfo(unittest.TestCase): |
| |
| def setUp(self): |
| self.free_storage_file = 23 |
| self.total_storage_file = 42 |
| self.free_storage_lvm = 69 |
| self.total_storage_lvm = 666 |
| self.node_info = [{"name": "myfile", |
| "type": constants.ST_FILE, |
| "storage_free": self.free_storage_file, |
| "storage_size": self.total_storage_file}, |
| {"name": "myvg", |
| "type": constants.ST_LVM_VG, |
| "storage_free": self.free_storage_lvm, |
| "storage_size": self.total_storage_lvm}, |
| {"name": "myspindle", |
| "type": constants.ST_LVM_PV, |
| "storage_free": 33, |
| "storage_size": 44}] |
| |
| def testAddDefaultStorageInfoToLegacyNodeInfo(self): |
| result = {} |
| rpc._AddDefaultStorageInfoToLegacyNodeInfo(result, self.node_info) |
| self.assertEqual(self.free_storage_file, result["storage_free"]) |
| self.assertEqual(self.total_storage_file, result["storage_size"]) |
| |
| def testAddDefaultStorageInfoToLegacyNodeInfoNoDefaults(self): |
| result = {} |
| rpc._AddDefaultStorageInfoToLegacyNodeInfo(result, self.node_info[-1:]) |
| self.assertFalse("storage_free" in result) |
| self.assertFalse("storage_size" in result) |
| |
| |
| if __name__ == "__main__": |
| testutils.GanetiTestProgram() |
