=== modified file 'bin/cloud-init'
--- bin/cloud-init	2015-08-05 03:01:27 +0000
+++ bin/cloud-init	2015-08-05 04:00:44 +0000
@@ -191,6 +191,8 @@
                     " longer be active shortly"))
         logging.resetLogging()
     logging.setupLogging(init.cfg)
+    reporting.update_configuration(
+        init.cfg.get('reporting', reporting.DEFAULT_CONFIG))
 
     # Any log usage prior to setupLogging above did not have local user log
     # config applied.  We send the welcome message now, as stderr/out have
@@ -283,6 +285,9 @@
         util.logexc(LOG, "Consuming user data failed!")
         return (init.datasource, ["Consuming user data failed!"])
 
+    reporting.update_configuration(
+        init.cfg.get('reporting', reporting.DEFAULT_CONFIG))
+
     # Stage 8 - re-read and apply relevant cloud-config to include user-data
     mods = stages.Modules(init, extract_fns(args), reporter=args.reporter)
     # Stage 9
@@ -343,6 +348,8 @@
                     " longer be active shortly"))
         logging.resetLogging()
     logging.setupLogging(mods.cfg)
+    reporting.update_configuration(
+        init.cfg.get('reporting', reporting.DEFAULT_CONFIG))
 
     # now that logging is setup and stdout redirected, send welcome
     welcome(name, msg=w_msg)
@@ -405,6 +412,8 @@
                    " longer be active shortly"))
         logging.resetLogging()
     logging.setupLogging(mods.cfg)
+    reporting.update_configuration(
+        init.cfg.get('reporting', reporting.DEFAULT_CONFIG))
 
     # now that logging is setup and stdout redirected, send welcome
     welcome(name, msg=w_msg)

=== modified file 'cloudinit/registry.py'
--- cloudinit/registry.py	2015-07-28 20:15:10 +0000
+++ cloudinit/registry.py	2015-08-05 03:24:25 +0000
@@ -14,6 +14,13 @@
                 'Item already registered with key {0}'.format(key))
         self._items[key] = item
 
+    def unregister_item(self, key, force=True):
+        """Add item to 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.

=== modified file 'cloudinit/reporting/__init__.py'
--- cloudinit/reporting/__init__.py	2015-08-05 02:52:46 +0000
+++ cloudinit/reporting/__init__.py	2015-08-05 13:55:03 +0000
@@ -46,6 +46,11 @@
         return '{0}: {1}: {2}'.format(
             self.event_type, self.name, self.description)
 
+    def as_json_data(self):
+        """The event represented as json friendly."""
+        return {'name': self.name, 'description': self.description,
+                'event_type': self.event_type}
+
 
 class FinishReportingEvent(ReportingEvent):
 
@@ -60,9 +65,18 @@
         return '{0}: {1}: {2}: {3}'.format(
             self.event_type, self.name, self.result, self.description)
 
+    def as_json_data(self):
+        """The event represented as json friendly."""
+        data = super(FinishReportingEvent, self).as_json_data()
+        data['result'] = self.result
+        return data
 
-def add_configuration(config):
+def update_configuration(config):
     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 +228,4 @@
             report_finish_event(self.fullname, msg, result)
 
 
-add_configuration(DEFAULT_CONFIG)
+update_configuration(DEFAULT_CONFIG)

=== modified file 'cloudinit/reporting/handlers.py'
--- cloudinit/reporting/handlers.py	2015-08-05 03:01:27 +0000
+++ cloudinit/reporting/handlers.py	2015-08-05 14:04:02 +0000
@@ -1,7 +1,13 @@
+# vi: ts=4 expandtab
+
 import abc
 import logging
+import json
+import oauthlib.oauth1 as oauth1
 
 from cloudinit.registry import DictRegistry
+from cloudinit import url_helper
+from cloudinit import util
 
 
 class ReportingHandler(object):
@@ -21,5 +27,33 @@
         logger.info(event.as_string())
 
 
+class WebHookHandler(ReportingHandler):
+    def __init__(self, endpoint, consumer_key=None, token_key=None,
+                 token_secret=None, consumer_secret=None, timeout=None,
+                 self.retries):
+        super(WebHookHandler, self).__init__()
+
+        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)
+        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:
+            read_url = self.oauth_helper.read_url
+        else:
+            read_url = url_helper.read_url
+        return read_url(
+            self.endpoint, data=event.as_json_data(),
+            timeout=self.timeout,
+            retries=self.retries, self.ssl_details)
+        
+
 available_handlers = DictRegistry()
 available_handlers.register_item('log', LogHandler)

=== modified file 'cloudinit/sources/DataSourceMAAS.py'
--- cloudinit/sources/DataSourceMAAS.py	2015-03-10 21:04:59 +0000
+++ cloudinit/sources/DataSourceMAAS.py	2015-08-05 13:39:08 +0000
@@ -52,8 +52,21 @@
         sources.DataSource.__init__(self, sys_cfg, distro, paths)
         self.base_url = None
         self.seed_dir = os.path.join(paths.seed_dir, 'maas')
-        self.oauth_clockskew = None
-
+        self.oauth_helper = self._get_helper()
+
+    def _get_helper(self):
+        mcfg = self.ds_cfg
+        # If we are missing token_key, token_secret or consumer_key
+        # then just do non-authed requests
+        for required in ('token_key', 'token_secret', 'consumer_key'):
+            if required not in mcfg:
+                return url_helper.OauthUrlHelper()
+
+        return url_helper.OauthHelper(
+            consumer_key=mcfg['consumer_key'], token_key=mcfg['token_key'],
+            token_secret=mcfg['token_secret'],
+            consumer_secret=mcfg.get('consumer_secret'))
+   
     def __str__(self):
         root = sources.DataSource.__str__(self)
         return "%s [%s]" % (root, self.base_url)
@@ -84,9 +97,9 @@
 
             self.base_url = url
 
-            (userdata, metadata) = read_maas_seed_url(self.base_url,
-                                                      self._md_headers,
-                                                      paths=self.paths)
+            (userdata, metadata) = read_maas_seed_url(
+                self.base_url, self.oauth_helper.md_headers,
+                paths=self.paths)
             self.userdata_raw = userdata
             self.metadata = metadata
             return True
@@ -94,31 +107,8 @@
             util.logexc(LOG, "Failed fetching metadata from url %s", url)
             return False
 
-    def _md_headers(self, url):
-        mcfg = self.ds_cfg
-
-        # If we are missing token_key, token_secret or consumer_key
-        # then just do non-authed requests
-        for required in ('token_key', 'token_secret', 'consumer_key'):
-            if required not in mcfg:
-                return {}
-
-        consumer_secret = mcfg.get('consumer_secret', "")
-
-        timestamp = None
-        if self.oauth_clockskew:
-            timestamp = int(time.time()) + self.oauth_clockskew
-
-        return oauth_headers(url=url,
-                             consumer_key=mcfg['consumer_key'],
-                             token_key=mcfg['token_key'],
-                             token_secret=mcfg['token_secret'],
-                             consumer_secret=consumer_secret,
-                             timestamp=timestamp)
-
     def wait_for_metadata_service(self, url):
         mcfg = self.ds_cfg
-
         max_wait = 120
         try:
             max_wait = int(mcfg.get("max_wait", max_wait))
@@ -138,10 +128,8 @@
         starttime = time.time()
         check_url = "%s/%s/meta-data/instance-id" % (url, MD_VERSION)
         urls = [check_url]
-        url = url_helper.wait_for_url(urls=urls, max_wait=max_wait,
-                                      timeout=timeout,
-                                      exception_cb=self._except_cb,
-                                      headers_cb=self._md_headers)
+        url = self.oauth_helper.wait_for_url(
+            urls=urls, max_wait=max_wait, timeout=timeout)
 
         if url:
             LOG.debug("Using metadata source: '%s'", url)
@@ -151,26 +139,6 @@
 
         return bool(url)
 
-    def _except_cb(self, msg, exception):
-        if not (isinstance(exception, url_helper.UrlError) and
-                (exception.code == 403 or exception.code == 401)):
-            return
-
-        if 'date' not in exception.headers:
-            LOG.warn("Missing header 'date' in %s response", exception.code)
-            return
-
-        date = exception.headers['date']
-        try:
-            ret_time = time.mktime(parsedate(date))
-        except Exception as e:
-            LOG.warn("Failed to convert datetime '%s': %s", date, e)
-            return
-
-        self.oauth_clockskew = int(ret_time - time.time())
-        LOG.warn("Setting oauth clockskew to %d", self.oauth_clockskew)
-        return
-
 
 def read_maas_seed_dir(seed_d):
     """
@@ -280,24 +248,6 @@
     return (userdata, md)
 
 
-def oauth_headers(url, consumer_key, token_key, token_secret, consumer_secret,
-                  timestamp=None):
-    if timestamp:
-        timestamp = str(timestamp)
-    else:
-        timestamp = None
-
-    client = oauth1.Client(
-        consumer_key,
-        client_secret=consumer_secret,
-        resource_owner_key=token_key,
-        resource_owner_secret=token_secret,
-        signature_method=oauth1.SIGNATURE_PLAINTEXT,
-        timestamp=timestamp)
-    uri, signed_headers, body = client.sign(url)
-    return signed_headers
-
-
 class MAASSeedDirNone(Exception):
     pass
 

=== modified file 'cloudinit/url_helper.py'
--- cloudinit/url_helper.py	2015-03-02 20:48:42 +0000
+++ cloudinit/url_helper.py	2015-08-05 13:42:21 +0000
@@ -25,6 +25,10 @@
 import six
 
 import requests
+import oauthlib.oauth1 as oauth1
+import os
+import json
+from functools import partial
 from requests import exceptions
 
 from six.moves.urllib.parse import (
@@ -147,13 +151,14 @@
 
 
 class UrlError(IOError):
-    def __init__(self, cause, code=None, headers=None):
+    def __init__(self, cause, code=None, headers=None, url=None):
         IOError.__init__(self, str(cause))
         self.cause = cause
         self.code = code
         self.headers = headers
         if self.headers is None:
             self.headers = {}
+        self.url = url
 
 
 def _get_ssl_args(url, ssl_details):
@@ -247,9 +252,10 @@
                     and hasattr(e, 'response')  # This appeared in v 0.10.8
                     and hasattr(e.response, 'status_code')):
                 excps.append(UrlError(e, code=e.response.status_code,
-                                      headers=e.response.headers))
+                                      headers=e.response.headers,
+                                      url=url))
             else:
-                excps.append(UrlError(e))
+                excps.append(UrlError(e, url=url))
                 if SSL_ENABLED and isinstance(e, exceptions.SSLError):
                     # ssl exceptions are not going to get fixed by waiting a
                     # few seconds
@@ -333,11 +339,11 @@
                 if not response.contents:
                     reason = "empty response [%s]" % (response.code)
                     url_exc = UrlError(ValueError(reason), code=response.code,
-                                       headers=response.headers)
+                                       headers=response.headers, url=url)
                 elif not response.ok():
                     reason = "bad status code [%s]" % (response.code)
                     url_exc = UrlError(ValueError(reason), code=response.code,
-                                       headers=response.headers)
+                                       headers=response.headers, url=url)
                 else:
                     return url
             except UrlError as e:
@@ -368,3 +374,129 @@
         time.sleep(sleep_time)
 
     return False
+
+
+class OauthUrlHelper(object):
+    def __init__(self, consumer_key=None, token_key=None,
+                 token_secret=None, consumer_secret=None,
+                 skew_data_file="/run/oauth_skew.json"):
+        self.consumer_key = consumer_key
+        self.consumer_secret = consumer_secret or ""
+        self.token_key = token_key
+        self.token_secret = token_secret
+        self.skew_data_file = skew_data_file
+        self.skew_data = {}
+        self._do_oauth = True
+        self.skew_change_limit = 5
+        required = (self.token_key, self.token_secret, self.consumer_key)
+        if not any(required):
+            self._do_oauth = False
+        elif not all(required):
+            raise ValueError("all or none of token_key, token_secret, or "
+                             "consumer_key can be set")
+
+        self.skew_data = self.read_skew_file()
+
+    def read_skew_file(self):
+        if self.skew_data_file and os.path.isfile(self.skew_data_file):
+            with open(self.skew_data_file, mode="r") as fp:
+                return json.load(fp.read())
+        return None
+
+    def update_skew_file(self, host, value):
+        # this is not atomic
+        cur = self.read_skew_file()
+        if cur is None or not self.skew_data_file:
+            return
+        cur[host] = value
+        with open(self.skew_data_file, mode="w") as fp:
+            fp.write(json.dumps(cur))
+
+    def exception_cb(self, msg, exception):
+        if not (isinstance(exception, UrlError) and
+                (exception.code == 403 or exception.code == 401)):
+            return
+
+        if 'date' not in exception.headers:
+            LOG.warn("Missing header 'date' in %s response", exception.code)
+            return
+
+        date = exception.headers['date']
+        try:
+            ret_time = time.mktime(parsedate(date))
+        except Exception as e:
+            LOG.warn("Failed to convert datetime '%s': %s", date, e)
+            return
+
+        host = urlparse(exception.url).netloc
+        skew = int(ret_time - time.time())
+        old_skew = self.skew_data.get(host)
+        if abs(old_skew - skew) > self.skew_change_limit:
+            self.update_skew_file(host, skew)
+            LOG.warn("Setting oauth clockskew for %s to %d",
+                     host, skew)
+        skew_data[host] = skew
+
+        return
+
+    def headers_cb(self, url):
+        if not self._do_oauth:
+            return {}
+
+        timestamp = None
+        host = urlparse(url).netloc
+        if host in self.skew_data:
+            timestamp = int(time.time()) + self.skew_data[host]
+
+        return oauth_headers(
+            url=url, consumer_key=self.consumer_key,
+            token_key=self.token_key, token_secret=self.token_secret,
+            consumer_secret=self.consumer_secret, timestamp=timestamp)
+
+    def _wrapped(self, wrapped_func, args, kwargs):
+        kwargs['headers_cb'] = partial(
+            self._headers_cb, kwargs.get('headers_cb'))
+        kwargs['exception_cb'] = partial(
+            self._exception_cb, kwargs.get('exception_cb'))
+        return wrapped_func(*args, **kwargs)
+
+    def wait_for_url(self, *args, **kwargs):
+        return self._wrapped(wait_for_url, args, kwargs)
+
+    def readurl(self, *args, **kwargs):
+        return self._wrapped(readurl, args, kwargs)
+    
+    def _exception_cb(self, extra_exception_cb, url, msg, exception):
+        ret = None
+        try:
+            if extra_exception_cb:
+                ret = extra_exception_cb(msg, exception)
+        finally:
+                self.exception_cb(self, msg, exception)
+        return ret
+
+    def _headers_cb(self, extra_headers_cb, url):
+        headers = {}
+        if extra_headers_cb:
+            headers = extra_headers_cb(url)
+        if headers:
+            headers.update(self.headers_cb(url))
+        return headers
+
+
+def oauth_headers(url, consumer_key, token_key, token_secret, consumer_secret,
+                  timestamp=None):
+    if timestamp:
+        timestamp = str(timestamp)
+    else:
+        timestamp = None
+
+    client = oauth1.Client(
+        consumer_key,
+        client_secret=consumer_secret,
+        resource_owner_key=token_key,
+        resource_owner_secret=token_secret,
+        signature_method=oauth1.SIGNATURE_PLAINTEXT,
+        timestamp=timestamp)
+    uri, signed_headers, body = client.sign(url)
+    return signed_headers

=== modified file 'cloudinit/util.py'
--- cloudinit/util.py	2015-07-28 00:42:56 +0000
+++ cloudinit/util.py	2015-08-05 12:29:43 +0000
@@ -782,7 +782,8 @@
             code = e.errno
             if e.errno == errno.ENOENT:
                 code = url_helper.NOT_FOUND
-            raise url_helper.UrlError(cause=e, code=code, headers=None)
+            raise url_helper.UrlError(cause=e, code=code, headers=None,
+                                      url=url)
         return url_helper.FileResponse(file_path, contents=contents)
     else:
         return url_helper.readurl(url,

=== modified file 'tests/unittests/test_reporting.py'
--- tests/unittests/test_reporting.py	2015-08-05 03:03:01 +0000
+++ tests/unittests/test_reporting.py	2015-08-05 03:27:24 +0000
@@ -147,7 +147,7 @@
     @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 +159,7 @@
         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 +177,7 @@
         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,7 +194,7 @@
         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)