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_modifying_registered_items_isnt_exposed_to_other_callers(self):
registry = DictRegistry()
registry.registered_items['test_item'] = mock.Mock()
self.assertEqual({}, 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)
def test_registry_starts_out_empty(self):
self.assertEqual({}, DictRegistry().registered_items)
def test_modifying_registered_items_isnt_exposed_to_other_callers(self):
registry = DictRegistry()
registry.registered_items['test_item'] = mock.Mock()
self.assertEqual({}, 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())
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)
if value not in status:
raise ValueError("'%s' not a valid result" % value)
self._result = value
@property
def message(self):
if self._message is not None:
return self._message
return self.description
@message.setter
def message(self, value):
self._message = value
def _finish_info(self, exc):
# return tuple of description, and value
if exc:
return (self.result_on_exception, self.message)
return self._childrens_finish_info()
def __exit__(self, exc_type, exc_value, traceback):
(result, msg) = self._finish_info(exc_value)
if self.parent:
self.parent.children[self.name] = (result, msg)
if self.reporting_enabled:
report_finish_event(self.fullname, msg, result)
instantiated_handler_registry = DictRegistry()
update_configuration(DEFAULT_CONFIG)
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)
import abc
import logging
from cloudinit.registry import DictRegistry
FINISH_EVENT_TYPE = 'finish'
START_EVENT_TYPE = 'start'
DEFAULT_CONFIG = {
'logging': {
'type': 'log'
},
}
instantiated_handler_registry = DictRegistry()
available_handlers = DictRegistry()
class ReportingEvent(object):
"""Encapsulation of event formatting."""
def __init__(self, event_type, name, description):
self.event_type = event_type
self.name = name
self.description = description
def as_string(self):
"""The event represented as a string."""
return '{0}: {1}: {2}'.format(self.event_type, self.name,
self.description)
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)
import abc
import logging
from cloudinit.registry import DictRegistry
FINISH_EVENT_TYPE = 'finish'
START_EVENT_TYPE = 'start'
DEFAULT_CONFIG = {
'logging': {'type': 'log'},
}
instantiated_handler_registry = DictRegistry()
available_handlers = DictRegistry()
class ReportingEvent(object):
"""Encapsulation of event formatting."""
def __init__(self, event_type, name, description):
self.event_type = event_type
self.name = name
self.description = description
def as_string(self):
"""The event represented as a string."""
return '{0}: {1}: {2}'.format(
self.event_type, self.name, self.description)
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
