From 89c5936c7c1fb6d172cd0eee9c5f9aa2cd5e2053 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Sun, 2 Aug 2015 16:50:47 -0400
Subject: sync with 2.0 trunk on reporting

---
 cloudinit/reporting/__init__.py | 100 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 100 insertions(+)
 create mode 100644 cloudinit/reporting/__init__.py

(limited to 'cloudinit/reporting/__init__.py')

diff --git a/cloudinit/reporting/__init__.py b/cloudinit/reporting/__init__.py
new file mode 100644
index 00000000..b0364eec
--- /dev/null
+++ b/cloudinit/reporting/__init__.py
@@ -0,0 +1,100 @@
+# Copyright 2015 Canonical Ltd.
+# This file is part of cloud-init.  See LICENCE file for license information.
+#
+# vi: ts=4 expandtab
+"""
+cloud-init reporting framework
+
+The reporting framework is intended to allow all parts of cloud-init to
+report events in a structured manner.
+"""
+
+from cloudinit.registry import DictRegistry
+from cloudinit.reporting.handlers import available_handlers
+
+
+FINISH_EVENT_TYPE = 'finish'
+START_EVENT_TYPE = 'start'
+
+DEFAULT_CONFIG = {
+    'logging': {'type': 'log'},
+}
+
+instantiated_handler_registry = 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)
+
+
+class FinishReportingEvent(ReportingEvent):
+
+    def __init__(self, name, description, successful=None):
+        super(FinishReportingEvent, self).__init__(
+            FINISH_EVENT_TYPE, name, description)
+        self.successful = successful
+
+    def as_string(self):
+        if self.successful is None:
+            return super(FinishReportingEvent, self).as_string()
+        success_string = 'success' if self.successful else 'fail'
+        return '{0}: {1}: {2}: {3}'.format(
+            self.event_type, self.name, success_string, self.description)
+
+
+def add_configuration(config):
+    for handler_name, handler_config in config.items():
+        handler_config = handler_config.copy()
+        cls = available_handlers.registered_items[handler_config.pop('type')]
+        instance = cls(**handler_config)
+        instantiated_handler_registry.register_item(handler_name, instance)
+
+
+def report_event(event):
+    """Report an event to all registered event handlers.
+
+    This should generally be called via one of the other functions in
+    the reporting module.
+
+    :param event_type:
+        The type of the event; this should be a constant from the
+        reporting module.
+    """
+    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)
+
+
+add_configuration(DEFAULT_CONFIG)
-- 
cgit v1.2.3


From 89c564a6fd5ac89869f83541370557e3fa58495c Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Sun, 2 Aug 2015 17:51:40 -0400
Subject: fix tests from sync change ReportStack to ReportEventStack change
 default ReportEventStack to be status.SUCCESS instead of None

---
 bin/cloud-init                    |  3 +-
 cloudinit/cloud.py                |  2 +-
 cloudinit/reporting/__init__.py   | 91 +++++++++++++++++++++++++++++++++++----
 cloudinit/reporting/handlers.py   |  7 +++
 cloudinit/sources/__init__.py     |  2 +-
 cloudinit/stages.py               | 10 ++---
 tests/unittests/test_reporting.py | 19 ++++----
 7 files changed, 109 insertions(+), 25 deletions(-)

(limited to 'cloudinit/reporting/__init__.py')

diff --git a/bin/cloud-init b/bin/cloud-init
index d369a806..51253c42 100755
--- a/bin/cloud-init
+++ b/bin/cloud-init
@@ -637,7 +637,8 @@ def main():
                         "running single module %s" % args.name)
         report_on = args.report
 
-    args.reporter = reporting.ReportStack(
+    reporting.add_configuration({'print': {'type': 'print'}})
+    args.reporter = reporting.ReportEventStack(
         rname, rdesc, reporting_enabled=report_on)
     with args.reporter:
         return util.log_time(
diff --git a/cloudinit/cloud.py b/cloudinit/cloud.py
index 71eb80eb..a0fb42a3 100644
--- a/cloudinit/cloud.py
+++ b/cloudinit/cloud.py
@@ -47,7 +47,7 @@ class Cloud(object):
         self._cfg = cfg
         self._runners = runners
         if reporter is None:
-            reporter = reporting.ReportStack(
+            reporter = reporting.ReportEventStack(
                 name="unnamed-cloud-reporter",
                 description="unnamed-cloud-reporter",
                 reporting_enabled=False)
diff --git a/cloudinit/reporting/__init__.py b/cloudinit/reporting/__init__.py
index b0364eec..78dde715 100644
--- a/cloudinit/reporting/__init__.py
+++ b/cloudinit/reporting/__init__.py
@@ -22,6 +22,15 @@ DEFAULT_CONFIG = {
 
 instantiated_handler_registry = DictRegistry()
 
+class _nameset(set):
+    def __getattr__(self, name):
+        if name in self:
+            return name
+        raise AttributeError("%s not a valid value" % name)
+
+
+status = _nameset(("SUCCESS", "WARN", "FAIL"))
+
 
 class ReportingEvent(object):
     """Encapsulation of event formatting."""
@@ -39,17 +48,16 @@ class ReportingEvent(object):
 
 class FinishReportingEvent(ReportingEvent):
 
-    def __init__(self, name, description, successful=None):
+    def __init__(self, name, description, result=status.SUCCESS):
         super(FinishReportingEvent, self).__init__(
             FINISH_EVENT_TYPE, name, description)
-        self.successful = successful
+        self.result = result
+        if result not in status:
+            raise ValueError("Invalid result: %s" % result)
 
     def as_string(self):
-        if self.successful is None:
-            return super(FinishReportingEvent, self).as_string()
-        success_string = 'success' if self.successful else 'fail'
         return '{0}: {1}: {2}: {3}'.format(
-            self.event_type, self.name, success_string, self.description)
+            self.event_type, self.name, self.result, self.description)
 
 
 def add_configuration(config):
@@ -74,12 +82,13 @@ def report_event(event):
         handler.publish_event(event)
 
 
-def report_finish_event(event_name, event_description, successful=None):
+def report_finish_event(event_name, event_description,
+                        result=status.SUCCESS):
     """Report a "finish" event.
 
     See :py:func:`.report_event` for parameter details.
     """
-    event = FinishReportingEvent(event_name, event_description, successful)
+    event = FinishReportingEvent(event_name, event_description, result)
     return report_event(event)
 
 
@@ -97,4 +106,70 @@ def report_start_event(event_name, event_description):
     return report_event(event)
 
 
+class ReportEventStack(object):
+    def __init__(self, name, description, message=None, parent=None,
+                 reporting_enabled=None, result_on_exception=status.FAIL):
+        self.parent = parent
+        self.name = name
+        self.description = description
+        self.message = message
+        self.result_on_exception = result_on_exception
+        self.result = status.SUCCESS
+
+        # use parents reporting value if not provided
+        if reporting_enabled is None:
+            if parent:
+                reporting_enabled = parent.reporting_enabled
+            else:
+                reporting_enabled = True
+        self.reporting_enabled = reporting_enabled
+
+        if parent:
+            self.fullname = '/'.join((parent.fullname, name,))
+        else:
+            self.fullname = self.name
+        self.children = {}
+
+    def __repr__(self):
+        return ("%s reporting=%s" % (self.fullname, self.reporting_enabled))
+
+    def __enter__(self):
+        self.result = status.SUCCESS
+        if self.reporting_enabled:
+            report_start_event(self.fullname, self.description)
+        if self.parent:
+            self.parent.children[self.name] = (None, None)
+        return self
+
+    def childrens_finish_info(self):
+        for cand_result in (status.FAIL, status.WARN):
+            for name, (value, msg) in self.children.items():
+                if value == cand_result:
+                    return (value, "[" + name + "]" + msg)
+        return (self.result, self.message)
+
+    @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)
+
+
 add_configuration(DEFAULT_CONFIG)
diff --git a/cloudinit/reporting/handlers.py b/cloudinit/reporting/handlers.py
index be323f53..1d5ca524 100644
--- a/cloudinit/reporting/handlers.py
+++ b/cloudinit/reporting/handlers.py
@@ -21,5 +21,12 @@ class LogHandler(ReportingHandler):
         logger.info(event.as_string())
 
 
+class StderrHandler(ReportingHandler):
+    def publish_event(self, event):
+        #sys.stderr.write(event.as_string() + "\n")
+        print(event.as_string())
+
+
 available_handlers = DictRegistry()
 available_handlers.register_item('log', LogHandler)
+available_handlers.register_item('print', StderrHandler)
diff --git a/cloudinit/sources/__init__.py b/cloudinit/sources/__init__.py
index 3b48f173..d07cf1fa 100644
--- a/cloudinit/sources/__init__.py
+++ b/cloudinit/sources/__init__.py
@@ -254,7 +254,7 @@ def find_source(sys_cfg, distro, paths, ds_deps, cfg_list, pkg_list, reporter):
     LOG.debug("Searching for %s data source in: %s", mode, ds_names)
 
     for name, cls in zip(ds_names, ds_list):
-        myrep = reporting.ReportStack(
+        myrep = reporting.ReportEventStack(
             name="search-%s-%s" % (mode, name.replace("DataSource", "")),
             description="searching for %s data from %s" % (mode, name),
             message = "no %s data found from %s" % (mode, name),
diff --git a/cloudinit/stages.py b/cloudinit/stages.py
index 8c79ae4e..42989bb4 100644
--- a/cloudinit/stages.py
+++ b/cloudinit/stages.py
@@ -67,7 +67,7 @@ class Init(object):
         self.datasource = NULL_DATA_SOURCE
 
         if reporter is None:
-            reporter = reporting.ReportStack(
+            reporter = reporting.ReportEventStack(
                 name="init-reporter", description="init-desc",
                 reporting_enabled=False)
         self.reporter = reporter
@@ -242,7 +242,7 @@ class Init(object):
         if self.datasource is not NULL_DATA_SOURCE:
             return self.datasource
 
-        with reporting.ReportStack(
+        with reporting.ReportEventStack(
             name="check-cache", description="attempting to read from cache",
             parent=self.reporter) as myrep:
                 ds = self._restore_from_cache()
@@ -508,11 +508,11 @@ class Init(object):
     def consume_data(self, frequency=PER_INSTANCE):
         # Consume the userdata first, because we need want to let the part
         # handlers run first (for merging stuff)
-        with reporting.ReportStack(
+        with reporting.ReportEventStack(
             "consume-user-data", "reading and applying user-data",
             parent=self.reporter):
                 self._consume_userdata(frequency)
-        with reporting.ReportStack(
+        with reporting.ReportEventStack(
             "consume-vendor-data", "reading and applying vendor-data",
             parent=self.reporter):
                 self._consume_userdata(frequency)
@@ -705,7 +705,7 @@ class Modules(object):
                 run_name = "config-%s" % (name)
 
                 desc="running %s with frequency %s" % (run_name, freq)
-                myrep = reporting.ReportStack(
+                myrep = reporting.ReportEventStack(
                     name=run_name, description=desc, parent=self.reporter)
 
                 with myrep:
diff --git a/tests/unittests/test_reporting.py b/tests/unittests/test_reporting.py
index 5700118f..4f4cf3a4 100644
--- a/tests/unittests/test_reporting.py
+++ b/tests/unittests/test_reporting.py
@@ -32,7 +32,7 @@ class TestReportStartEvent(TestCase):
 
 class TestReportFinishEvent(TestCase):
 
-    def _report_finish_event(self, result=None):
+    def _report_finish_event(self, result=reporting.status.SUCCESS):
         event_name, event_description = 'my_test_event', 'my description'
         reporting.report_finish_event(
             event_name, event_description, result=result)
@@ -95,31 +95,32 @@ class TestReportingHandler(TestCase):
 
     def test_no_default_publish_event_implementation(self):
         self.assertRaises(NotImplementedError,
-                          reporting.ReportingHandler().publish_event, None)
+                          reporting.handlers.ReportingHandler().publish_event,
+                          None)
 
 
 class TestLogHandler(TestCase):
 
-    @mock.patch.object(reporting.logging, 'getLogger')
+    @mock.patch.object(reporting.handlers.logging, 'getLogger')
     def test_appropriate_logger_used(self, getLogger):
         event_type, event_name = 'test_type', 'test_name'
         event = reporting.ReportingEvent(event_type, event_name, 'description')
-        reporting.LogHandler().publish_event(event)
+        reporting.handlers.LogHandler().publish_event(event)
         self.assertEqual(
             [mock.call(
                 'cloudinit.reporting.{0}.{1}'.format(event_type, event_name))],
             getLogger.call_args_list)
 
-    @mock.patch.object(reporting.logging, 'getLogger')
+    @mock.patch.object(reporting.handlers.logging, 'getLogger')
     def test_single_log_message_at_info_published(self, getLogger):
         event = reporting.ReportingEvent('type', 'name', 'description')
-        reporting.LogHandler().publish_event(event)
+        reporting.handlers.LogHandler().publish_event(event)
         self.assertEqual(1, getLogger.return_value.info.call_count)
 
-    @mock.patch.object(reporting.logging, 'getLogger')
+    @mock.patch.object(reporting.handlers.logging, 'getLogger')
     def test_log_message_uses_event_as_string(self, getLogger):
         event = reporting.ReportingEvent('type', 'name', 'description')
-        reporting.LogHandler().publish_event(event)
+        reporting.handlers.LogHandler().publish_event(event)
         self.assertIn(event.as_string(),
                       getLogger.return_value.info.call_args[0][0])
 
@@ -130,7 +131,7 @@ class TestDefaultRegisteredHandler(TestCase):
         registered_items = (
             reporting.instantiated_handler_registry.registered_items)
         for _, item in registered_items.items():
-            if isinstance(item, reporting.LogHandler):
+            if isinstance(item, reporting.handlers.LogHandler):
                 break
         else:
             self.fail('No reporting LogHandler registered by default.')
-- 
cgit v1.2.3


From 0550f95ccb31c9cad18c4a5851eeca53e371dd6b Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Tue, 4 Aug 2015 21:52:46 -0500
Subject: sync to 2.0 review @ patchset 4

---
 cloudinit/reporting/__init__.py | 56 +++++++++++++++++++++++++++++++++++------
 1 file changed, 49 insertions(+), 7 deletions(-)

(limited to 'cloudinit/reporting/__init__.py')

diff --git a/cloudinit/reporting/__init__.py b/cloudinit/reporting/__init__.py
index 78dde715..2b92ab58 100644
--- a/cloudinit/reporting/__init__.py
+++ b/cloudinit/reporting/__init__.py
@@ -22,6 +22,7 @@ DEFAULT_CONFIG = {
 
 instantiated_handler_registry = DictRegistry()
 
+
 class _nameset(set):
     def __getattr__(self, name):
         if name in self:
@@ -107,6 +108,36 @@ def report_start_event(event_name, event_description):
 
 
 class ReportEventStack(object):
+    """Context Manager for using :py:func:`report_event`
+
+    This enables calling :py:func:`report_start_event` and
+    :py:func:`report_finish_event` through a context manager.
+
+    :param name:
+        the name of the event
+
+    :param description:
+        the event's description, passed on to :py:func:`report_start_event`
+
+    :param message:
+        the description to use for the finish event. defaults to
+        :param:description.
+
+    :param parent:
+    :type parent: :py:class:ReportEventStack or None
+        The parent of this event.  The parent is populated with
+        results of all its children.  The name used in reporting
+        is <parent.name>/<name>
+
+    :param reporting_enabled:
+        Indicates if reporting events should be generated.
+        If not provided, defaults to the parent's value, or True if no parent
+        is provided.
+
+    :param result_on_exception:
+        The result value to set if an exception is caught. default
+        value is FAIL.
+    """
     def __init__(self, name, description, message=None, parent=None,
                  reporting_enabled=None, result_on_exception=status.FAIL):
         self.parent = parent
@@ -131,7 +162,8 @@ class ReportEventStack(object):
         self.children = {}
 
     def __repr__(self):
-        return ("%s reporting=%s" % (self.fullname, self.reporting_enabled))
+        return ("ReportEventStack(%s, %s, reporting_enabled=%s)" %
+                (self.name, self.description, self.reporting_enabled))
 
     def __enter__(self):
         self.result = status.SUCCESS
@@ -141,13 +173,23 @@ class ReportEventStack(object):
             self.parent.children[self.name] = (None, None)
         return self
 
-    def childrens_finish_info(self):
+    def _childrens_finish_info(self):
         for cand_result in (status.FAIL, status.WARN):
             for name, (value, msg) in self.children.items():
                 if value == cand_result:
-                    return (value, "[" + name + "]" + msg)
+                    return (value, self.message)
         return (self.result, self.message)
 
+    @property
+    def result(self):
+        return self._result
+
+    @result.setter
+    def result(self, value):
+        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:
@@ -157,15 +199,15 @@ class ReportEventStack(object):
     @message.setter
     def message(self, value):
         self._message = value
-       
-    def finish_info(self, exc):
+
+    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()
+        return self._childrens_finish_info()
 
     def __exit__(self, exc_type, exc_value, traceback):
-        (result, msg) = self.finish_info(exc_value)
+        (result, msg) = self._finish_info(exc_value)
         if self.parent:
             self.parent.children[self.name] = (result, msg)
         if self.reporting_enabled:
-- 
cgit v1.2.3


From 6fdb23b6cbc8de14ebcffc17e9e49342b7bf193d Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Thu, 6 Aug 2015 18:19:46 -0500
Subject: sync with cloudinit 2.0 for registry and reporting

---
 cloudinit/registry.py             | 14 +++++++++++
 cloudinit/reporting/__init__.py   | 29 +++++++++++++++++++---
 cloudinit/reporting/handlers.py   | 15 +++++++++++-
 tests/unittests/test_reporting.py | 51 ++++++++++++++++++++++++++++++++-------
 4 files changed, 95 insertions(+), 14 deletions(-)

(limited to 'cloudinit/reporting/__init__.py')

diff --git a/cloudinit/registry.py b/cloudinit/registry.py
index 46cf0585..04368ddf 100644
--- a/cloudinit/registry.py
+++ b/cloudinit/registry.py
@@ -1,3 +1,7 @@
+# Copyright 2015 Canonical Ltd.
+# This file is part of cloud-init.  See LICENCE file for license information.
+#
+# vi: ts=4 expandtab
 import copy
 
 
@@ -5,6 +9,9 @@ class DictRegistry(object):
     """A simple registry for a mapping of objects."""
 
     def __init__(self):
+        self.reset()
+
+    def reset(self):
         self._items = {}
 
     def register_item(self, key, item):
@@ -14,6 +21,13 @@ class DictRegistry(object):
                 'Item already registered with key {0}'.format(key))
         self._items[key] = item
 
+    def unregister_item(self, key, force=True):
+        """Remove item from the registry."""
+        if key in self._items:
+            del self._items[key]
+        elif not force:
+            raise KeyError("%s: key not present to unregister" % key)
+
     @property
     def registered_items(self):
         """All the items that have been registered.
diff --git a/cloudinit/reporting/__init__.py b/cloudinit/reporting/__init__.py
index 2b92ab58..d0bc14e3 100644
--- a/cloudinit/reporting/__init__.py
+++ b/cloudinit/reporting/__init__.py
@@ -20,8 +20,6 @@ DEFAULT_CONFIG = {
     'logging': {'type': 'log'},
 }
 
-instantiated_handler_registry = DictRegistry()
-
 
 class _nameset(set):
     def __getattr__(self, name):
@@ -46,6 +44,11 @@ class ReportingEvent(object):
         return '{0}: {1}: {2}'.format(
             self.event_type, self.name, self.description)
 
+    def as_dict(self):
+        """The event represented as a dictionary."""
+        return {'name': self.name, 'description': self.description,
+                'event_type': self.event_type}
+
 
 class FinishReportingEvent(ReportingEvent):
 
@@ -60,9 +63,26 @@ class FinishReportingEvent(ReportingEvent):
         return '{0}: {1}: {2}: {3}'.format(
             self.event_type, self.name, self.result, self.description)
 
+    def as_dict(self):
+        """The event represented as json friendly."""
+        data = super(FinishReportingEvent, self).as_dict()
+        data['result'] = self.result
+        return data
+
 
-def add_configuration(config):
+def update_configuration(config):
+    """Update the instanciated_handler_registry.
+
+    :param config:
+        The dictionary containing changes to apply.  If a key is given
+        with a False-ish value, the registered handler matching that name
+        will be unregistered.
+    """
     for handler_name, handler_config in config.items():
+        if not handler_config:
+            instantiated_handler_registry.unregister_item(
+                handler_name, force=True)
+            continue
         handler_config = handler_config.copy()
         cls = available_handlers.registered_items[handler_config.pop('type')]
         instance = cls(**handler_config)
@@ -214,4 +234,5 @@ class ReportEventStack(object):
             report_finish_event(self.fullname, msg, result)
 
 
-add_configuration(DEFAULT_CONFIG)
+instantiated_handler_registry = DictRegistry()
+update_configuration(DEFAULT_CONFIG)
diff --git a/cloudinit/reporting/handlers.py b/cloudinit/reporting/handlers.py
index be323f53..86cbe3c3 100644
--- a/cloudinit/reporting/handlers.py
+++ b/cloudinit/reporting/handlers.py
@@ -1,14 +1,27 @@
+# vi: ts=4 expandtab
+
 import abc
 import logging
+import oauthlib.oauth1 as oauth1
+
+import six
 
 from cloudinit.registry import DictRegistry
+from cloudinit import url_helper
+from cloudinit import util
 
 
+@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):
-        raise NotImplementedError
+        """Publish an event to the ``INFO`` log level."""
 
 
 class LogHandler(ReportingHandler):
diff --git a/tests/unittests/test_reporting.py b/tests/unittests/test_reporting.py
index ffeb55d2..1a4ee8c4 100644
--- a/tests/unittests/test_reporting.py
+++ b/tests/unittests/test_reporting.py
@@ -4,6 +4,7 @@
 # vi: ts=4 expandtab
 
 from cloudinit import reporting
+from cloudinit.reporting import handlers
 
 from .helpers import (mock, TestCase)
 
@@ -95,13 +96,29 @@ class TestReportingEvent(TestCase):
             [event_type, name, description])
         self.assertEqual(expected_string_representation, event.as_string())
 
+    def test_as_dict(self):
+        event_type, name, desc = 'test_type', 'test_name', 'test_desc'
+        event = reporting.ReportingEvent(event_type, name, desc)
+        self.assertEqual(
+            {'event_type': event_type, 'name': name, 'description': desc},
+            event.as_dict())
+
+
+class TestFinishReportingEvent(TestCase):
+    def test_as_has_result(self):
+        result = reporting.status.SUCCESS
+        name, desc = 'test_name', 'test_desc'
+        event = reporting.FinishReportingEvent(name, desc, result)
+        ret = event.as_dict()
+        self.assertTrue('result' in ret)
+        self.assertEqual(ret['result'], result)
+
 
-class TestReportingHandler(TestCase):
+class TestBaseReportingHandler(TestCase):
 
-    def test_no_default_publish_event_implementation(self):
-        self.assertRaises(NotImplementedError,
-                          reporting.handlers.ReportingHandler().publish_event,
-                          None)
+    def test_base_reporting_handler_is_abstract(self):
+        regexp = r".*abstract.*publish_event.*"
+        self.assertRaisesRegexp(TypeError, regexp, handlers.ReportingHandler)
 
 
 class TestLogHandler(TestCase):
@@ -147,7 +164,7 @@ class TestReportingConfiguration(TestCase):
     @mock.patch.object(reporting, 'instantiated_handler_registry')
     def test_empty_configuration_doesnt_add_handlers(
             self, instantiated_handler_registry):
-        reporting.add_configuration({})
+        reporting.update_configuration({})
         self.assertEqual(
             0, instantiated_handler_registry.register_item.call_count)
 
@@ -159,7 +176,7 @@ class TestReportingConfiguration(TestCase):
         handler_cls = mock.Mock()
         available_handlers.registered_items = {handler_type_name: handler_cls}
         handler_name = 'my_test_handler'
-        reporting.add_configuration(
+        reporting.update_configuration(
             {handler_name: {'type': handler_type_name}})
         self.assertEqual(
             {handler_name: handler_cls.return_value},
@@ -177,7 +194,7 @@ class TestReportingConfiguration(TestCase):
         handler_config = extra_kwargs.copy()
         handler_config.update({'type': handler_type_name})
         handler_name = 'my_test_handler'
-        reporting.add_configuration({handler_name: handler_config})
+        reporting.update_configuration({handler_name: handler_config})
         self.assertEqual(
             handler_cls.return_value,
             reporting.instantiated_handler_registry.registered_items[
@@ -194,9 +211,25 @@ class TestReportingConfiguration(TestCase):
         available_handlers.registered_items = {handler_type_name: handler_cls}
         handler_config = {'type': handler_type_name, 'foo': 'bar'}
         expected_handler_config = handler_config.copy()
-        reporting.add_configuration({'my_test_handler': handler_config})
+        reporting.update_configuration({'my_test_handler': handler_config})
         self.assertEqual(expected_handler_config, handler_config)
 
+    @mock.patch.object(
+        reporting, 'instantiated_handler_registry', reporting.DictRegistry())
+    @mock.patch.object(reporting, 'available_handlers')
+    def test_handlers_removed_if_falseish_specified(self, available_handlers):
+        handler_type_name = 'test_handler'
+        handler_cls = mock.Mock()
+        available_handlers.registered_items = {handler_type_name: handler_cls}
+        handler_name = 'my_test_handler'
+        reporting.update_configuration(
+            {handler_name: {'type': handler_type_name}})
+        self.assertEqual(
+            1, len(reporting.instantiated_handler_registry.registered_items))
+        reporting.update_configuration({handler_name: None})
+        self.assertEqual(
+            0, len(reporting.instantiated_handler_registry.registered_items))
+
 
 class TestReportingEventStack(TestCase):
     @mock.patch('cloudinit.reporting.report_finish_event')
-- 
cgit v1.2.3


From fc5fc6e476059327d4063f165170cdde01db4100 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Thu, 6 Aug 2015 23:51:17 -0500
Subject: add the webhook handler

---
 bin/cloud-init                  |  6 +++---
 cloudinit/reporting/__init__.py | 11 +++++++++--
 cloudinit/reporting/handlers.py | 15 +++++++++++----
 3 files changed, 23 insertions(+), 9 deletions(-)

(limited to 'cloudinit/reporting/__init__.py')

diff --git a/bin/cloud-init b/bin/cloud-init
index ad2e624a..86780408 100755
--- a/bin/cloud-init
+++ b/bin/cloud-init
@@ -138,8 +138,8 @@ def run_module_section(mods, action_name, section):
 
 
 def apply_reporting_cfg(cfg):
-    reporting.reset_configuration()
-    reporting.update_configuration(cfg.get('reporting'), {})
+    if cfg.get('reporting'):
+        reporting.update_configuration(cfg.get('reporting'))
 
 
 def main_init(name, args):
@@ -648,7 +648,7 @@ def main():
                         "running single module %s" % args.name)
         report_on = args.report
 
-    reporting.add_configuration({'print': {'type': 'print'}})
+    reporting.update_configuration({'print': {'type': 'print'}})
     args.reporter = reporting.ReportEventStack(
         rname, rdesc, reporting_enabled=report_on)
     with args.reporter:
diff --git a/cloudinit/reporting/__init__.py b/cloudinit/reporting/__init__.py
index d0bc14e3..b9d4f679 100644
--- a/cloudinit/reporting/__init__.py
+++ b/cloudinit/reporting/__init__.py
@@ -9,8 +9,8 @@ The reporting framework is intended to allow all parts of cloud-init to
 report events in a structured manner.
 """
 
-from cloudinit.registry import DictRegistry
-from cloudinit.reporting.handlers import available_handlers
+from ..registry import DictRegistry
+from ..reporting.handlers import available_handlers
 
 
 FINISH_EVENT_TYPE = 'finish'
@@ -18,6 +18,7 @@ START_EVENT_TYPE = 'start'
 
 DEFAULT_CONFIG = {
     'logging': {'type': 'log'},
+    'print': {'type': 'print'},
 }
 
 
@@ -83,8 +84,14 @@ def update_configuration(config):
             instantiated_handler_registry.unregister_item(
                 handler_name, force=True)
             continue
+        registered = instantiated_handler_registry.registered_items
         handler_config = handler_config.copy()
         cls = available_handlers.registered_items[handler_config.pop('type')]
+        if (handler_name in registered and
+                (registered[handler_name] == handler_config)):
+            continue
+        else:
+            instantiated_handler_registry.unregister_item(handler_name)
         instance = cls(**handler_config)
         instantiated_handler_registry.register_item(handler_name, instance)
 
diff --git a/cloudinit/reporting/handlers.py b/cloudinit/reporting/handlers.py
index d8f69641..a962edae 100644
--- a/cloudinit/reporting/handlers.py
+++ b/cloudinit/reporting/handlers.py
@@ -6,9 +6,8 @@ import oauthlib.oauth1 as oauth1
 
 import six
 
-from cloudinit.registry import DictRegistry
-from cloudinit import url_helper
-from cloudinit import util
+from ..registry import DictRegistry
+from .. import (url_helper, util)
 
 
 @six.add_metaclass(abc.ABCMeta)
@@ -34,13 +33,19 @@ class LogHandler(ReportingHandler):
         logger.info(event.as_string())
 
 
+class PrintHandler(ReportingHandler):
+    def publish_event(self, event):
+        """Publish an event to the ``INFO`` log level."""
+        print(event.as_string())
+
+
 class WebHookHandler(ReportingHandler):
     def __init__(self, endpoint, consumer_key=None, token_key=None,
                  token_secret=None, consumer_secret=None, timeout=None,
                  retries=None):
         super(WebHookHandler, self).__init__()
 
-        if any(consumer_key, token_key, token_secret, consumer_secret):
+        if any([consumer_key, token_key, token_secret, consumer_secret]):
             self.oauth_helper = url_helper.OauthHelper(
                 consumer_key=consumer_key, token_key=token_key,
                 token_secret=token_secret, consumer_secret=consumer_secret)
@@ -64,3 +69,5 @@ class WebHookHandler(ReportingHandler):
 
 available_handlers = DictRegistry()
 available_handlers.register_item('log', LogHandler)
+available_handlers.register_item('print', PrintHandler)
+available_handlers.register_item('webhook', WebHookHandler)
-- 
cgit v1.2.3


From 71c8fedcd581d8c4aa937d270f5bbd2e5af99e26 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Fri, 7 Aug 2015 10:20:34 -0500
Subject: undo broken logic that attempted to not re-initialize classes

---
 cloudinit/reporting/__init__.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'cloudinit/reporting/__init__.py')

diff --git a/cloudinit/reporting/__init__.py b/cloudinit/reporting/__init__.py
index b9d4f679..a3b8332f 100644
--- a/cloudinit/reporting/__init__.py
+++ b/cloudinit/reporting/__init__.py
@@ -87,11 +87,7 @@ def update_configuration(config):
         registered = instantiated_handler_registry.registered_items
         handler_config = handler_config.copy()
         cls = available_handlers.registered_items[handler_config.pop('type')]
-        if (handler_name in registered and
-                (registered[handler_name] == handler_config)):
-            continue
-        else:
-            instantiated_handler_registry.unregister_item(handler_name)
+        instantiated_handler_registry.unregister_item(handler_name)
         instance = cls(**handler_config)
         instantiated_handler_registry.register_item(handler_name, instance)
 
-- 
cgit v1.2.3


From 95bfe5d5150e2bf0a26dd1b97578c4fd04152365 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Fri, 7 Aug 2015 14:44:00 -0500
Subject: add doc, remove some debug / print statements.

---
 bin/cloud-init                          |  1 -
 cloudinit/reporting/__init__.py         |  1 -
 cloudinit/reporting/handlers.py         | 16 ++++++++++++++--
 doc/examples/cloud-config-reporting.txt | 17 +++++++++++++++++
 4 files changed, 31 insertions(+), 4 deletions(-)
 create mode 100644 doc/examples/cloud-config-reporting.txt

(limited to 'cloudinit/reporting/__init__.py')

diff --git a/bin/cloud-init b/bin/cloud-init
index 86780408..1f64461e 100755
--- a/bin/cloud-init
+++ b/bin/cloud-init
@@ -648,7 +648,6 @@ def main():
                         "running single module %s" % args.name)
         report_on = args.report
 
-    reporting.update_configuration({'print': {'type': 'print'}})
     args.reporter = reporting.ReportEventStack(
         rname, rdesc, reporting_enabled=report_on)
     with args.reporter:
diff --git a/cloudinit/reporting/__init__.py b/cloudinit/reporting/__init__.py
index a3b8332f..e23fab32 100644
--- a/cloudinit/reporting/__init__.py
+++ b/cloudinit/reporting/__init__.py
@@ -18,7 +18,6 @@ START_EVENT_TYPE = 'start'
 
 DEFAULT_CONFIG = {
     'logging': {'type': 'log'},
-    'print': {'type': 'print'},
 }
 
 
diff --git a/cloudinit/reporting/handlers.py b/cloudinit/reporting/handlers.py
index 9cf8bd2b..1343311f 100644
--- a/cloudinit/reporting/handlers.py
+++ b/cloudinit/reporting/handlers.py
@@ -28,17 +28,29 @@ class ReportingHandler(object):
 class LogHandler(ReportingHandler):
     """Publishes events to the cloud-init log at the ``INFO`` log level."""
 
+    def __init__(self, level="DEBUG"):
+        super(LogHandler, self).__init__()
+        if isinstance(level, int):
+            pass
+        else:
+            input_level = level
+            try:
+                level = gettattr(logging, level.upper())
+            except:
+                LOG.warn("invalid level '%s', using WARN", input_level)
+                level = logging.WARN
+        self.level = 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())
+        logger.log(self.level, event.as_string())
 
 
 class PrintHandler(ReportingHandler):
     def publish_event(self, event):
         """Publish an event to the ``INFO`` log level."""
-        print(event.as_string())
 
 
 class WebHookHandler(ReportingHandler):
diff --git a/doc/examples/cloud-config-reporting.txt b/doc/examples/cloud-config-reporting.txt
new file mode 100644
index 00000000..ee00078f
--- /dev/null
+++ b/doc/examples/cloud-config-reporting.txt
@@ -0,0 +1,17 @@
+#cloud-config
+##
+## The following sets up 2 reporting end points.
+## A 'webhook' and a 'log' type.
+## It also disables the built in default 'log'
+reporting:
+   smtest:
+     type: webhook
+     endpoint: "http://myhost:8000/"
+     consumer_key: "ckey_foo"
+     consumer_secret: "csecret_foo"
+     token_key: "tkey_foo"
+     token_secret: "tkey_foo"
+   smlogger:
+     type: log
+     level: WARN
+   log: null
-- 
cgit v1.2.3