Merge lp:~gandelman-a/charm-helpers/os_templating_contexts into lp:charm-helpers

[Adam Gandelman]

A common templating system and context generators for OpenStack charms.

[James Page (james-page)]

More feedback:

1) templating.py/get_loader

    tmpl_dirs = (
        ('essex', os.path.join(templates_dir, 'essex')),
        ('folsom', os.path.join(templates_dir, 'folsom')),
        ('grizzly', os.path.join(templates_dir, 'grizzly')),
        ('havana', os.path.join(templates_dir, 'havana')),
        ('icehouse', os.path.join(templates_dir, 'icehouse')),
    )

Can we drive this off a list of supported released please; if this is a for loop of suchlike they adding a new release is just done in openstack_utils.py

2) templating.py/general

level='ERROR'; hookenv has a constant for this - please use.

3) templating.py/OSConfigTemplate & OSConfigRenderer

Please could these classes grow some pydoc - took me a while to figure out how to use them.

review: Needs Fixing

[lp:~gandelman-a/charm-helpers/os_templating_contexts]

54. By Adam Gandelman on 2013-07-11

Capitalize openstack constatns, add icehouse.

55. By Adam Gandelman on 2013-07-11

Convert openstack release constants to ordered dict. Generate template search list from release constants.

56. By Adam Gandelman on 2013-07-11

Use logging constants in os templating.py

57. By Adam Gandelman on 2013-07-11

Add some docs to templating.py

[Adam Gandelman (gandelman-a)]

Hey James-

Fixed up logging, added some docs.

Good call on constructing the template loader from releases listed in openstack_utils. I needed to adjust those constants to be OrderedDicts.

review: Needs Resubmitting

=== added file 'charmhelpers/contrib/openstack/context.py'
--- charmhelpers/contrib/openstack/context.py	1970-01-01 00:00:00 +0000
+++ charmhelpers/contrib/openstack/context.py	2013-07-11 20:23:23 +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_utils import (
+    determine_api_port,
+    determine_haproxy_port,
+    https,
+    is_clustered,
+    peer_units,
+)
+
+from charmhelpers.contrib.hahelpers.apache_utils 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

=== modified file 'charmhelpers/contrib/openstack/openstack_utils.py'
--- charmhelpers/contrib/openstack/openstack_utils.py	2013-07-09 18:48:53 +0000
+++ charmhelpers/contrib/openstack/openstack_utils.py	2013-07-11 20:23:23 +0000
@@ -2,6 +2,8 @@
 
 # Common python helper functions used for OpenStack charms.
 
+from collections import OrderedDict
+
 import apt_pkg as apt
 import subprocess
 import os
@@ -18,24 +20,26 @@
 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',
-}
+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 = {
+SWIFT_CODENAMES = {
     '1.4.3': 'diablo',
     '1.4.8': 'essex',
     '1.7.4': 'folsom',
@@ -60,7 +64,7 @@
     rel = ''
     if src == 'distro':
         try:
-            rel = ubuntu_openstack_release[ubuntu_rel]
+            rel = UBUNTU_OPENSTACK_RELEASE[ubuntu_rel]
         except KeyError:
             e = 'Could not derive openstack release for '\
                 'this Ubuntu release: %s' % ubuntu_rel
@@ -74,7 +78,7 @@
 
     # Best guess match based on deb string provided
     if src.startswith('deb') or src.startswith('ppa'):
-        for k, v in openstack_codenames.iteritems():
+        for k, v in OPENSTACK_CODENAMES.iteritems():
             if v in src:
                 return v
 
@@ -87,7 +91,7 @@
 def get_os_codename_version(vers):
     '''Determine OpenStack codename from version number.'''
     try:
-        return openstack_codenames[vers]
+        return OPENSTACK_CODENAMES[vers]
     except KeyError:
         e = 'Could not determine OpenStack codename for version %s' % vers
         error_out(e)
@@ -95,7 +99,7 @@
 
 def get_os_version_codename(codename):
     '''Determine OpenStack version number from codename.'''
-    for k, v in openstack_codenames.iteritems():
+    for k, v in OPENSTACK_CODENAMES.iteritems():
         if v == codename:
             return k
     e = 'Could not derive OpenStack version for '\
@@ -103,17 +107,26 @@
     error_out(e)
 
 
-def get_os_codename_package(pkg, fatal=True):
+def get_os_codename_package(package, fatal=True):
     '''Derive OpenStack release codename from an installed package.'''
     apt.init()
     cache = apt.Cache()
 
     try:
-        pkg = cache[pkg]
+        pkg = cache[package]
     except:
         if not fatal:
             return None
-        e = 'Could not determine version of installed package: %s' % pkg
+        # 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)
@@ -121,10 +134,10 @@
     try:
         if 'swift' in pkg.name:
             vers = vers[:5]
-            return swift_codenames[vers]
+            return SWIFT_CODENAMES[vers]
         else:
             vers = vers[:6]
-            return openstack_codenames[vers]
+            return OPENSTACK_CODENAMES[vers]
     except KeyError:
         e = 'Could not determine OpenStack codename for version %s' % vers
         error_out(e)
@@ -138,9 +151,9 @@
         return None
 
     if 'swift' in pkg:
-        vers_map = swift_codenames
+        vers_map = SWIFT_CODENAMES
     else:
-        vers_map = openstack_codenames
+        vers_map = OPENSTACK_CODENAMES
 
     for version, cname in vers_map.iteritems():
         if cname == codename:

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

=== added file 'charmhelpers/contrib/openstack/templates/ceph.conf'
--- charmhelpers/contrib/openstack/templates/ceph.conf	1970-01-01 00:00:00 +0000
+++ charmhelpers/contrib/openstack/templates/ceph.conf	2013-07-11 20:23:23 +0000
@@ -0,0 +1,11 @@
+###############################################################################
+# [ WARNING ]
+# cinder configuration file maintained by Juju
+# local changes may be overwritten.
+###############################################################################
+{% if auth %}
+[global]
+ auth_supported = {{ auth }}
+ keyring = /etc/ceph/$cluster.$name.keyring
+ mon host = {{ mon_hosts }}
+{% endif %}

=== added file 'charmhelpers/contrib/openstack/templates/haproxy.cfg'
--- charmhelpers/contrib/openstack/templates/haproxy.cfg	1970-01-01 00:00:00 +0000
+++ charmhelpers/contrib/openstack/templates/haproxy.cfg	2013-07-11 20:23:23 +0000
@@ -0,0 +1,37 @@
+global
+    log 127.0.0.1 local0
+    log 127.0.0.1 local1 notice
+    maxconn 20000
+    user haproxy
+    group haproxy
+    spread-checks 0
+
+defaults
+    log global
+    mode http
+    option httplog
+    option dontlognull
+    retries 3
+    timeout queue 1000
+    timeout connect 1000
+    timeout client 30000
+    timeout server 30000
+
+listen stats :8888
+    mode http
+    stats enable
+    stats hide-version
+    stats realm Haproxy\ Statistics
+    stats uri /
+    stats auth admin:password
+
+{% if units %}
+{% for service, ports in service_ports.iteritems() -%}
+listen {{ service }} 0.0.0.0:{{ ports[0] }}
+    balance roundrobin
+    option tcplog
+    {% for unit, address in units.iteritems() -%}
+    server {{ unit }} {{ address }}:{{ ports[1] }} check
+    {% endfor %}
+{% endfor %}
+{% endif %}

=== added file 'charmhelpers/contrib/openstack/templates/openstack_https_frontend'
--- charmhelpers/contrib/openstack/templates/openstack_https_frontend	1970-01-01 00:00:00 +0000
+++ charmhelpers/contrib/openstack/templates/openstack_https_frontend	2013-07-11 20:23:23 +0000
@@ -0,0 +1,23 @@
+{% if endpoints %}
+{% for ext, int in endpoints %}
+Listen {{ ext }}
+NameVirtualHost *:{{ ext }}
+<VirtualHost *:{{ ext }}>
+    ServerName {{ private_address }}
+    SSLEngine on
+    SSLCertificateFile /etc/apache2/ssl/{{ namespace }}/cert
+    SSLCertificateKeyFile /etc/apache2/ssl/{{ namespace }}/key
+    ProxyPass / http://localhost:{{ int }}/
+    ProxyPassReverse / http://localhost:{{ int }}/
+    ProxyPreserveHost on
+</VirtualHost>
+<Proxy *>
+    Order deny,allow
+    Allow from all
+</Proxy>
+<Location />
+    Order allow,deny
+    Allow from all
+</Location>
+{% endfor %}
+{% endif %}

=== added file 'charmhelpers/contrib/openstack/templating.py'
--- charmhelpers/contrib/openstack/templating.py	1970-01-01 00:00:00 +0000
+++ charmhelpers/contrib/openstack/templating.py	2013-07-11 20:23:23 +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.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

=== modified file 'tests/contrib/openstack/test_openstack_utils.py'
--- tests/contrib/openstack/test_openstack_utils.py	2013-07-09 18:48:53 +0000
+++ tests/contrib/openstack/test_openstack_utils.py	2013-07-11 20:23:23 +0000
@@ -37,11 +37,12 @@
         'os_release': 'grizzly',
         'os_version': '1.7.7'
     },
+    # a package thats available in the cache but is not installed
     'cinder-common': {
-        'pkg_vers': '1:2013.2-0ubuntu1~cloud0',
         'os_release': 'havana',
         'os_version': '2013.2'
     },
+    # poorly formed openstack version
     'bad-version': {
         'pkg_vers': '1:2016.1-0ubuntu1.1~cloud0',
         'os_release': None,
@@ -66,11 +67,15 @@
         # mocks out the apt cache
         def cache_get(package):
             pkg = MagicMock()
-            if package in FAKE_REPO:
+            if package in FAKE_REPO and 'pkg_vers' in FAKE_REPO[package]:
                 pkg.name = package
                 pkg.current_ver.ver_str = FAKE_REPO[package]['pkg_vers']
+            elif (package in FAKE_REPO and
+                  'pkg_vers' not in FAKE_REPO[package]):
+                pkg.name = package
+                pkg.current_ver = None
             else:
-                raise
+                raise KeyError
             return pkg
         cache = MagicMock()
         cache.__getitem__.side_effect = cache_get
@@ -152,8 +157,11 @@
         with patch('apt_pkg.Cache') as cache:
             cache.return_value = self._apt_cache()
             for pkg, vers in FAKE_REPO.iteritems():
+                # test fake repo for all "installed" packages
                 if pkg.startswith('bad-'):
                     continue
+                if 'pkg_vers' not in vers:
+                    continue
                 self.assertEquals(openstack.get_os_codename_package(pkg),
                                   vers['os_release'])
 
@@ -168,7 +176,7 @@
 
     @patch('charmhelpers.contrib.openstack.openstack_utils.error_out')
     def test_os_codename_from_bad_package(self, mocked_error):
-        '''Test deriving OpenStack codename from an uninstalled package'''
+        '''Test deriving OpenStack codename from an unavailable package'''
         with patch('apt_pkg.Cache') as cache:
             cache.return_value = self._apt_cache()
             try:
@@ -177,11 +185,12 @@
                 # ignore exceptions that raise when error_out is mocked
                 # and doesn't sys.exit(1)
                 pass
-            _err = 'Could not determine version of installed package: foo'
-            mocked_error.assert_called_with(_err)
+            e = 'Could not determine version of package with no installation '\
+                'candidate: foo'
+            mocked_error.assert_called_with(e)
 
     def test_os_codename_from_bad_package_nonfatal(self):
-        '''Test OpenStack codename from an uninstalled package is non-fatal'''
+        '''Test OpenStack codename from an unavailable package is non-fatal'''
         with patch('apt_pkg.Cache') as cache:
             cache.return_value = self._apt_cache()
             self.assertEquals(
@@ -190,6 +199,28 @@
             )
 
     @patch('charmhelpers.contrib.openstack.openstack_utils.error_out')
+    def test_os_codename_from_uninstalled_package(self, mock_error):
+        '''Test OpenStack codename from an available but uninstalled pkg'''
+        with patch('apt_pkg.Cache') as cache:
+            cache.return_value = self._apt_cache()
+            try:
+                openstack.get_os_codename_package('cinder-common', fatal=True)
+            except:
+                pass
+            e = ('Could not determine version of uninstalled package: '
+                 'cinder-common')
+            mock_error.assert_called_with(e)
+
+    def test_os_codename_from_uninstalled_package_nonfatal(self):
+        '''Test OpenStack codename from avail uninstalled pkg is non fatal'''
+        with patch('apt_pkg.Cache') as cache:
+            cache.return_value = self._apt_cache()
+            self.assertEquals(
+                None,
+                openstack.get_os_codename_package('cinder-common', fatal=False)
+            )
+
+    @patch('charmhelpers.contrib.openstack.openstack_utils.error_out')
     def test_os_version_from_package(self, mocked_error):
         '''Test deriving OpenStack version from an installed package'''
         with patch('apt_pkg.Cache') as cache:
@@ -197,6 +228,8 @@
             for pkg, vers in FAKE_REPO.iteritems():
                 if pkg.startswith('bad-'):
                     continue
+                if 'pkg_vers' not in vers:
+                    continue
                 self.assertEquals(openstack.get_os_version_package(pkg),
                                   vers['os_version'])
 
@@ -211,8 +244,9 @@
                 # ignore exceptions that raise when error_out is mocked
                 # and doesn't sys.exit(1)
                 pass
-            _err = 'Could not determine version of installed package: foo'
-            mocked_error.assert_called_with(_err)
+            e = 'Could not determine version of package with no installation '\
+                'candidate: foo'
+            mocked_error.assert_called_with(e)
 
     def test_os_version_from_bad_package_nonfatal(self):
         '''Test OpenStack version from an uninstalled package is non-fatal'''

=== added file 'tests/contrib/openstack/test_os_contexts.py'
--- tests/contrib/openstack/test_os_contexts.py	1970-01-01 00:00:00 +0000
+++ tests/contrib/openstack/test_os_contexts.py	2013-07-11 20:23:23 +0000
@@ -0,0 +1,454 @@
+import unittest
+
+from mock import patch, MagicMock, call
+
+from contextlib import contextmanager
+from copy import copy
+
+import charmhelpers.contrib.openstack.context as context
+
+
+@contextmanager
+def patch_open():
+    '''Patch open() to allow mocking both open() itself and the file that is
+    yielded.
+
+    Yields the mock for "open" and "file", respectively.'''
+    mock_open = MagicMock(spec=open)
+    mock_file = MagicMock(spec=file)
+
+    @contextmanager
+    def stub_open(*args, **kwargs):
+        mock_open(*args, **kwargs)
+        yield mock_file
+
+    with patch('__builtin__.open', stub_open):
+        yield mock_open, mock_file
+
+
+class FakeRelation(object):
+    '''
+    A fake relation class. Lets tests specify simple relation data
+    for a default relation + unit (foo:0, foo/0, set in setUp()), eg:
+
+        rel = {
+            'private-address': 'foo',
+            'password': 'passwd',
+        }
+        relation = FakeRelation(rel)
+        self.relation_get.side_effect = relation.get
+        passwd = self.relation_get('password')
+
+    or more complex relations meant to be addressed by explicit relation id
+    + unit id combos:
+
+        rel = {
+            'mysql:0': {
+                'mysql/0': {
+                    'private-address': 'foo',
+                    'password': 'passwd',
+                }
+            }
+        }
+        relation = FakeRelation(rel)
+        self.relation_get.side_affect = relation.get
+        passwd = self.relation_get('password', rid='mysql:0', unit='mysql/0')
+    '''
+    def __init__(self, relation_data):
+        self.relation_data = relation_data
+
+    def get(self, attr=None, unit=None, rid=None):
+        if not rid or rid == 'foo:0':
+            if attr is None:
+                return self.relation_data
+            elif attr in self.relation_data:
+                return self.relation_data[attr]
+            return None
+        else:
+            if rid not in self.relation_data:
+                return None
+            try:
+                relation = self.relation_data[rid][unit]
+            except KeyError:
+                return None
+            if attr in relation:
+                return relation[attr]
+            return None
+
+    def relation_ids(self, relation):
+        return self.relation_data.keys()
+
+    def relation_units(self, relation_id):
+        if relation_id not in self.relation_data:
+            return None
+        return self.relation_data[relation_id].keys()
+
+SHARED_DB_RELATION = {
+    'db_host': 'dbserver.local',
+    'password': 'foo',
+}
+
+SHARED_DB_CONFIG = {
+    'database-user': 'adam',
+    'database': 'foodb',
+}
+
+IDENTITY_SERVICE_RELATION = {
+    'service_port': '5000',
+    'service_host': 'keystonehost.local',
+    'auth_host': 'keystone-host.local',
+    'auth_port': '35357',
+    'service_tenant': 'admin',
+    'service_password': 'foo',
+    'service_username': 'adam',
+}
+
+AMQP_RELATION = {
+    'private-address': 'rabbithost',
+    'password': 'foobar',
+    'vip': '10.0.0.1',
+}
+
+AMQP_CONFIG = {
+    'rabbit-user': 'adam',
+    'rabbit-vhost': 'foo',
+}
+
+CEPH_RELATION = {
+    'ceph:0': {
+        'ceph/0': {
+            'private-address': 'ceph_node1',
+            'auth': 'foo',
+        },
+        'ceph/1': {
+            'private-address': 'ceph_node2',
+            'auth': 'foo',
+        },
+    }
+}
+
+
+# Imported in contexts.py and needs patching in setUp()
+TO_PATCH = [
+    'b64decode',
+    'check_call',
+    'get_cert',
+    'get_ca_cert',
+    'log',
+    'config',
+    'relation_get',
+    'relation_ids',
+    'related_units',
+    'unit_get',
+    'https',
+    'determine_api_port',
+    'determine_haproxy_port',
+    'peer_units',
+    'is_clustered',
+]
+
+
+class ContextTests(unittest.TestCase):
+    def setUp(self):
+        for m in TO_PATCH:
+            setattr(self, m, self._patch(m))
+        # mock at least a single relation + unit
+        self.relation_ids.return_value = ['foo:0']
+        self.related_units.return_value = ['foo/0']
+
+    def _patch(self, method):
+        _m = patch('charmhelpers.contrib.openstack.context.' + method)
+        mock = _m.start()
+        self.addCleanup(_m.stop)
+        return mock
+
+    def test_base_class_not_implemented(self):
+        base = context.OSContextGenerator()
+        self.assertRaises(NotImplementedError, base)
+
+    def test_shared_db_context_with_data(self):
+        '''Test shared-db context with all required data'''
+        relation = FakeRelation(relation_data=SHARED_DB_RELATION)
+        self.relation_get.side_effect = relation.get
+        self.config.return_value = SHARED_DB_CONFIG
+        shared_db = context.SharedDBContext()
+        result = shared_db()
+        expected = {
+            'database_host': 'dbserver.local',
+            'database': 'foodb',
+            'database_user': 'adam',
+            'database_password': 'foo',
+        }
+        self.assertEquals(result, expected)
+
+    def test_shared_db_context_with_missing_relation(self):
+        '''Test shared-db context missing relation data'''
+        incomplete_relation = copy(SHARED_DB_RELATION)
+        incomplete_relation['password'] = None
+        relation = FakeRelation(relation_data=incomplete_relation)
+        self.relation_get.side_effect = relation.get
+        self.config.return_value = SHARED_DB_CONFIG
+        shared_db = context.SharedDBContext()
+        result = shared_db()
+        self.assertEquals(result, {})
+
+    def test_shared_db_context_with_missing_config(self):
+        '''Test shared-db context missing relation data'''
+        incomplete_config = copy(SHARED_DB_CONFIG)
+        del incomplete_config['database-user']
+        relation = FakeRelation(relation_data=SHARED_DB_RELATION)
+        self.relation_get.side_effect = relation.get
+        self.config.return_value = incomplete_config
+        shared_db = context.SharedDBContext()
+        self.assertRaises(context.OSContextError, shared_db)
+
+    def test_identity_service_context_with_data(self):
+        '''Test shared-db context with all required data'''
+        relation = FakeRelation(relation_data=IDENTITY_SERVICE_RELATION)
+        self.relation_get.side_effect = relation.get
+        identity_service = context.IdentityServiceContext()
+        result = identity_service()
+        expected = {
+            'admin_password': 'foo',
+            'admin_tenant_name': 'admin',
+            'admin_user': 'adam',
+            'auth_host': 'keystone-host.local',
+            'auth_port': '35357',
+            'auth_protocol': 'http',
+            'service_host': 'keystonehost.local',
+            'service_port': '5000',
+            'service_protocol': 'http'
+        }
+        self.assertEquals(result, expected)
+
+    def test_identity_service_context_with_missing_relation(self):
+        '''Test shared-db context missing relation data'''
+        incomplete_relation = copy(IDENTITY_SERVICE_RELATION)
+        incomplete_relation['service_password'] = None
+        relation = FakeRelation(relation_data=incomplete_relation)
+        self.relation_get.side_effect = relation.get
+        identity_service = context.IdentityServiceContext()
+        result = identity_service()
+        self.assertEquals(result, {})
+
+    def test_amqp_context_with_data(self):
+        '''Test amqp context with all required data'''
+        relation = FakeRelation(relation_data=AMQP_RELATION)
+        self.relation_get.side_effect = relation.get
+        self.config.return_value = AMQP_CONFIG
+        amqp = context.AMQPContext()
+        result = amqp()
+
+        expected = {
+            'rabbitmq_host': 'rabbithost',
+            'rabbitmq_password': 'foobar',
+            'rabbitmq_user': 'adam',
+            'rabbitmq_virtual_host': 'foo'
+        }
+        self.assertEquals(result, expected)
+
+    def test_amqp_context_with_data_clustered(self):
+        '''Test amqp context with all required data with clustered rabbit'''
+        relation_data = copy(AMQP_RELATION)
+        relation_data['clustered'] = 'yes'
+        relation = FakeRelation(relation_data=relation_data)
+        self.relation_get.side_effect = relation.get
+        self.config.return_value = AMQP_CONFIG
+        amqp = context.AMQPContext()
+        result = amqp()
+
+        expected = {
+            'rabbitmq_host': relation_data['vip'],
+            'rabbitmq_password': 'foobar',
+            'rabbitmq_user': 'adam',
+            'rabbitmq_virtual_host': 'foo'
+        }
+        self.assertEquals(result, expected)
+
+    def test_amqp_context_with_missing_relation(self):
+        '''Test amqp context missing relation data'''
+        incomplete_relation = copy(AMQP_RELATION)
+        incomplete_relation['password'] = ''
+        relation = FakeRelation(relation_data=incomplete_relation)
+        self.relation_get.side_effect = relation.get
+        self.config.return_value = AMQP_CONFIG
+        amqp = context.AMQPContext()
+        result = amqp()
+        self.assertEquals({}, result)
+
+    def test_amqp_context_with_missing_config(self):
+        '''Test amqp context missing relation data'''
+        incomplete_config = copy(AMQP_CONFIG)
+        del incomplete_config['rabbit-user']
+        relation = FakeRelation(relation_data=AMQP_RELATION)
+        self.relation_get.side_effect = relation.get
+        self.config.return_value = incomplete_config
+        amqp = context.AMQPContext()
+        self.assertRaises(context.OSContextError, amqp)
+
+    def test_ceph_context_with_data(self):
+        '''Test ceph context with all relation data'''
+        relation = FakeRelation(relation_data=CEPH_RELATION)
+        self.relation_get.side_effect = relation.get
+        self.relation_ids.side_effect = relation.relation_ids
+        self.related_units.side_effect = relation.relation_units
+        ceph = context.CephContext()
+        result = ceph()
+        expected = {
+            'mon_hosts': 'ceph_node2 ceph_node1',
+            'auth': 'foo'
+        }
+        self.assertEquals(result, expected)
+
+    def test_ceph_context_with_missing_data(self):
+        '''Test ceph context with missing relation data'''
+        relation = copy(CEPH_RELATION)
+        for k, v in relation.iteritems():
+            for u in v.iterkeys():
+                del relation[k][u]['auth']
+        relation = FakeRelation(relation_data=relation)
+        self.relation_get.side_effect = relation.get
+        self.relation_ids.side_effect = relation.relation_ids
+        self.related_units.side_effect = relation.relation_units
+        ceph = context.CephContext()
+        result = ceph()
+        self.assertEquals(result, {})
+
+    @patch('charmhelpers.contrib.openstack.context.unit_get')
+    @patch('charmhelpers.contrib.openstack.context.local_unit')
+    def test_haproxy_context_with_data(self, local_unit, unit_get):
+        '''Test haproxy context with all relation data'''
+        cluster_relation = {
+            'cluster:0': {
+                'peer/1': {
+                    'private-address': 'cluster-peer1.localnet',
+                },
+                'peer/2': {
+                    'private-address': 'cluster-peer2.localnet',
+                },
+            },
+        }
+        local_unit.return_value = 'peer/0'
+        unit_get.return_value = 'cluster-peer0.localnet'
+        relation = FakeRelation(cluster_relation)
+        self.relation_ids.side_effect = relation.relation_ids
+        self.relation_get.side_effect = relation.get
+        self.related_units.side_effect = relation.relation_units
+        haproxy = context.HAProxyContext()
+        with patch_open() as (_open, _file):
+            result = haproxy()
+        ex = {
+            'units': {
+                'peer-0': 'cluster-peer0.localnet',
+                'peer-1': 'cluster-peer1.localnet',
+                'peer-2': 'cluster-peer2.localnet'
+            }
+        }
+        # the context gets generated.
+        self.assertEquals(ex, result)
+        # and /etc/default/haproxy is updated.
+        self.assertEquals(_file.write.call_args_list,
+                          [call('ENABLED=1\n')])
+
+    def test_haproxy_context_with_missing_data(self):
+        '''Test haproxy context with missing relation data'''
+        self.relation_ids.return_value = []
+        haproxy = context.HAProxyContext()
+        self.assertEquals({}, haproxy())
+
+    @patch('charmhelpers.contrib.openstack.context.unit_get')
+    @patch('charmhelpers.contrib.openstack.context.local_unit')
+    def test_haproxy_context_with_no_peers(self, local_unit, unit_get):
+        '''Test haproxy context with single unit'''
+        # peer relations always show at least one peer relation, even
+        # if unit is alone. should be an incomplete context.
+        cluster_relation = {
+            'cluster:0': {
+                'peer/0': {
+                    'private-address': 'lonely.clusterpeer.howsad',
+                },
+            },
+        }
+        local_unit.return_value = 'peer/0'
+        unit_get.return_value = 'lonely.clusterpeer.howsad'
+        relation = FakeRelation(cluster_relation)
+        self.relation_ids.side_effect = relation.relation_ids
+        self.relation_get.side_effect = relation.get
+        self.related_units.side_effect = relation.relation_units
+        haproxy = context.HAProxyContext()
+        self.assertEquals({}, haproxy())
+
+    def test_https_context_with_no_https(self):
+        '''Test apache2 https when no https data available'''
+        apache = context.ApacheSSLContext()
+        self.https.return_value = False
+        self.assertEquals({}, apache())
+
+    def _test_https_context(self, apache, is_clustered, peer_units):
+        self.https.return_value = True
+
+        if is_clustered or peer_units:
+            self.determine_api_port.return_value = 8756
+            self.determine_haproxy_port.return_value = 8766
+        else:
+            self.determine_api_port.return_value = 8766
+
+        self.unit_get.return_value = 'cinderhost1'
+        self.is_clustered.return_value = is_clustered
+        self.peer_units.return_value = peer_units
+        apache = context.ApacheSSLContext()
+        apache.configure_cert = MagicMock
+        apache.enable_modules = MagicMock
+        apache.external_ports = '8776'
+        apache.service_namespace = 'cinder'
+
+        ex = {
+            'private_address': 'cinderhost1',
+            'namespace': 'cinder',
+            'endpoints': [(8776, 8766)],
+        }
+        self.assertEquals(ex, apache())
+        self.assertTrue(apache.configure_cert.called)
+        self.assertTrue(apache.enable_modules.called)
+
+    def test_https_context_no_peers_no_cluster(self):
+        '''Test apache2 https on a single, unclustered unit'''
+        apache = context.ApacheSSLContext()
+        self._test_https_context(apache, is_clustered=False, peer_units=None)
+
+    def test_https_context_wth_peers_no_cluster(self):
+        '''Test apache2 https on a unclustered unit with peers'''
+        apache = context.ApacheSSLContext()
+        self._test_https_context(apache, is_clustered=False, peer_units=[1, 2])
+
+    def test_https_context_loads_correct_apache_mods(self):
+        '''Test apache2 context also loads required apache modules'''
+        apache = context.ApacheSSLContext()
+        apache.enable_modules()
+        ex_cmd = ['a2enmod', 'ssl', 'proxy', 'proxy_http']
+        self.check_call.assert_called_with(ex_cmd)
+
+    @patch('__builtin__.open')
+    @patch('os.mkdir')
+    @patch('os.path.isdir')
+    def test_https_configure_cert(self, isdir, mkdir, _open):
+        '''Test apache2 properly installs certs and keys to disk'''
+        isdir.return_value = False
+        self.get_cert.return_value = ('SSL_CERT', 'SSL_KEY')
+        self.get_ca_cert.return_value = 'CA_CERT'
+        apache = context.ApacheSSLContext()
+        apache.service_namespace = 'cinder'
+        apache.configure_cert()
+        # appropriate directories are created.
+        dirs = [call('/etc/apache2/ssl'), call('/etc/apache2/ssl/cinder')]
+        self.assertEquals(dirs, mkdir.call_args_list)
+        # appropriate files are opened for writing.
+        _ca = '/usr/local/share/ca-certificates/keystone_juju_ca_cert.crt'
+        files = [call('/etc/apache2/ssl/cinder/cert', 'w'),
+                 call('/etc/apache2/ssl/cinder/key', 'w'),
+                 call(_ca, 'w')]
+        for f in files:
+            self.assertIn(f, _open.call_args_list)
+        # appropriate bits are b64decoded.
+        decode = [call('SSL_CERT'), call('SSL_KEY'), call('CA_CERT')]
+        self.assertEquals(decode, self.b64decode.call_args_list)

=== added file 'tests/contrib/openstack/test_os_templating.py'
--- tests/contrib/openstack/test_os_templating.py	1970-01-01 00:00:00 +0000
+++ tests/contrib/openstack/test_os_templating.py	2013-07-11 20:23:23 +0000
@@ -0,0 +1,232 @@
+
+import os
+
+import unittest
+from mock import patch, call, MagicMock
+
+import charmhelpers.contrib.openstack.templating as templating
+
+
+class FakeContextGenerator(object):
+    interfaces = None
+
+    def set(self, interfaces, context):
+        self.interfaces = interfaces
+        self.context = context
+
+    def __call__(self):
+        return self.context
+
+
+class FakeLoader(object):
+    def set(self, template):
+        self.template = template
+
+    def get(self, name):
+        return self.template
+
+
+class MockFSLoader(object):
+    def __init__(self, dirs):
+        self.searchpath = [dirs]
+
+
+class MockChoiceLoader(object):
+    def __init__(self, loaders):
+        self.loaders = loaders
+
+
+def MockTemplate():
+    templ = MagicMock()
+    templ.render = MagicMock()
+    return templ
+
+
+class TemplatingTests(unittest.TestCase):
+    def setUp(self):
+        path = os.path.dirname(__file__)
+        self.loader = FakeLoader()
+        self.context = FakeContextGenerator()
+
+        self.addCleanup(patch.object(templating, 'apt_install').start().stop())
+        self.addCleanup(patch.object(templating, 'log').start().stop())
+
+        templating.FileSystemLoader = MockFSLoader
+        templating.ChoiceLoader = MockChoiceLoader
+        templating.Environment = MagicMock
+
+        self.renderer = templating.OSConfigRenderer(templates_dir=path,
+                                                    openstack_release='folsom')
+
+    @patch.object(templating, 'apt_install')
+    def test_initializing_a_render_ensures_jinja2_present(self, apt):
+        '''Creatinga new renderer object installs jinja2 if needed'''
+        # temp. undo the patching from setUp
+        templating.FileSystemLoader = None
+        templating.ChoiceLoader = None
+        templating.Environment = None
+        templating.OSConfigRenderer(templates_dir='/tmp',
+                                    openstack_release='foo')
+        templating.FileSystemLoader = MockFSLoader
+        templating.ChoiceLoader = MockChoiceLoader
+        templating.Environment = MagicMock
+        apt.assert_called_with('python-jinja2')
+
+    def test_create_renderer_invalid_templates_dir(self):
+        '''Ensure OSConfigRenderer checks templates_dir'''
+        self.assertRaises(templating.OSConfigException,
+                          templating.OSConfigRenderer,
+                          templates_dir='/tmp/foooo0',
+                          openstack_release='grizzly')
+
+    def test_render_unregistered_config(self):
+        '''Ensure cannot render an unregistered config file'''
+        self.assertRaises(templating.OSConfigException,
+                          self.renderer.render,
+                          config_file='/tmp/foo')
+
+    def test_write_unregistered_config(self):
+        '''Ensure cannot write an unregistered config file'''
+        self.assertRaises(templating.OSConfigException,
+                          self.renderer.write,
+                          config_file='/tmp/foo')
+
+    def test_render_complete_context(self):
+        '''It renders a template when provided a complete context'''
+        self.loader.set('{{ foo }}')
+        self.context.set(interfaces=['fooservice'], context={'foo': 'bar'})
+        self.renderer.register('/tmp/foo', [self.context])
+        with patch.object(self.renderer, '_get_template') as _get_t:
+            fake_tmpl = MockTemplate()
+            _get_t.return_value = fake_tmpl
+            self.renderer.render('/tmp/foo')
+            fake_tmpl.render.assert_called_with(self.context())
+        self.assertIn('fooservice', self.renderer.complete_contexts())
+
+    def test_render_incomplete_context_with_template(self):
+        '''It renders a template when provided an incomplete context'''
+        self.context.set(interfaces=['fooservice'], context={})
+        self.renderer.register('/tmp/foo', [self.context])
+        with patch.object(self.renderer, '_get_template') as _get_t:
+            fake_tmpl = MockTemplate()
+            _get_t.return_value = fake_tmpl
+            self.renderer.render('/tmp/foo')
+            fake_tmpl.render.assert_called_with({})
+            self.assertNotIn('fooservice', self.renderer.complete_contexts())
+
+    @patch('__builtin__.open')
+    @patch.object(templating, 'get_loader')
+    def test_write_out_config(self, loader, _open):
+        '''It writes a templated config when provided a complete context'''
+        self.context.set(interfaces=['fooservice'], context={'foo': 'bar'})
+        self.renderer.register('/tmp/foo', [self.context])
+        with patch.object(self.renderer, '_get_template') as _get_t:
+            fake_tmpl = MockTemplate()
+            _get_t.return_value = fake_tmpl
+            self.renderer.write('/tmp/foo')
+            _open.assert_called_with('/tmp/foo', 'wb')
+
+    def test_write_all(self):
+        '''It writes out all configuration files at once'''
+        self.context.set(interfaces=['fooservice'], context={'foo': 'bar'})
+        self.renderer.register('/tmp/foo', [self.context])
+        self.renderer.register('/tmp/bar', [self.context])
+        ex_calls = [
+            call('/tmp/bar'),
+            call('/tmp/foo'),
+        ]
+        with patch.object(self.renderer, 'write') as _write:
+            self.renderer.write_all()
+            self.assertEquals(ex_calls, _write.call_args_list)
+            pass
+
+    @patch.object(templating, 'get_loader')
+    def test_reset_template_loader_for_new_os_release(self, loader):
+        self.loader.set('')
+        self.context.set(interfaces=['fooservice'], context={})
+        loader.return_value = MockFSLoader('/tmp/foo')
+        self.renderer.register('/tmp/foo', [self.context])
+        self.renderer.render('/tmp/foo')
+        loader.assert_called_with(os.path.dirname(__file__), 'folsom')
+        self.renderer.set_release(openstack_release='grizzly')
+        self.renderer.render('/tmp/foo')
+        loader.assert_called_with(os.path.dirname(__file__), 'grizzly')
+
+    @patch.object(templating, 'get_loader')
+    def test_incomplete_context_not_reported_complete(self, loader):
+        '''It does not recognize an incomplete context as a complete context'''
+        self.context.set(interfaces=['fooservice'], context={})
+        self.renderer.register('/tmp/foo', [self.context])
+        self.assertNotIn('fooservice', self.renderer.complete_contexts())
+
+    @patch.object(templating, 'get_loader')
+    def test_complete_context_reported_complete(self, loader):
+        '''It recognizes a complete context as a complete context'''
+        self.context.set(interfaces=['fooservice'], context={'foo': 'bar'})
+        self.renderer.register('/tmp/foo', [self.context])
+        self.assertIn('fooservice', self.renderer.complete_contexts())
+
+    @patch('os.path.isdir')
+    def test_get_loader_no_templates_dir(self, isdir):
+        '''Ensure getting loader fails with no template dir'''
+        isdir.return_value = False
+        self.assertRaises(templating.OSConfigException,
+                          templating.get_loader,
+                          templates_dir='/tmp/foo', os_release='foo')
+
+    @patch('os.path.isdir')
+    def test_get_loader_all_search_paths(self, isdir):
+        '''Ensure loader reverse searches of all release template dirs'''
+        isdir.return_value = True
+        choice_loader = templating.get_loader('/tmp/foo',
+                                              os_release='icehouse')
+        dirs = [l.searchpath for l in choice_loader.loaders]
+
+        common_tmplts = os.path.join(os.path.dirname(templating.__file__),
+                                     'templates')
+        expected = [['/tmp/foo/icehouse'],
+                    ['/tmp/foo/havana'],
+                    ['/tmp/foo/grizzly'],
+                    ['/tmp/foo/folsom'],
+                    ['/tmp/foo/essex'],
+                    ['/tmp/foo/diablo'],
+                    ['/tmp/foo'],
+                    [common_tmplts]]
+        self.assertEquals(dirs, expected)
+
+    @patch('os.path.isdir')
+    def test_get_loader_some_search_paths(self, isdir):
+        '''Ensure loader reverse searches of some release template dirs'''
+        isdir.return_value = True
+        choice_loader = templating.get_loader('/tmp/foo', os_release='grizzly')
+        dirs = [l.searchpath for l in choice_loader.loaders]
+
+        common_tmplts = os.path.join(os.path.dirname(templating.__file__),
+                                     'templates')
+
+        expected = [['/tmp/foo/grizzly'],
+                    ['/tmp/foo/folsom'],
+                    ['/tmp/foo/essex'],
+                    ['/tmp/foo/diablo'],
+                    ['/tmp/foo'],
+                    [common_tmplts]]
+        self.assertEquals(dirs, expected)
+
+    def test_register_template_with_list_of_contexts(self):
+        '''Ensure registering a template with a list of context generators'''
+        def _c1():
+            pass
+
+        def _c2():
+            pass
+        tmpl = templating.OSConfigTemplate(config_file='/tmp/foo',
+                                           contexts=[_c1, _c2])
+        self.assertEquals(tmpl.contexts, [_c1, _c2])
+
+    def test_register_template_with_single_context(self):
+        '''Ensure registering a template with a single non-list context'''
+        def _c1():
+            pass
+        tmpl = templating.OSConfigTemplate(config_file='/tmp/foo',
+                                           contexts=_c1)
+        self.assertEquals(tmpl.contexts, [_c1])