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