Merge lp:~james-page/charms/precise/quantum-gateway/nvp into lp:~charmers/charms/precise/quantum-gateway/trunk

[James Page]

Add support for NVP quantum plugin.

In an NVP deployment, the quantum gateway provides DHCP and Metadata services
to instances. L3 routing is provided by NVP itself.

[lp:~james-page/charms/precise/quantum-gateway/nvp]

40. By James Page on 2013-07-10

First phase of charm-helper refactoring

41. By James Page on 2013-07-19

Redux to use agree structure and OS templating

42. By James Page on 2013-07-19

Update TODO to remove implemented items.

43. By James Page on 2013-07-19

Drop use of keys

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2013-07-19 09:54:29 +0000
@@ -0,0 +1,1 @@
+.coverage

=== added file '.coveragerc'
--- .coveragerc	1970-01-01 00:00:00 +0000
+++ .coveragerc	2013-07-19 09:54:29 +0000
@@ -0,0 +1,6 @@
+[report]
+# Regexes for lines to exclude from consideration
+exclude_lines =
+    if __name__ == .__main__.:
+include=
+    hooks/quantum_*

=== modified file '.pydevproject'
--- .pydevproject	2013-04-12 16:19:51 +0000
+++ .pydevproject	2013-07-19 09:54:29 +0000
@@ -4,6 +4,6 @@
 <pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
 <pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
 <path>/quantum-gateway/hooks</path>
-<path>/quantum-gateway/templates</path>
+<path>/quantum-gateway/unit_tests</path>
 </pydev_pathproperty>
 </pydev_project>

=== added file 'Makefile'
--- Makefile	1970-01-01 00:00:00 +0000
+++ Makefile	2013-07-19 09:54:29 +0000
@@ -0,0 +1,14 @@
+#!/usr/bin/make
+PYTHON := /usr/bin/env python
+
+lint:
+	@flake8 --exclude hooks/charmhelpers hooks
+	@flake8 --exclude hooks/charmhelpers unit_tests
+	@charm proof
+
+test:
+	@echo Starting tests...
+	@$(PYTHON) /usr/bin/nosetests --nologcapture unit_tests
+
+sync:
+	@charm-helper-sync -c charm-helpers-sync.yaml

=== modified file 'README.md'
--- README.md	2012-12-06 10:22:24 +0000
+++ README.md	2013-07-19 09:54:29 +0000
@@ -1,4 +1,4 @@
-Overview
+
 --------
 
 Quantum provides flexible software defined networking (SDN) for OpenStack.
@@ -54,5 +54,3 @@
 
  * Provide more network configuration use cases.
  * Support VLAN in addition to GRE+OpenFlow for L2 separation.
- * High Avaliability.
- * Support for propriety plugins for Quantum.

=== added file 'charm-helpers-sync.yaml'
--- charm-helpers-sync.yaml	1970-01-01 00:00:00 +0000
+++ charm-helpers-sync.yaml	2013-07-19 09:54:29 +0000
@@ -0,0 +1,7 @@
+branch: lp:charm-helpers
+destination: hooks/charmhelpers
+include:
+    - core
+    - contrib.openstack
+    - contrib.hahelpers
+    - contrib.network.ovs

=== modified file 'config.yaml'
--- config.yaml	2013-03-20 16:08:54 +0000
+++ config.yaml	2013-07-19 09:54:29 +0000
@@ -7,6 +7,7 @@
       Supported values include:
       .
         ovs - OpenVSwitch
+        nvp - Nicira NVP
   ext-port:
     type: string
     description: |

=== modified symlink 'hooks/amqp-relation-changed'
=== target changed u'hooks.py' => u'quantum_hooks.py'
=== modified symlink 'hooks/amqp-relation-joined'
=== target changed u'hooks.py' => u'quantum_hooks.py'
=== 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/hahelpers'
=== added file 'hooks/charmhelpers/contrib/hahelpers/__init__.py'
=== added file 'hooks/charmhelpers/contrib/hahelpers/apache.py'
--- hooks/charmhelpers/contrib/hahelpers/apache.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/hahelpers/apache.py	2013-07-19 09:54:29 +0000
@@ -0,0 +1,58 @@
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This file is sourced from lp:openstack-charm-helpers
+#
+# Authors:
+#  James Page <[e-mail]>
+#  Adam Gandelman <[e-mail]>
+#
+
+import subprocess
+
+from charmhelpers.core.hookenv import (
+    config as config_get,
+    relation_get,
+    relation_ids,
+    related_units as relation_list,
+    log,
+    INFO,
+)
+
+
+def get_cert():
+    cert = config_get('ssl_cert')
+    key = config_get('ssl_key')
+    if not (cert and key):
+        log("Inspecting identity-service relations for SSL certificate.",
+            level=INFO)
+        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
+    log("Inspecting identity-service relations for CA SSL certificate.",
+        level=INFO)
+    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'])

=== added file 'hooks/charmhelpers/contrib/hahelpers/ceph.py'
--- hooks/charmhelpers/contrib/hahelpers/ceph.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/hahelpers/ceph.py	2013-07-19 09:54:29 +0000
@@ -0,0 +1,278 @@
+#
+# 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 os
+import shutil
+
+from subprocess import (
+    check_call,
+    check_output,
+    CalledProcessError
+)
+
+from charmhelpers.core.hookenv import (
+    relation_get,
+    relation_ids,
+    related_units,
+    log,
+    INFO,
+)
+
+from charmhelpers.core.host import (
+    apt_install,
+    mount,
+    mounts,
+    service_start,
+    service_stop,
+    umount,
+)
+
+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 running(service):
+    # this local util can be dropped as soon the following branch lands
+    # in lp:charm-helpers
+    # https://code.launchpad.net/~gandelman-a/charm-helpers/service_running/
+    try:
+        output = check_output(['service', service, 'status'])
+    except CalledProcessError:
+        return False
+    else:
+        if ("start/running" in output or "is running" in output):
+            return True
+        else:
+            return False
+
+
+def install():
+    ceph_dir = "/etc/ceph"
+    if not os.path.isdir(ceph_dir):
+        os.mkdir(ceph_dir)
+    apt_install('ceph-common', fatal=True)
+
+
+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
+    ]
+    check_call(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
+    ]
+    check_call(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):
+        log('ceph: Keyring exists at %s.' % keyring, level=INFO)
+    cmd = [
+        'ceph-authtool',
+        keyring,
+        '--create-keyring',
+        '--name=client.%s' % service,
+        '--add-key=%s' % key
+    ]
+    check_call(cmd)
+    log('ceph: Created new ring at %s.' % keyring, level=INFO)
+
+
+def create_key_file(service, key):
+    # create a file containing the key
+    keyfile = keyfile_path(service)
+    if os.path.exists(keyfile):
+        log('ceph: Keyfile exists at %s.' % keyfile, level=INFO)
+    fd = open(keyfile, 'w')
+    fd.write(key)
+    fd.close()
+    log('ceph: Created new keyfile at %s.' % keyfile, level=INFO)
+
+
+def get_ceph_nodes():
+    hosts = []
+    for r_id in relation_ids('ceph'):
+        for unit in related_units(r_id):
+            hosts.append(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),
+    ]
+    check_call(cmd)
+
+
+def filesystem_mounted(fs):
+    return fs in [f for m, f in mounts()]
+
+
+def make_filesystem(blk_device, fstype='ext4'):
+    log('ceph: Formatting block device %s as filesystem %s.' %
+        (blk_device, fstype), level=INFO)
+    cmd = ['mkfs', '-t', fstype, blk_device]
+    check_call(cmd)
+
+
+def place_data_on_ceph(service, blk_device, data_src_dst, fstype='ext4'):
+    # mount block device into /mnt
+    mount(blk_device, '/mnt')
+
+    # copy data to /mnt
+    try:
+        copy_files(data_src_dst, '/mnt')
+    except:
+        pass
+
+    # umount block device
+    umount('/mnt')
+
+    _dir = os.stat(data_src_dst)
+    uid = _dir.st_uid
+    gid = _dir.st_gid
+
+    # re-mount where the data should originally be
+    mount(blk_device, data_src_dst, persist=True)
+
+    # ensure original ownership of new mount.
+    cmd = ['chown', '-R', '%s:%s' % (uid, gid), data_src_dst]
+    check_call(cmd)
+
+
+# TODO: re-use
+def modprobe_kernel_module(module):
+    log('ceph: Loading kernel module', level=INFO)
+    cmd = ['modprobe', module]
+    check_call(cmd)
+    cmd = 'echo %s >> /etc/modules' % module
+    check_call(cmd, shell=True)
+
+
+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):
+        log('ceph: Creating new pool %s.' % pool, level=INFO)
+        create_pool(service, pool)
+
+    if not rbd_exists(service, pool, rbd_img):
+        log('ceph: Creating RBD image (%s).' % rbd_img, level=INFO)
+        create_rbd_image(service, pool, rbd_img, sizemb)
+
+    if not image_mapped(rbd_img):
+        log('ceph: Mapping RBD Image as a Block Device.', level=INFO)
+        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 running(svc):
+                log('Stopping services %s prior to migrating data.' % svc,
+                    level=INFO)
+                service_stop(svc)
+
+        place_data_on_ceph(service, blk_device, mount_point, fstype)
+
+        for svc in system_services:
+            service_start(svc)

=== added file 'hooks/charmhelpers/contrib/hahelpers/cluster.py'
--- hooks/charmhelpers/contrib/hahelpers/cluster.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/hahelpers/cluster.py	2013-07-19 09:54:29 +0000
@@ -0,0 +1,180 @@
+#
+# Copyright 2012 Canonical Ltd.
+#
+# Authors:
+#  James Page <[e-mail]>
+#  Adam Gandelman <[e-mail]>
+#
+
+import subprocess
+import os
+
+from socket import gethostname as get_unit_hostname
+
+from charmhelpers.core.hookenv import (
+    log,
+    relation_ids,
+    related_units as relation_list,
+    relation_get,
+    config as config_get,
+    INFO,
+    ERROR,
+)
+
+
+class HAIncompleteConfig(Exception):
+    pass
+
+
+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):
+            log('Deferring action to CRM leader.', level=INFO)
+            return False
+    else:
+        peers = peer_units()
+        if peers and not oldest_peer(peers):
+            log('Deferring action to oldest service unit.', level=INFO)
+            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 None not in [
+                relation_get('https_keystone', rid=r_id, unit=unit),
+                relation_get('ssl_cert', rid=r_id, unit=unit),
+                relation_get('ssl_key', rid=r_id, unit=unit),
+                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)
+
+
+def get_hacluster_config():
+    '''
+    Obtains all relevant configuration from charm configuration required
+    for initiating a relation to hacluster:
+
+        ha-bindiface, ha-mcastport, vip, vip_iface, vip_cidr
+
+    returns: dict: A dict containing settings keyed by setting name.
+    raises: HAIncompleteConfig if settings are missing.
+    '''
+    settings = ['ha-bindiface', 'ha-mcastport', 'vip', 'vip_iface', 'vip_cidr']
+    conf = {}
+    for setting in settings:
+        conf[setting] = config_get(setting)
+    missing = []
+    [missing.append(s) for s, v in conf.iteritems() if v is None]
+    if missing:
+        log('Insufficient config data to configure hacluster.', level=ERROR)
+        raise HAIncompleteConfig
+    return conf
+
+
+def canonical_url(configs, vip_setting='vip'):
+    '''
+    Returns the correct HTTP URL to this host given the state of HTTPS
+    configuration and hacluster.
+
+    :configs    : OSTemplateRenderer: A config tempating object to inspect for
+                                      a complete https context.
+    :vip_setting:                str: Setting in charm config that specifies
+                                      VIP address.
+    '''
+    scheme = 'http'
+    if 'https' in configs.complete_contexts():
+        scheme = 'https'
+    if is_clustered():
+        addr = config_get(vip_setting)
+    else:
+        addr = get_unit_hostname()
+    return '%s://%s' % (scheme, addr)

=== added directory 'hooks/charmhelpers/contrib/network'
=== added file 'hooks/charmhelpers/contrib/network/__init__.py'
=== added directory 'hooks/charmhelpers/contrib/network/ovs'
=== added file 'hooks/charmhelpers/contrib/network/ovs/__init__.py'
--- hooks/charmhelpers/contrib/network/ovs/__init__.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/network/ovs/__init__.py	2013-07-19 09:54:29 +0000
@@ -0,0 +1,72 @@
+''' Helpers for interacting with OpenvSwitch '''
+import subprocess
+import os
+from charmhelpers.core.hookenv import (
+    log, WARNING
+)
+from charmhelpers.core.host import (
+    service
+)
+
+
+def add_bridge(name):
+    ''' Add the named bridge to openvswitch '''
+    log('Creating bridge {}'.format(name))
+    subprocess.check_call(["ovs-vsctl", "--", "--may-exist", "add-br", name])
+
+
+def del_bridge(name):
+    ''' Delete the named bridge from openvswitch '''
+    log('Deleting bridge {}'.format(name))
+    subprocess.check_call(["ovs-vsctl", "--", "--if-exists", "del-br", name])
+
+
+def add_bridge_port(name, port):
+    ''' Add a port to the named openvswitch bridge '''
+    log('Adding port {} to bridge {}'.format(port, name))
+    subprocess.check_call(["ovs-vsctl", "--", "--may-exist", "add-port",
+                           name, port])
+    subprocess.check_call(["ip", "link", "set", port, "up"])
+
+
+def del_bridge_port(name, port):
+    ''' Delete a port from the named openvswitch bridge '''
+    log('Deleting port {} from bridge {}'.format(port, name))
+    subprocess.check_call(["ovs-vsctl", "--", "--if-exists", "del-port",
+                           name, port])
+    subprocess.check_call(["ip", "link", "set", port, "down"])
+
+
+def set_manager(manager):
+    ''' Set the controller for the local openvswitch '''
+    log('Setting manager for local ovs to {}'.format(manager))
+    subprocess.check_call(['ovs-vsctl', 'set-manager',
+                           'ssl:{}'.format(manager)])
+
+
+CERT_PATH = '/etc/openvswitch/ovsclient-cert.pem'
+
+
+def get_certificate():
+    ''' Read openvswitch certificate from disk '''
+    if os.path.exists(CERT_PATH):
+        log('Reading ovs certificate from {}'.format(CERT_PATH))
+        with open(CERT_PATH, 'r') as cert:
+            full_cert = cert.read()
+            begin_marker = "-----BEGIN CERTIFICATE-----"
+            end_marker = "-----END CERTIFICATE-----"
+            begin_index = full_cert.find(begin_marker)
+            end_index = full_cert.rfind(end_marker)
+            if end_index == -1 or begin_index == -1:
+                raise RuntimeError("Certificate does not contain valid begin"
+                                   " and end markers.")
+            full_cert = full_cert[begin_index:(end_index + len(end_marker))]
+            return full_cert
+    else:
+        log('Certificate not found', level=WARNING)
+        return None
+
+
+def full_restart():
+    ''' Full restart and reload of openvswitch '''
+    service('force-reload-kmod', 'openvswitch-switch')

=== added directory 'hooks/charmhelpers/contrib/openstack'
=== added file 'hooks/charmhelpers/contrib/openstack/__init__.py'
=== added file 'hooks/charmhelpers/contrib/openstack/context.py'
--- hooks/charmhelpers/contrib/openstack/context.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/openstack/context.py	2013-07-19 09:54:29 +0000
@@ -0,0 +1,271 @@
+import os
+
+from base64 import b64decode
+
+from subprocess import (
+    check_call
+)
+
+from charmhelpers.core.hookenv import (
+    config,
+    local_unit,
+    log,
+    relation_get,
+    relation_ids,
+    related_units,
+    unit_get,
+)
+
+from charmhelpers.contrib.hahelpers.cluster import (
+    determine_api_port,
+    determine_haproxy_port,
+    https,
+    is_clustered,
+    peer_units,
+)
+
+from charmhelpers.contrib.hahelpers.apache import (
+    get_cert,
+    get_ca_cert,
+)
+
+CA_CERT_PATH = '/usr/local/share/ca-certificates/keystone_juju_ca_cert.crt'
+
+
+class OSContextError(Exception):
+    pass
+
+
+def context_complete(ctxt):
+    _missing = []
+    for k, v in ctxt.iteritems():
+        if v is None or v == '':
+            _missing.append(k)
+    if _missing:
+        log('Missing required data: %s' % ' '.join(_missing), level='INFO')
+        return False
+    return True
+
+
+class OSContextGenerator(object):
+    interfaces = []
+
+    def __call__(self):
+        raise NotImplementedError
+
+
+class SharedDBContext(OSContextGenerator):
+    interfaces = ['shared-db']
+
+    def __call__(self):
+        log('Generating template context for shared-db')
+        conf = config()
+        try:
+            database = conf['database']
+            username = conf['database-user']
+        except KeyError as e:
+            log('Could not generate shared_db context. '
+                'Missing required charm config options: %s.' % e)
+            raise OSContextError
+        ctxt = {}
+        for rid in relation_ids('shared-db'):
+            for unit in related_units(rid):
+                ctxt = {
+                    'database_host': relation_get('db_host', rid=rid,
+                                                  unit=unit),
+                    'database': database,
+                    'database_user': username,
+                    'database_password': relation_get('password', rid=rid,
+                                                      unit=unit)
+                }
+        if not context_complete(ctxt):
+            return {}
+        return ctxt
+
+
+class IdentityServiceContext(OSContextGenerator):
+    interfaces = ['identity-service']
+
+    def __call__(self):
+        log('Generating template context for identity-service')
+        ctxt = {}
+
+        for rid in relation_ids('identity-service'):
+            for unit in related_units(rid):
+                ctxt = {
+                    'service_port': relation_get('service_port', rid=rid,
+                                                 unit=unit),
+                    'service_host': relation_get('service_host', rid=rid,
+                                                 unit=unit),
+                    'auth_host': relation_get('auth_host', rid=rid, unit=unit),
+                    'auth_port': relation_get('auth_port', rid=rid, unit=unit),
+                    'admin_tenant_name': relation_get('service_tenant',
+                                                      rid=rid, unit=unit),
+                    'admin_user': relation_get('service_username', rid=rid,
+                                               unit=unit),
+                    'admin_password': relation_get('service_password', rid=rid,
+                                                   unit=unit),
+                    # XXX: Hard-coded http.
+                    'service_protocol': 'http',
+                    'auth_protocol': 'http',
+                }
+        if not context_complete(ctxt):
+            return {}
+        return ctxt
+
+
+class AMQPContext(OSContextGenerator):
+    interfaces = ['amqp']
+
+    def __call__(self):
+        log('Generating template context for amqp')
+        conf = config()
+        try:
+            username = conf['rabbit-user']
+            vhost = conf['rabbit-vhost']
+        except KeyError as e:
+            log('Could not generate shared_db context. '
+                'Missing required charm config options: %s.' % e)
+            raise OSContextError
+
+        ctxt = {}
+        for rid in relation_ids('amqp'):
+            for unit in related_units(rid):
+                if relation_get('clustered', rid=rid, unit=unit):
+                    rabbitmq_host = relation_get('vip', rid=rid, unit=unit)
+                else:
+                    rabbitmq_host = relation_get('private-address',
+                                                 rid=rid, unit=unit)
+                ctxt = {
+                    'rabbitmq_host': rabbitmq_host,
+                    'rabbitmq_user': username,
+                    'rabbitmq_password': relation_get('password', rid=rid,
+                                                      unit=unit),
+                    'rabbitmq_virtual_host': vhost,
+                }
+        if not context_complete(ctxt):
+            return {}
+        return ctxt
+
+
+class CephContext(OSContextGenerator):
+    interfaces = ['ceph']
+
+    def __call__(self):
+        '''This generates context for /etc/ceph/ceph.conf templates'''
+        log('Generating tmeplate context for ceph')
+        mon_hosts = []
+        auth = None
+        for rid in relation_ids('ceph'):
+            for unit in related_units(rid):
+                mon_hosts.append(relation_get('private-address', rid=rid,
+                                              unit=unit))
+                auth = relation_get('auth', rid=rid, unit=unit)
+
+        ctxt = {
+            'mon_hosts': ' '.join(mon_hosts),
+            'auth': auth,
+        }
+        if not context_complete(ctxt):
+            return {}
+        return ctxt
+
+
+class HAProxyContext(OSContextGenerator):
+    interfaces = ['cluster']
+
+    def __call__(self):
+        '''
+        Builds half a context for the haproxy template, which describes
+        all peers to be included in the cluster.  Each charm needs to include
+        its own context generator that describes the port mapping.
+        '''
+        if not relation_ids('cluster'):
+            return {}
+
+        cluster_hosts = {}
+        l_unit = local_unit().replace('/', '-')
+        cluster_hosts[l_unit] = unit_get('private-address')
+
+        for rid in relation_ids('cluster'):
+            for unit in related_units(rid):
+                _unit = unit.replace('/', '-')
+                addr = relation_get('private-address', rid=rid, unit=unit)
+                cluster_hosts[_unit] = addr
+
+        ctxt = {
+            'units': cluster_hosts,
+        }
+        if len(cluster_hosts.keys()) > 1:
+            # Enable haproxy when we have enough peers.
+            log('Ensuring haproxy enabled in /etc/default/haproxy.')
+            with open('/etc/default/haproxy', 'w') as out:
+                out.write('ENABLED=1\n')
+            return ctxt
+        log('HAProxy context is incomplete, this unit has no peers.')
+        return {}
+
+
+class ApacheSSLContext(OSContextGenerator):
+    """
+    Generates a context for an apache vhost configuration that configures
+    HTTPS reverse proxying for one or many endpoints.  Generated context
+    looks something like:
+    {
+        'namespace': 'cinder',
+        'private_address': 'iscsi.mycinderhost.com',
+        'endpoints': [(8776, 8766), (8777, 8767)]
+    }
+
+    The endpoints list consists of a tuples mapping external ports
+    to internal ports.
+    """
+    interfaces = ['https']
+
+    # charms should inherit this context and set external ports
+    # and service namespace accordingly.
+    external_ports = []
+    service_namespace = None
+
+    def enable_modules(self):
+        cmd = ['a2enmod', 'ssl', 'proxy', 'proxy_http']
+        check_call(cmd)
+
+    def configure_cert(self):
+        if not os.path.isdir('/etc/apache2/ssl'):
+            os.mkdir('/etc/apache2/ssl')
+        ssl_dir = os.path.join('/etc/apache2/ssl/', self.service_namespace)
+        if not os.path.isdir(ssl_dir):
+            os.mkdir(ssl_dir)
+        cert, key = get_cert()
+        with open(os.path.join(ssl_dir, 'cert'), 'w') as cert_out:
+            cert_out.write(b64decode(cert))
+        with open(os.path.join(ssl_dir, 'key'), 'w') as key_out:
+            key_out.write(b64decode(key))
+        ca_cert = get_ca_cert()
+        if ca_cert:
+            with open(CA_CERT_PATH, 'w') as ca_out:
+                ca_out.write(b64decode(ca_cert))
+
+    def __call__(self):
+        if isinstance(self.external_ports, basestring):
+            self.external_ports = [self.external_ports]
+        if (not self.external_ports or not https()):
+            return {}
+
+        self.configure_cert()
+        self.enable_modules()
+
+        ctxt = {
+            'namespace': self.service_namespace,
+            'private_address': unit_get('private-address'),
+            'endpoints': []
+        }
+        for ext_port in self.external_ports:
+            if peer_units() or is_clustered():
+                int_port = determine_haproxy_port(ext_port)
+            else:
+                int_port = determine_api_port(ext_port)
+            portmap = (int(ext_port), int(int_port))
+            ctxt['endpoints'].append(portmap)
+        return ctxt

=== added directory 'hooks/charmhelpers/contrib/openstack/templates'
=== added file 'hooks/charmhelpers/contrib/openstack/templates/__init__.py'
--- hooks/charmhelpers/contrib/openstack/templates/__init__.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/openstack/templates/__init__.py	2013-07-19 09:54:29 +0000
@@ -0,0 +1,2 @@
+# dummy __init__.py to fool syncer into thinking this is a syncable python
+# module

=== added file 'hooks/charmhelpers/contrib/openstack/templating.py'
--- hooks/charmhelpers/contrib/openstack/templating.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/openstack/templating.py	2013-07-19 09:54:29 +0000
@@ -0,0 +1,261 @@
+import os
+
+from charmhelpers.core.host import apt_install
+
+from charmhelpers.core.hookenv import (
+    log,
+    ERROR,
+    INFO
+)
+
+from charmhelpers.contrib.openstack.utils import OPENSTACK_CODENAMES
+
+try:
+    from jinja2 import FileSystemLoader, ChoiceLoader, Environment
+except ImportError:
+    # python-jinja2 may not be installed yet, or we're running unittests.
+    FileSystemLoader = ChoiceLoader = Environment = None
+
+
+class OSConfigException(Exception):
+    pass
+
+
+def get_loader(templates_dir, os_release):
+    """
+    Create a jinja2.ChoiceLoader containing template dirs up to
+    and including os_release.  If directory template directory
+    is missing at templates_dir, it will be omitted from the loader.
+    templates_dir is added to the bottom of the search list as a base
+    loading dir.
+
+    A charm may also ship a templates dir with this module
+    and it will be appended to the bottom of the search list, eg:
+    hooks/charmhelpers/contrib/openstack/templates.
+
+    :param templates_dir: str: Base template directory containing release
+                               sub-directories.
+    :param os_release   : str: OpenStack release codename to construct template
+                               loader.
+
+    :returns            : jinja2.ChoiceLoader constructed with a list of
+                          jinja2.FilesystemLoaders, ordered in descending
+                          order by OpenStack release.
+    """
+    tmpl_dirs = [(rel, os.path.join(templates_dir, rel))
+                 for rel in OPENSTACK_CODENAMES.itervalues()]
+
+    if not os.path.isdir(templates_dir):
+        log('Templates directory not found @ %s.' % templates_dir,
+            level=ERROR)
+        raise OSConfigException
+
+    # the bottom contains tempaltes_dir and possibly a common templates dir
+    # shipped with the helper.
+    loaders = [FileSystemLoader(templates_dir)]
+    helper_templates = os.path.join(os.path.dirname(__file__), 'templates')
+    if os.path.isdir(helper_templates):
+        loaders.append(FileSystemLoader(helper_templates))
+
+    for rel, tmpl_dir in tmpl_dirs:
+        if os.path.isdir(tmpl_dir):
+            loaders.insert(0, FileSystemLoader(tmpl_dir))
+        if rel == os_release:
+            break
+    log('Creating choice loader with dirs: %s' %
+        [l.searchpath for l in loaders], level=INFO)
+    return ChoiceLoader(loaders)
+
+
+class OSConfigTemplate(object):
+    """
+    Associates a config file template with a list of context generators.
+    Responsible for constructing a template context based on those generators.
+    """
+    def __init__(self, config_file, contexts):
+        self.config_file = config_file
+
+        if hasattr(contexts, '__call__'):
+            self.contexts = [contexts]
+        else:
+            self.contexts = contexts
+
+        self._complete_contexts = []
+
+    def context(self):
+        ctxt = {}
+        for context in self.contexts:
+            _ctxt = context()
+            if _ctxt:
+                ctxt.update(_ctxt)
+                # track interfaces for every complete context.
+                [self._complete_contexts.append(interface)
+                 for interface in context.interfaces
+                 if interface not in self._complete_contexts]
+        return ctxt
+
+    def complete_contexts(self):
+        '''
+        Return a list of interfaces that have atisfied contexts.
+        '''
+        if self._complete_contexts:
+            return self._complete_contexts
+        self.context()
+        return self._complete_contexts
+
+
+class OSConfigRenderer(object):
+    """
+    This class provides a common templating system to be used by OpenStack
+    charms.  It is intended to help charms share common code and templates,
+    and ease the burden of managing config templates across multiple OpenStack
+    releases.
+
+    Basic usage:
+        # import some common context generates from charmhelpers
+        from charmhelpers.contrib.openstack import context
+
+        # Create a renderer object for a specific OS release.
+        configs = OSConfigRenderer(templates_dir='/tmp/templates',
+                                   openstack_release='folsom')
+        # register some config files with context generators.
+        configs.register(config_file='/etc/nova/nova.conf',
+                         contexts=[context.SharedDBContext(),
+                                   context.AMQPContext()])
+        configs.register(config_file='/etc/nova/api-paste.ini',
+                         contexts=[context.IdentityServiceContext()])
+        configs.register(config_file='/etc/haproxy/haproxy.conf',
+                         contexts=[context.HAProxyContext()])
+        # write out a single config
+        configs.write('/etc/nova/nova.conf')
+        # write out all registered configs
+        configs.write_all()
+
+    Details:
+
+    OpenStack Releases and template loading
+    ---------------------------------------
+    When the object is instantiated, it is associated with a specific OS
+    release.  This dictates how the template loader will be constructed.
+
+    The constructed loader attempts to load the template from several places
+    in the following order:
+        - from the most recent OS release-specific template dir (if one exists)
+        - the base templates_dir
+        - a template directory shipped in the charm with this helper file.
+
+
+    For the example above, '/tmp/templates' contains the following structure:
+        /tmp/templates/nova.conf
+        /tmp/templates/api-paste.ini
+        /tmp/templates/grizzly/api-paste.ini
+        /tmp/templates/havana/api-paste.ini
+
+    Since it was registered with the grizzly release, it first seraches
+    the grizzly directory for nova.conf, then the templates dir.
+
+    When writing api-paste.ini, it will find the template in the grizzly
+    directory.
+
+    If the object were created with folsom, it would fall back to the
+    base templates dir for its api-paste.ini template.
+
+    This system should help manage changes in config files through
+    openstack releases, allowing charms to fall back to the most recently
+    updated config template for a given release
+
+    The haproxy.conf, since it is not shipped in the templates dir, will
+    be loaded from the module directory's template directory, eg
+    $CHARM/hooks/charmhelpers/contrib/openstack/templates.  This allows
+    us to ship common templates (haproxy, apache) with the helpers.
+
+    Context generators
+    ---------------------------------------
+    Context generators are used to generate template contexts during hook
+    execution.  Doing so may require inspecting service relations, charm
+    config, etc.  When registered, a config file is associated with a list
+    of generators.  When a template is rendered and written, all context
+    generates are called in a chain to generate the context dictionary
+    passed to the jinja2 template. See context.py for more info.
+    """
+    def __init__(self, templates_dir, openstack_release):
+        if not os.path.isdir(templates_dir):
+            log('Could not locate templates dir %s' % templates_dir,
+                level=ERROR)
+            raise OSConfigException
+
+        self.templates_dir = templates_dir
+        self.openstack_release = openstack_release
+        self.templates = {}
+        self._tmpl_env = None
+
+        if None in [Environment, ChoiceLoader, FileSystemLoader]:
+            # if this code is running, the object is created pre-install hook.
+            # jinja2 shouldn't get touched until the module is reloaded on next
+            # hook execution, with proper jinja2 bits successfully imported.
+            apt_install('python-jinja2')
+
+    def register(self, config_file, contexts):
+        """
+        Register a config file with a list of context generators to be called
+        during rendering.
+        """
+        self.templates[config_file] = OSConfigTemplate(config_file=config_file,
+                                                       contexts=contexts)
+        log('Registered config file: %s' % config_file, level=INFO)
+
+    def _get_tmpl_env(self):
+        if not self._tmpl_env:
+            loader = get_loader(self.templates_dir, self.openstack_release)
+            self._tmpl_env = Environment(loader=loader)
+
+    def _get_template(self, template):
+        self._get_tmpl_env()
+        template = self._tmpl_env.get_template(template)
+        log('Loaded template from %s' % template.filename, level=INFO)
+        return template
+
+    def render(self, config_file):
+        if config_file not in self.templates:
+            log('Config not registered: %s' % config_file, level=ERROR)
+            raise OSConfigException
+        ctxt = self.templates[config_file].context()
+        _tmpl = os.path.basename(config_file)
+        log('Rendering from template: %s' % _tmpl, level=INFO)
+        template = self._get_template(_tmpl)
+        return template.render(ctxt)
+
+    def write(self, config_file):
+        """
+        Write a single config file, raises if config file is not registered.
+        """
+        if config_file not in self.templates:
+            log('Config not registered: %s' % config_file, level=ERROR)
+            raise OSConfigException
+        with open(config_file, 'wb') as out:
+            out.write(self.render(config_file))
+        log('Wrote template %s.' % config_file, level=INFO)
+
+    def write_all(self):
+        """
+        Write out all registered config files.
+        """
+        [self.write(k) for k in self.templates.iterkeys()]
+
+    def set_release(self, openstack_release):
+        """
+        Resets the template environment and generates a new template loader
+        based on a the new openstack release.
+        """
+        self._tmpl_env = None
+        self.openstack_release = openstack_release
+        self._get_tmpl_env()
+
+    def complete_contexts(self):
+        '''
+        Returns a list of context interfaces that yield a complete context.
+        '''
+        interfaces = []
+        [interfaces.extend(i.complete_contexts())
+         for i in self.templates.itervalues()]
+        return interfaces

=== added file 'hooks/charmhelpers/contrib/openstack/utils.py'
--- hooks/charmhelpers/contrib/openstack/utils.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/contrib/openstack/utils.py	2013-07-19 09:54:29 +0000
@@ -0,0 +1,273 @@
+#!/usr/bin/python
+
+# Common python helper functions used for OpenStack charms.
+
+from collections import OrderedDict
+
+import apt_pkg as apt
+import subprocess
+import os
+import sys
+
+from charmhelpers.core.hookenv import (
+    config,
+    log as juju_log,
+    charm_dir,
+)
+
+from charmhelpers.core.host import (
+    lsb_release,
+    apt_install,
+)
+
+CLOUD_ARCHIVE_URL = "http://ubuntu-cloud.archive.canonical.com/ubuntu"
+CLOUD_ARCHIVE_KEY_ID = '5EDB1B62EC4926EA'
+
+UBUNTU_OPENSTACK_RELEASE = OrderedDict([
+    ('oneiric', 'diablo'),
+    ('precise', 'essex'),
+    ('quantal', 'folsom'),
+    ('raring', 'grizzly'),
+    ('saucy', 'havana'),
+])
+
+
+OPENSTACK_CODENAMES = OrderedDict([
+    ('2011.2', 'diablo'),
+    ('2012.1', 'essex'),
+    ('2012.2', 'folsom'),
+    ('2013.1', 'grizzly'),
+    ('2013.2', 'havana'),
+    ('2014.1', 'icehouse'),
+])
+
+# 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',
+    '1.9.0': 'havana',
+    '1.9.1': 'havana',
+}
+
+
+def error_out(msg):
+    juju_log("FATAL ERROR: %s" % msg, level='ERROR')
+    sys.exit(1)
+
+
+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_version_install_source(src):
+    codename = get_os_codename_install_source(src)
+    return get_os_version_codename(codename)
+
+
+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(package, fatal=True):
+    '''Derive OpenStack release codename from an installed package.'''
+    apt.init()
+    cache = apt.Cache()
+
+    try:
+        pkg = cache[package]
+    except:
+        if not fatal:
+            return None
+        # the package is unknown to the current apt cache.
+        e = 'Could not determine version of package with no installation '\
+            'candidate: %s' % package
+        error_out(e)
+
+    if not pkg.current_ver:
+        if not fatal:
+            return None
+        # package is known, but no version is currently installed.
+        e = 'Could not determine version of uninstalled package: %s' % package
+        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, fatal=True):
+    '''Derive OpenStack version number from an installed package.'''
+    codename = get_os_codename_package(pkg, fatal=fatal)
+
+    if not codename:
+        return None
+
+    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',
+            'havana': 'precise-updates/havana',
+            'havana/updates': 'precise-updates/havana',
+            'havana/proposed': 'precise-proposed/havana',
+        }
+
+        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)
+        apt_install('ubuntu-cloud-keyring', fatal=True)
+
+        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.
+    """
+    juju_rc_path = "%s/%s" % (charm_dir(), script_path)
+    if not os.path.exists(os.path.dirname(juju_rc_path)):
+        os.mkdir(os.path.dirname(juju_rc_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"]
+
+
+def openstack_upgrade_available(package):
+    """
+    Determines if an OpenStack upgrade is available from installation
+    source, based on version of installed package.
+
+    :param package: str: Name of installed package.
+
+    :returns: bool:    : Returns True if configured installation source offers
+                         a newer version of package.
+
+    """
+
+    src = config('openstack-origin')
+    cur_vers = get_os_version_package(package)
+    available_vers = get_os_version_install_source(src)
+    apt.init()
+    return apt.version_compare(available_vers, cur_vers) == 1

=== 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-19 09:54:29 +0000
@@ -0,0 +1,340 @@
+"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()
+
+cache = {}
+
+
+def cached(func):
+    ''' Cache return values for multiple executions of func + args
+
+    For example:
+
+        @cached
+        def unit_get(attribute):
+            pass
+
+        unit_get('test')
+
+    will cache the result of unit_get + 'test' for future calls.
+    '''
+    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
+
+
+def flush(key):
+    ''' Flushes any entries from function cache where the
+    key is found in the function+args '''
+    flush_list = []
+    for item in cache:
+        if key in item:
+            flush_list.append(item)
+    for item in flush_list:
+        del cache[item]
+
+
+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 __getstate__(self):
+        # Pickle as a standard dictionary.
+        return self.data
+
+    def __setstate__(self, state):
+        # Unpickle into our wrapper.
+        self.data = state
+
+    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()
+    if relation_id():
+        context['reltype'] = relation_type()
+        context['relid'] = relation_id()
+        context['rel'] = relation_get()
+    context['unit'] = local_unit()
+    context['rels'] = relations()
+    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 service_name():
+    "The name service group this unit belongs to"
+    return local_unit().split('/')[0]
+
+
+@cached
+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:
+        return json.loads(subprocess.check_output(config_cmd_line))
+    except ValueError:
+        return None
+
+
+@cached
+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() + kwargs.items()):
+        if v is None:
+            relation_cmd_line.append('{}='.format(k))
+        else:
+            relation_cmd_line.append('{}={}'.format(k, v))
+    subprocess.check_call(relation_cmd_line)
+    # Flush cache of any relation-gets for local unit
+    flush(local_unit())
+
+
+@cached
+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)) or []
+    return []
+
+
+@cached
+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)) or []
+
+
+@cached
+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 relation
+
+
+@cached
+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
+
+
+@cached
+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
+
+
+@cached
+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
+
+
+@cached
+def relations():
+    rels = {}
+    for reltype in relation_types():
+        relids = {}
+        for relid in relation_ids(reltype):
+            units = {local_unit(): relation_get(unit=local_unit(), rid=relid)}
+            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)
+
+
+@cached
+def unit_get(attribute):
+    _args = ['unit-get', '--format=json', attribute]
+    try:
+        return json.loads(subprocess.check_output(_args))
+    except ValueError:
+        return None
+
+
+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)
+                if '_' in decorated.__name__:
+                    self.register(
+                        decorated.__name__.replace('_', '-'), decorated)
+            return decorated
+        return wrapper
+
+
+def charm_dir():
+    return os.environ.get('CHARM_DIR')

=== 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-19 09:54:29 +0000
@@ -0,0 +1,269 @@
+"""Tools for working with the host system"""
+# Copyright 2012 Canonical Ltd.
+#
+# Authors:
+#  Nick Moffitt <[e-mail]>
+#  Matthew Wedgwood <[e-mail]>
+
+import apt_pkg
+import os
+import pwd
+import grp
+import subprocess
+import hashlib
+
+from collections import OrderedDict
+
+from hookenv import log
+
+
+def service_start(service_name):
+    service('start', service_name)
+
+
+def service_stop(service_name):
+    service('stop', service_name)
+
+
+def service_restart(service_name):
+    service('restart', service_name)
+
+
+def service_reload(service_name, restart_on_failure=False):
+    if not service('reload', service_name) and restart_on_failure:
+        service('restart', service_name)
+
+
+def service(action, service_name):
+    cmd = ['service', service_name, action]
+    return subprocess.call(cmd) == 0
+
+
+def service_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 adduser(username, password=None, shell='/bin/bash', system_user=False):
+    """Add a user"""
+    try:
+        user_info = pwd.getpwnam(username)
+        log('user {0} already exists!'.format(username))
+    except KeyError:
+        log('creating user {0}'.format(username))
+        cmd = ['useradd']
+        if system_user or password is None:
+            cmd.append('--system')
+        else:
+            cmd.extend([
+                '--create-home',
+                '--shell', shell,
+                '--password', password,
+            ])
+        cmd.append(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"""
+    options = options or ['--delete', '--executability']
+    cmd = ['/usr/bin/rsync', flags]
+    cmd.extend(options)
+    cmd.append(from_path)
+    cmd.append(to_path)
+    log(" ".join(cmd))
+    return subprocess.check_output(cmd).strip()
+
+
+def symlink(source, destination):
+    """Create a symbolic link"""
+    log("Symlinking {} as {}".format(source, destination))
+    cmd = [
+        'ln',
+        '-sf',
+        source,
+        destination,
+    ]
+    subprocess.check_call(cmd)
+
+
+def mkdir(path, owner='root', group='root', perms=0555, force=False):
+    """Create a directory"""
+    log("Making dir {} {}:{} {:o}".format(path, owner, group,
+                                          perms))
+    uid = pwd.getpwnam(owner).pw_uid
+    gid = grp.getgrnam(group).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, content, owner='root', group='root', perms=0444):
+    """Create or overwrite a file with the contents of a string"""
+    log("Writing file {} {}:{} {:o}".format(path, owner, group, perms))
+    uid = pwd.getpwnam(owner).pw_uid
+    gid = grp.getgrnam(group).gr_gid
+    with open(path, 'w') as target:
+        os.fchown(target.fileno(), uid, gid)
+        os.fchmod(target.fileno(), perms)
+        target.write(content)
+
+
+def filter_installed_packages(packages):
+    """Returns a list of packages that require installation"""
+    apt_pkg.init()
+    cache = apt_pkg.Cache()
+    _pkgs = []
+    for package in packages:
+        try:
+            p = cache[package]
+            p.current_ver or _pkgs.append(package)
+        except KeyError:
+            log('Package {} has no installation candidate.'.format(package),
+                level='WARNING')
+            _pkgs.append(package)
+    return _pkgs
+
+
+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 apt_update(fatal=False):
+    """Update local apt cache"""
+    cmd = ['apt-get', 'update']
+    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
+
+
+def file_hash(path):
+    ''' Generate a md5 hash of the contents of 'path' or None if not found '''
+    if os.path.exists(path):
+        h = hashlib.md5()
+        with open(path, 'r') as source:
+            h.update(source.read())  # IGNORE:E1101 - it does have update
+        return h.hexdigest()
+    else:
+        return None
+
+
+def restart_on_change(restart_map):
+    ''' Restart services based on configuration files changing
+
+    This function is used a decorator, for example
+
+        @restart_on_change({
+            '/etc/ceph/ceph.conf': [ 'cinder-api', 'cinder-volume' ]
+            })
+        def ceph_client_changed():
+            ...
+
+    In this example, the cinder-api and cinder-volume services
+    would be restarted if /etc/ceph/ceph.conf is changed by the
+    ceph_client_changed function.
+    '''
+    def wrap(f):
+        def wrapped_f(*args):
+            checksums = {}
+            for path in restart_map:
+                checksums[path] = file_hash(path)
+            f(*args)
+            restarts = []
+            for path in restart_map:
+                if checksums[path] != file_hash(path):
+                    restarts += restart_map[path]
+            for service_name in list(OrderedDict.fromkeys(restarts)):
+                service('restart', service_name)
+        return wrapped_f
+    return wrap
+
+
+def lsb_release():
+    '''Return /etc/lsb-release in a dict'''
+    d = {}
+    with open('/etc/lsb-release', 'r') as lsb:
+        for l in lsb:
+            k, v = l.split('=')
+            d[k.strip()] = v.strip()
+    return d

=== modified symlink 'hooks/cluster-relation-departed'
=== target changed u'hooks.py' => u'quantum_hooks.py'
=== modified symlink 'hooks/config-changed'
=== target changed u'hooks.py' => u'quantum_hooks.py'
=== modified symlink 'hooks/ha-relation-joined'
=== target changed u'hooks.py' => u'quantum_hooks.py'
=== modified symlink 'hooks/install'
=== target changed u'hooks.py' => u'quantum_hooks.py'
=== removed directory 'hooks/lib'
=== removed file 'hooks/lib/__init__.py'
=== removed file 'hooks/lib/cluster_utils.py'
--- hooks/lib/cluster_utils.py	2013-03-20 16:08:54 +0000
+++ hooks/lib/cluster_utils.py	1970-01-01 00:00:00 +0000
@@ -1,130 +0,0 @@
-#
-# 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 (
-    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)

=== removed file 'hooks/lib/openstack_common.py'
--- hooks/lib/openstack_common.py	2013-05-22 22:24:48 +0000
+++ hooks/lib/openstack_common.py	1970-01-01 00:00:00 +0000
@@ -1,230 +0,0 @@
-#!/usr/bin/python
-
-# Common python helper functions used for OpenStack charms.
-
-import apt_pkg as apt
-import subprocess
-import os
-
-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)
-    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 = 'Code not derive openstack release for '\
-                'this Ubuntu release: %s' % 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 = 'Code 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 configure_installation_source(rel):
-    '''Configure apt installation source.'''
-
-    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)
-
-    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
-        else:
-            error_out("Invalid openstack-release: %s" % 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)
-        _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.
-    """
-    charm_dir = os.getenv('CHARM_DIR')
-    juju_rc_path = "%s/%s" % (charm_dir, 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"]

=== removed file 'hooks/lib/utils.py'
--- hooks/lib/utils.py	2013-04-12 15:39:37 +0000
+++ hooks/lib/utils.py	1970-01-01 00:00:00 +0000
@@ -1,359 +0,0 @@
-#
-# 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
-import hashlib
-
-
-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 file_hash(path):
-    if os.path.exists(path):
-        h = hashlib.md5()
-        with open(path, 'r') as source:
-            h.update(source.read())  # IGNORE:E1101 - it does have update
-        return h.hexdigest()
-    else:
-        return None
-
-
-def inteli_restart(restart_map):
-    def wrap(f):
-        def wrapped_f(*args):
-            checksums = {}
-            for path in restart_map:
-                checksums[path] = file_hash(path)
-            f(*args)
-            restarts = []
-            for path in restart_map:
-                if checksums[path] != file_hash(path):
-                    restarts += restart_map[path]
-            restart(*list(set(restarts)))
-        return wrapped_f
-    return wrap
-
-
-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

=== modified symlink 'hooks/quantum-network-service-relation-changed'
=== target changed u'hooks.py' => u'quantum_hooks.py'
=== added file 'hooks/quantum_contexts.py'
--- hooks/quantum_contexts.py	1970-01-01 00:00:00 +0000
+++ hooks/quantum_contexts.py	2013-07-19 09:54:29 +0000
@@ -0,0 +1,66 @@
+# vim: set ts=4:et
+from charmhelpers.core.hookenv import (
+    config,
+    relation_ids,
+    related_units,
+    relation_get,
+)
+from charmhelpers.contrib.openstack.context import (
+    OSContextGenerator,
+    context_complete
+)
+import quantum_utils as qutils
+
+
+class NetworkServiceContext(OSContextGenerator):
+    interfaces = ['quantum-network-service']
+
+    def __call__(self):
+        for rid in relation_ids('quantum-network-service'):
+            for unit in related_units(rid):
+                ctxt = {
+                    'keystone_host': relation_get('keystone_host',
+                                                  rid=rid, unit=unit),
+                    'service_port': relation_get('service_port', rid=rid,
+                                                 unit=unit),
+                    'auth_port': relation_get('auth_port', rid=rid, unit=unit),
+                    'service_tenant': relation_get('service_tenant',
+                                                   rid=rid, unit=unit),
+                    'service_username': relation_get('service_username',
+                                                     rid=rid, unit=unit),
+                    'service_password': relation_get('service_password',
+                                                     rid=rid, unit=unit),
+                    'quantum_host': relation_get('quantum_host',
+                                                 rid=rid, unit=unit),
+                    'quantum_port': relation_get('quantum_port',
+                                                 rid=rid, unit=unit),
+                    'quantum_url': relation_get('quantum_url',
+                                                rid=rid, unit=unit),
+                    'region': relation_get('region',
+                                           rid=rid, unit=unit),
+                    # XXX: Hard-coded http.
+                    'service_protocol': 'http',
+                    'auth_protocol': 'http',
+                }
+                if context_complete(ctxt):
+                    return ctxt
+        return {}
+
+
+class ExternalPortContext(OSContextGenerator):
+    def __call__(self):
+        if config('ext-port'):
+            return {"ext_port": config('ext-port')}
+        else:
+            return None
+
+
+class QuantumGatewayContext(OSContextGenerator):
+    def __call__(self):
+        ctxt = {
+            'shared_secret': qutils.get_shared_secret(),
+            'local_ip': qutils.get_host_ip(),
+            'core_plugin': qutils.CORE_PLUGIN[config('plugin')],
+            'plugin': config('plugin')
+        }
+        return ctxt

=== renamed file 'hooks/hooks.py' => 'hooks/quantum_hooks.py'
--- hooks/hooks.py	2013-05-22 23:02:16 +0000
+++ hooks/quantum_hooks.py	2013-07-19 09:54:29 +0000
@@ -1,313 +1,126 @@
 #!/usr/bin/python
 
-import lib.utils as utils
-import lib.cluster_utils as cluster
-import lib.openstack_common as openstack
+from charmhelpers.core.hookenv import (
+    log, ERROR, WARNING,
+    config,
+    relation_get,
+    relation_set,
+    unit_get,
+    Hooks, UnregisteredHookError
+)
+from charmhelpers.core.host import (
+    apt_update,
+    apt_install,
+    filter_installed_packages,
+    restart_on_change
+)
+from charmhelpers.contrib.hahelpers.cluster import(
+    eligible_leader
+)
+from charmhelpers.contrib.hahelpers.apache import(
+    install_ca_cert
+)
+from charmhelpers.contrib.openstack.utils import (
+    configure_installation_source,
+    openstack_upgrade_available
+)
+
 import sys
-import quantum_utils as qutils
-import os
-
-PLUGIN = utils.config_get('plugin')
-
-
+from quantum_utils import (
+    register_configs,
+    restart_map,
+    do_openstack_upgrade,
+    get_packages,
+    get_early_packages,
+    valid_plugin,
+    RABBIT_USER,
+    RABBIT_VHOST,
+    DB_USER, QUANTUM_DB,
+    NOVA_DB_USER, NOVA_DB,
+    configure_ovs,
+    reassign_agent_resources,
+)
+
+hooks = Hooks()
+CONFIGS = register_configs()
+
+
[e-mail]('install')
 def install():
-    utils.configure_source()
-    if PLUGIN in qutils.GATEWAY_PKGS.keys():
-        if PLUGIN == qutils.OVS:
-            # Install OVS DKMS first to ensure that the ovs module
-            # loaded supports GRE tunnels
-            utils.install('openvswitch-datapath-dkms')
-        utils.install(*qutils.GATEWAY_PKGS[PLUGIN])
+    configure_installation_source(config('openstack-origin'))
+    apt_update(fatal=True)
+    if valid_plugin():
+        apt_install(filter_installed_packages(get_early_packages()),
+                    fatal=True)
+        apt_install(filter_installed_packages(get_packages()),
+                    fatal=True)
     else:
-        utils.juju_log('ERROR', 'Please provide a valid plugin config')
+        log('Please provide a valid plugin config', level=ERROR)
         sys.exit(1)
 
 
[e-mail]_restart(qutils.RESTART_MAP)
[e-mail]('config-changed')
+@restart_on_change(restart_map())
 def config_changed():
-    src = utils.config_get('openstack-origin')
-    available = openstack.get_os_codename_install_source(src)
-    installed = openstack.get_os_codename_package('quantum-common')
-    if (available and
-        openstack.get_os_version_codename(available) > \
-        openstack.get_os_version_codename(installed)):
-        qutils.do_openstack_upgrade()
-
-    if PLUGIN in qutils.GATEWAY_PKGS.keys():
-        render_quantum_conf()
-        render_dhcp_agent_conf()
-        render_l3_agent_conf()
-        render_metadata_agent_conf()
-        render_metadata_api_conf()
-        render_plugin_conf()
-        render_ext_port_upstart()
-        render_evacuate_unit()
-        if PLUGIN == qutils.OVS:
-            qutils.add_bridge(qutils.INT_BRIDGE)
-            qutils.add_bridge(qutils.EXT_BRIDGE)
-            ext_port = utils.config_get('ext-port')
-            if ext_port:
-                qutils.add_bridge_port(qutils.EXT_BRIDGE, ext_port)
+    if openstack_upgrade_available('quantum-common'):
+        do_openstack_upgrade(CONFIGS)
+    if valid_plugin():
+        CONFIGS.write_all()
+        configure_ovs()
     else:
-        utils.juju_log('ERROR',
-                       'Please provide a valid plugin config')
+        log('Please provide a valid plugin config', level=ERROR)
         sys.exit(1)
 
 
[e-mail]('upgrade-charm')
 def upgrade_charm():
     install()
     config_changed()
 
 
-def render_ext_port_upstart():
-    if utils.config_get('ext-port'):
-        with open(qutils.EXT_PORT_CONF, "w") as conf:
-            conf.write(utils.render_template(
-                            os.path.basename(qutils.EXT_PORT_CONF),
-                            {"ext_port": utils.config_get('ext-port')}
-                            )
-                       )
-    else:
-        if os.path.exists(qutils.EXT_PORT_CONF):
-            os.remove(qutils.EXT_PORT_CONF)
-
-
-def render_l3_agent_conf():
-    context = get_keystone_conf()
-    if (context and
-        os.path.exists(qutils.L3_AGENT_CONF)):
-        with open(qutils.L3_AGENT_CONF, "w") as conf:
-            conf.write(utils.render_template(
-                            os.path.basename(qutils.L3_AGENT_CONF),
-                            context
-                            )
-                       )
-
-
-def render_dhcp_agent_conf():
-    if (os.path.exists(qutils.DHCP_AGENT_CONF)):
-        with open(qutils.DHCP_AGENT_CONF, "w") as conf:
-            conf.write(utils.render_template(
-                            os.path.basename(qutils.DHCP_AGENT_CONF),
-                            {}
-                            )
-                       )
-
-
-def render_metadata_agent_conf():
-    context = get_keystone_conf()
-    if (context and
-        os.path.exists(qutils.METADATA_AGENT_CONF)):
-        context['local_ip'] = utils.get_host_ip()
-        context['shared_secret'] = qutils.get_shared_secret()
-        with open(qutils.METADATA_AGENT_CONF, "w") as conf:
-            conf.write(utils.render_template(
-                            os.path.basename(qutils.METADATA_AGENT_CONF),
-                            context
-                            )
-                       )
-
-
-def render_quantum_conf():
-    context = get_rabbit_conf()
-    if (context and
-        os.path.exists(qutils.QUANTUM_CONF)):
-        context['core_plugin'] = \
-            qutils.CORE_PLUGIN[PLUGIN]
-        with open(qutils.QUANTUM_CONF, "w") as conf:
-            conf.write(utils.render_template(
-                            os.path.basename(qutils.QUANTUM_CONF),
-                            context
-                            )
-                       )
-
-
-def render_plugin_conf():
-    context = get_quantum_db_conf()
-    if (context and
-        os.path.exists(qutils.PLUGIN_CONF[PLUGIN])):
-        context['local_ip'] = utils.get_host_ip()
-        conf_file = qutils.PLUGIN_CONF[PLUGIN]
-        with open(conf_file, "w") as conf:
-            conf.write(utils.render_template(
-                            os.path.basename(conf_file),
-                            context
-                            )
-                       )
-
-
-def render_metadata_api_conf():
-    context = get_nova_db_conf()
-    r_context = get_rabbit_conf()
-    q_context = get_keystone_conf()
-    if (context and r_context and q_context and
-        os.path.exists(qutils.NOVA_CONF)):
-        context.update(r_context)
-        context.update(q_context)
-        context['shared_secret'] = qutils.get_shared_secret()
-        with open(qutils.NOVA_CONF, "w") as conf:
-            conf.write(utils.render_template(
-                            os.path.basename(qutils.NOVA_CONF),
-                            context
-                            )
-                       )
-
-
-def render_evacuate_unit():
-    context = get_keystone_conf()
-    if context:
-        with open('/usr/local/bin/quantum-evacuate-unit', "w") as conf:
-            conf.write(utils.render_template('evacuate_unit.py', context))
-        os.chmod('/usr/local/bin/quantum-evacuate-unit', 0700)
-
-
-def get_keystone_conf():
-    for relid in utils.relation_ids('quantum-network-service'):
-        for unit in utils.relation_list(relid):
-            conf = {
-                "keystone_host": utils.relation_get('keystone_host',
-                                                    unit, relid),
-                "service_port": utils.relation_get('service_port',
-                                                   unit, relid),
-                "auth_port": utils.relation_get('auth_port', unit, relid),
-                "service_username": utils.relation_get('service_username',
-                                                       unit, relid),
-                "service_password": utils.relation_get('service_password',
-                                                       unit, relid),
-                "service_tenant": utils.relation_get('service_tenant',
-                                                     unit, relid),
-                "quantum_host": utils.relation_get('quantum_host',
-                                                   unit, relid),
-                "quantum_port": utils.relation_get('quantum_port',
-                                                   unit, relid),
-                "quantum_url": utils.relation_get('quantum_url',
-                                                   unit, relid),
-                "region": utils.relation_get('region',
-                                             unit, relid)
-                }
-            if None not in conf.itervalues():
-                return conf
-    return None
-
-
[e-mail]('shared-db-relation-joined')
 def db_joined():
-    utils.relation_set(quantum_username=qutils.DB_USER,
-                       quantum_database=qutils.QUANTUM_DB,
-                       quantum_hostname=utils.unit_get('private-address'),
-                       nova_username=qutils.NOVA_DB_USER,
-                       nova_database=qutils.NOVA_DB,
-                       nova_hostname=utils.unit_get('private-address'))
-
-
[e-mail]_restart(qutils.RESTART_MAP)
-def db_changed():
-    render_plugin_conf()
-    render_metadata_api_conf()
-
-
-def get_quantum_db_conf():
-    for relid in utils.relation_ids('shared-db'):
-        for unit in utils.relation_list(relid):
-            conf = {
-                "host": utils.relation_get('db_host',
-                                           unit, relid),
-                "user": qutils.DB_USER,
-                "password": utils.relation_get('quantum_password',
-                                               unit, relid),
-                "db": qutils.QUANTUM_DB
-                }
-            if None not in conf.itervalues():
-                return conf
-    return None
-
-
-def get_nova_db_conf():
-    for relid in utils.relation_ids('shared-db'):
-        for unit in utils.relation_list(relid):
-            conf = {
-                "host": utils.relation_get('db_host',
-                                           unit, relid),
-                "user": qutils.NOVA_DB_USER,
-                "password": utils.relation_get('nova_password',
-                                               unit, relid),
-                "db": qutils.NOVA_DB
-                }
-            if None not in conf.itervalues():
-                return conf
-    return None
-
-
+    relation_set(quantum_username=DB_USER,
+                 quantum_database=QUANTUM_DB,
+                 quantum_hostname=unit_get('private-address'),
+                 nova_username=NOVA_DB_USER,
+                 nova_database=NOVA_DB,
+                 nova_hostname=unit_get('private-address'))
+
+
[e-mail]('amqp-relation-joined')
 def amqp_joined():
-    utils.relation_set(username=qutils.RABBIT_USER,
-                       vhost=qutils.RABBIT_VHOST)
-
-
[e-mail]_restart(qutils.RESTART_MAP)
-def amqp_changed():
-    render_dhcp_agent_conf()
-    render_quantum_conf()
-    render_metadata_api_conf()
-
-
-def get_rabbit_conf():
-    for relid in utils.relation_ids('amqp'):
-        for unit in utils.relation_list(relid):
-            conf = {
-                "rabbit_host": utils.relation_get('private-address',
-                                                  unit, relid),
-                "rabbit_virtual_host": qutils.RABBIT_VHOST,
-                "rabbit_userid": qutils.RABBIT_USER,
-                "rabbit_password": utils.relation_get('password',
-                                                      unit, relid)
-                }
-            clustered = utils.relation_get('clustered', unit, relid)
-            if clustered:
-                conf['rabbit_host'] = utils.relation_get('vip', unit, relid)
-            if None not in conf.itervalues():
-                return conf
-    return None
-
-
[e-mail]_restart(qutils.RESTART_MAP)
+    relation_set(username=RABBIT_USER,
+                 vhost=RABBIT_VHOST)
+
+
[e-mail]('shared-db-relation-changed',
+            'amqp-relation-changed')
+@restart_on_change(restart_map())
+def db_amqp_changed():
+    CONFIGS.write_all()
+
+
[e-mail]('quantum-network-service-relation-changed')
+@restart_on_change(restart_map())
 def nm_changed():
-    render_dhcp_agent_conf()
-    render_l3_agent_conf()
-    render_metadata_agent_conf()
-    render_metadata_api_conf()
-    render_evacuate_unit()
-    store_ca_cert()
-
-
-def store_ca_cert():
-    ca_cert = get_ca_cert()
-    if ca_cert:
-        qutils.install_ca(ca_cert)
-
-
-def get_ca_cert():
-    for relid in utils.relation_ids('quantum-network-service'):
-        for unit in utils.relation_list(relid):
-            ca_cert = utils.relation_get('ca_cert', unit, relid)
-            if ca_cert:
-                return ca_cert
-    return None
-
-
+    CONFIGS.write_all()
+    if relation_get('ca_cert'):
+        install_ca_cert(relation_get('ca_cert'))
+
+
[e-mail]("cluster-relation-departed")
 def cluster_departed():
-    conf = get_keystone_conf()
-    if conf and cluster.eligible_leader(None):
-        qutils.reassign_agent_resources(conf)
-
-utils.do_hooks({
-    "install": install,
-    "config-changed": config_changed,
-    "upgrade-charm": upgrade_charm,
-    "shared-db-relation-joined": db_joined,
-    "shared-db-relation-changed": db_changed,
-    "amqp-relation-joined": amqp_joined,
-    "amqp-relation-changed": amqp_changed,
-    "quantum-network-service-relation-changed": nm_changed,
-    "cluster-relation-departed": cluster_departed
-    })
-
-sys.exit(0)
+    if config('plugin') == 'nvp':
+        log('Unable to re-assign agent resources for failed nodes with nvp',
+            level=WARNING)
+        return
+    if eligible_leader(None):
+        reassign_agent_resources()
+
+
+if __name__ == '__main__':
+    try:
+        hooks.execute(sys.argv)
+    except UnregisteredHookError as e:
+        log('Unknown hook {} - skipping.'.format(e))

=== modified file 'hooks/quantum_utils.py'
--- hooks/quantum_utils.py	2013-05-25 21:11:15 +0000
+++ hooks/quantum_utils.py	2013-07-19 09:54:29 +0000
@@ -1,28 +1,54 @@
-import subprocess
 import os
 import uuid
-import base64
-import apt_pkg as apt
-from lib.utils import (
-    juju_log as log,
-    configure_source,
-    config_get
-    )
-
+import socket
+from charmhelpers.core.hookenv import (
+    log,
+    config,
+    unit_get,
+    cached
+)
+from charmhelpers.core.host import (
+    apt_install,
+    apt_update
+)
+from charmhelpers.contrib.network.ovs import (
+    add_bridge,
+    add_bridge_port
+)
+from charmhelpers.contrib.openstack.utils import (
+    configure_installation_source,
+    get_os_codename_package,
+    get_os_codename_install_source
+)
+import charmhelpers.contrib.openstack.context as context
+import charmhelpers.contrib.openstack.templating as templating
+import quantum_contexts
+from collections import OrderedDict
 
 OVS = "ovs"
+NVP = "nvp"
 
 OVS_PLUGIN = \
     "quantum.plugins.openvswitch.ovs_quantum_plugin.OVSQuantumPluginV2"
+NVP_PLUGIN = \
+    "quantum.plugins.nicira.nicira_nvp_plugin.QuantumPlugin.NvpPluginV2"
 CORE_PLUGIN = {
     OVS: OVS_PLUGIN,
-    }
+    NVP: NVP_PLUGIN
+}
+
+
+def valid_plugin():
+    return config('plugin') in CORE_PLUGIN
 
 OVS_PLUGIN_CONF = \
     "/etc/quantum/plugins/openvswitch/ovs_quantum_plugin.ini"
+NVP_PLUGIN_CONF = \
+    "/etc/quantum/plugins/nicira/nvp.ini"
 PLUGIN_CONF = {
     OVS: OVS_PLUGIN_CONF,
-    }
+    NVP: NVP_PLUGIN_CONF
+}
 
 GATEWAY_PKGS = {
     OVS: [
@@ -31,34 +57,128 @@
         "quantum-dhcp-agent",
         'python-mysqldb',
         "nova-api-metadata"
-        ],
-    }
-
-GATEWAY_AGENTS = {
-    OVS: [
-        "quantum-plugin-openvswitch-agent",
-        "quantum-l3-agent",
+    ],
+    NVP: [
+        "openvswitch-switch",
         "quantum-dhcp-agent",
+        'python-mysqldb',
         "nova-api-metadata"
-        ],
-    }
+    ]
+}
+
+EARLY_PACKAGES = {
+    OVS: ['openvswitch-datapath-dkms']
+}
+
+
+def get_early_packages():
+    '''Return a list of package for pre-install based on configured plugin'''
+    if config('plugin') in EARLY_PACKAGES:
+        return EARLY_PACKAGES[config('plugin')]
+    else:
+        return []
+
+
+def get_packages():
+    '''Return a list of packages for install based on the configured plugin'''
+    return GATEWAY_PKGS[config('plugin')]
 
 EXT_PORT_CONF = '/etc/init/ext-port.conf'
-
-
-def get_os_version(package=None):
-    apt.init()
-    cache = apt.Cache()
-    pkg = cache[package or 'quantum-common']
-    if pkg.current_ver:
-        return apt.upstream_version(pkg.current_ver.ver_str)
-    else:
-        return None
-
-
-if get_os_version('quantum-common') >= "2013.1":
-    for plugin in GATEWAY_AGENTS:
-        GATEWAY_AGENTS[plugin].append("quantum-metadata-agent")
+TEMPLATES = 'templates'
+
+QUANTUM_CONF = "/etc/quantum/quantum.conf"
+L3_AGENT_CONF = "/etc/quantum/l3_agent.ini"
+DHCP_AGENT_CONF = "/etc/quantum/dhcp_agent.ini"
+METADATA_AGENT_CONF = "/etc/quantum/metadata_agent.ini"
+NOVA_CONF = "/etc/nova/nova.conf"
+
+SHARED_CONFIG_FILES = {
+    DHCP_AGENT_CONF: {
+        'hook_contexts': [quantum_contexts.QuantumGatewayContext()],
+        'services': ['quantum-dhcp-agent']
+    },
+    METADATA_AGENT_CONF: {
+        'hook_contexts': [quantum_contexts.NetworkServiceContext()],
+        'services': ['quantum-metadata-agent']
+    },
+    NOVA_CONF: {
+        'hook_contexts': [context.AMQPContext(),
+                          context.SharedDBContext(),
+                          quantum_contexts.NetworkServiceContext(),
+                          quantum_contexts.QuantumGatewayContext()],
+        'services': ['nova-api-metadata']
+    },
+}
+
+OVS_CONFIG_FILES = {
+    QUANTUM_CONF: {
+        'hook_contexts': [context.AMQPContext(),
+                          quantum_contexts.QuantumGatewayContext()],
+        'services': ['quantum-l3-agent',
+                     'quantum-dhcp-agent',
+                     'quantum-metadata-agent',
+                     'quantum-plugin-openvswitch-agent']
+    },
+    L3_AGENT_CONF: {
+        'hook_contexts': [quantum_contexts.NetworkServiceContext()],
+        'services': ['quantum-l3-agent']
+    },
+    # TODO: Check to see if this is actually required
+    OVS_PLUGIN_CONF: {
+        'hook_contexts': [context.SharedDBContext(),
+                          quantum_contexts.QuantumGatewayContext()],
+        'services': ['quantum-plugin-openvswitch-agent']
+    },
+    EXT_PORT_CONF: {
+        'hook_contexts': [quantum_contexts.ExternalPortContext()],
+        'services': []
+    }
+}
+
+NVP_CONFIG_FILES = {
+    QUANTUM_CONF: {
+        'hook_contexts': [context.AMQPContext()],
+        'services': ['quantum-dhcp-agent', 'quantum-metadata-agent']
+    },
+}
+
+CONFIG_FILES = {
+    NVP: NVP_CONFIG_FILES.update(SHARED_CONFIG_FILES),
+    OVS: OVS_CONFIG_FILES.update(SHARED_CONFIG_FILES),
+}
+
+
+def register_configs():
+    ''' Register config files with their respective contexts. '''
+    release = get_os_codename_package('quantum-common', fatal=False) or \
+        'essex'
+    configs = templating.OSConfigRenderer(templates_dir=TEMPLATES,
+                                          openstack_release=release)
+
+    plugin = config('plugin')
+    for conf in CONFIG_FILES[plugin]:
+        configs.register(conf, CONFIG_FILES[conf]['hook_contexts'])
+
+    return configs
+
+
+def restart_map():
+    '''
+    Determine the correct resource map to be passed to
+    charmhelpers.core.restart_on_change() based on the services configured.
+
+    :returns: dict: A dictionary mapping config file to lists of services
+                    that should be restarted when file changes.
+    '''
+    _map = []
+    for f, ctxt in CONFIG_FILES[config('plugin')].iteritems():
+        svcs = []
+        for svc in ctxt['services']:
+            svcs.append(svc)
+        if svcs:
+            _map.append((f, svcs))
+    return OrderedDict(_map)
+
 
 DB_USER = "quantum"
 QUANTUM_DB = "quantum"
@@ -66,77 +186,12 @@
 NOVA_DB_USER = "nova"
 NOVA_DB = "nova"
 
-QUANTUM_CONF = "/etc/quantum/quantum.conf"
-L3_AGENT_CONF = "/etc/quantum/l3_agent.ini"
-DHCP_AGENT_CONF = "/etc/quantum/dhcp_agent.ini"
-METADATA_AGENT_CONF = "/etc/quantum/metadata_agent.ini"
-NOVA_CONF = "/etc/nova/nova.conf"
-
-RESTART_MAP = {
-    QUANTUM_CONF: [
-        'quantum-l3-agent',
-        'quantum-dhcp-agent',
-        'quantum-metadata-agent',
-        'quantum-plugin-openvswitch-agent'
-        ],
-    DHCP_AGENT_CONF: [
-        'quantum-dhcp-agent'
-        ],
-    L3_AGENT_CONF: [
-        'quantum-l3-agent'
-        ],
-    METADATA_AGENT_CONF: [
-        'quantum-metadata-agent'
-        ],
-    OVS_PLUGIN_CONF: [
-        'quantum-plugin-openvswitch-agent'
-        ],
-    NOVA_CONF: [
-        'nova-api-metadata'
-        ]
-    }
-
 RABBIT_USER = "nova"
 RABBIT_VHOST = "nova"
 
 INT_BRIDGE = "br-int"
 EXT_BRIDGE = "br-ex"
 
-
-def add_bridge(name):
-    status = subprocess.check_output(["ovs-vsctl", "show"])
-    if "Bridge {}".format(name) not in status:
-        log('INFO', 'Creating bridge {}'.format(name))
-        subprocess.check_call(["ovs-vsctl", "add-br", name])
-
-
-def del_bridge(name):
-    status = subprocess.check_output(["ovs-vsctl", "show"])
-    if "Bridge {}".format(name) in status:
-        log('INFO', 'Deleting bridge {}'.format(name))
-        subprocess.check_call(["ovs-vsctl", "del-br", name])
-
-
-def add_bridge_port(name, port):
-    status = subprocess.check_output(["ovs-vsctl", "show"])
-    if ("Bridge {}".format(name) in status and
-        "Interface \"{}\"".format(port) not in status):
-        log('INFO',
-            'Adding port {} to bridge {}'.format(port, name))
-        subprocess.check_call(["ovs-vsctl", "add-port", name, port])
-        subprocess.check_call(["ip", "link", "set", port, "up"])
-
-
-def del_bridge_port(name, port):
-    status = subprocess.check_output(["ovs-vsctl", "show"])
-    if ("Bridge {}".format(name) in status and
-        "Interface \"{}\"".format(port) in status):
-        log('INFO',
-            'Deleting port {} from bridge {}'.format(port, name))
-        subprocess.check_call(["ovs-vsctl", "del-port", name, port])
-        subprocess.check_call(["ip", "link", "set", port, "down"])
-
-
 SHARED_SECRET = "/etc/quantum/secret.txt"
 
 
@@ -151,33 +206,22 @@
             secret = secret_file.read().strip()
     return secret
 
-
-def flush_local_configuration():
-    if os.path.exists('/usr/bin/quantum-netns-cleanup'):
-        cmd = [
-            "quantum-netns-cleanup",
-            "--config-file=/etc/quantum/quantum.conf"
-            ]
-        for agent_conf in ['l3_agent.ini', 'dhcp_agent.ini']:
-            agent_cmd = list(cmd)
-            agent_cmd.append('--config-file=/etc/quantum/{}'\
-                                .format(agent_conf))
-            subprocess.call(agent_cmd)
-
-
-def install_ca(ca_cert):
-    with open('/usr/local/share/ca-certificates/keystone_juju_ca_cert.crt',
-              'w') as crt:
-        crt.write(base64.b64decode(ca_cert))
-    subprocess.check_call(['update-ca-certificates', '--fresh'])
-
 DHCP_AGENT = "DHCP Agent"
 L3_AGENT = "L3 Agent"
 
 
-def reassign_agent_resources(env):
+def reassign_agent_resources():
     ''' Use agent scheduler API to detect down agents and re-schedule '''
-    from quantumclient.v2_0 import client
+    env = quantum_contexts.NetworkServiceContext()()
+    if not env:
+        log('Unable to re-assign resources at this time')
+        return
+    try:
+        from quantumclient.v2_0 import client
+    except ImportError:
+        ''' Try to import neutronclient instead for havana+ '''
+        from neutronclient.v2_0 import client
+
     # TODO: Fixup for https keystone
     auth_url = 'http://%(keystone_host)s:%(auth_port)s/v2.0' % env
     quantum = client.Client(username=env['service_username'],
@@ -192,7 +236,7 @@
     networks = {}
     for agent in agents['agents']:
         if not agent['alive']:
-            log('INFO', 'DHCP Agent %s down' % agent['id'])
+            log('DHCP Agent %s down' % agent['id'])
             for network in \
                 quantum.list_networks_on_dhcp_agent(agent['id'])['networks']:
                 networks[network['id']] = agent['id']
@@ -203,7 +247,7 @@
     routers = {}
     for agent in agents['agents']:
         if not agent['alive']:
-            log('INFO', 'L3 Agent %s down' % agent['id'])
+            log('L3 Agent %s down' % agent['id'])
             for router in \
                 quantum.list_routers_on_l3_agent(agent['id'])['routers']:
                 routers[router['id']] = agent['id']
@@ -213,8 +257,7 @@
     index = 0
     for router_id in routers:
         agent = index % len(l3_agents)
-        log('INFO',
-            'Moving router %s from %s to %s' % \
+        log('Moving router %s from %s to %s' %
             (router_id, routers[router_id], l3_agents[agent]))
         quantum.remove_router_from_l3_agent(l3_agent=routers[router_id],
                                             router_id=router_id)
@@ -225,8 +268,7 @@
     index = 0
     for network_id in networks:
         agent = index % len(dhcp_agents)
-        log('INFO',
-            'Moving network %s from %s to %s' % \
+        log('Moving network %s from %s to %s' %
             (network_id, networks[network_id], dhcp_agents[agent]))
         quantum.remove_network_from_dhcp_agent(dhcp_agent=networks[network_id],
                                                network_id=network_id)
@@ -234,16 +276,57 @@
                                           body={'network_id': network_id})
         index += 1
 
-def do_openstack_upgrade():
-    configure_source()
-    plugin = config_get('plugin')
-    pkgs = []
-    if plugin in GATEWAY_PKGS.keys():
-        pkgs += GATEWAY_PKGS[plugin]
-        if plugin == OVS:
-            pkgs.append('openvswitch-datapath-dkms')
-    cmd = ['apt-get', '-y',
-           '--option', 'Dpkg::Options::=--force-confold',
-           '--option', 'Dpkg::Options::=--force-confdef',
-           'install'] + pkgs
-    subprocess.check_call(cmd)
+
+def do_openstack_upgrade(configs):
+    """
+    Perform an upgrade.  Takes care of upgrading packages, rewriting
+    configs, database migrations and potentially any other post-upgrade
+    actions.
+
+    :param configs: The charms main OSConfigRenderer object.
+    """
+    new_src = config('openstack-origin')
+    new_os_rel = get_os_codename_install_source(new_src)
+
+    log('Performing OpenStack upgrade to %s.' % (new_os_rel))
+
+    configure_installation_source(new_src)
+    dpkg_opts = [
+        '--option', 'Dpkg::Options::=--force-confnew',
+        '--option', 'Dpkg::Options::=--force-confdef',
+    ]
+    apt_update(fatal=True)
+    apt_install(packages=GATEWAY_PKGS[config('plugin')], options=dpkg_opts,
+                fatal=True)
+
+    # set CONFIGS to load templates from new release
+    configs.set_release(openstack_release=new_os_rel)
+
+
+@cached
+def get_host_ip(hostname=None):
+    try:
+        import dns.resolver
+    except ImportError:
+        apt_install('python-dnspython', fatal=True)
+        import dns.resolver
+    hostname = hostname or 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
+
+
+def configure_ovs():
+    if config('plugin') == OVS:
+        add_bridge(INT_BRIDGE)
+        add_bridge(EXT_BRIDGE)
+        ext_port = config('ext-port')
+        if ext_port:
+            add_bridge_port(EXT_BRIDGE, ext_port)
+    if config('plugin') == NVP:
+        add_bridge(INT_BRIDGE)

=== modified symlink 'hooks/shared-db-relation-changed'
=== target changed u'hooks.py' => u'quantum_hooks.py'
=== modified symlink 'hooks/shared-db-relation-joined'
=== target changed u'hooks.py' => u'quantum_hooks.py'
=== modified symlink 'hooks/start'
=== target changed u'hooks.py' => u'quantum_hooks.py'
=== modified symlink 'hooks/stop'
=== target changed u'hooks.py' => u'quantum_hooks.py'
=== modified symlink 'hooks/upgrade-charm'
=== target changed u'hooks.py' => u'quantum_hooks.py'
=== added file 'setup.cfg'
--- setup.cfg	1970-01-01 00:00:00 +0000
+++ setup.cfg	2013-07-19 09:54:29 +0000
@@ -0,0 +1,5 @@
+[nosetests]
+verbosity=2
+with-coverage=1
+cover-erase=1
+cover-package=hooks

=== modified file 'templates/dhcp_agent.ini'
--- templates/dhcp_agent.ini	2012-11-05 11:59:27 +0000
+++ templates/dhcp_agent.ini	2013-07-19 09:54:29 +0000
@@ -3,3 +3,8 @@
 interface_driver = quantum.agent.linux.interface.OVSInterfaceDriver
 dhcp_driver = quantum.agent.linux.dhcp.Dnsmasq
 root_helper = sudo /usr/bin/quantum-rootwrap /etc/quantum/rootwrap.conf
+{% if plugin == 'nvp' %}
+ovs_use_veth = True
+enable_metadata_network = True
+enable_isolated_metadata = True
+{% endif %}

=== removed file 'templates/evacuate_unit.py'
--- templates/evacuate_unit.py	2013-04-12 16:27:28 +0000
+++ templates/evacuate_unit.py	1970-01-01 00:00:00 +0000
@@ -1,70 +0,0 @@
-#!/usr/bin/python
-
-import subprocess
-
-
-def log(priority, message):
-    print "{}: {}".format(priority, message)
-
-DHCP_AGENT = "DHCP Agent"
-L3_AGENT = "L3 Agent"
-
-
-def evacuate_unit(unit):
-    ''' Use agent scheduler API to detect down agents and re-schedule '''
-    from quantumclient.v2_0 import client
-    # TODO: Fixup for https keystone
-    auth_url = 'http://{{ keystone_host }}:{{ auth_port }}/v2.0'
-    quantum = client.Client(username='{{ service_username }}',
-                            password='{{ service_password }}',
-                            tenant_name='{{ service_tenant }}',
-                            auth_url=auth_url,
-                            region_name='{{ region }}')
-
-    agents = quantum.list_agents(agent_type=DHCP_AGENT)
-    dhcp_agents = []
-    l3_agents = []
-    networks = {}
-    for agent in agents['agents']:
-        if agent['alive'] and agent['host'] != unit:
-            dhcp_agents.append(agent['id'])
-        elif agent['host'] == unit:
-            for network in \
-                quantum.list_networks_on_dhcp_agent(agent['id'])['networks']:
-                networks[network['id']] = agent['id']
-
-    agents = quantum.list_agents(agent_type=L3_AGENT)
-    routers = {}
-    for agent in agents['agents']:
-        if agent['alive'] and agent['host'] != unit:
-            l3_agents.append(agent['id'])
-        elif agent['host'] == unit:
-            for router in \
-                quantum.list_routers_on_l3_agent(agent['id'])['routers']:
-                routers[router['id']] = agent['id']
-
-    index = 0
-    for router_id in routers:
-        agent = index % len(l3_agents)
-        log('INFO',
-            'Moving router %s from %s to %s' % \
-            (router_id, routers[router_id], l3_agents[agent]))
-        quantum.remove_router_from_l3_agent(l3_agent=routers[router_id],
-                                            router_id=router_id)
-        quantum.add_router_to_l3_agent(l3_agent=l3_agents[agent],
-                                       body={'router_id': router_id})
-        index += 1
-
-    index = 0
-    for network_id in networks:
-        agent = index % len(dhcp_agents)
-        log('INFO',
-            'Moving network %s from %s to %s' % \
-            (network_id, networks[network_id], dhcp_agents[agent]))
-        quantum.remove_network_from_dhcp_agent(dhcp_agent=networks[network_id],
-                                               network_id=network_id)
-        quantum.add_network_to_dhcp_agent(dhcp_agent=dhcp_agents[agent],
-                                          body={'network_id': network_id})
-        index += 1
-
-evacuate_unit(subprocess.check_output(['hostname', '-f']).strip())

=== modified file 'templates/l3_agent.ini'
--- templates/l3_agent.ini	2013-01-22 18:36:19 +0000
+++ templates/l3_agent.ini	2013-07-19 09:54:29 +0000
@@ -1,6 +1,6 @@
 [DEFAULT]
 interface_driver = quantum.agent.linux.interface.OVSInterfaceDriver
-auth_url = http://{{ keystone_host }}:{{ service_port }}/v2.0
+auth_url = {{ service_protocol }}://{{ keystone_host }}:{{ service_port }}/v2.0
 auth_region = {{ region }}
 admin_tenant_name = {{ service_tenant }}
 admin_user = {{ service_username }}

=== modified file 'templates/metadata_agent.ini'
--- templates/metadata_agent.ini	2013-01-22 18:36:19 +0000
+++ templates/metadata_agent.ini	2013-07-19 09:54:29 +0000
@@ -1,6 +1,6 @@
 [DEFAULT]
 debug = True
-auth_url = http://{{ keystone_host }}:{{ service_port }}/v2.0
+auth_url = {{ service_protocol }}://{{ keystone_host }}:{{ service_port }}/v2.0
 auth_region = {{ region }}
 admin_tenant_name = {{ service_tenant }}
 admin_user = {{ service_username }}

=== modified file 'templates/nova.conf'
--- templates/nova.conf	2013-03-11 12:25:14 +0000
+++ templates/nova.conf	2013-07-19 09:54:29 +0000
@@ -22,4 +22,4 @@
 quantum_admin_tenant_name={{ service_tenant }}
 quantum_admin_username={{ service_username }}
 quantum_admin_password={{ service_password }}
-quantum_admin_auth_url=http://{{ keystone_host }}:{{ service_port }}/v2.0
+quantum_admin_auth_url={{ service_protocol }}://{{ keystone_host }}:{{ service_port }}/v2.0

=== added directory 'unit_tests'
=== added file 'unit_tests/__init__.py'