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")
|