def __init__(self):
super(EventsNotificationEndpoint, self).__init__()
self.dispatcher_manager = dispatcher.load_dispatcher_manager()
LOG.debug(_('Loading event definitions'))
self.event_converter = event_converter.setup_events(
extension.ExtensionManager(
namespace='ceilometer.event.trait_plugin'))
def start(self):
"""Bind the UDP socket and handle incoming data."""
# ensure dispatcher is configured before starting other services
self.dispatcher_manager = dispatcher.load_dispatcher_manager()
self.rpc_server = None
self.notification_server = None
super(CollectorService, self).start()
if cfg.CONF.collector.udp_address:
self.tg.add_thread(self.start_udp)
allow_requeue = cfg.CONF.collector.requeue_sample_on_dispatcher_error
transport = messaging.get_transport(optional=True)
if transport:
self.rpc_server = messaging.get_rpc_server(
transport, cfg.CONF.publisher_rpc.metering_topic, self)
target = oslo.messaging.Target(
topic=cfg.CONF.publisher_notifier.metering_topic)
self.notification_server = messaging.get_notification_listener(
transport, [target], [self],
allow_requeue=allow_requeue)
self.rpc_server.start()
self.notification_server.start()
if not cfg.CONF.collector.udp_address:
# Add a dummy thread to have wait() working
self.tg.add_timer(604800, lambda: None)
def test_record_metering_data(self):
mock_dispatcher = self._setup_fake_dispatcher()
dps = dispatcher.load_dispatcher_manager()
(self.srv.meter_manager, self.srv.manager) = dps
self.srv.record_metering_data(None, self.counter)
mock_dispatcher.record_metering_data.assert_called_once_with(
data=self.counter)
def __init__(self):
super(EventsNotificationEndpoint, self).__init__()
self.dispatcher_manager = dispatcher.load_dispatcher_manager()
LOG.debug(_('Loading event definitions'))
self.event_converter = event_converter.setup_events(
extension.ExtensionManager(
namespace='ceilometer.event.trait_plugin'))
def test_record_metering_data(self):
mock_dispatcher = self._setup_fake_dispatcher()
dps = dispatcher.load_dispatcher_manager()
(self.srv.meter_manager, self.srv.manager) = dps
self.srv.record_metering_data(None, self.counter)
mock_dispatcher.record_metering_data.assert_called_once_with(
data=self.counter)
def __init__(self, worker_id, conf):
super(CollectorService, self).__init__(worker_id)
self.conf = conf
# ensure dispatcher is configured before starting other services
dispatcher_managers = dispatcher.load_dispatcher_manager(conf)
(self.meter_manager, self.event_manager) = dispatcher_managers
self.sample_listener = None
self.event_listener = None
self.udp_thread = None
def __init__(self, worker_id, conf):
super(CollectorService, self).__init__(worker_id)
self.conf = conf
# ensure dispatcher is configured before starting other services
dispatcher_managers = dispatcher.load_dispatcher_manager(conf)
(self.meter_manager, self.event_manager) = dispatcher_managers
self.sample_listener = None
self.event_listener = None
self.udp_thread = None
def _test_collector_requeue(self, listener):
mock_dispatcher = self._setup_fake_dispatcher()
self.srv.dispatcher_manager = dispatcher.load_dispatcher_manager()
mock_dispatcher.record_metering_data.side_effect = Exception('boom')
mock_dispatcher.record_events.side_effect = Exception('boom')
self.srv.start()
endp = getattr(self.srv, listener).dispatcher.endpoints[0]
ret = endp.sample({}, 'pub_id', 'event', {}, {})
self.assertEqual(oslo_messaging.NotificationResult.REQUEUE, ret)
def _test_collector_no_requeue(self, listener):
mock_dispatcher = self._setup_fake_dispatcher()
self.srv.dispatcher_manager = dispatcher.load_dispatcher_manager()
mock_dispatcher.record_metering_data.side_effect = (
FakeException('boom'))
mock_dispatcher.record_events.side_effect = (FakeException('boom'))
self.srv.start()
endp = getattr(self.srv, listener).dispatcher.endpoints[0]
self.assertRaises(FakeException, endp.sample, {}, 'pub_id', 'event',
{}, {})
def _test_collector_no_requeue(self, listener):
mock_dispatcher = self._setup_fake_dispatcher()
self.srv.dispatcher_manager = dispatcher.load_dispatcher_manager()
mock_dispatcher.record_metering_data.side_effect = (FakeException
('boom'))
mock_dispatcher.record_events.side_effect = (FakeException
('boom'))
self.srv.start()
endp = getattr(self.srv, listener).dispatcher.endpoints[0]
self.assertRaises(FakeException, endp.sample, {}, 'pub_id',
'event', {}, {})
def _test_collector_requeue(self, listener):
mock_dispatcher = self._setup_fake_dispatcher()
self.srv.dispatcher_manager = dispatcher.load_dispatcher_manager()
mock_dispatcher.record_metering_data.side_effect = Exception('boom')
mock_dispatcher.record_events.side_effect = Exception('boom')
self.srv.start()
endp = getattr(self.srv, listener).dispatcher.endpoints[0]
ret = endp.sample({}, 'pub_id', 'event', {}, {})
self.assertEqual(oslo_messaging.NotificationResult.REQUEUE,
ret)
def _test_collector_no_requeue(self, listener):
mock_dispatcher = self._setup_fake_dispatcher()
self.srv.dispatcher_manager = dispatcher.load_dispatcher_manager()
mock_dispatcher.record_metering_data.side_effect = FakeException("boom")
mock_dispatcher.record_events.side_effect = FakeException("boom")
self.srv.start()
endp = getattr(self.srv, listener).dispatcher.endpoints[0]
self.assertRaises(
FakeException,
endp.sample,
[{"ctxt": {}, "publisher_id": "pub_id", "event_type": "event", "payload": {}, "metadata": {}}],
)
def _test_collector_requeue(self, listener, batch_listener=False):
mock_dispatcher = self._setup_fake_dispatcher()
self.srv.dispatcher_manager = dispatcher.load_dispatcher_manager()
mock_dispatcher.record_metering_data.side_effect = Exception("boom")
mock_dispatcher.record_events.side_effect = Exception("boom")
self.srv.start()
endp = getattr(self.srv, listener).dispatcher.endpoints[0]
ret = endp.sample(
[{"ctxt": {}, "publisher_id": "pub_id", "event_type": "event", "payload": {}, "metadata": {}}]
)
self.assertEqual(oslo_messaging.NotificationResult.REQUEUE, ret)
def test_sample_with_bad_signature(self, mocked_verify):
def _fake_verify(ev, secret):
return ev.get('message_signature') != 'bad_signature'
mocked_verify.side_effect = _fake_verify
sample = {"payload": [{"message_signature": "bad_signature"}]}
manager = dispatcher.load_dispatcher_manager(self.conf)[1]
v = collector.EventEndpoint("secret", manager)
v.sample([sample])
self.assertEqual([], manager['file'].obj.events)
del sample['payload'][0]['message_signature']
sample['payload'][0]['message_signature'] = utils.compute_signature(
sample['payload'][0], "secret")
v.sample([sample])
self.assertEqual(sample['payload'], manager['file'].obj.events)
def test_sample_with_bad_signature(self, mocked_verify):
def _fake_verify(ev, secret):
return ev.get('message_signature') != 'bad_signature'
mocked_verify.side_effect = _fake_verify
sample = {"payload": [{"message_signature": "bad_signature"}]}
manager = dispatcher.load_dispatcher_manager()[0]
v = collector.EventEndpoint("secret", manager)
v.sample([sample])
self.assertEqual([], manager['database'].obj.events)
del sample['payload'][0]['message_signature']
sample['payload'][0]['message_signature'] = utils.compute_signature(
sample['payload'][0], "secret")
v.sample([sample])
self.assertEqual(sample['payload'], manager['database'].obj.events)
def __init__(self, worker_id, conf):
super(CollectorService, self).__init__(worker_id)
self.conf = conf
# ensure dispatcher is configured before starting other services
dispatcher_managers = dispatcher.load_dispatcher_manager(conf)
(self.meter_manager, self.event_manager) = dispatcher_managers
self.sample_listener = None
self.event_listener = None
self.udp_thread = None
import debtcollector
debtcollector.deprecate("Ceilometer collector service is deprecated."
"Use publishers to push data instead",
version="9.0", removal_version="10.0")
def _test_collector_requeue(self, listener, batch_listener=False):
self.srv.dispatcher_manager = dispatcher.load_dispatcher_manager()
mock_record = self.mock_dispatcher.record_metering_data
mock_record.side_effect = Exception('boom')
self.mock_dispatcher.record_events.side_effect = Exception('boom')
self.srv.run()
self.addCleanup(self.srv.terminate)
endp = getattr(self.srv, listener).dispatcher.endpoints[0]
ret = endp.sample([{'ctxt': {}, 'publisher_id': 'pub_id',
'event_type': 'event', 'payload': {},
'metadata': {}}])
self.assertEqual(oslo_messaging.NotificationResult.REQUEUE,
ret)
def _test_collector_requeue(self, listener, batch_listener=False):
self.srv.dispatcher_manager = dispatcher.load_dispatcher_manager()
mock_record = self.mock_dispatcher.record_metering_data
mock_record.side_effect = Exception('boom')
self.mock_dispatcher.record_events.side_effect = Exception('boom')
self.srv.run()
self.addCleanup(self.srv.terminate)
endp = getattr(self.srv, listener).dispatcher.endpoints[0]
ret = endp.sample([{'ctxt': {}, 'publisher_id': 'pub_id',
'event_type': 'event', 'payload': {},
'metadata': {}}])
self.assertEqual(oslo_messaging.NotificationResult.REQUEUE,
ret)
def start(self):
"""Bind the UDP socket and handle incoming data."""
# ensure dispatcher is configured before starting other services
self.dispatcher_manager = dispatcher.load_dispatcher_manager()
super(CollectorService, self).start()
if cfg.CONF.collector.udp_address:
self.tg.add_thread(self.start_udp)
if self.rpc_enabled():
self.rpc_server = messaging.get_rpc_server(
cfg.CONF.publisher_rpc.metering_topic, self)
self.rpc_server.start()
if not cfg.CONF.collector.udp_address:
# Add a dummy thread to have wait() working
self.tg.add_timer(604800, lambda: None)
def __init__(self, worker_id, conf):
super(CollectorService, self).__init__(worker_id)
self.conf = conf
# ensure dispatcher is configured before starting other services
dispatcher_managers = dispatcher.load_dispatcher_manager(conf)
(self.meter_manager, self.event_manager) = dispatcher_managers
self.sample_listener = None
self.event_listener = None
self.udp_thread = None
import debtcollector
debtcollector.deprecate(
"Ceilometer collector service is deprecated."
"Use publishers to push data instead",
version="9.0",
removal_version="10.0")
def start(self):
"""Bind the UDP socket and handle incoming data."""
# ensure dispatcher is configured before starting other services
dispatcher_managers = dispatcher.load_dispatcher_manager()
(self.meter_manager, self.event_manager) = dispatcher_managers
self.rpc_server = None
self.sample_listener = None
self.event_listener = None
super(CollectorService, self).start()
if cfg.CONF.collector.udp_address:
self.tg.add_thread(self.start_udp)
transport = messaging.get_transport(optional=True)
if transport:
if cfg.CONF.collector.enable_rpc:
LOG.warning('RPC collector is deprecated in favour of queues. '
'Please switch to notifier publisher.')
self.rpc_server = messaging.get_rpc_server(
transport, cfg.CONF.publisher_rpc.metering_topic, self)
if list(self.meter_manager):
sample_target = oslo_messaging.Target(
topic=cfg.CONF.publisher_notifier.metering_topic)
self.sample_listener = messaging.get_notification_listener(
transport, [sample_target],
[SampleEndpoint(self.meter_manager)],
allow_requeue=(cfg.CONF.collector.
requeue_sample_on_dispatcher_error))
self.sample_listener.start()
if cfg.CONF.notification.store_events and list(self.event_manager):
event_target = oslo_messaging.Target(
topic=cfg.CONF.publisher_notifier.event_topic)
self.event_listener = messaging.get_notification_listener(
transport, [event_target],
[EventEndpoint(self.event_manager)],
allow_requeue=(cfg.CONF.collector.
requeue_event_on_dispatcher_error))
self.event_listener.start()
if cfg.CONF.collector.enable_rpc:
self.rpc_server.start()
if not cfg.CONF.collector.udp_address:
# Add a dummy thread to have wait() working
self.tg.add_timer(604800, lambda: None)
def start(self):
"""Bind the UDP socket and handle incoming data."""
# ensure dispatcher is configured before starting other services
dispatcher_managers = dispatcher.load_dispatcher_manager()
(self.meter_manager, self.event_manager) = dispatcher_managers
self.sample_listener = None
self.event_listener = None
self.udp_thread = None
super(CollectorService, self).start()
if cfg.CONF.collector.udp_address:
self.udp_thread = threading.Thread(target=self.start_udp)
self.udp_thread.daemon = True
self.udp_thread.start()
transport = messaging.get_transport(optional=True)
if transport:
if list(self.meter_manager):
sample_target = oslo_messaging.Target(
topic=cfg.CONF.publisher_notifier.metering_topic)
self.sample_listener = (
messaging.get_batch_notification_listener(
transport, [sample_target],
[SampleEndpoint(self.meter_manager)],
allow_requeue=True,
batch_size=cfg.CONF.collector.batch_size,
batch_timeout=cfg.CONF.collector.batch_timeout))
self.sample_listener.start()
if cfg.CONF.notification.store_events and list(self.event_manager):
event_target = oslo_messaging.Target(
topic=cfg.CONF.publisher_notifier.event_topic)
self.event_listener = (
messaging.get_batch_notification_listener(
transport, [event_target],
[EventEndpoint(self.event_manager)],
allow_requeue=True,
batch_size=cfg.CONF.collector.batch_size,
batch_timeout=cfg.CONF.collector.batch_timeout))
self.event_listener.start()
if not cfg.CONF.collector.udp_address:
# NOTE(sileht): We have to drop oslo.service to remove this
# last eventlet thread
# Add a dummy thread to have wait() working
self.tg.add_timer(604800, lambda: None)
def start(self):
"""Bind the UDP socket and handle incoming data."""
# ensure dispatcher is configured before starting other services
self.dispatcher_manager = dispatcher.load_dispatcher_manager()
self.rpc_server = None
self.sample_listener = None
self.event_listener = None
super(CollectorService, self).start()
if cfg.CONF.collector.udp_address:
self.tg.add_thread(self.start_udp)
transport = messaging.get_transport(optional=True)
if transport:
if cfg.CONF.collector.enable_rpc:
LOG.warning('RPC collector is deprecated in favour of queues. '
'Please switch to notifier publisher.')
self.rpc_server = messaging.get_rpc_server(
transport, cfg.CONF.publisher_rpc.metering_topic, self)
sample_target = oslo_messaging.Target(
topic=cfg.CONF.publisher_notifier.metering_topic)
self.sample_listener = messaging.get_notification_listener(
transport, [sample_target],
[SampleEndpoint(self.dispatcher_manager)],
allow_requeue=(
cfg.CONF.collector.requeue_sample_on_dispatcher_error))
if cfg.CONF.notification.store_events:
event_target = oslo_messaging.Target(
topic=cfg.CONF.publisher_notifier.event_topic)
self.event_listener = messaging.get_notification_listener(
transport, [event_target],
[EventEndpoint(self.dispatcher_manager)],
allow_requeue=(
cfg.CONF.collector.requeue_event_on_dispatcher_error))
self.event_listener.start()
if cfg.CONF.collector.enable_rpc:
self.rpc_server.start()
self.sample_listener.start()
if not cfg.CONF.collector.udp_address:
# Add a dummy thread to have wait() working
self.tg.add_timer(604800, lambda: None)
def run(self):
"""Bind the UDP socket and handle incoming data."""
super(CollectorService, self).run()
# ensure dispatcher is configured before starting other services
dispatcher_managers = dispatcher.load_dispatcher_manager()
(self.meter_manager, self.event_manager) = dispatcher_managers
self.sample_listener = None
self.event_listener = None
self.udp_thread = None
if cfg.CONF.collector.udp_address:
self.udp_thread = utils.spawn_thread(self.start_udp)
transport = messaging.get_transport(optional=True)
if transport:
if list(self.meter_manager):
sample_target = oslo_messaging.Target(
topic=cfg.CONF.publisher_notifier.metering_topic)
self.sample_listener = (
messaging.get_batch_notification_listener(
transport, [sample_target], [
SampleEndpoint(cfg.CONF.publisher.telemetry_secret,
self.meter_manager)
],
allow_requeue=True,
batch_size=cfg.CONF.collector.batch_size,
batch_timeout=cfg.CONF.collector.batch_timeout))
self.sample_listener.start()
if cfg.CONF.notification.store_events and list(self.event_manager):
event_target = oslo_messaging.Target(
topic=cfg.CONF.publisher_notifier.event_topic)
self.event_listener = (
messaging.get_batch_notification_listener(
transport, [event_target], [
EventEndpoint(cfg.CONF.publisher.telemetry_secret,
self.event_manager)
],
allow_requeue=True,
batch_size=cfg.CONF.collector.batch_size,
batch_timeout=cfg.CONF.collector.batch_timeout))
self.event_listener.start()
def start(self):
self.dispatcher_manager = dispatcher.load_dispatcher_manager()
self.notification_server = None
super(ConsumerService, self).start()
allow_requeue = cfg.CONF.consumer.requeue_on_error
transport = messaging.get_transport(optional=True)
if transport:
self.rpc_server = messaging.get_rpc_server(
transport, cfg.CONF.consumer.topic, self)
target = oslo.messaging.Target(
topic=cfg.CONF.consumer.topic)
self.notification_server = messaging.get_notification_listener(
transport, [target],
[ConsumerEndpoint(self.dispatcher_manager,
'record_metering_data',
cfg.CONF.consumer.priority)],
allow_requeue=allow_requeue)
self.notification_server.start()
def start(self):
"""Bind the UDP socket and handle incoming data."""
# ensure dispatcher is configured before starting other services
dispatcher_managers = dispatcher.load_dispatcher_manager()
(self.meter_manager, self.event_manager) = dispatcher_managers
self.sample_listener = None
self.event_listener = None
self.udp_thread = None
super(CollectorService, self).start()
if cfg.CONF.collector.udp_address:
self.udp_thread = utils.spawn_thread(self.start_udp)
transport = messaging.get_transport(optional=True)
if transport:
if list(self.meter_manager):
sample_target = oslo_messaging.Target(
topic=cfg.CONF.publisher_notifier.metering_topic)
self.sample_listener = (
messaging.get_batch_notification_listener(
transport, [sample_target],
[SampleEndpoint(cfg.CONF.publisher.telemetry_secret,
self.meter_manager)],
allow_requeue=True,
batch_size=cfg.CONF.collector.batch_size,
batch_timeout=cfg.CONF.collector.batch_timeout))
self.sample_listener.start()
if cfg.CONF.notification.store_events and list(self.event_manager):
event_target = oslo_messaging.Target(
topic=cfg.CONF.publisher_notifier.event_topic)
self.event_listener = (
messaging.get_batch_notification_listener(
transport, [event_target],
[EventEndpoint(cfg.CONF.publisher.telemetry_secret,
self.event_manager)],
allow_requeue=True,
batch_size=cfg.CONF.collector.batch_size,
batch_timeout=cfg.CONF.collector.batch_timeout))
self.event_listener.start()
def start(self):
self.dispatcher_manager = dispatcher.load_dispatcher_manager()
self.notification_server = None
super(ConsumerService, self).start()
allow_requeue = cfg.CONF.consumer.requeue_on_error
transport = messaging.get_transport(optional=True)
if transport:
self.rpc_server = messaging.get_rpc_server(transport,
cfg.CONF.consumer.topic,
self)
target = oslo.messaging.Target(topic=cfg.CONF.consumer.topic)
self.notification_server = messaging.get_notification_listener(
transport, [target], [
ConsumerEndpoint(self.dispatcher_manager,
'record_metering_data',
cfg.CONF.consumer.priority)
],
allow_requeue=allow_requeue)
self.notification_server.start()
def start(self):
"""Bind the UDP socket and handle incoming data."""
# ensure dispatcher is configured before starting other services
dispatcher_managers = dispatcher.load_dispatcher_manager()
(self.meter_manager, self.event_manager) = dispatcher_managers
self.sample_listener = None
self.event_listener = None
super(CollectorService, self).start()
if cfg.CONF.collector.udp_address:
self.tg.add_thread(self.start_udp)
transport = messaging.get_transport(optional=True)
if transport:
if list(self.meter_manager):
sample_target = oslo_messaging.Target(
topic=cfg.CONF.publisher_notifier.metering_topic)
self.sample_listener = messaging.get_notification_listener(
transport, [sample_target],
[SampleEndpoint(self.meter_manager)],
allow_requeue=(
cfg.CONF.collector.requeue_sample_on_dispatcher_error))
self.sample_listener.start()
if cfg.CONF.notification.store_events and list(self.event_manager):
event_target = oslo_messaging.Target(
topic=cfg.CONF.publisher_notifier.event_topic)
self.event_listener = messaging.get_notification_listener(
transport, [event_target],
[EventEndpoint(self.event_manager)],
allow_requeue=(
cfg.CONF.collector.requeue_event_on_dispatcher_error))
self.event_listener.start()
if not cfg.CONF.collector.udp_address:
# Add a dummy thread to have wait() working
self.tg.add_timer(604800, lambda: None)
def test_load(self):
sample_mg, event_mg = dispatcher.load_dispatcher_manager()
self.assertEqual(2, len(list(sample_mg)))
self.assertEqual(1, len(list(event_mg)))
def test_load(self):
sample_mg, event_mg = dispatcher.load_dispatcher_manager(self.CONF)
self.assertEqual(2, len(list(sample_mg)))
