Merge lp:~lazypower/charms/trusty/mongodb/charmhelpers_merge into lp:charms/mongodb

[Charles Butler]

Re-submission of charm-helpers migration. Adds validation test for Ceilometer. (note: when running tests, you will need to point teh cluster test at lp:~lazypower/charms/trusty/mongodb/charmhelpers_merge - as the store version will fail 100% of the time)

Please take a look

[lp:~lazypower/charms/trusty/mongodb/charmhelpers_merge]

55. By Charles Butler on 2014-07-30

adds missing import relation_ids

[Cory Johns (johnsca)]

Charles,

With the fixes as we discussed on IRC, I give this refactor my +1.

The tests all pass, with the caveat mentioned above (which will be resolved once it is merged), and the charm is overall cleaner. I particularly like the pattern for pulling in charm_helpers_sync.py and wonder if that could be leveraged into a pattern for pulling in charmhelpers at deploy time.

review: Approve

[Marco Ceppi (marcoceppi)]

lgtm

review: Approve

[lp:~lazypower/charms/trusty/mongodb/charmhelpers_merge]

56. By Charles Butler on 2014-07-30

Fixes missing default on key, strips check around apt-add-repository

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2014-07-30 17:48:38 +0000
@@ -0,0 +1,3 @@
+.git
+bin/*
+scripts/charm-helpers-sync.py

=== modified file 'Makefile'
--- Makefile	2014-04-11 20:55:42 +0000
+++ Makefile	2014-07-30 17:48:38 +0000
@@ -13,9 +13,17 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+PYTHON := /usr/bin/env python
 
 unittest:
 	tests/10-unit.test
 
 sync:
-	@charm-helper-sync -c charm-helpers-sync.yaml
+	@mkdir -p bin
+	@bzr cat lp:charm-helpers/tools/charm_helpers_sync/charm_helpers_sync.py > bin/charm_helpers_sync.py	
+	@$(PYTHON) bin/charm_helpers_sync.py -c charm-helpers-sync.yaml
+
+clean:
+	@find . -name \*.pyc -delete
+	@find . -name '*.bak' -delete
+

=== added file '__init__.py'
=== added directory 'bin'
=== modified file 'config.yaml'
--- config.yaml	2014-06-18 11:13:54 +0000
+++ config.yaml	2014-07-30 17:48:38 +0000
@@ -211,6 +211,7 @@
       option.
   key:
     type: string
+    default:
     description: >
       Key ID to import to the apt keyring to support use with arbitary source
       configuration from outside of Launchpad archives or PPA's.

=== added file 'hooks/charmhelpers/core/fstab.py'
--- hooks/charmhelpers/core/fstab.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/core/fstab.py	2014-07-30 17:48:38 +0000
@@ -0,0 +1,116 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+__author__ = 'Jorge Niedbalski R. <[e-mail]>'
+
+import os
+
+
+class Fstab(file):
+    """This class extends file in order to implement a file reader/writer
+    for file `/etc/fstab`
+    """
+
+    class Entry(object):
+        """Entry class represents a non-comment line on the `/etc/fstab` file
+        """
+        def __init__(self, device, mountpoint, filesystem,
+                     options, d=0, p=0):
+            self.device = device
+            self.mountpoint = mountpoint
+            self.filesystem = filesystem
+
+            if not options:
+                options = "defaults"
+
+            self.options = options
+            self.d = d
+            self.p = p
+
+        def __eq__(self, o):
+            return str(self) == str(o)
+
+        def __str__(self):
+            return "{} {} {} {} {} {}".format(self.device,
+                                              self.mountpoint,
+                                              self.filesystem,
+                                              self.options,
+                                              self.d,
+                                              self.p)
+
+    DEFAULT_PATH = os.path.join(os.path.sep, 'etc', 'fstab')
+
+    def __init__(self, path=None):
+        if path:
+            self._path = path
+        else:
+            self._path = self.DEFAULT_PATH
+        file.__init__(self, self._path, 'r+')
+
+    def _hydrate_entry(self, line):
+        # NOTE: use split with no arguments to split on any
+        #       whitespace including tabs
+        return Fstab.Entry(*filter(
+            lambda x: x not in ('', None),
+            line.strip("\n").split()))
+
+    @property
+    def entries(self):
+        self.seek(0)
+        for line in self.readlines():
+            try:
+                if not line.startswith("#"):
+                    yield self._hydrate_entry(line)
+            except ValueError:
+                pass
+
+    def get_entry_by_attr(self, attr, value):
+        for entry in self.entries:
+            e_attr = getattr(entry, attr)
+            if e_attr == value:
+                return entry
+        return None
+
+    def add_entry(self, entry):
+        if self.get_entry_by_attr('device', entry.device):
+            return False
+
+        self.write(str(entry) + '\n')
+        self.truncate()
+        return entry
+
+    def remove_entry(self, entry):
+        self.seek(0)
+
+        lines = self.readlines()
+
+        found = False
+        for index, line in enumerate(lines):
+            if not line.startswith("#"):
+                if self._hydrate_entry(line) == entry:
+                    found = True
+                    break
+
+        if not found:
+            return False
+
+        lines.remove(line)
+
+        self.seek(0)
+        self.write(''.join(lines))
+        self.truncate()
+        return True
+
+    @classmethod
+    def remove_by_mountpoint(cls, mountpoint, path=None):
+        fstab = cls(path=path)
+        entry = fstab.get_entry_by_attr('mountpoint', mountpoint)
+        if entry:
+            return fstab.remove_entry(entry)
+        return False
+
+    @classmethod
+    def add(cls, device, mountpoint, filesystem, options=None, path=None):
+        return cls(path=path).add_entry(Fstab.Entry(device,
+                                                    mountpoint, filesystem,
+                                                    options=options))

=== modified file 'hooks/charmhelpers/core/hookenv.py'
--- hooks/charmhelpers/core/hookenv.py	2014-04-11 20:55:42 +0000
+++ hooks/charmhelpers/core/hookenv.py	2014-07-30 17:48:38 +0000
@@ -25,7 +25,7 @@
 def cached(func):
     """Cache return values for multiple executions of func + args
 
-    For example:
+    For example::
 
         @cached
         def unit_get(attribute):
@@ -155,6 +155,100 @@
     return os.path.basename(sys.argv[0])
 
 
+class Config(dict):
+    """A Juju charm config dictionary that can write itself to
+    disk (as json) and track which values have changed since
+    the previous hook invocation.
+
+    Do not instantiate this object directly - instead call
+    ``hookenv.config()``
+
+    Example usage::
+
+        >>> # inside a hook
+        >>> from charmhelpers.core import hookenv
+        >>> config = hookenv.config()
+        >>> config['foo']
+        'bar'
+        >>> config['mykey'] = 'myval'
+        >>> config.save()
+
+
+        >>> # user runs `juju set mycharm foo=baz`
+        >>> # now we're inside subsequent config-changed hook
+        >>> config = hookenv.config()
+        >>> config['foo']
+        'baz'
+        >>> # test to see if this val has changed since last hook
+        >>> config.changed('foo')
+        True
+        >>> # what was the previous value?
+        >>> config.previous('foo')
+        'bar'
+        >>> # keys/values that we add are preserved across hooks
+        >>> config['mykey']
+        'myval'
+        >>> # don't forget to save at the end of hook!
+        >>> config.save()
+
+    """
+    CONFIG_FILE_NAME = '.juju-persistent-config'
+
+    def __init__(self, *args, **kw):
+        super(Config, self).__init__(*args, **kw)
+        self._prev_dict = None
+        self.path = os.path.join(charm_dir(), Config.CONFIG_FILE_NAME)
+        if os.path.exists(self.path):
+            self.load_previous()
+
+    def load_previous(self, path=None):
+        """Load previous copy of config from disk so that current values
+        can be compared to previous values.
+
+        :param path:
+
+            File path from which to load the previous config. If `None`,
+            config is loaded from the default location. If `path` is
+            specified, subsequent `save()` calls will write to the same
+            path.
+
+        """
+        self.path = path or self.path
+        with open(self.path) as f:
+            self._prev_dict = json.load(f)
+
+    def changed(self, key):
+        """Return true if the value for this key has changed since
+        the last save.
+
+        """
+        if self._prev_dict is None:
+            return True
+        return self.previous(key) != self.get(key)
+
+    def previous(self, key):
+        """Return previous value for this key, or None if there
+        is no "previous" value.
+
+        """
+        if self._prev_dict:
+            return self._prev_dict.get(key)
+        return None
+
+    def save(self):
+        """Save this config to disk.
+
+        Preserves items in _prev_dict that do not exist in self.
+
+        """
+        if self._prev_dict:
+            for k, v in self._prev_dict.iteritems():
+                if k not in self:
+                    self[k] = v
+        with open(self.path, 'w') as f:
+            json.dump(self, f)
+
+
 @cached
 def config(scope=None):
     """Juju charm configuration"""
@@ -163,7 +257,10 @@
         config_cmd_line.append(scope)
     config_cmd_line.append('--format=json')
     try:
-        return json.loads(subprocess.check_output(config_cmd_line))
+        config_data = json.loads(subprocess.check_output(config_cmd_line))
+        if scope is not None:
+            return config_data
+        return Config(config_data)
     except ValueError:
         return None
 
@@ -348,18 +445,19 @@
 class Hooks(object):
     """A convenient handler for hook functions.
 
-    Example:
+    Example::
+
         hooks = Hooks()
 
         # register a hook, taking its name from the function name
         @hooks.hook()
         def install():
-            ...
+            pass  # your code here
 
         # register a hook, providing a custom hook name
         @hooks.hook("config-changed")
         def config_changed():
-            ...
+            pass  # your code here
 
         if __name__ == "__main__":
             # execute a hook based on the name the program is called by

=== modified file 'hooks/charmhelpers/core/host.py'
--- hooks/charmhelpers/core/host.py	2014-04-11 20:55:42 +0000
+++ hooks/charmhelpers/core/host.py	2014-07-30 17:48:38 +0000
@@ -16,6 +16,7 @@
 from collections import OrderedDict
 
 from hookenv import log
+from fstab import Fstab
 
 
 def service_start(service_name):
@@ -34,7 +35,8 @@
 
 
 def service_reload(service_name, restart_on_failure=False):
-    """Reload a system service, optionally falling back to restart if reload fails"""
+    """Reload a system service, optionally falling back to restart if
+    reload fails"""
     service_result = service('reload', service_name)
     if not service_result and restart_on_failure:
         service_result = service('restart', service_name)
@@ -143,7 +145,19 @@
         target.write(content)
 
 
-def mount(device, mountpoint, options=None, persist=False):
+def fstab_remove(mp):
+    """Remove the given mountpoint entry from /etc/fstab
+    """
+    return Fstab.remove_by_mountpoint(mp)
+
+
+def fstab_add(dev, mp, fs, options=None):
+    """Adds the given device entry to the /etc/fstab file
+    """
+    return Fstab.add(dev, mp, fs, options=options)
+
+
+def mount(device, mountpoint, options=None, persist=False, filesystem="ext3"):
     """Mount a filesystem at a particular mountpoint"""
     cmd_args = ['mount']
     if options is not None:
@@ -154,9 +168,9 @@
     except subprocess.CalledProcessError, e:
         log('Error mounting {} at {}\n{}'.format(device, mountpoint, e.output))
         return False
+
     if persist:
-        # TODO: update fstab
-        pass
+        return fstab_add(device, mountpoint, filesystem, options=options)
     return True
 
 
@@ -168,9 +182,9 @@
     except subprocess.CalledProcessError, e:
         log('Error unmounting {}\n{}'.format(mountpoint, e.output))
         return False
+
     if persist:
-        # TODO: update fstab
-        pass
+        return fstab_remove(mountpoint)
     return True
 
 
@@ -197,13 +211,13 @@
 def restart_on_change(restart_map, stopstart=False):
     """Restart services based on configuration files changing
 
-    This function is used a decorator, for example
+    This function is used a decorator, for example::
 
         @restart_on_change({
             '/etc/ceph/ceph.conf': [ 'cinder-api', 'cinder-volume' ]
             })
         def ceph_client_changed():
-            ...
+            pass  # your code here
 
     In this example, the cinder-api and cinder-volume services
     would be restarted if /etc/ceph/ceph.conf is changed by the
@@ -295,3 +309,19 @@
     if 'link/ether' in words:
         hwaddr = words[words.index('link/ether') + 1]
     return hwaddr
+
+
+def cmp_pkgrevno(package, revno, pkgcache=None):
+    '''Compare supplied revno with the revno of the installed package
+
+    *  1 => Installed revno is greater than supplied arg
+    *  0 => Installed revno is the same as supplied arg
+    * -1 => Installed revno is less than supplied arg
+
+    '''
+    import apt_pkg
+    if not pkgcache:
+        apt_pkg.init()
+        pkgcache = apt_pkg.Cache()
+    pkg = pkgcache[package]
+    return apt_pkg.version_compare(pkg.current_ver.ver_str, revno)

=== modified file 'hooks/charmhelpers/fetch/__init__.py'
--- hooks/charmhelpers/fetch/__init__.py	2014-04-11 20:55:42 +0000
+++ hooks/charmhelpers/fetch/__init__.py	2014-07-30 17:48:38 +0000
@@ -1,4 +1,5 @@
 import importlib
+import time
 from yaml import safe_load
 from charmhelpers.core.host import (
     lsb_release
@@ -12,9 +13,9 @@
     config,
     log,
 )
-import apt_pkg
 import os
 
+
 CLOUD_ARCHIVE = """# Ubuntu Cloud Archive
 deb http://ubuntu-cloud.archive.canonical.com/ubuntu {} main
 """
@@ -54,12 +55,74 @@
     'icehouse/proposed': 'precise-proposed/icehouse',
     'precise-icehouse/proposed': 'precise-proposed/icehouse',
     'precise-proposed/icehouse': 'precise-proposed/icehouse',
+    # Juno
+    'juno': 'trusty-updates/juno',
+    'trusty-juno': 'trusty-updates/juno',
+    'trusty-juno/updates': 'trusty-updates/juno',
+    'trusty-updates/juno': 'trusty-updates/juno',
+    'juno/proposed': 'trusty-proposed/juno',
+    'juno/proposed': 'trusty-proposed/juno',
+    'trusty-juno/proposed': 'trusty-proposed/juno',
+    'trusty-proposed/juno': 'trusty-proposed/juno',
 }
 
+# The order of this list is very important. Handlers should be listed in from
+# least- to most-specific URL matching.
+FETCH_HANDLERS = (
+    'charmhelpers.fetch.archiveurl.ArchiveUrlFetchHandler',
+    'charmhelpers.fetch.bzrurl.BzrUrlFetchHandler',
+)
+
+APT_NO_LOCK = 100  # The return code for "couldn't acquire lock" in APT.
+APT_NO_LOCK_RETRY_DELAY = 10  # Wait 10 seconds between apt lock checks.
+APT_NO_LOCK_RETRY_COUNT = 30  # Retry to acquire the lock X times.
+
+
+class SourceConfigError(Exception):
+    pass
+
+
+class UnhandledSource(Exception):
+    pass
+
+
+class AptLockError(Exception):
+    pass
+
+
+class BaseFetchHandler(object):
+
+    """Base class for FetchHandler implementations in fetch plugins"""
+
+    def can_handle(self, source):
+        """Returns True if the source can be handled. Otherwise returns
+        a string explaining why it cannot"""
+        return "Wrong source type"
+
+    def install(self, source):
+        """Try to download and unpack the source. Return the path to the
+        unpacked files or raise UnhandledSource."""
+        raise UnhandledSource("Wrong source type {}".format(source))
+
+    def parse_url(self, url):
+        return urlparse(url)
+
+    def base_url(self, url):
+        """Return url without querystring or fragment"""
+        parts = list(self.parse_url(url))
+        parts[4:] = ['' for i in parts[4:]]
+        return urlunparse(parts)
+
 
 def filter_installed_packages(packages):
     """Returns a list of packages that require installation"""
+    import apt_pkg
     apt_pkg.init()
+
+    # Tell apt to build an in-memory cache to prevent race conditions (if
+    # another process is already building the cache).
+    apt_pkg.config.set("Dir::Cache::pkgcache", "")
+
     cache = apt_pkg.Cache()
     _pkgs = []
     for package in packages:
@@ -87,14 +150,7 @@
         cmd.extend(packages)
     log("Installing {} with options: {}".format(packages,
                                                 options))
-    env = os.environ.copy()
-    if 'DEBIAN_FRONTEND' not in env:
-        env['DEBIAN_FRONTEND'] = 'noninteractive'
-
-    if fatal:
-        subprocess.check_call(cmd, env=env)
-    else:
-        subprocess.call(cmd, env=env)
+    _run_apt_command(cmd, fatal)
 
 
 def apt_upgrade(options=None, fatal=False, dist=False):
@@ -109,24 +165,13 @@
     else:
         cmd.append('upgrade')
     log("Upgrading with options: {}".format(options))
-
-    env = os.environ.copy()
-    if 'DEBIAN_FRONTEND' not in env:
-        env['DEBIAN_FRONTEND'] = 'noninteractive'
-
-    if fatal:
-        subprocess.check_call(cmd, env=env)
-    else:
-        subprocess.call(cmd, env=env)
+    _run_apt_command(cmd, fatal)
 
 
 def apt_update(fatal=False):
     """Update local apt cache"""
     cmd = ['apt-get', 'update']
-    if fatal:
-        subprocess.check_call(cmd)
-    else:
-        subprocess.call(cmd)
+    _run_apt_command(cmd, fatal)
 
 
 def apt_purge(packages, fatal=False):
@@ -137,10 +182,7 @@
     else:
         cmd.extend(packages)
     log("Purging {}".format(packages))
-    if fatal:
-        subprocess.check_call(cmd)
-    else:
-        subprocess.call(cmd)
+    _run_apt_command(cmd, fatal)
 
 
 def apt_hold(packages, fatal=False):
@@ -151,6 +193,7 @@
     else:
         cmd.extend(packages)
     log("Holding {}".format(packages))
+
     if fatal:
         subprocess.check_call(cmd)
     else:
@@ -184,57 +227,50 @@
             apt.write(PROPOSED_POCKET.format(release))
     if key:
         subprocess.check_call(['apt-key', 'adv', '--keyserver',
-                               'keyserver.ubuntu.com', '--recv',
+                               'hkp://keyserver.ubuntu.com:80', '--recv',
                                key])
 
 
-class SourceConfigError(Exception):
-    pass
-
-
 def configure_sources(update=False,
                       sources_var='install_sources',
                       keys_var='install_keys'):
     """
-    Configure multiple sources from charm configuration
+    Configure multiple sources from charm configuration.
+
+    The lists are encoded as yaml fragments in the configuration.
+    The frament needs to be included as a string.
 
     Example config:
-        install_sources:
+        install_sources: |
           - "ppa:foo"
           - "http://example.com/repo precise main"
-        install_keys:
+        install_keys: |
           - null
           - "a1b2c3d4"
 
     Note that 'null' (a.k.a. None) should not be quoted.
     """
-    sources = safe_load(config(sources_var))
-    keys = config(keys_var)
-    if keys is not None:
-        keys = safe_load(keys)
-    if isinstance(sources, basestring) and (
-            keys is None or isinstance(keys, basestring)):
-        add_source(sources, keys)
+    sources = safe_load((config(sources_var) or '').strip()) or []
+    keys = safe_load((config(keys_var) or '').strip()) or None
+
+    if isinstance(sources, basestring):
+        sources = [sources]
+
+    if keys is None:
+        for source in sources:
+            add_source(source, None)
     else:
-        if not len(sources) == len(keys):
-            msg = 'Install sources and keys lists are different lengths'
-            raise SourceConfigError(msg)
-        for src_num in range(len(sources)):
-            add_source(sources[src_num], keys[src_num])
+        if isinstance(keys, basestring):
+            keys = [keys]
+
+        if len(sources) != len(keys):
+            raise SourceConfigError(
+                'Install sources and keys lists are different lengths')
+        for source, key in zip(sources, keys):
+            add_source(source, key)
     if update:
         apt_update(fatal=True)
 
-# The order of this list is very important. Handlers should be listed in from
-# least- to most-specific URL matching.
-FETCH_HANDLERS = (
-    'charmhelpers.fetch.archiveurl.ArchiveUrlFetchHandler',
-    'charmhelpers.fetch.bzrurl.BzrUrlFetchHandler',
-)
-
-
-class UnhandledSource(Exception):
-    pass
-
 
 def install_remote(source):
     """
@@ -265,30 +301,6 @@
     return install_remote(source)
 
 
-class BaseFetchHandler(object):
-
-    """Base class for FetchHandler implementations in fetch plugins"""
-
-    def can_handle(self, source):
-        """Returns True if the source can be handled. Otherwise returns
-        a string explaining why it cannot"""
-        return "Wrong source type"
-
-    def install(self, source):
-        """Try to download and unpack the source. Return the path to the
-        unpacked files or raise UnhandledSource."""
-        raise UnhandledSource("Wrong source type {}".format(source))
-
-    def parse_url(self, url):
-        return urlparse(url)
-
-    def base_url(self, url):
-        """Return url without querystring or fragment"""
-        parts = list(self.parse_url(url))
-        parts[4:] = ['' for i in parts[4:]]
-        return urlunparse(parts)
-
-
 def plugins(fetch_handlers=None):
     if not fetch_handlers:
         fetch_handlers = FETCH_HANDLERS
@@ -306,3 +318,40 @@
             log("FetchHandler {} not found, skipping plugin".format(
                 handler_name))
     return plugin_list
+
+
+def _run_apt_command(cmd, fatal=False):
+    """
+    Run an APT command, checking output and retrying if the fatal flag is set
+    to True.
+
+    :param: cmd: str: The apt command to run.
+    :param: fatal: bool: Whether the command's output should be checked and
+        retried.
+    """
+    env = os.environ.copy()
+
+    if 'DEBIAN_FRONTEND' not in env:
+        env['DEBIAN_FRONTEND'] = 'noninteractive'
+
+    if fatal:
+        retry_count = 0
+        result = None
+
+        # If the command is considered "fatal", we need to retry if the apt
+        # lock was not acquired.
+
+        while result is None or result == APT_NO_LOCK:
+            try:
+                result = subprocess.check_call(cmd, env=env)
+            except subprocess.CalledProcessError, e:
+                retry_count = retry_count + 1
+                if retry_count > APT_NO_LOCK_RETRY_COUNT:
+                    raise
+                result = e.returncode
+                log("Couldn't acquire DPKG lock. Will retry in {} seconds."
+                    "".format(APT_NO_LOCK_RETRY_DELAY))
+                time.sleep(APT_NO_LOCK_RETRY_DELAY)
+
+    else:
+        subprocess.call(cmd, env=env)

=== modified file 'hooks/charmhelpers/fetch/bzrurl.py'
--- hooks/charmhelpers/fetch/bzrurl.py	2014-04-11 20:55:42 +0000
+++ hooks/charmhelpers/fetch/bzrurl.py	2014-07-30 17:48:38 +0000
@@ -39,7 +39,8 @@
     def install(self, source):
         url_parts = self.parse_url(source)
         branch_name = url_parts.path.strip("/").split("/")[-1]
-        dest_dir = os.path.join(os.environ.get('CHARM_DIR'), "fetched", branch_name)
+        dest_dir = os.path.join(os.environ.get('CHARM_DIR'), "fetched",
+                                branch_name)
         if not os.path.exists(dest_dir):
             mkdir(dest_dir, perms=0755)
         try:

=== modified file 'hooks/hooks.py'
--- hooks/hooks.py	2014-07-29 10:22:55 +0000
+++ hooks/hooks.py	2014-07-30 17:48:38 +0000
@@ -6,7 +6,6 @@
 '''
 
 import commands
-import json
 import os
 import re
 import signal
@@ -15,7 +14,6 @@
 import sys
 import time
 import yaml
-import argparse
 
 from os import chmod
 from os import remove
@@ -29,10 +27,27 @@
     apt_update,
     apt_install
 )
+
 from charmhelpers.core.hookenv import (
-    config
-)
-
+    config,
+    unit_get,
+    relation_get,
+    relation_set,
+    relations_of_type,
+    relation_id,
+    relation_ids,
+    open_port,
+    close_port,
+    Hooks,
+)
+
+from charmhelpers.core.hookenv import log as juju_log
+
+from charmhelpers.core.host import (
+    service,
+)
+
+hooks = Hooks()
 
 ###############################################################################
 # Global variables
@@ -40,222 +55,14 @@
 default_mongodb_config = "/etc/mongodb.conf"
 default_mongodb_init_config = "/etc/init/mongodb.conf"
 default_mongos_list = "/etc/mongos.list"
-default_wait_for = 20
-default_max_tries = 20
+default_wait_for = 10
+default_max_tries = 5
 
 ###############################################################################
 # Supporting functions
 ###############################################################################
 
 
-#------------------------------------------------------------------------------
-# juju_log:  calls juju-log and records the message defined by the message
-#            variable
-#------------------------------------------------------------------------------
-def juju_log(message=None):
-    return (subprocess.call(['juju-log', str(message)]) == 0)
-
-
-#------------------------------------------------------------------------------
-# service:  Analogous to calling service on the command line to start/stop
-#           and get status of a service/daemon.
-#           Parameters:
-#           service_name:    The name of the service to act on.
-#           service_action:  The action (start, stop, status, etc.)
-#           Returns: True if the command was successfully executed or False on
-#                    error.
-#------------------------------------------------------------------------------
-def service(service_name=None, service_action=None):
-    juju_log("service: %s, action: %s" % (service_name, service_action))
-    if service_name is not None and service_action is not None:
-        retVal = subprocess.call(
-            ["service", service_name, service_action]) == 0
-    else:
-        retVal = False
-    juju_log("service %s %s returns: %s" %
-    (service_name, service_action, retVal))
-    return(retVal)
-
-
-#------------------------------------------------------------------------------
-# unit_get:  Convenience function wrapping the juju command unit-get
-#            Parameter:
-#            setting_name:  The setting to get out of unit_get
-#            Returns:  The requested information or None on error
-#------------------------------------------------------------------------------
-def unit_get(setting_name=None):
-    juju_log("unit_get: %s" % setting_name)
-    try:
-        cmd_line = ['unit-get', '--format=json']
-        if setting_name is not None:
-            cmd_line.append(setting_name)
-        unit_data = json.loads(subprocess.check_output(cmd_line))
-    except Exception, e:
-        subprocess.call(['juju-log', str(e)])
-        unit_data = None
-    finally:
-        juju_log("unit_get %s returns: %s" % (setting_name, unit_data))
-        return(unit_data)
-
-
-#------------------------------------------------------------------------------
-# config_get:  Returns a dictionary containing all of the config information
-#              Optional parameter: scope
-#              scope: limits the scope of the returned configuration to the
-#                     desired config item.
-#------------------------------------------------------------------------------
-def config_get(scope=None):
-    juju_log("config_get: %s" % scope)
-    try:
-        config_cmd_line = ['config-get']
-        if scope is not None:
-            config_cmd_line.append(scope)
-        config_cmd_line.append('--format=json')
-        config_data = json.loads(subprocess.check_output(config_cmd_line))
-    except Exception, e:
-        juju_log(str(e))
-        config_data = None
-    finally:
-        juju_log("config_get: %s returns: %s" % (scope, config_data))
-        return(config_data)
-
-
-#------------------------------------------------------------------------------
-# relation_get:  Returns a dictionary containing the relation information
-#                Optional parameters: scope, relation_id
-#                scope:        limits the scope of the returned data to the
-#                              desired item.
-#                unit_name:    limits the data ( and optionally the scope )
-#                              to the specified unit
-#                relation_id:  specify relation id for out of context usage.
-#------------------------------------------------------------------------------
-def relation_get(scope=None, unit_name=None, relation_id=None,
-        wait_for=default_wait_for, max_tries=default_max_tries):
-    juju_log("relation_get: scope: %s, unit_name: %s, relation_id: %s" %
-    (scope, unit_name, relation_id))
-    current_try = 0
-    try:
-        relation_cmd_line = ['relation-get', '--format=json']
-        if relation_id is not None:
-            relation_cmd_line.extend(('-r', relation_id))
-        if scope is not None:
-            relation_cmd_line.append(scope)
-        else:
-            relation_cmd_line.append('')
-        if unit_name is not None:
-            relation_cmd_line.append(unit_name)
-        relation_data = json.loads(subprocess.check_output(relation_cmd_line))
-
-#        while relation_data is None and current_try < max_tries:
-#            time.sleep(wait_for)
-#            relation_data = json.loads(subprocess.check_output(relation_cmd_line))
-#            current_try += 1
-
-    except Exception, e:
-        juju_log(str(e))
-        relation_data = None
-    finally:
-        juju_log("relation_get returns: %s" % relation_data)
-        return(relation_data)
-
-
-#------------------------------------------------------------------------------
-# relation_set:  Convenience function wrapping the juju command relation-set
-#                Parameters:
-#                key_value_pairs: A dictionary containing the key/value pairs
-#                                 to be set.
-#                Optional Parameter:
-#                relation_id:  The relation id to use
-#                Returns: True on success or False on failure
-#------------------------------------------------------------------------------
-def relation_set(key_value_pairs=None, relation_id=None):
-    juju_log("relation_set: kv: %s, relation_id: %s" %
-    (key_value_pairs, relation_id))
-    if key_value_pairs is None or not isinstance(key_value_pairs, dict):
-        juju_log("relation_set: Invalid key_value_pais.")
-        return(False)
-    try:
-        relation_cmd_line = ['relation-set', '--format=json']
-        if relation_id is not None:
-            relation_cmd_line.append('-r %s' % relation_id)
-        for (key, value) in key_value_pairs.items():
-            relation_cmd_line.append('%s=%s' % (key, value))
-        retVal = (subprocess.call(relation_cmd_line) == 0)
-    except Exception, e:
-        juju_log(str(e))
-        retVal = False
-    finally:
-        juju_log("relation_set returns: %s" % retVal)
-        return(retVal)
-
-
-def relation_list(relation_id=None, wait_for=default_wait_for,
-        max_tries=default_max_tries):
-    juju_log("relation_list: relation_id: %s" % relation_id)
-    current_try = 0
-    try:
-        relation_cmd_line = ['relation-list', '--format=json']
-        if relation_id is not None:
-            relation_cmd_line.append('-r %s' % relation_id)
-        relation_data = json.loads(subprocess.check_output(relation_cmd_line))
-
-#        while relation_data is None and current_try < max_tries:
-#            time.sleep(wait_for)
-#            relation_data = json.loads(subprocess.check_output(relation_cmd_line))
-#            current_try += 1
-
-    except Exception, e:
-        juju_log(str(e))
-        relation_data = None
-    finally:
-        juju_log("relation_id %s returns: %s" % (relation_id, relation_data))
-        return(relation_data)
-
-
-def relation_ids(relation_name=None):
-    juju_log("relation_ids: relation_name: %s" % relation_name)
-    try:
-        relation_cmd_line = ['relation-ids', '--format=json']
-        if relation_name is not None:
-            relation_cmd_line.append(relation_name)
-        relation_data = json.loads(subprocess.check_output(relation_cmd_line))
-    except Exception, e:
-        juju_log(str(e))
-        relation_data = None
-    finally:
-        juju_log("relation_ids %s returns: %s" % (relation_name, relation_data))
-        return(relation_data)
-
-#------------------------------------------------------------------------------
-# open_port:  Convenience function to open a port in juju to
-#             expose a service
-#------------------------------------------------------------------------------
-def open_port(port=None, protocol="TCP"):
-    juju_log("open_port: port: %d protocol: %s" % (int(port), protocol))
-    if port is None:
-        retVal = False
-    else:
-        retVal = subprocess.call(['open-port', "%d/%s" %
-        (int(port), protocol)]) == 0
-    juju_log("open_port %d/%s returns: %s" % (int(port), protocol, retVal))
-    return(retVal)
-
-
-#------------------------------------------------------------------------------
-# close_port:  Convenience function to close a port in juju to
-#              unexpose a service
-#------------------------------------------------------------------------------
-def close_port(port=None, protocol="TCP"):
-    juju_log("close_port: port: %d protocol: %s" % (int(port), protocol))
-    if port is None:
-        retVal = False
-    else:
-        retVal = subprocess.call(['close-port', "%d/%s" %
-        (int(port), protocol)]) == 0
-    juju_log("close_port %d/%s returns: %s" % (int(port), protocol, retVal))
-    return(retVal)
-
-
 def port_check(host=None, port=None, protocol='TCP'):
     if host is None or port is None:
         juju_log("port_check: host and port must be defined.")
@@ -494,7 +301,7 @@
         config.append("")
 
     # arbiter
-    if config_data['arbiter'] != "disabled" and\
+    if config_data['arbiter'] != "disabled" and \
     config_data['arbiter'] != "enabled":
         config.append("arbiter = %s" % config_data['arbiter'])
         config.append("")
@@ -657,7 +464,7 @@
 
 
 def configsvr_status(wait_for=default_wait_for, max_tries=default_max_tries):
-    config_data = config_get()
+    config_data = config()
     current_try = 0
     while (process_check_pidfile('/var/run/mongodb/configsvr.pid') !=
     (None, None)) and not port_check(
@@ -685,7 +492,7 @@
         juju_log("disable_configsvr: port not defined.")
         return(False)
     try:
-        config_server_port = config_get('config_server_port')
+        config_server_port = config('config_server_port')
         pid = open('/var/run/mongodb/configsvr.pid').read()
         os.kill(int(pid), signal.SIGTERM)
         os.unlink('/var/run/mongodb/configsvr.pid')
@@ -747,7 +554,7 @@
 
 
 def mongos_status(wait_for=default_wait_for, max_tries=default_max_tries):
-    config_data = config_get()
+    config_data = config()
     current_try = 0
     while (process_check_pidfile('/var/run/mongodb/mongos.pid') !=
     (None, None)) and not port_check(
@@ -839,17 +646,17 @@
 
 def restart_mongod(wait_for=default_wait_for, max_tries=default_max_tries):
     my_hostname = unit_get('public-address')
-    my_port = config_get('port')
+    my_port = config('port')
     current_try = 0
 
-    service('mongodb', 'stop')
+    service('stop', 'mongodb')
     if os.path.exists('/var/lib/mongodb/mongod.lock'):
         os.remove('/var/lib/mongodb/mongod.lock')
 
-    if not service('mongodb', 'start'):
+    if not service('start', 'mongodb'):
         return False
 
-    while (service('mongodb', 'status') and
+    while (service('status', 'mongodb') and
            not port_check(my_hostname, my_port) and
            current_try < max_tries):
         juju_log(
@@ -859,14 +666,14 @@
         current_try += 1
 
     return(
-        (service('mongodb', 'status') == port_check(my_hostname, my_port))
+        (service('status', 'mongodb') == port_check(my_hostname, my_port))
          is True)
 
 
 def backup_cronjob(disable=False):
     """Generate the cronjob to backup with mongodbump."""
     juju_log('Setting up cronjob')
-    config_data = config_get()
+    config_data = config()
     backupdir = config_data['backup_directory']
     bind_ip = config_data['bind_ip']
     cron_file = '/etc/cron.d/mongodb'
@@ -915,18 +722,19 @@
 ###############################################################################
 # Hook functions
 ###############################################################################
[e-mail]('install')
 def install_hook():
     juju_log("Installing mongodb")
     add_source(config('source'), config('key'))
     apt_update(fatal=True)
     apt_install(packages=['mongodb', 'python-yaml'], fatal=True)
-    return True
-
-
+
+
[e-mail]('config-changed')
 def config_changed():
     juju_log("Entering config_changed")
     print "Entering config_changed"
-    config_data = config_get()
+    config_data = config()
     print "config_data: ", config_data
     mongodb_config = open(default_mongodb_config).read()
 
@@ -1048,7 +856,7 @@
         juju_log("config_changed: Exceptions: %s" % str(e))
 
     if mongos_pid is not None:
-        mongos_port = re.search('--port (\w+)', mongos_cmd_line).group(2)
+        mongos_port = re.search('--port (\w+)', mongos_cmd_line).group(1)
         disable_mongos(mongos_port)
         enable_mongos(config_data['mongos_port'])
     else:
@@ -1058,6 +866,7 @@
     return(True)
 
 
[e-mail]('start')
 def start_hook():
     juju_log("start_hook")
     retVal = restart_mongod()
@@ -1065,10 +874,11 @@
     return(retVal)
 
 
[e-mail]('stop')
 def stop_hook():
     juju_log("stop_hook")
     try:
-        retVal = service('mongodb', 'stop')
+        retVal = service('stop', 'mongodb')
         os.remove('/var/lib/mongodb/mongod.lock')
         #FIXME Need to check if this is still needed
     except Exception, e:
@@ -1079,15 +889,16 @@
         return(retVal)
 
 
[e-mail]('database-relation-joined')
 def database_relation_joined():
     juju_log("database_relation_joined")
     my_hostname = unit_get('public-address')
-    my_port = config_get('port')
-    my_replset = config_get('replicaset')
+    my_port = config('port')
+    my_replset = config('replicaset')
     juju_log("my_hostname: %s" % my_hostname)
     juju_log("my_port: %s" % my_port)
     juju_log("my_replset: %s" % my_replset)
-    return(relation_set(
+    return(relation_set(relation_id(),
         {
             'hostname': my_hostname,
             'port': my_port,
@@ -1096,34 +907,36 @@
         }))
 
 
[e-mail]('replicaset-relation-joined')
 def replica_set_relation_joined():
     juju_log("replica_set_relation_joined")
     my_hostname = unit_get('public-address')
-    my_port = config_get('port')
-    my_replset = config_get('replicaset')
+    my_port = config('port')
+    my_replset = config('replicaset')
     my_install_order = os.environ['JUJU_UNIT_NAME'].split('/')[1]
     juju_log("my_hostname: %s" % my_hostname)
     juju_log("my_port: %s" % my_port)
     juju_log("my_replset: %s" % my_replset)
     juju_log("my_install_order: %s" % my_install_order)
-    return(enable_replset(my_replset) ==
-    restart_mongod() ==
-    relation_set(
-        {
-            'hostname': my_hostname,
-            'port': my_port,
-            'replset': my_replset,
-            'install-order': my_install_order,
-            'type': 'replset',
-        }))
-
-
+    enable_replset(my_replset)
+    restart_mongod()
+
+    relation_set(relation_id(), {
+        'hostname': my_hostname,
+        'port': my_port,
+        'replset': my_replset,
+        'install-order': my_install_order,
+        'type': 'replset',
+        })
+
+
[e-mail]('replicaset-relation-changed')
 def replica_set_relation_changed():
     juju_log("replica_set_relation_changed")
     my_hostname = unit_get('public-address')
-    my_port = config_get('port')
+    my_port = config('port')
     my_install_order = os.environ['JUJU_UNIT_NAME'].split('/')[1]
-    my_replicaset_master = config_get('replicaset_master')
+    my_replicaset_master = config('replicaset_master')
 
     # If we are joining an existing replicaset cluster, just join and leave.
     if my_replicaset_master != "auto":
@@ -1135,44 +948,44 @@
     master_install_order = my_install_order
 
     # Check the nodes in the relation to find the master
-    for member in relation_list():
+    for member in relations_of_type('replica-set'):
+        member = member['__unit__']
         juju_log("replica_set_relation_changed: member: %s" % member)
         hostname = relation_get('hostname', member)
         port = relation_get('port', member)
-        install_order = relation_get('install-order', member)
-        juju_log("replica_set_relation_changed: install_order: %s" % install_order)
-        if install_order is None:
-            juju_log("replica_set_relation_changed: install_order is None.  relation is not ready")
+        inst_ordr = relation_get('install-order', member)
+        juju_log("replica_set_relation_changed: install_order: %s" % inst_ordr)
+        if inst_ordr is None:
+            juju_log("replica_set_relation_changed: install_order is None."
+                     "  relation is not ready")
             break
-        if int(install_order) < int(master_install_order):
+        if int(inst_ordr) < int(master_install_order):
             master_hostname = hostname
             master_port = port
-            master_install_order = install_order
+            master_install_order = inst_ordr
 
     # Initiate the replset
     init_replset("%s:%s" % (master_hostname, master_port))
 
     # Add the rest of the nodes to the replset
-    for member in relation_list():
-        hostname = relation_get('hostname', member)
-        port = relation_get('port', member)
+    for member in relations_of_type('replica-set'):
+        hostname = relation_get('hostname', member['__unit__'])
+        port = relation_get('port', member['__unit__'])
         if master_hostname != hostname:
             if hostname == my_hostname:
-                subprocess.call(['mongo',
-                    '--eval',
-                    "rs.add(\"%s\")" % hostname])
+                subprocess.call(['mongo', '--eval',
+                                 "rs.add(\"%s\")" % hostname])
             else:
                 join_replset("%s:%s" % (master_hostname, master_port),
-                    "%s:%s" % (hostname, port))
+                             "%s:%s" % (hostname, port))
 
     # Add this node to the replset ( if needed )
     if master_hostname != my_hostname:
         join_replset("%s:%s" % (master_hostname, master_port),
-            "%s:%s" % (my_hostname, my_port))
-
-    return(True)
-
-
+                     "%s:%s" % (my_hostname, my_port))
+
+
[e-mail]('data-relation-joined')
 def data_relation_joined():
     juju_log("data_relation_joined")
 
@@ -1182,6 +995,7 @@
         }))
 
 
[e-mail]('data-relation-changed')
 def data_relation_changed():
     juju_log("data_relation_changed")
 
@@ -1189,60 +1003,63 @@
         juju_log("mountpoint from storage subordinate not ready, let's wait")
         return(True)
 
-    return(config_changed())
-
-
+    config_changed()
+
+
[e-mail]('data-relation-departed')
 def data_relation_departed():
     juju_log("data_relation_departed")
     return(config_changed())
 
-
[e-mail]('configsvr-relation-joined')
 def configsvr_relation_joined():
     juju_log("configsvr_relation_joined")
     my_hostname = unit_get('public-address')
-    my_port = config_get('config_server_port')
+    my_port = config('config_server_port')
     my_install_order = os.environ['JUJU_UNIT_NAME'].split('/')[1]
-    return(relation_set(
-        {
-            'hostname': my_hostname,
-            'port': my_port,
-            'install-order': my_install_order,
-            'type': 'configsvr',
-        }))
-
-
+    relation_set(relation_id(),
+                        {
+                            'hostname': my_hostname,
+                            'port': my_port,
+                            'install-order': my_install_order,
+                            'type': 'configsvr',
+                        })
+
+
[e-mail]('configsvr-relation-changed')
 def configsvr_relation_changed():
     juju_log("configsvr_relation_changed")
-    config_data = config_get()
+    config_data = config()
     my_port = config_data['config_server_port']
     disable_configsvr(my_port)
-    retVal = enable_configsvr(config_data)
-    juju_log("configsvr_relation_changed returns: %s" % retVal)
-    return(retVal)
-
-
+
+
[e-mail]('mongos-cfg-relation-joined')
[e-mail]('mongos-relation-joined')
 def mongos_relation_joined():
     juju_log("mongos_relation_joined")
     my_hostname = unit_get('public-address')
-    my_port = config_get('mongos_port')
+    my_port = config('mongos_port')
     my_install_order = os.environ['JUJU_UNIT_NAME'].split('/')[1]
-    return(relation_set(
-        {
-            'hostname': my_hostname,
-            'port': my_port,
-            'install-order': my_install_order,
-            'type': 'mongos'
-        }))
-
-
+    relation_set(relation_id(),
+                 {
+                     'hostname': my_hostname,
+                     'port': my_port,
+                     'install-order': my_install_order,
+                     'type': 'mongos'
+                 })
+
+
[e-mail]('mongos-cfg-relation-changed')
[e-mail]('mongos-relation-changed')
 def mongos_relation_changed():
     juju_log("mongos_relation_changed")
-    config_data = config_get()
+    config_data = config()
     retVal = False
-    for member in relation_list():
-        hostname = relation_get('hostname', member)
-        port = relation_get('port', member)
-        rel_type = relation_get('type', member)
+    for member in relations_of_type('mongos-cfg'):
+        hostname = relation_get('hostname', member['__unit__'])
+        port = relation_get('port', member['__unit__'])
+        rel_type = relation_get('type', member['__unit__'])
         if hostname is None or port is None or rel_type is None:
             juju_log("mongos_relation_changed: relation data not ready.")
             break
@@ -1264,34 +1081,33 @@
             if mongos_ready():
                 mongos_host = "%s:%s" % (
                     unit_get('public-address'),
-                    config_get('mongos_port'))
+                    config('mongos_port'))
                 shard_command1 = "sh.addShard(\"%s:%s\")" % (hostname, port)
-                retVal1 = mongo_client(mongos_host, shard_command1)
+                mongo_client(mongos_host, shard_command1)
                 replicaset = relation_get('replset', member)
-                shard_command2 = "sh.addShard(\"%s/%s:%s\")" % \
+                shard_command2 = "sh.addShard(\"%s/%s:%s\")" %  \
                 (replicaset, hostname, port)
-                retVal2 = mongo_client(mongos_host, shard_command2)
-                retVal = retVal1 is True and retVal2 is True
-            else:
-                juju_log("Not enough config server for mongos yet.")
-                retVal = True
+                mongo_client(mongos_host, shard_command2)
+
+
         else:
             juju_log("mongos_relation_change: undefined rel_type: %s" %
-            rel_type)
+                     rel_type)
             return(False)
     juju_log("mongos_relation_changed returns: %s" % retVal)
-    return(retVal)
-
-
+
+
+
[e-mail]('mongos-relation-broken')
 def mongos_relation_broken():
-#    config_servers = load_config_servers(default_mongos_list)
-#    for member in relation_list():
-#        hostname = relation_get('hostname', member)
-#        port = relation_get('port', member)
-#        if '%s:%s' % (hostname, port) in config_servers:
-#            config_servers.remove('%s:%s' % (hostname, port))
-#    return(update_file(default_mongos_list, '\n'.join(config_servers)))
-    return(True)
+    config_servers = load_config_servers(default_mongos_list)
+    for member in relations_of_type('mongos'):
+        hostname = relation_get('hostname', member)
+        port = relation_get('port', member)
+        if '%s:%s' % (hostname, port) in config_servers:
+            config_servers.remove('%s:%s' % (hostname, port))
+
+    update_file(default_mongos_list, '\n'.join(config_servers))
 
 
 def run(command, exit_on_error=True):
@@ -1318,7 +1134,7 @@
 #
 #------------------------------
 def volume_get_volid_from_volume_map():
-    config_data = config_get()
+    config_data = config()
     volume_map = {}
     try:
         volume_map = yaml.load(config_data['volume-map'].strip())
@@ -1379,19 +1195,21 @@
 #           None    config state is invalid - we should not serve
 def volume_get_volume_id():
 
+    config_data = config()
+
+
 
     volid = volume_get_id_for_storage_subordinate()
     if volid:
         return volid
 
-    config_data = config_get()
     ephemeral_storage = config_data['volume-ephemeral-storage']
     volid = volume_get_volid_from_volume_map()
     juju_unit_name = os.environ['JUJU_UNIT_NAME']
     if ephemeral_storage in [True, 'yes', 'Yes', 'true', 'True']:
         if volid:
             juju_log(
-                "volume-ephemeral-storage is True, but " +
+                "volume-ephemeral-storage is True, but"
                 "volume-map[{!r}] -> {}".format(juju_unit_name, volid))
             return None
         else:
@@ -1424,6 +1242,7 @@
         return None
     return output
 
+
 #------------------------------------------------------------------------------
 # Core logic for permanent storage changes:
 # NOTE the only 2 "True" return points:
@@ -1435,7 +1254,7 @@
 #     - manipulate /var/lib/mongodb/VERSION/CLUSTER symlink
 #------------------------------------------------------------------------------
 def config_changed_volume_apply():
-    config_data = config_get()
+    config_data = config()
     data_directory_path = config_data["dbpath"]
     assert(data_directory_path)
     volid = volume_get_volume_id()
@@ -1548,57 +1367,6 @@
 ###############################################################################
 # Main section
 ###############################################################################
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-H', '--hook_name', dest='hook_name',
-                        help='hook to call')
-    args = parser.parse_args()
-    if args.hook_name is not None:
-        hook_name = args.hook_name
-    else:
-        hook_name = os.path.basename(sys.argv[0])
-
-    if hook_name == "install":
-        retVal = install_hook()
-    elif hook_name == "config-changed":
-        retVal = config_changed()
-    elif hook_name == "start":
-        retVal = start_hook()
-    elif hook_name == "stop":
-        retVal = stop_hook()
-    elif hook_name == "database-relation-joined":
-        retVal = database_relation_joined()
-    elif hook_name == "replica-set-relation-joined":
-        retVal = replica_set_relation_joined()
-    elif hook_name == "replica-set-relation-changed":
-        retVal = replica_set_relation_changed()
-    elif hook_name == "configsvr-relation-joined":
-        retVal = configsvr_relation_joined()
-    elif hook_name == "configsvr-relation-changed":
-        retVal = configsvr_relation_changed()
-    elif hook_name == "mongos-cfg-relation-joined":
-        retVal = mongos_relation_joined()
-    elif hook_name == "mongos-cfg-relation-changed":
-        retVal = mongos_relation_changed()
-    elif hook_name == "mongos-cfg-relation-broken":
-        retVal = mongos_relation_broken()
-    elif hook_name == "mongos-relation-joined":
-        retVal = mongos_relation_joined()
-    elif hook_name == "mongos-relation-changed":
-        retVal = mongos_relation_changed()
-    elif hook_name == "mongos-relation-broken":
-        retVal = mongos_relation_broken()
-    elif hook_name == "data-relation-joined":
-        retVal = data_relation_joined()
-    elif hook_name == "data-relation-changed":
-        retVal = data_relation_changed()
-    elif hook_name == "data-relation-departed":
-        retVal = data_relation_departed()
-    else:
-        print "Unknown hook"
-        retVal = False
-
-    if retVal is True:
-        sys.exit(0)
-    else:
-        sys.exit(1)
+if __name__ == "__main__":
+    # execute a hook based on the name the program is called by
+    hooks.execute(sys.argv)
\ No newline at end of file

=== modified file 'hooks/install'
--- hooks/install	2013-11-25 19:48:00 +0000
+++ hooks/install	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-#!/bin/bash
-
-sudo apt-get install "python-yaml"
-
-hooks/hooks.py -H install

=== target is u'hooks.py'
=== modified file 'metadata.yaml'
--- metadata.yaml	2014-06-18 11:13:54 +0000
+++ metadata.yaml	2014-07-30 17:48:38 +0000
@@ -1,6 +1,9 @@
 name: mongodb
-maintainer: Juan Negron <[e-mail]>
-summary: MongoDB (from humongous) is an open-source document database
+summary: An open-source document database, and the leading NoSQL database
+maintainers:
+ - Juan Negron <[e-mail]>
+ - Marco Ceppi <[e-mail]>
+ - Charles Butler <[e-mail]>
 description: |
   MongoDB is a high-performance, open source, schema-free document-
   oriented  data store that's easy to deploy, manage and use. It's

=== modified file 'tests/00-setup'
--- tests/00-setup	2014-02-25 21:37:07 +0000
+++ tests/00-setup	2014-07-30 17:48:38 +0000
@@ -1,11 +1,11 @@
 #!/bin/bash
 
+set -e
+
 sudo apt-get install python-setuptools -y
-
-if [ -f '/etc/apt.d/sources.list.d/juju-stable-precise.list' ]; then
-	sudo add-apt-repository ppa:juju/stable -y
-fi
+sudo add-apt-repository ppa:juju/stable -y
 
 sudo apt-get update
 
-sudo apt-get install amulet python3 python3-requests python3-pymongo juju-core charm-tools python-mock -y
+
+sudo apt-get install amulet python3 python3-requests python3-pymongo juju-core charm-tools python-mock python-pymongo -y

=== added file 'tests/200_relate_ceilometer.test'
--- tests/200_relate_ceilometer.test	1970-01-01 00:00:00 +0000
+++ tests/200_relate_ceilometer.test	2014-07-30 17:48:38 +0000
@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+
+import amulet
+import pdb
+
+class TestDeploy(object):
+
+    def __init__(self, time=2500):
+        # Attempt to load the deployment topology from a bundle.
+        self.deploy = amulet.Deployment(series="trusty")
+
+        # If something errored out, attempt to continue by
+        # manually specifying a standalone deployment
+        self.deploy.add('mongodb')
+        self.deploy.add('ceilometer', 'cs:trusty/ceilometer')
+        # send blank configs to finalize the objects in the deployment map
+        self.deploy.configure('mongodb', {})
+        self.deploy.configure('ceilometer', {})
+
+        self.deploy.relate('mongodb:database', 'ceilometer:shared-db')
+
+        try:
+            self.deploy.setup(time)
+            self.deploy.sentry.wait(time)
+        except:
+            amulet.raise_status(amulet.FAIL, msg="Environment standup timeout")
+        # sentry = self.deploy.sentry
+
+    def run(self):
+        for test in dir(self):
+            if test.startswith('test_'):
+                getattr(self, test)()
+
+    def test_mongo_relation(self):
+        unit = self.deploy.sentry.unit['ceilometer/0']
+        mongo = self.deploy.sentry.unit['mongodb/0'].info['public-address']
+        cont = unit.file_contents('/etc/ceilometer/ceilometer.conf')
+        if mongo not in cont:
+            amulet.raise_status(amulet.FAIL, "Unable to verify ceilometer cfg")
+
+if __name__ == '__main__':
+    runner = TestDeploy()
+    runner.run()