def __init__(self): topic = cfg.CONF.oslo_messaging.event_stream_topic if cfg.CONF.oslo_messaging.event_stream_transport_url: # Use custom URL self.transport = oslo_messaging.get_rpc_transport( cfg.CONF, cfg.CONF.oslo_messaging.event_stream_transport_url) else: self.transport = oslo_messaging.get_rpc_transport(cfg.CONF) self.target = oslo_messaging.Target(topic=topic, exchange="common", namespace='control', fanout=False, version='1.0') self.client = oslo_messaging.RPCClient(self.transport, self.target)
def test_warning_when_rpc_transport(self, log): transport = oslo_messaging.get_rpc_transport(self.conf) oslo_messaging.Notifier(transport, 'test.localhost') log.warning.assert_called_once_with( "Using RPC transport for notifications. Please use " "get_notification_transport to obtain a " "notification transport instance.")
def start_keystone_listener(app): global kube_app kube_app = app conf = cfg.ConfigOpts() conf.transport_url = get_transport_url() if conf.transport_url is None: return transport = oslo_messaging.get_rpc_transport(conf) targets = [ oslo_messaging.Target(exchange='keystone', topic='notifications', fanout=True), ] endpoints = [ NotificationEndpoint(), ] pool = "sysinv-keystone-listener-workers" server = oslo_messaging.get_notification_listener(transport, targets, endpoints, pool=pool) LOG.info("Sysinv keystone listener started!") server.start() server.wait()
def init(conf): global TRANSPORT, NOTIFIER exmods = get_allowed_exmods() TRANSPORT = messaging.get_rpc_transport(conf, allowed_remote_exmods=exmods) serializer = RequestContextSerializer(JsonPayloadSerializer()) NOTIFIER = messaging.Notifier(TRANSPORT, serializer=serializer)
def _init_rpc_messaging(self): topic = d_const.OCTAVIA_TO_DRIVER_TOPIC transport = messaging.get_rpc_transport(cfg.CONF) target = messaging.Target(topic=topic, exchange="common", namespace='control', fanout=False, version='1.0') self.client = messaging.RPCClient(transport, target)
def _rpc_transport(self): """Returns an rpc transport. :returns: Object """ return oslo_messaging.get_rpc_transport(self.conf)
def get_transport(): global _TRANSPORT if not _TRANSPORT: _TRANSPORT = messaging.get_rpc_transport(cfg.CONF) return _TRANSPORT
def test_cast_to_target(self): target = oslo_messaging.Target(**self.ctor) expect_target = oslo_messaging.Target(**self.expect) transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') client = oslo_messaging.RPCClient(transport, target) transport._send = mock.Mock() msg = dict(method='foo', args={}) if 'namespace' in self.expect: msg['namespace'] = self.expect['namespace'] if 'version' in self.expect: msg['version'] = self.expect['version'] if self.prepare: client = client.prepare(**self.prepare) if self.double_prepare: client = client.prepare(**self.prepare) client.cast({}, 'foo') transport._send.assert_called_once_with(expect_target, {}, msg, retry=None)
def test_cast_to_target(self): target = oslo_messaging.Target(**self.ctor) expect_target = oslo_messaging.Target(**self.expect) transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') client = oslo_messaging.RPCClient(transport, target) transport._send = mock.Mock() msg = dict(method='foo', args={}) if 'namespace' in self.expect: msg['namespace'] = self.expect['namespace'] if 'version' in self.expect: msg['version'] = self.expect['version'] if self.prepare: client = client.prepare(**self.prepare) if self.double_prepare: client = client.prepare(**self.prepare) client.cast({}, 'foo') transport._send.assert_called_once_with(expect_target, {}, msg, retry=None, transport_options=None)
def test_version_cap(self): self.config(rpc_response_timeout=None) transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') target = oslo_messaging.Target(version=self.version) client = oslo_messaging.RPCClient(transport, target, version_cap=self.cap) prep_kwargs = {} if self.prepare_cap is not _notset: prep_kwargs['version_cap'] = self.prepare_cap if self.prepare_version is not _notset: prep_kwargs['version'] = self.prepare_version if prep_kwargs: client = client.prepare(**prep_kwargs) if self.can_send_version is not _notset: can_send = client.can_send_version(version=self.can_send_version) call_context_can_send = client.prepare().can_send_version( version=self.can_send_version) self.assertEqual(can_send, call_context_can_send) else: can_send = client.can_send_version() self.assertEqual(self.can_send, can_send)
def test_cast_call_with_transport_options(self): self.config(rpc_response_timeout=None) transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') transport_options = oslo_messaging.TransportOptions(at_least_once=True) client = oslo_messaging.RPCClient(transport, oslo_messaging.Target(), transport_options=transport_options) transport._send = mock.Mock() msg = dict(method='foo', args=self.args) kwargs = {'retry': None, 'transport_options': transport_options} if self.call: kwargs['wait_for_reply'] = True kwargs['timeout'] = None kwargs['call_monitor_timeout'] = None method = client.call if self.call else client.cast method(self.ctxt, 'foo', **self.args) self.assertTrue(transport_options.at_least_once) transport._send.assert_called_once_with(oslo_messaging.Target(), self.ctxt, msg, **kwargs)
def _init_rpc_listener(self, healthmonitor, l7policy, l7rule, listener, loadbalancer, member, pool): # Initialize RPC listener topic = constants.OCTAVIA_TO_DRIVER_TOPIC server = socket.gethostname() transport = messaging.get_rpc_transport(cfg.CONF) target = messaging.Target(topic=topic, server=server, exchange="common", fanout=False) self.endpoints = [ NSXOctaviaListenerEndpoint(client=self.client, loadbalancer=loadbalancer, listener=listener, pool=pool, member=member, healthmonitor=healthmonitor, l7policy=l7policy, l7rule=l7rule) ] access_policy = dispatcher.DefaultRPCAccessPolicy self.octavia_server = messaging.get_rpc_server( transport, target, self.endpoints, executor='eventlet', access_policy=access_policy) self.octavia_server.start()
def setup(url=None, optional=False): """Initialise the oslo_messaging layer.""" global TRANSPORT, GLOBAL_TRANSPORT, NOTIFIER if url and url.startswith("fake://"): # NOTE: oslo_messaging fake driver uses time.sleep # for task switch, so we need to monkey_patch it eventlet.monkey_patch(time=True) messaging.set_transport_defaults('senlin') if not TRANSPORT: exmods = ['senlin.common.exception'] try: TRANSPORT = messaging.get_rpc_transport( cfg.CONF, url, allowed_remote_exmods=exmods) except messaging.InvalidTransportURL as e: TRANSPORT = None if not optional or e.url: # NOTE: oslo_messaging is configured but unloadable # so reraise the exception raise if not NOTIFIER: exmods = ['senlin.common.exception'] try: NOTIFICATION_TRANSPORT = messaging.get_notification_transport( cfg.CONF, allowed_remote_exmods=exmods) except Exception as e: raise serializer = RequestContextSerializer(JsonPayloadSerializer()) NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer, topics=cfg.CONF.notification_topics)
def __init__(self, topic, ids, endpoints, fanout=True): """Init function. :param topic: (string) MQ exchange topic :param ids: (list of int) list of IDs of the processes implementing the MQ Notifier which will be in the message context :param endpoints: (list of class) list of classes implementing the methods (see `MessagingNotifier.send_message) used by the Notifier :param fanout: (bool) MQ clients may request that a copy of the message be delivered to all servers listening on a topic by setting fanout to ``True``, rather than just one of them :returns: `MessagingConsumer` class object """ self._ids = ids self._endpoints = endpoints self._transport = oslo_messaging.get_rpc_transport( cfg.CONF, url=messaging.TRANSPORT_URL) self._target = oslo_messaging.Target(topic=topic, fanout=fanout, server=messaging.SERVER) self._server = oslo_messaging.get_rpc_server( self._transport, self._target, self._endpoints, executor=messaging.RPC_SERVER_EXECUTOR, access_policy=oslo_messaging.DefaultRPCAccessPolicy)
def test_client_call_timeout(self): transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') finished = False wait = threading.Condition() class TestEndpoint(object): def ping(self, ctxt, arg): with wait: if not finished: wait.wait() server_thread = self._setup_server(transport, TestEndpoint()) client = self._setup_client(transport) try: client.prepare(timeout=0).call({}, 'ping', arg='foo') except Exception as ex: self.assertIsInstance(ex, oslo_messaging.MessagingTimeout, ex) else: self.assertTrue(False) with wait: finished = True wait.notify() self._stop_server(client, server_thread)
def test_constructor(self, warn): transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') target = oslo_messaging.Target(topic='foo', server='bar') endpoints = [object()] serializer = object() access_policy = dispatcher.DefaultRPCAccessPolicy warnings.simplefilter("always", FutureWarning) server = oslo_messaging.get_rpc_server(transport, target, endpoints, serializer=serializer, access_policy=access_policy) self.assertIs(server.conf, self.conf) self.assertIs(server.transport, transport) self.assertIsInstance(server.dispatcher, oslo_messaging.RPCDispatcher) self.assertIs(server.dispatcher.endpoints, endpoints) self.assertIs(server.dispatcher.serializer, serializer) self.assertEqual('blocking', server.executor_type) self.assertEqual([ mock.call("blocking executor is deprecated. Executor default will " "be removed. Use explicitly threading or eventlet " "instead in version 'pike' and will be removed in " "version 'rocky'", category=FutureWarning, stacklevel=3) ], warn.mock_calls)
def test_server_wait_method(self): transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') target = oslo_messaging.Target(topic='foo', server='bar') endpoints = [object()] serializer = object() class MagicMockIgnoreArgs(mock.MagicMock): """MagicMock ignores arguments. A MagicMock which can never misinterpret the arguments passed to it during construction. """ def __init__(self, *args, **kwargs): super(MagicMockIgnoreArgs, self).__init__() server = oslo_messaging.get_rpc_server(transport, target, endpoints, serializer=serializer) # Mocking executor server._executor_cls = MagicMockIgnoreArgs server._create_listener = MagicMockIgnoreArgs() server.dispatcher = MagicMockIgnoreArgs() # Here assigning executor's listener object to listener variable # before calling wait method, because in wait method we are # setting executor to None. server.start() listener = server.listener server.stop() # call server wait method server.wait() self.assertEqual(1, listener.cleanup.call_count)
def adder(num): global adder_rpc if not adder_rpc: transport_url = 'rabbit://*****:*****@127.0.0.1:5672/' transport = oslo_messaging.get_rpc_transport(cfg.CONF, transport_url) target = oslo_messaging.Target(topic='test') adder_rpc = oslo_messaging.RPCClient(transport, target) return adder_rpc.call({}, 'adder', arg=num)
def __init__(self, target): super(RPCServer, self).__init__() self._server = messaging.get_rpc_server( target=target, transport=messaging.get_rpc_transport(cfg.CONF), endpoints=[ContextEndpointHandler(self, target)], executor='eventlet', )
def __init__(self, amp_id): super(AmphoraUpdateController, self).__init__() topic = cfg.CONF.oslo_messaging.topic self.transport = messaging.get_rpc_transport(cfg.CONF) self.target = messaging.Target( namespace=constants.RPC_NAMESPACE_CONTROLLER_AGENT, topic=topic, version="1.0", fanout=False) self.client = messaging.RPCClient(self.transport, target=self.target) self.amp_id = amp_id
def __init__(self): super(AmphoraProviderDriver, self).__init__() topic = cfg.CONF.oslo_messaging.topic self.transport = messaging.get_rpc_transport(cfg.CONF) self.target = messaging.Target( namespace=consts.RPC_NAMESPACE_CONTROLLER_AGENT, topic=topic, version="1.0", fanout=False) self.client = messaging.RPCClient(self.transport, target=self.target) self.repositories = repositories.Repositories()
def test_call_fanout(self): transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') client = oslo_messaging.RPCClient(transport, oslo_messaging.Target(**self.target)) if self.prepare is not _notset: client = client.prepare(**self.prepare) self.assertRaises(exceptions.InvalidTarget, client.call, {}, 'foo')
def __init__(self): topic = cfg.CONF.oslo_messaging.topic self.transport = messaging.get_rpc_transport(cfg.CONF) self.target = messaging.Target( namespace=constants.RPC_NAMESPACE_CONTROLLER_AGENT, topic=topic, version="1.0", fanout=False) self.client = messaging.RPCClient(self.transport, target=self.target)
def setup_client(rpc_endpoint_info, topic, server): oslo_messaging.set_transport_defaults(rpc_endpoint_info.Exchange) transport = oslo_messaging.get_rpc_transport(cfg.CONF, url=rpc_endpoint_info.TransportEndpoint) target = oslo_messaging.Target(topic=topic, version=rpc_endpoint_info.Version, server=server, namespace=rpc_endpoint_info.Namespace) client = oslo_messaging.RPCClient(transport, target) return client
def __init__(self, transport=None, context=None, topic=None): serializer = RequestContextSerializer(JsonPayloadSerializer()) if transport is None: transport = messaging.get_rpc_transport(cfg.CONF) self._context = context if topic is None: topic = '' target = messaging.Target(topic=topic) self._client = messaging.RPCClient(transport, target, serializer=serializer)
def test_unknown_executor(self): transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') try: oslo_messaging.get_rpc_server(transport, None, [], executor='foo') except Exception as ex: self.assertIsInstance(ex, oslo_messaging.ExecutorLoadFailure) self.assertEqual('foo', ex.executor) else: self.assertTrue(False)
def test_warning_when_rpc_transport(self, log): transport = oslo_messaging.get_rpc_transport(self.conf) target = oslo_messaging.Target(topic='foo') endpoints = [object()] oslo_messaging.get_notification_listener(transport, [target], endpoints) log.warning.assert_called_once_with( "Using RPC transport for notifications. Please use " "get_notification_transport to obtain a " "notification transport instance.")
def init(conf): global TRANSPORT, NOTIFICATION_TRANSPORT, NOTIFIER exmods = get_allowed_exmods() TRANSPORT = oslo_messaging.get_rpc_transport(conf, allowed_remote_exmods=exmods) NOTIFICATION_TRANSPORT = oslo_messaging.get_notification_transport( conf, allowed_remote_exmods=exmods) serializer = RequestContextSerializer() NOTIFIER = oslo_messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer)
def __init__(self, topic, server, handlers): serializer = RequestContextSerializer(JsonPayloadSerializer()) transport = messaging.get_rpc_transport(cfg.CONF) # TODO(asalkeld) add support for version='x.y' target = messaging.Target(topic=topic, server=server) access_policy = dispatcher.DefaultRPCAccessPolicy self._server = messaging.get_rpc_server(transport, target, handlers, executor='threading', serializer=serializer, access_policy=access_policy)
def test_invalid_version_type(self): target = oslo_messaging.Target(topic='sometopic') transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') client = oslo_messaging.RPCClient(transport, target) self.assertRaises(exceptions.MessagingException, client.prepare, version='5') self.assertRaises(exceptions.MessagingException, client.prepare, version='5.a') self.assertRaises(exceptions.MessagingException, client.prepare, version='5.5.a')
def test_warning_when_rpc_transport(self, log): transport = oslo_messaging.get_rpc_transport(self.conf) target = oslo_messaging.Target(topic='foo') endpoints = [object()] oslo_messaging.get_notification_listener( transport, [target], endpoints) log.warning.assert_called_once_with( "Using RPC transport for notifications. Please use " "get_notification_transport to obtain a " "notification transport instance.")
def init(conf): global TRANSPORT, NOTIFICATION_TRANSPORT, NOTIFIER exmods = get_allowed_exmods() TRANSPORT = messaging.get_rpc_transport(conf, allowed_remote_exmods=exmods) NOTIFICATION_TRANSPORT = messaging.get_notification_transport( conf, allowed_remote_exmods=exmods) serializer = RequestContextSerializer(messaging.JsonPayloadSerializer()) NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer, topics=['notifications'])
def __init__(self, driver, **kwargs): super(OctaviaConsumer, self).__init__(**kwargs) topic = cfg.CONF.oslo_messaging.event_stream_topic server = cfg.CONF.host self.driver = driver self.transport = messaging.get_rpc_transport(cfg.CONF) self.target = messaging.Target(topic=topic, server=server, exchange="common", fanout=False) self.endpoints = [ConsumerEndPoint(self.driver)] self.server = None
def __init__(self): super(A10ProviderDriver, self).__init__() self._args = {} self.transport = messaging.get_rpc_transport(cfg.CONF) self._args['fanout'] = False self._args['namespace'] = constants.RPC_NAMESPACE_CONTROLLER_AGENT self._args['topic'] = "a10_octavia" self._args['version'] = '1.0' self.target = messaging.Target(**self._args) self.client = messaging.RPCClient(self.transport, target=self.target)
def __init__(self, topic, server, handlers): serializer = RequestContextSerializer( objects_base.CloudpulseObjectSerializer()) transport = messaging.get_rpc_transport(cfg.CONF, aliases=TRANSPORT_ALIASES) # TODO(asalkeld) add support for version='x.y' target = messaging.Target(topic=topic, server=server) access_policy = dispatcher.DefaultRPCAccessPolicy self._server = messaging.get_rpc_server(transport, target, handlers, serializer=serializer, access_policy=access_policy)
def test_no_server_topic(self): transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') target = oslo_messaging.Target(server='testserver') server = oslo_messaging.get_rpc_server(transport, target, []) try: server.start() except Exception as ex: self.assertIsInstance(ex, oslo_messaging.InvalidTarget, ex) self.assertEqual('testserver', ex.target.server) else: self.assertTrue(False)
def _init_rpc_listener(self): # Initialize RPC listener topic = d_const.DRIVER_TO_OCTAVIA_TOPIC server = socket.gethostname() transport = messaging.get_rpc_transport(cfg.CONF) target = messaging.Target(topic=topic, server=server, exchange="common", fanout=False) endpoints = [NSXOctaviaDriverEndpoint()] access_policy = dispatcher.DefaultRPCAccessPolicy self.octavia_server = messaging.get_rpc_server( transport, target, endpoints, executor='threading', access_policy=access_policy) self.octavia_server.start()
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, **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 _get_transport(self, next_hop): """NOTE(belliott) Each Transport object contains connection pool state. Maintain references to them to avoid continual reconnects to the message broker. """ transport_url = next_hop.db_info['transport_url'] if transport_url not in self.transports: transport = messaging.get_rpc_transport( nova.conf.CONF, transport_url) self.transports[transport_url] = transport else: transport = self.transports[transport_url] return transport
def _test_no_client_topic(self, call=True): transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') client = self._setup_client(transport, topic=None) method = client.call if call else client.cast try: method({}, 'ping', arg='foo') except Exception as ex: self.assertIsInstance(ex, oslo_messaging.InvalidTarget, ex) self.assertIsNotNone(ex.target) else: self.assertTrue(False)
def __init__(self, topic, server, endpoints, binary): super(Service, self).__init__() serializer = _init_serializer() transport = messaging.get_rpc_transport(CONF) access_policy = dispatcher.DefaultRPCAccessPolicy # TODO(asalkeld) add support for version='x.y' target = messaging.Target(topic=topic, server=server) self.endpoints = endpoints self._server = messaging.get_rpc_server(transport, target, endpoints, executor='eventlet', serializer=serializer, access_policy=access_policy) self.binary = binary profiler.setup(binary, CONF.host)
def test_call(self): # NOTE(milan): using a separate transport instance for each the client # and the server to be able to check independent transport instances # can communicate over same exchange&topic transport_srv = oslo_messaging.get_rpc_transport(self.conf, url='fake:') transport_cli = oslo_messaging.get_rpc_transport(self.conf, url='fake:') class TestEndpoint(object): def ping(self, ctxt, arg): return arg server_thread = self._setup_server(transport_srv, TestEndpoint()) client = self._setup_client(transport_cli) self.assertIsNone(client.call({}, 'ping', arg=None)) self.assertEqual(0, client.call({}, 'ping', arg=0)) self.assertFalse(client.call({}, 'ping', arg=False)) self.assertEqual([], client.call({}, 'ping', arg=[])) self.assertEqual({}, client.call({}, 'ping', arg={})) self.assertEqual('dsdsfoo', client.call({}, 'ping', arg='foo')) self._stop_server(client, server_thread)
def get_specific_transport(url, optional, exmods, is_for_notifications=False): try: if is_for_notifications: return oslo_messaging.get_notification_transport( cfg.CONF, url, allowed_remote_exmods=exmods) else: return oslo_messaging.get_rpc_transport( cfg.CONF, url, allowed_remote_exmods=exmods) except oslo_messaging.InvalidTransportURL as e: if not optional or e.url: # NOTE(sileht): oslo_messaging is configured but unloadable # so reraise the exception raise else: return None
def __init__(self, transport=None, context=None, topic=None, server=None, timeout=None): serializer = RequestContextSerializer( objects_base.CloudpulseObjectSerializer()) if transport is None: exmods = rpc.get_allowed_exmods() transport = messaging.get_rpc_transport( cfg.CONF, allowed_remote_exmods=exmods) self._context = context if topic is None: topic = '' target = messaging.Target(topic=topic, server=server) self._client = messaging.RPCClient(transport, target, serializer=serializer, timeout=timeout)
def test_constructor_without_explicit_RPCAccessPolicy(self, warn): transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') target = oslo_messaging.Target(topic='foo', server='bar') endpoints = [object()] serializer = object() warnings.simplefilter("always", FutureWarning) oslo_messaging.get_rpc_server(transport, target, endpoints, serializer=serializer) self.assertEqual([ mock.call("blocking executor is deprecated. Executor default will " "be removed. Use explicitly threading or eventlet " "instead in version 'pike' and will be removed in " "version 'rocky'", category=FutureWarning, stacklevel=3) ], warn.mock_calls)
def test_context(self): transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') class TestEndpoint(object): def ctxt_check(self, ctxt, key): return ctxt[key] server_thread = self._setup_server(transport, TestEndpoint()) client = self._setup_client(transport) self.assertEqual('dsdsb', client.call({'dsa': 'b'}, 'ctxt_check', key='a')) self._stop_server(client, server_thread)