def _prepare_notification_service(server_id):
endpoints = [report_notification, track_instance, untrack_instance]
transport = messaging.get_transport(config.CONF)
s_target = target.Target(topic='murano', server=server_id)
dispatcher = oslo_dispatcher.NotificationDispatcher([s_target], endpoints,
None, True)
return messaging.MessageHandlingServer(transport, dispatcher, 'eventlet')
def listen_for_notifications(self, targets_and_priorities):
LOG.debug("Listen for notifications %s", targets_and_priorities)
listener = ProtonListener(self)
for target, priority in targets_and_priorities:
topic = '%s.%s' % (target.topic, priority)
t = messaging_target.Target(topic=topic)
self._ctrl.add_task(ListenTask(t, listener, True))
return listener
def target_parse(target_str):
attrs = target_str.split(',')
kwargs = dict(attr.split('=', 1) for attr in attrs)
if 'fanout' in kwargs:
# should use oslo.config.types.Bool.__call__ ?
value = kwargs['fanout']
kwargs['fanout'] = _BOOLEAN_STATES[value.lower()]
return target.Target(**kwargs)
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 listen_for_notifications(self, targets_and_priorities, pool):
LOG.debug("Listen for notifications %s", targets_and_priorities)
if pool:
raise NotImplementedError('"pool" not implemented by'
'this transport driver')
listener = ProtonListener(self)
for target, priority in targets_and_priorities:
topic = '%s.%s' % (target.topic, priority)
t = messaging_target.Target(topic=topic)
self._ctrl.add_task(ListenTask(t, listener, True))
return listener
def test_create_destroy_rpc_proxy(self):
self.mock_device_exists.return_value = False
self.agent.create_namespace_agent(self.ctxt, self.port)
with mock.patch('oslo.messaging.proxy.get_proxy_server'
) as mock_get_proxy_server:
mock_transport = self.mock_get_transport.return_value
proxy_id_send = self.agent.create_rpc_proxy(
self.ctxt, self.port_id,
'topic=src_topic_send,server=src_server_send',
'topic=dst_topic_send,server=dst_server_send', 'send')
src_target_send = target.Target(topic='src_topic_send',
server='src_server_send')
dst_target_send = target.Target(topic='dst_topic_send',
server='dst_server_send')
self.agent.create_rpc_proxy(
self.ctxt, self.port_id,
'topic=src_topic_receive,server=src_server_receive',
'topic=dst_topic_receive,server=dst_server_receive', 'receive')
src_target_recv = target.Target(topic='src_topic_receive',
server='src_server_receive')
dst_target_recv = target.Target(topic='dst_topic_receive',
server='dst_server_receive')
self.agent.destroy_rpc_proxy(self.ctxt,
self.port_id, proxy_id_send)
self.agent.destroy_namespace_agent(self.ctxt, self.port_id)
mock_get_proxy_server.assert_has_calls([
mock.call(mock_transport, src_target_send, None,
mock_transport, dst_target_send, None,
executor=mock.ANY),
mock.call().start(),
mock.call(mock_transport, dst_target_recv, None,
mock_transport, src_target_recv, None,
executor=mock.ANY),
mock.call().start(),
mock.call().stop(), mock.call().wait(),
mock.call().stop(), mock.call().wait()])
class TestTarget(base.BaseTestCase):
target_str = ('exchange=default,topic=topic,namespace=namespace,'
'version=version,server=server,fanout=False')
target_instance = target.Target('default', 'topic', 'namespace', 'version',
'server', False)
def test_parse(self):
t = agent_target.target_parse(self.target_str)
self.assertEqual(t, self.target_instance)
def test_str(self):
t = agent_target.target_str(self.target_instance)
self.assertEqual(t, self.target_str)
def test_create_destroy_rpc_proxy_receive(self):
self.agent.create_namespace_agent(self.ctxt, self.port)
with mock.patch('oslo.messaging.proxy.get_proxy_server'
) as mock_get_proxy_server:
mock_transport = self.mock_get_transport.return_value
mock_instance = mock_get_proxy_server.return_value
proxy_id = self.agent.create_rpc_proxy(
self.ctxt, self.port_id, 'topic=src_topic,server=src_server',
'topic=dst_topic,server=dst_server', 'receive')
src_target = target.Target(topic='src_topic', server='src_server')
dst_target = target.Target(topic='dst_topic', server='dst_server')
mock_get_proxy_server.assert_called_once_with(
mock_transport, dst_target, None,
mock_transport, src_target, None, executor=mock.ANY)
mock_instance.start.assert_called_once_with()
self.agent.destroy_rpc_proxy(self.ctxt, self.port_id, proxy_id)
mock_instance.stop.assert_called_once_with()
mock_instance.wait.assert_called_once_with()
self.agent.destroy_namespace_agent(self.ctxt, self.port_id)
def start_listener(conf, exchange, topic, endpoints):
"""Start up notification listener
:param: conf configuration object for listener
:param: exchange exchange name
:param: topic topic name
:param: endpoints the listener endpoints
"""
trans = transport.get_transport(conf)
targets = [target.Target(exchange=exchange, topic=topic)]
create_listener = listener.get_notification_listener
if 'pool' in inspect.getargspec(create_listener).args:
pool_name = _get_pool_name(exchange)
mylistener = create_listener(trans, targets, endpoints,
allow_requeue=False, pool=pool_name)
else:
mylistener = create_listener(trans, targets, endpoints,
allow_requeue=False)
_start_notification_listener(mylistener)
def __init__(self, transport):
client_target = target.Target('murano', 'tasks')
self._client = rpc.RPCClient(transport, client_target, timeout=15)
def _prepare_rpc_service(server_id):
endpoints = [TaskProcessingEndpoint()]
transport = messaging.get_transport(config.CONF)
s_target = target.Target('murano', 'tasks', server=server_id)
return messaging.get_rpc_server(transport, s_target, endpoints, 'eventlet')
def __init__(self, endpoints, serializer):
self.endpoints = endpoints
self.serializer = serializer or msg_serializer.NoOpSerializer()
self._default_target = target.Target()
