Merge lp:~dspiteri/charms/precise/etherpad-lite/pythonport into lp:charms/etherpad-lite

[Darren Spiteri]

[Mark Mims (mark-mims)]

lgtm.

Please consider adding back support for a config option to install ep from upstream i.e., git

Thanks!

review: Approve

=== modified file 'README.md'
--- README.md	2013-04-09 18:38:59 +0000
+++ README.md	2013-07-09 03:52:26 +0000
@@ -27,15 +27,16 @@
 lose all of the pads within your standalone deployment - same applies
 vica-versa.
 
-You can change the upstream commit tag for etherpad-lite by using charm config
-either in a yaml file::
-
-    etherpad-lite:
-        commit: 1.0
-
-or::
-
-    juju set etherpad-lite commit=cfb58a80a30486156a15515164c9c0f4647f165b
-
-This can be changed for an existing service as well - allowing you to upgrade to
-a newer (potentially broken!) version.
\ No newline at end of file
+The charm config has the following configurables:
+
+    application_url: Bundled BZR branch with node.js deps
+    application_revision: branch revision to update
+    install_dir: directory to install to
+    extra_archives: get an appropriate version of node.js and related packages
+
+To upgrade, set application_revision to the latest version:
+	
+    juju upgrade-charm etherpad-lite
+
+Your data will be retained in {install_dir}-db, or fixup the mysql relation as above.
+

=== modified file 'config.yaml'
--- config.yaml	2012-03-30 17:10:49 +0000
+++ config.yaml	2013-07-09 03:52:26 +0000
@@ -1,9 +1,31 @@
 options:
-  commit:
-    default: cfb58a80a30486156a15515164c9c0f4647f165b
-    type: string
-    description: |
-      Commit from http://github.com/Pita/etherpad-lite to use.  This
-      could also refer to a branch (master) or a tag (1.1).
-      .
-      Default is one that is know to work with this charm.
+  extra_archives:
+    default: "ppa:onestone/node.js-0.8"
+    type: string
+    description: |
+      Extra archives for node.js and dependencies.
+  install_path:
+    default: "/srv/etherpad-lite"
+    type: string
+    description: |
+      Install path for etherpad-lite application.
+  application_name:
+    default: "etherpad-lite"
+    type: string
+    description: |
+      Operating name of the application.
+  application_user:
+    default: "etherpad"
+    type: "string"
+    description: |
+      System user id to run the application under.
+  application_url:
+    default: "lp:etherpad-lite-charm-deps"
+    type: "string"
+    description: |
+      BZR repository containing etherpad-list and dependencies.
+  application_revision:
+    default: "4"
+    type: "string"
+    description: |
+      Revision to pull from application_url BZR repo. 

=== added directory 'hooks/charmhelpers'
=== added file 'hooks/charmhelpers/__init__.py'
=== added directory 'hooks/charmhelpers/contrib'
=== added file 'hooks/charmhelpers/contrib/__init__.py'
=== added directory 'hooks/charmhelpers/contrib/charmhelpers'
=== added file 'hooks/charmhelpers/contrib/charmhelpers/IMPORT'
--- hooks/charmhelpers/contrib/charmhelpers/IMPORT	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/charmhelpers/IMPORT	2013-07-09 03:52:26 +0000
@@ -0,0 +1,4 @@
+Source lp:charm-tools/trunk
+
+charm-tools/helpers/python/charmhelpers/__init__.py -> charmhelpers/charmhelpers/contrib/charmhelpers/__init__.py
+charm-tools/helpers/python/charmhelpers/tests/test_charmhelpers.py -> charmhelpers/tests/contrib/charmhelpers/test_charmhelpers.py

=== added file 'hooks/charmhelpers/contrib/charmhelpers/__init__.py'
--- hooks/charmhelpers/contrib/charmhelpers/__init__.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/charmhelpers/__init__.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,183 @@
+# Copyright 2012 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+import warnings
+warnings.warn("contrib.charmhelpers is deprecated", DeprecationWarning)
+
+"""Helper functions for writing Juju charms in Python."""
+
+__metaclass__ = type
+__all__ = [
+           #'get_config',             # core.hookenv.config()
+           #'log',                    # core.hookenv.log()
+           #'log_entry',              # core.hookenv.log()
+           #'log_exit',               # core.hookenv.log()
+           #'relation_get',           # core.hookenv.relation_get()
+           #'relation_set',           # core.hookenv.relation_set()
+           #'relation_ids',           # core.hookenv.relation_ids()
+           #'relation_list',          # core.hookenv.relation_units()
+           #'config_get',             # core.hookenv.config()
+           #'unit_get',               # core.hookenv.unit_get()
+           #'open_port',              # core.hookenv.open_port()
+           #'close_port',             # core.hookenv.close_port()
+           #'service_control',        # core.host.service()
+           'unit_info',              # client-side, NOT IMPLEMENTED
+           'wait_for_machine',       # client-side, NOT IMPLEMENTED
+           'wait_for_page_contents', # client-side, NOT IMPLEMENTED
+           'wait_for_relation',      # client-side, NOT IMPLEMENTED
+           'wait_for_unit',          # client-side, NOT IMPLEMENTED
+           ]
+
+import operator
+from shelltoolbox import (
+    command,
+)
+import tempfile
+import time
+import urllib2
+import yaml
+
+SLEEP_AMOUNT = 0.1
+# We create a juju_status Command here because it makes testing much,
+# much easier.
+juju_status = lambda: command('juju')('status')
+
+# re-implemented as charmhelpers.fetch.configure_sources()
+#def configure_source(update=False):
+#    source = config_get('source')
+#    if ((source.startswith('ppa:') or
+#         source.startswith('cloud:') or
+#         source.startswith('http:'))):
+#        run('add-apt-repository', source)
+#    if source.startswith("http:"):
+#        run('apt-key', 'import', config_get('key'))
+#    if update:
+#        run('apt-get', 'update')
+
+# DEPRECATED: client-side only
+def make_charm_config_file(charm_config):
+    charm_config_file = tempfile.NamedTemporaryFile()
+    charm_config_file.write(yaml.dump(charm_config))
+    charm_config_file.flush()
+    # The NamedTemporaryFile instance is returned instead of just the name
+    # because we want to take advantage of garbage collection-triggered
+    # deletion of the temp file when it goes out of scope in the caller.
+    return charm_config_file
+
+
+# DEPRECATED: client-side only
+def unit_info(service_name, item_name, data=None, unit=None):
+    if data is None:
+        data = yaml.safe_load(juju_status())
+    service = data['services'].get(service_name)
+    if service is None:
+        # XXX 2012-02-08 gmb:
+        #     This allows us to cope with the race condition that we
+        #     have between deploying a service and having it come up in
+        #     `juju status`. We could probably do with cleaning it up so
+        #     that it fails a bit more noisily after a while.
+        return ''
+    units = service['units']
+    if unit is not None:
+        item = units[unit][item_name]
+    else:
+        # It might seem odd to sort the units here, but we do it to
+        # ensure that when no unit is specified, the first unit for the
+        # service (or at least the one with the lowest number) is the
+        # one whose data gets returned.
+        sorted_unit_names = sorted(units.keys())
+        item = units[sorted_unit_names[0]][item_name]
+    return item
+
+
+# DEPRECATED: client-side only
+def get_machine_data():
+    return yaml.safe_load(juju_status())['machines']
+
+
+# DEPRECATED: client-side only
+def wait_for_machine(num_machines=1, timeout=300):
+    """Wait `timeout` seconds for `num_machines` machines to come up.
+
+    This wait_for... function can be called by other wait_for functions
+    whose timeouts might be too short in situations where only a bare
+    Juju setup has been bootstrapped.
+
+    :return: A tuple of (num_machines, time_taken). This is used for
+             testing.
+    """
+    # You may think this is a hack, and you'd be right. The easiest way
+    # to tell what environment we're working in (LXC vs EC2) is to check
+    # the dns-name of the first machine. If it's localhost we're in LXC
+    # and we can just return here.
+    if get_machine_data()[0]['dns-name'] == 'localhost':
+        return 1, 0
+    start_time = time.time()
+    while True:
+        # Drop the first machine, since it's the Zookeeper and that's
+        # not a machine that we need to wait for. This will only work
+        # for EC2 environments, which is why we return early above if
+        # we're in LXC.
+        machine_data = get_machine_data()
+        non_zookeeper_machines = [
+            machine_data[key] for key in machine_data.keys()[1:]]
+        if len(non_zookeeper_machines) >= num_machines:
+            all_machines_running = True
+            for machine in non_zookeeper_machines:
+                if machine.get('instance-state') != 'running':
+                    all_machines_running = False
+                    break
+            if all_machines_running:
+                break
+        if time.time() - start_time >= timeout:
+            raise RuntimeError('timeout waiting for service to start')
+        time.sleep(SLEEP_AMOUNT)
+    return num_machines, time.time() - start_time
+
+
+# DEPRECATED: client-side only
+def wait_for_unit(service_name, timeout=480):
+    """Wait `timeout` seconds for a given service name to come up."""
+    wait_for_machine(num_machines=1)
+    start_time = time.time()
+    while True:
+        state = unit_info(service_name, 'agent-state')
+        if 'error' in state or state == 'started':
+            break
+        if time.time() - start_time >= timeout:
+            raise RuntimeError('timeout waiting for service to start')
+        time.sleep(SLEEP_AMOUNT)
+    if state != 'started':
+        raise RuntimeError('unit did not start, agent-state: ' + state)
+
+
+# DEPRECATED: client-side only
+def wait_for_relation(service_name, relation_name, timeout=120):
+    """Wait `timeout` seconds for a given relation to come up."""
+    start_time = time.time()
+    while True:
+        relation = unit_info(service_name, 'relations').get(relation_name)
+        if relation is not None and relation['state'] == 'up':
+            break
+        if time.time() - start_time >= timeout:
+            raise RuntimeError('timeout waiting for relation to be up')
+        time.sleep(SLEEP_AMOUNT)
+
+
+# DEPRECATED: client-side only
+def wait_for_page_contents(url, contents, timeout=120, validate=None):
+    if validate is None:
+        validate = operator.contains
+    start_time = time.time()
+    while True:
+        try:
+            stream = urllib2.urlopen(url)
+        except (urllib2.HTTPError, urllib2.URLError):
+            pass
+        else:
+            page = stream.read()
+            if validate(page, contents):
+                return page
+        if time.time() - start_time >= timeout:
+            raise RuntimeError('timeout waiting for contents of ' + url)
+        time.sleep(SLEEP_AMOUNT)

=== added directory 'hooks/charmhelpers/contrib/charmsupport'
=== added file 'hooks/charmhelpers/contrib/charmsupport/IMPORT'
--- hooks/charmhelpers/contrib/charmsupport/IMPORT	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/charmsupport/IMPORT	2013-07-09 03:52:26 +0000
@@ -0,0 +1,14 @@
+Source: lp:charmsupport/trunk
+
+charmsupport/charmsupport/execd.py -> charm-helpers/charmhelpers/contrib/charmsupport/execd.py
+charmsupport/charmsupport/hookenv.py -> charm-helpers/charmhelpers/contrib/charmsupport/hookenv.py
+charmsupport/charmsupport/host.py -> charm-helpers/charmhelpers/contrib/charmsupport/host.py
+charmsupport/charmsupport/nrpe.py -> charm-helpers/charmhelpers/contrib/charmsupport/nrpe.py
+charmsupport/charmsupport/volumes.py -> charm-helpers/charmhelpers/contrib/charmsupport/volumes.py
+
+charmsupport/tests/test_execd.py -> charm-helpers/tests/contrib/charmsupport/test_execd.py
+charmsupport/tests/test_hookenv.py -> charm-helpers/tests/contrib/charmsupport/test_hookenv.py
+charmsupport/tests/test_host.py -> charm-helpers/tests/contrib/charmsupport/test_host.py
+charmsupport/tests/test_nrpe.py -> charm-helpers/tests/contrib/charmsupport/test_nrpe.py
+
+charmsupport/bin/charmsupport -> charm-helpers/bin/contrib/charmsupport/charmsupport

=== added file 'hooks/charmhelpers/contrib/charmsupport/__init__.py'
=== added file 'hooks/charmhelpers/contrib/charmsupport/nrpe.py'
--- hooks/charmhelpers/contrib/charmsupport/nrpe.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/charmsupport/nrpe.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,217 @@
+"""Compatibility with the nrpe-external-master charm"""
+# Copyright 2012 Canonical Ltd.
+#
+# Authors:
+#  Matthew Wedgwood <[e-mail]>
+
+import subprocess
+import pwd
+import grp
+import os
+import re
+import shlex
+import yaml
+
+from charmhelpers.core.hookenv import (
+        config,
+        local_unit,
+        log,
+        relation_ids,
+        relation_set,
+    )
+from charmhelpers.core.host import service
+
+# This module adds compatibility with the nrpe-external-master and plain nrpe
+# subordinate charms. To use it in your charm:
+#
+# 1. Update metadata.yaml
+#
+#   provides:
+#     (...)
+#     nrpe-external-master:
+#       interface: nrpe-external-master
+#       scope: container
+#
+#   and/or
+#
+#   provides:
+#     (...)
+#     local-monitors:
+#       interface: local-monitors
+#       scope: container
+
+#
+# 2. Add the following to config.yaml
+#
+#    nagios_context:
+#      default: "juju"
+#      type: string
+#      description: |
+#        Used by the nrpe subordinate charms.
+#        A string that will be prepended to instance name to set the host name
+#        in nagios. So for instance the hostname would be something like:
+#            juju-myservice-0
+#        If you're running multiple environments with the same services in them
+#        this allows you to differentiate between them.
+#
+# 3. Add custom checks (Nagios plugins) to files/nrpe-external-master
+#
+# 4. Update your hooks.py with something like this:
+#
+#    from charmsupport.nrpe import NRPE
+#    (...)
+#    def update_nrpe_config():
+#        nrpe_compat = NRPE()
+#        nrpe_compat.add_check(
+#            shortname = "myservice",
+#            description = "Check MyService",
+#            check_cmd = "check_http -w 2 -c 10 http://localhost"
+#            )
+#        nrpe_compat.add_check(
+#            "myservice_other",
+#            "Check for widget failures",
+#            check_cmd = "/srv/myapp/scripts/widget_check"
+#            )
+#        nrpe_compat.write()
+#
+#    def config_changed():
+#        (...)
+#        update_nrpe_config()
+#
+#    def nrpe_external_master_relation_changed():
+#        update_nrpe_config()
+#
+#    def local_monitors_relation_changed():
+#        update_nrpe_config()
+#
+# 5. ln -s hooks.py nrpe-external-master-relation-changed
+#    ln -s hooks.py local-monitors-relation-changed
+
+
+class CheckException(Exception):
+    pass
+
+
+class Check(object):
+    shortname_re = '[A-Za-z0-9-_]+$'
+    service_template = ("""
+#---------------------------------------------------
+# This file is Juju managed
+#---------------------------------------------------
+define service {{
+    use                             active-service
+    host_name                       {nagios_hostname}
+    service_description             {nagios_hostname}[{shortname}] """
+                        """{description}
+    check_command                   check_nrpe!{command}
+    servicegroups                   {nagios_servicegroup}
+}}
+""")
+
+    def __init__(self, shortname, description, check_cmd):
+        super(Check, self).__init__()
+        # XXX: could be better to calculate this from the service name
+        if not re.match(self.shortname_re, shortname):
+            raise CheckException("shortname must match {}".format(
+                Check.shortname_re))
+        self.shortname = shortname
+        self.command = "check_{}".format(shortname)
+        # Note: a set of invalid characters is defined by the
+        # Nagios server config
+        # The default is: illegal_object_name_chars=`~!$%^&*"|'<>?,()=
+        self.description = description
+        self.check_cmd = self._locate_cmd(check_cmd)
+
+    def _locate_cmd(self, check_cmd):
+        search_path = (
+            '/',
+            os.path.join(os.environ['CHARM_DIR'],
+                         'files/nrpe-external-master'),
+            '/usr/lib/nagios/plugins',
+        )
+        parts = shlex.split(check_cmd)
+        for path in search_path:
+            if os.path.exists(os.path.join(path, parts[0])):
+                command = os.path.join(path, parts[0])
+                if len(parts) > 1:
+                    command += " " + " ".join(parts[1:])
+                return command
+        log('Check command not found: {}'.format(parts[0]))
+        return ''
+
+    def write(self, nagios_context, hostname):
+        nrpe_check_file = '/etc/nagios/nrpe.d/{}.cfg'.format(
+            self.command)
+        with open(nrpe_check_file, 'w') as nrpe_check_config:
+            nrpe_check_config.write("# check {}\n".format(self.shortname))
+            nrpe_check_config.write("command[{}]={}\n".format(
+                self.command, self.check_cmd))
+
+        if not os.path.exists(NRPE.nagios_exportdir):
+            log('Not writing service config as {} is not accessible'.format(
+                NRPE.nagios_exportdir))
+        else:
+            self.write_service_config(nagios_context, hostname)
+
+    def write_service_config(self, nagios_context, hostname):
+        for f in os.listdir(NRPE.nagios_exportdir):
+            if re.search('.*{}.cfg'.format(self.command), f):
+                os.remove(os.path.join(NRPE.nagios_exportdir, f))
+
+        templ_vars = {
+            'nagios_hostname': hostname,
+            'nagios_servicegroup': nagios_context,
+            'description': self.description,
+            'shortname': self.shortname,
+            'command': self.command,
+            }
+        nrpe_service_text = Check.service_template.format(**templ_vars)
+        nrpe_service_file = '{}/service__{}_{}.cfg'.format(
+            NRPE.nagios_exportdir, hostname, self.command)
+        with open(nrpe_service_file, 'w') as nrpe_service_config:
+            nrpe_service_config.write(str(nrpe_service_text))
+
+    def run(self):
+        subprocess.call(self.check_cmd)
+
+
+class NRPE(object):
+    nagios_logdir = '/var/log/nagios'
+    nagios_exportdir = '/var/lib/nagios/export'
+    nrpe_confdir = '/etc/nagios/nrpe.d'
+
+    def __init__(self):
+        super(NRPE, self).__init__()
+        self.config = config()
+        self.nagios_context = self.config['nagios_context']
+        self.unit_name = local_unit().replace('/', '-')
+        self.hostname = "{}-{}".format(self.nagios_context, self.unit_name)
+        self.checks = []
+
+    def add_check(self, *args, **kwargs):
+        self.checks.append(Check(*args, **kwargs))
+
+    def write(self):
+        try:
+            nagios_uid = pwd.getpwnam('nagios').pw_uid
+            nagios_gid = grp.getgrnam('nagios').gr_gid
+        except:
+            log("Nagios user not set up, nrpe checks not updated")
+            return
+
+        if not os.path.exists(NRPE.nagios_logdir):
+            os.mkdir(NRPE.nagios_logdir)
+            os.chown(NRPE.nagios_logdir, nagios_uid, nagios_gid)
+
+        nrpe_monitors = {}
+        monitors = {"monitors": {"remote": {"nrpe": nrpe_monitors}}}
+        for nrpecheck in self.checks:
+            nrpecheck.write(self.nagios_context, self.hostname)
+            nrpe_monitors[nrpecheck.shortname] = {
+                "command": nrpecheck.command,
+                }
+
+        service('restart', 'nagios-nrpe-server')
+
+        for rid in relation_ids("local-monitors"):
+            relation_set(relation_id=rid, monitors=yaml.dump(monitors))

=== added file 'hooks/charmhelpers/contrib/charmsupport/volumes.py'
--- hooks/charmhelpers/contrib/charmsupport/volumes.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/charmsupport/volumes.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,156 @@
+'''
+Functions for managing volumes in juju units. One volume is supported per unit.
+Subordinates may have their own storage, provided it is on its own partition.
+
+Configuration stanzas:
+  volume-ephemeral:
+    type: boolean
+    default: true
+    description: >
+      If false, a volume is mounted as sepecified in "volume-map"
+      If true, ephemeral storage will be used, meaning that log data
+         will only exist as long as the machine. YOU HAVE BEEN WARNED.
+  volume-map:
+    type: string
+    default: {}
+    description: >
+      YAML map of units to device names, e.g:
+        "{ rsyslog/0: /dev/vdb, rsyslog/1: /dev/vdb }"
+      Service units will raise a configure-error if volume-ephemeral
+      is 'true' and no volume-map value is set. Use 'juju set' to set a
+      value and 'juju resolved' to complete configuration.
+
+Usage:
+    from charmsupport.volumes import configure_volume, VolumeConfigurationError
+    from charmsupport.hookenv import log, ERROR
+    def post_mount_hook():
+        stop_service('myservice')
+    def post_mount_hook():
+        start_service('myservice')
+
+    if __name__ == '__main__':
+        try:
+            configure_volume(before_change=pre_mount_hook,
+                             after_change=post_mount_hook)
+        except VolumeConfigurationError:
+            log('Storage could not be configured', ERROR)
+'''
+
+# XXX: Known limitations
+# - fstab is neither consulted nor updated
+
+import os
+import hookenv
+import host
+import yaml
+
+
+MOUNT_BASE = '/srv/juju/volumes'
+
+
+class VolumeConfigurationError(Exception):
+    '''Volume configuration data is missing or invalid'''
+    pass
+
+
+def get_config():
+    '''Gather and sanity-check volume configuration data'''
+    volume_config = {}
+    config = hookenv.config()
+
+    errors = False
+
+    if config.get('volume-ephemeral') in (True, 'True', 'true', 'Yes', 'yes'):
+        volume_config['ephemeral'] = True
+    else:
+        volume_config['ephemeral'] = False
+
+    try:
+        volume_map = yaml.safe_load(config.get('volume-map', '{}'))
+    except yaml.YAMLError as e:
+        hookenv.log("Error parsing YAML volume-map: {}".format(e),
+                    hookenv.ERROR)
+        errors = True
+    if volume_map is None:
+        # probably an empty string
+        volume_map = {}
+    elif isinstance(volume_map, dict):
+        hookenv.log("Volume-map should be a dictionary, not {}".format(
+            type(volume_map)))
+        errors = True
+
+    volume_config['device'] = volume_map.get(os.environ['JUJU_UNIT_NAME'])
+    if volume_config['device'] and volume_config['ephemeral']:
+        # asked for ephemeral storage but also defined a volume ID
+        hookenv.log('A volume is defined for this unit, but ephemeral '
+                    'storage was requested', hookenv.ERROR)
+        errors = True
+    elif not volume_config['device'] and not volume_config['ephemeral']:
+        # asked for permanent storage but did not define volume ID
+        hookenv.log('Ephemeral storage was requested, but there is no volume '
+                    'defined for this unit.', hookenv.ERROR)
+        errors = True
+
+    unit_mount_name = hookenv.local_unit().replace('/', '-')
+    volume_config['mountpoint'] = os.path.join(MOUNT_BASE, unit_mount_name)
+
+    if errors:
+        return None
+    return volume_config
+
+
+def mount_volume(config):
+    if os.path.exists(config['mountpoint']):
+        if not os.path.isdir(config['mountpoint']):
+            hookenv.log('Not a directory: {}'.format(config['mountpoint']))
+            raise VolumeConfigurationError()
+    else:
+        host.mkdir(config['mountpoint'])
+    if os.path.ismount(config['mountpoint']):
+        unmount_volume(config)
+    if not host.mount(config['device'], config['mountpoint'], persist=True):
+        raise VolumeConfigurationError()
+
+
+def unmount_volume(config):
+    if os.path.ismount(config['mountpoint']):
+        if not host.umount(config['mountpoint'], persist=True):
+            raise VolumeConfigurationError()
+
+
+def managed_mounts():
+    '''List of all mounted managed volumes'''
+    return filter(lambda mount: mount[0].startswith(MOUNT_BASE), host.mounts())
+
+
+def configure_volume(before_change=lambda: None, after_change=lambda: None):
+    '''Set up storage (or don't) according to the charm's volume configuration.
+       Returns the mount point or "ephemeral". before_change and after_change
+       are optional functions to be called if the volume configuration changes.
+    '''
+
+    config = get_config()
+    if not config:
+        hookenv.log('Failed to read volume configuration', hookenv.CRITICAL)
+        raise VolumeConfigurationError()
+
+    if config['ephemeral']:
+        if os.path.ismount(config['mountpoint']):
+            before_change()
+            unmount_volume(config)
+            after_change()
+        return 'ephemeral'
+    else:
+        # persistent storage
+        if os.path.ismount(config['mountpoint']):
+            mounts = dict(managed_mounts())
+            if mounts.get(config['mountpoint']) != config['device']:
+                before_change()
+                unmount_volume(config)
+                mount_volume(config)
+                after_change()
+        else:
+            before_change()
+            mount_volume(config)
+            after_change()
+        return config['mountpoint']

=== added directory 'hooks/charmhelpers/contrib/hahelpers'
=== added file 'hooks/charmhelpers/contrib/hahelpers/IMPORT'
--- hooks/charmhelpers/contrib/hahelpers/IMPORT	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/hahelpers/IMPORT	2013-07-09 03:52:26 +0000
@@ -0,0 +1,7 @@
+Source: lp:~openstack-charmers/openstack-charm-helpers/ha-helpers
+
+ha-helpers/lib/apache_utils.py -> charm-helpers/charmhelpers/contrib/openstackhelpers/apache_utils.py
+ha-helpers/lib/cluster_utils.py -> charm-helpers/charmhelpers/contrib/openstackhelpers/cluster_utils.py
+ha-helpers/lib/ceph_utils.py -> charm-helpers/charmhelpers/contrib/openstackhelpers/ceph_utils.py
+ha-helpers/lib/haproxy_utils.py -> charm-helpers/charmhelpers/contrib/openstackhelpers/haproxy_utils.py
+ha-helpers/lib/utils.py -> charm-helpers/charmhelpers/contrib/openstackhelpers/utils.py

=== added file 'hooks/charmhelpers/contrib/hahelpers/__init__.py'
=== added file 'hooks/charmhelpers/contrib/hahelpers/apache_utils.py'
--- hooks/charmhelpers/contrib/hahelpers/apache_utils.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/hahelpers/apache_utils.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,196 @@
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This file is sourced from lp:openstack-charm-helpers
+#
+# Authors:
+#  James Page <[e-mail]>
+#  Adam Gandelman <[e-mail]>
+#
+
+from hahelpers.utils import (
+    relation_ids,
+    relation_list,
+    relation_get,
+    render_template,
+    juju_log,
+    config_get,
+    install,
+    get_host_ip,
+    restart
+    )
+from hahelpers.cluster_utils import https
+
+import os
+import subprocess
+from base64 import b64decode
+
+APACHE_SITE_DIR = "/etc/apache2/sites-available"
+SITE_TEMPLATE = "apache2_site.tmpl"
+RELOAD_CHECK = "To activate the new configuration"
+
+
+def get_cert():
+    cert = config_get('ssl_cert')
+    key = config_get('ssl_key')
+    if not (cert and key):
+        juju_log('INFO',
+                 "Inspecting identity-service relations for SSL certificate.")
+        cert = key = None
+        for r_id in relation_ids('identity-service'):
+            for unit in relation_list(r_id):
+                if not cert:
+                    cert = relation_get('ssl_cert',
+                                        rid=r_id, unit=unit)
+                if not key:
+                    key = relation_get('ssl_key',
+                                       rid=r_id, unit=unit)
+    return (cert, key)
+
+
+def get_ca_cert():
+    ca_cert = None
+    juju_log('INFO',
+             "Inspecting identity-service relations for CA SSL certificate.")
+    for r_id in relation_ids('identity-service'):
+        for unit in relation_list(r_id):
+            if not ca_cert:
+                ca_cert = relation_get('ca_cert',
+                                       rid=r_id, unit=unit)
+    return ca_cert
+
+
+def install_ca_cert(ca_cert):
+    if ca_cert:
+        with open('/usr/local/share/ca-certificates/keystone_juju_ca_cert.crt',
+                  'w') as crt:
+            crt.write(ca_cert)
+        subprocess.check_call(['update-ca-certificates', '--fresh'])
+
+
+def enable_https(port_maps, namespace, cert, key, ca_cert=None):
+    '''
+    For a given number of port mappings, configures apache2
+    HTTPs local reverse proxying using certficates and keys provided in
+    either configuration data (preferred) or relation data.  Assumes ports
+    are not in use (calling charm should ensure that).
+
+    port_maps: dict: external to internal port mappings
+    namespace: str: name of charm
+    '''
+    def _write_if_changed(path, new_content):
+        content = None
+        if os.path.exists(path):
+            with open(path, 'r') as f:
+                content = f.read().strip()
+        if content != new_content:
+            with open(path, 'w') as f:
+                f.write(new_content)
+            return True
+        else:
+            return False
+
+    juju_log('INFO', "Enabling HTTPS for port mappings: {}".format(port_maps))
+    http_restart = False
+
+    if cert:
+        cert = b64decode(cert)
+    if key:
+        key = b64decode(key)
+    if ca_cert:
+        ca_cert = b64decode(ca_cert)
+
+    if not cert and not key:
+        juju_log('ERROR',
+                 "Expected but could not find SSL certificate data, not "
+                 "configuring HTTPS!")
+        return False
+
+    install('apache2')
+    if RELOAD_CHECK in subprocess.check_output(['a2enmod', 'ssl',
+                                                'proxy', 'proxy_http']):
+        http_restart = True
+
+    ssl_dir = os.path.join('/etc/apache2/ssl', namespace)
+    if not os.path.exists(ssl_dir):
+        os.makedirs(ssl_dir)
+
+    if (_write_if_changed(os.path.join(ssl_dir, 'cert'), cert)):
+        http_restart = True
+    if (_write_if_changed(os.path.join(ssl_dir, 'key'), key)):
+        http_restart = True
+    os.chmod(os.path.join(ssl_dir, 'key'), 0600)
+
+    install_ca_cert(ca_cert)
+
+    sites_dir = '/etc/apache2/sites-available'
+    for ext_port, int_port in port_maps.items():
+        juju_log('INFO',
+                 'Creating apache2 reverse proxy vhost'
+                 ' for {}:{}'.format(ext_port,
+                                     int_port))
+        site = "{}_{}".format(namespace, ext_port)
+        site_path = os.path.join(sites_dir, site)
+        with open(site_path, 'w') as fsite:
+            context = {
+                "ext": ext_port,
+                "int": int_port,
+                "namespace": namespace,
+                "private_address": get_host_ip()
+                }
+            fsite.write(render_template(SITE_TEMPLATE,
+                                        context))
+
+        if RELOAD_CHECK in subprocess.check_output(['a2ensite', site]):
+            http_restart = True
+
+    if http_restart:
+        restart('apache2')
+
+    return True
+
+
+def disable_https(port_maps, namespace):
+    '''
+    Ensure HTTPS reverse proxying is disables for given port mappings
+
+    port_maps: dict: of ext -> int port mappings
+    namespace: str: name of chamr
+    '''
+    juju_log('INFO', 'Ensuring HTTPS disabled for {}'.format(port_maps))
+
+    if (not os.path.exists('/etc/apache2') or
+        not os.path.exists(os.path.join('/etc/apache2/ssl', namespace))):
+        return
+
+    http_restart = False
+    for ext_port in port_maps.keys():
+        if os.path.exists(os.path.join(APACHE_SITE_DIR,
+                                       "{}_{}".format(namespace,
+                                                      ext_port))):
+            juju_log('INFO',
+                     "Disabling HTTPS reverse proxy"
+                     " for {} {}.".format(namespace,
+                                          ext_port))
+            if (RELOAD_CHECK in
+                subprocess.check_output(['a2dissite',
+                                         '{}_{}'.format(namespace,
+                                                        ext_port)])):
+                http_restart = True
+
+    if http_restart:
+        restart(['apache2'])
+
+
+def setup_https(port_maps, namespace, cert, key, ca_cert=None):
+    '''
+    Ensures HTTPS is either enabled or disabled for given port
+    mapping.
+
+    port_maps: dict: of ext -> int port mappings
+    namespace: str: name of charm
+    '''
+    if not https:
+        disable_https(port_maps, namespace)
+    else:
+        enable_https(port_maps, namespace, cert, key, ca_cert)

=== added file 'hooks/charmhelpers/contrib/hahelpers/ceph_utils.py'
--- hooks/charmhelpers/contrib/hahelpers/ceph_utils.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/hahelpers/ceph_utils.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,256 @@
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This file is sourced from lp:openstack-charm-helpers
+#
+# Authors:
+#  James Page <[e-mail]>
+#  Adam Gandelman <[e-mail]>
+#
+
+import commands
+import subprocess
+import os
+import shutil
+import hahelpers.utils as utils
+
+KEYRING = '/etc/ceph/ceph.client.%s.keyring'
+KEYFILE = '/etc/ceph/ceph.client.%s.key'
+
+CEPH_CONF = """[global]
+ auth supported = %(auth)s
+ keyring = %(keyring)s
+ mon host = %(mon_hosts)s
+"""
+
+
+def execute(cmd):
+    subprocess.check_call(cmd)
+
+
+def execute_shell(cmd):
+    subprocess.check_call(cmd, shell=True)
+
+
+def install():
+    ceph_dir = "/etc/ceph"
+    if not os.path.isdir(ceph_dir):
+        os.mkdir(ceph_dir)
+    utils.install('ceph-common')
+
+
+def rbd_exists(service, pool, rbd_img):
+    (rc, out) = commands.getstatusoutput('rbd list --id %s --pool %s' %\
+                                         (service, pool))
+    return rbd_img in out
+
+
+def create_rbd_image(service, pool, image, sizemb):
+    cmd = [
+        'rbd',
+        'create',
+        image,
+        '--size',
+        str(sizemb),
+        '--id',
+        service,
+        '--pool',
+        pool
+        ]
+    execute(cmd)
+
+
+def pool_exists(service, name):
+    (rc, out) = commands.getstatusoutput("rados --id %s lspools" % service)
+    return name in out
+
+
+def create_pool(service, name):
+    cmd = [
+        'rados',
+        '--id',
+        service,
+        'mkpool',
+        name
+        ]
+    execute(cmd)
+
+
+def keyfile_path(service):
+    return KEYFILE % service
+
+
+def keyring_path(service):
+    return KEYRING % service
+
+
+def create_keyring(service, key):
+    keyring = keyring_path(service)
+    if os.path.exists(keyring):
+        utils.juju_log('INFO', 'ceph: Keyring exists at %s.' % keyring)
+    cmd = [
+        'ceph-authtool',
+        keyring,
+        '--create-keyring',
+        '--name=client.%s' % service,
+        '--add-key=%s' % key
+        ]
+    execute(cmd)
+    utils.juju_log('INFO', 'ceph: Created new ring at %s.' % keyring)
+
+
+def create_key_file(service, key):
+    # create a file containing the key
+    keyfile = keyfile_path(service)
+    if os.path.exists(keyfile):
+        utils.juju_log('INFO', 'ceph: Keyfile exists at %s.' % keyfile)
+    fd = open(keyfile, 'w')
+    fd.write(key)
+    fd.close()
+    utils.juju_log('INFO', 'ceph: Created new keyfile at %s.' % keyfile)
+
+
+def get_ceph_nodes():
+    hosts = []
+    for r_id in utils.relation_ids('ceph'):
+        for unit in utils.relation_list(r_id):
+            hosts.append(utils.relation_get('private-address',
+                                            unit=unit, rid=r_id))
+    return hosts
+
+
+def configure(service, key, auth):
+    create_keyring(service, key)
+    create_key_file(service, key)
+    hosts = get_ceph_nodes()
+    mon_hosts = ",".join(map(str, hosts))
+    keyring = keyring_path(service)
+    with open('/etc/ceph/ceph.conf', 'w') as ceph_conf:
+        ceph_conf.write(CEPH_CONF % locals())
+    modprobe_kernel_module('rbd')
+
+
+def image_mapped(image_name):
+    (rc, out) = commands.getstatusoutput('rbd showmapped')
+    return image_name in out
+
+
+def map_block_storage(service, pool, image):
+    cmd = [
+        'rbd',
+        'map',
+        '%s/%s' % (pool, image),
+        '--user',
+        service,
+        '--secret',
+        keyfile_path(service),
+        ]
+    execute(cmd)
+
+
+def filesystem_mounted(fs):
+    return subprocess.call(['grep', '-wqs', fs, '/proc/mounts']) == 0
+
+
+def make_filesystem(blk_device, fstype='ext4'):
+    utils.juju_log('INFO',
+                   'ceph: Formatting block device %s as filesystem %s.' %\
+                   (blk_device, fstype))
+    cmd = ['mkfs', '-t', fstype, blk_device]
+    execute(cmd)
+
+
+def place_data_on_ceph(service, blk_device, data_src_dst, fstype='ext4'):
+    # mount block device into /mnt
+    cmd = ['mount', '-t', fstype, blk_device, '/mnt']
+    execute(cmd)
+
+    # copy data to /mnt
+    try:
+        copy_files(data_src_dst, '/mnt')
+    except:
+        pass
+
+    # umount block device
+    cmd = ['umount', '/mnt']
+    execute(cmd)
+
+    _dir = os.stat(data_src_dst)
+    uid = _dir.st_uid
+    gid = _dir.st_gid
+
+    # re-mount where the data should originally be
+    cmd = ['mount', '-t', fstype, blk_device, data_src_dst]
+    execute(cmd)
+
+    # ensure original ownership of new mount.
+    cmd = ['chown', '-R', '%s:%s' % (uid, gid), data_src_dst]
+    execute(cmd)
+
+
+# TODO: re-use
+def modprobe_kernel_module(module):
+    utils.juju_log('INFO', 'Loading kernel module')
+    cmd = ['modprobe', module]
+    execute(cmd)
+    cmd = 'echo %s >> /etc/modules' % module
+    execute_shell(cmd)
+
+
+def copy_files(src, dst, symlinks=False, ignore=None):
+    for item in os.listdir(src):
+        s = os.path.join(src, item)
+        d = os.path.join(dst, item)
+        if os.path.isdir(s):
+            shutil.copytree(s, d, symlinks, ignore)
+        else:
+            shutil.copy2(s, d)
+
+
+def ensure_ceph_storage(service, pool, rbd_img, sizemb, mount_point,
+                        blk_device, fstype, system_services=[]):
+    """
+    To be called from the current cluster leader.
+    Ensures given pool and RBD image exists, is mapped to a block device,
+    and the device is formatted and mounted at the given mount_point.
+
+    If formatting a device for the first time, data existing at mount_point
+    will be migrated to the RBD device before being remounted.
+
+    All services listed in system_services will be stopped prior to data
+    migration and restarted when complete.
+    """
+    # Ensure pool, RBD image, RBD mappings are in place.
+    if not pool_exists(service, pool):
+        utils.juju_log('INFO', 'ceph: Creating new pool %s.' % pool)
+        create_pool(service, pool)
+
+    if not rbd_exists(service, pool, rbd_img):
+        utils.juju_log('INFO', 'ceph: Creating RBD image (%s).' % rbd_img)
+        create_rbd_image(service, pool, rbd_img, sizemb)
+
+    if not image_mapped(rbd_img):
+        utils.juju_log('INFO', 'ceph: Mapping RBD Image as a Block Device.')
+        map_block_storage(service, pool, rbd_img)
+
+    # make file system
+    # TODO: What happens if for whatever reason this is run again and
+    # the data is already in the rbd device and/or is mounted??
+    # When it is mounted already, it will fail to make the fs
+    # XXX: This is really sketchy!  Need to at least add an fstab entry
+    #      otherwise this hook will blow away existing data if its executed
+    #      after a reboot.
+    if not filesystem_mounted(mount_point):
+        make_filesystem(blk_device, fstype)
+
+        for svc in system_services:
+            if utils.running(svc):
+                utils.juju_log('INFO',
+                               'Stopping services %s prior to migrating '\
+                               'data' % svc)
+                utils.stop(svc)
+
+        place_data_on_ceph(service, blk_device, mount_point, fstype)
+
+        for svc in system_services:
+            utils.start(svc)

=== added file 'hooks/charmhelpers/contrib/hahelpers/cluster_utils.py'
--- hooks/charmhelpers/contrib/hahelpers/cluster_utils.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/hahelpers/cluster_utils.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,130 @@
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This file is sourced from lp:openstack-charm-helpers
+#
+# Authors:
+#  James Page <[e-mail]>
+#  Adam Gandelman <[e-mail]>
+#
+
+from hahelpers.utils import (
+    juju_log,
+    relation_ids,
+    relation_list,
+    relation_get,
+    get_unit_hostname,
+    config_get
+    )
+import subprocess
+import os
+
+
+def is_clustered():
+    for r_id in (relation_ids('ha') or []):
+        for unit in (relation_list(r_id) or []):
+            clustered = relation_get('clustered',
+                                     rid=r_id,
+                                     unit=unit)
+            if clustered:
+                return True
+    return False
+
+
+def is_leader(resource):
+    cmd = [
+        "crm", "resource",
+        "show", resource
+        ]
+    try:
+        status = subprocess.check_output(cmd)
+    except subprocess.CalledProcessError:
+        return False
+    else:
+        if get_unit_hostname() in status:
+            return True
+        else:
+            return False
+
+
+def peer_units():
+    peers = []
+    for r_id in (relation_ids('cluster') or []):
+        for unit in (relation_list(r_id) or []):
+            peers.append(unit)
+    return peers
+
+
+def oldest_peer(peers):
+    local_unit_no = int(os.getenv('JUJU_UNIT_NAME').split('/')[1])
+    for peer in peers:
+        remote_unit_no = int(peer.split('/')[1])
+        if remote_unit_no < local_unit_no:
+            return False
+    return True
+
+
+def eligible_leader(resource):
+    if is_clustered():
+        if not is_leader(resource):
+            juju_log('INFO', 'Deferring action to CRM leader.')
+            return False
+    else:
+        peers = peer_units()
+        if peers and not oldest_peer(peers):
+            juju_log('INFO', 'Deferring action to oldest service unit.')
+            return False
+    return True
+
+
+def https():
+    '''
+    Determines whether enough data has been provided in configuration
+    or relation data to configure HTTPS
+    .
+    returns: boolean
+    '''
+    if config_get('use-https') == "yes":
+        return True
+    if config_get('ssl_cert') and config_get('ssl_key'):
+        return True
+    for r_id in relation_ids('identity-service'):
+        for unit in relation_list(r_id):
+            if (relation_get('https_keystone', rid=r_id, unit=unit) and
+                relation_get('ssl_cert', rid=r_id, unit=unit) and
+                relation_get('ssl_key', rid=r_id, unit=unit) and
+                relation_get('ca_cert', rid=r_id, unit=unit)):
+                return True
+    return False
+
+
+def determine_api_port(public_port):
+    '''
+    Determine correct API server listening port based on
+    existence of HTTPS reverse proxy and/or haproxy.
+
+    public_port: int: standard public port for given service
+
+    returns: int: the correct listening port for the API service
+    '''
+    i = 0
+    if len(peer_units()) > 0 or is_clustered():
+        i += 1
+    if https():
+        i += 1
+    return public_port - (i * 10)
+
+
+def determine_haproxy_port(public_port):
+    '''
+    Description: Determine correct proxy listening port based on public IP +
+    existence of HTTPS reverse proxy.
+
+    public_port: int: standard public port for given service
+
+    returns: int: the correct listening port for the HAProxy service
+    '''
+    i = 0
+    if https():
+        i += 1
+    return public_port - (i * 10)

=== added file 'hooks/charmhelpers/contrib/hahelpers/haproxy_utils.py'
--- hooks/charmhelpers/contrib/hahelpers/haproxy_utils.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/hahelpers/haproxy_utils.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,55 @@
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This file is sourced from lp:openstack-charm-helpers
+#
+# Authors:
+#  James Page <[e-mail]>
+#  Adam Gandelman <[e-mail]>
+#
+
+from lib.utils import (
+    relation_ids,
+    relation_list,
+    relation_get,
+    unit_get,
+    reload,
+    render_template
+    )
+import os
+
+HAPROXY_CONF = '/etc/haproxy/haproxy.cfg'
+HAPROXY_DEFAULT = '/etc/default/haproxy'
+
+
+def configure_haproxy(service_ports):
+    '''
+    Configure HAProxy based on the current peers in the service
+    cluster using the provided port map:
+
+        "swift": [ 8080, 8070 ]
+
+    HAproxy will also be reloaded/started if required
+
+    service_ports: dict: dict of lists of [ frontend, backend ]
+    '''
+    cluster_hosts = {}
+    cluster_hosts[os.getenv('JUJU_UNIT_NAME').replace('/', '-')] = \
+        unit_get('private-address')
+    for r_id in relation_ids('cluster'):
+        for unit in relation_list(r_id):
+            cluster_hosts[unit.replace('/', '-')] = \
+                relation_get(attribute='private-address',
+                             rid=r_id,
+                             unit=unit)
+    context = {
+        'units': cluster_hosts,
+        'service_ports': service_ports
+        }
+    with open(HAPROXY_CONF, 'w') as f:
+        f.write(render_template(os.path.basename(HAPROXY_CONF),
+                                context))
+    with open(HAPROXY_DEFAULT, 'w') as f:
+        f.write('ENABLED=1')
+
+    reload('haproxy')

=== added file 'hooks/charmhelpers/contrib/hahelpers/utils.py'
--- hooks/charmhelpers/contrib/hahelpers/utils.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/hahelpers/utils.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,332 @@
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This file is sourced from lp:openstack-charm-helpers
+#
+# Authors:
+#  James Page <[e-mail]>
+#  Paul Collins <[e-mail]>
+#  Adam Gandelman <[e-mail]>
+#
+
+import json
+import os
+import subprocess
+import socket
+import sys
+
+
+def do_hooks(hooks):
+    hook = os.path.basename(sys.argv[0])
+
+    try:
+        hook_func = hooks[hook]
+    except KeyError:
+        juju_log('INFO',
+                 "This charm doesn't know how to handle '{}'.".format(hook))
+    else:
+        hook_func()
+
+
+def install(*pkgs):
+    cmd = [
+        'apt-get',
+        '-y',
+        'install'
+          ]
+    for pkg in pkgs:
+        cmd.append(pkg)
+    subprocess.check_call(cmd)
+
+TEMPLATES_DIR = 'templates'
+
+try:
+    import jinja2
+except ImportError:
+    install('python-jinja2')
+    import jinja2
+
+try:
+    import dns.resolver
+except ImportError:
+    install('python-dnspython')
+    import dns.resolver
+
+
+def render_template(template_name, context, template_dir=TEMPLATES_DIR):
+    templates = jinja2.Environment(
+                    loader=jinja2.FileSystemLoader(template_dir)
+                    )
+    template = templates.get_template(template_name)
+    return template.render(context)
+
+CLOUD_ARCHIVE = \
+""" # Ubuntu Cloud Archive
+deb http://ubuntu-cloud.archive.canonical.com/ubuntu {} main
+"""
+
+CLOUD_ARCHIVE_POCKETS = {
+    'folsom': 'precise-updates/folsom',
+    'folsom/updates': 'precise-updates/folsom',
+    'folsom/proposed': 'precise-proposed/folsom',
+    'grizzly': 'precise-updates/grizzly',
+    'grizzly/updates': 'precise-updates/grizzly',
+    'grizzly/proposed': 'precise-proposed/grizzly'
+    }
+
+
+def configure_source():
+    source = str(config_get('openstack-origin'))
+    if not source:
+        return
+    if source.startswith('ppa:'):
+        cmd = [
+            'add-apt-repository',
+            source
+            ]
+        subprocess.check_call(cmd)
+    if source.startswith('cloud:'):
+        # CA values should be formatted as cloud:ubuntu-openstack/pocket, eg:
+        #   cloud:precise-folsom/updates or cloud:precise-folsom/proposed
+        install('ubuntu-cloud-keyring')
+        pocket = source.split(':')[1]
+        pocket = pocket.split('-')[1]
+        with open('/etc/apt/sources.list.d/cloud-archive.list', 'w') as apt:
+            apt.write(CLOUD_ARCHIVE.format(CLOUD_ARCHIVE_POCKETS[pocket]))
+    if source.startswith('deb'):
+        l = len(source.split('|'))
+        if l == 2:
+            (apt_line, key) = source.split('|')
+            cmd = [
+                'apt-key',
+                'adv', '--keyserver keyserver.ubuntu.com',
+                '--recv-keys', key
+                ]
+            subprocess.check_call(cmd)
+        elif l == 1:
+            apt_line = source
+
+        with open('/etc/apt/sources.list.d/quantum.list', 'w') as apt:
+            apt.write(apt_line + "\n")
+    cmd = [
+        'apt-get',
+        'update'
+        ]
+    subprocess.check_call(cmd)
+
+# Protocols
+TCP = 'TCP'
+UDP = 'UDP'
+
+
+def expose(port, protocol='TCP'):
+    cmd = [
+        'open-port',
+        '{}/{}'.format(port, protocol)
+        ]
+    subprocess.check_call(cmd)
+
+
+def juju_log(severity, message):
+    cmd = [
+        'juju-log',
+        '--log-level', severity,
+        message
+        ]
+    subprocess.check_call(cmd)
+
+
+cache = {}
+
+
+def cached(func):
+    def wrapper(*args, **kwargs):
+        global cache
+        key = str((func, args, kwargs))
+        try:
+            return cache[key]
+        except KeyError:
+            res = func(*args, **kwargs)
+            cache[key] = res
+            return res
+    return wrapper
+
+
+@cached
+def relation_ids(relation):
+    cmd = [
+        'relation-ids',
+        relation
+        ]
+    result = str(subprocess.check_output(cmd)).split()
+    if result == "":
+        return None
+    else:
+        return result
+
+
+@cached
+def relation_list(rid):
+    cmd = [
+        'relation-list',
+        '-r', rid,
+        ]
+    result = str(subprocess.check_output(cmd)).split()
+    if result == "":
+        return None
+    else:
+        return result
+
+
+@cached
+def relation_get(attribute, unit=None, rid=None):
+    cmd = [
+        'relation-get',
+        ]
+    if rid:
+        cmd.append('-r')
+        cmd.append(rid)
+    cmd.append(attribute)
+    if unit:
+        cmd.append(unit)
+    value = subprocess.check_output(cmd).strip()  # IGNORE:E1103
+    if value == "":
+        return None
+    else:
+        return value
+
+
+@cached
+def relation_get_dict(relation_id=None, remote_unit=None):
+    """Obtain all relation data as dict by way of JSON"""
+    cmd = [
+        'relation-get', '--format=json'
+        ]
+    if relation_id:
+        cmd.append('-r')
+        cmd.append(relation_id)
+    if remote_unit:
+        remote_unit_orig = os.getenv('JUJU_REMOTE_UNIT', None)
+        os.environ['JUJU_REMOTE_UNIT'] = remote_unit
+    j = subprocess.check_output(cmd)
+    if remote_unit and remote_unit_orig:
+        os.environ['JUJU_REMOTE_UNIT'] = remote_unit_orig
+    d = json.loads(j)
+    settings = {}
+    # convert unicode to strings
+    for k, v in d.iteritems():
+        settings[str(k)] = str(v)
+    return settings
+
+
+def relation_set(**kwargs):
+    cmd = [
+        'relation-set'
+        ]
+    args = []
+    for k, v in kwargs.items():
+        if k == 'rid':
+            if v:
+                cmd.append('-r')
+                cmd.append(v)
+        else:
+            args.append('{}={}'.format(k, v))
+    cmd += args
+    subprocess.check_call(cmd)
+
+
+@cached
+def unit_get(attribute):
+    cmd = [
+        'unit-get',
+        attribute
+        ]
+    value = subprocess.check_output(cmd).strip()  # IGNORE:E1103
+    if value == "":
+        return None
+    else:
+        return value
+
+
+@cached
+def config_get(attribute):
+    cmd = [
+        'config-get',
+        '--format',
+        'json',
+        ]
+    out = subprocess.check_output(cmd).strip()  # IGNORE:E1103
+    cfg = json.loads(out)
+
+    try:
+        return cfg[attribute]
+    except KeyError:
+        return None
+
+
+@cached
+def get_unit_hostname():
+    return socket.gethostname()
+
+
+@cached
+def get_host_ip(hostname=unit_get('private-address')):
+    try:
+        # Test to see if already an IPv4 address
+        socket.inet_aton(hostname)
+        return hostname
+    except socket.error:
+        answers = dns.resolver.query(hostname, 'A')
+        if answers:
+            return answers[0].address
+    return None
+
+
+def _svc_control(service, action):
+    subprocess.check_call(['service', service, action])
+
+
+def restart(*services):
+    for service in services:
+        _svc_control(service, 'restart')
+
+
+def stop(*services):
+    for service in services:
+        _svc_control(service, 'stop')
+
+
+def start(*services):
+    for service in services:
+        _svc_control(service, 'start')
+
+
+def reload(*services):
+    for service in services:
+        try:
+            _svc_control(service, 'reload')
+        except subprocess.CalledProcessError:
+            # Reload failed - either service does not support reload
+            # or it was not running - restart will fixup most things
+            _svc_control(service, 'restart')
+
+
+def running(service):
+    try:
+        output = subprocess.check_output(['service', service, 'status'])
+    except subprocess.CalledProcessError:
+        return False
+    else:
+        if ("start/running" in output or
+            "is running" in output):
+            return True
+        else:
+            return False
+
+
+def is_relation_made(relation, key='private-address'):
+    for r_id in (relation_ids(relation) or []):
+        for unit in (relation_list(r_id) or []):
+            if relation_get(key, rid=r_id, unit=unit):
+                return True
+    return False

=== added directory 'hooks/charmhelpers/contrib/jujugui'
=== added file 'hooks/charmhelpers/contrib/jujugui/IMPORT'
--- hooks/charmhelpers/contrib/jujugui/IMPORT	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/jujugui/IMPORT	2013-07-09 03:52:26 +0000
@@ -0,0 +1,4 @@
+Source: lp:charms/juju-gui
+
+juju-gui/hooks/utils.py -> charm-helpers/charmhelpers/contrib/jujugui/utils.py
+juju-gui/tests/test_utils.py -> charm-helpers/tests/contrib/jujugui/test_utils.py

=== added file 'hooks/charmhelpers/contrib/jujugui/__init__.py'
=== added file 'hooks/charmhelpers/contrib/jujugui/utils.py'
--- hooks/charmhelpers/contrib/jujugui/utils.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/jujugui/utils.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,602 @@
+"""Juju GUI charm utilities."""
+
+__all__ = [
+    'AGENT',
+    'APACHE',
+    'API_PORT',
+    'CURRENT_DIR',
+    'HAPROXY',
+    'IMPROV',
+    'JUJU_DIR',
+    'JUJU_GUI_DIR',
+    'JUJU_GUI_SITE',
+    'JUJU_PEM',
+    'WEB_PORT',
+    'bzr_checkout',
+    'chain',
+    'cmd_log',
+    'fetch_api',
+    'fetch_gui',
+    'find_missing_packages',
+    'first_path_in_dir',
+    'get_api_address',
+    'get_npm_cache_archive_url',
+    'get_release_file_url',
+    'get_staging_dependencies',
+    'get_zookeeper_address',
+    'legacy_juju',
+    'log_hook',
+    'merge',
+    'parse_source',
+    'prime_npm_cache',
+    'render_to_file',
+    'save_or_create_certificates',
+    'setup_apache',
+    'setup_gui',
+    'start_agent',
+    'start_gui',
+    'start_improv',
+    'write_apache_config',
+]
+
+from contextlib import contextmanager
+import errno
+import json
+import os
+import logging
+import shutil
+from subprocess import CalledProcessError
+import tempfile
+from urlparse import urlparse
+
+import apt
+import tempita
+
+from launchpadlib.launchpad import Launchpad
+from shelltoolbox import (
+    Serializer,
+    apt_get_install,
+    command,
+    environ,
+    install_extra_repositories,
+    run,
+    script_name,
+    search_file,
+    su,
+)
+from charmhelpers.core.host import (
+    service_start,
+)
+from charmhelpers.core.hookenv import (
+    log,
+    config,
+    unit_get,
+)
+
+
+AGENT = 'juju-api-agent'
+APACHE = 'apache2'
+IMPROV = 'juju-api-improv'
+HAPROXY = 'haproxy'
+
+API_PORT = 8080
+WEB_PORT = 8000
+
+CURRENT_DIR = os.getcwd()
+JUJU_DIR = os.path.join(CURRENT_DIR, 'juju')
+JUJU_GUI_DIR = os.path.join(CURRENT_DIR, 'juju-gui')
+JUJU_GUI_SITE = '/etc/apache2/sites-available/juju-gui'
+JUJU_GUI_PORTS = '/etc/apache2/ports.conf'
+JUJU_PEM = 'juju.includes-private-key.pem'
+BUILD_REPOSITORIES = ('ppa:chris-lea/node.js-legacy',)
+DEB_BUILD_DEPENDENCIES = (
+    'bzr', 'imagemagick', 'make',  'nodejs', 'npm',
+)
+DEB_STAGE_DEPENDENCIES = (
+    'zookeeper',
+)
+
+
+# Store the configuration from on invocation to the next.
+config_json = Serializer('/tmp/config.json')
+# Bazaar checkout command.
+bzr_checkout = command('bzr', 'co', '--lightweight')
+# Whether or not the charm is deployed using juju-core.
+# If juju-core has been used to deploy the charm, an agent.conf file must
+# be present in the charm parent directory.
+legacy_juju = lambda: not os.path.exists(
+    os.path.join(CURRENT_DIR, '..', 'agent.conf'))
+
+
+def _get_build_dependencies():
+    """Install deb dependencies for building."""
+    log('Installing build dependencies.')
+    cmd_log(install_extra_repositories(*BUILD_REPOSITORIES))
+    cmd_log(apt_get_install(*DEB_BUILD_DEPENDENCIES))
+
+
+def get_api_address(unit_dir):
+    """Return the Juju API address stored in the uniter agent.conf file."""
+    import yaml  # python-yaml is only installed if juju-core is used.
+    # XXX 2013-03-27 frankban bug=1161443:
+        # currently the uniter agent.conf file does not include the API
+        # address. For now retrieve it from the machine agent file.
+    base_dir = os.path.abspath(os.path.join(unit_dir, '..'))
+    for dirname in os.listdir(base_dir):
+        if dirname.startswith('machine-'):
+            agent_conf = os.path.join(base_dir, dirname, 'agent.conf')
+            break
+    else:
+        raise IOError('Juju agent configuration file not found.')
+    contents = yaml.load(open(agent_conf))
+    return contents['apiinfo']['addrs'][0]
+
+
+def get_staging_dependencies():
+    """Install deb dependencies for the stage (improv) environment."""
+    log('Installing stage dependencies.')
+    cmd_log(apt_get_install(*DEB_STAGE_DEPENDENCIES))
+
+
+def first_path_in_dir(directory):
+    """Return the full path of the first file/dir in *directory*."""
+    return os.path.join(directory, os.listdir(directory)[0])
+
+
+def _get_by_attr(collection, attr, value):
+    """Return the first item in collection having attr == value.
+
+    Return None if the item is not found.
+    """
+    for item in collection:
+        if getattr(item, attr) == value:
+            return item
+
+
+def get_release_file_url(project, series_name, release_version):
+    """Return the URL of the release file hosted in Launchpad.
+
+    The returned URL points to a release file for the given project, series
+    name and release version.
+    The argument *project* is a project object as returned by launchpadlib.
+    The arguments *series_name* and *release_version* are strings. If
+    *release_version* is None, the URL of the latest release will be returned.
+    """
+    series = _get_by_attr(project.series, 'name', series_name)
+    if series is None:
+        raise ValueError('%r: series not found' % series_name)
+    # Releases are returned by Launchpad in reverse date order.
+    releases = list(series.releases)
+    if not releases:
+        raise ValueError('%r: series does not contain releases' % series_name)
+    if release_version is not None:
+        release = _get_by_attr(releases, 'version', release_version)
+        if release is None:
+            raise ValueError('%r: release not found' % release_version)
+        releases = [release]
+    for release in releases:
+        for file_ in release.files:
+            if str(file_).endswith('.tgz'):
+                return file_.file_link
+    raise ValueError('%r: file not found' % release_version)
+
+
+def get_zookeeper_address(agent_file_path):
+    """Retrieve the Zookeeper address contained in the given *agent_file_path*.
+
+    The *agent_file_path* is a path to a file containing a line similar to the
+    following::
+
+        env JUJU_ZOOKEEPER="address"
+    """
+    line = search_file('JUJU_ZOOKEEPER', agent_file_path).strip()
+    return line.split('=')[1].strip('"')
+
+
+@contextmanager
+def log_hook():
+    """Log when a hook starts and stops its execution.
+
+    Also log to stdout possible CalledProcessError exceptions raised executing
+    the hook.
+    """
+    script = script_name()
+    log(">>> Entering {}".format(script))
+    try:
+        yield
+    except CalledProcessError as err:
+        log('Exception caught:')
+        log(err.output)
+        raise
+    finally:
+        log("<<< Exiting {}".format(script))
+
+
+def parse_source(source):
+    """Parse the ``juju-gui-source`` option.
+
+    Return a tuple of two elements representing info on how to deploy Juju GUI.
+    Examples:
+       - ('stable', None): latest stable release;
+       - ('stable', '0.1.0'): stable release v0.1.0;
+       - ('trunk', None): latest trunk release;
+       - ('trunk', '0.1.0+build.1'): trunk release v0.1.0 bzr revision 1;
+       - ('branch', 'lp:juju-gui'): release is made from a branch;
+       - ('url', 'http://example.com/gui'): release from a downloaded file.
+    """
+    if source.startswith('url:'):
+        source = source[4:]
+        # Support file paths, including relative paths.
+        if urlparse(source).scheme == '':
+            if not source.startswith('/'):
+                source = os.path.join(os.path.abspath(CURRENT_DIR), source)
+            source = "file://%s" % source
+        return 'url', source
+    if source in ('stable', 'trunk'):
+        return source, None
+    if source.startswith('lp:') or source.startswith('http://'):
+        return 'branch', source
+    if 'build' in source:
+        return 'trunk', source
+    return 'stable', source
+
+
+def render_to_file(template_name, context, destination):
+    """Render the given *template_name* into *destination* using *context*.
+
+    The tempita template language is used to render contents
+    (see http://pythonpaste.org/tempita/).
+    The argument *template_name* is the name or path of the template file:
+    it may be either a path relative to ``../config`` or an absolute path.
+    The argument *destination* is a file path.
+    The argument *context* is a dict-like object.
+    """
+    template_path = os.path.abspath(template_name)
+    template = tempita.Template.from_filename(template_path)
+    with open(destination, 'w') as stream:
+        stream.write(template.substitute(context))
+
+
+results_log = None
+
+
+def _setupLogging():
+    global results_log
+    if results_log is not None:
+        return
+    cfg = config()
+    logging.basicConfig(
+        filename=cfg['command-log-file'],
+        level=logging.INFO,
+        format="%(asctime)s: %(name)s@%(levelname)s %(message)s")
+    results_log = logging.getLogger('juju-gui')
+
+
+def cmd_log(results):
+    global results_log
+    if not results:
+        return
+    if results_log is None:
+        _setupLogging()
+    # Since 'results' may be multi-line output, start it on a separate line
+    # from the logger timestamp, etc.
+    results_log.info('\n' + results)
+
+
+def start_improv(staging_env, ssl_cert_path,
+                 config_path='/etc/init/juju-api-improv.conf'):
+    """Start a simulated juju environment using ``improv.py``."""
+    log('Setting up staging start up script.')
+    context = {
+        'juju_dir': JUJU_DIR,
+        'keys': ssl_cert_path,
+        'port': API_PORT,
+        'staging_env': staging_env,
+    }
+    render_to_file('config/juju-api-improv.conf.template', context, config_path)
+    log('Starting the staging backend.')
+    with su('root'):
+        service_start(IMPROV)
+
+
+def start_agent(
+        ssl_cert_path, config_path='/etc/init/juju-api-agent.conf',
+        read_only=False):
+    """Start the Juju agent and connect to the current environment."""
+    # Retrieve the Zookeeper address from the start up script.
+    unit_dir = os.path.realpath(os.path.join(CURRENT_DIR, '..'))
+    agent_file = '/etc/init/juju-{0}.conf'.format(os.path.basename(unit_dir))
+    zookeeper = get_zookeeper_address(agent_file)
+    log('Setting up API agent start up script.')
+    context = {
+        'juju_dir': JUJU_DIR,
+        'keys': ssl_cert_path,
+        'port': API_PORT,
+        'zookeeper': zookeeper,
+        'read_only': read_only
+    }
+    render_to_file('config/juju-api-agent.conf.template', context, config_path)
+    log('Starting API agent.')
+    with su('root'):
+        service_start(AGENT)
+
+
+def start_gui(
+        console_enabled, login_help, readonly, in_staging, ssl_cert_path,
+        charmworld_url, serve_tests, haproxy_path='/etc/haproxy/haproxy.cfg',
+        config_js_path=None, secure=True, sandbox=False):
+    """Set up and start the Juju GUI server."""
+    with su('root'):
+        run('chown', '-R', 'ubuntu:', JUJU_GUI_DIR)
+    # XXX 2013-02-05 frankban bug=1116320:
+        # External insecure resources are still loaded when testing in the
+        # debug environment. For now, switch to the production environment if
+        # the charm is configured to serve tests.
+    if in_staging and not serve_tests:
+        build_dirname = 'build-debug'
+    else:
+        build_dirname = 'build-prod'
+    build_dir = os.path.join(JUJU_GUI_DIR, build_dirname)
+    log('Generating the Juju GUI configuration file.')
+    is_legacy_juju = legacy_juju()
+    user, password = None, None
+    if (is_legacy_juju and in_staging) or sandbox:
+        user, password = 'admin', 'admin'
+    else:
+        user, password = None, None
+
+    api_backend = 'python' if is_legacy_juju else 'go'
+    if secure:
+        protocol = 'wss'
+    else:
+        log('Running in insecure mode! Port 80 will serve unencrypted.')
+        protocol = 'ws'
+
+    context = {
+        'raw_protocol': protocol,
+        'address': unit_get('public-address'),
+        'console_enabled': json.dumps(console_enabled),
+        'login_help': json.dumps(login_help),
+        'password': json.dumps(password),
+        'api_backend': json.dumps(api_backend),
+        'readonly': json.dumps(readonly),
+        'user': json.dumps(user),
+        'protocol': json.dumps(protocol),
+        'sandbox': json.dumps(sandbox),
+        'charmworld_url': json.dumps(charmworld_url),
+    }
+    if config_js_path is None:
+        config_js_path = os.path.join(
+            build_dir, 'juju-ui', 'assets', 'config.js')
+    render_to_file('config/config.js.template', context, config_js_path)
+
+    write_apache_config(build_dir, serve_tests)
+
+    log('Generating haproxy configuration file.')
+    if is_legacy_juju:
+        # The PyJuju API agent is listening on localhost.
+        api_address = '127.0.0.1:{0}'.format(API_PORT)
+    else:
+        # Retrieve the juju-core API server address.
+        api_address = get_api_address(os.path.join(CURRENT_DIR, '..'))
+    context = {
+        'api_address': api_address,
+        'api_pem': JUJU_PEM,
+        'legacy_juju': is_legacy_juju,
+        'ssl_cert_path': ssl_cert_path,
+        # In PyJuju environments, use the same certificate for both HTTPS and
+        # WebSocket connections. In juju-core the system already has the proper
+        # certificate installed.
+        'web_pem': JUJU_PEM,
+        'web_port': WEB_PORT,
+        'secure': secure
+    }
+    render_to_file('config/haproxy.cfg.template', context, haproxy_path)
+    log('Starting Juju GUI.')
+
+
+def write_apache_config(build_dir, serve_tests=False):
+    log('Generating the apache site configuration file.')
+    context = {
+        'port': WEB_PORT,
+        'serve_tests': serve_tests,
+        'server_root': build_dir,
+        'tests_root': os.path.join(JUJU_GUI_DIR, 'test', ''),
+    }
+    render_to_file('config/apache-ports.template', context, JUJU_GUI_PORTS)
+    render_to_file('config/apache-site.template', context, JUJU_GUI_SITE)
+
+
+def get_npm_cache_archive_url(Launchpad=Launchpad):
+    """Figure out the URL of the most recent NPM cache archive on Launchpad."""
+    launchpad = Launchpad.login_anonymously('Juju GUI charm', 'production')
+    project = launchpad.projects['juju-gui']
+    # Find the URL of the most recently created NPM cache archive.
+    npm_cache_url = get_release_file_url(project, 'npm-cache', None)
+    return npm_cache_url
+
+
+def prime_npm_cache(npm_cache_url):
+    """Download NPM cache archive and prime the NPM cache with it."""
+    # Download the cache archive and then uncompress it into the NPM cache.
+    npm_cache_archive = os.path.join(CURRENT_DIR, 'npm-cache.tgz')
+    cmd_log(run('curl', '-L', '-o', npm_cache_archive, npm_cache_url))
+    npm_cache_dir = os.path.expanduser('~/.npm')
+    # The NPM cache directory probably does not exist, so make it if not.
+    try:
+        os.mkdir(npm_cache_dir)
+    except OSError, e:
+        # If the directory already exists then ignore the error.
+        if e.errno != errno.EEXIST:  # File exists.
+            raise
+    uncompress = command('tar', '-x', '-z', '-C', npm_cache_dir, '-f')
+    cmd_log(uncompress(npm_cache_archive))
+
+
+def fetch_gui(juju_gui_source, logpath):
+    """Retrieve the Juju GUI release/branch."""
+    # Retrieve a Juju GUI release.
+    origin, version_or_branch = parse_source(juju_gui_source)
+    if origin == 'branch':
+        # Make sure we have the dependencies necessary for us to actually make
+        # a build.
+        _get_build_dependencies()
+        # Create a release starting from a branch.
+        juju_gui_source_dir = os.path.join(CURRENT_DIR, 'juju-gui-source')
+        log('Retrieving Juju GUI source checkout from %s.' % version_or_branch)
+        cmd_log(run('rm', '-rf', juju_gui_source_dir))
+        cmd_log(bzr_checkout(version_or_branch, juju_gui_source_dir))
+        log('Preparing a Juju GUI release.')
+        logdir = os.path.dirname(logpath)
+        fd, name = tempfile.mkstemp(prefix='make-distfile-', dir=logdir)
+        log('Output from "make distfile" sent to %s' % name)
+        with environ(NO_BZR='1'):
+            run('make', '-C', juju_gui_source_dir, 'distfile',
+                stdout=fd, stderr=fd)
+        release_tarball = first_path_in_dir(
+            os.path.join(juju_gui_source_dir, 'releases'))
+    else:
+        log('Retrieving Juju GUI release.')
+        if origin == 'url':
+            file_url = version_or_branch
+        else:
+            # Retrieve a release from Launchpad.
+            launchpad = Launchpad.login_anonymously(
+                'Juju GUI charm', 'production')
+            project = launchpad.projects['juju-gui']
+            file_url = get_release_file_url(project, origin, version_or_branch)
+        log('Downloading release file from %s.' % file_url)
+        release_tarball = os.path.join(CURRENT_DIR, 'release.tgz')
+        cmd_log(run('curl', '-L', '-o', release_tarball, file_url))
+    return release_tarball
+
+
+def fetch_api(juju_api_branch):
+    """Retrieve the Juju branch."""
+    # Retrieve Juju API source checkout.
+    log('Retrieving Juju API source checkout.')
+    cmd_log(run('rm', '-rf', JUJU_DIR))
+    cmd_log(bzr_checkout(juju_api_branch, JUJU_DIR))
+
+
+def setup_gui(release_tarball):
+    """Set up Juju GUI."""
+    # Uncompress the release tarball.
+    log('Installing Juju GUI.')
+    release_dir = os.path.join(CURRENT_DIR, 'release')
+    cmd_log(run('rm', '-rf', release_dir))
+    os.mkdir(release_dir)
+    uncompress = command('tar', '-x', '-z', '-C', release_dir, '-f')
+    cmd_log(uncompress(release_tarball))
+    # Link the Juju GUI dir to the contents of the release tarball.
+    cmd_log(run('ln', '-sf', first_path_in_dir(release_dir), JUJU_GUI_DIR))
+
+
+def setup_apache():
+    """Set up apache."""
+    log('Setting up apache.')
+    if not os.path.exists(JUJU_GUI_SITE):
+        cmd_log(run('touch', JUJU_GUI_SITE))
+        cmd_log(run('chown', 'ubuntu:', JUJU_GUI_SITE))
+        cmd_log(
+            run('ln', '-s', JUJU_GUI_SITE,
+                '/etc/apache2/sites-enabled/juju-gui'))
+
+    if not os.path.exists(JUJU_GUI_PORTS):
+        cmd_log(run('touch', JUJU_GUI_PORTS))
+        cmd_log(run('chown', 'ubuntu:', JUJU_GUI_PORTS))
+
+    with su('root'):
+        run('a2dissite', 'default')
+        run('a2ensite', 'juju-gui')
+
+
+def save_or_create_certificates(
+        ssl_cert_path, ssl_cert_contents, ssl_key_contents):
+    """Generate the SSL certificates.
+
+    If both *ssl_cert_contents* and *ssl_key_contents* are provided, use them
+    as certificates; otherwise, generate them.
+
+    Also create a pem file, suitable for use in the haproxy configuration,
+    concatenating the key and the certificate files.
+    """
+    crt_path = os.path.join(ssl_cert_path, 'juju.crt')
+    key_path = os.path.join(ssl_cert_path, 'juju.key')
+    if not os.path.exists(ssl_cert_path):
+        os.makedirs(ssl_cert_path)
+    if ssl_cert_contents and ssl_key_contents:
+        # Save the provided certificates.
+        with open(crt_path, 'w') as cert_file:
+            cert_file.write(ssl_cert_contents)
+        with open(key_path, 'w') as key_file:
+            key_file.write(ssl_key_contents)
+    else:
+        # Generate certificates.
+        # See http://superuser.com/questions/226192/openssl-without-prompt
+        cmd_log(run(
+            'openssl', 'req', '-new', '-newkey', 'rsa:4096',
+            '-days', '365', '-nodes', '-x509', '-subj',
+            # These are arbitrary test values for the certificate.
+            '/C=GB/ST=Juju/L=GUI/O=Ubuntu/CN=juju.ubuntu.com',
+            '-keyout', key_path, '-out', crt_path))
+    # Generate the pem file.
+    pem_path = os.path.join(ssl_cert_path, JUJU_PEM)
+    if os.path.exists(pem_path):
+        os.remove(pem_path)
+    with open(pem_path, 'w') as pem_file:
+        shutil.copyfileobj(open(key_path), pem_file)
+        shutil.copyfileobj(open(crt_path), pem_file)
+
+
+def find_missing_packages(*packages):
+    """Given a list of packages, return the packages which are not installed.
+    """
+    cache = apt.Cache()
+    missing = set()
+    for pkg_name in packages:
+        try:
+            pkg = cache[pkg_name]
+        except KeyError:
+            missing.add(pkg_name)
+            continue
+        if pkg.is_installed:
+            continue
+        missing.add(pkg_name)
+    return missing
+
+
+## Backend support decorators
+
+def chain(name):
+    """Helper method to compose a set of mixin objects into a callable.
+
+    Each method is called in the context of its mixin instance, and its
+    argument is the Backend instance.
+    """
+    # Chain method calls through all implementing mixins.
+    def method(self):
+        for mixin in self.mixins:
+            a_callable = getattr(type(mixin), name, None)
+            if a_callable:
+                a_callable(mixin, self)
+
+    method.__name__ = name
+    return method
+
+
+def merge(name):
+    """Helper to merge a property from a set of strategy objects
+    into a unified set.
+    """
+    # Return merged property from every providing mixin as a set.
+    @property
+    def method(self):
+        result = set()
+        for mixin in self.mixins:
+            segment = getattr(type(mixin), name, None)
+            if segment and isinstance(segment, (list, tuple, set)):
+                result |= set(segment)
+
+        return result
+    return method

=== added directory 'hooks/charmhelpers/contrib/openstack'
=== added file 'hooks/charmhelpers/contrib/openstack/IMPORT'
--- hooks/charmhelpers/contrib/openstack/IMPORT	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/openstack/IMPORT	2013-07-09 03:52:26 +0000
@@ -0,0 +1,9 @@
+Source: lp:~openstack-charmers/openstack-charm-helpers/ha-helpers
+
+ha-helpers/lib/openstack-common -> charm-helpers/charmhelpers/contrib/openstackhelpers/openstack-common
+ha-helpers/lib/openstack_common.py -> charm-helpers/charmhelpers/contrib/openstackhelpers/openstack_common.py
+ha-helpers/lib/nova -> charm-helpers/charmhelpers/contrib/openstackhelpers/nova
+ha-helpers/lib/nova/nova-common -> charm-helpers/charmhelpers/contrib/openstackhelpers/nova/nova-common
+ha-helpers/lib/nova/grizzly -> charm-helpers/charmhelpers/contrib/openstackhelpers/nova/grizzly
+ha-helpers/lib/nova/essex -> charm-helpers/charmhelpers/contrib/openstackhelpers/nova/essex
+ha-helpers/lib/nova/folsom -> charm-helpers/charmhelpers/contrib/openstackhelpers/nova/folsom

=== added file 'hooks/charmhelpers/contrib/openstack/__init__.py'
=== added directory 'hooks/charmhelpers/contrib/openstack/nova'
=== added file 'hooks/charmhelpers/contrib/openstack/nova/essex'
--- hooks/charmhelpers/contrib/openstack/nova/essex	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/openstack/nova/essex	2013-07-09 03:52:26 +0000
@@ -0,0 +1,43 @@
+#!/bin/bash -e
+
+# Essex-specific functions
+
+nova_set_or_update() {
+  # Set a config option in nova.conf or api-paste.ini, depending
+  # Defaults to updating nova.conf
+  local key=$1
+  local value=$2
+  local conf_file=$3
+  local pattern=""
+
+  local nova_conf=${NOVA_CONF:-/etc/nova/nova.conf}
+  local api_conf=${API_CONF:-/etc/nova/api-paste.ini}
+  local libvirtd_conf=${LIBVIRTD_CONF:-/etc/libvirt/libvirtd.conf}
+  [[ -z $key ]] && juju-log "$CHARM set_or_update: value $value missing key" && exit 1
+  [[ -z $value ]] && juju-log "$CHARM set_or_update: key $key missing value" && exit 1
+  [[ -z "$conf_file" ]] && conf_file=$nova_conf
+
+  case "$conf_file" in
+    "$nova_conf") match="\-\-$key="
+                  pattern="--$key="
+                  out=$pattern
+                  ;;
+    "$api_conf"|"$libvirtd_conf") match="^$key = "
+                 pattern="$match"
+                 out="$key = "
+                 ;;
+    *) error_out "ERROR: set_or_update: Invalid conf_file ($conf_file)"
+  esac
+
+  cat $conf_file | grep "$match$value" >/dev/null &&
+    juju-log "$CHARM: $key=$value already in set in $conf_file" \
+      && return 0
+  if cat $conf_file | grep "$match" >/dev/null ; then
+    juju-log "$CHARM: Updating $conf_file, $key=$value"
+    sed -i "s|\($pattern\).*|\1$value|" $conf_file
+  else
+    juju-log "$CHARM: Setting new option $key=$value in $conf_file"
+    echo "$out$value" >>$conf_file
+  fi
+  CONFIG_CHANGED=True
+}

=== added file 'hooks/charmhelpers/contrib/openstack/nova/folsom'
--- hooks/charmhelpers/contrib/openstack/nova/folsom	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/openstack/nova/folsom	2013-07-09 03:52:26 +0000
@@ -0,0 +1,81 @@
+#!/bin/bash -e
+
+# Folsom-specific functions
+
+nova_set_or_update() {
+  # TODO: This needs to be shared among folsom, grizzly and beyond.
+  # Set a config option in nova.conf or api-paste.ini, depending
+  # Defaults to updating nova.conf
+  local key="$1"
+  local value="$2"
+  local conf_file="$3"
+  local section="${4:-DEFAULT}"
+
+  local nova_conf=${NOVA_CONF:-/etc/nova/nova.conf}
+  local api_conf=${API_CONF:-/etc/nova/api-paste.ini}
+  local quantum_conf=${QUANTUM_CONF:-/etc/quantum/quantum.conf}
+  local quantum_api_conf=${QUANTUM_API_CONF:-/etc/quantum/api-paste.ini}
+  local quantum_plugin_conf=${QUANTUM_PLUGIN_CONF:-/etc/quantum/plugins/openvswitch/ovs_quantum_plugin.ini}
+  local libvirtd_conf=${LIBVIRTD_CONF:-/etc/libvirt/libvirtd.conf}
+
+  [[ -z $key ]] && juju-log "$CHARM: set_or_update: value $value missing key" && exit 1
+  [[ -z $value ]] && juju-log "$CHARM: set_or_update: key $key missing value" && exit 1
+
+  [[ -z "$conf_file" ]] && conf_file=$nova_conf
+
+  local pattern=""
+  case "$conf_file" in
+    "$nova_conf") match="^$key="
+                  pattern="$key="
+                  out=$pattern
+                  ;;
+    "$api_conf"|"$quantum_conf"|"$quantum_api_conf"|"$quantum_plugin_conf"| \
+    "$libvirtd_conf")
+                 match="^$key = "
+                 pattern="$match"
+                 out="$key = "
+                 ;;
+    *) juju-log "$CHARM ERROR: set_or_update: Invalid conf_file ($conf_file)"
+  esac
+
+  cat $conf_file | grep "$match$value" >/dev/null &&
+    juju-log "$CHARM: $key=$value already in set in $conf_file" \
+      && return 0
+
+  case $conf_file in
+    "$quantum_conf"|"$quantum_api_conf"|"$quantum_plugin_conf")
+        python -c "
+import ConfigParser
+config = ConfigParser.RawConfigParser()
+config.read('$conf_file')
+config.set('$section','$key','$value')
+with open('$conf_file', 'wb') as configfile:
+    config.write(configfile)
+"
+      ;;
+    *)
+      if cat $conf_file | grep "$match" >/dev/null ; then
+        juju-log "$CHARM: Updating $conf_file, $key=$value"
+        sed -i "s|\($pattern\).*|\1$value|" $conf_file
+      else
+        juju-log "$CHARM: Setting new option $key=$value in $conf_file"
+        echo "$out$value" >>$conf_file
+      fi
+      ;;
+  esac
+  CONFIG_CHANGED="True"
+}
+
+# Upgrade Helpers
+nova_pre_upgrade() {
+  # Pre-upgrade helper.  Caller should pass the version of OpenStack we are
+  # upgrading from.
+  return 0 # Nothing to do here, yet.
+}
+
+nova_post_upgrade() {
+  # Post-upgrade helper.  Caller should pass the version of OpenStack we are
+  # upgrading from.
+  juju-log "$CHARM: Running post-upgrade hook: $upgrade_from -> folsom."
+  # nothing to do here yet.
+}

=== added symlink 'hooks/charmhelpers/contrib/openstack/nova/grizzly'
=== target is u'folsom'
=== added file 'hooks/charmhelpers/contrib/openstack/nova/nova-common'
--- hooks/charmhelpers/contrib/openstack/nova/nova-common	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/openstack/nova/nova-common	2013-07-09 03:52:26 +0000
@@ -0,0 +1,147 @@
+#!/bin/bash -e
+
+# Common utility functions used across all nova charms.
+
+CONFIG_CHANGED=False
+
+# Load the common OpenStack helper library.
+if [[ -e $CHARM_DIR/lib/openstack-common ]] ; then
+  . $CHARM_DIR/lib/openstack-common
+else
+  juju-log "Couldn't load $CHARM_DIR/lib/opentack-common." && exit 1
+fi
+
+set_or_update() {
+  # Update config flags in nova.conf or api-paste.ini.
+  # Config layout changed in Folsom, so this is now OpenStack release specific.
+  local rel=$(get_os_codename_package "nova-common")
+  . $CHARM_DIR/lib/nova/$rel
+  nova_set_or_update $@
+}
+
+function set_config_flags() {
+  # Set user-defined nova.conf flags from deployment config
+  juju-log "$CHARM: Processing config-flags."
+  flags=$(config-get config-flags)
+  if [[ "$flags" != "None" && -n "$flags" ]] ; then
+    for f in $(echo $flags | sed -e 's/,/ /g') ; do
+      k=$(echo $f | cut -d= -f1)
+      v=$(echo $f | cut -d= -f2)
+      set_or_update "$k" "$v"
+    done
+  fi
+}
+
+configure_volume_service() {
+  local svc="$1"
+  local cur_vers="$(get_os_codename_package "nova-common")"
+  case "$svc" in
+    "cinder")
+      set_or_update "volume_api_class" "nova.volume.cinder.API" ;;
+    "nova-volume")
+      # nova-volume only supported before grizzly.
+      [[ "$cur_vers" == "essex" ]] || [[ "$cur_vers" == "folsom" ]] &&
+        set_or_update "volume_api_class" "nova.volume.api.API"
+      ;;
+    *) juju-log "$CHARM ERROR - configure_volume_service: Invalid service $svc"
+       return 1 ;;
+  esac
+}
+
+function configure_network_manager {
+  local manager="$1"
+  echo "$CHARM: configuring $manager network manager"
+  case $1 in
+    "FlatManager")
+      set_or_update "network_manager" "nova.network.manager.FlatManager"
+      ;;
+    "FlatDHCPManager")
+      set_or_update "network_manager" "nova.network.manager.FlatDHCPManager"
+
+      if [[ "$CHARM" == "nova-compute" ]] ; then
+        local flat_interface=$(config-get flat-interface)
+        local ec2_host=$(relation-get ec2_host)
+        set_or_update flat_inteface "$flat_interface"
+        set_or_update ec2_dmz_host "$ec2_host"
+
+        # Ensure flat_interface has link.
+        if ip link show $flat_interface >/dev/null 2>&1 ; then
+          ip link set $flat_interface up
+        fi
+
+        # work around (LP: #1035172)
+        if [[ -e /dev/vhost-net ]] ; then
+          iptables -A POSTROUTING -t mangle -p udp --dport 68 -j CHECKSUM \
+            --checksum-fill
+        fi
+      fi
+
+      ;;
+    "Quantum")
+      local local_ip=$(get_ip `unit-get private-address`)
+      [[ -n $local_ip ]] || {
+        juju-log "Unable to resolve local IP address"
+        exit 1
+      }
+      set_or_update "network_api_class" "nova.network.quantumv2.api.API"
+      set_or_update "quantum_auth_strategy" "keystone"
+      set_or_update "core_plugin" "$QUANTUM_CORE_PLUGIN" "$QUANTUM_CONF"
+      set_or_update "bind_host" "0.0.0.0" "$QUANTUM_CONF"
+      if [ "$QUANTUM_PLUGIN" == "ovs" ]; then
+          set_or_update "tenant_network_type" "gre" $QUANTUM_PLUGIN_CONF "OVS"
+          set_or_update "enable_tunneling" "True" $QUANTUM_PLUGIN_CONF "OVS"
+          set_or_update "tunnel_id_ranges" "1:1000" $QUANTUM_PLUGIN_CONF "OVS"
+          set_or_update "local_ip" "$local_ip" $QUANTUM_PLUGIN_CONF "OVS"
+      fi
+      ;;
+    *) juju-log "ERROR: Invalid network manager $1" && exit 1 ;;
+  esac
+}
+
+function trigger_remote_service_restarts() {
+  # Trigger a service restart on all other nova nodes that have a relation
+  # via the cloud-controller interface.
+
+  # possible relations to other nova services.
+  local relations="cloud-compute nova-volume-service"
+
+  for rel in $relations; do
+    local r_ids=$(relation-ids $rel)
+    for r_id in $r_ids ; do
+      juju-log "$CHARM: Triggering a service restart on relation $r_id."
+      relation-set -r $r_id restart-trigger=$(uuid)
+    done
+  done
+}
+
+do_openstack_upgrade() {
+  # update openstack components to those provided by a new installation source
+  # it is assumed the calling hook has confirmed that the upgrade is sane.
+  local rel="$1"
+  shift
+  local packages=$@
+
+  orig_os_rel=$(get_os_codename_package "nova-common")
+  new_rel=$(get_os_codename_install_source "$rel")
+
+  # Backup the config directory.
+  local stamp=$(date +"%Y%m%d%M%S")
+  tar -pcf /var/lib/juju/$CHARM-backup-$stamp.tar $CONF_DIR
+
+  # load the release helper library for pre/post upgrade hooks specific to the
+  # release we are upgrading to.
+  . $CHARM_DIR/lib/nova/$new_rel
+
+  # new release specific pre-upgrade hook
+  nova_pre_upgrade "$orig_os_rel"
+
+  # Setup apt repository access and kick off the actual package upgrade.
+  configure_install_source "$rel"
+  apt-get update
+  DEBIAN_FRONTEND=noninteractive apt-get --option Dpkg::Options::=--force-confold -y \
+     install --no-install-recommends $packages
+
+  # new release sepcific post-upgrade hook
+  nova_post_upgrade "$orig_os_rel"
+
+}

=== added file 'hooks/charmhelpers/contrib/openstack/openstack-common'
--- hooks/charmhelpers/contrib/openstack/openstack-common	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/openstack/openstack-common	2013-07-09 03:52:26 +0000
@@ -0,0 +1,781 @@
+#!/bin/bash -e
+
+# Common utility functions used across all OpenStack charms.
+
+error_out() {
+  juju-log "$CHARM ERROR: $@"
+  exit 1
+}
+
+function service_ctl_status {
+  # Return 0 if a service is running, 1 otherwise.
+  local svc="$1"
+  local status=$(service $svc status | cut -d/ -f1 | awk '{ print $2 }')
+  case $status in
+    "start") return 0 ;;
+    "stop") return 1 ;;
+    *) error_out "Unexpected status of service $svc: $status" ;;
+  esac
+}
+
+function service_ctl {
+  # control a specific service, or all (as defined by $SERVICES)
+  # service restarts will only occur depending on global $CONFIG_CHANGED,
+  # which should be updated in charm's set_or_update().
+  local config_changed=${CONFIG_CHANGED:-True}
+  if [[ $1 == "all" ]] ; then
+    ctl="$SERVICES"
+  else
+    ctl="$1"
+  fi
+  action="$2"
+  if [[ -z "$ctl" ]] || [[ -z "$action" ]] ; then
+    error_out "ERROR service_ctl: Not enough arguments"
+  fi
+
+  for i in $ctl ; do
+    case $action in
+      "start")
+        service_ctl_status $i || service $i start ;;
+      "stop")
+        service_ctl_status $i && service $i stop || return 0 ;;
+      "restart")
+        if [[ "$config_changed" == "True" ]] ; then
+          service_ctl_status $i && service $i restart || service $i start
+        fi
+        ;;
+    esac
+    if [[ $? != 0 ]] ; then
+      juju-log "$CHARM: service_ctl ERROR - Service $i failed to $action"
+    fi
+  done
+  # all configs should have been reloaded on restart of all services, reset
+  # flag if its being used.
+  if [[ "$action" == "restart" ]] && [[ -n "$CONFIG_CHANGED" ]] &&
+     [[ "$ctl" == "all" ]]; then
+    CONFIG_CHANGED="False"
+  fi
+}
+
+function configure_install_source {
+  # Setup and configure installation source based on a config flag.
+  local src="$1"
+
+  # Default to installing from the main Ubuntu archive.
+  [[ $src == "distro" ]] || [[ -z "$src" ]] && return 0
+
+  . /etc/lsb-release
+
+  # standard 'ppa:someppa/name' format.
+   if [[ "${src:0:4}" == "ppa:" ]] ; then
+    juju-log "$CHARM: Configuring installation from custom src ($src)"
+    add-apt-repository -y "$src" || error_out "Could not configure PPA access."
+    return 0
+  fi
+
+  # standard 'deb http://url/ubuntu main' entries. gpg key ids must
+  # be appended to the end of url after a |, ie:
+  # 'deb http://url/ubuntu main|$GPGKEYID'
+  if [[ "${src:0:3}" == "deb" ]] ; then
+    juju-log "$CHARM: Configuring installation from custom src URL ($src)"
+    if echo "$src" | grep -q "|" ; then
+      # gpg key id tagged to end of url folloed by a |
+      url=$(echo $src | cut -d'|' -f1)
+      key=$(echo $src | cut -d'|' -f2)
+      juju-log "$CHARM: Importing repository key: $key"
+      apt-key adv --keyserver keyserver.ubuntu.com --recv-keys "$key" || \
+        juju-log "$CHARM WARN: Could not import key from keyserver: $key"
+    else
+      juju-log "$CHARM No repository key specified."
+      url="$src"
+    fi
+    echo "$url" > /etc/apt/sources.list.d/juju_deb.list
+    return 0
+  fi
+
+  # Cloud Archive
+  if [[ "${src:0:6}" == "cloud:" ]] ; then
+
+    # current os releases supported by the UCA.
+    local cloud_archive_versions="folsom grizzly"
+
+    local ca_rel=$(echo $src | cut -d: -f2)
+    local u_rel=$(echo $ca_rel | cut -d- -f1)
+    local os_rel=$(echo $ca_rel | cut -d- -f2 | cut -d/ -f1)
+
+    [[ "$u_rel" != "$DISTRIB_CODENAME" ]] &&
+      error_out "Cannot install from Cloud Archive pocket $src " \
+                "on this Ubuntu version ($DISTRIB_CODENAME)!"
+
+    valid_release=""
+    for rel in $cloud_archive_versions ; do
+      if [[ "$os_rel" == "$rel" ]] ; then
+        valid_release=1
+        juju-log "Installing OpenStack ($os_rel) from the Ubuntu Cloud Archive."
+      fi
+    done
+    if [[ -z "$valid_release" ]] ; then
+      error_out "OpenStack release ($os_rel) not supported by "\
+                "the Ubuntu Cloud Archive."
+    fi
+
+    # CA staging repos are standard PPAs.
+    if echo $ca_rel | grep -q "staging" ; then
+      add-apt-repository -y ppa:ubuntu-cloud-archive/${os_rel}-staging
+      return 0
+    fi
+
+    # the others are LP-external deb repos.
+    case "$ca_rel" in
+      "$u_rel-$os_rel"|"$u_rel-$os_rel/updates") pocket="$u_rel-updates/$os_rel" ;;
+      "$u_rel-$os_rel/proposed") pocket="$u_rel-proposed/$os_rel" ;;
+      "$u_rel-$os_rel"|"$os_rel/updates") pocket="$u_rel-updates/$os_rel" ;;
+      "$u_rel-$os_rel/proposed") pocket="$u_rel-proposed/$os_rel" ;;
+      *) error_out "Invalid Cloud Archive repo specified: $src"
+    esac
+
+    apt-get -y install ubuntu-cloud-keyring
+    entry="deb http://ubuntu-cloud.archive.canonical.com/ubuntu $pocket main"
+    echo "$entry" \
+      >/etc/apt/sources.list.d/ubuntu-cloud-archive-$DISTRIB_CODENAME.list
+    return 0
+  fi
+
+  error_out "Invalid installation source specified in config: $src"
+
+}
+
+get_os_codename_install_source() {
+  # derive the openstack release provided by a supported installation source.
+  local rel="$1"
+  local codename="unknown"
+  . /etc/lsb-release
+
+  # map ubuntu releases to the openstack version shipped with it.
+  if [[ "$rel" == "distro" ]] ; then
+    case "$DISTRIB_CODENAME" in
+      "oneiric") codename="diablo" ;;
+      "precise") codename="essex" ;;
+      "quantal") codename="folsom" ;;
+      "raring")  codename="grizzly" ;;
+    esac
+  fi
+
+  # derive version from cloud archive strings.
+  if [[ "${rel:0:6}" == "cloud:" ]] ; then
+    rel=$(echo $rel | cut -d: -f2)
+    local u_rel=$(echo $rel | cut -d- -f1)
+    local ca_rel=$(echo $rel | cut -d- -f2)
+    if [[ "$u_rel" == "$DISTRIB_CODENAME" ]] ; then
+      case "$ca_rel" in
+        "folsom"|"folsom/updates"|"folsom/proposed"|"folsom/staging")
+          codename="folsom" ;;
+        "grizzly"|"grizzly/updates"|"grizzly/proposed"|"grizzly/staging")
+          codename="grizzly" ;;
+      esac
+    fi
+  fi
+
+  # have a guess based on the deb string provided
+  if [[ "${rel:0:3}" == "deb" ]] || \
+     [[ "${rel:0:3}" == "ppa" ]] ; then
+    CODENAMES="diablo essex folsom grizzly havana"
+    for cname in $CODENAMES; do
+      if echo $rel | grep -q $cname; then
+        codename=$cname
+      fi
+    done
+  fi
+  echo $codename
+}
+
+get_os_codename_package() {
+  local pkg_vers=$(dpkg -l | grep "$1" | awk '{ print $3 }') || echo "none"
+  pkg_vers=$(echo $pkg_vers | cut -d: -f2) # epochs
+  case "${pkg_vers:0:6}" in
+    "2011.2") echo "diablo" ;;
+    "2012.1") echo "essex" ;;
+    "2012.2") echo "folsom" ;;
+    "2013.1") echo "grizzly" ;;
+    "2013.2") echo "havana" ;;
+  esac
+}
+
+get_os_version_codename() {
+  case "$1" in
+    "diablo") echo "2011.2" ;;
+    "essex") echo "2012.1" ;;
+    "folsom") echo "2012.2" ;;
+    "grizzly") echo "2013.1" ;;
+    "havana") echo "2013.2" ;;
+  esac
+}
+
+get_ip() {
+  dpkg -l | grep -q python-dnspython || {
+    apt-get -y install python-dnspython 2>&1 > /dev/null
+  }
+  hostname=$1
+  python -c "
+import dns.resolver
+import socket
+try:
+  # Test to see if already an IPv4 address
+  socket.inet_aton('$hostname')
+  print '$hostname'
+except socket.error:
+  try:
+    answers = dns.resolver.query('$hostname', 'A')
+    if answers:
+      print answers[0].address
+  except dns.resolver.NXDOMAIN:
+    pass
+"
+}
+
+# Common storage routines used by cinder, nova-volume and swift-storage.
+clean_storage() {
+  # if configured to overwrite existing storage, we unmount the block-dev
+  # if mounted and clear any previous pv signatures
+  local block_dev="$1"
+  juju-log "Cleaining storage '$block_dev'"
+  if grep -q "^$block_dev" /proc/mounts ; then
+    mp=$(grep "^$block_dev" /proc/mounts   | awk '{ print $2 }')
+    juju-log "Unmounting $block_dev from $mp"
+    umount "$mp" || error_out "ERROR: Could not unmount storage from $mp"
+  fi
+  if pvdisplay "$block_dev" >/dev/null 2>&1 ; then
+    juju-log "Removing existing LVM PV signatures from $block_dev"
+
+    # deactivate any volgroups that may be built on this dev
+    vg=$(pvdisplay $block_dev | grep "VG Name" | awk '{ print $3 }')
+    if [[ -n "$vg" ]] ; then
+      juju-log "Deactivating existing volume group: $vg"
+      vgchange -an "$vg" ||
+        error_out "ERROR: Could not deactivate volgroup $vg.  Is it in use?"
+    fi
+    echo "yes" | pvremove -ff "$block_dev" ||
+      error_out "Could not pvremove $block_dev"
+  else
+    juju-log "Zapping disk of all GPT and MBR structures"
+    sgdisk --zap-all $block_dev ||
+      error_out "Unable to zap $block_dev"
+  fi
+}
+
+function get_block_device() {
+  # given a string, return full path to the block device for that
+  # if input is not a block device, find a loopback device
+  local input="$1"
+
+  case "$input" in
+    /dev/*) [[ ! -b "$input" ]] && error_out "$input does not exist."
+            echo "$input"; return 0;;
+    /*) :;;
+    *)  [[ ! -b "/dev/$input" ]] && error_out "/dev/$input does not exist."
+        echo "/dev/$input"; return 0;;
+  esac
+
+  # this represents a file
+  # support "/path/to/file|5G"
+  local fpath size oifs="$IFS"
+  if [ "${input#*|}" != "${input}" ]; then
+    size=${input##*|}
+    fpath=${input%|*}
+  else
+    fpath=${input}
+    size=5G
+  fi
+
+  ## loop devices are not namespaced.  This is bad for containers.
+  ## it means that the output of 'losetup' may have the given $fpath
+  ## in it, but that may not represent this containers $fpath, but
+  ## another containers.  To address that, we really need to
+  ## allow some uniq container-id to be expanded within path.
+  ## TODO: find a unique container-id that will be consistent for
+  ##       this container throughout its lifetime and expand it
+  ##       in the fpath.
+  # fpath=${fpath//%{id}/$THAT_ID}
+
+  local found=""
+  # parse through 'losetup -a' output, looking for this file
+  # output is expected to look like:
+  #   /dev/loop0: [0807]:961814 (/tmp/my.img)
+  found=$(losetup -a |
+    awk 'BEGIN { found=0; }
+         $3 == f { sub(/:$/,"",$1); print $1; found=found+1; }
+         END { if( found == 0 || found == 1 ) { exit(0); }; exit(1); }' \
+         f="($fpath)")
+
+  if [ $? -ne 0 ]; then
+    echo "multiple devices found for $fpath: $found" 1>&2
+    return 1;
+  fi
+
+  [ -n "$found" -a -b "$found" ] && { echo "$found"; return 1; }
+
+  if [ -n "$found" ]; then
+    echo "confused, $found is not a block device for $fpath";
+    return 1;
+  fi
+
+  # no existing device was found, create one
+  mkdir -p "${fpath%/*}"
+  truncate --size "$size" "$fpath" ||
+    { echo "failed to create $fpath of size $size"; return 1; }
+
+  found=$(losetup --find --show "$fpath") ||
+    { echo "failed to setup loop device for $fpath" 1>&2; return 1; }
+
+  echo "$found"
+  return 0
+}
+
+HAPROXY_CFG=/etc/haproxy/haproxy.cfg
+HAPROXY_DEFAULT=/etc/default/haproxy
+##########################################################################
+# Description: Configures HAProxy services for Openstack API's
+# Parameters:
+#   Space delimited list of service:port:mode combinations for which
+#   haproxy service configuration should be generated for.  The function
+#   assumes the name of the peer relation is 'cluster' and that every
+#   service unit in the peer relation is running the same services.
+#
+#   Services that do not specify :mode in parameter will default to http.
+#
+# Example
+#   configure_haproxy cinder_api:8776:8756:tcp nova_api:8774:8764:http
+##########################################################################
+configure_haproxy() {
+  local address=`unit-get private-address`
+  local name=${JUJU_UNIT_NAME////-}
+  cat > $HAPROXY_CFG << EOF
+global
+  log 127.0.0.1 local0
+  log 127.0.0.1 local1 notice
+  maxconn 20000
+  user haproxy
+  group haproxy
+  spread-checks 0
+
+defaults
+  log global
+  mode http
+  option httplog
+  option dontlognull
+  retries 3
+  timeout queue 1000
+  timeout connect 1000
+  timeout client 30000
+  timeout server 30000
+
+listen stats :8888
+  mode http
+  stats enable
+  stats hide-version
+  stats realm Haproxy\ Statistics
+  stats uri /
+  stats auth admin:password
+
+EOF
+  for service in $@; do
+    local service_name=$(echo $service | cut -d : -f 1)
+    local haproxy_listen_port=$(echo $service | cut -d : -f 2)
+    local api_listen_port=$(echo $service | cut -d : -f 3)
+    local mode=$(echo $service | cut -d : -f 4)
+    [[ -z "$mode" ]] && mode="http"
+    juju-log "Adding haproxy configuration entry for $service "\
+             "($haproxy_listen_port -> $api_listen_port)"
+    cat >> $HAPROXY_CFG << EOF
+listen $service_name 0.0.0.0:$haproxy_listen_port
+  balance roundrobin
+  mode $mode
+  option ${mode}log
+  server $name $address:$api_listen_port check
+EOF
+    local r_id=""
+    local unit=""
+    for r_id in `relation-ids cluster`; do
+      for unit in `relation-list -r $r_id`; do
+        local unit_name=${unit////-}
+        local unit_address=`relation-get -r $r_id private-address $unit`
+        if [ -n "$unit_address" ]; then
+          echo "  server $unit_name $unit_address:$api_listen_port check" \
+            >> $HAPROXY_CFG
+        fi
+      done
+    done
+  done
+  echo "ENABLED=1" > $HAPROXY_DEFAULT
+  service haproxy restart
+}
+
+##########################################################################
+# Description: Query HA interface to determine is cluster is configured
+# Returns: 0 if configured, 1 if not configured
+##########################################################################
+is_clustered() {
+  local r_id=""
+  local unit=""
+  for r_id in $(relation-ids ha); do
+    if [ -n "$r_id" ]; then
+      for unit in $(relation-list -r $r_id); do
+         clustered=$(relation-get -r $r_id clustered $unit)
+         if [ -n "$clustered" ]; then
+           juju-log "Unit is haclustered"
+           return 0
+         fi
+      done
+    fi
+  done
+  juju-log "Unit is not haclustered"
+  return 1
+}
+
+##########################################################################
+# Description: Return a list of all peers in cluster relations
+##########################################################################
+peer_units() {
+  local peers=""
+  local r_id=""
+  for r_id in $(relation-ids cluster); do
+    peers="$peers $(relation-list -r $r_id)"
+  done
+  echo $peers
+}
+
+##########################################################################
+# Description: Determines whether the current unit is the oldest of all
+#              its peers - supports partial leader election
+# Returns: 0 if oldest, 1 if not
+##########################################################################
+oldest_peer() {
+  peers=$1
+  local l_unit_no=$(echo $JUJU_UNIT_NAME | cut -d / -f 2)
+  for peer in $peers; do
+    echo "Comparing $JUJU_UNIT_NAME with peers: $peers"
+    local r_unit_no=$(echo $peer | cut -d / -f 2)
+    if (($r_unit_no<$l_unit_no)); then
+        juju-log "Not oldest peer; deferring"
+        return 1
+    fi
+  done
+  juju-log "Oldest peer; might take charge?"
+  return 0
+}
+
+##########################################################################
+# Description: Determines whether the current service units is the
+#              leader within a) a cluster of its peers or b) across a
+#              set of unclustered peers.
+# Parameters: CRM resource to check ownership of if clustered
+# Returns: 0 if leader, 1 if not
+##########################################################################
+eligible_leader() {
+  if is_clustered; then
+    if ! is_leader $1; then
+      juju-log 'Deferring action to CRM leader'
+      return 1
+    fi
+  else
+    peers=$(peer_units)
+    if [ -n "$peers" ] && ! oldest_peer "$peers"; then
+      juju-log 'Deferring action to oldest service unit.'
+      return 1
+    fi
+  fi
+  return 0
+}
+
+##########################################################################
+# Description: Query Cluster peer interface to see if peered
+# Returns: 0 if peered, 1 if not peered
+##########################################################################
+is_peered() {
+  local r_id=$(relation-ids cluster)
+  if [ -n "$r_id" ]; then
+    if [ -n "$(relation-list -r $r_id)" ]; then
+      juju-log "Unit peered"
+      return 0
+    fi
+  fi
+  juju-log "Unit not peered"
+  return 1
+}
+
+##########################################################################
+# Description: Determines whether host is owner of clustered services
+# Parameters: Name of CRM resource to check ownership of
+# Returns: 0 if leader, 1 if not leader
+##########################################################################
+is_leader() {
+  hostname=`hostname`
+  if [ -x /usr/sbin/crm ]; then
+    if crm resource show $1 | grep -q $hostname; then
+      juju-log "$hostname is cluster leader."
+      return 0
+    fi
+  fi
+  juju-log "$hostname is not cluster leader."
+  return 1
+}
+
+##########################################################################
+# Description: Determines whether enough data has been provided in
+# configuration or relation data to configure HTTPS.
+# Parameters:  None
+# Returns: 0 if HTTPS can be configured, 1 if not.
+##########################################################################
+https() {
+  local r_id=""
+  if [[ -n "$(config-get ssl_cert)" ]] &&
+     [[ -n "$(config-get ssl_key)" ]] ; then
+    return 0
+  fi
+  for r_id in $(relation-ids identity-service) ; do
+    for unit in $(relation-list -r $r_id) ; do
+      if [[ "$(relation-get -r $r_id https_keystone $unit)" == "True" ]] &&
+         [[ -n "$(relation-get -r $r_id ssl_cert $unit)" ]] &&
+         [[ -n "$(relation-get -r $r_id ssl_key $unit)" ]] &&
+         [[ -n "$(relation-get -r $r_id ca_cert $unit)" ]] ; then
+          return 0
+      fi
+    done
+  done
+  return 1
+}
+
+##########################################################################
+# Description: For a given number of port mappings, configures apache2
+# HTTPs local reverse proxying using certficates and keys provided in
+# either configuration data (preferred) or relation data.  Assumes ports
+# are not in use (calling charm should ensure that).
+# Parameters:  Variable number of proxy port mappings as
+# $internal:$external.
+# Returns: 0 if reverse proxy(s) have been configured, 0 if not.
+##########################################################################
+enable_https() {
+  local port_maps="$@"
+  local http_restart=""
+  juju-log "Enabling HTTPS for port mappings: $port_maps."
+
+  # allow overriding of keystone provided certs with those set manually
+  # in config.
+  local cert=$(config-get ssl_cert)
+  local key=$(config-get ssl_key)
+  local ca_cert=""
+  if [[ -z "$cert" ]] || [[ -z "$key" ]] ; then
+    juju-log "Inspecting identity-service relations for SSL certificate."
+    local r_id=""
+    cert=""
+    key=""
+    ca_cert=""
+    for r_id in $(relation-ids identity-service) ; do
+      for unit in $(relation-list -r $r_id) ; do
+        [[ -z "$cert" ]] && cert="$(relation-get -r $r_id ssl_cert $unit)"
+        [[ -z "$key" ]] && key="$(relation-get -r $r_id ssl_key $unit)"
+        [[ -z "$ca_cert" ]] && ca_cert="$(relation-get -r $r_id ca_cert $unit)"
+      done
+    done
+    [[ -n "$cert" ]] && cert=$(echo $cert | base64 -di)
+    [[ -n "$key" ]] && key=$(echo $key | base64 -di)
+    [[ -n "$ca_cert" ]] && ca_cert=$(echo $ca_cert | base64 -di)
+  else
+    juju-log "Using SSL certificate provided in service config."
+  fi
+
+  [[ -z "$cert" ]] || [[ -z "$key" ]] &&
+    juju-log "Expected but could not find SSL certificate data, not "\
+             "configuring HTTPS!" && return 1
+
+  apt-get -y install apache2
+  a2enmod ssl proxy proxy_http | grep -v "To activate the new configuration" &&
+    http_restart=1
+
+  mkdir -p /etc/apache2/ssl/$CHARM
+  echo "$cert" >/etc/apache2/ssl/$CHARM/cert
+  echo "$key" >/etc/apache2/ssl/$CHARM/key
+  if [[ -n "$ca_cert" ]] ; then
+    juju-log "Installing Keystone supplied CA cert."
+    echo "$ca_cert" >/usr/local/share/ca-certificates/keystone_juju_ca_cert.crt
+    update-ca-certificates --fresh
+
+    # XXX TODO: Find a better way of exporting this?
+    if [[ "$CHARM" == "nova-cloud-controller" ]] ; then
+      [[ -e /var/www/keystone_juju_ca_cert.crt ]] &&
+        rm -rf /var/www/keystone_juju_ca_cert.crt
+      ln -s  /usr/local/share/ca-certificates/keystone_juju_ca_cert.crt \
+             /var/www/keystone_juju_ca_cert.crt
+    fi
+
+  fi
+  for port_map in $port_maps ; do
+    local ext_port=$(echo $port_map | cut -d: -f1)
+    local int_port=$(echo $port_map | cut -d: -f2)
+    juju-log "Creating apache2 reverse proxy vhost for $port_map."
+    cat >/etc/apache2/sites-available/${CHARM}_${ext_port} <<END
+Listen $ext_port
+NameVirtualHost *:$ext_port
+<VirtualHost *:$ext_port>
+    ServerName $(unit-get private-address)
+    SSLEngine on
+    SSLCertificateFile /etc/apache2/ssl/$CHARM/cert
+    SSLCertificateKeyFile /etc/apache2/ssl/$CHARM/key
+    ProxyPass / http://localhost:$int_port/
+    ProxyPassReverse / http://localhost:$int_port/
+    ProxyPreserveHost on
+</VirtualHost>
+<Proxy *>
+    Order deny,allow
+    Allow from all
+</Proxy>
+<Location />
+    Order allow,deny
+    Allow from all
+</Location>
+END
+    a2ensite ${CHARM}_${ext_port} | grep -v "To activate the new configuration" &&
+      http_restart=1
+  done
+  if [[ -n "$http_restart" ]] ; then
+    service apache2 restart
+  fi
+}
+
+##########################################################################
+# Description: Ensure HTTPS reverse proxying is disabled for given port
+# mappings.
+# Parameters:  Variable number of proxy port mappings as
+# $internal:$external.
+# Returns: 0 if reverse proxy is not active for all portmaps, 1 on error.
+##########################################################################
+disable_https() {
+  local port_maps="$@"
+  local http_restart=""
+  juju-log "Ensuring HTTPS disabled for $port_maps."
+  ( [[ ! -d /etc/apache2 ]] || [[ ! -d /etc/apache2/ssl/$CHARM ]] ) && return 0
+  for port_map in $port_maps ; do
+    local ext_port=$(echo $port_map | cut -d: -f1)
+    local int_port=$(echo $port_map | cut -d: -f2)
+    if [[ -e /etc/apache2/sites-available/${CHARM}_${ext_port} ]] ; then
+      juju-log "Disabling HTTPS reverse proxy for $CHARM $port_map."
+      a2dissite ${CHARM}_${ext_port} | grep -v "To activate the new configuration" &&
+        http_restart=1
+    fi
+  done
+  if [[ -n "$http_restart" ]] ; then
+    service apache2 restart
+  fi
+}
+
+
+##########################################################################
+# Description: Ensures HTTPS is either enabled or disabled for given port
+# mapping.
+# Parameters:  Variable number of proxy port mappings as
+# $internal:$external.
+# Returns: 0 if HTTPS reverse proxy is in place, 1 if it is not.
+##########################################################################
+setup_https() {
+  # configure https via apache reverse proxying either
+  # using certs provided by config or keystone.
+  [[ -z "$CHARM" ]] &&
+    error_out "setup_https(): CHARM not set."
+  if ! https ; then
+    disable_https $@
+  else
+    enable_https $@
+  fi
+}
+
+##########################################################################
+# Description: Determine correct API server listening port based on
+# existence of HTTPS reverse proxy and/or haproxy.
+# Paremeters: The standard public port for given service.
+# Returns: The correct listening port for API service.
+##########################################################################
+determine_api_port() {
+  local public_port="$1"
+  local i=0
+  ( [[ -n "$(peer_units)" ]] || is_clustered >/dev/null 2>&1 ) && i=$[$i + 1]
+  https >/dev/null 2>&1 && i=$[$i + 1]
+  echo $[$public_port - $[$i * 10]]
+}
+
+##########################################################################
+# Description: Determine correct proxy listening port based on public IP +
+# existence of HTTPS reverse proxy.
+# Paremeters: The standard public port for given service.
+# Returns: The correct listening port for haproxy service public address.
+##########################################################################
+determine_haproxy_port() {
+  local public_port="$1"
+  local i=0
+  https >/dev/null 2>&1 && i=$[$i + 1]
+  echo $[$public_port - $[$i * 10]]
+}
+
+##########################################################################
+# Description: Print the value for a given config option in an OpenStack
+# .ini style configuration file.
+# Parameters: File path, option to retrieve, optional
+# section name (default=DEFAULT)
+# Returns: Prints value if set, prints nothing otherwise.
+##########################################################################
+local_config_get() {
+  # return config values set in openstack .ini config files.
+  # default placeholders starting (eg, %AUTH_HOST%) treated as
+  # unset values.
+  local file="$1"
+  local option="$2"
+  local section="$3"
+  [[ -z "$section" ]] && section="DEFAULT"
+  python -c "
+import ConfigParser
+config = ConfigParser.RawConfigParser()
+config.read('$file')
+try:
+  value = config.get('$section', '$option')
+except:
+  print ''
+  exit(0)
+if value.startswith('%'): exit(0)
+print value
+"
+}
+
+##########################################################################
+# Description: Creates an rc file exporting environment variables to a
+# script_path local to the charm's installed directory.
+# Any charm scripts run outside the juju hook environment can source this
+# scriptrc to obtain updated config information necessary to perform health
+# checks or service changes
+#
+# Parameters:
+#   An array of '=' delimited  ENV_VAR:value combinations to export.
+#   If optional script_path key is not provided in the array, script_path
+#     defaults to scripts/scriptrc
+##########################################################################
+function save_script_rc {
+  if [ ! -n "$JUJU_UNIT_NAME" ]; then
+     echo "Error: Missing JUJU_UNIT_NAME environment variable"
+     exit 1
+  fi
+  # our default unit_path
+  unit_path="/var/lib/juju/units/${JUJU_UNIT_NAME/\//-}/charm/scripts/scriptrc"
+  echo $unit_path
+  tmp_rc="/tmp/${JUJU_UNIT_NAME/\//-}rc"
+
+  echo "#!/bin/bash" > $tmp_rc
+  for env_var in "${@}"
+  do
+    if `echo $env_var | grep -q script_path`; then
+       # well then we need to reset the new unit-local script path
+       unit_path="/var/lib/juju/units/${JUJU_UNIT_NAME/\//-}/charm/${env_var/script_path=/}"
+    else
+       echo "export $env_var" >> $tmp_rc
+    fi
+  done
+  chmod 755 $tmp_rc
+  mv $tmp_rc $unit_path
+}

=== added file 'hooks/charmhelpers/contrib/openstack/openstack_utils.py'
--- hooks/charmhelpers/contrib/openstack/openstack_utils.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/openstack/openstack_utils.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,228 @@
+#!/usr/bin/python
+
+# Common python helper functions used for OpenStack charms.
+
+import apt_pkg as apt
+import subprocess
+import os
+import sys
+
+CLOUD_ARCHIVE_URL = "http://ubuntu-cloud.archive.canonical.com/ubuntu"
+CLOUD_ARCHIVE_KEY_ID = '5EDB1B62EC4926EA'
+
+ubuntu_openstack_release = {
+    'oneiric': 'diablo',
+    'precise': 'essex',
+    'quantal': 'folsom',
+    'raring': 'grizzly',
+}
+
+
+openstack_codenames = {
+    '2011.2': 'diablo',
+    '2012.1': 'essex',
+    '2012.2': 'folsom',
+    '2013.1': 'grizzly',
+    '2013.2': 'havana',
+}
+
+# The ugly duckling
+swift_codenames = {
+    '1.4.3': 'diablo',
+    '1.4.8': 'essex',
+    '1.7.4': 'folsom',
+    '1.7.6': 'grizzly',
+    '1.7.7': 'grizzly',
+    '1.8.0': 'grizzly',
+}
+
+
+def juju_log(msg):
+    subprocess.check_call(['juju-log', msg])
+
+
+def error_out(msg):
+    juju_log("FATAL ERROR: %s" % msg)
+    sys.exit(1)
+
+
+def lsb_release():
+    '''Return /etc/lsb-release in a dict'''
+    lsb = open('/etc/lsb-release', 'r')
+    d = {}
+    for l in lsb:
+        k, v = l.split('=')
+        d[k.strip()] = v.strip()
+    return d
+
+
+def get_os_codename_install_source(src):
+    '''Derive OpenStack release codename from a given installation source.'''
+    ubuntu_rel = lsb_release()['DISTRIB_CODENAME']
+
+    rel = ''
+    if src == 'distro':
+        try:
+            rel = ubuntu_openstack_release[ubuntu_rel]
+        except KeyError:
+            e = 'Could not derive openstack release for '\
+                'this Ubuntu release: %s' % ubuntu_rel
+            error_out(e)
+        return rel
+
+    if src.startswith('cloud:'):
+        ca_rel = src.split(':')[1]
+        ca_rel = ca_rel.split('%s-' % ubuntu_rel)[1].split('/')[0]
+        return ca_rel
+
+    # Best guess match based on deb string provided
+    if src.startswith('deb') or src.startswith('ppa'):
+        for k, v in openstack_codenames.iteritems():
+            if v in src:
+                return v
+
+
+def get_os_codename_version(vers):
+    '''Determine OpenStack codename from version number.'''
+    try:
+        return openstack_codenames[vers]
+    except KeyError:
+        e = 'Could not determine OpenStack codename for version %s' % vers
+        error_out(e)
+
+
+def get_os_version_codename(codename):
+    '''Determine OpenStack version number from codename.'''
+    for k, v in openstack_codenames.iteritems():
+        if v == codename:
+            return k
+    e = 'Could not derive OpenStack version for '\
+        'codename: %s' % codename
+    error_out(e)
+
+
+def get_os_codename_package(pkg):
+    '''Derive OpenStack release codename from an installed package.'''
+    apt.init()
+    cache = apt.Cache()
+
+    try:
+        pkg = cache[pkg]
+    except:
+        e = 'Could not determine version of installed package: %s' % pkg
+        error_out(e)
+
+    vers = apt.UpstreamVersion(pkg.current_ver.ver_str)
+
+    try:
+        if 'swift' in pkg.name:
+            vers = vers[:5]
+            return swift_codenames[vers]
+        else:
+            vers = vers[:6]
+            return openstack_codenames[vers]
+    except KeyError:
+        e = 'Could not determine OpenStack codename for version %s' % vers
+        error_out(e)
+
+
+def get_os_version_package(pkg):
+    '''Derive OpenStack version number from an installed package.'''
+    codename = get_os_codename_package(pkg)
+
+    if 'swift' in pkg:
+        vers_map = swift_codenames
+    else:
+        vers_map = openstack_codenames
+
+    for version, cname in vers_map.iteritems():
+        if cname == codename:
+            return version
+    #e = "Could not determine OpenStack version for package: %s" % pkg
+    #error_out(e)
+
+def import_key(keyid):
+    cmd = "apt-key adv --keyserver keyserver.ubuntu.com " \
+          "--recv-keys %s" % keyid
+    try:
+        subprocess.check_call(cmd.split(' '))
+    except subprocess.CalledProcessError:
+        error_out("Error importing repo key %s" % keyid)
+
+def configure_installation_source(rel):
+    '''Configure apt installation source.'''
+    if rel == 'distro':
+        return
+    elif rel[:4] == "ppa:":
+        src = rel
+        subprocess.check_call(["add-apt-repository", "-y", src])
+    elif rel[:3] == "deb":
+        l = len(rel.split('|'))
+        if l == 2:
+            src, key = rel.split('|')
+            juju_log("Importing PPA key from keyserver for %s" % src)
+            import_key(key)
+        elif l == 1:
+            src = rel
+        with open('/etc/apt/sources.list.d/juju_deb.list', 'w') as f:
+            f.write(src)
+    elif rel[:6] == 'cloud:':
+        ubuntu_rel = lsb_release()['DISTRIB_CODENAME']
+        rel = rel.split(':')[1]
+        u_rel = rel.split('-')[0]
+        ca_rel = rel.split('-')[1]
+
+        if u_rel != ubuntu_rel:
+            e = 'Cannot install from Cloud Archive pocket %s on this Ubuntu '\
+                'version (%s)' % (ca_rel, ubuntu_rel)
+            error_out(e)
+
+        if 'staging' in ca_rel:
+            # staging is just a regular PPA.
+            os_rel = ca_rel.split('/')[0]
+            ppa = 'ppa:ubuntu-cloud-archive/%s-staging' % os_rel
+            cmd = 'add-apt-repository -y %s' % ppa
+            subprocess.check_call(cmd.split(' '))
+            return
+
+        # map charm config options to actual archive pockets.
+        pockets = {
+            'folsom': 'precise-updates/folsom',
+            'folsom/updates': 'precise-updates/folsom',
+            'folsom/proposed': 'precise-proposed/folsom',
+            'grizzly': 'precise-updates/grizzly',
+            'grizzly/updates': 'precise-updates/grizzly',
+            'grizzly/proposed': 'precise-proposed/grizzly'
+        }
+
+        try:
+            pocket = pockets[ca_rel]
+        except KeyError:
+            e = 'Invalid Cloud Archive release specified: %s' % rel
+            error_out(e)
+
+        src = "deb %s %s main" % (CLOUD_ARCHIVE_URL, pocket)
+        # TODO: Replace key import with cloud archive keyring pkg.
+        import_key(CLOUD_ARCHIVE_KEY_ID)
+
+        with open('/etc/apt/sources.list.d/cloud-archive.list', 'w') as f:
+            f.write(src)
+    else:
+        error_out("Invalid openstack-release specified: %s" % rel)
+
+
+def save_script_rc(script_path="scripts/scriptrc", **env_vars):
+    """
+    Write an rc file in the charm-delivered directory containing
+    exported environment variables provided by env_vars. Any charm scripts run
+    outside the juju hook environment can source this scriptrc to obtain
+    updated config information necessary to perform health checks or
+    service changes.
+    """
+    unit_name = os.getenv('JUJU_UNIT_NAME').replace('/', '-')
+    juju_rc_path = "/var/lib/juju/units/%s/charm/%s" % (unit_name, script_path)
+    with open(juju_rc_path, 'wb') as rc_script:
+        rc_script.write(
+            "#!/bin/bash\n")
+        [rc_script.write('export %s=%s\n' % (u, p))
+         for u, p in env_vars.iteritems() if u != "script_path"]

=== added directory 'hooks/charmhelpers/core'
=== added file 'hooks/charmhelpers/core/__init__.py'
=== added file 'hooks/charmhelpers/core/hookenv.py'
--- hooks/charmhelpers/core/hookenv.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/core/hookenv.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,267 @@
+"Interactions with the Juju environment"
+# Copyright 2013 Canonical Ltd.
+#
+# Authors:
+#  Charm Helpers Developers <[e-mail]>
+
+import os
+import json
+import yaml
+import subprocess
+import UserDict
+
+CRITICAL = "CRITICAL"
+ERROR = "ERROR"
+WARNING = "WARNING"
+INFO = "INFO"
+DEBUG = "DEBUG"
+MARKER = object()
+
+
+def log(message, level=None):
+    "Write a message to the juju log"
+    command = ['juju-log']
+    if level:
+        command += ['-l', level]
+    command += [message]
+    subprocess.call(command)
+
+
+class Serializable(UserDict.IterableUserDict):
+    "Wrapper, an object that can be serialized to yaml or json"
+
+    def __init__(self, obj):
+        # wrap the object
+        UserDict.IterableUserDict.__init__(self)
+        self.data = obj
+
+    def __getattr__(self, attr):
+        # See if this object has attribute.
+        if attr in ("json", "yaml", "data"):
+            return self.__dict__[attr]
+        # Check for attribute in wrapped object.
+        got = getattr(self.data, attr, MARKER)
+        if got is not MARKER:
+            return got
+        # Proxy to the wrapped object via dict interface.
+        try:
+            return self.data[attr]
+        except KeyError:
+            raise AttributeError(attr)
+
+    def json(self):
+        "Serialize the object to json"
+        return json.dumps(self.data)
+
+    def yaml(self):
+        "Serialize the object to yaml"
+        return yaml.dump(self.data)
+
+
+def execution_environment():
+    """A convenient bundling of the current execution context"""
+    context = {}
+    context['conf'] = config()
+    context['reltype'] = relation_type()
+    context['relid'] = relation_id()
+    context['unit'] = local_unit()
+    context['rels'] = relations()
+    context['rel'] = relation_get()
+    context['env'] = os.environ
+    return context
+
+
+def in_relation_hook():
+    "Determine whether we're running in a relation hook"
+    return 'JUJU_RELATION' in os.environ
+
+
+def relation_type():
+    "The scope for the current relation hook"
+    return os.environ.get('JUJU_RELATION', None)
+
+
+def relation_id():
+    "The relation ID for the current relation hook"
+    return os.environ.get('JUJU_RELATION_ID', None)
+
+
+def local_unit():
+    "Local unit ID"
+    return os.environ['JUJU_UNIT_NAME']
+
+
+def remote_unit():
+    "The remote unit for the current relation hook"
+    return os.environ['JUJU_REMOTE_UNIT']
+
+
+def config(scope=None):
+    "Juju charm configuration"
+    config_cmd_line = ['config-get']
+    if scope is not None:
+        config_cmd_line.append(scope)
+    config_cmd_line.append('--format=json')
+    try:
+        config_data = json.loads(subprocess.check_output(config_cmd_line))
+    except (ValueError, OSError, subprocess.CalledProcessError) as err:
+        log(str(err), level=ERROR)
+        raise
+    return Serializable(config_data)
+
+
+def relation_get(attribute=None, unit=None, rid=None):
+    _args = ['relation-get', '--format=json']
+    if rid:
+        _args.append('-r')
+        _args.append(rid)
+    _args.append(attribute or '-')
+    if unit:
+        _args.append(unit)
+    try:
+        return json.loads(subprocess.check_output(_args))
+    except ValueError:
+        return None
+
+
+def relation_set(relation_id=None, relation_settings={}, **kwargs):
+    relation_cmd_line = ['relation-set']
+    if relation_id is not None:
+        relation_cmd_line.extend(('-r', relation_id))
+    for k, v in relation_settings.items():
+        relation_cmd_line.append('{}={}'.format(k, v))
+    for k, v in kwargs.items():
+        relation_cmd_line.append('{}={}'.format(k, v))
+    subprocess.check_call(relation_cmd_line)
+
+
+def relation_ids(reltype=None):
+    "A list of relation_ids"
+    reltype = reltype or relation_type()
+    relid_cmd_line = ['relation-ids', '--format=json']
+    if reltype is not None:
+        relid_cmd_line.append(reltype)
+        return json.loads(subprocess.check_output(relid_cmd_line))
+    return []
+
+
+def related_units(relid=None):
+    "A list of related units"
+    relid = relid or relation_id()
+    units_cmd_line = ['relation-list', '--format=json']
+    if relid is not None:
+        units_cmd_line.extend(('-r', relid))
+    return json.loads(subprocess.check_output(units_cmd_line))
+
+
+def relation_for_unit(unit=None, rid=None):
+    "Get the json represenation of a unit's relation"
+    unit = unit or remote_unit()
+    relation = relation_get(unit=unit, rid=rid)
+    for key in relation:
+        if key.endswith('-list'):
+            relation[key] = relation[key].split()
+    relation['__unit__'] = unit
+    return Serializable(relation)
+
+
+def relations_for_id(relid=None):
+    "Get relations of a specific relation ID"
+    relation_data = []
+    relid = relid or relation_ids()
+    for unit in related_units(relid):
+        unit_data = relation_for_unit(unit, relid)
+        unit_data['__relid__'] = relid
+        relation_data.append(unit_data)
+    return relation_data
+
+
+def relations_of_type(reltype=None):
+    "Get relations of a specific type"
+    relation_data = []
+    reltype = reltype or relation_type()
+    for relid in relation_ids(reltype):
+        for relation in relations_for_id(relid):
+            relation['__relid__'] = relid
+            relation_data.append(relation)
+    return relation_data
+
+
+def relation_types():
+    "Get a list of relation types supported by this charm"
+    charmdir = os.environ.get('CHARM_DIR', '')
+    mdf = open(os.path.join(charmdir, 'metadata.yaml'))
+    md = yaml.safe_load(mdf)
+    rel_types = []
+    for key in ('provides','requires','peers'):
+        section = md.get(key)
+        if section:
+            rel_types.extend(section.keys())
+    mdf.close()
+    return rel_types
+
+
+def relations():
+    rels = {}
+    for reltype in relation_types():
+        relids = {}
+        for relid in relation_ids(reltype):
+            units = {}
+            for unit in related_units(relid):
+                reldata = relation_get(unit=unit, rid=relid)
+                units[unit] = reldata
+            relids[relid] = units
+        rels[reltype] = relids
+    return rels
+
+
+def open_port(port, protocol="TCP"):
+    "Open a service network port"
+    _args = ['open-port']
+    _args.append('{}/{}'.format(port, protocol))
+    subprocess.check_call(_args)
+
+
+def close_port(port, protocol="TCP"):
+    "Close a service network port"
+    _args = ['close-port']
+    _args.append('{}/{}'.format(port, protocol))
+    subprocess.check_call(_args)
+
+
+def unit_get(attribute):
+    _args = ['unit-get', attribute]
+    return subprocess.check_output(_args).strip()
+
+
+def unit_private_ip():
+    return unit_get('private-address')
+
+
+class UnregisteredHookError(Exception):
+    pass
+
+
+class Hooks(object):
+    def __init__(self):
+        super(Hooks, self).__init__()
+        self._hooks = {}
+
+    def register(self, name, function):
+        self._hooks[name] = function
+
+    def execute(self, args):
+        hook_name = os.path.basename(args[0])
+        if hook_name in self._hooks:
+            self._hooks[hook_name]()
+        else:
+            raise UnregisteredHookError(hook_name)
+
+    def hook(self, *hook_names):
+        def wrapper(decorated):
+            for hook_name in hook_names:
+                self.register(hook_name, decorated)
+            else:
+                self.register(decorated.__name__, decorated)
+            return decorated
+        return wrapper

=== added file 'hooks/charmhelpers/core/host.py'
--- hooks/charmhelpers/core/host.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/core/host.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,188 @@
+"""Tools for working with the host system"""
+# Copyright 2012 Canonical Ltd.
+#
+# Authors:
+#  Nick Moffitt <[e-mail]>
+#  Matthew Wedgwood <[e-mail]>
+
+import os
+import pwd
+import grp
+import subprocess
+
+from hookenv import log, execution_environment
+
+
+def service_start(service_name):
+    service('start', service_name)
+
+
+def service_stop(service_name):
+    service('stop', service_name)
+
+
+def service(action, service_name):
+    cmd = None
+    if os.path.exists(os.path.join('/etc/init', '%s.conf' % service_name)):
+        cmd = ['initctl', action, service_name]
+    elif os.path.exists(os.path.join('/etc/init.d', service_name)):
+        cmd = [os.path.join('/etc/init.d', service_name), action]
+    if cmd:
+        return_value = subprocess.call(cmd)
+        return return_value == 0
+    return False
+
+
+def adduser(username, password, shell='/bin/bash'):
+    """Add a user"""
+    # TODO: generate a password if none is given
+    try:
+        user_info = pwd.getpwnam(username)
+        log('user {0} already exists!'.format(username))
+    except KeyError:
+        log('creating user {0}'.format(username))
+        cmd = [
+            'useradd',
+            '--create-home',
+            '--shell', shell,
+            '--password', password,
+            username
+        ]
+        subprocess.check_call(cmd)
+        user_info = pwd.getpwnam(username)
+    return user_info
+
+
+def add_user_to_group(username, group):
+    """Add a user to a group"""
+    cmd = [
+        'gpasswd', '-a',
+        username,
+        group
+    ]
+    log("Adding user {} to group {}".format(username, group))
+    subprocess.check_call(cmd)
+
+
+def rsync(from_path, to_path, flags='-r', options=None):
+    """Replicate the contents of a path"""
+    context = execution_environment()
+    options = options or ['--delete', '--executability']
+    cmd = ['/usr/bin/rsync', flags]
+    cmd.extend(options)
+    cmd.append(from_path.format(**context))
+    cmd.append(to_path.format(**context))
+    log(" ".join(cmd))
+    return subprocess.check_output(cmd).strip()
+
+
+def symlink(source, destination):
+    """Create a symbolic link"""
+    context = execution_environment()
+    log("Symlinking {} as {}".format(source, destination))
+    cmd = [
+        'ln',
+        '-sf',
+        source.format(**context),
+        destination.format(**context)
+    ]
+    subprocess.check_call(cmd)
+
+
+def mkdir(path, owner='root', group='root', perms=0555, force=False):
+    """Create a directory"""
+    context = execution_environment()
+    log("Making dir {} {}:{} {:o}".format(path, owner, group,
+                                          perms))
+    uid = pwd.getpwnam(owner.format(**context)).pw_uid
+    gid = grp.getgrnam(group.format(**context)).gr_gid
+    realpath = os.path.abspath(path)
+    if os.path.exists(realpath):
+        if force and not os.path.isdir(realpath):
+            log("Removing non-directory file {} prior to mkdir()".format(path))
+            os.unlink(realpath)
+    else:
+        os.makedirs(realpath, perms)
+    os.chown(realpath, uid, gid)
+
+
+def write_file(path, fmtstr, owner='root', group='root', perms=0444, **kwargs):
+    """Create or overwrite a file with the contents of a string"""
+    context = execution_environment()
+    context.update(kwargs)
+    log("Writing file {} {}:{} {:o}".format(path, owner, group,
+        perms))
+    uid = pwd.getpwnam(owner.format(**context)).pw_uid
+    gid = grp.getgrnam(group.format(**context)).gr_gid
+    with open(path.format(**context), 'w') as target:
+        os.fchown(target.fileno(), uid, gid)
+        os.fchmod(target.fileno(), perms)
+        target.write(fmtstr.format(**context))
+
+
+def render_template_file(source, destination, **kwargs):
+    """Create or overwrite a file using a template"""
+    log("Rendering template {} for {}".format(source,
+        destination))
+    context = execution_environment()
+    with open(source.format(**context), 'r') as template:
+        write_file(destination.format(**context), template.read(),
+                   **kwargs)
+
+
+def apt_install(packages, options=None, fatal=False):
+    """Install one or more packages"""
+    options = options or []
+    cmd = ['apt-get', '-y']
+    cmd.extend(options)
+    cmd.append('install')
+    if isinstance(packages, basestring):
+        cmd.append(packages)
+    else:
+        cmd.extend(packages)
+    log("Installing {} with options: {}".format(packages,
+                                                options))
+    if fatal:
+        subprocess.check_call(cmd)
+    else:
+        subprocess.call(cmd)
+
+
+def mount(device, mountpoint, options=None, persist=False):
+    '''Mount a filesystem'''
+    cmd_args = ['mount']
+    if options is not None:
+        cmd_args.extend(['-o', options])
+    cmd_args.extend([device, mountpoint])
+    try:
+        subprocess.check_output(cmd_args)
+    except subprocess.CalledProcessError, e:
+        log('Error mounting {} at {}\n{}'.format(device, mountpoint, e.output))
+        return False
+    if persist:
+        # TODO: update fstab
+        pass
+    return True
+
+
+def umount(mountpoint, persist=False):
+    '''Unmount a filesystem'''
+    cmd_args = ['umount', mountpoint]
+    try:
+        subprocess.check_output(cmd_args)
+    except subprocess.CalledProcessError, e:
+        log('Error unmounting {}\n{}'.format(mountpoint, e.output))
+        return False
+    if persist:
+        # TODO: update fstab
+        pass
+    return True
+
+
+def mounts():
+    '''List of all mounted volumes as [[mountpoint,device],[...]]'''
+    with open('/proc/mounts') as f:
+        # [['/mount/point','/dev/path'],[...]]
+        system_mounts = [m[1::-1] for m in [l.strip().split()
+                                            for l in f.readlines()]]
+    return system_mounts

=== added directory 'hooks/charmhelpers/fetch'
=== added file 'hooks/charmhelpers/fetch/__init__.py'
--- hooks/charmhelpers/fetch/__init__.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/fetch/__init__.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,46 @@
+from yaml import safe_load
+from core.hookenv import config_get
+from subprocess import check_call
+
+
+def add_source(source, key=None):
+    if ((source.startswith('ppa:') or
+         source.startswith('cloud:') or
+         source.startswith('http:'))):
+        check_call('add-apt-repository', source)
+    if key:
+        check_call('apt-key', 'import', key)
+
+
+class SourceConfigError(Exception):
+    pass
+
+
+def configure_sources(update=False,
+                      sources_var='install_sources',
+                      keys_var='install_keys'):
+    """
+    Configure multiple sources from charm configuration
+
+    Example config:
+        install_sources:
+          - "ppa:foo"
+          - "http://example.com/repo precise main"
+        install_keys:
+          - null
+          - "a1b2c3d4"
+
+    Note that 'null' (a.k.a. None) should not be quoted.
+    """
+    sources = safe_load(config_get(sources_var))
+    keys = safe_load(config_get(keys_var))
+    if isinstance(sources, basestring) and isinstance(keys, basestring):
+        add_source(sources, keys)
+    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], sources[src_num])
+    if update:
+        check_call(('apt-get', 'update'))

=== added directory 'hooks/charmhelpers/payload'
=== added file 'hooks/charmhelpers/payload/__init__.py'
--- hooks/charmhelpers/payload/__init__.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/payload/__init__.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,1 @@
+"Tools for working with files injected into a charm just before deployment."

=== added file 'hooks/charmhelpers/payload/execd.py'
--- hooks/charmhelpers/payload/execd.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/payload/execd.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+
+import os
+import sys
+import subprocess
+from charmhelpers.core import hookenv
+
+
+def default_execd_dir():
+    return os.path.join(os.environ['CHARM_DIR'],'exec.d')
+
+
+def execd_module_paths(execd_dir=None):
+    if not execd_dir:
+        execd_dir = default_execd_dir()
+    for subpath in os.listdir(execd_dir):
+        module = os.path.join(execd_dir, subpath)
+        if os.path.isdir(module):
+            yield module
+
+
+def execd_submodule_paths(submodule, execd_dir=None):
+    for module_path in execd_module_paths(execd_dir):
+        path = os.path.join(module_path, submodule)
+        if os.access(path, os.X_OK) and os.path.isfile(path):
+            yield path
+
+
+def execd_run(submodule, execd_dir=None, die_on_error=False):
+    for submodule_path in execd_submodule_paths(submodule, execd_dir):
+        try:
+            subprocess.check_call(submodule_path, shell=True)
+        except subprocess.CalledProcessError as e:
+            hookenv.log(e.output)
+            if die_on_error:
+                sys.exit(e.returncode)
+
+
+def execd_preinstall(execd_dir=None):
+    execd_run(execd_dir, 'charm-pre-install')

=== modified symlink 'hooks/config-changed'
=== target changed u'ep-common' => u'hooks.py'
=== modified symlink 'hooks/db-relation-broken'
=== target changed u'ep-common' => u'hooks.py'
=== modified symlink 'hooks/db-relation-changed'
=== target changed u'ep-common' => u'hooks.py'
=== modified symlink 'hooks/db-relation-joined'
=== target changed u'ep-common' => u'hooks.py'
=== removed file 'hooks/ep-common'
--- hooks/ep-common	2013-01-11 01:00:42 +0000
+++ hooks/ep-common	1970-01-01 00:00:00 +0000
@@ -1,164 +0,0 @@
-#!/bin/bash
-
-set -e
-
-# Common configuration for all scripts
-app_name="etherpad-lite"
-app_dir="/opt/${app_name}"
-app_user="ubuntu"
-app_scm="git"
-app_url="https://github.com/ether/etherpad-lite.git"
-app_branch="master"
-
-umask 002
-
-start_ep () {
-    start ${app_name} || :
-}
-
-stop_ep () {
-    stop ${app_name} || :
-}
-
-restart_ep () {
-    restart ${app_name} || start ${app_name}
-}
-
-install_node () {
-    juju-log "Installing node..."
-    apt-get update
-    apt-get -y install -qq nodejs nodejs-dev build-essential npm curl
-}
-
-install_ep () {
-    juju-log "Installing ${app_name}..."
-    apt-get -y install -qq git-core daemon gzip abiword
-    if [ ! -d ${app_dir} ]; then
-        git clone ${app_url} ${app_dir} -b ${app_branch}
-    fi
-}
-
-update_ep () {
-    juju-log "Updating ${app_nane}..."
-    if [ -d ${app_dir} ]; then
-    (
-        cd ${app_dir}
-        git checkout master
-        git pull
-        git checkout $(config-get commit)
-        npm install
-    )
-    fi
-
-    # Modifiy the app so $app_user can write to it 
-    # needed as starts up with a dirty database
-    chown -Rf ${app_user}.${app_user} ${app_dir}
-}
-
-install_upstart_config () {
-    juju-log "Installing upstart configuration for etherpad-lite"
-    cat > /etc/init/${app_name}.conf <<EOS
-description "${app_name} server"
- 
-start on runlevel [2345]
-stop on runlevel [!2345]
-
-limit nofile 8192 8192
-
-pre-start script
-  touch /var/log/${app_name}.log || true
-  chown ${app_user}:${app_user} /var/log/${app_name}.log || true
-end script
-
-script
-  exec daemon --name=${app_name} --inherit --user=${app_user} --output=/var/log/${app_name}.log \
-    -- ${app_dir}/bin/run.sh 
-end script
-EOS
-}
-
-configure_dirty_ep () {
-    juju-log "Configurating ${app_name} with default dirty database..."
-    cp templates/settings.json.dirty /opt/${app_name}/settings.json
-}
-
-configure_mysql_ep () {
-    # Get the database settings; if not set, wait for this hook to be
-    # invoked again
-    host=`relation-get host`
-    if [ -z "$host" ] ; then
-        exit 0 # wait for future handshake from database service unit
-    fi
-
-    # Get rest of mysql setup
-    user=`relation-get user`
-    password=`relation-get password`
-    database=`relation-get database`
-
-    juju-log "configuring ${app_name} to work with the mysql service"
-
-    config_file_path=$app_dir/settings.json
-
-    cp templates/settings.json.mysql $config_file_path
-    if [ -f $config_file_path ]; then
-      juju-log "Writing $app_name config file $config_file_path"
-      sed -i "s/DB_USER/${user}/g" $config_file_path
-      sed -i "s/DB_HOST/${host}/g" $config_file_path
-      sed -i "s/DB_PASS/${password}/g" $config_file_path
-      sed -i "s/DB_NAME/${database}/g" $config_file_path
-    fi
-}
-
-configure_website () {
-    juju-log "Setting relation parameters for website..."
-    relation-set port="9001" hostname=`unit-get private-address`
-}
-
-open_ports () {
-    juju-log "Opening ports for access to ${app_name}"
-    open-port 9001
-}
-
-COMMAND=`basename $0`
-
-
-case $COMMAND in
-    install)
-        install_node
-        install_ep
-        update_ep
-        install_upstart_config
-        configure_dirty_ep
-        ;;
-    start)
-        start_ep
-        open_ports
-        ;;
-    stop)
-        stop_ep
-        ;;
-    upgrade-charm)
-        install_node
-        update_ep
-        install_upstart_config
-        restart_ep
-        ;;
-    config-changed)
-        update_ep
-        restart_ep
-        ;;
-    website-relation-joined)
-        configure_website
-        ;;
-    db-relation-joined|db-relation-changed)
-        configure_mysql_ep 
-        restart_ep
-        ;;
-    db-relation-broken)
-        configure_dirty_ep
-        restart_ep
-        ;; 
-    *)
-        juju-log "Command not recognised"
-        ;;
-esac

=== added file 'hooks/hooks.py'
--- hooks/hooks.py	1970-01-01 00:00:00 +0000
+++ hooks/hooks.py	2013-07-09 03:52:26 +0000
@@ -0,0 +1,177 @@
+#!/usr/bin/python
+import os.path
+import sys
+import subprocess
+import uuid
+import pwd
+import grp
+
+from charmhelpers.core.host import (
+    service_start,
+    service_stop,
+    adduser,
+    apt_install,
+    log,
+    mkdir,
+    symlink,
+)
+
+from charmhelpers.core.hookenv import (
+    Hooks,
+    relation_get,
+    relation_set,
+    relation_ids,
+    related_units,
+    config,
+    execution_environment,
+)
+
+hooks = Hooks()
+
+required_pkgs = [
+    'nodejs',
+    'curl',
+    'bzr',
+    'daemon',
+    'abiword',
+    'npm',
+]
+
+APP_DIR = str(config("install_path"))
+APP_NAME = str(config("application_name"))
+APP_USER = str(config("application_user"))
+APP_URL = str(config("application_url"))
+APP_REVNO = str(config("application_revision"))
+
+def write_file(path, fmtstr, owner='root', group='root', perms=0444, context=None):
+    """Create or overwrite a file with the contents of a string"""
+    if context == None:
+        context = {}
+    else:
+        context = dict(context)
+        context.update(execution_environment())
+    log("Writing file {} {}:{} {:o}".format(path, owner, group,
+        perms))
+    uid = pwd.getpwnam(owner.format(**context)).pw_uid
+    gid = grp.getgrnam(group.format(**context)).gr_gid
+    with open(path.format(**context), 'w') as target:
+        os.fchown(target.fileno(), uid, gid)
+        os.fchmod(target.fileno(), perms)
+        target.write(fmtstr.format(**context))
+
+def render_template_file(source, destination, **context):
+    """Create or overwrite a file using a template"""
+    log("Rendering template {} for {}".format(source,
+        destination))
+    with open(source, 'r') as template:
+        write_file(destination, template.read(),
+            context=context)
+
+def add_extra_repos():
+    extra_repos = config('extra_archives')
+    if extra_repos.data: #serialize cannot be cast as boolean
+        repos_added = False
+        extra_repos_added = set()
+        for repo in extra_repos.split():
+            if repo not in extra_repos_added:
+                subprocess.check_call(['add-apt-repository', '--yes', repo])
+                extra_repos_added.add(repo)
+                repos_added = True
+        if repos_added:
+            subprocess.check_call(['apt-get', 'update'])
+
+def start():
+    subprocess.check_call(['open-port','9001'])
+    service_start(APP_NAME)
+
+def stop():
+    service_stop(APP_NAME)
+
+def configure_dirty():
+    log("Configuring {} with local dirty database.".format(APP_NAME))
+    stop()
+    render_template_file("templates/settings.json.dirty", "{}/settings.json".format(APP_DIR),
+        APP_DIR=APP_DIR)
+    mkdir("{}-db/".format(APP_DIR), APP_USER, APP_USER, 0700)
+    start()
+
+def configure_mysql():
+    log("Configuring {} with mysql database.".format(APP_NAME))
+    host = relation_get("host")
+    if not host:
+        return
+    user = relation_get("user")
+    password = relation_get("password")
+    database = relation_get("database")
+    stop()
+    render_template_file("templates/settings.json.mysql", "{}/settings.json".format(APP_DIR),
+        host=host, user=user, password=password, database=database)
+    start()
+
[e-mail]("install")
+def install():
+    log("Installing {}".format(APP_NAME))
+    add_extra_repos()
+    apt_install(required_pkgs, options=['--force-yes'])
+    adduser(APP_USER, str(uuid.uuid4()))
+    installdir = APP_DIR+"."+str(uuid.uuid4())
+    subprocess.check_call(['bzr', 'branch', '-r', APP_REVNO, APP_URL, installdir])
+    write_file("{}/APIKEY.txt".format(installdir), str(uuid.uuid4()), APP_USER, APP_USER, 0600)
+    write_file("{}/src/.ep_initialized".format(installdir), "", APP_USER, APP_USER, 0600)
+    stop()
+    if os.path.exists(APP_DIR):
+        os.unlink(APP_DIR)
+    symlink(installdir, APP_DIR)
+    mkdir("{}/var".format(APP_DIR), APP_USER, APP_USER, 0700)
+    units = relation_ids("db")
+    if not units:
+        configure_dirty()
+    else:
+        configure_mysql()
+    start()
+
[e-mail]("config-changed")
+def config_change():
+    log("Installing upstart configuration for {}".format(APP_NAME))
+    render_template_file('templates/etherpad-lite.conf', '/etc/init/etherpad-lite.conf',
+         APP_NAME=APP_NAME, APP_USER=APP_USER, APP_DIR=APP_DIR)
+    configure_dirty()
+    stop()
+    start()
+
[e-mail]("upgrade-charm")
+def upgrade_charm():
+    log("Upgrading charm for {}".format(APP_NAME))
+    install()
+
[e-mail]("db-relation-joined")
+def db_relation_joined():
+    configure_mysql()
+
[e-mail]("db-relation-changed")
+def db_relation_changed():
+    configure_mysql()
+
[e-mail]("db-relation-broken")
+def db_relation_broken():
+    configure_dirty()
+
[e-mail]("pgsql-relation-joined")
+def pgsql_relation_joined():
+    configure_pgsql()
+
[e-mail]("pgsql-relation-changed")
+def pgsql_relation_changed():
+    configure_pgsql()
+
[e-mail]("pgsql-relation-broken")
+def pgsql_relation_broken():
+    configure_dirty()
+
[e-mail]("website-relation-joined")
+def website_relation_joined():
+    log("Adding website relation for {}".format(APP_NAME))
+    relation_set(port="9001", hostname=subprocess.check_output(["unit-get","private-address"]))
+
+if __name__ == "__main__":
+    hooks.execute(sys.argv)

=== modified symlink 'hooks/install'
=== target changed u'ep-common' => u'hooks.py'
=== removed symlink 'hooks/start'
=== target was u'ep-common'
=== removed symlink 'hooks/stop'
=== target was u'ep-common'
=== modified symlink 'hooks/upgrade-charm'
=== target changed u'ep-common' => u'hooks.py'
=== modified symlink 'hooks/website-relation-joined'
=== target changed u'ep-common' => u'hooks.py'
=== modified file 'metadata.yaml'
--- metadata.yaml	2012-05-22 11:05:30 +0000
+++ metadata.yaml	2013-07-09 03:52:26 +0000
@@ -6,6 +6,9 @@
   db:
     interface: mysql
     optional: true
+  pgsql:
+    interface: pgsql
+    optional: true
 provides:
   website:
     interface: http

=== modified file 'revision'
--- revision	2012-07-06 08:32:44 +0000
+++ revision	2013-07-09 03:52:26 +0000
@@ -1,1 +1,1 @@
-22
+177

=== added file 'templates/etherpad-lite.conf'
--- templates/etherpad-lite.conf	1970-01-01 00:00:00 +0000
+++ templates/etherpad-lite.conf	2013-07-09 03:52:26 +0000
@@ -0,0 +1,16 @@
+description "{APP_NAME} server"
+ 
+start on runlevel [2345]
+stop on runlevel [!2345]
+
+limit nofile 8192 8192
+
+pre-start script
+  touch /var/log/{APP_NAME}.log || true
+  chown {APP_USER}:{APP_USER} /var/log/{APP_NAME}.log || true
+end script
+
+script
+  exec daemon --name={APP_NAME} --inherit --user={APP_USER} \
+    --output=/var/log/{APP_NAME}.log -- {APP_DIR}/bin/run.sh 
+end script

=== modified file 'templates/settings.json.dirty'
--- templates/settings.json.dirty	2011-09-28 12:53:35 +0000
+++ templates/settings.json.dirty	2013-07-09 03:52:26 +0000
@@ -1,12 +1,12 @@
-{
+{{
   "ip": "0.0.0.0",
   "port" : 9001,
   "dbType" : "dirty",
-  "dbSettings" : {
-                   "filename" : "../var/dirty.db"
-                 },
+  "dbSettings" : {{
+                   "filename" : "{APP_DIR}-db/dirty.db"
+                 }},
   "defaultPadText" : "Welcome to Etherpad Lite!\n\nThis pad text is synchronized as you type, so that everyone viewing this page sees the same text. This allows you to collaborate seamlessly on documents!\n\nEtherpad Lite on Github: http:\/\/j.mp/ep-lite\n",
   "minify" : true,
   "abiword" : "/usr/bin/abiword",
   "loglevel" : "INFO"
-}
+}}

=== modified file 'templates/settings.json.mysql'
--- templates/settings.json.mysql	2011-08-30 12:50:18 +0000
+++ templates/settings.json.mysql	2013-07-09 03:52:26 +0000
@@ -1,15 +1,15 @@
-{
+{{
   "ip": "0.0.0.0",
   "port" : 9001,
   "dbType" : "mysql",
-  "dbSettings" : {
-                   "user"    : "DB_USER", 
-                   "host"    : "DB_HOST", 
-                   "password": "DB_PASS", 
-                   "database": "DB_NAME"
-                 },
+  "dbSettings" : {{
+                   "user"    : "{user}", 
+                   "host"    : "{host}", 
+                   "password": "{password}", 
+                   "database": "{database}"
+                 }},
   "defaultPadText" : "Welcome to Etherpad Lite!\n\nThis pad text is synchronized as you type, so that everyone viewing this page sees the same text. This allows you to collaborate seamlessly on documents!\n\nEtherpad Lite on Github: http:\/\/j.mp/ep-lite\n",
   "minify" : true,
   "abiword" : "/usr/bin/abiword",
   "loglevel" : "INFO"
-}
+}}

=== added file 'templates/settings.json.postgres'
--- templates/settings.json.postgres	1970-01-01 00:00:00 +0000
+++ templates/settings.json.postgres	2013-07-09 03:52:26 +0000
@@ -0,0 +1,15 @@
+{{
+  "ip": "0.0.0.0",
+  "port" : 9001,
+  "dbType" : "postgres",
+  "dbSettings" : {{
+                   "user"    : "{user}", 
+                   "host"    : "{host}", 
+                   "password": "{password}", 
+                   "database": "{database}"
+                 }},
+  "defaultPadText" : "Welcome to Etherpad Lite!\n\nThis pad text is synchronized as you type, so that everyone viewing this page sees the same text. This allows you to collaborate seamlessly on documents!\n\nEtherpad Lite on Github: http:\/\/j.mp/ep-lite\n",
+  "minify" : true,
+  "abiword" : "/usr/bin/abiword",
+  "loglevel" : "INFO"
+}}

=== modified file 'templates/settings.json.sqlite'
--- templates/settings.json.sqlite	2011-08-30 12:50:18 +0000
+++ templates/settings.json.sqlite	2013-07-09 03:52:26 +0000
@@ -1,12 +1,12 @@
-{
+{{
   "ip": "0.0.0.0",
   "port" : 9001,
   "dbType" : "sqlite",
-  "dbSettings" : {
-                   "filename" : "../var/sqlite.db"
-                 },
+  "dbSettings" : {{
+                   "filename" : "{APP_DIR}-db/sqlite.db"
+                 }},
   "defaultPadText" : "Welcome to Etherpad Lite!\n\nThis pad text is synchronized as you type, so that everyone viewing this page sees the same text. This allows you to collaborate seamlessly on documents!\n\nEtherpad Lite on Github: http:\/\/j.mp/ep-lite\n",
   "minify" : true,
   "abiword" : "/usr/bin/abiword",
   "loglevel" : "INFO"
-}
+}}