Merge lp:~sidnei/charms/precise/apache2/trunk into lp:charms/apache2

[Sidnei da Silva]

Greatly improved test coverage. Support for 'all_services' set from haproxy relation. Improved documentation.

[Marco Ceppi (marcoceppi)]

This looks good to me. Since you're using charmhelpers2 now, you might want to consider using Hooks.hook decorator from core.hookenv which will allow you to simplify your methods by removing the giant case statement at the bottom, eg:

```
from charmhelper.core.hookenv import Hooks

hooks = Hooks()

@hooks.hook('config-changed', 'reverseproxy-relation-broken', ...)
def config_changed():
     relationship_data = {}
     config_data = config_get()
     ...
```

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2013-01-24 08:48:41 +0000
+++ .bzrignore	2013-10-10 22:50:52 +0000
@@ -1,4 +1,10 @@
 revision
 basenode/
+_trial_temp
+.coverage
+coverage.xml
+exec.d/
 *.crt
 *.key
+lib/*
+build/charm-helpers

=== added file 'Makefile'
--- Makefile	1970-01-01 00:00:00 +0000
+++ Makefile	2013-10-10 22:50:52 +0000
@@ -0,0 +1,39 @@
+PWD := $(shell pwd)
+SOURCEDEPS_DIR ?= $(shell dirname $(PWD))/.sourcecode
+HOOKS_DIR := $(PWD)/hooks
+TEST_PREFIX := PYTHONPATH=$(HOOKS_DIR)
+TEST_DIR := $(PWD)/hooks/tests
+CHARM_DIR := $(PWD)
+PYTHON := /usr/bin/env python
+
+
+build: test lint proof
+
+revision:
+	@test -f revision || echo 0 > revision
+
+proof: revision
+	@echo Proofing charm...
+	@(charm proof $(PWD) || [ $$? -eq 100 ]) && echo OK
+	@test `cat revision` = 0 && rm revision
+
+test:
+	@echo Starting tests...
+	@CHARM_DIR=$(CHARM_DIR) $(TEST_PREFIX) nosetests $(TEST_DIR)
+
+lint:
+	@echo Checking for Python syntax...
+	@flake8 $(HOOKS_DIR) --ignore=E123 --exclude=$(HOOKS_DIR)/charmhelpers && echo OK
+
+sourcedeps: $(PWD)/config-manager.txt
+	@echo Updating source dependencies...
+	@$(PYTHON) cm.py -c $(PWD)/config-manager.txt \
+		-p $(SOURCEDEPS_DIR) \
+		-t $(PWD)
+	@$(PYTHON) build/charm-helpers/tools/charm_helpers_sync/charm_helpers_sync.py \
+		-c charm-helpers.yaml \
+		-b build/charm-helpers \
+		-d hooks/charmhelpers
+	@echo Do not forget to commit the updated files if any.
+
+.PHONY: revision proof test lint sourcedeps charm-payload

=== modified file 'README.md'
--- README.md	2013-02-01 23:11:54 +0000
+++ README.md	2013-10-10 22:50:52 +0000
@@ -1,42 +1,88 @@
-Juju charm apache
-=================
-
-The Apache Software Foundation's goal is to build a secure, efficient
-and extensible HTTP server as standards-compliant open source
-software. The result has long been the number one web server on the
-Internet.  It features support for HTTPS, virtual hosting, CGI, SSI,
-IPv6, easy scripting and database integration, request/response
-filtering, many flexible authentication schemes, and more.
-
-How to deploy the charm
------------------------
-    juju deploy apache2
-    juju set apache2 "vhost_http_template=$(base64 < vhost.tmpl)"
+# Juju charm for Apache
+
+The Apache Software Foundation's goal is to build a secure,
+efficient and extensible HTTP server as standards-compliant open
+source software. The result has long been the number one web server
+on the Internet.  It features support for HTTPS, virtual hosting,
+CGI, SSI, IPv6, easy scripting and database integration,
+request/response filtering, many flexible authentication schemes,
+and more.
+
+## Development
+
+
+The following steps are needed for testing and development of the
+charm, but **not** for deployment:
+
+    sudo apt-get install python-software-properties
+    sudo add-apt-repository ppa:chrisjohnston/flake8
+    sudo apt-get update
+    sudo apt-get install flake8 python-nose python-coverage python-testtools
+
+To fetch additional source dependencies and run the tests:
+
+    make build
+
+... will run the unit tests, run flake8 over the source to warn
+about formatting issues and output a code coverage summary of the
+'hooks.py' module.
+
+## How to deploy the charm
+
+Assuming you have a copy of the charm into a `charms/$distrocodename/apache2`
+directory relative to your current directory.
+
+... then to perform a deployment execute the following steps:
+
+    juju deploy --repository=charms local:apache2
+    juju set apache2 "vhost_http_template=$(base64 < http_vhost.tmpl)"
+
+
     # and / or
-    juju set apache2 "vhost_https_template=$(base64 < vhost.tmpl)"
+    juju set apache2 "vhost_https_template=$(base64 < https_vhost.tmpl)"
+
+If you want a simple `reverseproxy` relation to your services (only
+really useful if you have a single unit on the other side of the
+relation):
+
     juju add-relation apache2:reverseproxy haproxy:website
-
-Vhost templates
----------------
-The charm expects a jinja2 template to be passed in. The variables in
-the template should relate to the services that apache will be proxying
--- obviously no variables need to be specified if no proxying is needed.
-
-The charm will create the service variable, with the unit_name, when
-the reverseproxy relationship is joined and present this to the template
-at which point the vhost will be generated from the template again.  
-All config settings are also available to the template.
-
-For example to access squid then the {{ squid }} variable should be used.
-This will be populated with the hostname:port of the squid service. The
-individual hostname and port can also be accessed via squid_hostname and
-squid_port.
-
-Note: The service name should be used, not the charm name.  If deploying
-      a charm with a different service name, use that instaed.
-
-The joining charm may also set an all_services variable which contains
-a list of services it provides in yaml format (list of associative arrays):
+    # and / or
+    juju add-relation apache2:reverseproxy squid-reverseproxy:cached-website
+
+Alternatively, you can use the `balancer` relation so that requests
+are load balanced across multiple units of your services. For more information see the section on `Using the balancer relation`:
+
+    juju add-relation apache2:balancer haproxy:website
+    # and / or
+    juju add-relation apache2:balancer squid-reverseproxy:cached-website
+
+## VirtualHost templates
+
+The charm expects a jinja2 template to be passed in. The variables
+in the template should relate to the services that apache will be
+proxying -- obviously no variables need to be specified if no
+proxying is needed.
+
+### Using the reverseproxy relation
+
+The charm will create the service variable, with the `unit_name`,
+when the `reverseproxy` relationship is joined and present this to
+the template at which point the vhost will be generated from the
+template again.  All config settings are also available to the
+template.
+
+For example to access squid then the `{{ squid }}` variable should
+be used.  This will be populated with the hostname:port of the squid
+service. The individual hostname and port can also be accessed via
+`squid_hostname` and `squid_port`.
+
+Note: The service name should be used, not the charm name.  If
+      deploying a charm with a different service name, use that
+      instead.
+
+The joining charm may set an `all_services` variable which
+contains a list of services it provides in yaml format (list of
+associative arrays):
 
     # ... in haproxy charm, website-relation-joined
     relation-set all_services="
@@ -45,24 +91,24 @@
       - {service_name: my-webapp, service_port: 9090}
     "
 
-then variables for each service would be available to the jinja2 template
-in <juju_service_name>_<sub_service_name>.  In our example above 
-haproxy contains stanzas named gunicorn, solr and my-webapp.  These are
-accessed as {{ haproxy_gunicorn }}, {{ haproxy_solr }} and
-{{ haproxy_mywebapp }} respectively.  If any unsupported characters are in
-your juju service name or the service names exposed through "all_services",
-they will be stripped.
+then variables for each service would be available to the jinja2
+template in `<juju_service_name>_<sub_service_name>`.  In our example
+above haproxy contains stanzas named gunicorn, solr and my-webapp.
+These are accessed as `{{ haproxy_gunicorn }}`, `{{ haproxy_solr }}` and
+`{{ haproxy_mywebapp }}` respectively.  If any unsupported characters
+are in your juju service name or the service names exposed through
+"all_services", they will be stripped.
 
 For example a vhost that will pass all traffic on to an haproxy instance:
 
     <VirtualHost *:80>
-    	ServerName radiotiptop.org.uk
-    
-    	CustomLog /var/log/apache2/radiotiptop-access.log combined
-    	ErrorLog /var/log/apache2/radiotiptop-error.log
-    
+        ServerName radiotiptop.org.uk
+
+        CustomLog /var/log/apache2/radiotiptop-access.log combined
+        ErrorLog /var/log/apache2/radiotiptop-error.log
+
         DocumentRoot /srv/radiotiptop/www/root
-    
+
         ProxyRequests off
         <Proxy *>
             Order Allow,Deny
@@ -72,48 +118,111 @@
             ErrorDocument 502 /offline.html
             ErrorDocument 503 /offline.html
         </Proxy>
-    
+
         ProxyPreserveHost off
         ProxyPassReverse / http://{{ haproxy_gunicorn }}/
-    
+
         RewriteEngine on
-    
+
         RewriteRule ^/$ /index.html [L]
         RewriteRule ^/(.*)$ http://{{ haproxy_gunicorn }}/$1 [P,L]
     </VirtualHost>
 
-Certs, keys and chains
-----------------------
-ssl_keylocation, ssl_certlocation and ssl_chainlocation are file names in the 
-charm /data directory.  If found, they will be copied as follows:
+### Using the `balancer` relation
+
+Using the balancer relation will set up named balancers using
+Apache's mod_balancer. Each balancer will be named after the
+`sitenames` or `all_services` setting exported from the other side
+of the relation. Requests sent through those balancers will have a
+`X-Balancer-Name` header set, which can be used by the related
+service to appropriatedly route requests internally.
+
+The joining charm may set an `all_services` variable which
+contains a list of services it provides in yaml format (list of
+associative arrays):
+
+    # ... in haproxy charm, website-relation-joined
+    relation-set all_services="
+      - {service_name: gunicorn, service_port: 80}
+      - {service_name: solr, service_port: 8080}
+      - {service_name: my-webapp, service_port: 9090}
+    "
+
+Each separate service name will cause a new `balancer` definition to be created on the Apache side, like:
+
+  <Proxy balancer://gunicorn>
+    ProxySet lbmethod=byrequests
+    RequestHeader set X-Balancer-Name "gunicorn"
+  </Proxy>
+
+For example a vhost that will pass specific requests to the `gunicorn` service that's defined in haproxy:
+
+    <VirtualHost *:80>
+        ServerName radiotiptop.org.uk
+
+        CustomLog /var/log/apache2/radiotiptop-access.log combined
+        ErrorLog /var/log/apache2/radiotiptop-error.log
+
+        DocumentRoot /srv/radiotiptop/www/root
+
+        ProxyRequests off
+        <Proxy *>
+            Order Allow,Deny
+            Allow from All
+            ErrorDocument 403 /offline.html
+            ErrorDocument 500 /offline.html
+            ErrorDocument 502 /offline.html
+            ErrorDocument 503 /offline.html
+        </Proxy>
+
+        ProxyPreserveHost on
+
+        RewriteEngine on
+
+        RewriteRule ^/$ /index.html [L]
+        RewriteRule ^/(.*)$ balancer://gunicorn/$1 [P,L]
+    </VirtualHost>
+
+
+## Certs, keys and chains
+
+`ssl_keylocation`, `ssl_certlocation` and `ssl_chainlocation` are
+file names in the charm `/data` directory.  If found, they will be
+copied as follows:
 
   - /etc/ssl/private/<ssl_keylocation>
   - /etc/ssl/certs/<ssl_certlocation>
   - /etc/ssl/certs/<ssl_chainlocation>
 
-ssl_key and ssl_cert can also be specified which are are assumed to be
-base64 encoded.  If specified, they will be written to appropriate directories
-given the values in ssl_keylocation and ssl_certlocation as listed above.
-
-ssl_cert may also be set to SELFSIGNED, which will generate a certificate.
-This, of course, is mostly useful for testing and staging purposes.  The
-generated certifcate/key will be placed according to ssl_certlocation and
-ssl_keylocation as listed above.
-
-{enable,disable}_modules
-------------------------
+`ssl_key` and `ssl_cert` can also be specified which are are assumed
+to be base64 encoded.  If specified, they will be written to
+appropriate directories given the values in ssl_keylocation and
+ssl_certlocation as listed above.
+
+`ssl_cert` may also be set to SELFSIGNED, which will generate a
+certificate.  This, of course, is mostly useful for testing and
+staging purposes.  The generated certifcate/key will be placed
+according to `ssl_certlocation` and `ssl_keylocation` as listed
+above.
+
+## `{enable,disable}_modules`
+
 Space separated list of modules to be enabled or disabled. If a module to
 be enabled cannot be found then the charm will attempt to install it.
 
-TODO:
------
+## TODO:
 
   * Document the use of balancer, nrpe, logging and website-cache
-  * Method to deliver site content. This maybe by converting the charm to a
-    subordinate and making it the master charms problem
-  * Implement secure method for delivering key.  Juju will likely need to provide
-    this.
-  * Tuning. No tuning options are present. Convert apache2.conf to a template
-    and expose config options
-  * Testing. I have only tested the relationship setup with 1 haproxy instance.
-    Needs testing against multiple instances 
+
+  * Method to deliver site content. This maybe by converting the
+    charm to a subordinate and making it the master charms problem
+
+  * Implement secure method for delivering key.  Juju will likely
+    need to provide this.
+
+  * Tuning. No tuning options are present. Convert apache2.conf to a
+    template and expose config options
+
+  * The all_services variable can be passed as part of the http interface and is
+    optional. However its kind of secret and it would be more obvious if a
+    seperate interface was used like http-allservices.

=== added directory 'build'
=== added file 'charm-helpers.yaml'
--- charm-helpers.yaml	1970-01-01 00:00:00 +0000
+++ charm-helpers.yaml	2013-10-10 22:50:52 +0000
@@ -0,0 +1,4 @@
+include:
+    - core
+    - fetch
+    - contrib.charmsupport
\ No newline at end of file

=== added file 'cm.py'
--- cm.py	1970-01-01 00:00:00 +0000
+++ cm.py	2013-10-10 22:50:52 +0000
@@ -0,0 +1,193 @@
+# Copyright 2010-2013 Canonical Ltd. All rights reserved.
+import os
+import re
+import sys
+import errno
+import hashlib
+import subprocess
+import optparse
+
+from os import curdir
+from bzrlib.branch import Branch
+from bzrlib.plugin import load_plugins
+load_plugins()
+from bzrlib.plugins.launchpad import account as lp_account
+
+if 'GlobalConfig' in dir(lp_account):
+    from bzrlib.config import LocationConfig as LocationConfiguration
+    _ = LocationConfiguration
+else:
+    from bzrlib.config import LocationStack as LocationConfiguration
+    _ = LocationConfiguration
+
+
+def get_branch_config(config_file):
+    """
+    Retrieves the sourcedeps configuration for an source dir.
+    Returns a dict of (branch, revspec) tuples, keyed by branch name.
+    """
+    branches = {}
+    with open(config_file, 'r') as stream:
+        for line in stream:
+            line = line.split('#')[0].strip()
+            bzr_match = re.match(r'(\S+)\s+'
+                                 'lp:([^;]+)'
+                                 '(?:;revno=(\d+))?', line)
+            if bzr_match:
+                name, branch, revno = bzr_match.group(1, 2, 3)
+                if revno is None:
+                    revspec = -1
+                else:
+                    revspec = revno
+                branches[name] = (branch, revspec)
+                continue
+            dir_match = re.match(r'(\S+)\s+'
+                                 '\(directory\)', line)
+            if dir_match:
+                name = dir_match.group(1)
+                branches[name] = None
+    return branches
+
+
+def main(config_file, parent_dir, target_dir, verbose):
+    """Do the deed."""
+
+    try:
+        os.makedirs(parent_dir)
+    except OSError, e:
+        if e.errno != errno.EEXIST:
+            raise
+
+    branches = sorted(get_branch_config(config_file).items())
+    for branch_name, spec in branches:
+        if spec is None:
+            # It's a directory, just create it and move on.
+            destination_path = os.path.join(target_dir, branch_name)
+            if not os.path.isdir(destination_path):
+                os.makedirs(destination_path)
+            continue
+
+        (quoted_branch_spec, revspec) = spec
+        revno = int(revspec)
+
+        # qualify mirror branch name with hash of remote repo path to deal
+        # with changes to the remote branch URL over time
+        branch_spec_digest = hashlib.sha1(quoted_branch_spec).hexdigest()
+        branch_directory = branch_spec_digest
+
+        source_path = os.path.join(parent_dir, branch_directory)
+        destination_path = os.path.join(target_dir, branch_name)
+
+        # Remove leftover symlinks/stray files.
+        try:
+            os.remove(destination_path)
+        except OSError, e:
+            if e.errno != errno.EISDIR and e.errno != errno.ENOENT:
+                raise
+
+        lp_url = "lp:" + quoted_branch_spec
+
+        # Create the local mirror branch if it doesn't already exist
+        if verbose:
+            sys.stderr.write('%30s: ' % (branch_name,))
+            sys.stderr.flush()
+
+        fresh = False
+        if not os.path.exists(source_path):
+            subprocess.check_call(['bzr', 'branch', '-q', '--no-tree',
+                                   '--', lp_url, source_path])
+            fresh = True
+
+        if not fresh:
+            source_branch = Branch.open(source_path)
+            if revno == -1:
+                orig_branch = Branch.open(lp_url)
+                fresh = source_branch.revno() == orig_branch.revno()
+            else:
+                fresh = source_branch.revno() == revno
+
+        # Freshen the source branch if required.
+        if not fresh:
+            subprocess.check_call(['bzr', 'pull', '-q', '--overwrite', '-r',
+                                   str(revno), '-d', source_path,
+                                   '--', lp_url])
+
+        if os.path.exists(destination_path):
+            # Overwrite the destination with the appropriate revision.
+            subprocess.check_call(['bzr', 'clean-tree', '--force', '-q',
+                                   '--ignored', '-d', destination_path])
+            subprocess.check_call(['bzr', 'pull', '-q', '--overwrite',
+                                   '-r', str(revno),
+                                   '-d', destination_path, '--', source_path])
+        else:
+            # Create a new branch.
+            subprocess.check_call(['bzr', 'branch', '-q', '--hardlink',
+                                   '-r', str(revno),
+                                   '--', source_path, destination_path])
+
+        # Check the state of the destination branch.
+        destination_branch = Branch.open(destination_path)
+        destination_revno = destination_branch.revno()
+
+        if verbose:
+            sys.stderr.write('checked out %4s of %s\n' %
+                             ("r" + str(destination_revno), lp_url))
+            sys.stderr.flush()
+
+        if revno != -1 and destination_revno != revno:
+            raise RuntimeError("Expected revno %d but got revno %d" %
+                               (revno, destination_revno))
+
+if __name__ == '__main__':
+    parser = optparse.OptionParser(
+        usage="%prog [options]",
+        description=(
+            "Add a lightweight checkout in <target> for each "
+            "corresponding file in <parent>."),
+        add_help_option=False)
+    parser.add_option(
+        '-p', '--parent', dest='parent',
+        default=None,
+        help=("The directory of the parent tree."),
+        metavar="DIR")
+    parser.add_option(
+        '-t', '--target', dest='target', default=curdir,
+        help=("The directory of the target tree."),
+        metavar="DIR")
+    parser.add_option(
+        '-c', '--config', dest='config', default=None,
+        help=("The config file to be used for config-manager."),
+        metavar="DIR")
+    parser.add_option(
+        '-q', '--quiet', dest='verbose', action='store_false',
+        help="Be less verbose.")
+    parser.add_option(
+        '-v', '--verbose', dest='verbose', action='store_true',
+        help="Be more verbose.")
+    parser.add_option(
+        '-h', '--help', action='help',
+        help="Show this help message and exit.")
+    parser.set_defaults(verbose=True)
+
+    options, args = parser.parse_args()
+
+    if options.parent is None:
+        options.parent = os.environ.get(
+            "SOURCEDEPS_DIR",
+            os.path.join(curdir, ".sourcecode"))
+
+    if options.target is None:
+        parser.error(
+            "Target directory not specified.")
+
+    if options.config is None:
+        config = [arg for arg in args
+                  if arg != "update"]
+        if not config or len(config) > 1:
+            parser.error("Config not specified")
+        options.config = config[0]
+
+    sys.exit(main(config_file=options.config,
+                  parent_dir=options.parent,
+                  target_dir=options.target,
+                  verbose=options.verbose))

=== added file 'config-manager.txt'
--- config-manager.txt	1970-01-01 00:00:00 +0000
+++ config-manager.txt	2013-10-10 22:50:52 +0000
@@ -0,0 +1,6 @@
+# After making changes to this file, to ensure that your sourcedeps are
+# up-to-date do:
+#
+#   make sourcedeps
+
+./build/charm-helpers                   lp:charm-helpers;revno=70

=== modified file 'config.yaml'
--- config.yaml	2013-03-18 07:31:45 +0000
+++ config.yaml	2013-10-10 22:50:52 +0000
@@ -121,6 +121,12 @@
     description: >
       Use daily extension like YYYMMDD instead of simply adding a number
     default: True
+  package_status:
+    default: "install"
+    type: "string"
+    description: >
+      The status of service-affecting packages will be set to this value in the dpkg database.
+      Useful valid values are "install" and "hold".
   use_rsyslog:
     type: boolean
     description: >-
@@ -157,3 +163,7 @@
     type: string
     description: Security setting. Set to one of  On  Off  extended
     default: "On"
+  extra_packages:
+    type: string
+    description: List of extra packages to be installed (e.g. commercial GeoIP package)
+    default: ""

=== modified file 'data/balancer.template'
--- data/balancer.template	2012-10-16 12:26:37 +0000
+++ data/balancer.template	2013-10-10 22:50:52 +0000
@@ -3,4 +3,5 @@
     BalancerMember http://{{ host }} timeout={{ lb_balancer_timeout }}
 {% endfor %}
     ProxySet lbmethod=byrequests
+    RequestHeader set X-Balancer-Name "{{ balancer_name }}"
 </Proxy>

=== modified file 'data/logrotate.conf.template'
--- data/logrotate.conf.template	2013-01-29 17:31:09 +0000
+++ data/logrotate.conf.template	2013-10-10 22:50:52 +0000
@@ -10,6 +10,13 @@
         compress
         delaycompress
         notifempty
+{%- if use_rsyslog %}
+        create 640 syslog adm
+        sharedscripts
+        postrotate
+                reload rsyslog >/dev/null 2>&1 || true
+        endscript
+{%- else %}
         create 640 root adm
         sharedscripts
         postrotate
@@ -20,4 +27,5 @@
                         run-parts /etc/logrotate.d/httpd-prerotate; \
                 fi; \
         endscript
+{%- endif %}
 }

=== removed file 'data/nrpe_service.template'
--- data/nrpe_service.template	2012-10-16 11:02:00 +0000
+++ data/nrpe_service.template	1970-01-01 00:00:00 +0000
@@ -1,11 +0,0 @@
-#---------------------------------------------------
-# This file is Juju managed
-#---------------------------------------------------
-define service {
-    use                             active-service
-    host_name                       {{ nagios_hostname }}
-    service_description             {{ nagios_hostname }} Check Apache Vhost
-    check_command                   check_nrpe!check_vhost
-    servicegroups                   {{ nagios_servicegroup }}
-
-}

=== added file 'data/syslog-apache.conf'
--- data/syslog-apache.conf	1970-01-01 00:00:00 +0000
+++ data/syslog-apache.conf	2013-10-10 22:50:52 +0000
@@ -0,0 +1,13 @@
+#
+#    "             "
+#  mmm   m   m   mmm   m   m
+#    #   #   #     #   #   #
+#    #   #   #     #   #   #
+#    #   "mm"#     #   "mm"#
+#    #             #
+#  ""            ""
+# This file is managed by Juju. Do not make local changes.
+#
+
+ErrorLog syslog
+CustomLog "|/usr/bin/logger -p local0.info -t apache2" vhost_combined

=== added file 'data/syslog-rsyslog.conf'
--- data/syslog-rsyslog.conf	1970-01-01 00:00:00 +0000
+++ data/syslog-rsyslog.conf	2013-10-10 22:50:52 +0000
@@ -0,0 +1,26 @@
+#
+#    "             "
+#  mmm   m   m   mmm   m   m
+#    #   #   #     #   #   #
+#    #   #   #     #   #   #
+#    #   "mm"#     #   "mm"#
+#    #             #
+#  ""            ""
+# This file is managed by Juju. Do not make local changes.
+#
+
+# Create a template to print just the raw message to avoid duplicate timestamps
+# and other info not needed. Also, as documented on the rsyslog website
+# http://www.rsyslog.com/log-normalization-and-the-leading-space/
+# msg has a leading whitespace so strip that.
+$template ApacheLogFormat,"%msg:2:10000%\n"
+
+# We want all access entries, even if rsyslog deems them as repeated msgs.
+$RepeatedMsgReduction off
+
+# Error logs
+if $syslogfacility-text == 'local0' and $syslogseverity == 3 and $syslogtag == "apache2:" then /var/log/apache2/error.log;ApacheLogFormat
+& ~
+# Access logs
+if $syslogfacility-text == 'local0' and $syslogseverity == 6 and $syslogtag == "apache2:" then /var/log/apache2/access.log;ApacheLogFormat
+& ~

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

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

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

=== added file 'hooks/charmhelpers/core/host.py'
--- hooks/charmhelpers/core/host.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/core/host.py	2013-10-10 22:50:52 +0000
@@ -0,0 +1,239 @@
+"""Tools for working with the host system"""
+# Copyright 2012 Canonical Ltd.
+#
+# Authors:
+#  Nick Moffitt <[e-mail]>
+#  Matthew Wedgwood <[e-mail]>
+
+import os
+import pwd
+import grp
+import random
+import string
+import subprocess
+import hashlib
+
+from collections import OrderedDict
+
+from hookenv import log
+
+
+def service_start(service_name):
+    service('start', service_name)
+
+
+def service_stop(service_name):
+    service('stop', service_name)
+
+
+def service_restart(service_name):
+    service('restart', service_name)
+
+
+def service_reload(service_name, restart_on_failure=False):
+    if not service('reload', service_name) and restart_on_failure:
+        service('restart', service_name)
+
+
+def service(action, service_name):
+    cmd = ['service', service_name, action]
+    return subprocess.call(cmd) == 0
+
+
+def service_running(service):
+    try:
+        output = subprocess.check_output(['service', service, 'status'])
+    except subprocess.CalledProcessError:
+        return False
+    else:
+        if ("start/running" in output or "is running" in output):
+            return True
+        else:
+            return False
+
+
+def adduser(username, password=None, shell='/bin/bash', system_user=False):
+    """Add a user"""
+    try:
+        user_info = pwd.getpwnam(username)
+        log('user {0} already exists!'.format(username))
+    except KeyError:
+        log('creating user {0}'.format(username))
+        cmd = ['useradd']
+        if system_user or password is None:
+            cmd.append('--system')
+        else:
+            cmd.extend([
+                '--create-home',
+                '--shell', shell,
+                '--password', password,
+            ])
+        cmd.append(username)
+        subprocess.check_call(cmd)
+        user_info = pwd.getpwnam(username)
+    return user_info
+
+
+def add_user_to_group(username, group):
+    """Add a user to a group"""
+    cmd = [
+        'gpasswd', '-a',
+        username,
+        group
+    ]
+    log("Adding user {} to group {}".format(username, group))
+    subprocess.check_call(cmd)
+
+
+def rsync(from_path, to_path, flags='-r', options=None):
+    """Replicate the contents of a path"""
+    options = options or ['--delete', '--executability']
+    cmd = ['/usr/bin/rsync', flags]
+    cmd.extend(options)
+    cmd.append(from_path)
+    cmd.append(to_path)
+    log(" ".join(cmd))
+    return subprocess.check_output(cmd).strip()
+
+
+def symlink(source, destination):
+    """Create a symbolic link"""
+    log("Symlinking {} as {}".format(source, destination))
+    cmd = [
+        'ln',
+        '-sf',
+        source,
+        destination,
+    ]
+    subprocess.check_call(cmd)
+
+
+def mkdir(path, owner='root', group='root', perms=0555, force=False):
+    """Create a directory"""
+    log("Making dir {} {}:{} {:o}".format(path, owner, group,
+                                          perms))
+    uid = pwd.getpwnam(owner).pw_uid
+    gid = grp.getgrnam(group).gr_gid
+    realpath = os.path.abspath(path)
+    if os.path.exists(realpath):
+        if force and not os.path.isdir(realpath):
+            log("Removing non-directory file {} prior to mkdir()".format(path))
+            os.unlink(realpath)
+    else:
+        os.makedirs(realpath, perms)
+    os.chown(realpath, uid, gid)
+
+
+def write_file(path, content, owner='root', group='root', perms=0444):
+    """Create or overwrite a file with the contents of a string"""
+    log("Writing file {} {}:{} {:o}".format(path, owner, group, perms))
+    uid = pwd.getpwnam(owner).pw_uid
+    gid = grp.getgrnam(group).gr_gid
+    with open(path, 'w') as target:
+        os.fchown(target.fileno(), uid, gid)
+        os.fchmod(target.fileno(), perms)
+        target.write(content)
+
+
+def mount(device, mountpoint, options=None, persist=False):
+    '''Mount a filesystem'''
+    cmd_args = ['mount']
+    if options is not None:
+        cmd_args.extend(['-o', options])
+    cmd_args.extend([device, mountpoint])
+    try:
+        subprocess.check_output(cmd_args)
+    except subprocess.CalledProcessError, e:
+        log('Error mounting {} at {}\n{}'.format(device, mountpoint, e.output))
+        return False
+    if persist:
+        # TODO: update fstab
+        pass
+    return True
+
+
+def umount(mountpoint, persist=False):
+    '''Unmount a filesystem'''
+    cmd_args = ['umount', mountpoint]
+    try:
+        subprocess.check_output(cmd_args)
+    except subprocess.CalledProcessError, e:
+        log('Error unmounting {}\n{}'.format(mountpoint, e.output))
+        return False
+    if persist:
+        # TODO: update fstab
+        pass
+    return True
+
+
+def mounts():
+    '''List of all mounted volumes as [[mountpoint,device],[...]]'''
+    with open('/proc/mounts') as f:
+        # [['/mount/point','/dev/path'],[...]]
+        system_mounts = [m[1::-1] for m in [l.strip().split()
+                                            for l in f.readlines()]]
+    return system_mounts
+
+
+def file_hash(path):
+    ''' Generate a md5 hash of the contents of 'path' or None if not found '''
+    if os.path.exists(path):
+        h = hashlib.md5()
+        with open(path, 'r') as source:
+            h.update(source.read())  # IGNORE:E1101 - it does have update
+        return h.hexdigest()
+    else:
+        return None
+
+
+def restart_on_change(restart_map):
+    ''' Restart services based on configuration files changing
+
+    This function is used a decorator, for example
+
+        @restart_on_change({
+            '/etc/ceph/ceph.conf': [ 'cinder-api', 'cinder-volume' ]
+            })
+        def ceph_client_changed():
+            ...
+
+    In this example, the cinder-api and cinder-volume services
+    would be restarted if /etc/ceph/ceph.conf is changed by the
+    ceph_client_changed function.
+    '''
+    def wrap(f):
+        def wrapped_f(*args):
+            checksums = {}
+            for path in restart_map:
+                checksums[path] = file_hash(path)
+            f(*args)
+            restarts = []
+            for path in restart_map:
+                if checksums[path] != file_hash(path):
+                    restarts += restart_map[path]
+            for service_name in list(OrderedDict.fromkeys(restarts)):
+                service('restart', service_name)
+        return wrapped_f
+    return wrap
+
+
+def lsb_release():
+    '''Return /etc/lsb-release in a dict'''
+    d = {}
+    with open('/etc/lsb-release', 'r') as lsb:
+        for l in lsb:
+            k, v = l.split('=')
+            d[k.strip()] = v.strip()
+    return d
+
+
+def pwgen(length=None):
+    '''Generate a random pasword.'''
+    if length is None:
+        length = random.choice(range(35, 45))
+    alphanumeric_chars = [
+        l for l in (string.letters + string.digits)
+        if l not in 'l0QD1vAEIOUaeiou']
+    random_chars = [
+        random.choice(alphanumeric_chars) for _ in range(length)]
+    return(''.join(random_chars))

=== added directory 'hooks/charmhelpers/fetch'
=== added file 'hooks/charmhelpers/fetch/__init__.py'
--- hooks/charmhelpers/fetch/__init__.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/fetch/__init__.py	2013-10-10 22:50:52 +0000
@@ -0,0 +1,209 @@
+import importlib
+from yaml import safe_load
+from charmhelpers.core.host import (
+    lsb_release
+)
+from urlparse import (
+    urlparse,
+    urlunparse,
+)
+import subprocess
+from charmhelpers.core.hookenv import (
+    config,
+    log,
+)
+import apt_pkg
+
+CLOUD_ARCHIVE = """# Ubuntu Cloud Archive
+deb http://ubuntu-cloud.archive.canonical.com/ubuntu {} main
+"""
+PROPOSED_POCKET = """# Proposed
+deb http://archive.ubuntu.com/ubuntu {}-proposed main universe multiverse restricted
+"""
+
+
+def filter_installed_packages(packages):
+    """Returns a list of packages that require installation"""
+    apt_pkg.init()
+    cache = apt_pkg.Cache()
+    _pkgs = []
+    for package in packages:
+        try:
+            p = cache[package]
+            p.current_ver or _pkgs.append(package)
+        except KeyError:
+            log('Package {} has no installation candidate.'.format(package),
+                level='WARNING')
+            _pkgs.append(package)
+    return _pkgs
+
+
+def apt_install(packages, options=None, fatal=False):
+    """Install one or more packages"""
+    options = options or []
+    cmd = ['apt-get', '-y']
+    cmd.extend(options)
+    cmd.append('install')
+    if isinstance(packages, basestring):
+        cmd.append(packages)
+    else:
+        cmd.extend(packages)
+    log("Installing {} with options: {}".format(packages,
+                                                options))
+    if fatal:
+        subprocess.check_call(cmd)
+    else:
+        subprocess.call(cmd)
+
+
+def apt_update(fatal=False):
+    """Update local apt cache"""
+    cmd = ['apt-get', 'update']
+    if fatal:
+        subprocess.check_call(cmd)
+    else:
+        subprocess.call(cmd)
+
+
+def apt_purge(packages, fatal=False):
+    """Purge one or more packages"""
+    cmd = ['apt-get', '-y', 'purge']
+    if isinstance(packages, basestring):
+        cmd.append(packages)
+    else:
+        cmd.extend(packages)
+    log("Purging {}".format(packages))
+    if fatal:
+        subprocess.check_call(cmd)
+    else:
+        subprocess.call(cmd)
+
+
+def add_source(source, key=None):
+    if ((source.startswith('ppa:') or
+         source.startswith('http:'))):
+        subprocess.check_call(['add-apt-repository', '--yes', source])
+    elif source.startswith('cloud:'):
+        apt_install(filter_installed_packages(['ubuntu-cloud-keyring']),
+                    fatal=True)
+        pocket = source.split(':')[-1]
+        with open('/etc/apt/sources.list.d/cloud-archive.list', 'w') as apt:
+            apt.write(CLOUD_ARCHIVE.format(pocket))
+    elif source == 'proposed':
+        release = lsb_release()['DISTRIB_CODENAME']
+        with open('/etc/apt/sources.list.d/proposed.list', 'w') as apt:
+            apt.write(PROPOSED_POCKET.format(release))
+    if key:
+        subprocess.check_call(['apt-key', 'import', key])
+
+
+class SourceConfigError(Exception):
+    pass
+
+
+def configure_sources(update=False,
+                      sources_var='install_sources',
+                      keys_var='install_keys'):
+    """
+    Configure multiple sources from charm configuration
+
+    Example config:
+        install_sources:
+          - "ppa:foo"
+          - "http://example.com/repo precise main"
+        install_keys:
+          - null
+          - "a1b2c3d4"
+
+    Note that 'null' (a.k.a. None) should not be quoted.
+    """
+    sources = safe_load(config(sources_var))
+    keys = safe_load(config(keys_var))
+    if isinstance(sources, basestring) and isinstance(keys, basestring):
+        add_source(sources, keys)
+    else:
+        if not len(sources) == len(keys):
+            msg = 'Install sources and keys lists are different lengths'
+            raise SourceConfigError(msg)
+        for src_num in range(len(sources)):
+            add_source(sources[src_num], keys[src_num])
+    if update:
+        apt_update(fatal=True)
+
+# The order of this list is very important. Handlers should be listed in from
+# least- to most-specific URL matching.
+FETCH_HANDLERS = (
+    'charmhelpers.fetch.archiveurl.ArchiveUrlFetchHandler',
+    'charmhelpers.fetch.bzrurl.BzrUrlFetchHandler',
+)
+
+
+class UnhandledSource(Exception):
+    pass
+
+
+def install_remote(source):
+    """
+    Install a file tree from a remote source
+
+    The specified source should be a url of the form:
+        scheme://[host]/path[#[option=value][&...]]
+
+    Schemes supported are based on this modules submodules
+    Options supported are submodule-specific"""
+    # We ONLY check for True here because can_handle may return a string
+    # explaining why it can't handle a given source.
+    handlers = [h for h in plugins() if h.can_handle(source) is True]
+    installed_to = None
+    for handler in handlers:
+        try:
+            installed_to = handler.install(source)
+        except UnhandledSource:
+            pass
+    if not installed_to:
+        raise UnhandledSource("No handler found for source {}".format(source))
+    return installed_to
+
+
+def install_from_config(config_var_name):
+    charm_config = config()
+    source = charm_config[config_var_name]
+    return install_remote(source)
+
+
+class BaseFetchHandler(object):
+    """Base class for FetchHandler implementations in fetch plugins"""
+    def can_handle(self, source):
+        """Returns True if the source can be handled. Otherwise returns
+        a string explaining why it cannot"""
+        return "Wrong source type"
+
+    def install(self, source):
+        """Try to download and unpack the source. Return the path to the
+        unpacked files or raise UnhandledSource."""
+        raise UnhandledSource("Wrong source type {}".format(source))
+
+    def parse_url(self, url):
+        return urlparse(url)
+
+    def base_url(self, url):
+        """Return url without querystring or fragment"""
+        parts = list(self.parse_url(url))
+        parts[4:] = ['' for i in parts[4:]]
+        return urlunparse(parts)
+
+
+def plugins(fetch_handlers=None):
+    if not fetch_handlers:
+        fetch_handlers = FETCH_HANDLERS
+    plugin_list = []
+    for handler_name in fetch_handlers:
+        package, classname = handler_name.rsplit('.', 1)
+        try:
+            handler_class = getattr(importlib.import_module(package), classname)
+            plugin_list.append(handler_class())
+        except (ImportError, AttributeError):
+            # Skip missing plugins so that they can be ommitted from
+            # installation if desired
+            log("FetchHandler {} not found, skipping plugin".format(handler_name))
+    return plugin_list

=== added file 'hooks/charmhelpers/fetch/archiveurl.py'
--- hooks/charmhelpers/fetch/archiveurl.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/fetch/archiveurl.py	2013-10-10 22:50:52 +0000
@@ -0,0 +1,48 @@
+import os
+import urllib2
+from charmhelpers.fetch import (
+    BaseFetchHandler,
+    UnhandledSource
+)
+from charmhelpers.payload.archive import (
+    get_archive_handler,
+    extract,
+)
+from charmhelpers.core.host import mkdir
+
+
+class ArchiveUrlFetchHandler(BaseFetchHandler):
+    """Handler for archives via generic URLs"""
+    def can_handle(self, source):
+        url_parts = self.parse_url(source)
+        if url_parts.scheme not in ('http', 'https', 'ftp', 'file'):
+            return "Wrong source type"
+        if get_archive_handler(self.base_url(source)):
+            return True
+        return False
+
+    def download(self, source, dest):
+        # propogate all exceptions
+        # URLError, OSError, etc
+        response = urllib2.urlopen(source)
+        try:
+            with open(dest, 'w') as dest_file:
+                dest_file.write(response.read())
+        except Exception as e:
+            if os.path.isfile(dest):
+                os.unlink(dest)
+            raise e
+
+    def install(self, source):
+        url_parts = self.parse_url(source)
+        dest_dir = os.path.join(os.environ.get('CHARM_DIR'), 'fetched')
+        if not os.path.exists(dest_dir):
+            mkdir(dest_dir, perms=0755)
+        dld_file = os.path.join(dest_dir, os.path.basename(url_parts.path))
+        try:
+            self.download(source, dld_file)
+        except urllib2.URLError as e:
+            raise UnhandledSource(e.reason)
+        except OSError as e:
+            raise UnhandledSource(e.strerror)
+        return extract(dld_file)

=== added file 'hooks/charmhelpers/fetch/bzrurl.py'
--- hooks/charmhelpers/fetch/bzrurl.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/fetch/bzrurl.py	2013-10-10 22:50:52 +0000
@@ -0,0 +1,44 @@
+import os
+from bzrlib.branch import Branch
+from charmhelpers.fetch import (
+    BaseFetchHandler,
+    UnhandledSource
+)
+from charmhelpers.core.host import mkdir
+
+
+class BzrUrlFetchHandler(BaseFetchHandler):
+    """Handler for bazaar branches via generic and lp URLs"""
+    def can_handle(self, source):
+        url_parts = self.parse_url(source)
+        if url_parts.scheme not in ('bzr+ssh', 'lp'):
+            return False
+        else:
+            return True
+
+    def branch(self, source, dest):
+        url_parts = self.parse_url(source)
+        # If we use lp:branchname scheme we need to load plugins
+        if not self.can_handle(source):
+            raise UnhandledSource("Cannot handle {}".format(source))
+        if url_parts.scheme == "lp":
+            from bzrlib.plugin import load_plugins
+            load_plugins()
+        try:
+            remote_branch = Branch.open(source)
+            remote_branch.bzrdir.sprout(dest).open_branch()
+        except Exception as e:
+            raise e
+
+    def install(self, source):
+        url_parts = self.parse_url(source)
+        branch_name = url_parts.path.strip("/").split("/")[-1]
+        dest_dir = os.path.join(os.environ.get('CHARM_DIR'), "fetched", branch_name)
+        if not os.path.exists(dest_dir):
+            mkdir(dest_dir, perms=0755)
+        try:
+            self.branch(source, dest_dir)
+        except OSError as e:
+            raise UnhandledSource(e.strerror)
+        return dest_dir
+

=== modified file 'hooks/hooks.py'
--- hooks/hooks.py	2013-04-30 08:30:51 +0000
+++ hooks/hooks.py	2013-10-10 22:50:52 +0000
@@ -1,6 +1,5 @@
 #!/usr/bin/env python
 
-import json
 import os
 import re
 import socket
@@ -12,7 +11,15 @@
 import pwd
 import shutil
 import os.path
-import glob
+
+from charmhelpers.core.hookenv import (
+    open_port,
+    close_port,
+    log,
+    config as config_get,
+    relations_of_type,
+)
+from charmhelpers.contrib.charmsupport import nrpe
 
 ###############################################################################
 # Global variables
@@ -21,7 +28,7 @@
 default_apache2_config = "%s/apache2.conf" % default_apache2_config_dir
 default_apache2_service_config_dir = "/var/run/apache2"
 test_apache2_vhost = "/etc/apache2/sites-available/testvhost"
-hook_name = os.path.basename(sys.argv[0])
+service_affecting_packages = ['apache2']
 
 juju_warning_header = """#
 #    "             "
@@ -39,137 +46,24 @@
 # Supporting functions
 ###############################################################################
 
-
-#------------------------------------------------------------------------------
-# juju_log:  Convenience wrapper around juju-log
-#------------------------------------------------------------------------------
-def juju_log(msg="MARK"):
-    subprocess.call(['juju-log', str(msg)])
-
-
-#------------------------------------------------------------------------------
-# open_port:  Convenience function to open a port in juju to
-#             expose a service
-#------------------------------------------------------------------------------
-def open_port(port=None, protocol="TCP"):
-    if port is None:
-        return(None)
-    return(subprocess.call(['open-port', "%d/%s"
-                            % (int(port), protocol)]))
-
-
-#------------------------------------------------------------------------------
-# close_port:  Convenience function to close a port in juju to
-#              unexpose a service
-#------------------------------------------------------------------------------
-def close_port(port=None, protocol="TCP"):
-    if port is None:
-        return(None)
-    return(subprocess.call(['close-port', "%d/%s"
-                            % (int(port), protocol)]))
-
-
-#------------------------------------------------------------------------------
-# config_get:  Returns a dictionary containing all of the config information
-#              Optional parameter: scope
-#              scope: limits the scope of the returned configuration to the
-#                     desired config item.
-#------------------------------------------------------------------------------
-def config_get(scope=None):
-    try:
-        config_cmd_line = ['config-get']
-        if scope is not None:
-            config_cmd_line.append(scope)
-        config_cmd_line.append('--format=json')
-        config_data = json.loads(subprocess.check_output(config_cmd_line))
-        if not config_data["servername"]:
-            config_data["servername"] = run(["unit-get", "public-address"]).rstrip()
-
-    except Exception, e:
-        juju_log(e)
-        config_data = None
-    finally:
-        return(config_data)
-
-
-#------------------------------------------------------------------------------
-# relation_get:  Returns a dictionary containing the relation information
-#                Optional parameters: scope, relation_id
-#                scope:        limits the scope of the returned data to the
-#                              desired item.
-#                unit_name:    limits the data ( and optionally the scope )
-#                              to the specified unit
-#                relation_id:  specify relation id for out of context usage.
-#------------------------------------------------------------------------------
-def relation_get(scope=None, unit_name=None, relation_id=None):
-    try:
-        relation_cmd_line = ['relation-get', '--format=json']
-        if relation_id is not None:
-            relation_cmd_line.extend(('-r', relation_id))
-        if scope is not None:
-            relation_cmd_line.append(scope)
-        if unit_name is not None:
-            relation_cmd_line.append('-')
-            relation_cmd_line.append(unit_name)
-        juju_log('Calling: %s' % relation_cmd_line)
-        relation_data = json.loads(subprocess.check_output(relation_cmd_line))
-    except Exception:
-        relation_data = None
-    finally:
-        return(relation_data)
-
-
-def relation_ids_get(relation_name=None):
-    try:
-        relation_cmd_line = ['relation-ids', '--format=json']
-        if relation_name is not None:
-            relation_cmd_line.append(relation_name)
-        juju_log('Calling: %s' % relation_cmd_line)
-        relation_ids = json.loads(subprocess.check_output(relation_cmd_line))
-    except Exception:
-        relation_ids = None
-    finally:
-        return(relation_ids)
-
-
-def relation_list_get(relation_id=None):
-    try:
-        relation_cmd_line = ['relation-list', '--format=json']
-        if relation_id is not None:
-            relation_cmd_line.extend(('-r', relation_id))
-        juju_log('Calling: %s' % relation_cmd_line)
-        relations = json.loads(subprocess.check_output(relation_cmd_line))
-    except Exception:
-        relations = None
-    finally:
-        return(relations)
-
-
-def all_relation_data_get(relation_name=None):
-    relation_ids = relation_ids_get(relation_name)
-    if relation_ids is None:
-        return()
-    try:
-        all_relation_data = {}
-        for rid in relation_ids:
-            units = relation_list_get(relation_id=rid)
-            for unit in units:
-                all_relation_data[unit.replace('/', '-')] = relation_get(relation_id=rid, unit_name=unit)
-    except Exception:
-        all_relation_data = None
-    finally:
-        return(all_relation_data)
-
-
 #------------------------------------------------------------------------------
 # apt_get_install( package ):  Installs a package
 #------------------------------------------------------------------------------
 def apt_get_install(packages=None):
     if packages is None:
-        return(False)
+        return False
     cmd_line = ['apt-get', '-y', 'install', '-qq']
     cmd_line.append(packages)
-    return(subprocess.call(cmd_line))
+    return subprocess.call(cmd_line)
+
+
+def ensure_package_status(packages, status):
+    if status in ['install', 'hold']:
+        selections = ''.join(['{} {}\n'.format(package, status)
+                              for package in packages])
+        dpkg = subprocess.Popen(['dpkg', '--set-selections'],
+                                stdin=subprocess.PIPE)
+        dpkg.communicate(input=selections)
 
 
 #------------------------------------------------------------------------------
@@ -177,10 +71,10 @@
 #------------------------------------------------------------------------------
 def apt_get_purge(packages=None):
     if packages is None:
-        return(False)
+        return False
     cmd_line = ['apt-get', '-y', 'purge', '-qq']
     cmd_line.append(packages)
-    return(subprocess.call(cmd_line))
+    return subprocess.call(cmd_line)
 
 
 #------------------------------------------------------------------------------
@@ -189,21 +83,13 @@
 #------------------------------------------------------------------------------
 def service_apache2(action=None):
     if action is None:
-        return(None)
+        return
     elif action == "check":
-        retVal = subprocess.call(['/usr/sbin/apache2ctl', 'configtest'])
-        if retVal == 1:
-            return(False)
-        elif retVal == 0:
-            return(True)
-        else:
-            return(False)
+        args = ['/usr/sbin/apache2ctl', 'configtest']
     else:
-        retVal = subprocess.call(['service', 'apache2', action])
-        if retVal == 0:
-            return(True)
-        else:
-            return(False)
+        args = ['service', 'apache2', action]
+    ret_val = subprocess.call(args)
+    return ret_val == 0
 
 
 def run(command, *args, **kwargs):
@@ -211,54 +97,63 @@
         output = subprocess.check_output(command, *args, **kwargs)
         return output
     except Exception, e:
-        print str(e)
+        print e
         raise
 
 
 def enable_module(module=None):
     if module is None:
-        return(True)
+        return True
     if os.path.exists("/etc/apache2/mods-enabled/%s.load" % (module)):
-        juju_log("Module already loaded: %s" % module)
-        return(True)
+        log("Module already loaded: %s" % module)
+        return True
     if not os.path.exists("/etc/apache2/mods-available/%s.load" % (module)):
-        retVal = apt_get_install("libapache2-mod-%s" % (module))
-        if retVal != 0:
-            juju_log("Installing module %s failed" % module)
-            return(False)
-    retVal = subprocess.call(['/usr/sbin/a2enmod', module])
-    if retVal != 0:
-        return(False)
+        return_value = apt_get_install("libapache2-mod-%s" % (module))
+        if return_value != 0:
+            log("Installing module %s failed" % (module))
+            return False
+    return_value = subprocess.call(['/usr/sbin/a2enmod', module])
+    if return_value != 0:
+        return False
     if service_apache2("check"):
         service_apache2("reload")
-        return(True)
+        return True
 
 
 def disable_module(module=None):
     if module is None:
-        return(True)
+        return True
     if not os.path.exists("/etc/apache2/mods-enabled/%s.load" % (module)):
-        juju_log("Module already disabled: %s" % module)
-        return(True)
-    retVal = subprocess.call(['/usr/sbin/a2dismod', module])
-    if retVal != 0:
-        return(False)
+        log("Module already disabled: %s" % module)
+        return True
+    return_value = subprocess.call(['/usr/sbin/a2dismod', module])
+    if return_value != 0:
+        return False
     if service_apache2("check"):
         service_apache2("reload")
-        return(True)
+        return True
 
 
 ###############################################################################
 # Hook functions
 ###############################################################################
 def install_hook():
-    for f in glob.glob('exec.d/*/charm-pre-install'):
-        if os.path.isfile(f) and os.access(f, os.X_OK):
-            subprocess.check_call(['sh', '-c', f])
     if not os.path.exists(default_apache2_service_config_dir):
         os.mkdir(default_apache2_service_config_dir, 0600)
     apt_get_install("python-jinja2")
-    return (apt_get_install("apache2"))
+    install_status = apt_get_install("apache2")
+    if install_status == 0:
+        ensure_package_status(service_affecting_packages, config_get('package_status'))
+    ensure_extra_packages()
+    return install_status
+
+
+def ensure_extra_packages():
+    extra = str(config_get('extra_packages'))
+    if extra:
+        install_status = apt_get_install(extra)
+        if install_status == 0:
+            ensure_package_status(extra, config_get('package_status'))
 
 
 def dump_data(data2dump, log_prefix):
@@ -271,59 +166,95 @@
 
 
 def get_reverseproxy_data(relation='reverseproxy'):
-    relation_data = all_relation_data_get(relation_name=relation)
+    relation_data = relations_of_type(relation)
     reverseproxy_data = {}
     if relation_data is None or len(relation_data) == 0:
         return reverseproxy_data
-    for unit_name in relation_data.keys():
-        if 'port' not in relation_data[unit_name]:
+    for unit_data in relation_data:
+        unit_name = unit_data["__unit__"]
+        if 'port' not in unit_data:
             return reverseproxy_data
-
         # unit_name: <service-name>-<unit_number>
         # jinja2 templates require python-type variables, remove all characters
         # that do not comply
-        unit_type = re.sub(r'(.*)-[0-9]*', r'\1', unit_name)
+        unit_type = re.sub(r'(.*)/[0-9]*', r'\1', unit_name)
         unit_type = re.sub('[^a-zA-Z0-9_]*', '', unit_type)
-        juju_log('unit_type: %s' % unit_type)
+        log('unit_type: %s' % unit_type)
 
-        host = relation_data[unit_name]['private-address']
-        for config_setting in relation_data[unit_name].keys():
-            config_key = '%s_%s' % (unit_type, config_setting)
-            reverseproxy_data[config_key] = relation_data[unit_name][config_setting]
-            reverseproxy_data[unit_type] = '%s:%s' % (host, relation_data[unit_name]['port'])
-        if 'all_services' in relation_data[unit_name]:
-            service_data = yaml.load(relation_data[unit_name]['all_services'])
+        host = unit_data['private-address']
+        if unit_type in reverseproxy_data:
+            continue
+        for config_setting in unit_data.keys():
+            if config_setting in ("__unit__", "__relid__"):
+                continue
+            config_key = '%s_%s' % (unit_type,
+                                    config_setting.replace("-", "_"))
+            config_key = re.sub('[^a-zA-Z0-9_]*', '', config_key)
+            reverseproxy_data[config_key] = unit_data[
+                config_setting]
+            reverseproxy_data[unit_type] = '%s:%s' % (
+                host, unit_data['port'])
+        if 'all_services' in unit_data:
+            service_data = yaml.safe_load(unit_data['all_services'])
             for service_item in service_data:
                 service_name = service_item['service_name']
                 service_port = service_item['service_port']
                 service_key = '%s_%s' % (unit_type, service_name)
                 service_key = re.sub('[^a-zA-Z0-9_]*', '', service_key)
                 reverseproxy_data[service_key] = '%s:%s' % (host, service_port)
-    relation_data.update(reverseproxy_data)
-    return relation_data
+    return reverseproxy_data
 
 
 def update_balancers():
-    relation_data = all_relation_data_get(relation_name='balancer')
-    config_data = config_get()
+    relation_data = relations_of_type('balancer')
     if relation_data is None or len(relation_data) == 0:
-        juju_log('No relation data exiting')
+        log("No relation data, exiting.")
         return
+
     unit_dict = {}
-    for unit_name in relation_data.keys():
-        if 'port' not in relation_data[unit_name]:
-            return
-        unit_type = re.sub(r'(.*)-[0-9]*', r'\1', unit_name)
-        host = relation_data[unit_name]['private-address']
-        port = relation_data[unit_name]['port']
-        if unit_type in unit_dict:
-            current_units = unit_dict[unit_type]
-            current_units.append('%s:%s' % (host, port))
-            unit_dict[unit_type] = current_units
+    for unit_data in relation_data:
+        unit_name = unit_data["__unit__"]
+        if "port" not in unit_data:
+            log("No port in relation data for '%s', skipping." % unit_name)
+            continue
+        port = unit_data["port"]
+        if "private-address" not in unit_data:
+            log("No private-address in relation data for '%s', skipping." %
+                unit_name)
+            continue
+        host = unit_data['private-address']
+
+        if "all_services" in unit_data:
+            service_data = yaml.safe_load(unit_data[
+                "all_services"])
+            for service_item in service_data:
+                service_port = service_item["service_port"]
+                current_units = unit_dict.setdefault(
+                    service_item["service_name"], [])
+                current_units.append("%s:%s" % (host, service_port))
         else:
-            unit_dict[unit_type] = ['%s:%s' % (host, port)]
+            if "sitenames" in unit_data:
+                unit_types = unit_data["sitenames"].split()
+            else:
+                unit_types = (re.sub(r"(.*)/[0-9]*", r"\1", unit_name),)
+
+            for unit_type in unit_types:
+                current_units = unit_dict.setdefault(unit_type, [])
+                current_units.append("%s:%s" % (host, port))
+
+    if not unit_dict:
+        return
+
+    write_balancer_config(unit_dict)
+    return unit_dict
+
+
+def write_balancer_config(unit_dict):
+    config_data = config_get()
+
     from jinja2 import Environment, FileSystemLoader
-    template_env = Environment(loader=FileSystemLoader(os.path.join(os.environ['CHARM_DIR'], 'data')))
+    template_env = Environment(loader=FileSystemLoader(os.path.join(
+        os.environ['CHARM_DIR'], 'data')))
     for balancer_name in unit_dict.keys():
         balancer_host_file = '%s/%s.balancer' % (default_apache2_config_dir,
                                                  balancer_name)
@@ -334,63 +265,31 @@
         }
         template = template_env.get_template(
             'balancer.template').render(templ_vars)
-        juju_log("Writing file: %s with data: %s" % (balancer_host_file, templ_vars))
+        log("Writing file: %s with data: %s" % (balancer_host_file,
+                                                templ_vars))
         with open(balancer_host_file, 'w') as balancer_config:
             balancer_config.write(str(template))
 
 
 def update_nrpe_checks():
-    config_data = config_get()
-    if 'nagios_check_http_params' not in config_data or len(config_data['nagios_check_http_params']) == 0:
-        juju_log("No nrpe configuration, skipping")
-        return
-    try:
-        nagios_uid = pwd.getpwnam('nagios').pw_uid
-        nagios_gid = grp.getgrnam('nagios').gr_gid
-    except:
-        juju_log("Nagios user not setup, exiting")
-        return
-
-    unit_name = os.environ['JUJU_UNIT_NAME'].replace('/', '-')
-    nrpe_check_file = '/etc/nagios/nrpe.d/check_vhost.cfg'
-    nagios_hostname = "%s-%s" % (config_data['nagios_context'], unit_name)
-    nagios_logdir = '/var/log/nagios'
-    nagios_exportdir = '/var/lib/nagios/export'
-    nrpe_service_file = '/var/lib/nagios/export/service__%s_check_vhost.cfg' %\
-        (nagios_hostname)
-    if not os.path.exists(nagios_logdir):
-        os.mkdir(nagios_logdir)
-        os.chown(nagios_logdir, nagios_uid, nagios_gid)
-    if not os.path.exists(nagios_exportdir):
-        juju_log('Exiting as %s is not accessible' % nagios_exportdir)
-        return
-    for f in os.listdir(nagios_exportdir):
-        if re.search('.*check_vhost.cfg', f):
-            os.remove(os.path.join(nagios_exportdir, f))
-    from jinja2 import Environment, FileSystemLoader
-    template_env = Environment(loader=FileSystemLoader(os.path.join(os.environ['CHARM_DIR'], 'data')))
-    templ_vars = {
-        'nagios_hostname': nagios_hostname,
-        'nagios_servicegroup': config_data['nagios_context'],
-    }
-    template = \
-        template_env.get_template('nrpe_service.template').render(templ_vars)
-    with open(nrpe_service_file, 'w') as nrpe_service_config:
-        nrpe_service_config.write(str(template))
-    with open(nrpe_check_file, 'w') as nrpe_check_config:
-        nrpe_check_config.write("# check Apache vhosts\n")
-        nrpe_check_config.write(
-            "command[check_vhost]=/usr/lib/nagios/plugins/check_http %s\n" %
-            (config_data['nagios_check_http_params']))
-    if os.path.isfile('/etc/init.d/nagios-nrpe-server'):
-        subprocess.call(['service', 'nagios-nrpe-server', 'reload'])
+    nrpe_compat = nrpe.NRPE()
+    conf = nrpe_compat.config
+    check_http_params = conf.get('nagios_check_http_params')
+    if check_http_params:
+        nrpe_compat.add_check(
+            shortname='vhost',
+            description='Check Virtual Host',
+            check_cmd='check_http %s' % check_http_params
+        )
+    nrpe_compat.write()
 
 
 def create_mpm_workerfile():
     config_data = config_get()
     mpm_workerfile = '/etc/apache2/conf.d/000mpm-worker'
     from jinja2 import Environment, FileSystemLoader
-    template_env = Environment(loader=FileSystemLoader(os.path.join(os.environ['CHARM_DIR'], 'data')))
+    template_env = Environment(loader=FileSystemLoader(os.path.join(
+        os.environ['CHARM_DIR'], 'data')))
     templ_vars = {
         'mpm_type': config_data['mpm_type'],
         'mpm_startservers': config_data['mpm_startservers'],
@@ -412,7 +311,8 @@
     config_data = config_get()
     securityfile = '/etc/apache2/conf.d/security'
     from jinja2 import Environment, FileSystemLoader
-    template_env = Environment(loader=FileSystemLoader(os.path.join(os.environ['CHARM_DIR'], 'data')))
+    template_env = Environment(loader=FileSystemLoader(os.path.join(
+        os.environ['CHARM_DIR'], 'data')))
     templ_vars = {
         'juju_warning_header': juju_warning_header,
         'server_tokens': config_data['server_tokens'],
@@ -429,14 +329,16 @@
     config_data = config_get()
     logrotate_file = '/etc/logrotate.d/apache2'
     from jinja2 import Environment, FileSystemLoader
-    template_env = Environment(loader=FileSystemLoader(os.path.join(os.environ['CHARM_DIR'], 'data')))
+    template_env = Environment(loader=FileSystemLoader(os.path.join(
+        os.environ['CHARM_DIR'], 'data')))
     templ_vars = {
         'juju_warning_header': juju_warning_header,
         'logrotate_rotate': config_data['logrotate_rotate'],
         'logrotate_count': config_data['logrotate_count'],
         'logrotate_dateext': config_data['logrotate_dateext'],
     }
-    template = template_env.get_template('logrotate.conf.template').render(templ_vars)
+    template = template_env.get_template('logrotate.conf.template').render(
+        templ_vars)
     with open(logrotate_file, 'w') as logrotate_conf:
         logrotate_conf.write(str(template))
 
@@ -444,6 +346,10 @@
 def config_changed():
     relationship_data = {}
     config_data = config_get()
+
+    ensure_package_status(service_affecting_packages, config_data['package_status'])
+    ensure_extra_packages()
+
     relationship_data.update(get_reverseproxy_data(relation='reverseproxy'))
     relationship_data.update(get_reverseproxy_data(relation='website-cache'))
     update_balancers()
@@ -476,7 +382,7 @@
             from jinja2 import Template
             template = Template(
                 str(base64.b64decode(config_data[template_var])))
-            juju_log("Writing file: %s with data: %s" % (vhost_file, template_data))
+            log("Writing file: %s with data: %s" % (vhost_file, template_data))
             with open(vhost_file, 'w') as vhost:
                 vhost.write(str(template.render(template_data)))
             open_port(ports[proto])
@@ -510,7 +416,7 @@
         else:
             # Certificate provided as base64-encoded string.
             if config_data['ssl_cert']:
-                juju_log("Writing cert from config ssl_cert: %s" % cert_file)
+                log("Writing cert from config ssl_cert: %s" % cert_file)
                 with open(cert_file, 'w') as f:
                     f.write(str(base64.b64decode(config_data['ssl_cert'])))
             # Use certificate file shipped out with charm.
@@ -520,11 +426,11 @@
                 if os.path.exists(source):
                     shutil.copy(source, cert_file)
                 else:
-                    juju_log("Certificate not found, ignoring: %s" % source)
+                    log("Certificate not found, ignoring: %s" % source)
 
             # Private key provided as base64-encoded string.
             if config_data['ssl_key']:
-                juju_log("Writing key from config ssl_key: %s" % key_file)
+                log("Writing key from config ssl_key: %s" % key_file)
                 with open(key_file, 'w') as f:
                     f.write(str(base64.b64decode(config_data['ssl_key'])))
             # Use private key shipped out with charm.
@@ -534,12 +440,13 @@
                 if os.path.exists(source):
                     shutil.copy(source, key_file)
                 else:
-                    juju_log("Key file not found, ignoring: %s" % source)
+                    log("Key file not found, ignoring: %s" % source)
 
             if chain_file is not None:
                 # Chain certificates provided as base64-encoded string.
                 if config_data['ssl_chain']:
-                    juju_log("Writing chain certificates file from config ssl_chain: %s" % chain_file)
+                    log("Writing chain certificates file from"
+                        "config ssl_chain: %s" % chain_file)
                     with open(chain_file, 'w') as f:
                         f.write(str(base64.b64decode(config_data['ssl_chain'])))
                 # Use chain certificates shipped out with charm.
@@ -549,7 +456,8 @@
                     if os.path.exists(source):
                         shutil.copy(source, chain_file)
                     else:
-                        juju_log("Chain certificates not found, ignoring: %s" % source)
+                        log("Chain certificates not found, "
+                            "ignoring: %s" % source)
 
         # Tighten permissions on private key file.
         if os.path.exists(key_file):
@@ -557,6 +465,24 @@
             os.chown(key_file, pwd.getpwnam('root').pw_uid,
                      grp.getgrnam('ssl-cert').gr_gid)
 
+    apache_syslog_conf = "/etc/apache2/conf.d/syslog"
+    rsyslog_apache_conf = "/etc/rsyslog.d/45-apache2.conf"
+    if config_data['use_rsyslog']:
+        shutil.copy2("data/syslog-apache.conf", apache_syslog_conf)
+        shutil.copy2("data/syslog-rsyslog.conf", rsyslog_apache_conf)
+        # Fix permissions of access.log and error.log to allow syslog user to
+        # write to
+        os.chown("/var/log/apache2/access.log", pwd.getpwnam('syslog').pw_uid,
+                 pwd.getpwnam('syslog').pw_gid)
+        os.chown("/var/log/apache2/error.log", pwd.getpwnam('syslog').pw_uid,
+                 pwd.getpwnam('syslog').pw_gid)
+    else:
+        if os.path.exists(apache_syslog_conf):
+            os.unlink(apache_syslog_conf)
+        if os.path.exists(rsyslog_apache_conf):
+            os.unlink(rsyslog_apache_conf)
+    run(["/usr/sbin/service", "rsyslog", "restart"])
+
     # Disable the default website because we don't want people to see the
     # "It works!" page on production services and remove the
     # conf.d/other-vhosts-access-log conf.
@@ -606,36 +532,47 @@
 ###############################################################################
 # Main section
 ###############################################################################
-if hook_name == "install":
-    install_hook()
-elif hook_name == "config-changed" or hook_name == "upgrade-charm":
-    config_changed()
-elif hook_name == "start":
-    start_hook()
-elif hook_name == "stop":
-    stop_hook()
-elif hook_name == "reverseproxy-relation-broken":
-    config_changed()
-elif hook_name == "reverseproxy-relation-changed":
-    config_changed()
-elif hook_name == "reverseproxy-relation-joined":
-    config_changed()
-elif hook_name == "balancer-relation-broken":
-    config_changed()
-elif hook_name == "balancer-relation-changed":
-    config_changed()
-elif hook_name == "balancer-relation-joined":
-    config_changed()
-elif hook_name == "website-cache-relation-broken":
-    config_changed()
-elif hook_name == "website-cache-relation-changed":
-    config_changed()
-elif hook_name == "website-cache-relation-joined":
-    config_changed()
-elif hook_name == "website-relation-joined":
-    website_interface("joined")
-elif hook_name == "nrpe-external-master-relation-changed":
-    update_nrpe_checks()
-else:
-    print "Unknown hook"
-    sys.exit(1)
+def main(hook_name):
+    if hook_name == "install":
+        install_hook()
+    elif hook_name == "config-changed" or hook_name == "upgrade-charm":
+        config_changed()
+    elif hook_name == "start":
+        start_hook()
+    elif hook_name == "stop":
+        stop_hook()
+    elif hook_name == "reverseproxy-relation-broken":
+        config_changed()
+    elif hook_name == "reverseproxy-relation-changed":
+        config_changed()
+    elif hook_name == "reverseproxy-relation-joined":
+        config_changed()
+    elif hook_name == "balancer-relation-broken":
+        config_changed()
+    elif hook_name == "balancer-relation-changed":
+        config_changed()
+    elif hook_name == "balancer-relation-joined":
+        config_changed()
+    elif hook_name == "website-cache-relation-broken":
+        config_changed()
+    elif hook_name == "website-cache-relation-changed":
+        config_changed()
+    elif hook_name == "website-cache-relation-joined":
+        config_changed()
+    elif hook_name == "website-relation-joined":
+        website_interface("joined")
+    elif hook_name in ("nrpe-external-master-relation-changed",
+                       "local-monitors-relation-changed"):
+        update_nrpe_checks()
+    else:
+        print "Unknown hook"
+        sys.exit(1)
+
+if __name__ == "__main__":
+    hook_name = os.path.basename(sys.argv[0])
+    # Also support being invoked directly with hook as argument name.
+    if hook_name == "hooks.py":
+        if len(sys.argv) < 2:
+            sys.exit("Missing required hook name argument.")
+        hook_name = sys.argv[1]
+    main(hook_name)

=== modified symlink 'hooks/install' (properties changed: -x to +x)
=== target was u'hooks.py'
--- hooks/install	1970-01-01 00:00:00 +0000
+++ hooks/install	2013-10-10 22:50:52 +0000
@@ -0,0 +1,9 @@
+#!/bin/sh
+
+set -eu
+
+juju-log 'Invoking charm-pre-install hooks'
+[ -d exec.d ] && ( for f in exec.d/*/charm-pre-install; do [ -x $f ] && /bin/sh -c "$f"; done )
+
+juju-log 'Invoking python-based install hook'
+python hooks/hooks.py install

=== added symlink 'hooks/local-monitors-relation-changed'
=== target is u'hooks.py'
=== added directory 'hooks/tests'
=== added file 'hooks/tests/__init__.py'
=== added directory 'hooks/tests/fixtures'
=== added file 'hooks/tests/fixtures/bar.balancer'
--- hooks/tests/fixtures/bar.balancer	1970-01-01 00:00:00 +0000
+++ hooks/tests/fixtures/bar.balancer	2013-10-10 22:50:52 +0000
@@ -0,0 +1,7 @@
+<Proxy balancer://bar>
+BalancerMember http://10.11.12.14 timeout=123
+BalancerMember http://10.11.12.15 timeout=123
+
+    ProxySet lbmethod=byrequests
+    RequestHeader set X-Balancer-Name "bar"
+</Proxy>
\ No newline at end of file

=== added file 'hooks/tests/fixtures/foo.balancer'
--- hooks/tests/fixtures/foo.balancer	1970-01-01 00:00:00 +0000
+++ hooks/tests/fixtures/foo.balancer	2013-10-10 22:50:52 +0000
@@ -0,0 +1,6 @@
+<Proxy balancer://foo>
+BalancerMember http://10.11.12.13 timeout=123
+
+    ProxySet lbmethod=byrequests
+    RequestHeader set X-Balancer-Name "foo"
+</Proxy>
\ No newline at end of file

=== added file 'hooks/tests/fixtures/nrpe_check_config'
--- hooks/tests/fixtures/nrpe_check_config	1970-01-01 00:00:00 +0000
+++ hooks/tests/fixtures/nrpe_check_config	2013-10-10 22:50:52 +0000
@@ -0,0 +1,2 @@
+# check Apache vhosts
+command[check_vhost]=/usr/lib/nagios/plugins/check_http ['foo', 'bar']

=== added file 'hooks/tests/fixtures/nrpe_service_config'
--- hooks/tests/fixtures/nrpe_service_config	1970-01-01 00:00:00 +0000
+++ hooks/tests/fixtures/nrpe_service_config	2013-10-10 22:50:52 +0000
@@ -0,0 +1,11 @@
+#---------------------------------------------------
+# This file is Juju managed
+#---------------------------------------------------
+define service {
+    use                             active-service
+    host_name                       somecontext-some-unit
+    service_description             somecontext-some-unit Check Apache Vhost
+    check_command                   check_nrpe!check_vhost
+    servicegroups                   somecontext
+
+}
\ No newline at end of file

=== added file 'hooks/tests/test_balancer_hook.py'
--- hooks/tests/test_balancer_hook.py	1970-01-01 00:00:00 +0000
+++ hooks/tests/test_balancer_hook.py	2013-10-10 22:50:52 +0000
@@ -0,0 +1,652 @@
+from pprint import pformat
+import os
+import shutil
+from StringIO import StringIO
+import tempfile
+import yaml
+
+from testtools import TestCase
+from mock import patch, call, MagicMock
+
+import hooks
+
+
+FIXTURES = os.path.join(os.path.dirname(__file__), 'fixtures')
+
+
+original_open = open
+
+
+class BalancerRelationTest(TestCase):
+
+    def setUp(self):
+        super(BalancerRelationTest, self).setUp()
+
+        self.relations_of_type = self.patch_hook("relations_of_type")
+        self.config_get = self.patch_hook("config_get")
+        self.log = self.patch_hook("log")
+        self.write_balancer_config = self.patch_hook("write_balancer_config")
+
+    def patch_hook(self, hook_name):
+        mock_controller = patch.object(hooks, hook_name)
+        mock = mock_controller.start()
+        self.addCleanup(mock_controller.stop)
+        return mock
+
+    def test_relation_data_returns_no_relations(self):
+        self.relations_of_type.return_value = []
+        self.assertIs(None, hooks.update_balancers())
+        self.log.assert_called_once_with("No relation data, exiting.")
+        self.write_balancer_config.assert_not_called()
+
+    def test_no_port_in_relation_data(self):
+        self.relations_of_type.return_value = [
+            {"private-address": "1.2.3.4",
+             "__unit__": "foo/1"},
+        ]
+        self.assertIs(None, hooks.update_balancers())
+        self.log.assert_called_once_with(
+            "No port in relation data for 'foo/1', skipping.")
+        self.write_balancer_config.assert_not_called()
+
+    def test_no_private_address_in_relation_data(self):
+        self.relations_of_type.return_value = [
+            {"port": 4242,
+             "__unit__": "foo/1"},
+        ]
+        self.assertIs(None, hooks.update_balancers())
+        self.log.assert_called_once_with(
+            "No private-address in relation data for 'foo/1', skipping.")
+        self.write_balancer_config.assert_not_called()
+
+    def test_sitenames_in_relation_data(self):
+        self.relations_of_type.return_value = [
+            {"private-address": "1.2.3.4",
+             "port": 4242,
+             "sitenames": "foo.internal bar.internal",
+             "__unit__": "foo/1"},
+            ]
+        expected = {
+            "foo.internal": ["1.2.3.4:4242"],
+            "bar.internal": ["1.2.3.4:4242"],
+        }
+        self.assertEqual(hooks.update_balancers(), expected)
+        self.write_balancer_config.assert_called_once_with(expected)
+
+    def test_all_services_in_relation_data(self):
+        self.relations_of_type.return_value = [
+            {"private-address": "1.2.3.4",
+             "port": 80,
+             "__unit__": "foo/1",
+             "all_services": yaml.dump(
+                 [
+                     {"service_name": "foo.internal",
+                      "service_port": 4242},
+                     {"service_name": "bar.internal",
+                      "service_port": 4243},
+                     ]
+                 ),
+             },
+        ]
+        expected = {
+            "foo.internal": ["1.2.3.4:4242"],
+            "bar.internal": ["1.2.3.4:4243"],
+        }
+        self.assertEqual(hooks.update_balancers(), expected)
+        self.write_balancer_config.assert_called_once_with(expected)
+
+    def test_unit_names_in_relation_data(self):
+        self.relations_of_type.return_value = [
+            {"private-address": "1.2.3.4",
+             "port": 4242,
+             "__unit__": "foo/1"},
+            {"private-address": "1.2.3.5",
+             "port": 4242,
+             "__unit__": "foo/2"},
+        ]
+        expected = {
+            "foo": ["1.2.3.4:4242", "1.2.3.5:4242"],
+        }
+        self.assertEqual(hooks.update_balancers(), expected)
+        self.write_balancer_config.assert_called_once_with(expected)
+
+
+class HelpersTest(TestCase):
+    def setUp(self):
+        super(HelpersTest, self).setUp()
+
+        self.tempdir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        super(HelpersTest, self).tearDown()
+
+        shutil.rmtree(self.tempdir, ignore_errors=True)
+
+    def read_fixture(self, basename):
+        fixture = os.path.join(FIXTURES, basename)
+        with original_open(fixture) as f:
+            content = f.read()
+        return content
+
+    @patch('subprocess.call')
+    def test_installs_packages(self, mock_call):
+        mock_call.return_value = 'some result'
+
+        result = hooks.apt_get_install('foo bar')
+
+        self.assertEqual(result, 'some result')
+        mock_call.assert_called_with(['apt-get', '-y', 'install', '-qq',
+                                      'foo bar'])
+
+    @patch('subprocess.call')
+    def test_installs_nothing_if_package_not_provided(self, mock_call):
+        self.assertFalse(hooks.apt_get_install())
+        self.assertFalse(mock_call.called)
+
+    @patch('subprocess.call')
+    def test_purges_packages(self, mock_call):
+        mock_call.return_value = 'some result'
+
+        result = hooks.apt_get_purge('foo bar')
+
+        self.assertEqual(result, 'some result')
+        mock_call.assert_called_with(['apt-get', '-y', 'purge', '-qq',
+                                      'foo bar'])
+
+    @patch('subprocess.call')
+    def test_purges_nothing_if_package_not_provided(self, mock_call):
+        self.assertFalse(hooks.apt_get_purge())
+        self.assertFalse(mock_call.called)
+
+    @patch('subprocess.call')
+    def test_starts_apache_successfully(self, mock_call):
+        mock_call.return_value = 0
+        action = 'start'
+
+        self.assertTrue(hooks.service_apache2(action))
+        mock_call.assert_called_with(['service', 'apache2', action])
+
+    @patch('subprocess.call')
+    def test_fails_to_start_apache(self, mock_call):
+        mock_call.return_value = 1
+        action = 'start'
+
+        self.assertFalse(hooks.service_apache2(action))
+        mock_call.assert_called_with(['service', 'apache2', action])
+
+    @patch('subprocess.call')
+    def test_checks_apache_successfully(self, mock_call):
+        mock_call.return_value = 0
+
+        self.assertTrue(hooks.service_apache2('check'))
+        mock_call.assert_called_with(['/usr/sbin/apache2ctl', 'configtest'])
+
+    @patch('subprocess.call')
+    def test_fails_to_check_apache(self, mock_call):
+        mock_call.return_value = 1
+
+        self.assertFalse(hooks.service_apache2('check'))
+        mock_call.assert_called_with(['/usr/sbin/apache2ctl', 'configtest'])
+
+    @patch('subprocess.call')
+    def test_fails_to_check_apache_with_another_return_value(self, mock_call):
+        mock_call.return_value = 2
+
+        self.assertFalse(hooks.service_apache2('check'))
+        mock_call.assert_called_with(['/usr/sbin/apache2ctl', 'configtest'])
+
+    @patch('subprocess.call')
+    def test_does_nothing_if_action_not_provided(self, mock_call):
+        self.assertIsNone(hooks.service_apache2())
+        self.assertFalse(mock_call.called)
+
+    @patch('subprocess.check_output')
+    def test_runs_an_arbitrary_command(self, check_output):
+        check_output.return_value = 'some result'
+
+        self.assertEqual(hooks.run('foo', 1, 2, bar='baz'), 'some result')
+        check_output.assert_called_with('foo', 1, 2, bar='baz')
+
+    @patch('subprocess.check_output')
+    @patch('sys.stdout.write')
+    def test_prints_and_reraises_run_error(self, write, check_output):
+        check_output.side_effect = RuntimeError('some error')
+
+        self.assertRaises(RuntimeError, hooks.run, 'some command')
+        self.assertEqual(write.mock_calls, [
+            call('some error'),
+            call('\n'),
+        ])
+
+    @patch('subprocess.call')
+    @patch('hooks.log')
+    @patch('hooks.service_apache2')
+    @patch('os.path.exists')
+    @patch('hooks.apt_get_install')
+    def test_enables_a_module(self, apt_get_install, path_exists,
+                              service_apache2, log, mock_call):
+        module = 'foo'
+        module_already_enabled = False
+        module_available = False
+        apache_check = True
+        apache_reload = None
+        module_installed = 0
+        module_finally_enabled = 0
+
+        path_exists.side_effect = [module_already_enabled, module_available]
+        service_apache2.side_effect = [apache_check, apache_reload]
+        apt_get_install.return_value = module_installed
+        mock_call.return_value = module_finally_enabled
+
+        result = hooks.enable_module(module)
+
+        self.assertTrue(result)
+        path_exists.assert_has_calls([
+            call("/etc/apache2/mods-enabled/%s.load" % (module)),
+            call("/etc/apache2/mods-available/%s.load" % (module))
+        ])
+        apt_get_install.assert_called_with("libapache2-mod-%s" % (module))
+        mock_call.assert_called_with(['/usr/sbin/a2enmod', module])
+        service_apache2.assert_has_calls([call('check'), call('reload')])
+        self.assertFalse(log.called)
+
+    @patch('subprocess.call')
+    @patch('hooks.log')
+    @patch('hooks.service_apache2')
+    @patch('os.path.exists')
+    @patch('hooks.apt_get_install')
+    def test_doesnt_enable_if_module_not_provided(self, apt_get_install,
+                                                  path_exists, service_apache2,
+                                                  log, mock_call):
+        module = None
+
+        result = hooks.enable_module(module)
+
+        self.assertTrue(result)
+        self.assertFalse(apt_get_install.called)
+        self.assertFalse(path_exists.called)
+        self.assertFalse(service_apache2.called)
+        self.assertFalse(log.called)
+        self.assertFalse(mock_call.called)
+
+    @patch('subprocess.call')
+    @patch('hooks.log')
+    @patch('hooks.service_apache2')
+    @patch('os.path.exists')
+    @patch('hooks.apt_get_install')
+    def test_doesnt_enable_if_module_already_enabled(self, apt_get_install,
+                                                     path_exists,
+                                                     service_apache2, log,
+                                                     mock_call):
+        module = 'foo'
+        module_already_enabled = True
+
+        path_exists.return_value = module_already_enabled
+
+        result = hooks.enable_module(module)
+
+        self.assertTrue(result)
+        path_exists.assert_called_with(
+            "/etc/apache2/mods-enabled/%s.load" % (module))
+        log.assert_called_with("Module already loaded: foo")
+        self.assertFalse(apt_get_install.called)
+        self.assertFalse(service_apache2.called)
+        self.assertFalse(mock_call.called)
+
+    @patch('subprocess.call')
+    @patch('hooks.log')
+    @patch('hooks.service_apache2')
+    @patch('os.path.exists')
+    @patch('hooks.apt_get_install')
+    def test_fails_to_enable_if_module_not_installed(self, apt_get_install,
+                                                     path_exists,
+                                                     service_apache2, log,
+                                                     mock_call):
+        module = 'foo'
+        module_already_enabled = False
+        module_available = False
+        module_installed = 1
+
+        path_exists.side_effect = [module_already_enabled, module_available]
+        apt_get_install.return_value = module_installed
+
+        result = hooks.enable_module(module)
+
+        self.assertFalse(result)
+        path_exists.assert_has_calls([
+            call("/etc/apache2/mods-enabled/%s.load" % (module)),
+            call("/etc/apache2/mods-available/%s.load" % (module))
+        ])
+        apt_get_install.assert_called_with("libapache2-mod-%s" % (module))
+        log.assert_called_with("Installing module %s failed" % (module))
+        self.assertFalse(mock_call.called)
+        self.assertFalse(service_apache2.called)
+
+    @patch('subprocess.call')
+    @patch('hooks.log')
+    @patch('hooks.service_apache2')
+    @patch('os.path.exists')
+    @patch('hooks.apt_get_install')
+    def test_fails_to_enable_if_enmod_fails(self, apt_get_install,
+                                            path_exists, service_apache2,
+                                            log, mock_call):
+        module = 'foo'
+        module_already_enabled = False
+        module_available = False
+        module_installed = 0
+        module_finally_enabled = 1
+
+        path_exists.side_effect = [module_already_enabled, module_available]
+        apt_get_install.return_value = module_installed
+        mock_call.return_value = module_finally_enabled
+
+        result = hooks.enable_module(module)
+
+        self.assertFalse(result)
+        path_exists.assert_has_calls([
+            call("/etc/apache2/mods-enabled/%s.load" % (module)),
+            call("/etc/apache2/mods-available/%s.load" % (module))
+        ])
+        apt_get_install.assert_called_with("libapache2-mod-%s" % (module))
+        mock_call.assert_called_with(['/usr/sbin/a2enmod', module])
+        self.assertFalse(log.called)
+        self.assertFalse(service_apache2.called)
+
+    @patch('subprocess.call')
+    @patch('hooks.log')
+    @patch('hooks.service_apache2')
+    @patch('os.path.exists')
+    def test_disables_a_module(self, path_exists, service_apache2, log,
+                               mock_call):
+        module = 'foo'
+        module_still_enabled = True
+        apache_check = True
+        apache_reload = None
+        module_finally_disabled = 0
+
+        path_exists.return_value = module_still_enabled
+        service_apache2.side_effect = [apache_check, apache_reload]
+        mock_call.return_value = module_finally_disabled
+
+        result = hooks.disable_module(module)
+
+        self.assertTrue(result)
+        path_exists.assert_called_with(
+            "/etc/apache2/mods-enabled/%s.load" % (module))
+        mock_call.assert_called_with(['/usr/sbin/a2dismod', module])
+        service_apache2.assert_has_calls([call('check'), call('reload')])
+        self.assertFalse(log.called)
+
+    @patch('subprocess.call')
+    @patch('hooks.log')
+    @patch('hooks.service_apache2')
+    @patch('os.path.exists')
+    def test_doest_disable_if_module_not_provided(self, path_exists,
+                                                  service_apache2, log,
+                                                  mock_call):
+        module = None
+
+        result = hooks.disable_module(module)
+
+        self.assertTrue(result)
+        self.assertFalse(path_exists.called)
+        self.assertFalse(service_apache2.called)
+        self.assertFalse(log.called)
+        self.assertFalse(mock_call.called)
+
+    @patch('subprocess.call')
+    @patch('hooks.log')
+    @patch('hooks.service_apache2')
+    @patch('os.path.exists')
+    def test_does_nothing_if_module_already_disabled(self, path_exists,
+                                                     service_apache2, log,
+                                                     mock_call):
+        module = 'foo'
+        module_still_enabled = False
+
+        path_exists.return_value = module_still_enabled
+
+        result = hooks.disable_module(module)
+
+        self.assertTrue(result)
+        path_exists.assert_called_with(
+            "/etc/apache2/mods-enabled/%s.load" % (module))
+        log.assert_called_with("Module already disabled: foo")
+
+    @patch('subprocess.call')
+    @patch('hooks.log')
+    @patch('hooks.service_apache2')
+    @patch('os.path.exists')
+    def test_fails_to_disable_if_dismod_fails(self, path_exists,
+                                              service_apache2, log, mock_call):
+        module = 'foo'
+        module_still_enabled = True
+        apache_check = True
+        apache_reload = None
+        module_finally_disabled = 1
+
+        path_exists.return_value = module_still_enabled
+        service_apache2.side_effect = [apache_check, apache_reload]
+        mock_call.return_value = module_finally_disabled
+
+        result = hooks.disable_module(module)
+
+        self.assertFalse(result)
+        path_exists.assert_called_with(
+            "/etc/apache2/mods-enabled/%s.load" % (module))
+        mock_call.assert_called_with(['/usr/sbin/a2dismod', module])
+        self.assertFalse(service_apache2.called)
+        self.assertFalse(log.called)
+
+    @patch('hooks.config_get')
+    @patch('hooks.log')
+    def test_writes_balancer_config(self, log, config_get):
+        config_get.return_value = {
+            'lb_balancer_timeout': 123,
+        }
+        balancer_config = {
+            'foo': ['10.11.12.13'],
+            'bar': ['10.11.12.14', '10.11.12.15'],
+        }
+        with patch('hooks.default_apache2_config_dir', self.tempdir):
+            hooks.write_balancer_config(balancer_config)
+        for balancer in balancer_config.keys():
+            basename = '%s.balancer' % balancer
+            exp_path = os.path.join(FIXTURES, basename)
+            res_path = os.path.join(self.tempdir, basename)
+            with open(exp_path) as exp, open(res_path) as res:
+                self.assertEqual(exp.read(), res.read())
+
+
+class HooksTest(TestCase):
+    def setUp(self):
+        super(HooksTest, self).setUp()
+        self.executable_file = '/some/executable'
+        self.unexecutable_file = '/some/unexecutable'
+        self.is_a_file = True
+        self.not_a_file = False
+        self.is_executable = True
+        self.not_executable = False
+        self.dir_exists = True
+        self.not_a_dir = False
+        self.log_prefix = 'baz'
+        self.log_path = '/tmp/pprint-%s.log' % self.log_prefix
+
+    def tearDown(self):
+        super(HooksTest, self).tearDown()
+        if os.path.exists(self.log_path):
+            os.remove(self.log_path)
+
+    @patch('hooks.config_get')
+    @patch('os.path.exists')
+    @patch('os.mkdir')
+    @patch('hooks.apt_get_install')
+    @patch('hooks.log', MagicMock())
+    def test_installs_hook(self, apt_get_install, mkdir, exists, config_get):
+        exists.return_value = self.not_a_dir
+        config_get.return_value = None
+        apt_get_install.return_value = 'some result'
+
+        result = hooks.install_hook()
+
+        self.assertEqual(result, 'some result')
+        exists.assert_called_with(hooks.default_apache2_service_config_dir)
+        mkdir.assert_called_with(hooks.default_apache2_service_config_dir,
+                                 0600)
+        apt_get_install.assert_has_calls([
+            call('python-jinja2'),
+            call('apache2'),
+        ])
+
+    @patch('hooks.config_get')
+    @patch('os.path.exists')
+    @patch('os.mkdir')
+    @patch('hooks.apt_get_install')
+    @patch('hooks.log', MagicMock())
+    def test_install_hook_installs_extra_packages(
+            self, apt_get_install, mkdir, exists, config_get):
+        exists.return_value = self.dir_exists
+        config_get.return_value = "extra"
+        apt_get_install.return_value = 'some result'
+
+        result = hooks.install_hook()
+
+        self.assertEqual(result, 'some result')
+        apt_get_install.assert_has_calls([
+            call('python-jinja2'),
+            call('apache2'),
+            call('extra'),
+        ])
+
+    @patch('hooks.config_get')
+    @patch('os.path.exists')
+    @patch('os.mkdir')
+    @patch('hooks.apt_get_install')
+    @patch('hooks.log', MagicMock())
+    def test_doesnt_create_dir_to_install_hooks_if_not_needed(
+            self, apt_get_install, mkdir, exists, config_get):
+        exists.return_value = self.dir_exists
+        config_get.return_value = None
+        apt_get_install.return_value = 'some result'
+
+        result = hooks.install_hook()
+
+        self.assertEqual(result, 'some result')
+        exists.assert_called_with(hooks.default_apache2_service_config_dir)
+        self.assertFalse(mkdir.called)
+        apt_get_install.assert_has_calls([
+            call('python-jinja2'),
+            call('apache2'),
+        ])
+
+    def test_dumps_data_into_file(self):
+        data = {'foo': 'bar'}
+
+        hooks.dump_data(data, self.log_prefix)
+
+        with open(self.log_path) as f:
+            self.assertEqual(f.read().strip(), pformat(data).strip())
+
+    def test_dumps_nothing_if_data_not_provided(self):
+        data = None
+
+        hooks.dump_data(data, self.log_prefix)
+
+        self.assertFalse(os.path.exists(self.log_path))
+
+    @patch('hooks.relations_of_type')
+    @patch('yaml.safe_load')
+    @patch('hooks.log')
+    def test_gets_reverseproxy_data(self, log, load, relations_of_type):
+        relation_data = [
+            {'port': 1234,
+             'private-address': '10.11.12.13',
+             'all_services': '/some/yaml/file',
+             '__unit__': 'foo-unit/1',
+             },
+            {'port': 1234,
+             'private-address': '10.11.12.14',
+             'all_services': '/some/yaml/file2',
+             '__unit__': 'foo-unit/2',
+             },
+            {'port': 3214,
+             'private-address': '10.11.12.13',
+             'all_services': '/some/yaml/file3',
+             '__unit__': 'bar-unit/1',
+             },
+        ]
+        yaml_content = [
+            {
+                'service_name': 'some-service',
+                'service_port': '2345',
+            },
+        ]
+
+        relations_of_type.return_value = relation_data
+        load.return_value = yaml_content
+
+        result = hooks.get_reverseproxy_data(relation='baz-proxy')
+
+        self.assertEqual(result, {
+            'barunit': '10.11.12.13:3214',
+            'barunit_all_services': '/some/yaml/file3',
+            'barunit_port': 3214,
+            'barunit_private_address': '10.11.12.13',
+            'barunit_someservice': '10.11.12.13:2345',
+            'foounit': '10.11.12.13:1234',
+            'foounit_all_services': '/some/yaml/file',
+            'foounit_port': 1234,
+            'foounit_private_address': '10.11.12.13',
+            'foounit_someservice': '10.11.12.13:2345',
+        })
+        relations_of_type.assert_called_with('baz-proxy')
+        self.assertEqual(sorted(load.mock_calls), sorted([
+            call('/some/yaml/file'),
+            call('/some/yaml/file3'),
+        ]))
+        self.assertEqual(sorted(log.mock_calls), sorted([
+            call('unit_type: barunit'),
+            call('unit_type: foounit'),
+            call('unit_type: foounit'),
+        ]))
+
+    @patch('hooks.relations_of_type')
+    @patch('yaml.safe_load')
+    @patch('hooks.log')
+    def test_truncates_reverseproxy_data_if_unit_has_no_port(
+            self, log, load, relations_of_type):
+        relation_data = [
+            {'port': 1234,
+             'private-address': '10.11.12.13',
+             'all_services': '/some/yaml/file',
+             '__unit__': 'foo-unit/1',
+             },
+            {'private-address': '10.11.12.13',
+             'all_services': '/some/yaml/file3',
+             '__unit__': 'bar-unit/1',
+             },
+        ]
+
+        relations_of_type.return_value = relation_data
+
+        result = hooks.get_reverseproxy_data(relation='baz-proxy')
+
+        self.assertEqual(result, {'foounit': '10.11.12.13:1234',
+                                  'foounit_all_services': '/some/yaml/file',
+                                  'foounit_port': 1234,
+                                  'foounit_private_address': '10.11.12.13'})
+        relations_of_type.assert_called_with('baz-proxy')
+        self.assertTrue(load.called)
+
+    @patch('hooks.relations_of_type')
+    @patch('yaml.safe_load')
+    @patch('hooks.log')
+    def test_truncates_reverseproxy_data_if_no_data_available(
+            self, log, load, relations_of_type):
+        relations_of_type.return_value = []
+
+        result = hooks.get_reverseproxy_data(relation='baz-proxy')
+
+        self.assertEqual(result, {})
+        relations_of_type.assert_called_with('baz-proxy')
+        self.assertFalse(load.called)

=== added file 'hooks/tests/test_nrpe_hooks.py'
--- hooks/tests/test_nrpe_hooks.py	1970-01-01 00:00:00 +0000
+++ hooks/tests/test_nrpe_hooks.py	2013-10-10 22:50:52 +0000
@@ -0,0 +1,134 @@
+import os
+import grp
+import pwd
+import subprocess
+from testtools import TestCase
+from mock import patch, call
+
+import hooks
+from charmhelpers.contrib.charmsupport import nrpe
+from charmhelpers.core.hookenv import Serializable
+
+
+class NRPERelationTest(TestCase):
+    """Tests for the update_nrpe_checks hook.
+
+    Half of this is already tested in the tests for charmsupport.nrpe, but
+    as the hook in the charm pre-dates that, the tests are left here to ensure
+    backwards-compatibility.
+
+    """
+    patches = {
+        'config': {'object': nrpe},
+        'log': {'object': nrpe},
+        'getpwnam': {'object': pwd},
+        'getgrnam': {'object': grp},
+        'mkdir': {'object': os},
+        'chown': {'object': os},
+        'exists': {'object': os.path},
+        'listdir': {'object': os},
+        'remove': {'object': os},
+        'open': {'object': nrpe, 'create': True},
+        'isfile': {'object': os.path},
+        'call': {'object': subprocess},
+        'relation_ids': {'object': nrpe},
+        'relation_set': {'object': nrpe},
+    }
+
+    def setUp(self):
+        super(NRPERelationTest, self).setUp()
+        self.patched = {}
+        # Mock the universe.
+        for attr, data in self.patches.items():
+            create = data.get('create', False)
+            patcher = patch.object(data['object'], attr, create=create)
+            self.patched[attr] = patcher.start()
+            self.addCleanup(patcher.stop)
+        if not 'JUJU_UNIT_NAME' in os.environ:
+            os.environ['JUJU_UNIT_NAME'] = 'test'
+
+    def check_call_counts(self, **kwargs):
+        for attr, expected in kwargs.items():
+            patcher = self.patched[attr]
+            self.assertEqual(expected, patcher.call_count, attr)
+
+    def test_update_nrpe_no_nagios_bails(self):
+        config = {'nagios_context': 'test'}
+        self.patched['config'].return_value = Serializable(config)
+        self.patched['getpwnam'].side_effect = KeyError
+
+        self.assertEqual(None, hooks.update_nrpe_checks())
+
+        expected = 'Nagios user not set up, nrpe checks not updated'
+        self.patched['log'].assert_called_once_with(expected)
+        self.check_call_counts(log=1, config=1, getpwnam=1)
+
+    def test_update_nrpe_removes_existing_config(self):
+        config = {
+            'nagios_context': 'test',
+            'nagios_check_http_params': '-u http://example.com/url',
+        }
+        self.patched['config'].return_value = Serializable(config)
+        self.patched['exists'].return_value = True
+        self.patched['listdir'].return_value = [
+            'foo', 'bar.cfg', 'check_vhost.cfg']
+
+        self.assertEqual(None, hooks.update_nrpe_checks())
+
+        expected = '/var/lib/nagios/export/check_vhost.cfg'
+        self.patched['remove'].assert_called_once_with(expected)
+        self.check_call_counts(config=1, getpwnam=1, getgrnam=1,
+                               exists=3, remove=1, open=2, listdir=1)
+
+    def test_update_nrpe_with_check_url(self):
+        config = {
+            'nagios_context': 'test',
+            'nagios_check_http_params': '-u foo -H bar',
+        }
+        self.patched['config'].return_value = Serializable(config)
+        self.patched['exists'].return_value = True
+        self.patched['isfile'].return_value = False
+
+        self.assertEqual(None, hooks.update_nrpe_checks())
+        self.assertEqual(2, self.patched['open'].call_count)
+        filename = 'check_vhost.cfg'
+
+        service_file_contents = """
+#---------------------------------------------------
+# This file is Juju managed
+#---------------------------------------------------
+define service {
+    use                             active-service
+    host_name                       test-test
+    service_description             test-test[vhost] Check Virtual Host
+    check_command                   check_nrpe!check_vhost
+    servicegroups                   test
+}
+"""
+        self.patched['open'].assert_has_calls(
+            [call('/etc/nagios/nrpe.d/%s' % filename, 'w'),
+             call('/var/lib/nagios/export/service__test-test_%s' %
+                  filename, 'w'),
+             call().__enter__().write(service_file_contents),
+             call().__enter__().write('# check vhost\n'),
+             call().__enter__().write(
+                 'command[check_vhost]=/check_http -u foo -H bar\n')],
+            any_order=True)
+
+        self.check_call_counts(config=1, getpwnam=1, getgrnam=1,
+                               exists=3, open=2, listdir=1)
+
+    def test_update_nrpe_restarts_service(self):
+        config = {
+            'nagios_context': 'test',
+            'nagios_check_http_params': '-u foo -p 3128'
+        }
+        self.patched['config'].return_value = Serializable(config)
+        self.patched['exists'].return_value = True
+
+        self.assertEqual(None, hooks.update_nrpe_checks())
+
+        expected = ['service', 'nagios-nrpe-server', 'restart']
+        self.assertEqual(expected, self.patched['call'].call_args[0][0])
+        self.check_call_counts(config=1, getpwnam=1, getgrnam=1,
+                               exists=3, open=2, listdir=1, call=1)

=== modified file 'metadata.yaml'
--- metadata.yaml	2013-04-22 19:37:54 +0000
+++ metadata.yaml	2013-10-10 22:50:52 +0000
@@ -13,6 +13,9 @@
   nrpe-external-master:
     interface: nrpe-external-master
     scope: container
+  local-monitors:
+    interface: local-monitors
+    scope: container
   website:
     interface: http
 requires:
@@ -22,3 +25,5 @@
     interface: http
   balancer:
     interface: http
+  logging:
+    interface: syslog

=== removed file 'revision'
--- revision	2013-04-30 08:49:11 +0000
+++ revision	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-5

=== added file 'setup.cfg'
--- setup.cfg	1970-01-01 00:00:00 +0000
+++ setup.cfg	2013-10-10 22:50:52 +0000
@@ -0,0 +1,4 @@
+[nosetests]
+with-coverage=1
+cover-erase=1
+cover-package=hooks
\ No newline at end of file

=== added file 'tarmac_tests.sh'
--- tarmac_tests.sh	1970-01-01 00:00:00 +0000
+++ tarmac_tests.sh	2013-10-10 22:50:52 +0000
@@ -0,0 +1,6 @@
+#!/bin/sh
+# How the tests are run in Jenkins by Tarmac
+
+set -e
+
+make build