def test_send_internal_and_broker(self):
frame = Frame(command=Command.SEND,
headers={Headers.DESTINATION: 'jms.topic.vdsm_requests',
Headers.REPLY_TO: 'jms.topic.vdsm_responses',
Headers.CONTENT_LENGTH: '103'},
body=('{"jsonrpc":"2.0","method":"Host.getAllVmStats",'
'"params":{},"id":"e8a936a6-d886-4cfa-97b9-2d54209'
'053ff"}'
)
)
ids = {}
subscription = TestSubscription('jms.topic.vdsm_requests',
'e8a936a6-d886-4cfa-97b9-2d54209053ff')
client = TestClient()
subscription.set_client(client)
destinations = defaultdict(list)
destinations['jms.topic.vdsm_requests'].append(subscription)
adapter = StompAdapterImpl(Reactor(), destinations, ids)
adapter.handle_frame(TestDispatcher(adapter), frame)
data = adapter.pop_message()
self.assertIsNot(data, None)
request = JsonRpcRequest.decode(data)
self.assertEqual(request.method, 'Host.getAllVmStats')
self.assertEqual(len(ids), 1)
resp_frame = client.pop_message()
self.assertIsNot(resp_frame, None)
self.assertEqual(resp_frame.command, Command.MESSAGE)
self.assertEqual(resp_frame.body, data)
def _callMethod(self, methodName, *args, **kwargs):
try:
method = _COMMAND_CONVERTER[methodName]
except KeyError as e:
raise Exception("Attempt to call function: %s with "
"arguments: %s error: %s" % (methodName, args, e))
class_name, method_name = method.split('.')
params = self._prepare_args(class_name, method_name, args, kwargs)
timeout = kwargs.pop('_transport_timeout', CALL_TIMEOUT)
req = JsonRpcRequest(method, params, reqId=str(uuid4()))
responses = self._client.call(req, timeout=timeout)
if responses:
resp = responses[0]
else:
raise JsonRpcNoResponseError(method)
if resp.error is not None:
return response.error_raw(resp.error["code"],
resp.error["message"])
if not self._xml_compat:
return response.success_raw(resp.result)
if resp.result and resp.result is not True:
# None is translated to True inside our JSONRPC implementation
return response.success(**resp.result)
return response.success()
def test_full_pool(self):
def thread_factory(callable):
raise exception.ResourceExhausted("Too many tasks",
resource="test",
current_tasks=0)
ctx = FakeContext()
request = JsonRpcRequest.decode(
'{"jsonrpc":"2.0","method":"Host.stats","params":{},"id":"943"}')
server = JsonRpcServer(None, 0, None, threadFactory=thread_factory)
server._runRequest(ctx, request)
error = ctx.response.toDict().get('error')
self.assertEqual(1100, error.get('code'))
msg = error.get('message')
self.assertTrue(msg.startswith("Not enough resources:"))
# not deterministic order in a dict so we need to parse
reason = json.loads(msg[22:].replace("'", '"'))
self.assertEqual(
{
"reason": "Too many tasks",
"resource": "test",
"current_tasks": 0
}, reason)
def test_send_internal_and_broker(self):
frame = Frame(command=Command.SEND,
headers={Headers.DESTINATION: 'jms.topic.vdsm_requests',
Headers.REPLY_TO: 'jms.topic.vdsm_responses',
Headers.CONTENT_LENGTH: '103'},
body=('{"jsonrpc":"2.0","method":"Host.getAllVmStats",'
'"params":{},"id":"e8a936a6-d886-4cfa-97b9-2d54209'
'053ff"}'
)
)
ids = {}
subscription = FakeSubscription('jms.topic.vdsm_requests',
'e8a936a6-d886-4cfa-97b9-2d54209053ff')
client = FakeAsyncClient()
subscription.set_client(client)
destinations = defaultdict(list)
destinations['jms.topic.vdsm_requests'].append(subscription)
adapter = StompAdapterImpl(Reactor(), destinations, ids)
adapter.handle_frame(FakeAsyncDispatcher(adapter), frame)
data = adapter.pop_message()
self.assertIsNot(data, None)
request = JsonRpcRequest.decode(data)
self.assertEqual(request.method, 'Host.getAllVmStats')
self.assertEqual(len(ids), 1)
resp_frame = client.pop_message()
self.assertIsNot(resp_frame, None)
self.assertEqual(resp_frame.command, Command.MESSAGE)
self.assertEqual(resp_frame.body, data)
def callMethod(self, methodName, params=[], rid=None):
responses = self.call(JsonRpcRequest(methodName, params, rid))
if responses is None:
raise exception.JsonRpcNoResponseError(method=methodName)
response = responses[0]
if response.error:
raise response.error
else:
return response.result
def _callTimeout(self, client, methodName, params=None, rid=None,
timeout=None):
responses = client.call(JsonRpcRequest(methodName, params, rid),
timeout=CALL_TIMEOUT)
if not responses:
raise JsonRpcNoResponseError(methodName)
resp = responses[0]
if resp.error is not None:
raise JsonRpcError(resp.error['code'], resp.error['message'])
return resp.result
def _callTimeout(self,
client,
methodName,
params=None,
rid=None,
timeout=None):
call = client.call_async(JsonRpcRequest(methodName, params, rid))
self.assertTrue(call.wait(timeout))
resp = call.responses[0]
if resp.error is not None:
raise JsonRpcError(resp.error['code'], resp.error['message'])
return resp.result
def test_client_reconnect_failed(self):
bridge = _DummyBridge()
with constructAcceptor(self.log, False, bridge) as acceptor:
client = SimpleClient(acceptor._host,
acceptor._port,
False,
incoming_heartbeat=1000,
outgoing_heartbeat=5000,
nr_retries=1)
# make sure client received CONNECTED frame
time.sleep(2)
acceptor.stop()
time.sleep(2)
with self.assertRaises(Disconnected):
client.call(JsonRpcRequest("ping", [], CALL_ID),
timeout=CALL_TIMEOUT)
def test_send_broker_parent_topic(self):
frame = Frame(command=Command.SEND,
headers={Headers.DESTINATION:
'jms.topic.vdsm_requests.getAllVmStats',
Headers.REPLY_TO:
'jms.topic.vdsm_responses.getAllVmStats',
Headers.CONTENT_LENGTH: '103'},
body=('{"jsonrpc":"2.0","method":"Host.getAllVmStats",'
'"params":{},"id":"e8a936a6-d886-4cfa-97b9-2d54209'
'053ff"}'
)
)
ids = {}
subscription = FakeSubscription('jms.topic.vdsm_requests',
'e8a936a6-d886-4cfa-97b9-2d54209053ff')
client = FakeAsyncClient()
subscription.set_client(client)
destinations = defaultdict(list)
destinations['jms'].append(subscription)
destinations['jms.topic'].append(subscription)
destinations['jms.topic.vdsm_requests'].append(subscription)
# Topics that should not match
destinations['jms.other'].append(subscription)
destinations['jms.top'].append(subscription)
adapter = StompAdapterImpl(Reactor(), destinations, ids)
adapter.handle_frame(FakeAsyncDispatcher(adapter), frame)
data = adapter.pop_message()
self.assertIsNot(data, None)
request = JsonRpcRequest.decode(data)
self.assertEqual(request.method, 'Host.getAllVmStats')
self.assertEqual(len(ids), 1)
for i in range(3):
resp_frame = client.pop_message()
self.assertIsNot(resp_frame, None)
self.assertEqual(resp_frame.command, Command.MESSAGE)
self.assertEqual(resp_frame.body, data)
# The last two subscriptions do not match
self.assertTrue(client.empty())
def test_send_broker_parent_topic(self):
frame = Frame(command=Command.SEND,
headers={Headers.DESTINATION:
'jms.topic.vdsm_requests.getAllVmStats',
Headers.REPLY_TO:
'jms.topic.vdsm_responses.getAllVmStats',
Headers.CONTENT_LENGTH: '103'},
body=('{"jsonrpc":"2.0","method":"Host.getAllVmStats",'
'"params":{},"id":"e8a936a6-d886-4cfa-97b9-2d54209'
'053ff"}'
)
)
ids = {}
subscription = TestSubscription('jms.topic.vdsm_requests',
'e8a936a6-d886-4cfa-97b9-2d54209053ff')
client = TestClient()
subscription.set_client(client)
destinations = defaultdict(list)
destinations['jms'].append(subscription)
destinations['jms.topic'].append(subscription)
destinations['jms.topic.vdsm_requests'].append(subscription)
# Topics that should not match
destinations['jms.other'].append(subscription)
destinations['jms.top'].append(subscription)
adapter = StompAdapterImpl(Reactor(), destinations, ids)
adapter.handle_frame(TestDispatcher(adapter), frame)
data = adapter.pop_message()
self.assertIsNot(data, None)
request = JsonRpcRequest.decode(data)
self.assertEqual(request.method, 'Host.getAllVmStats')
self.assertEqual(len(ids), 1)
for i in range(3):
resp_frame = client.pop_message()
self.assertIsNot(resp_frame, None)
self.assertEqual(resp_frame.command, Command.MESSAGE)
self.assertEqual(resp_frame.body, data)
# The last two subscriptions do not match
self.assertTrue(client.empty())
def test_send(self):
frame = Frame(command=Command.SEND,
headers={Headers.DESTINATION: 'jms.topic.vdsm_requests',
Headers.REPLY_TO: 'jms.topic.vdsm_responses',
Headers.CONTENT_LENGTH: '103'},
body=('{"jsonrpc":"2.0","method":"Host.getAllVmStats",'
'"params":{},"id":"e8a936a6-d886-4cfa-97b9-2d54209'
'053ff"}'
)
)
ids = {}
adapter = StompAdapterImpl(Reactor(), defaultdict(list), ids)
adapter.handle_frame(TestDispatcher(adapter), frame)
data = adapter.pop_message()
self.assertIsNot(data, None)
request = JsonRpcRequest.decode(data)
self.assertEqual(request.method, 'Host.getAllVmStats')
self.assertEqual(len(ids), 1)
def test_send(self):
frame = Frame(command=Command.SEND,
headers={Headers.DESTINATION: 'jms.topic.vdsm_requests',
Headers.REPLY_TO: 'jms.topic.vdsm_responses',
Headers.CONTENT_LENGTH: '103'},
body=('{"jsonrpc":"2.0","method":"Host.getAllVmStats",'
'"params":{},"id":"e8a936a6-d886-4cfa-97b9-2d54209'
'053ff"}'
)
)
ids = {}
adapter = StompAdapterImpl(Reactor(), defaultdict(list), ids)
adapter.handle_frame(FakeAsyncDispatcher(adapter), frame)
data = adapter.pop_message()
self.assertIsNot(data, None)
request = JsonRpcRequest.decode(data)
self.assertEqual(request.method, 'Host.getAllVmStats')
self.assertEqual(len(ids), 1)
def _processEvent(self, obj, event_queue):
if not event_queue:
self.log.debug(
"No event queue is registered for received event, "
"ignoring. Event: %s", obj)
return
if isinstance(obj, list):
for o in obj:
self._processEvent(o, event_queue)
return
req = JsonRpcRequest.fromRawObject(obj)
if not req.isNotification():
self.log.warning("Recieved non notification, ignoring")
return
try:
event_queue.put((req.method, req.params))
except queue.Full:
self.log.warning("Event queue full, ignoring received event.")
def test_full_pool(self):
def thread_factory(callable):
raise exception.ResourceExhausted("Too many tasks",
resource="test", current_tasks=0)
ctx = FakeContext()
request = JsonRpcRequest.decode(
'{"jsonrpc":"2.0","method":"Host.stats","params":{},"id":"943"}')
server = JsonRpcServer(None, 0, None, threadFactory=thread_factory)
server._runRequest(ctx, request)
error = ctx.response.toDict().get('error')
self.assertEqual(1100, error.get('code'))
msg = error.get('message')
self.assertTrue(msg.startswith("Not enough resources:"))
# not deterministic order in a dict so we need to parse
reason = json.loads(msg[22:].replace("'", '"'))
self.assertEqual({"reason": "Too many tasks",
"resource": "test",
"current_tasks": 0}, reason)
def _processEvent(self, obj, event_queue):
if not event_queue:
self.log.debug(
"No event queue is registered for received event, "
"ignoring. Event: %s",
obj
)
return
if isinstance(obj, list):
for o in obj:
self._processEvent(o, event_queue)
return
req = JsonRpcRequest.fromRawObject(obj)
if not req.isNotification():
self.log.warning("Recieved non notification, ignoring")
return
try:
event_queue.put((req.method, req.params))
except queue.Full:
self.log.warning("Event queue full, ignoring received event.")
def _callMethod(self, methodName, *args, **kwargs):
try:
method = _COMMAND_CONVERTER[methodName]
except KeyError as e:
raise Exception("Attempt to call function: %s with "
"arguments: %s error: %s" % (methodName, args, e))
class_name, method_name = method.split('.')
timeout = kwargs.pop('_transport_timeout', self._default_timeout)
params = self._prepare_args(class_name, method_name, args, kwargs)
req = JsonRpcRequest(method, params, reqId=str(uuid4()))
responses = self._client.call(req,
timeout=self._timeouts.get(
method_name, timeout))
if responses:
resp = responses[0]
else:
raise JsonRpcNoResponseError(method=method)
if resp.error is not None:
return response.error_raw(resp.error.code, str(resp.error))
if not self._xml_compat:
return response.success_raw(resp.result)
if resp.result and resp.result is not True:
# None is translated to True inside our JSONRPC implementation
if isinstance(resp.result, list):
return response.success(items=resp.result)
elif isinstance(resp.result, six.string_types):
return response.success(resp.result)
else:
return response.success(**resp.result)
return response.success()
