def setUp(self): """Run before each test method to initialize test environment.""" super(TestCase, self).setUp() conf_fixture.set_defaults(CONF) CONF([], default_config_files=[]) global _DB_CACHE if not _DB_CACHE: _DB_CACHE = Database( db_api, migration, sql_connection=CONF.database.connection, sqlite_db=CONF.sqlite_db, sqlite_clean_db=CONF.sqlite_clean_db, ) self.useFixture(_DB_CACHE) self.injected = [] self._services = [] self.flags(fatal_exception_format_errors=True) # This will be cleaned up by the NestedTempfile fixture lock_path = self.useFixture(fixtures.TempDir()).path self.fixture = self.useFixture(config_fixture.Config(lockutils.CONF)) self.fixture.config(lock_path=lock_path, group='oslo_concurrency') self.fixture.config( disable_process_locking=True, group='oslo_concurrency') rpc.add_extra_exmods('manila.tests') self.addCleanup(rpc.clear_extra_exmods) self.addCleanup(rpc.cleanup) self.messaging_conf = messaging_conffixture.ConfFixture(CONF) self.messaging_conf.transport_url = 'fake:/' self.messaging_conf.response_timeout = 15 self.useFixture(self.messaging_conf) oslo_messaging.get_notification_transport(CONF) self.override_config('driver', ['test'], group='oslo_messaging_notifications') rpc.init(CONF) mock.patch('keystoneauth1.loading.load_auth_from_conf_options').start() fake_notifier.stub_notifier(self) # Locks must be cleaned up after tests CONF.set_override('backend_url', 'file://' + lock_path, group='coordination') coordination.LOCK_COORDINATOR.start() self.addCleanup(coordination.LOCK_COORDINATOR.stop)
def test_warning_when_notifier_transport(self, log): transport = oslo_messaging.get_notification_transport(self.conf) oslo_messaging.RPCClient(transport, oslo_messaging.Target()) log.warning.assert_called_once_with( "Using notification transport for RPC. Please use " "get_rpc_transport to obtain an RPC transport " "instance.")
def test_batch_size(self): transport = oslo_messaging.get_notification_transport(self.conf, url='fake:') endpoint = mock.Mock() endpoint.info.return_value = None listener_thread = self._setup_listener(transport, [endpoint], batch=(5, None)) notifier = self._setup_notifier(transport) for _ in range(10): notifier.info({}, 'an_event.start', 'test message') self.wait_for_messages(2) self.assertFalse(listener_thread.stop()) messages = [dict(ctxt={}, publisher_id='testpublisher', event_type='an_event.start', payload='test message', metadata={'message_id': mock.ANY, 'timestamp': mock.ANY})] endpoint.info.assert_has_calls([mock.call(messages * 5), mock.call(messages * 5)])
def init(conf): global TRANSPORT, NOTIFICATION_TRANSPORT, LEGACY_NOTIFIER, NOTIFIER exmods = get_allowed_exmods() TRANSPORT = messaging.get_transport(conf, allowed_remote_exmods=exmods, aliases=TRANSPORT_ALIASES) NOTIFICATION_TRANSPORT = messaging.get_notification_transport( conf, allowed_remote_exmods=exmods, aliases=TRANSPORT_ALIASES) serializer = RequestContextSerializer(JsonPayloadSerializer()) if conf.notification_format == 'unversioned': LEGACY_NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer) NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer, driver='noop') elif conf.notification_format == 'both': LEGACY_NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer) NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer, topics=['versioned_notifications']) else: LEGACY_NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer, driver='noop') NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer, topics=['versioned_notifications'])
def start(self): super(RPCService, self).start() target = messaging.Target(topic=self.topic, server=self.host) endpoints = [self.manager] serializer = objects_base.KongmingObjectSerializer() self.rpcserver = rpc.get_server(target, endpoints, serializer) self.rpcserver.start() admin_context = context.get_admin_context() self.tg.add_dynamic_timer( self.manager.periodic_tasks, periodic_interval_max=CONF.periodic_interval, context=admin_context) LOG.info('Created RPC server for service %(service)s on host ' '%(host)s.', {'service': self.topic, 'host': self.host}) if self.init_notification_listner: transport = messaging.get_notification_transport(CONF) targets = [ messaging.Target(topic='versioned_notifications', exchange='nova') ] endpoints = [ notification_handler.NotificationEndpoint() ] self.notification_listener = messaging.get_notification_listener( transport, targets, endpoints, executor='threading', pool='kongming-notification-handler') self.notification_listener.start()
def test_topics_from_kwargs(self): self.config(driver=['log'], group='oslo_messaging_notifications') transport = oslo_messaging.get_notification_transport(self.conf, url='fake:') notifier = oslo_messaging.Notifier(transport, 'test.localhost', topics=['topic1', 'topic2']) self.assertEqual(['topic1', 'topic2'], notifier._topics)
def init(conf): global TRANSPORT, NOTIFICATION_TRANSPORT, NOTIFIER exmods = get_allowed_exmods() TRANSPORT = oslo_messaging.get_transport(conf, allowed_remote_exmods=exmods, aliases=TRANSPORT_ALIASES) NOTIFICATION_TRANSPORT = oslo_messaging.get_notification_transport( conf, allowed_remote_exmods=exmods, aliases=TRANSPORT_ALIASES ) serializer = RequestContextSerializer() NOTIFIER = oslo_messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer)
def __init__(self, *args, **kwargs): # NOTE(dhellmann): Avoid a cyclical import by doing this one # at runtime. import oslo_messaging logging.Handler.__init__(self, *args, **kwargs) self._transport = oslo_messaging.get_notification_transport(cfg.CONF) self._notifier = oslo_messaging.Notifier( self._transport, publisher_id='error.publisher')
def init(conf): global TRANSPORT, NOTIFIER, NOTIFICATION_TRANSPORT exmods = get_allowed_exmods() TRANSPORT = create_transport(get_transport_url()) NOTIFICATION_TRANSPORT = messaging.get_notification_transport( conf, allowed_remote_exmods=exmods) serializer = RequestContextSerializer(JsonPayloadSerializer()) NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer)
def test_transport_url(self): transport = oslo_messaging.get_notification_transport(self.conf, self.url) self.addCleanup(transport.cleanup) driver = transport._driver self.assertEqual(self.expected['hostaddrs'], driver.pconn.hostaddrs) self.assertEqual(self.expected['username'], driver.pconn.username) self.assertEqual(self.expected['password'], driver.pconn.password) self.assertEqual(self.expected['vhost'], driver.virtual_host)
def init(conf): global TRANSPORT, NOTIFICATION_TRANSPORT, NOTIFIER exmods = get_allowed_exmods() TRANSPORT = oslo_messaging.get_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(conf): global TRANSPORT, NOTIFICATION_TRANSPORT, NOTIFIER exmods = get_allowed_exmods() TRANSPORT = create_transport(get_transport_url()) NOTIFICATION_TRANSPORT = messaging.get_notification_transport( conf, allowed_remote_exmods=exmods) serializer = RequestContextSerializer(JsonPayloadSerializer()) NOTIFIER = messaging.Notifier( NOTIFICATION_TRANSPORT, serializer=serializer)
def initialize(self): """Set up the Vitrage API client and add the notification callback. """ url = self.config['transport_url'] transport = messaging.get_notification_transport(cfg.CONF, url) self.notifier = messaging.Notifier(transport, driver='messagingv2', publisher_id=COLLECTD_DATASOURCE, topics=['vitrage_notifications']) self.add_notification_callback(self.notify)
def __init__(self): if not CONF.stats.env_audit_enabled: return if Notification.transport is None: Notification.transport = messaging.get_notification_transport(CONF) self._notifier = messaging.Notifier( Notification.transport, publisher_id=('murano.%s' % socket.gethostname()), driver='messaging')
def __init__(self): self._zk = None transport = oslo_messaging.get_notification_transport(CONF) targets = [oslo_messaging.Target(exchange='ceilometer', topic='event')] endpoints = [NotificationHandler(self.zk)] server = oslo_messaging.get_notification_listener(transport, targets, endpoints, executor='threading') self.server = server
def test_topics_from_config(self): self.config(driver=['log'], group='oslo_messaging_notifications') self.config(topics=['topic1', 'topic2'], group='oslo_messaging_notifications') transport = oslo_messaging.get_notification_transport(self.conf, url='fake:') notifier = oslo_messaging.Notifier(transport, 'test.localhost') self.assertEqual(['topic1', 'topic2'], notifier._topics)
def __init__(self, app, **conf): self.notifier = notify.Notifier( oslo_messaging.get_notification_transport(cfg.CONF, conf.get('url')), publisher_id=conf.get('publisher_id', os.path.basename(sys.argv[0]))) self.service_name = conf.get('service_name') self.ignore_req_list = [x.upper().strip() for x in conf.get('ignore_req_list', '').split(',')] super(RequestNotifier, self).__init__(app)
def test_transport_url(self): transport = oslo_messaging.get_notification_transport(self.conf, self.url) self.addCleanup(transport.cleanup) driver = transport._driver self.assertEqual(self.expected['hostaddrs'], driver.pconn.hostaddrs) self.assertEqual(self.expected['username'], driver.pconn.username) self.assertEqual(self.expected['password'], driver.pconn.password) self.assertEqual(self.expected['vhost'], driver.virtual_host)
def test_notifier(self): self.config(driver=['noop'], group='oslo_messaging_notifications') transport = oslo_messaging.get_notification_transport(self.conf, url='fake:') notifier = oslo_messaging.Notifier(transport, 'test.localhost') self.assertFalse(notifier.is_enabled())
def get_notification_listener(): endpoints = [report_notification, track_instance, untrack_instance] transport = messaging.get_notification_transport(CONF) s_target = target.Target(topic='murano', server=str(uuid.uuid4())) listener = messaging.get_notification_listener(transport, [s_target], endpoints, executor='threading') return listener
def init(conf): global TRANSPORT, NOTIFICATION_TRANSPORT, NOTIFIER exmods = get_allowed_exmods() #TRANSPORT = messaging.get_rpc_transport(conf, TRANSPORT = messaging.get_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 setUp(self): super(TestRoutingNotifier, self).setUp() self.config(driver=['routing'], group='oslo_messaging_notifications') transport = oslo_messaging.get_notification_transport(self.conf, url='fake:') self.notifier = oslo_messaging.Notifier(transport) self.router = self.notifier._driver_mgr['routing'].obj self.assertTrue(self.notifier.is_enabled())
def test_notifier_retry_config(self): conf = self.messaging_conf.conf self.config(driver=['messaging'], group='oslo_messaging_notifications') conf.set_override('retry', 3, group='oslo_messaging_notifications') transport = oslo_messaging.get_notification_transport(self.conf, url='fake:') notifier = oslo_messaging.Notifier(transport, retry=5) self.assertEqual(5, notifier.retry)
def test_instanciate(self): temp_dir = self.useFixture(fixtures.TempDir()).path self.config(location=temp_dir, group='oslo_messaging_notifications') transport = oslo_messaging.get_notification_transport(self.conf) oslo_messaging.Notifier(transport, driver='prometheus_exporter', topics=['my_topics']) self.assertEqual(self.conf.oslo_messaging_notifications.location, temp_dir) self.assertTrue(os.path.isdir( self.conf.oslo_messaging_notifications.location))
def test_warning_when_notifier_transport(self, log): transport = oslo_messaging.get_notification_transport(self.conf) target = oslo_messaging.Target(topic='foo', server='bar') endpoints = [object()] serializer = object() oslo_messaging.get_rpc_server(transport, target, endpoints, serializer=serializer) log.warning.assert_called_once_with( "Using notification transport for RPC. Please use " "get_rpc_transport to obtain an RPC transport " "instance.")
def __init__(self, app, **conf): self.notifier = notify.Notifier( oslo_messaging.get_notification_transport(cfg.CONF, conf.get('url')), publisher_id=conf.get('publisher_id', os.path.basename(sys.argv[0]))) self.service_name = conf.get('service_name') self.ignore_req_list = [ x.upper().strip() for x in conf.get('ignore_req_list', '').split(',') ] super(RequestNotifier, self).__init__(app)
def __init__(self, environment): if StatusReporter.transport is None: StatusReporter.transport = messaging.get_notification_transport( CONF) self._notifier = messaging.Notifier( StatusReporter.transport, publisher_id=uuidutils.generate_uuid(), topic='murano') if isinstance(environment, six.string_types): self._environment_id = environment else: self._environment_id = environment.id
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 test_logging_conf(self, mock_utcnow): fake_transport = oslo_messaging.get_notification_transport(self.conf) with mock.patch('oslo_messaging.transport._get_transport', return_value=fake_transport): logging.config.dictConfig({ 'version': 1, 'handlers': { 'notification': { 'class': 'oslo_messaging.LoggingNotificationHandler', 'level': self.priority.upper(), 'url': 'test://', }, }, 'loggers': { 'default': { 'handlers': ['notification'], 'level': self.priority.upper(), }, }, }) mock_utcnow.return_value = datetime.datetime.utcnow() levelno = getattr(logging, self.priority.upper()) logger = logging.getLogger('default') lineno = sys._getframe().f_lineno + 1 logger.log(levelno, 'foobar') n = oslo_messaging.notify._impl_test.NOTIFICATIONS[0][1] self.assertEqual(getattr(self, 'queue', self.priority.upper()), n['priority']) self.assertEqual('logrecord', n['event_type']) self.assertEqual(str(timeutils.utcnow()), n['timestamp']) self.assertIsNone(n['publisher_id']) pathname = __file__ if pathname.endswith(('.pyc', '.pyo')): pathname = pathname[:-1] self.assertDictEqual( n['payload'], { 'process': os.getpid(), 'funcName': 'test_logging_conf', 'name': 'default', 'thread': None, 'levelno': levelno, 'processName': 'MainProcess', 'pathname': pathname, 'lineno': lineno, 'msg': 'foobar', 'exc_info': None, 'levelname': logging.getLevelName(levelno), 'extra': None })
def test_warning_when_notifier_transport(self, log): transport = oslo_messaging.get_notification_transport(self.conf) target = oslo_messaging.Target(topic='foo', server='bar') endpoints = [object()] serializer = object() oslo_messaging.get_rpc_server(transport, target, endpoints, serializer=serializer) log.warning.assert_called_once_with( "Using notification transport for RPC. Please use " "get_rpc_transport to obtain an RPC transport " "instance.")
def start(self): endpoints = [report_notification, track_instance, untrack_instance] transport = messaging.get_notification_transport(CONF) s_target = target.Target(topic='murano', server=str(uuid.uuid4())) self.server = messaging.get_notification_listener(transport, [s_target], endpoints, executor='eventlet') self.server.start() super(NotificationService, self).start()
def setup_notifications(): global NOTIFICATION_TRANSPORT, NOTIFIER, MESSAGING_TRANSPORT try: NOTIFICATION_TRANSPORT = messaging.get_notification_transport(cfg.CONF) except Exception: LOG.error("Unable to setup notification transport. Reusing " "service transport for that.") setup_service_messaging() NOTIFICATION_TRANSPORT = MESSAGING_TRANSPORT serializer = ContextSerializer(JsonPayloadSerializer()) NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer)
def start(self): endpoints = [ TaskProcessingEndpoint(), StaticActionEndpoint(), SchemaEndpoint() ] transport = messaging.get_notification_transport(CONF) s_target = target.Target('murano', 'tasks', server=str(uuid.uuid4())) self.server = messaging.get_rpc_server(transport, s_target, endpoints, 'eventlet') self.server.start() super(EngineService, self).start()
def ListenerProc(exchange, project_id, cluster_id): transport = messaging.get_notification_transport(cfg.CONF) targets = [ messaging.Target(topic='notifications', exchange=exchange), ] endpoints = [ NotificationEndpoint(project_id, cluster_id), ] listener = messaging.get_notification_listener( transport, targets, endpoints, pool="senlin-listeners") listener.start() listener.wait()
def ListenerProc(exchange, project_id, cluster_id): transport = messaging.get_notification_transport(cfg.CONF) targets = [ messaging.Target(topic='versioned_notifications', exchange=exchange), ] endpoints = [ NotificationEndpoint(project_id, cluster_id), ] listener = messaging.get_notification_listener( transport, targets, endpoints, executor='threading', pool="senlin-listeners") listener.start()
def get_server_for_sp(sp): """Get notification listener for a particular service provider. The server can be run in the background under eventlet using .start() """ cfg = config.get_conf_for_sp(sp) transport = oslo_messaging.get_notification_transport(CONF, cfg.messagebus) targets = [oslo_messaging.Target(topic='notifications')] return oslo_messaging.get_notification_listener(transport, targets, get_endpoints_for_sp( cfg.sp_name), executor='eventlet')
def get_server_for_sp(sp): """Get notification listener for a particular service provider. The server can be run in the background under eventlet using .start() """ cfg = config.get_conf_for_sp(sp) transport = oslo_messaging.get_notification_transport(CONF, cfg.messagebus) targets = [oslo_messaging.Target(topic='notifications')] return oslo_messaging.get_notification_listener( transport, targets, get_endpoints_for_sp(cfg.sp_name), executor='eventlet')
def __init__(self, monitor_plugins): """Initialize a notification monitor.""" LOG.debug('Initializing a notification monitor...') try: self.handlers = defaultdict(list) self.listener = oslo_messaging.get_notification_listener( oslo_messaging.get_notification_transport(cfg.CONF), self._get_targets(monitor_plugins), self._get_endpoints(monitor_plugins), executor='eventlet') LOG.debug('Notification listener is successfully created.') except Exception as e: LOG.exception('Failed to create a notification listener. (%s)', str(e))
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) if utils.notifications_enabled(conf): json_serializer = messaging.JsonPayloadSerializer() serializer = RequestContextSerializer(json_serializer) NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer) else: NOTIFIER = utils.DO_NOTHING
def __init__(self, app, conf): self.logger = get_logger(conf, log_route='ceilometer') self._app = app oslo_messaging.set_transport_defaults( conf.get('control_exchange', 'swift') ) self._notifier = oslo_messaging.Notifier( oslo_messaging.get_notification_transport(cfg.CONF, url=conf.get('url')), publisher_id='ceilometermiddleware', driver=conf.get('driver', 'messagingv2'), topics=[conf.get('topic', 'notifications')] )
def __init__(self): """ The method for notification client to send message called info(ctxt, msg, priority, retry). :param ctxt: (dict) A request context dict :param msg: (dict) Message to be sent :param priority: (str) Priority of the message(info, warn, error). It is the same as the function name in server's EndPoint. :param retry: (int) The num for client to re-send the message when it is failed. It is optional, and the default is None or -1(Means do not retry) """ super(NotificationClient, self).__init__() self.transport = oslo_messaging.get_notification_transport(cfg.CONF) self.publisher_id = 'oslo_test' self.client = oslo_messaging.Notifier(self.transport, self.publisher_id, driver='messaging', topic=self.topic)
def create_notifier(conf, log): if oslo_messaging: transport = oslo_messaging.get_notification_transport( conf.oslo_conf_obj, url=conf.get('transport_url')) notifier = oslo_messaging.Notifier(transport, os.path.basename(sys.argv[0]), driver=conf.get('driver'), topics=conf.get('topics')) return _MessagingNotifier(notifier) else: return _LogNotifier(log)
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, aliases=_ALIASES) else: return oslo_messaging.get_transport( cfg.CONF, url, allowed_remote_exmods=exmods, aliases=_ALIASES) 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(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(JsonPayloadSerializer()) if not conf.notification_level: NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer, driver='noop') else: NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer)
def start_server(endpoints=[], topic='test_topic', url=''): transport = oslo_messaging.get_notification_transport(cfg.CONF, url=url) targets = [oslo_messaging.Target(topic=topic)] server = oslo_messaging.get_notification_listener(transport, targets, endpoints) try: server.start() server.wait() except KeyboardInterrupt: print("stop server") server.stop() except Exception as e: print("[ERROR] faield to start server '%s'" % (e.message)) server.stop()
def init(conf, rpc_ext_mods=None): global TRANSPORT, NOTIFICATION_TRANSPORT, NOTIFIER if rpc_ext_mods is None: rpc_ext_mods = _DFT_EXMODS else: rpc_ext_mods = list(set(rpc_ext_mods + _DFT_EXMODS)) TRANSPORT = oslo_messaging.get_rpc_transport( conf, allowed_remote_exmods=rpc_ext_mods) NOTIFICATION_TRANSPORT = oslo_messaging.get_notification_transport( conf, allowed_remote_exmods=rpc_ext_mods) serializer = RequestContextSerializer() NOTIFIER = oslo_messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer)
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(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) if utils.notifications_enabled(conf): json_serializer = messaging.JsonPayloadSerializer() serializer = RequestContextSerializer(json_serializer) NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer) else: NOTIFIER = utils.DO_NOTHING
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) # get_notification_transport has loaded oslo_messaging_notifications config # group, so we can now check if notifications are actually enabled. if utils.notifications_enabled(conf): json_serializer = messaging.JsonPayloadSerializer() serializer = RequestContextSerializer(json_serializer) NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer) else: NOTIFIER = utils.DO_NOTHING
def start(self): super(ListenerService, self).start() transport = oslo_messaging.get_notification_transport(CONF) targets = [ oslo_messaging.Target(topic=pl_topic, exchange=pl_exchange) for pl_topic, pl_exchange in self.topics_exchanges_set ] endpoints = [ NotificationEndpoint(self.plugins, PipelineManager(self.plugins)) ] listener = oslo_messaging.get_notification_listener( transport, targets, endpoints, executor='threading', pool=CONF.listener.notifications_pool) listener.start() self.listeners.append(listener)
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 _get_notifier(): """Return a notifier object. If _notifier is None it means that a notifier object has not been set. If _notifier is False it means that a notifier has previously failed to construct. Otherwise it is a constructed Notifier object. """ global _notifier if _notifier is None: host = CONF.default_publisher_id or socket.gethostname() try: transport = oslo_messaging.get_notification_transport(CONF) _notifier = oslo_messaging.Notifier(transport, "identity.%s" % host) except Exception: LOG.exception(_LE("Failed to construct notifier")) _notifier = False return _notifier
def setup_notifications(): global NOTIFICATION_TRANSPORT, NOTIFIER, MESSAGING_TRANSPORT if not cfg.CONF.oslo_messaging_notifications.enable: LOG.info(_LI("Notifications disabled")) return try: NOTIFICATION_TRANSPORT = messaging.get_notification_transport( cfg.CONF, aliases=_ALIASES) except Exception: LOG.error(_LE("Unable to setup notification transport. Reusing " "service transport for that.")) setup_service_messaging() NOTIFICATION_TRANSPORT = MESSAGING_TRANSPORT serializer = ContextSerializer(JsonPayloadSerializer()) NOTIFIER = messaging.Notifier( NOTIFICATION_TRANSPORT, serializer=serializer) LOG.info(_LI("Notifications enabled"))
def init(conf): global TRANSPORT, NOTIFICATION_TRANSPORT global SENSORS_NOTIFIER, VERSIONED_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()) SENSORS_NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer) if conf.notification_level is None: VERSIONED_NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer, driver='noop') else: VERSIONED_NOTIFIER = messaging.Notifier(NOTIFICATION_TRANSPORT, serializer=serializer, topics=['ironic_versioned_' 'notifications'])
def setup(conf, binary, host): if conf.profiler.enabled: # Note(wangxiyuan): OSprofiler now support some kind of backends, such # as Ceilometer, ElasticSearch, Messaging and MongoDB. # 1. Ceilometer is only used for data collection, and Messaging is only # used for data transfer. So Ceilometer only works when Messaging is # enabled. # 2. ElasticSearch and MongoDB support both data collection and # transfer. So they can be used standalone. # 3. Choose which backend depends on the config option # "connection_string" , and the default value is "messaging://". backend_uri = conf.profiler.connection_string if "://" not in backend_uri: backend_uri += "://" parsed_connection = urlparse.urlparse(backend_uri) backend_type = parsed_connection.scheme if backend_type == "messaging": import oslo_messaging _notifier = notifier.create( backend_uri, oslo_messaging, {}, oslo_messaging.get_notification_transport(conf), "Zaqar", binary, host) else: _notifier = notifier.create(backend_uri, project="Zaqar", service=binary, host=host) notifier.set(_notifier) LOG.warning("OSProfiler is enabled.\nIt means that person who " "knows any of hmac_keys that are specified in " "/etc/zaqar/zaqar.conf can trace his requests. \n In " "real life only operator can read this file so there " "is no security issue. Note that even if person can " "trigger profiler, only admin user can retrieve trace " "information.\n" "To disable OSprofiler set in zaqar.conf:\n" "[profiler]\nenabled=false") web.enable(conf.profiler.hmac_keys) else: web.disable()
def test_notifier(self, mock_utcnow): self.config(driver=['log'], group='oslo_messaging_notifications') transport = oslo_messaging.get_notification_transport(self.conf, url='fake:') notifier = oslo_messaging.Notifier(transport, 'test.localhost') message_id = uuid.uuid4() uuid.uuid4 = mock.Mock() uuid.uuid4.return_value = message_id mock_utcnow.return_value = datetime.datetime.utcnow() logger = mock.Mock() message = { 'message_id': str(message_id), 'publisher_id': 'test.localhost', 'event_type': 'test.notify', 'priority': 'INFO', 'payload': 'bar', 'timestamp': str(timeutils.utcnow()), } with mock.patch.object(logging, 'getLogger') as gl: gl.return_value = logger notifier.info({}, 'test.notify', 'bar') uuid.uuid4.assert_called_once_with() logging.getLogger.assert_called_once_with( 'oslo.messaging.notification.test.notify') logger.info.assert_called_once_with(JsonMessageMatcher(message)) self.assertTrue(notifier.is_enabled())
def main(): if len(sys.argv) < 2: print("Supply an exchange") sys.exit(0) exchange = sys.argv[1] pool = sys.argv[2] if len(sys.argv) > 2 else None transport = oslo_messaging.get_notification_transport( cfg.CONF, url='rabbit://%s:%s@%s' % (username, password, host)) targets = [oslo_messaging.Target(topic=topic, exchange=exchange)] endpoints = [EP()] oslo_listener = oslo_messaging.get_notification_listener( transport, targets, endpoints, pool=pool, executor='threading') try: print("Started") oslo_listener.start() while True: time.sleep(1) except KeyboardInterrupt: print("Stopping") oslo_listener.stop() oslo_listener.wait()
def get_transport(): return oslo_messaging.get_notification_transport(CONF)