Revision d9de612c test/ganeti.rpc_unittest.py
| b/test/ganeti.rpc_unittest.py | ||
|---|---|---|
| 1 | 1 |
#!/usr/bin/python |
| 2 | 2 |
# |
| 3 | 3 |
|
| 4 |
# Copyright (C) 2010 Google Inc. |
|
| 4 |
# Copyright (C) 2010, 2011 Google Inc.
|
|
| 5 | 5 |
# |
| 6 | 6 |
# This program is free software; you can redistribute it and/or modify |
| 7 | 7 |
# it under the terms of the GNU General Public License as published by |
| ... | ... | |
| 73 | 73 |
resolver = rpc._StaticResolver(["127.0.0.1"]) |
| 74 | 74 |
http_proc = _FakeRequestProcessor(self._GetVersionResponse) |
| 75 | 75 |
proc = rpc._RpcProcessor(resolver, 24094) |
| 76 |
result = proc(["localhost"], "version", None, _req_process_fn=http_proc,
|
|
| 77 |
read_timeout=60) |
|
| 76 |
result = proc(["localhost"], "version", {"localhost": ""},
|
|
| 77 |
_req_process_fn=http_proc, read_timeout=60)
|
|
| 78 | 78 |
self.assertEqual(result.keys(), ["localhost"]) |
| 79 | 79 |
lhresp = result["localhost"] |
| 80 | 80 |
self.assertFalse(lhresp.offline) |
| ... | ... | |
| 98 | 98 |
resolver = rpc._StaticResolver(["192.0.2.13"]) |
| 99 | 99 |
http_proc = _FakeRequestProcessor(self._ReadTimeoutResponse) |
| 100 | 100 |
proc = rpc._RpcProcessor(resolver, 19176) |
| 101 |
result = proc(["node31856"], "version", None, _req_process_fn=http_proc, |
|
| 101 |
host = "node31856" |
|
| 102 |
body = {host: ""}
|
|
| 103 |
result = proc([host], "version", body, _req_process_fn=http_proc, |
|
| 102 | 104 |
read_timeout=12356) |
| 103 |
self.assertEqual(result.keys(), ["node31856"])
|
|
| 104 |
lhresp = result["node31856"]
|
|
| 105 |
self.assertEqual(result.keys(), [host])
|
|
| 106 |
lhresp = result[host]
|
|
| 105 | 107 |
self.assertFalse(lhresp.offline) |
| 106 |
self.assertEqual(lhresp.node, "node31856")
|
|
| 108 |
self.assertEqual(lhresp.node, host)
|
|
| 107 | 109 |
self.assertFalse(lhresp.fail_msg) |
| 108 | 110 |
self.assertEqual(lhresp.payload, -1) |
| 109 | 111 |
self.assertEqual(lhresp.call, "version") |
| ... | ... | |
| 114 | 116 |
resolver = rpc._StaticResolver([rpc._OFFLINE]) |
| 115 | 117 |
http_proc = _FakeRequestProcessor(NotImplemented) |
| 116 | 118 |
proc = rpc._RpcProcessor(resolver, 30668) |
| 117 |
result = proc(["n17296"], "version", None, _req_process_fn=http_proc, |
|
| 119 |
host = "n17296" |
|
| 120 |
body = {host: ""}
|
|
| 121 |
result = proc([host], "version", body, _req_process_fn=http_proc, |
|
| 118 | 122 |
read_timeout=60) |
| 119 |
self.assertEqual(result.keys(), ["n17296"])
|
|
| 120 |
lhresp = result["n17296"]
|
|
| 123 |
self.assertEqual(result.keys(), [host])
|
|
| 124 |
lhresp = result[host]
|
|
| 121 | 125 |
self.assertTrue(lhresp.offline) |
| 122 |
self.assertEqual(lhresp.node, "n17296")
|
|
| 126 |
self.assertEqual(lhresp.node, host)
|
|
| 123 | 127 |
self.assertTrue(lhresp.fail_msg) |
| 124 | 128 |
self.assertFalse(lhresp.payload) |
| 125 | 129 |
self.assertEqual(lhresp.call, "version") |
| ... | ... | |
| 142 | 146 |
|
| 143 | 147 |
def testMultiVersionSuccess(self): |
| 144 | 148 |
nodes = ["node%s" % i for i in range(50)] |
| 149 |
body = dict((n, "") for n in nodes) |
|
| 145 | 150 |
resolver = rpc._StaticResolver(nodes) |
| 146 | 151 |
http_proc = _FakeRequestProcessor(self._GetMultiVersionResponse) |
| 147 | 152 |
proc = rpc._RpcProcessor(resolver, 23245) |
| 148 |
result = proc(nodes, "version", None, _req_process_fn=http_proc,
|
|
| 153 |
result = proc(nodes, "version", body, _req_process_fn=http_proc,
|
|
| 149 | 154 |
read_timeout=60) |
| 150 | 155 |
self.assertEqual(sorted(result.keys()), sorted(nodes)) |
| 151 | 156 |
|
| ... | ... | |
| 173 | 178 |
http_proc = \ |
| 174 | 179 |
_FakeRequestProcessor(compat.partial(self._GetVersionResponseFail, |
| 175 | 180 |
errinfo)) |
| 176 |
result = proc(["aef9ur4i.example.com"], "version", None, |
|
| 181 |
host = "aef9ur4i.example.com" |
|
| 182 |
body = {host: ""}
|
|
| 183 |
result = proc(body.keys(), "version", body, |
|
| 177 | 184 |
_req_process_fn=http_proc, read_timeout=60) |
| 178 |
self.assertEqual(result.keys(), ["aef9ur4i.example.com"])
|
|
| 179 |
lhresp = result["aef9ur4i.example.com"]
|
|
| 185 |
self.assertEqual(result.keys(), [host])
|
|
| 186 |
lhresp = result[host]
|
|
| 180 | 187 |
self.assertFalse(lhresp.offline) |
| 181 |
self.assertEqual(lhresp.node, "aef9ur4i.example.com")
|
|
| 188 |
self.assertEqual(lhresp.node, host)
|
|
| 182 | 189 |
self.assert_(lhresp.fail_msg) |
| 183 | 190 |
self.assertFalse(lhresp.payload) |
| 184 | 191 |
self.assertEqual(lhresp.call, "version") |
| ... | ... | |
| 208 | 215 |
|
| 209 | 216 |
def testHttpError(self): |
| 210 | 217 |
nodes = ["uaf6pbbv%s" % i for i in range(50)] |
| 218 |
body = dict((n, "") for n in nodes) |
|
| 211 | 219 |
resolver = rpc._StaticResolver(nodes) |
| 212 | 220 |
|
| 213 | 221 |
httperrnodes = set(nodes[1::7]) |
| ... | ... | |
| 222 | 230 |
http_proc = \ |
| 223 | 231 |
_FakeRequestProcessor(compat.partial(self._GetHttpErrorResponse, |
| 224 | 232 |
httperrnodes, failnodes)) |
| 225 |
result = proc(nodes, "vg_list", None, _req_process_fn=http_proc,
|
|
| 233 |
result = proc(nodes, "vg_list", body, _req_process_fn=http_proc,
|
|
| 226 | 234 |
read_timeout=rpc._TMO_URGENT) |
| 227 | 235 |
self.assertEqual(sorted(result.keys()), sorted(nodes)) |
| 228 | 236 |
|
| ... | ... | |
| 265 | 273 |
|
| 266 | 274 |
for fn in [self._GetInvalidResponseA, self._GetInvalidResponseB]: |
| 267 | 275 |
http_proc = _FakeRequestProcessor(fn) |
| 268 |
result = proc(["oqo7lanhly.example.com"], "version", None, |
|
| 276 |
host = "oqo7lanhly.example.com" |
|
| 277 |
body = {host: ""}
|
|
| 278 |
result = proc([host], "version", body, |
|
| 269 | 279 |
_req_process_fn=http_proc, read_timeout=60) |
| 270 |
self.assertEqual(result.keys(), ["oqo7lanhly.example.com"])
|
|
| 271 |
lhresp = result["oqo7lanhly.example.com"]
|
|
| 280 |
self.assertEqual(result.keys(), [host])
|
|
| 281 |
lhresp = result[host]
|
|
| 272 | 282 |
self.assertFalse(lhresp.offline) |
| 273 |
self.assertEqual(lhresp.node, "oqo7lanhly.example.com")
|
|
| 283 |
self.assertEqual(lhresp.node, host)
|
|
| 274 | 284 |
self.assert_(lhresp.fail_msg) |
| 275 | 285 |
self.assertFalse(lhresp.payload) |
| 276 | 286 |
self.assertEqual(lhresp.call, "version") |
| ... | ... | |
| 295 | 305 |
http_proc = _FakeRequestProcessor(compat.partial(self._GetBodyTestResponse, |
| 296 | 306 |
test_data)) |
| 297 | 307 |
proc = rpc._RpcProcessor(resolver, 18700) |
| 298 |
body = serializer.DumpJson(test_data) |
|
| 299 |
result = proc(["node19759"], "upload_file", body, _req_process_fn=http_proc, |
|
| 308 |
host = "node19759" |
|
| 309 |
body = {host: serializer.DumpJson(test_data)}
|
|
| 310 |
result = proc([host], "upload_file", body, _req_process_fn=http_proc, |
|
| 300 | 311 |
read_timeout=30) |
| 301 |
self.assertEqual(result.keys(), ["node19759"])
|
|
| 302 |
lhresp = result["node19759"]
|
|
| 312 |
self.assertEqual(result.keys(), [host])
|
|
| 313 |
lhresp = result[host]
|
|
| 303 | 314 |
self.assertFalse(lhresp.offline) |
| 304 |
self.assertEqual(lhresp.node, "node19759")
|
|
| 315 |
self.assertEqual(lhresp.node, host)
|
|
| 305 | 316 |
self.assertFalse(lhresp.fail_msg) |
| 306 | 317 |
self.assertEqual(lhresp.payload, None) |
| 307 | 318 |
self.assertEqual(lhresp.call, "upload_file") |
Also available in: Unified diff