def test_keys_cannot_be_replaced(self):
registry = DictRegistry()
item_key = 'test_key'
registry.register_item(item_key, mock.Mock())
self.assertRaises(ValueError, registry.register_item, item_key,
mock.Mock())
def test_added_item_included_in_output(self):
registry = DictRegistry()
item_key, item_to_register = 'test_key', mock.Mock()
registry.register_item(item_key, item_to_register)
self.assertEqual({item_key: item_to_register},
registry.registered_items)
def test_keys_cannot_be_replaced(self):
registry = DictRegistry()
item_key = 'test_key'
registry.register_item(item_key, mock.Mock())
self.assertRaises(ValueError,
registry.register_item, item_key, mock.Mock())
def test_added_item_included_in_output(self):
registry = DictRegistry()
item_key, item_to_register = 'test_key', mock.Mock()
registry.register_item(item_key, item_to_register)
self.assertEqual({item_key: item_to_register},
registry.registered_items)
consumer_key=consumer_key,
token_key=token_key,
token_secret=token_secret,
consumer_secret=consumer_secret)
else:
self.oauth_helper = None
self.endpoint = endpoint
self.timeout = timeout
self.retries = retries
self.ssl_details = util.fetch_ssl_details()
def publish_event(self, event):
if self.oauth_helper:
readurl = self.oauth_helper.readurl
else:
readurl = url_helper.readurl
try:
return readurl(self.endpoint,
data=json.dumps(event.as_dict()),
timeout=self.timeout,
retries=self.retries,
ssl_details=self.ssl_details)
except Exception:
LOG.warn("failed posting event: %s" % event.as_string())
available_handlers = DictRegistry()
available_handlers.register_item('log', LogHandler)
available_handlers.register_item('print', PrintHandler)
available_handlers.register_item('webhook', WebHookHandler)
self._append_kvp_item(encoded_data)
except (OSError, IOError) as e:
LOG.warning("failed posting events to kvp, %s", e)
finally:
for _ in range(items_from_queue):
self.q.task_done()
# when main process exits, q.get() will through EOFError
# indicating we should exit this thread.
except EOFError:
return
# since the saving to the kvp pool can be a time costing task
# if the kvp pool already contains a chunk of data,
# so defer it to another thread.
def publish_event(self, event):
if not self._event_types or event.event_type in self._event_types:
self.q.put(event)
def flush(self):
LOG.debug('HyperVReportingHandler flushing remaining events')
self.q.join()
available_handlers = DictRegistry()
available_handlers.register_item('log', LogHandler)
available_handlers.register_item('print', PrintHandler)
available_handlers.register_item('webhook', WebHookHandler)
available_handlers.register_item('hyperv', HyperVKvpReportingHandler)
# vi: ts=4 expandtab
if any([consumer_key, token_key, token_secret, consumer_secret]):
self.oauth_helper = url_helper.OauthUrlHelper(
consumer_key=consumer_key, token_key=token_key,
token_secret=token_secret, consumer_secret=consumer_secret)
else:
self.oauth_helper = None
self.endpoint = endpoint
self.timeout = timeout
self.retries = retries
self.ssl_details = util.fetch_ssl_details()
def publish_event(self, event):
if self.oauth_helper:
readurl = self.oauth_helper.readurl
else:
readurl = url_helper.readurl
try:
return readurl(
self.endpoint, data=json.dumps(event.as_dict()),
timeout=self.timeout,
retries=self.retries, ssl_details=self.ssl_details)
except Exception:
LOG.warn("failed posting event: %s" % event.as_string())
available_handlers = DictRegistry()
available_handlers.register_item('log', LogHandler)
available_handlers.register_item('print', PrintHandler)
available_handlers.register_item('webhook', WebHookHandler)
import logging
import six
from cloudinit.registry import DictRegistry
@six.add_metaclass(abc.ABCMeta)
class ReportingHandler(object):
"""Base class for report handlers.
Implement :meth:`~publish_event` for controlling what
the handler does with an event.
"""
@abc.abstractmethod
def publish_event(self, event):
"""Publish an event to the ``INFO`` log level."""
class LogHandler(ReportingHandler):
"""Publishes events to the cloud-init log at the ``INFO`` log level."""
def publish_event(self, event):
"""Publish an event to the ``INFO`` log level."""
logger = logging.getLogger('.'.join(
['cloudinit', 'reporting', event.event_type, event.name]))
logger.info(event.as_string())
available_handlers = DictRegistry()
available_handlers.register_item('log', LogHandler)
except EOFError:
return
# since the saving to the kvp pool can be a time costing task
# if the kvp pool already contains a chunk of data,
# so defer it to another thread.
def publish_event(self, event):
if not self._event_types or event.event_type in self._event_types:
self.q.put(event)
def flush(self):
LOG.debug("HyperVReportingHandler flushing remaining events")
self.q.join()
# Type[ReportingHandler] doesn't work here because each class has different
# call args. Protocols in python 3.8 can probably make this simpler.
HandlerType = Union[
ReportingHandler,
LogHandler,
PrintHandler,
WebHookHandler,
HyperVKvpReportingHandler,
]
available_handlers = DictRegistry()
available_handlers.register_item("log", LogHandler)
available_handlers.register_item("print", PrintHandler)
available_handlers.register_item("webhook", WebHookHandler)
available_handlers.register_item("hyperv", HyperVKvpReportingHandler)
"""
for _, handler in instantiated_handler_registry.registered_items.items():
handler.publish_event(event)
def report_finish_event(event_name, event_description, successful=None):
"""Report a "finish" event.
See :py:func:`.report_event` for parameter details.
"""
event = FinishReportingEvent(event_name, event_description, successful)
return report_event(event)
def report_start_event(event_name, event_description):
"""Report a "start" event.
:param event_name:
The name of the event; this should be a topic which events would
share (e.g. it will be the same for start and finish events).
:param event_description:
A human-readable description of the event that has occurred.
"""
event = ReportingEvent(START_EVENT_TYPE, event_name, event_description)
return report_event(event)
available_handlers.register_item('log', LogHandler)
add_configuration(DEFAULT_CONFIG)
self._append_kvp_item(encoded_data)
except (OSError, IOError) as e:
LOG.warning("failed posting events to kvp, %s", e)
finally:
for _ in range(items_from_queue):
self.q.task_done()
# when main process exits, q.get() will through EOFError
# indicating we should exit this thread.
except EOFError:
return
# since the saving to the kvp pool can be a time costing task
# if the kvp pool already contains a chunk of data,
# so defer it to another thread.
def publish_event(self, event):
if not self._event_types or event.event_type in self._event_types:
self.q.put(event)
def flush(self):
LOG.debug('HyperVReportingHandler flushing remaining events')
self.q.join()
available_handlers = DictRegistry()
available_handlers.register_item('log', LogHandler)
available_handlers.register_item('print', PrintHandler)
available_handlers.register_item('webhook', WebHookHandler)
available_handlers.register_item('hyperv', HyperVKvpReportingHandler)
# vi: ts=4 expandtab
