Merge lp:~openstack-charmers/charms/precise/quantum-gateway/ha-support into lp:~charmers/charms/precise/quantum-gateway/trunk

[James Page]

Support for Grizzly

Support for High Avaliability

=== modified file '.pydevproject'
--- .pydevproject	2012-12-06 10:22:24 +0000
+++ .pydevproject	2013-05-29 17:55:39 +0000
@@ -1,10 +1,9 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<?eclipse-pydev version="1.0"?>
-
-<pydev_project>
+<?eclipse-pydev version="1.0"?><pydev_project>
 <pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
 <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>
 </pydev_pathproperty>
 </pydev_project>

=== added symlink 'hooks/cluster-relation-departed'
=== target is u'hooks.py'
=== added symlink 'hooks/ha-relation-joined'
=== target is u'hooks.py'
=== modified file 'hooks/hooks.py'
--- hooks/hooks.py	2012-12-03 15:16:55 +0000
+++ hooks/hooks.py	2013-05-29 17:55:39 +0000
@@ -1,6 +1,8 @@
 #!/usr/bin/python
 
-import utils
+import lib.utils as utils
+import lib.cluster_utils as cluster
+import lib.openstack_common as openstack
 import sys
 import quantum_utils as qutils
 import os
@@ -21,18 +23,31 @@
         sys.exit(1)
 
 
[e-mail]_restart(qutils.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_l3_agent_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)
-        utils.restart(*qutils.GATEWAY_AGENTS[PLUGIN])
     else:
         utils.juju_log('ERROR',
                        'Please provide a valid plugin config')
@@ -44,6 +59,19 @@
     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
@@ -56,6 +84,30 @@
                        )
 
 
+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
@@ -71,7 +123,7 @@
 
 
 def render_plugin_conf():
-    context = get_db_conf()
+    context = get_quantum_db_conf()
     if (context and
         os.path.exists(qutils.PLUGIN_CONF[PLUGIN])):
         context['local_ip'] = utils.get_host_ip()
@@ -84,6 +136,31 @@
                        )
 
 
+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):
@@ -98,7 +175,15 @@
                 "service_password": utils.relation_get('service_password',
                                                        unit, relid),
                 "service_tenant": utils.relation_get('service_tenant',
-                                                     unit, relid)
+                                                     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
@@ -106,24 +191,28 @@
 
 
 def db_joined():
-    utils.relation_set(username=qutils.DB_USER,
-                       database=qutils.QUANTUM_DB,
-                       hostname=utils.unit_get('private-address'))
-
-
+    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()
-    utils.restart(*qutils.GATEWAY_AGENTS[PLUGIN])
-
-
-def get_db_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('private-address',
+                "host": utils.relation_get('db_host',
                                            unit, relid),
                 "user": qutils.DB_USER,
-                "password": utils.relation_get('password',
+                "password": utils.relation_get('quantum_password',
                                                unit, relid),
                 "db": qutils.QUANTUM_DB
                 }
@@ -132,14 +221,32 @@
     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
+
+
 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()
-    utils.restart(*qutils.GATEWAY_AGENTS[PLUGIN])
+    render_metadata_api_conf()
 
 
 def get_rabbit_conf():
@@ -153,15 +260,43 @@
                 "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)
 def nm_changed():
+    render_dhcp_agent_conf()
     render_l3_agent_conf()
-    utils.restart(*qutils.GATEWAY_AGENTS[PLUGIN])
-
+    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
+
+
+def cluster_departed():
+    conf = get_keystone_conf()
+    if conf and cluster.eligible_leader(None):
+        qutils.reassign_agent_resources(conf)
 
 utils.do_hooks({
     "install": install,
@@ -172,6 +307,7 @@
     "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)

=== added directory 'hooks/lib'
=== added file 'hooks/lib/__init__.py'
=== added file 'hooks/lib/cluster_utils.py'
--- hooks/lib/cluster_utils.py	1970-01-01 00:00:00 +0000
+++ hooks/lib/cluster_utils.py	2013-05-29 17:55:39 +0000
@@ -0,0 +1,130 @@
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This file is sourced from lp:openstack-charm-helpers
+#
+# Authors:
+#  James Page <[e-mail]>
+#  Adam Gandelman <[e-mail]>
+#
+
+from 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)

=== added file 'hooks/lib/openstack_common.py'
--- hooks/lib/openstack_common.py	1970-01-01 00:00:00 +0000
+++ hooks/lib/openstack_common.py	2013-05-29 17:55:39 +0000
@@ -0,0 +1,230 @@
+#!/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"]

=== added file 'hooks/lib/utils.py'
--- hooks/lib/utils.py	1970-01-01 00:00:00 +0000
+++ hooks/lib/utils.py	2013-05-29 17:55:39 +0000
@@ -0,0 +1,359 @@
+#
+# 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 file 'hooks/quantum_utils.py'
--- hooks/quantum_utils.py	2012-12-03 15:16:55 +0000
+++ hooks/quantum_utils.py	2013-05-29 17:55:39 +0000
@@ -1,26 +1,27 @@
 import subprocess
-from utils import juju_log as log
+import os
+import uuid
+import base64
+import apt_pkg as apt
+from lib.utils import (
+    juju_log as log,
+    configure_source,
+    config_get
+    )
 
 
 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
     }
 
 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 = {
@@ -28,28 +29,72 @@
         "quantum-plugin-openvswitch-agent",
         "quantum-l3-agent",
         "quantum-dhcp-agent",
-        'python-mysqldb'
+        'python-mysqldb',
+        "nova-api-metadata"
         ],
-    NVP: [
-        "quantum-plugin-nicira"
-        ]
     }
 
 GATEWAY_AGENTS = {
     OVS: [
         "quantum-plugin-openvswitch-agent",
         "quantum-l3-agent",
-        "quantum-dhcp-agent"
-        ]
+        "quantum-dhcp-agent",
+        "nova-api-metadata"
+        ],
     }
 
+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")
+
 DB_USER = "quantum"
 QUANTUM_DB = "quantum"
 KEYSTONE_SERVICE = "quantum"
+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"
@@ -90,3 +135,115 @@
             '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"
+
+
+def get_shared_secret():
+    secret = None
+    if not os.path.exists(SHARED_SECRET):
+        secret = str(uuid.uuid4())
+        with open(SHARED_SECRET, 'w') as secret_file:
+            secret_file.write(secret)
+    else:
+        with open(SHARED_SECRET, 'r') as secret_file:
+            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):
+    ''' 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)s:%(auth_port)s/v2.0' % env
+    quantum = client.Client(username=env['service_username'],
+                            password=env['service_password'],
+                            tenant_name=env['service_tenant'],
+                            auth_url=auth_url,
+                            region_name=env['region'])
+
+    agents = quantum.list_agents(agent_type=DHCP_AGENT)
+    dhcp_agents = []
+    l3_agents = []
+    networks = {}
+    for agent in agents['agents']:
+        if not agent['alive']:
+            log('INFO', 'DHCP Agent %s down' % agent['id'])
+            for network in \
+                quantum.list_networks_on_dhcp_agent(agent['id'])['networks']:
+                networks[network['id']] = agent['id']
+        else:
+            dhcp_agents.append(agent['id'])
+
+    agents = quantum.list_agents(agent_type=L3_AGENT)
+    routers = {}
+    for agent in agents['agents']:
+        if not agent['alive']:
+            log('INFO', 'L3 Agent %s down' % agent['id'])
+            for router in \
+                quantum.list_routers_on_l3_agent(agent['id'])['routers']:
+                routers[router['id']] = agent['id']
+        else:
+            l3_agents.append(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
+
+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)

=== removed file 'hooks/utils.py'
--- hooks/utils.py	2012-12-07 08:36:54 +0000
+++ hooks/utils.py	1970-01-01 00:00:00 +0000
@@ -1,237 +0,0 @@
-
-#
-# Copyright 2012 Canonical Ltd.
-#
-# Authors:
-#  James Page <[e-mail]>
-#  Paul Collins <[e-mail]>
-#
-
-import os
-import subprocess
-import socket
-import sys
-
-
-def do_hooks(hooks):
-    hook = os.path.basename(sys.argv[0])
-
-    try:
-        hook_func = hooks[hook]
-    except KeyError:
-        juju_log('INFO',
-                 "This charm doesn't know how to handle '{}'.".format(hook))
-    else:
-        hook_func()
-
-
-def install(*pkgs):
-    cmd = [
-        'apt-get',
-        '-y',
-        'install'
-          ]
-    for pkg in pkgs:
-        cmd.append(pkg)
-    subprocess.check_call(cmd)
-
-TEMPLATES_DIR = 'templates'
-
-try:
-    import jinja2
-except ImportError:
-    install('python-jinja2')
-    import jinja2
-
-try:
-    import dns.resolver
-except ImportError:
-    install('python-dnspython')
-    import dns.resolver
-
-
-def render_template(template_name, context, template_dir=TEMPLATES_DIR):
-    templates = jinja2.Environment(
-                    loader=jinja2.FileSystemLoader(template_dir)
-                    )
-    template = templates.get_template(template_name)
-    return template.render(context)
-
-CLOUD_ARCHIVE = \
-""" # Ubuntu Cloud Archive
-deb http://ubuntu-cloud.archive.canonical.com/ubuntu {} main
-"""
-
-CLOUD_ARCHIVE_POCKETS = {
-    'precise-folsom': 'precise-updates/folsom',
-    'precise-folsom/updates': 'precise-updates/folsom',
-    'precise-folsom/proposed': 'precise-proposed/folsom',
-    'precise-grizzly': 'precise-updates/grizzly',
-    'precise-grizzly/updates': 'precise-updates/grizzly',
-    'precise-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:'):
-        install('ubuntu-cloud-keyring')
-        pocket = source.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)
-
-
-def relation_ids(relation):
-    cmd = [
-        'relation-ids',
-        relation
-        ]
-    return subprocess.check_output(cmd).split()  # IGNORE:E1103
-
-
-def relation_list(rid):
-    cmd = [
-        'relation-list',
-        '-r', rid,
-        ]
-    return subprocess.check_output(cmd).split()  # IGNORE:E1103
-
-
-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
-
-
-def relation_set(**kwargs):
-    cmd = [
-        'relation-set'
-        ]
-    args = []
-    for k, v in kwargs.items():
-        if k == 'rid':
-            cmd.append('-r')
-            cmd.append(v)
-        else:
-            args.append('{}={}'.format(k, v))
-    cmd += args
-    subprocess.check_call(cmd)
-
-
-def unit_get(attribute):
-    cmd = [
-        'unit-get',
-        attribute
-        ]
-    value = subprocess.check_output(cmd).strip()  # IGNORE:E1103
-    if value == "":
-        return None
-    else:
-        return value
-
-
-def config_get(attribute):
-    cmd = [
-        'config-get',
-        attribute
-        ]
-    value = subprocess.check_output(cmd).strip()  # IGNORE:E1103
-    if value == "":
-        return None
-    else:
-        return value
-
-
-def get_unit_hostname():
-    return socket.gethostname()
-
-
-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:
-        pass
-    try:
-        answers = dns.resolver.query(hostname, 'A')
-        if answers:
-            return answers[0].address
-    except dns.resolver.NXDOMAIN:
-        pass
-    return None
-
-
-def restart(*services):
-    for service in services:
-        subprocess.check_call(['service', service, 'restart'])
-
-
-def stop(*services):
-    for service in services:
-        subprocess.check_call(['service', service, 'stop'])
-
-
-def start(*services):
-    for service in services:
-        subprocess.check_call(['service', service, 'start'])

=== modified file 'metadata.yaml'
--- metadata.yaml	2012-12-03 15:16:55 +0000
+++ metadata.yaml	2013-05-29 17:55:39 +0000
@@ -20,4 +20,7 @@
   shared-db:
     interface: mysql-shared
   amqp:
-    interface: rabbitmq
\ No newline at end of file
+    interface: rabbitmq
+peers:
+  cluster:
+    interface: quantum-gateway-ha
\ No newline at end of file

=== modified file 'revision'
--- revision	2012-12-07 08:36:54 +0000
+++ revision	2013-05-29 17:55:39 +0000
@@ -1,1 +1,1 @@
-36
+56

=== added file 'templates/evacuate_unit.py'
--- templates/evacuate_unit.py	1970-01-01 00:00:00 +0000
+++ templates/evacuate_unit.py	2013-05-29 17:55:39 +0000
@@ -0,0 +1,70 @@
+#!/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())

=== added file 'templates/ext-port.conf'
--- templates/ext-port.conf	1970-01-01 00:00:00 +0000
+++ templates/ext-port.conf	2013-05-29 17:55:39 +0000
@@ -0,0 +1,9 @@
+description "Enabling Quantum external networking port"
+
+start on runlevel [2345]
+
+task
+
+script
+	ip link set {{ ext_port }} up
+end script
\ No newline at end of file

=== modified file 'templates/l3_agent.ini'
--- templates/l3_agent.ini	2012-11-05 11:59:27 +0000
+++ templates/l3_agent.ini	2013-05-29 17:55:39 +0000
@@ -1,7 +1,7 @@
 [DEFAULT]
 interface_driver = quantum.agent.linux.interface.OVSInterfaceDriver
 auth_url = http://{{ keystone_host }}:{{ service_port }}/v2.0
-auth_region = RegionOne
+auth_region = {{ region }}
 admin_tenant_name = {{ service_tenant }}
 admin_user = {{ service_username }}
 admin_password = {{ service_password }}

=== added file 'templates/metadata_agent.ini'
--- templates/metadata_agent.ini	1970-01-01 00:00:00 +0000
+++ templates/metadata_agent.ini	2013-05-29 17:55:39 +0000
@@ -0,0 +1,17 @@
+[DEFAULT]
+debug = True
+auth_url = http://{{ keystone_host }}:{{ service_port }}/v2.0
+auth_region = {{ region }}
+admin_tenant_name = {{ service_tenant }}
+admin_user = {{ service_username }}
+admin_password = {{ service_password }}
+root_helper = sudo quantum-rootwrap /etc/quantum/rootwrap.conf
+state_path = /var/lib/quantum
+# Gateway runs a metadata API server locally
+nova_metadata_ip = {{ local_ip }}
+nova_metadata_port = 8775
+# When proxying metadata requests, Quantum signs the Instance-ID header with a
+# shared secret to prevent spoofing. You may select any string for a secret,
+# but it must match here and in the configuration used by the Nova Metadata
+# Server. NOTE: Nova uses a different key: quantum_metadata_proxy_shared_secret
+metadata_proxy_shared_secret = {{ shared_secret }}

=== added file 'templates/nova.conf'
--- templates/nova.conf	1970-01-01 00:00:00 +0000
+++ templates/nova.conf	2013-05-29 17:55:39 +0000
@@ -0,0 +1,25 @@
+[DEFAULT]
+logdir=/var/log/nova
+state_path=/var/lib/nova
+lock_path=/var/lock/nova
+root_helper=sudo nova-rootwrap /etc/nova/rootwrap.conf
+verbose=True
+api_paste_config=/etc/nova/api-paste.ini
+enabled_apis=metadata
+multi_host=True
+sql_connection=mysql://{{ user }}:{{ password }}@{{ host }}/{{ db }}
+quantum_metadata_proxy_shared_secret={{ shared_secret }}
+service_quantum_metadata_proxy=True
+# Access to message bus
+rabbit_userid={{ rabbit_userid }}
+rabbit_virtual_host={{ rabbit_virtual_host }}
+rabbit_host={{ rabbit_host }}
+rabbit_password={{ rabbit_password }}
+# Access to quantum API services
+network_api_class=nova.network.quantumv2.api.API
+quantum_auth_strategy=keystone
+quantum_url={{ quantum_url }}
+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

=== modified file 'templates/ovs_quantum_plugin.ini'
--- templates/ovs_quantum_plugin.ini	2012-11-05 11:59:27 +0000
+++ templates/ovs_quantum_plugin.ini	2013-05-29 17:55:39 +0000
@@ -7,5 +7,5 @@
 enable_tunneling = True
 tunnel_id_ranges = 1:1000
 [AGENT]
-polling_interval = 2
+polling_interval = 10
 root_helper = sudo /usr/bin/quantum-rootwrap /etc/quantum/rootwrap.conf

=== modified file 'templates/quantum.conf'
--- templates/quantum.conf	2012-11-05 11:59:27 +0000
+++ templates/quantum.conf	2013-05-29 17:55:39 +0000
@@ -12,4 +12,9 @@
 control_exchange = quantum
 notification_driver = quantum.openstack.common.notifier.list_notifier
 list_notifier_drivers = quantum.openstack.common.notifier.rabbit_notifier
-[QUOTAS]
+lock_path = /var/lock/quantum
+# Ensure that netns cleanup operations kill processes and remove ports
+# force = true
+[AGENT]
+root_helper = sudo /usr/bin/quantum-rootwrap /etc/quantum/rootwrap.conf
+[QUOTAS]
\ No newline at end of file