def __init__(self, transport, target, timeout=None, version_cap=None, serializer=None): """Construct an RPC client. :param transport: a messaging transport handle :type transport: Transport :param target: the default target for invocations :type target: Target :param timeout: an optional default timeout (in seconds) for call()s :type timeout: int or float :param version_cap: raise a RPCVersionCapError version exceeds this cap :type version_cap: str :param serializer: an optional entity serializer :type serializer: Serializer """ self.conf = transport.conf self.conf.register_opts(_client_opts) self.transport = transport self.target = target self.timeout = timeout self.version_cap = version_cap self.serializer = serializer or msg_serializer.NoOpSerializer() super(RPCClient, self).__init__()
def test_serializer(self): endpoint = _FakeEndpoint() serializer = msg_serializer.NoOpSerializer() target = messaging.Target() dispatcher = messaging.RPCDispatcher(target, [endpoint], serializer) self.mox.StubOutWithMock(endpoint, 'foo') args = dict([(k, 'd' + v) for k, v in self.args.items()]) endpoint.foo(self.dctxt, **args).AndReturn(self.retval) self.mox.StubOutWithMock(serializer, 'serialize_entity') self.mox.StubOutWithMock(serializer, 'deserialize_entity') self.mox.StubOutWithMock(serializer, 'deserialize_context') serializer.deserialize_context(self.ctxt).AndReturn(self.dctxt) for arg in self.args: serializer.deserialize_entity(self.dctxt, arg).AndReturn('d' + arg) serializer.serialize_entity(self.dctxt, self.retval).\ AndReturn('s' + self.retval if self.retval else None) self.mox.ReplayAll() retval = dispatcher._dispatch(self.ctxt, dict(method='foo', args=self.args)) if self.retval is not None: self.assertEqual('s' + self.retval, retval)
def __init__(self, target, endpoints, serializer): """Construct a rpc server dispatcher. :param target: the exchange, topic and server to listen on :type target: Target """ self.endpoints = endpoints self.serializer = serializer or msg_serializer.NoOpSerializer() self._default_target = msg_target.Target() self._target = target
def __init__(self, targets, endpoints, serializer, allow_requeue): self.targets = targets self.endpoints = endpoints self.serializer = serializer or msg_serializer.NoOpSerializer() self.allow_requeue = allow_requeue self._callbacks_by_priority = {} for endpoint, prio in itertools.product(endpoints, PRIORITIES): if hasattr(endpoint, prio): method = getattr(endpoint, prio) self._callbacks_by_priority.setdefault(prio, []).append(method) priorities = self._callbacks_by_priority.keys() self._targets_priorities = set( itertools.product(self.targets, priorities))
def __init__(self, transport, publisher_id=None, driver=None, topic=None, serializer=None, retry=None): """Construct a Notifier object. :param transport: the transport to use for sending messages :type transport: oslo.messaging.Transport :param publisher_id: field in notifications sent, for example 'compute.host1' :type publisher_id: str :param driver: a driver to lookup from oslo.messaging.notify.drivers :type driver: str :param topic: the topic which to send messages on :type topic: str :param serializer: an optional entity serializer :type serializer: Serializer :param retry: an connection retries configuration None or -1 means to retry forever 0 means no retry N means N retries :type retry: int """ transport.conf.register_opts(_notifier_opts) self.transport = transport self.publisher_id = publisher_id self.retry = retry self._driver_names = ([driver] if driver is not None else transport.conf.notification_driver) self._topics = ([topic] if topic is not None else transport.conf.notification_topics) self._serializer = serializer or msg_serializer.NoOpSerializer() self._driver_mgr = named.NamedExtensionManager( 'oslo.messaging.notify.drivers', names=self._driver_names, invoke_on_load=True, invoke_args=[transport.conf], invoke_kwds={ 'topics': self._topics, 'transport': self.transport, })
def test_call_serializer(self): self.config(rpc_response_timeout=None) transport = _FakeTransport(self.conf) serializer = msg_serializer.NoOpSerializer() client = messaging.RPCClient(transport, messaging.Target(), serializer=serializer) self.mox.StubOutWithMock(transport, '_send') msg = dict(method='foo', args=dict([(k, 's' + v) for k, v in self.args.items()])) kwargs = dict(wait_for_reply=True, timeout=None) if self.call else {} kwargs['retry'] = None transport._send(messaging.Target(), dict(user='******'), msg, **kwargs).AndReturn(self.retval) self.mox.StubOutWithMock(serializer, 'serialize_entity') self.mox.StubOutWithMock(serializer, 'deserialize_entity') self.mox.StubOutWithMock(serializer, 'serialize_context') for arg in self.args: serializer.serialize_entity(self.ctxt, arg).AndReturn('s' + arg) if self.call: serializer.deserialize_entity(self.ctxt, self.retval).\ AndReturn('d' + self.retval) serializer.serialize_context(self.ctxt).AndReturn(dict(user='******')) self.mox.ReplayAll() method = client.call if self.call else client.cast retval = method(self.ctxt, 'foo', **self.args) if self.retval is not None: self.assertEqual('d' + self.retval, retval)
def test_serializer(self, mock_utcnow): transport = _FakeTransport(self.conf) serializer = msg_serializer.NoOpSerializer() notifier = messaging.Notifier(transport, 'test.localhost', driver='test', topic='test', serializer=serializer) message_id = uuid.uuid4() self.mox.StubOutWithMock(uuid, 'uuid4') uuid.uuid4().AndReturn(message_id) mock_utcnow.return_value = datetime.datetime.utcnow() self.mox.StubOutWithMock(serializer, 'serialize_context') self.mox.StubOutWithMock(serializer, 'serialize_entity') serializer.serialize_context(dict(user='******')).\ AndReturn(dict(user='******')) serializer.serialize_entity(dict(user='******'), 'bar').AndReturn('sbar') self.mox.ReplayAll() notifier.info(dict(user='******'), 'test.notify', 'bar') message = { 'message_id': str(message_id), 'publisher_id': 'test.localhost', 'event_type': 'test.notify', 'priority': 'INFO', 'payload': 'sbar', 'timestamp': str(timeutils.utcnow()), } self.assertEqual([(dict(user='******'), message, 'INFO', None)], _impl_test.NOTIFICATIONS)
def __init__(self, endpoints, serializer): self.endpoints = endpoints self.serializer = serializer or msg_serializer.NoOpSerializer() self._default_target = target.Target()