def __init__(self, endpoints, serializer, access_policy=None):
"""Construct a rpc server dispatcher.
:param endpoints: list of endpoint objects for dispatching to
:param serializer: optional message serializer
"""
for ep in endpoints:
target = getattr(ep, 'target', None)
if target and not isinstance(target, msg_target.Target):
errmsg = "'target' is a reserved Endpoint attribute used" + \
" for namespace and version filtering. It must" + \
" be of type oslo_messaging.Target. Do not" + \
" define an Endpoint method named 'target'"
raise TypeError("%s: endpoint=%s" % (errmsg, ep))
self.endpoints = endpoints
self.serializer = serializer or msg_serializer.NoOpSerializer()
self._default_target = msg_target.Target()
if access_policy is not None:
if issubclass(access_policy, RPCAccessPolicyBase):
self.access_policy = access_policy()
else:
raise TypeError('access_policy must be a subclass of '
'RPCAccessPolicyBase')
else:
self.access_policy = DefaultRPCAccessPolicy()
def __init__(self, transport, target,
timeout=None, version_cap=None, serializer=None, retry=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
:param retry: an optional default connection retries configuration:
None or -1 means to retry forever.
0 means no retry is attempted.
N means attempt at most N retries.
:type retry: int
"""
if serializer is None:
serializer = msg_serializer.NoOpSerializer()
super(RPCClient, self).__init__(
transport, target, serializer, timeout, version_cap, retry
)
self.conf.register_opts(_client_opts)
def test_serializer(self):
endpoint = _FakeEndpoint()
serializer = msg_serializer.NoOpSerializer()
target = oslo_messaging.Target()
dispatcher = oslo_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,
transport,
publisher_id=None,
driver=None,
serializer=None,
retry=None,
topics=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 serializer: an optional entity serializer
:type serializer: Serializer
:param retry: connection retries configuration (used by the messaging
driver):
None or -1 means to retry forever.
0 means no retry is attempted.
N means attempt at most N retries.
:type retry: int
:param topics: the topics which to send messages on
:type topics: list of strings
"""
conf = transport.conf
conf.register_opts(_notifier_opts,
group='oslo_messaging_notifications')
if not isinstance(transport, msg_transport.NotificationTransport):
_LOG.warning("Using RPC transport for notifications. Please use "
"get_notification_transport to obtain a "
"notification transport instance.")
self.transport = transport
self.publisher_id = publisher_id
if retry is not None:
self.retry = retry
else:
self.retry = conf.oslo_messaging_notifications.retry
self._driver_names = ([driver] if driver is not None else
conf.oslo_messaging_notifications.driver)
if topics is not None:
self._topics = topics
else:
self._topics = conf.oslo_messaging_notifications.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=[conf],
invoke_kwds={
'topics': self._topics,
'transport': self.transport,
})
def __init__(self, transport, target,
timeout=None, version_cap=None, serializer=None, retry=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
:param retry: an optional default connection retries configuration
None or -1 means to retry forever
0 means no retry
N means N retries
:type retry: int
"""
self.conf = transport.conf
self.conf.register_opts(_client_opts)
self.transport = transport
self.target = target
self.timeout = timeout
self.retry = retry
self.version_cap = version_cap
self.serializer = serializer or msg_serializer.NoOpSerializer()
super(RPCClient, self).__init__()
def __init__(self,
transport,
publisher_id=None,
driver=None,
topic=None,
serializer=None,
retry=None,
topics=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
:param topics: the topics which to send messages on
:type topic: list of strings
"""
conf = transport.conf
conf.register_opts(_notifier_opts,
group='oslo_messaging_notifications')
self.transport = transport
self.publisher_id = publisher_id
self.retry = retry
self._driver_names = ([driver] if driver is not None else
conf.oslo_messaging_notifications.driver)
if topics is not None:
self._topics = topics
elif topic is not None:
self._topics = [topic]
else:
self._topics = conf.oslo_messaging_notifications.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=[conf],
invoke_kwds={
'topics': self._topics,
'transport': self.transport,
})
def __init__(self, endpoints, serializer):
"""Construct a rpc server dispatcher.
:param endpoints: list of endpoint objects for dispatching to
:param serializer: optional message serializer
"""
self.endpoints = endpoints
self.serializer = serializer or msg_serializer.NoOpSerializer()
self._default_target = msg_target.Target()
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, endpoints, serializer):
self.endpoints = endpoints
self.serializer = serializer or msg_serializer.NoOpSerializer()
self._callbacks_by_priority = {}
for endpoint, prio in itertools.product(endpoints, PRIORITIES):
if hasattr(endpoint, prio):
method = getattr(endpoint, prio)
screen = getattr(endpoint, 'filter_rule', None)
self._callbacks_by_priority.setdefault(prio, []).append(
(screen, method))
def test_call_serializer(self):
self.config(rpc_response_timeout=None)
transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:')
serializer = msg_serializer.NoOpSerializer()
client = oslo_messaging.RPCClient(transport,
oslo_messaging.Target(),
serializer=serializer)
transport._send = mock.Mock()
kwargs = dict(wait_for_reply=True, timeout=None) if self.call else {}
kwargs['retry'] = None
if self.call:
kwargs['call_monitor_timeout'] = None
transport._send.return_value = self.retval
serializer.serialize_entity = mock.Mock()
serializer.deserialize_entity = mock.Mock()
serializer.serialize_context = mock.Mock()
def _stub(ctxt, arg):
return 's' + arg
msg = dict(method='foo', args=dict())
for k, v in self.args.items():
msg['args'][k] = 's' + v
serializer.serialize_entity.side_effect = _stub
if self.call:
serializer.deserialize_entity.return_value = 'd' + self.retval
serializer.serialize_context.return_value = dict(user='******')
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)
transport._send.assert_called_once_with(oslo_messaging.Target(),
dict(user='******'),
msg,
transport_options=None,
**kwargs)
expected_calls = [mock.call(self.ctxt, arg) for arg in self.args]
self.assertEqual(expected_calls,
serializer.serialize_entity.mock_calls)
if self.call:
serializer.deserialize_entity.assert_called_once_with(
self.ctxt, self.retval)
serializer.serialize_context.assert_called_once_with(self.ctxt)
def __init__(self, endpoints, serializer, access_policy=None):
"""Construct a rpc server dispatcher.
:param endpoints: list of endpoint objects for dispatching to
:param serializer: optional message serializer
"""
cfg.CONF.register_opts(_dispatcher_opts)
oslo_rpc_server_ping = None
for ep in endpoints:
# Check if we have an attribute named 'target'
target = getattr(ep, 'target', None)
if target and not isinstance(target, msg_target.Target):
errmsg = "'target' is a reserved Endpoint attribute used" + \
" for namespace and version filtering. It must" + \
" be of type oslo_messaging.Target. Do not" + \
" define an Endpoint method named 'target'"
raise TypeError("%s: endpoint=%s" % (errmsg, ep))
# Check if we have an attribute named 'oslo_rpc_server_ping'
oslo_rpc_server_ping = getattr(ep, 'oslo_rpc_server_ping', None)
if oslo_rpc_server_ping:
errmsg = "'oslo_rpc_server_ping' is a reserved Endpoint" + \
" attribute which can be use to ping the" + \
" endpoint. Please avoid using any oslo_* " + \
" naming."
LOG.warning("%s (endpoint=%s)" % (errmsg, ep))
self.endpoints = endpoints
# Add ping endpoint if enabled in config
if cfg.CONF.rpc_ping_enabled:
if oslo_rpc_server_ping:
LOG.warning("rpc_ping_enabled=True in config but "
"oslo_rpc_server_ping is already declared "
"in an other Endpoint. Not enabling rpc_ping "
"Endpoint.")
else:
self.endpoints.append(PingEndpoint())
self.serializer = serializer or msg_serializer.NoOpSerializer()
self._default_target = msg_target.Target()
if access_policy is not None:
if issubclass(access_policy, RPCAccessPolicyBase):
self.access_policy = access_policy()
else:
raise TypeError('access_policy must be a subclass of '
'RPCAccessPolicyBase')
else:
self.access_policy = DefaultRPCAccessPolicy()
def test_call_serializer(self):
self.config(rpc_response_timeout=None)
transport = _FakeTransport(self.conf)
serializer = msg_serializer.NoOpSerializer()
client = oslo_messaging.RPCClient(transport, oslo_messaging.Target(),
serializer=serializer)
transport._send = mock.Mock()
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.return_value = self.retval
serializer.serialize_entity = mock.Mock()
serializer.deserialize_entity = mock.Mock()
serializer.serialize_context = mock.Mock()
expected_side_effect = []
for arg in self.args:
expected_side_effect.append('s' + arg)
serializer.serialize_entity.side_effect = expected_side_effect
if self.call:
serializer.deserialize_entity.return_value = 'd' + self.retval
serializer.serialize_context.return_value = dict(user='******')
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)
transport._send.assert_called_once_with(oslo_messaging.Target(),
dict(user='******'),
msg,
**kwargs)
expected_calls = [mock.call(self.ctxt, arg) for arg in self.args]
self.assertEqual(expected_calls,
serializer.serialize_entity.mock_calls)
if self.call:
serializer.deserialize_entity.assert_called_once_with(self.ctxt,
self.retval)
serializer.serialize_context.assert_called_once_with(self.ctxt)
def __init__(self,
transport,
target,
timeout=None,
version_cap=None,
serializer=None,
retry=None,
call_monitor_timeout=None,
transport_options=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
:param retry: an optional default connection retries configuration:
None or -1 means to retry forever.
0 means no retry is attempted.
N means attempt at most N retries.
:type retry: int
:param call_monitor_timeout: an optional timeout (in seconds) for
active call heartbeating. If specified,
requires the server to heartbeat
long-running calls at this interval
(less than the overall timeout
parameter).
:type call_monitor_timeout: int
"""
if serializer is None:
serializer = msg_serializer.NoOpSerializer()
if not isinstance(transport, msg_transport.RPCTransport):
LOG.warning("Using notification transport for RPC. Please use "
"get_rpc_transport to obtain an RPC transport "
"instance.")
super(RPCClient,
self).__init__(transport, target, serializer, timeout,
version_cap, retry, call_monitor_timeout,
transport_options)
self.conf.register_opts(_client_opts)
def __init__(self, targets, endpoints, serializer, allow_requeue,
pool=None):
self.targets = targets
self.endpoints = endpoints
self.serializer = serializer or msg_serializer.NoOpSerializer()
self.allow_requeue = allow_requeue
self.pool = pool
self._callbacks_by_priority = {}
for endpoint, prio in itertools.product(endpoints, PRIORITIES):
if hasattr(endpoint, prio):
method = getattr(endpoint, prio)
screen = getattr(endpoint, 'filter_rule', None)
self._callbacks_by_priority.setdefault(prio, []).append(
(screen, method))
priorities = self._callbacks_by_priority.keys()
self._targets_priorities = set(itertools.product(self.targets,
priorities))
def __init__(self, endpoints, serializer, access_policy=None):
"""Construct a rpc server dispatcher.
:param endpoints: list of endpoint objects for dispatching to
:param serializer: optional message serializer
"""
self.endpoints = endpoints
self.serializer = serializer or msg_serializer.NoOpSerializer()
self._default_target = msg_target.Target()
if access_policy is not None:
if issubclass(access_policy, RPCAccessPolicyBase):
self.access_policy = access_policy()
else:
raise TypeError('access_policy must be a subclass of '
'RPCAccessPolicyBase')
else:
# TODO(pvinci): Change to DefaultRPCAccessPolicy when setting to
# DefaultRCPAccessPolicy no longer breaks in tempest tests.
self.access_policy = LegacyRPCAccessPolicy()
def test_serializer(self, mock_utcnow):
transport = oslo_messaging.get_notification_transport(self.conf,
url='fake:')
serializer = msg_serializer.NoOpSerializer()
notifier = oslo_messaging.Notifier(transport,
'test.localhost',
driver='test',
topics=['test'],
serializer=serializer)
message_id = uuid.uuid4()
uuid.uuid4 = mock.Mock(return_value=message_id)
mock_utcnow.return_value = datetime.datetime.utcnow()
serializer.serialize_context = mock.Mock()
serializer.serialize_context.return_value = dict(user='******')
serializer.serialize_entity = mock.Mock()
serializer.serialize_entity.return_value = 'sbar'
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', -1)],
_impl_test.NOTIFICATIONS)
uuid.uuid4.assert_called_once_with()
serializer.serialize_context.assert_called_once_with(dict(user='******'))
serializer.serialize_entity.assert_called_once_with(
dict(user='******'), 'bar')
def test_serializer(self):
endpoint = _FakeEndpoint()
serializer = msg_serializer.NoOpSerializer()
dispatcher = oslo_messaging.RPCDispatcher([endpoint], serializer)
endpoint.foo = mock.Mock()
args = dict([(k, 'd' + v) for k, v in self.args.items()])
endpoint.foo.return_value = self.retval
serializer.serialize_entity = mock.Mock()
serializer.deserialize_entity = mock.Mock()
serializer.deserialize_context = mock.Mock()
serializer.deserialize_context.return_value = self.dctxt
expected_side_effect = ['d' + arg for arg in self.args]
serializer.deserialize_entity.side_effect = expected_side_effect
serializer.serialize_entity.return_value = None
if self.retval:
serializer.serialize_entity.return_value = 's' + self.retval
incoming = mock.Mock()
incoming.ctxt = self.ctxt
incoming.message = dict(method='foo', args=self.args)
incoming.client_timeout = 0
retval = dispatcher.dispatch(incoming)
if self.retval is not None:
self.assertEqual('s' + self.retval, retval)
endpoint.foo.assert_called_once_with(self.dctxt, **args)
serializer.deserialize_context.assert_called_once_with(self.ctxt)
expected_calls = [mock.call(self.dctxt, arg) for arg in self.args]
self.assertEqual(expected_calls,
serializer.deserialize_entity.mock_calls)
serializer.serialize_entity.assert_called_once_with(
self.dctxt, self.retval)
def test_call_serializer(self):
self.config(rpc_response_timeout=None)
transport = _FakeTransport(self.conf)
serializer = msg_serializer.NoOpSerializer()
client = oslo_messaging.RPCClient(transport, oslo_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(oslo_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 = oslo_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)
