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

[Sidnei da Silva]

* The 'all_services' config now supports a static list of servers to be used *in addition* to the ones provided via relation.

* When more than one haproxy units exist, the configured service is upgraded in-place to a mode where traffic is routed to a single haproxy unit (the first one in unit-name order) and the remaining ones are configured as 'backup'. This is done to allow the enforcement of a 'maxconn' session in the configured services, which would not be possible to enforce otherwise.

* Changes to the configured services are properly propagated to the upstream relation.

[Juan L. Negron (negronjl)]

Reviewing this now.

-Juan

[Juan L. Negron (negronjl)]

Hi Sidnei:

I ran charm proof on the charm ( after mergin it locally ) and I get the following:
negronjl@negronjl-laptop:~/src/juju/charms/precise$ charm proof haproxy
W: website-relation-changed not executable
W: nrpe-external-master-relation-changed not executable
W: reverseproxy-relation-changed not executable
W: peer-relation-changed not executable
W: install not executable
W: start not executable
W: stop not executable
W: config-changed not executable

As I try to deploy the charm, I get this:
negronjl@negronjl-laptop:~/src/juju/charms$ juju deploy --repository . local:precise/haproxy
2013-02-27 10:17:30,036 INFO Searching for charm local:precise/haproxy in local charm repository: /home/negronjl/src/juju/charms
2013-02-27 10:17:30,244 INFO Connecting to environment...
2013-02-27 10:17:33,069 INFO Connected to environment.
2013-02-27 10:17:33,337 ERROR [Errno 2] No such file or directory: '/home/negronjl/src/juju/charms/precise/haproxy/lib/charmsupport'

review: Disapprove

[Sidnei da Silva (sidnei)]

Ah, lib/charmsupport is a symlink and those don't get included in the charm IIRC. Maybe 'charm proof' should check for that.

I'll add charm proof to our tarmac test step and fix the other issue.

[Mark Mims (mark-mims)]

same story as apache... please reserve /tests for charm tests.

review: Needs Resubmitting

[James Page (james-page)]

Sidnei

This all looks like great work; I really like the approach you are taking to testing (gonna steal some of that goodness for my own charms) and you have pointed me at charmsupport which overlaps alot with the openstack-charm-helpers we use for the OpenStack charms.

I have one gripe right now; as is this change will make the charm un-deployable from the charm store as you have introduced a requirement to branch it locally and pull in the other dependencies.

I personally don't think this is acceptable; the branch for haproxy should ship the required revisions of its dependencies so that this will continue work.

review: Disapprove

[James Page (james-page)]

Sorry - that should have been 'Needs Fixing' not 'Disapprove'.

Not got my head on straight this morning...

review: Needs Fixing

[Sidnei da Silva (sidnei)]

Hi James,

re: dependencies that's actually not the case anymore, and I'll update the README to match. Notice how I've changed the install hook to be a shell script that adds a PPA and then installs the package dependencies, such that it still works if you deploy directly from the charm store.

[David Britton (dpb)]

Sidnei: the README.md needs the following ppa url:

  sudo add-apt-repository ppa:cjohnston/flake8

it's mispelled right now.

[David Britton (dpb)]

[2]: flake8 in the apt-get install line should be python-flake8

[David Britton (dpb)]

[3]: also add python-nosexcover

[David Britton (dpb)]

Just tested this branch with an upstream apache2 and downstream landscape charm that depends on the relation driven proxying change in r64. Its missing the functionality in r64 and r64 from trunk right now.

review: Needs Fixing

[lp:~sidnei/charms/precise/haproxy/trunk]

83. By Tom Haddon on 2013-08-27

Merge from U1 charms - also an upstream review in process for this. Add in charmhelpers and updating some tests.

84. By Matthias Arnason on 2013-09-17

[ev r=tiaz] Always write at least one listen stanza, do not pass null relationIDs to subprocess

85. By Matthias Arnason on 2013-09-25

[sidnei r=tiaz] Switch to using service name instead of hostname in backend server name, filter frontend-only options into frontend, create frontend/backend stanzas instead of a single listen stanza. Still support old listen stanzas when parsing for bw-compatibility.

86. By David Ames on 2013-10-01

[dames,r=mthaddon] reverting revno 84 and making notify_website call more explicit for relation_ids

87. By JuanJo Ciarlante on 2013-10-15

[sidnei, r=jjo] Dupe mode http/tcp and option httplog/tcplog between frontend and backend

Unmerged revisions

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2013-10-10 22:34:35 +0000
@@ -0,0 +1,10 @@
+revision
+_trial_temp
+.coverage
+coverage.xml
+*.crt
+*.key
+lib/*
+*.pyc
+exec.d
+build/charm-helpers

=== added file 'Makefile'
--- Makefile	1970-01-01 00:00:00 +0000
+++ Makefile	2013-10-10 22:34:35 +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-12 23:43:54 +0000
+++ README.md	2013-10-10 22:34:35 +0000
@@ -1,5 +1,5 @@
-Juju charm haproxy
-==================
+Juju charm for HAProxy
+======================
 
 HAProxy is a free, very fast and reliable solution offering high availability,
 load balancing, and proxying for TCP and HTTP-based applications. It is
@@ -9,6 +9,23 @@
 integration into existing architectures very easy and riskless, while still
 offering the possibility not to expose fragile web servers to the Net.
 
+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:cjohnston/flake8
+    sudo apt-get update
+    sudo apt-get install python-mock python-flake8 python-nose python-nosexcover
+
+To 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
 -----------------------
     juju deploy haproxy
@@ -27,7 +44,7 @@
 the "Website Relation" section for more information about that.
 
 When your charm hooks into reverseproxy you have two general approaches
-which can be used to notify haproxy about what services you are running. 
+which can be used to notify haproxy about what services you are running.
 1) Single-service proxying or 2) Multi-service or relation-driven proxying.
 
 ** 1) Single-Service Proxying **
@@ -67,7 +84,7 @@
 
     #!/bin/bash
     # hooks/website-relation-changed
-  
+
     host=$(unit-get private-address)
     port=80
 
@@ -80,7 +97,7 @@
     "
 
 Once set, haproxy will union multiple `servers` stanzas from any units
-joining with the same `service_name` under one listen stanza. 
+joining with the same `service_name` under one listen stanza.
 `service-options` and `server_options` will be overwritten, so ensure they
 are set uniformly on all services with the same name.
 
@@ -102,18 +119,8 @@
 Many of the haproxy settings can be altered via the standard juju configuration
 settings.  Please see the config.yaml file as each is fairly clearly documented.
 
-Testing
--------
-This charm has a simple unit-test program.  Please expand it and make sure new
-changes are covered by simple unit tests.  To run the unit tests:
-
-    sudo apt-get install python-mocker
-    sudo apt-get install python-twisted-core
-    cd hooks; trial test_hooks
-
 TODO:
 -----
 
   * Expand Single-Service section as I have not tested that mode fully.
   * Trigger website-relation-changed when the reverse-proxy relation changes
-

=== 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:34:35 +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:34:35 +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:34:35 +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	2012-10-10 14:38:47 +0000
+++ config.yaml	2013-10-10 22:34:35 +0000
@@ -59,7 +59,7 @@
         restarting, a turn-around timer of 1 second is applied before a retry
         occurs.
   default_timeouts:
-    default: "queue 1000, connect 1000, client 1000, server 1000"
+    default: "queue 20000, client 50000, connect 5000, server 50000"
     type: string
     description: Default timeouts 
   enable_monitoring:
@@ -90,6 +90,12 @@
     default: 3
     type: int
     description: Monitoring interface refresh interval (in seconds)
+  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".
   services:
     default: |
               - service_name: haproxy_service
@@ -106,6 +112,12 @@
         before the first variable, service_name, as above. Service options is a
         comma separated list, server options will be appended as a string to
         the individual server lines for a given listen stanza.
+  sysctl:
+    default: ""
+    type: string
+    description: >
+      YAML-formatted list of sysctl values, e.g.:
+      '{ net.ipv4.tcp_max_syn_backlog : 65536 }'
   nagios_context:
     default: "juju"
     type: string

=== renamed directory 'files/nrpe-external-master' => 'files/nrpe'
=== modified file 'files/nrpe/check_haproxy.sh'
--- files/nrpe-external-master/check_haproxy.sh	2012-11-07 22:32:06 +0000
+++ files/nrpe/check_haproxy.sh	2013-10-10 22:34:35 +0000
@@ -2,7 +2,7 @@
 #--------------------------------------------
 # This file is managed by Juju
 #--------------------------------------------
-#                                       
+#
 # Copyright 2009,2012 Canonical Ltd.
 # Author: Tom Haddon
 
@@ -13,7 +13,7 @@
 
 for appserver in $(grep '    server' /etc/haproxy/haproxy.cfg | awk '{print $2'});
 do
-    output=$(/usr/lib/nagios/plugins/check_http -a ${AUTH} -I 127.0.0.1 -p 10000 --regex="class=\"active(2|3).*${appserver}" -e ' 200 OK')
+    output=$(/usr/lib/nagios/plugins/check_http -a ${AUTH} -I 127.0.0.1 -p 10000 --regex="class=\"(active|backup)(2|3).*${appserver}" -e ' 200 OK')
     if [ $? != 0 ]; then
         date >> $LOGFILE
         echo $output >> $LOGFILE
@@ -30,4 +30,3 @@
 
 echo "OK: All haproxy instances looking good"
 exit 0
-

=== 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:34:35 +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:34:35 +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:34:35 +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:34:35 +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:34:35 +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:34:35 +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:34:35 +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-05-23 21:52:06 +0000
+++ hooks/hooks.py	2013-10-10 22:34:35 +0000
@@ -1,17 +1,31 @@
 #!/usr/bin/env python
 
-import json
 import glob
 import os
-import random
 import re
 import socket
-import string
+import shutil
 import subprocess
 import sys
 import yaml
-import nrpe
-import time
+
+from itertools import izip, tee
+
+from charmhelpers.core.host import pwgen
+from charmhelpers.core.hookenv import (
+    log,
+    config as config_get,
+    relation_set,
+    relation_ids as get_relation_ids,
+    relations_of_type,
+    relations_for_id,
+    relation_id,
+    open_port,
+    close_port,
+    unit_get,
+    )
+from charmhelpers.fetch import apt_install
+from charmhelpers.contrib.charmsupport import nrpe
 
 
 ###############################################################################
@@ -20,92 +34,52 @@
 default_haproxy_config_dir = "/etc/haproxy"
 default_haproxy_config = "%s/haproxy.cfg" % default_haproxy_config_dir
 default_haproxy_service_config_dir = "/var/run/haproxy"
-HOOK_NAME = os.path.basename(sys.argv[0])
+service_affecting_packages = ['haproxy']
+
+frontend_only_options = [
+    "backlog",
+    "bind",
+    "capture cookie",
+    "capture request header",
+    "capture response header",
+    "clitimeout",
+    "default_backend",
+    "maxconn",
+    "monitor fail",
+    "monitor-net",
+    "monitor-uri",
+    "option accept-invalid-http-request",
+    "option clitcpka",
+    "option contstats",
+    "option dontlog-normal",
+    "option dontlognull",
+    "option http-use-proxy-header",
+    "option log-separate-errors",
+    "option logasap",
+    "option socket-stats",
+    "option tcp-smart-accept",
+    "rate-limit sessions",
+    "tcp-request content accept",
+    "tcp-request content reject",
+    "tcp-request inspect-delay",
+    "timeout client",
+    "timeout clitimeout",
+    "use_backend",
+    ]
+
 
 ###############################################################################
 # Supporting functions
 ###############################################################################
 
-def unit_get(*args):
-    """Simple wrapper around unit-get, all arguments passed untouched"""
-    get_args = ["unit-get"]
-    get_args.extend(args)
-    return subprocess.check_output(get_args)
-
-def juju_log(*args):
-    """Simple wrapper around juju-log, all arguments are passed untouched"""
-    log_args = ["juju-log"]
-    log_args.extend(args)
-    subprocess.call(log_args)
-
-#------------------------------------------------------------------------------
-# 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))
-    except Exception, e:
-        subprocess.call(['juju-log', str(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)
-        else:
-            relation_cmd_line.append('')
-        if unit_name is not None:
-            relation_cmd_line.append(unit_name)
-        relation_data = json.loads(subprocess.check_output(relation_cmd_line))
-    except Exception, e:
-        subprocess.call(['juju-log', str(e)])
-        relation_data = None
-    finally:
-        return(relation_data)
-
-def relation_set(arguments, relation_id=None):
-    """
-    Wrapper around relation-set
-    @param arguments: list of command line arguments
-    @param relation_id: optional relation-id (passed to -r parameter) to use
-    """
-    set_args = ["relation-set"]
-    if relation_id is not None:
-        set_args.extend(["-r", str(relation_id)])
-    set_args.extend(arguments)
-    subprocess.check_call(set_args)
-
-#------------------------------------------------------------------------------
-# apt_get_install( package ):  Installs a package
-#------------------------------------------------------------------------------
-def apt_get_install(packages=None):
-    if packages is None:
-        return(False)
-    cmd_line = ['apt-get', '-y', 'install', '-qq']
-    cmd_line.append(packages)
-    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)
 
 
 #------------------------------------------------------------------------------
@@ -113,8 +87,8 @@
 #------------------------------------------------------------------------------
 def enable_haproxy():
     default_haproxy = "/etc/default/haproxy"
-    enabled_haproxy = \
-    open(default_haproxy).read().replace('ENABLED=0', 'ENABLED=1')
+    with open(default_haproxy) as f:
+        enabled_haproxy = f.read().replace('ENABLED=0', 'ENABLED=1')
     with open(default_haproxy, 'w') as f:
         f.write(enabled_haproxy)
 
@@ -137,8 +111,8 @@
     if config_data['global_quiet'] is True:
         haproxy_globals.append("    quiet")
     haproxy_globals.append("    spread-checks %d" %
-    config_data['global_spread_checks'])
-    return('\n'.join(haproxy_globals))
+                           config_data['global_spread_checks'])
+    return '\n'.join(haproxy_globals)
 
 
 #------------------------------------------------------------------------------
@@ -157,7 +131,7 @@
     haproxy_defaults.append("    retries %d" % config_data['default_retries'])
     for timeout_item in default_timeouts:
         haproxy_defaults.append("    timeout %s" % timeout_item.strip())
-    return('\n'.join(haproxy_defaults))
+    return '\n'.join(haproxy_defaults)
 
 
 #------------------------------------------------------------------------------
@@ -168,9 +142,9 @@
 #------------------------------------------------------------------------------
 def load_haproxy_config(haproxy_config_file="/etc/haproxy/haproxy.cfg"):
     if os.path.isfile(haproxy_config_file):
-        return(open(haproxy_config_file).read())
+        return open(haproxy_config_file).read()
     else:
-        return(None)
+        return None
 
 
 #------------------------------------------------------------------------------
@@ -182,12 +156,12 @@
 def get_monitoring_password(haproxy_config_file="/etc/haproxy/haproxy.cfg"):
     haproxy_config = load_haproxy_config(haproxy_config_file)
     if haproxy_config is None:
-        return(None)
+        return None
     m = re.search("stats auth\s+(\w+):(\w+)", haproxy_config)
     if m is not None:
-        return(m.group(2))
+        return m.group(2)
     else:
-        return(None)
+        return None
 
 
 #------------------------------------------------------------------------------
@@ -197,32 +171,29 @@
 #                     to open and close when exposing/unexposing a service
 #------------------------------------------------------------------------------
 def get_service_ports(haproxy_config_file="/etc/haproxy/haproxy.cfg"):
+    stanzas = get_listen_stanzas(haproxy_config_file=haproxy_config_file)
+    return tuple((int(port) for service, addr, port in stanzas))
+
+
+#------------------------------------------------------------------------------
+# get_listen_stanzas: Convenience function that scans the existing haproxy
+#                     configuration file and returns a list of the existing
+#                     listen stanzas cofnigured.
+#------------------------------------------------------------------------------
+def get_listen_stanzas(haproxy_config_file="/etc/haproxy/haproxy.cfg"):
     haproxy_config = load_haproxy_config(haproxy_config_file)
     if haproxy_config is None:
-        return(None)
-    return(re.findall("listen.*:(.*)", haproxy_config))
-
-
-#------------------------------------------------------------------------------
-# 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)]))
+        return ()
+    listen_stanzas = re.findall(
+        "listen\s+([^\s]+)\s+([^:]+):(.*)",
+        haproxy_config)
+    bind_stanzas = re.findall(
+        "\s+bind\s+([^:]+):(\d+)\s*\n\s+default_backend\s+([^\s]+)",
+        haproxy_config, re.M)
+    return (tuple(((service, addr, int(port))
+                   for service, addr, port in listen_stanzas)) +
+            tuple(((service, addr, int(port))
+                   for addr, port, service in bind_stanzas)))
 
 
 #------------------------------------------------------------------------------
@@ -232,26 +203,25 @@
 #------------------------------------------------------------------------------
 def update_service_ports(old_service_ports=None, new_service_ports=None):
     if old_service_ports is None or new_service_ports is None:
-        return(None)
+        return None
     for port in old_service_ports:
         if port not in new_service_ports:
             close_port(port)
     for port in new_service_ports:
-        if port not in old_service_ports:
-            open_port(port)
-
-
-#------------------------------------------------------------------------------
-# pwgen:  Generates a random password
-#         pwd_length:  Defines the length of the password to generate
-#                      default: 20
-#------------------------------------------------------------------------------
-def pwgen(pwd_length=20):
-    alphanumeric_chars = [l for l in (string.letters + string.digits)
-    if l not in 'Iil0oO1']
-    random_chars = [random.choice(alphanumeric_chars)
-    for i in range(pwd_length)]
-    return(''.join(random_chars))
+        open_port(port)
+
+
+#------------------------------------------------------------------------------
+# update_sysctl: create a sysctl.conf file from YAML-formatted 'sysctl' config
+#------------------------------------------------------------------------------
+def update_sysctl(config_data):
+    sysctl_dict = yaml.load(config_data.get("sysctl", "{}"))
+    if sysctl_dict:
+        sysctl_file = open("/etc/sysctl.d/50-haproxy.conf", "w")
+        for key in sysctl_dict:
+            sysctl_file.write("{}={}\n".format(key, sysctl_dict[key]))
+        sysctl_file.close()
+        subprocess.call(["sysctl", "-p", "/etc/sysctl.d/50-haproxy.conf"])
 
 
 #------------------------------------------------------------------------------
@@ -271,22 +241,40 @@
                          service_port=None, service_options=None,
                          server_entries=None):
     if service_name is None or service_ip is None or service_port is None:
-        return(None)
+        return None
+    fe_options = []
+    be_options = []
+    if service_options is not None:
+        # Filter provided service options into frontend-only and backend-only.
+        results = izip(
+            (fe_options, be_options),
+            (True, False),
+            tee((o, any(map(o.strip().startswith,
+                            frontend_only_options)))
+                for o in service_options))
+        for out, cond, result in results:
+            out.extend(option for option, match in result if match is cond)
     service_config = []
-    service_config.append("listen %s %s:%s" %
-    (service_name, service_ip, service_port))
-    if service_options is not None:
-        for service_option in service_options:
-            service_config.append("    %s" % service_option.strip())
-    if server_entries is not None and isinstance(server_entries, list):
-        for (server_name, server_ip, server_port, server_options) \
-        in server_entries:
+    unit_name = os.environ["JUJU_UNIT_NAME"].replace("/", "-")
+    service_config.append("frontend %s-%s" % (unit_name, service_port))
+    service_config.append("    bind %s:%s" %
+                          (service_ip, service_port))
+    service_config.append("    default_backend %s" % (service_name,))
+    service_config.extend("    %s" % service_option.strip()
+                          for service_option in fe_options)
+    service_config.append("")
+    service_config.append("backend %s" % (service_name,))
+    service_config.extend("    %s" % service_option.strip()
+                          for service_option in be_options)
+    if isinstance(server_entries, (list, tuple)):
+        for (server_name, server_ip, server_port,
+             server_options) in server_entries:
             server_line = "    server %s %s:%s" % \
-            (server_name, server_ip, server_port)
+                (server_name, server_ip, server_port)
             if server_options is not None:
-                server_line += " %s" % server_options
+                server_line += " %s" % " ".join(server_options)
             service_config.append(server_line)
-    return('\n'.join(service_config))
+    return '\n'.join(service_config)
 
 
 #------------------------------------------------------------------------------
@@ -296,216 +284,234 @@
 def create_monitoring_stanza(service_name="haproxy_monitoring"):
     config_data = config_get()
     if config_data['enable_monitoring'] is False:
-        return(None)
+        return None
     monitoring_password = get_monitoring_password()
     if config_data['monitoring_password'] != "changeme":
         monitoring_password = config_data['monitoring_password']
-    elif monitoring_password is None and \
-    config_data['monitoring_password'] == "changeme":
-        monitoring_password = pwgen()
+    elif (monitoring_password is None and
+          config_data['monitoring_password'] == "changeme"):
+        monitoring_password = pwgen(length=20)
     monitoring_config = []
     monitoring_config.append("mode http")
     monitoring_config.append("acl allowed_cidr src %s" %
-    config_data['monitoring_allowed_cidr'])
+                             config_data['monitoring_allowed_cidr'])
     monitoring_config.append("block unless allowed_cidr")
     monitoring_config.append("stats enable")
     monitoring_config.append("stats uri /")
     monitoring_config.append("stats realm Haproxy\ Statistics")
     monitoring_config.append("stats auth %s:%s" %
-    (config_data['monitoring_username'], monitoring_password))
+                             (config_data['monitoring_username'],
+                              monitoring_password))
     monitoring_config.append("stats refresh %d" %
-    config_data['monitoring_stats_refresh'])
-    return(create_listen_stanza(service_name,
+                             config_data['monitoring_stats_refresh'])
+    return create_listen_stanza(service_name,
                                 "0.0.0.0",
                                 config_data['monitoring_port'],
-                                monitoring_config))
-
-def get_host_port(services_list):
-    """
-    Given a services list and global juju information, get a host
-    and port for this system.
-    """
-    host = services_list[0]["service_host"]
-    port = int(services_list[0]["service_port"])
-    return (host, port)
-
+                                monitoring_config)
+
+
+#------------------------------------------------------------------------------
+# get_config_services:  Convenience function that returns a mapping containing
+#                       all of the services configuration
+#------------------------------------------------------------------------------
 def get_config_services():
-    """
-    Return dict of all services in the configuration, and in the relation
-    where appropriate.  If a relation contains a "services" key, read
-    it in as yaml as is the case with the configuration. Set the host and
-    port for any relation initiated service entry as those items cannot be
-    known by the other side of the relation. In the case of a
-    proxy configuration found, ensure the forward for option is set.
-    """
     config_data = config_get()
-    config_services_list = yaml.load(config_data['services'])
-    (host, port) = get_host_port(config_services_list)
-    all_relations = relation_get_all("reverseproxy")
-    services_list = []
-    if hasattr(all_relations, "iteritems"):
-        for relid, reldata in all_relations.iteritems():
-            for unit, relation_info in reldata.iteritems():
-                if relation_info.has_key("services"):
-                    rservices = yaml.load(relation_info["services"])
-                    for r in rservices:
-                        r["service_host"] = host
-                        r["service_port"] = port
-                        port += 1
-                    services_list.extend(rservices)
-    if len(services_list) == 0:
-        services_list = config_services_list
-    return(services_list)
+    services = {}
+    for service in yaml.safe_load(config_data['services']):
+        service_name = service["service_name"]
+        if not services:
+            # 'None' is used as a marker for the first service defined, which
+            # is used as the default service if a proxied server doesn't
+            # specify which service it is bound to.
+            services[None] = {"service_name": service_name}
+        if is_proxy(service_name) and ("option forwardfor" not in
+                                       service["service_options"]):
+            service["service_options"].append("option forwardfor")
+
+        if isinstance(service["server_options"], basestring):
+            service["server_options"] = service["server_options"].split()
+
+        services[service_name] = service
+
+    return services
 
 
 #------------------------------------------------------------------------------
 # get_config_service:   Convenience function that returns a dictionary
-#                       of the configuration of a given services configuration
+#                       of the configuration of a given service's configuration
 #------------------------------------------------------------------------------
 def get_config_service(service_name=None):
-    services_list = get_config_services()
-    for service_item in services_list:
-        if service_item['service_name'] == service_name:
-            return(service_item)
-    return(None)
-
-
-def relation_get_all(relation_name):
-    """
-    Iterate through all relations, and return large data structure with the
-    relation data set:
-
-    @param relation_name: The name of the relation to check
-
-    Returns:
-
-        relation_id:
-            unit:
-                key: value
-                key2: value
-    """
-    result = {}
-    try:
-        relids = subprocess.Popen(
-                ['relation-ids', relation_name], stdout=subprocess.PIPE)
-        for relid in [x.strip() for x in relids.stdout]:
-            result[relid] = {}
-            for unit in json.loads(
-                subprocess.check_output(
-                    ['relation-list', '--format=json', '-r', relid])):
-                result[relid][unit] = relation_get(None, unit, relid)
-        return result
-    except Exception, e:
-        subprocess.call(['juju-log', str(e)])
-
-def get_services_dict():
-    """
-    Transform the services list into a dict for easier comprehension,
-    and to ensure that we have only one entry per service type.  If multiple
-    relations specify the same server_name, try to union the servers
-    entries.
-    """
-    services_list = get_config_services()
-    services_dict = {}
-
-    for service_item in services_list:
-        if not hasattr(service_item, "iteritems"):
-            juju_log("Each 'services' entry must be a dict: %s" % service_item)
-            continue;
-        if "service_name" not in service_item:
-            juju_log("Missing 'service_name': %s" % service_item)
-            continue;
-        name = service_item["service_name"]
-        options = service_item["service_options"]
-        if name in services_dict:
-            if "servers" in services_dict[name]:
-                services_dict[name]["servers"].extend(service_item["servers"])
-        else:
-            services_dict[name] = service_item
-        if os.path.exists("%s/%s.is.proxy" % (
-            default_haproxy_service_config_dir, name)):
-            if 'option forwardfor' not in options:
-                options.append("option forwardfor")
-
-    return services_dict
-
-def get_all_services():
-    """
-    Transform a services dict into an "all_services" relation setting expected
-    by apache2.  This is needed to ensure we have the port and hostname setting
-    correct and in the proper format
-    """
-    services = get_services_dict()
-    all_services = []
-    for name in services:
-        s = {"service_name": name,
-             "service_port": services[name]["service_port"]}
-        all_services.append(s)
-    return all_services
+    return get_config_services().get(service_name, None)
+
+
+def is_proxy(service_name):
+    flag_path = os.path.join(default_haproxy_service_config_dir,
+                             "%s.is.proxy" % service_name)
+    return os.path.exists(flag_path)
+
 
 #------------------------------------------------------------------------------
 # create_services:  Function that will create the services configuration
 #                   from the config data and/or relation information
 #------------------------------------------------------------------------------
 def create_services():
-    services_list = get_config_services()
-    services_dict = get_services_dict()
-
-    # service definitions overwrites user specified haproxy file in
-    # a pseudo-template form
-    all_relations = relation_get_all("reverseproxy")
-    for relid, reldata in all_relations.iteritems():
-        for unit, relation_info in reldata.iteritems():
-            if not isinstance(relation_info, dict):
-                sys.exit(0)
-            if "services" in relation_info:
-                juju_log("Relation %s has services override defined" % relid)
-                continue;
-            if "hostname" not in relation_info or "port" not in relation_info:
-                juju_log("Relation %s needs hostname and port defined" % relid)
-                continue;
-            juju_service_name = unit.rpartition('/')[0]
-            # Mandatory switches ( hostname, port )
-            server_name = "%s__%s" % (
-                relation_info['hostname'].replace('.', '_'),
-                relation_info['port'])
-            server_ip = relation_info['hostname']
-            server_port = relation_info['port']
-            # Optional switches ( service_name )
-            if 'service_name' in relation_info:
-                if relation_info['service_name'] in services_dict:
-                    service_name = relation_info['service_name']
-                else:
-                    juju_log("service %s does not exist." % (
-                        relation_info['service_name']))
-                    sys.exit(1)
-            elif juju_service_name + '_service' in services_dict:
-                service_name = juju_service_name + '_service'
+    services_dict = get_config_services()
+    if len(services_dict) == 0:
+        log("No services configured, exiting.")
+        return
+
+    relation_data = relations_of_type("reverseproxy")
+
+    for relation_info in relation_data:
+        unit = relation_info['__unit__']
+        juju_service_name = unit.rpartition('/')[0]
+
+        relation_ok = True
+        for required in ("port", "private-address", "hostname"):
+            if not required in relation_info:
+                log("No %s in relation data for '%s', skipping." %
+                    (required, unit))
+                relation_ok = False
+                break
+
+        if not relation_ok:
+            continue
+
+        # Mandatory switches ( private-address, port )
+        host = relation_info['private-address']
+        port = relation_info['port']
+        server_name = ("%s-%s" % (unit.replace("/", "-"), port))
+
+        # Optional switches ( service_name, sitenames )
+        service_names = set()
+        if 'service_name' in relation_info:
+            if relation_info['service_name'] in services_dict:
+                service_names.add(relation_info['service_name'])
             else:
-                service_name = services_list[0]['service_name']
+                log("Service '%s' does not exist." %
+                    relation_info['service_name'])
+                continue
+
+        if 'sitenames' in relation_info:
+            sitenames = relation_info['sitenames'].split()
+            for sitename in sitenames:
+                if sitename in services_dict:
+                    service_names.add(sitename)
+
+        if juju_service_name + "_service" in services_dict:
+            service_names.add(juju_service_name + "_service")
+
+        if juju_service_name in services_dict:
+            service_names.add(juju_service_name)
+
+        if not service_names:
+            service_names.add(services_dict[None]["service_name"])
+
+        for service_name in service_names:
+            service = services_dict[service_name]
+
             # Add the server entries
-            if not 'servers' in services_dict[service_name]:
-                services_dict[service_name]['servers'] = []
-            services_dict[service_name]['servers'].append((
-                server_name, server_ip, server_port,
-                services_dict[service_name]['server_options']))
-
+            servers = service.setdefault("servers", [])
+            servers.append((server_name, host, port,
+                            services_dict[service_name].get(
+                                'server_options', [])))
+
+    has_servers = False
+    for service_name, service in services_dict.iteritems():
+        if service.get("servers", []):
+            has_servers = True
+
+    if not has_servers:
+        log("No backend servers, exiting.")
+        return
+
+    del services_dict[None]
+    services_dict = apply_peer_config(services_dict)
+    write_service_config(services_dict)
+    return services_dict
+
+
+def apply_peer_config(services_dict):
+    peer_data = relations_of_type("peer")
+
+    peer_services = {}
+    for relation_info in peer_data:
+        unit_name = relation_info["__unit__"]
+        peer_services_data = relation_info.get("all_services")
+        if peer_services_data is None:
+            continue
+        service_data = yaml.safe_load(peer_services_data)
+        for service in service_data:
+            service_name = service["service_name"]
+            if service_name in services_dict:
+                peer_service = peer_services.setdefault(service_name, {})
+                peer_service["service_name"] = service_name
+                peer_service["service_host"] = service["service_host"]
+                peer_service["service_port"] = service["service_port"]
+                peer_service["service_options"] = ["balance leastconn",
+                                                   "mode tcp",
+                                                   "option tcplog"]
+                servers = peer_service.setdefault("servers", [])
+                servers.append((unit_name.replace("/", "-"),
+                                relation_info["private-address"],
+                                service["service_port"] + 1, ["check"]))
+
+    if not peer_services:
+        return services_dict
+
+    unit_name = os.environ["JUJU_UNIT_NAME"].replace("/", "-")
+    private_address = unit_get("private-address")
+    for service_name, peer_service in peer_services.iteritems():
+        original_service = services_dict[service_name]
+
+        # If the original service has timeout settings, copy them over to the
+        # peer service.
+        for option in original_service.get("service_options", ()):
+            if "timeout" in option:
+                peer_service["service_options"].append(option)
+
+        servers = peer_service["servers"]
+        # Add ourselves to the list of servers for the peer listen stanza.
+        servers.append((unit_name, private_address,
+                        original_service["service_port"] + 1,
+                        ["check"]))
+
+        # Make all but the first server in the peer listen stanza a backup
+        # server.
+        servers.sort()
+        for server in servers[1:]:
+            server[3].append("backup")
+
+        # Remap original service port, will now be used by peer listen stanza.
+        original_service["service_port"] += 1
+
+        # Remap original service to a new name, stuff peer listen stanza into
+        # it's place.
+        be_service = service_name + "_be"
+        original_service["service_name"] = be_service
+        services_dict[be_service] = original_service
+        services_dict[service_name] = peer_service
+
+    return services_dict
+
+
+def write_service_config(services_dict):
     # Construct the new haproxy.cfg file
-    for service in services_dict:
-        juju_log("Service: ", service)
-        server_entries = None
-        if 'servers' in services_dict[service]:
-            server_entries = services_dict[service]['servers']
-        service_config_file = "%s/%s.service" % (
-            default_haproxy_service_config_dir,
-            services_dict[service]['service_name'])
-        with open(service_config_file, 'w') as service_config:
-                service_config.write(
-                create_listen_stanza(services_dict[service]['service_name'],
-                                     services_dict[service]['service_host'],
-                                     services_dict[service]['service_port'],
-                                     services_dict[service]['service_options'],
-                                     server_entries))
+    for service_key, service_config in services_dict.items():
+        log("Service: %s" % service_key)
+        server_entries = service_config.get('servers')
+
+        service_name = service_config["service_name"]
+        if not os.path.exists(default_haproxy_service_config_dir):
+            os.mkdir(default_haproxy_service_config_dir, 0600)
+        with open(os.path.join(default_haproxy_service_config_dir,
+                               "%s.service" % service_name), 'w') as config:
+            config.write(create_listen_stanza(
+                service_name,
+                service_config['service_host'],
+                service_config['service_port'],
+                service_config['service_options'],
+                server_entries))
 
 
 #------------------------------------------------------------------------------
@@ -516,17 +522,19 @@
     services = ''
     if service_name is not None:
         if os.path.exists("%s/%s.service" %
-        (default_haproxy_service_config_dir, service_name)):
-            services = open("%s/%s.service" %
-            (default_haproxy_service_config_dir, service_name)).read()
+                          (default_haproxy_service_config_dir, service_name)):
+            with open("%s/%s.service" % (default_haproxy_service_config_dir,
+                                         service_name)) as f:
+                services = f.read()
         else:
             services = None
     else:
         for service in glob.glob("%s/*.service" %
-            default_haproxy_service_config_dir):
-            services += open(service).read()
-            services += "\n\n"
-    return(services)
+                                 default_haproxy_service_config_dir):
+            with open(service) as f:
+                services += f.read()
+                services += "\n\n"
+    return services
 
 
 #------------------------------------------------------------------------------
@@ -537,24 +545,24 @@
 #------------------------------------------------------------------------------
 def remove_services(service_name=None):
     if service_name is not None:
-        if os.path.exists("%s/%s.service" %
-        (default_haproxy_service_config_dir, service_name)):
+        path = "%s/%s.service" % (default_haproxy_service_config_dir,
+                                  service_name)
+        if os.path.exists(path):
             try:
-                os.remove("%s/%s.service" %
-                (default_haproxy_service_config_dir, service_name))
-                return(True)
+                os.remove(path)
             except Exception, e:
-                subprocess.call(['juju-log', str(e)])
-                return(False)
+                log(str(e))
+                return False
+        return True
     else:
         for service in glob.glob("%s/*.service" %
-        default_haproxy_service_config_dir):
+                                 default_haproxy_service_config_dir):
             try:
                 os.remove(service)
             except Exception, e:
-                subprocess.call(['juju-log', str(e)])
+                log(str(e))
                 pass
-        return(True)
+        return True
 
 
 #------------------------------------------------------------------------------
@@ -567,27 +575,18 @@
 #                            optional arguments
 #------------------------------------------------------------------------------
 def construct_haproxy_config(haproxy_globals=None,
-                         haproxy_defaults=None,
-                         haproxy_monitoring=None,
-                         haproxy_services=None):
-    if haproxy_globals is None or \
-       haproxy_defaults is None:
-        return(None)
+                             haproxy_defaults=None,
+                             haproxy_monitoring=None,
+                             haproxy_services=None):
+    if None in (haproxy_globals, haproxy_defaults):
+        return
     with open(default_haproxy_config, 'w') as haproxy_config:
-        haproxy_config.write(haproxy_globals)
-        haproxy_config.write("\n")
-        haproxy_config.write("\n")
-        haproxy_config.write(haproxy_defaults)
-        haproxy_config.write("\n")
-        haproxy_config.write("\n")
-        if haproxy_monitoring is not None:
-            haproxy_config.write(haproxy_monitoring)
-            haproxy_config.write("\n")
-            haproxy_config.write("\n")
-        if haproxy_services is not None:
-            haproxy_config.write(haproxy_services)
-            haproxy_config.write("\n")
-            haproxy_config.write("\n")
+        config_string = ''
+        for config in (haproxy_globals, haproxy_defaults, haproxy_monitoring,
+                       haproxy_services):
+            if config is not None:
+                config_string += config + '\n\n'
+        haproxy_config.write(config_string)
 
 
 #------------------------------------------------------------------------------
@@ -595,50 +594,37 @@
 #                   the haproxy service
 #------------------------------------------------------------------------------
 def service_haproxy(action=None, haproxy_config=default_haproxy_config):
-    if action is None or haproxy_config is None:
-        return(None)
+    if None in (action, haproxy_config):
+        return None
     elif action == "check":
-        retVal = subprocess.call(
-        ['/usr/sbin/haproxy', '-f', haproxy_config, '-c'])
-        if retVal == 1:
-            return(False)
-        elif retVal == 0:
-            return(True)
-        else:
-            return(False)
+        command = ['/usr/sbin/haproxy', '-f', haproxy_config, '-c']
     else:
-        retVal = subprocess.call(['service', 'haproxy', action])
-        if retVal == 0:
-            return(True)
-        else:
-            return(False)
-
-def website_notify():
-    """
-    Notify any webiste relations of any configuration changes.
-    """
-    juju_log("Notifying all website relations of change")
-    all_relations = relation_get_all("website")
-    if hasattr(all_relations, "iteritems"):
-        for relid, reldata in all_relations.iteritems():
-            relation_set(["time=%s" % time.time()], relation_id=relid)
+        command = ['service', 'haproxy', action]
+    return_value = subprocess.call(command)
+    return return_value == 0
 
 
 ###############################################################################
 # 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_haproxy_service_config_dir):
         os.mkdir(default_haproxy_service_config_dir, 0600)
-    return ((apt_get_install("haproxy") == enable_haproxy()) is True)
+
+    apt_install('haproxy', fatal=True)
+    ensure_package_status(service_affecting_packages,
+                          config_get('package_status'))
+    enable_haproxy()
 
 
 def config_changed():
     config_data = config_get()
-    current_service_ports = get_service_ports()
+
+    ensure_package_status(service_affecting_packages,
+                          config_data['package_status'])
+
+    old_service_ports = get_service_ports()
+    old_stanzas = get_listen_stanzas()
     haproxy_globals = create_haproxy_globals()
     haproxy_defaults = create_haproxy_defaults()
     if config_data['enable_monitoring'] is True:
@@ -648,105 +634,177 @@
     remove_services()
     create_services()
     haproxy_services = load_services()
+    update_sysctl(config_data)
     construct_haproxy_config(haproxy_globals,
                              haproxy_defaults,
                              haproxy_monitoring,
                              haproxy_services)
 
     if service_haproxy("check"):
-        updated_service_ports = get_service_ports()
-        update_service_ports(current_service_ports, updated_service_ports)
+        update_service_ports(old_service_ports, get_service_ports())
         service_haproxy("reload")
+        if not (get_listen_stanzas() == old_stanzas):
+            notify_website()
+            notify_peer()
+    else:
+        # XXX Ideally the config should be restored to a working state if the
+        # check fails, otherwise an inadvertent reload will cause the service
+        # to be broken.
+        log("HAProxy configuration check failed, exiting.")
+        sys.exit(1)
 
 
 def start_hook():
     if service_haproxy("status"):
-        return(service_haproxy("restart"))
+        return service_haproxy("restart")
     else:
-        return(service_haproxy("start"))
+        return service_haproxy("start")
 
 
 def stop_hook():
     if service_haproxy("status"):
-        return(service_haproxy("stop"))
+        return service_haproxy("stop")
 
 
 def reverseproxy_interface(hook_name=None):
     if hook_name is None:
-        return(None)
-    elif hook_name == "changed":
-        config_changed()
-        website_notify()
-    elif hook_name=="departed":
-        config_changed()
-        website_notify()
+        return None
+    if hook_name in ("changed", "departed"):
+        config_changed()
+
 
 def website_interface(hook_name=None):
     if hook_name is None:
-        return(None)
+        return None
+    # Notify website relation but only for the current relation in context.
+    notify_website(changed=hook_name == "changed",
+                   relation_ids=(relation_id(),))
+
+
+def get_hostname(host=None):
+    my_host = socket.gethostname()
+    if host is None or host == "0.0.0.0":
+        # If the listen ip has been set to 0.0.0.0 then pass back the hostname
+        return socket.getfqdn(my_host)
+    elif host == "localhost":
+        # If the fqdn lookup has returned localhost (lxc setups) then return
+        # hostname
+        return my_host
+    return host
+
+
+def notify_relation(relation, changed=False, relation_ids=None):
+    config_data = config_get()
+    default_host = get_hostname()
     default_port = 80
-    relation_data = relation_get()
-
-    # If a specfic service has been asked for then return the ip:port for
-    # that service, else pass back the default
-    if 'service_name' in relation_data:
-        service_name = relation_data['service_name']
-        requestedservice = get_config_service(service_name)
-        my_host = requestedservice['service_host']
-        my_port = requestedservice['service_port']
-    else:
-        my_host = socket.getfqdn(socket.gethostname())
-        my_port = default_port
-
-    # If the listen ip has been set to 0.0.0.0 then pass back the hostname
-    if my_host == "0.0.0.0":
-        my_host = socket.getfqdn(socket.gethostname())
-
-    # If the fqdn lookup has returned localhost (lxc setups) then return
-    # hostname
-    if my_host == "localhost":
-        my_host = socket.gethostname()
-    subprocess.call(
-            ['relation-set', 'port=%d' % my_port, 'hostname=%s' % my_host,
-             'all_services=%s' % yaml.safe_dump(get_all_services())])
-    if hook_name == "changed":
-        if 'is-proxy' in relation_data:
-            service_name = "%s__%d" % \
-            (relation_data['hostname'], relation_data['port'])
-            open("%s/%s.is.proxy" %
-            (default_haproxy_service_config_dir, service_name), 'a').close()
+
+    for rid in relation_ids or get_relation_ids(relation):
+        service_names = set()
+        if rid is None:
+            rid = relation_id()
+        for relation_data in relations_for_id(rid):
+            if 'service_name' in relation_data:
+                service_names.add(relation_data['service_name'])
+
+            if changed:
+                if 'is-proxy' in relation_data:
+                    remote_service = ("%s__%d" % (relation_data['hostname'],
+                                                  relation_data['port']))
+                    open("%s/%s.is.proxy" % (
+                        default_haproxy_service_config_dir,
+                        remote_service), 'a').close()
+
+        service_name = None
+        if len(service_names) == 1:
+            service_name = service_names.pop()
+        elif len(service_names) > 1:
+            log("Remote units requested than a single service name."
+                "Falling back to default host/port.")
+
+        if service_name is not None:
+            # If a specfic service has been asked for then return the ip:port
+            # for that service, else pass back the default
+            requestedservice = get_config_service(service_name)
+            my_host = get_hostname(requestedservice['service_host'])
+            my_port = requestedservice['service_port']
+        else:
+            my_host = default_host
+            my_port = default_port
+
+        relation_set(relation_id=rid, port=str(my_port),
+                     hostname=my_host,
+                     all_services=config_data['services'])
+
+
+def notify_website(changed=False, relation_ids=None):
+    notify_relation("website", changed=changed, relation_ids=relation_ids)
+
+
+def notify_peer(changed=False, relation_ids=None):
+    notify_relation("peer", changed=changed, relation_ids=relation_ids)
+
+
+def install_nrpe_scripts():
+    scripts_src = os.path.join(os.environ["CHARM_DIR"], "files",
+                               "nrpe")
+    scripts_dst = "/usr/lib/nagios/plugins"
+    if not os.path.exists(scripts_dst):
+        os.makedirs(scripts_dst)
+    for fname in glob.glob(os.path.join(scripts_src, "*.sh")):
+        shutil.copy2(fname,
+                     os.path.join(scripts_dst, os.path.basename(fname)))
+
 
 def update_nrpe_config():
+    install_nrpe_scripts()
     nrpe_compat = nrpe.NRPE()
-    nrpe_compat.add_check('haproxy','Check HAProxy', 'check_haproxy.sh')
-    nrpe_compat.add_check('haproxy_queue','Check HAProxy queue depth', 'check_haproxy_queue_depth.sh')
+    nrpe_compat.add_check('haproxy', 'Check HAProxy', 'check_haproxy.sh')
+    nrpe_compat.add_check('haproxy_queue', 'Check HAProxy queue depth',
+                          'check_haproxy_queue_depth.sh')
     nrpe_compat.write()
 
+
 ###############################################################################
 # Main section
 ###############################################################################
-if __name__ == "__main__":
-    if HOOK_NAME == "install":
+
+
+def main(hook_name):
+    if hook_name == "install":
         install_hook()
-    elif HOOK_NAME == "config-changed":
+    elif hook_name in ("config-changed", "upgrade-charm"):
         config_changed()
         update_nrpe_config()
-    elif HOOK_NAME == "start":
+    elif hook_name == "start":
         start_hook()
-    elif HOOK_NAME == "stop":
+    elif hook_name == "stop":
         stop_hook()
-    elif HOOK_NAME == "reverseproxy-relation-broken":
+    elif hook_name == "reverseproxy-relation-broken":
         config_changed()
-    elif HOOK_NAME == "reverseproxy-relation-changed":
+    elif hook_name == "reverseproxy-relation-changed":
         reverseproxy_interface("changed")
-    elif HOOK_NAME == "reverseproxy-relation-departed":
+    elif hook_name == "reverseproxy-relation-departed":
         reverseproxy_interface("departed")
-    elif HOOK_NAME == "website-relation-joined":
+    elif hook_name == "website-relation-joined":
         website_interface("joined")
-    elif HOOK_NAME == "website-relation-changed":
+    elif hook_name == "website-relation-changed":
         website_interface("changed")
-    elif HOOK_NAME == "nrpe-external-master-relation-changed":
+    elif hook_name == "peer-relation-joined":
+        website_interface("joined")
+    elif hook_name == "peer-relation-changed":
+        reverseproxy_interface("changed")
+    elif hook_name in ("nrpe-external-master-relation-joined",
+                       "local-monitors-relation-joined"):
         update_nrpe_config()
     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:34:35 +0000
@@ -0,0 +1,13 @@
+#!/bin/sh
+
+set -eu
+
+apt_get_install() {
+    DEBIAN_FRONTEND=noninteractive apt-get -y -qq -o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold" install $@
+}
+
+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-joined'
=== target is u'./hooks.py'
=== renamed symlink 'hooks/nrpe-external-master-relation-changed' => 'hooks/nrpe-external-master-relation-joined'
=== removed file 'hooks/nrpe.py'
--- hooks/nrpe.py	2012-12-21 11:08:58 +0000
+++ hooks/nrpe.py	1970-01-01 00:00:00 +0000
@@ -1,170 +0,0 @@
-import json
-import subprocess
-import pwd
-import grp
-import os
-import re
-import shlex
-
-# This module adds compatibility with the nrpe_external_master
-# subordinate charm. To use it in your charm:
-# 
-# 1. Update metadata.yaml
-#
-#   provides:
-#     (...)
-#     nrpe-external-master:
-#       interface: nrpe-external-master
-#           scope: container
-# 
-# 2. Add the following to config.yaml
-#
-#    nagios_context:
-#      default: "juju"
-#      type: string
-#      description: |
-#        Used by the nrpe-external-master subordinate charm.
-#        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:
-#
-#    import nrpe
-#    (...)
-#    def update_nrpe_config():
-#        nrpe_compat = NRPE("myservice")
-#        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()
-
-class ConfigurationError(Exception):
-    '''An error interacting with the Juju config'''
-    pass
-def config_get(scope=None):
-    '''Return the Juju config as a dictionary'''
-    try:
-        config_cmd_line = ['config-get']
-        if scope is not None:
-            config_cmd_line.append(scope)
-        config_cmd_line.append('--format=json')
-        return json.loads(subprocess.check_output(config_cmd_line))
-    except (ValueError, OSError, subprocess.CalledProcessError) as error:
-        subprocess.call(['juju-log', str(error)])
-        raise ConfigurationError(str(error))
-
-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!check_{shortname}
-    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.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',
-        )
-        command = shlex.split(check_cmd)
-        for path in search_path:
-            if os.path.exists(os.path.join(path,command[0])):
-                return os.path.join(path, command[0]) + " " + " ".join(command[1:])
-        subprocess.call(['juju-log', 'Check command not found: {}'.format(command[0])])
-        return ''
-
-    def write(self, nagios_context, hostname):
-        for f in os.listdir(NRPE.nagios_exportdir):
-            if re.search('.*check_{}.cfg'.format(self.shortname), 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,
-        }
-        nrpe_service_text = Check.service_template.format(**templ_vars)
-        nrpe_service_file = '{}/service__{}_check_{}.cfg'.format(
-            NRPE.nagios_exportdir, hostname, self.shortname)
-        with open(nrpe_service_file, 'w') as nrpe_service_config:
-            nrpe_service_config.write(str(nrpe_service_text))
-
-        nrpe_check_file = '/etc/nagios/nrpe.d/check_{}.cfg'.format(self.shortname)
-        with open(nrpe_check_file, 'w') as nrpe_check_config:
-            nrpe_check_config.write("# check {}\n".format(self.shortname))
-            nrpe_check_config.write("command[check_{}]={}\n".format(
-                self.shortname, self.check_cmd))
-
-    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_get()
-        self.nagios_context = self.config['nagios_context']
-        self.unit_name = os.environ['JUJU_UNIT_NAME'].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:
-            subprocess.call(['juju-log', "Nagios user not set up, nrpe checks not updated"])
-            return
-
-        if not os.path.exists(NRPE.nagios_exportdir):
-            subprocess.call(['juju-log', 'Exiting as {} is not accessible'.format(NRPE.nagios_exportdir)])
-            return
-
-        if not os.path.exists(NRPE.nagios_logdir):
-            os.mkdir(NRPE.nagios_logdir)
-            os.chown(NRPE.nagios_logdir, nagios_uid, nagios_gid)
-
-        for nrpecheck in self.checks:
-            nrpecheck.write(self.nagios_context, self.hostname)
-
-        if os.path.isfile('/etc/init.d/nagios-nrpe-server'):
-            subprocess.call(['service', 'nagios-nrpe-server', 'reload'])

=== added symlink 'hooks/peer-relation-changed'
=== target is u'./hooks.py'
=== added symlink 'hooks/peer-relation-joined'
=== target is u'./hooks.py'
=== removed file 'hooks/test_hooks.py'
--- hooks/test_hooks.py	2013-02-14 21:35:47 +0000
+++ hooks/test_hooks.py	1970-01-01 00:00:00 +0000
@@ -1,263 +0,0 @@
-import hooks
-import yaml
-from textwrap import dedent
-from mocker import MockerTestCase, ARGS
-
-class JujuHookTest(MockerTestCase):
-
-    def setUp(self):
-        self.config_services = [{
-            "service_name": "haproxy_test",
-            "service_host": "0.0.0.0",
-            "service_port": "88",
-            "service_options": ["balance leastconn"],
-            "server_options": "maxconn 25"}]
-        self.config_services_extended = [
-            {"service_name": "unit_service",
-            "service_host": "supplied-hostname",
-            "service_port": "999",
-            "service_options": ["balance leastconn"],
-            "server_options": "maxconn 99"}]
-        self.relation_services = [
-            {"service_name": "foo_svc",
-            "service_options": ["balance leastconn"],
-            "servers": [("A", "hA", "1", "oA1 oA2")]},
-            {"service_name": "bar_svc",
-            "service_options": ["balance leastconn"],
-            "servers": [
-                ("A", "hA", "1", "oA1 oA2"), ("B", "hB", "2", "oB1 oB2")]}]
-        self.relation_services2 = [
-            {"service_name": "foo_svc",
-            "service_options": ["balance leastconn"],
-            "servers": [("A2", "hA2", "12", "oA12 oA22")]}]
-        hooks.default_haproxy_config_dir = self.makeDir()
-        hooks.default_haproxy_config = self.makeFile()
-        hooks.default_haproxy_service_config_dir = self.makeDir()
-        obj = self.mocker.replace("hooks.juju_log")
-        obj(ARGS)
-        self.mocker.count(0, None)
-        obj = self.mocker.replace("hooks.unit_get")
-        obj("public-address")
-        self.mocker.result("test-host.example.com")
-        self.mocker.count(0, None)
-        self.maxDiff = None
-    
-    def _expect_config_get(self, **kwargs):
-        result = {
-            "default_timeouts": "queue 1000, connect 1000, client 1000, server 1000",
-            "global_log": "127.0.0.1 local0, 127.0.0.1 local1 notice",
-            "global_spread_checks": 0,
-            "monitoring_allowed_cidr": "127.0.0.1/32",
-            "monitoring_username": "haproxy",
-            "default_log": "global",
-            "global_group": "haproxy",
-            "monitoring_stats_refresh": 3,
-            "default_retries": 3,
-            "services": yaml.dump(self.config_services),
-            "global_maxconn": 4096,
-            "global_user": "haproxy",
-            "default_options": "httplog, dontlognull",
-            "monitoring_port": 10000,
-            "global_debug": False,
-            "nagios_context": "juju",
-            "global_quiet": False,
-            "enable_monitoring": False,
-            "monitoring_password": "changeme",
-            "default_mode": "http"}
-        obj = self.mocker.replace("hooks.config_get")
-        obj()
-        result.update(kwargs)
-        self.mocker.result(result)
-        self.mocker.count(1, None)
-
-    def _expect_relation_get_all(self, relation, extra={}):
-        obj = self.mocker.replace("hooks.relation_get_all")
-        obj(relation)
-        relation = {"hostname": "10.0.1.2",
-                    "private-address": "10.0.1.2",
-                    "port": "10000"}
-        relation.update(extra)
-        result = {"1": {"unit/0": relation}}
-        self.mocker.result(result)
-        self.mocker.count(1, None)
-
-    def _expect_relation_get_all_multiple(self, relation_name):
-        obj = self.mocker.replace("hooks.relation_get_all")
-        obj(relation_name)
-        result = {
-                "1": {"unit/0": {
-                    "hostname": "10.0.1.2",
-                    "private-address": "10.0.1.2",
-                    "port": "10000",
-                    "services": yaml.dump(self.relation_services)}},
-                "2": {"unit/1": {
-                    "hostname": "10.0.1.3",
-                    "private-address": "10.0.1.3",
-                    "port": "10001",
-                    "services": yaml.dump(self.relation_services2)}}}
-        self.mocker.result(result)
-        self.mocker.count(1, None)
-
-    def _expect_relation_get_all_with_services(self, relation, extra={}):
-        extra.update({"services": yaml.dump(self.relation_services)})
-        return self._expect_relation_get_all(relation, extra)
-
-    def _expect_relation_get(self):
-        obj = self.mocker.replace("hooks.relation_get")
-        obj()
-        result = {}
-        self.mocker.result(result)
-        self.mocker.count(1, None)
-
-    def test_create_services(self):
-        """
-        Simplest use case, config stanza seeded in config file, server line
-        added through simple relation.  Many servers can join this, but
-        multiple services will not be presented to the outside
-        """
-        self._expect_config_get()
-        self._expect_relation_get_all("reverseproxy")
-        self.mocker.replay()
-        hooks.create_services()
-        services = hooks.load_services()
-        stanza = """\
-            listen haproxy_test 0.0.0.0:88
-                balance leastconn
-                server 10_0_1_2__10000 10.0.1.2:10000 maxconn 25
-
-        """
-        self.assertEquals(services, dedent(stanza))
-
-    def test_create_services_extended_with_relation(self):
-        """
-        This case covers specifying an up-front services file to ha-proxy
-        in the config.  The relation then specifies a singular hostname, 
-        port and server_options setting which is filled into the appropriate
-        haproxy stanza based on multiple criteria.
-        """
-        self._expect_config_get(
-                services=yaml.dump(self.config_services_extended))
-        self._expect_relation_get_all("reverseproxy")
-        self.mocker.replay()
-        hooks.create_services()
-        services = hooks.load_services()
-        stanza = """\
-            listen unit_service supplied-hostname:999
-                balance leastconn
-                server 10_0_1_2__10000 10.0.1.2:10000 maxconn 99
-
-        """
-        self.assertEquals(dedent(stanza), services)
-
-    def test_create_services_pure_relation(self):
-        """
-        In this case, the relation is in control of the haproxy config file.
-        Each relation chooses what server it creates in the haproxy file, it
-        relies on the haproxy service only for the hostname and front-end port.
-        Each member of the relation will put a backend server entry under in
-        the desired stanza.  Each realtion can in fact supply multiple
-        entries from the same juju service unit if desired.
-        """
-        self._expect_config_get()
-        self._expect_relation_get_all_with_services("reverseproxy")
-        self.mocker.replay()
-        hooks.create_services()
-        services = hooks.load_services()
-        stanza = """\
-            listen foo_svc 0.0.0.0:88
-                balance leastconn
-                server A hA:1 oA1 oA2
-        """
-        self.assertIn(dedent(stanza), services)
-        stanza = """\
-            listen bar_svc 0.0.0.0:89
-                balance leastconn
-                server A hA:1 oA1 oA2
-                server B hB:2 oB1 oB2
-        """
-        self.assertIn(dedent(stanza), services)
-
-    def test_create_services_pure_relation_multiple(self):
-        """
-        This is much liek the pure_relation case, where the relation specifies
-        a "services" override.  However, in this case we have multiple relations
-        that partially override each other.  We expect that the created haproxy
-        conf file will combine things appropriately.
-        """
-        self._expect_config_get()
-        self._expect_relation_get_all_multiple("reverseproxy")
-        self.mocker.replay()
-        hooks.create_services()
-        result = hooks.load_services()
-        stanza = """\
-            listen foo_svc 0.0.0.0:88
-                balance leastconn
-                server A hA:1 oA1 oA2
-                server A2 hA2:12 oA12 oA22
-        """
-        self.assertIn(dedent(stanza), result)
-        stanza = """\
-            listen bar_svc 0.0.0.0:89
-                balance leastconn
-                server A hA:1 oA1 oA2
-                server B hB:2 oB1 oB2
-        """
-        self.assertIn(dedent(stanza), result)
-
-    def test_get_config_services_config_only(self):
-        """
-        Attempting to catch the case where a relation is not joined yet
-        """
-        self._expect_config_get()
-        obj = self.mocker.replace("hooks.relation_get_all")
-        obj("reverseproxy")
-        self.mocker.result(None)
-        self.mocker.replay()
-        result = hooks.get_config_services()
-        self.assertEquals(result, self.config_services)
-
-    def test_get_config_services_relation_no_services(self):
-        """
-        If the config specifies services and the realtion does not, just the
-        config services should come through.
-        """
-        self._expect_config_get()
-        self._expect_relation_get_all("reverseproxy")
-        self.mocker.replay()
-        result = hooks.get_config_services()
-        self.assertEquals(result, self.config_services)
-
-    def test_get_config_services_relation_with_services(self):
-        """
-        Testing with both the config and relation providing services should
-        yield the just the relation
-        """
-        self._expect_config_get()
-        self._expect_relation_get_all_with_services("reverseproxy")
-        self.mocker.replay()
-        result = hooks.get_config_services()
-        # Just test "servers" since hostname and port and maybe other keys
-        # will be added by the hook
-        self.assertEquals(result[0]["servers"],
-                self.relation_services[0]["servers"])
-
-    def test_config_generation_indempotent(self):
-        self._expect_config_get()
-        self._expect_relation_get_all_multiple("reverseproxy")
-        self.mocker.replay()
-
-        # Test that we generate the same haproxy.conf file each time
-        hooks.create_services()
-        result1 = hooks.load_services()
-        hooks.create_services()
-        result2 = hooks.load_services()
-        self.assertEqual(result1, result2)
-
-    def test_get_all_services(self):
-        self._expect_config_get()
-        self._expect_relation_get_all_multiple("reverseproxy")
-        self.mocker.replay()
-        baseline = [{"service_name": "foo_svc", "service_port": 88},
-                    {"service_name": "bar_svc", "service_port": 89}]
-        services = hooks.get_all_services()
-        self.assertEqual(baseline, services)

=== added directory 'hooks/tests'
=== added file 'hooks/tests/__init__.py'
=== added file 'hooks/tests/test_config_changed_hooks.py'
--- hooks/tests/test_config_changed_hooks.py	1970-01-01 00:00:00 +0000
+++ hooks/tests/test_config_changed_hooks.py	2013-10-10 22:34:35 +0000
@@ -0,0 +1,120 @@
+import sys
+
+from testtools import TestCase
+from mock import patch
+
+import hooks
+from utils_for_tests import patch_open
+
+
+class ConfigChangedTest(TestCase):
+
+    def setUp(self):
+        super(ConfigChangedTest, self).setUp()
+        self.config_get = self.patch_hook("config_get")
+        self.get_service_ports = self.patch_hook("get_service_ports")
+        self.get_listen_stanzas = self.patch_hook("get_listen_stanzas")
+        self.create_haproxy_globals = self.patch_hook(
+            "create_haproxy_globals")
+        self.create_haproxy_defaults = self.patch_hook(
+            "create_haproxy_defaults")
+        self.remove_services = self.patch_hook("remove_services")
+        self.create_services = self.patch_hook("create_services")
+        self.load_services = self.patch_hook("load_services")
+        self.construct_haproxy_config = self.patch_hook(
+            "construct_haproxy_config")
+        self.service_haproxy = self.patch_hook(
+            "service_haproxy")
+        self.update_sysctl = self.patch_hook(
+            "update_sysctl")
+        self.notify_website = self.patch_hook("notify_website")
+        self.notify_peer = self.patch_hook("notify_peer")
+        self.log = self.patch_hook("log")
+        sys_exit = patch.object(sys, "exit")
+        self.sys_exit = sys_exit.start()
+        self.addCleanup(sys_exit.stop)
+
+    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_config_changed_notify_website_changed_stanzas(self):
+        self.service_haproxy.return_value = True
+        self.get_listen_stanzas.side_effect = (
+            (('foo.internal', '1.2.3.4', 123),),
+            (('foo.internal', '1.2.3.4', 123),
+             ('bar.internal', '1.2.3.5', 234),))
+
+        hooks.config_changed()
+
+        self.notify_website.assert_called_once_with()
+        self.notify_peer.assert_called_once_with()
+
+    def test_config_changed_no_notify_website_not_changed(self):
+        self.service_haproxy.return_value = True
+        self.get_listen_stanzas.side_effect = (
+            (('foo.internal', '1.2.3.4', 123),),
+            (('foo.internal', '1.2.3.4', 123),))
+
+        hooks.config_changed()
+
+        self.notify_website.assert_not_called()
+        self.notify_peer.assert_not_called()
+
+    def test_config_changed_no_notify_website_failed_check(self):
+        self.service_haproxy.return_value = False
+        self.get_listen_stanzas.side_effect = (
+            (('foo.internal', '1.2.3.4', 123),),
+            (('foo.internal', '1.2.3.4', 123),
+             ('bar.internal', '1.2.3.5', 234),))
+
+        hooks.config_changed()
+
+        self.notify_website.assert_not_called()
+        self.notify_peer.assert_not_called()
+        self.log.assert_called_once_with(
+            "HAProxy configuration check failed, exiting.")
+        self.sys_exit.assert_called_once_with(1)
+
+
+class HelpersTest(TestCase):
+    def test_constructs_haproxy_config(self):
+        with patch_open() as (mock_open, mock_file):
+            hooks.construct_haproxy_config('foo-globals', 'foo-defaults',
+                                           'foo-monitoring', 'foo-services')
+
+            mock_file.write.assert_called_with(
+                'foo-globals\n\n'
+                'foo-defaults\n\n'
+                'foo-monitoring\n\n'
+                'foo-services\n\n'
+            )
+            mock_open.assert_called_with(hooks.default_haproxy_config, 'w')
+
+    def test_constructs_nothing_if_globals_is_none(self):
+        with patch_open() as (mock_open, mock_file):
+            hooks.construct_haproxy_config(None, 'foo-defaults',
+                                           'foo-monitoring', 'foo-services')
+
+            self.assertFalse(mock_open.called)
+            self.assertFalse(mock_file.called)
+
+    def test_constructs_nothing_if_defaults_is_none(self):
+        with patch_open() as (mock_open, mock_file):
+            hooks.construct_haproxy_config('foo-globals', None,
+                                           'foo-monitoring', 'foo-services')
+
+            self.assertFalse(mock_open.called)
+            self.assertFalse(mock_file.called)
+
+    def test_constructs_haproxy_config_without_optionals(self):
+        with patch_open() as (mock_open, mock_file):
+            hooks.construct_haproxy_config('foo-globals', 'foo-defaults')
+
+            mock_file.write.assert_called_with(
+                'foo-globals\n\n'
+                'foo-defaults\n\n'
+            )
+            mock_open.assert_called_with(hooks.default_haproxy_config, 'w')

=== added file 'hooks/tests/test_helpers.py'
--- hooks/tests/test_helpers.py	1970-01-01 00:00:00 +0000
+++ hooks/tests/test_helpers.py	2013-10-10 22:34:35 +0000
@@ -0,0 +1,745 @@
+import os
+
+from contextlib import contextmanager
+from StringIO import StringIO
+
+from testtools import TestCase
+from mock import patch, call, MagicMock
+
+import hooks
+from utils_for_tests import patch_open
+
+
+class HelpersTest(TestCase):
+
+    @patch('hooks.config_get')
+    def test_creates_haproxy_globals(self, config_get):
+        config_get.return_value = {
+            'global_log': 'foo-log, bar-log',
+            'global_maxconn': 123,
+            'global_user': 'foo-user',
+            'global_group': 'foo-group',
+            'global_spread_checks': 234,
+            'global_debug': False,
+            'global_quiet': False,
+        }
+        result = hooks.create_haproxy_globals()
+
+        expected = '\n'.join([
+            'global',
+            '    log foo-log',
+            '    log bar-log',
+            '    maxconn 123',
+            '    user foo-user',
+            '    group foo-group',
+            '    spread-checks 234',
+        ])
+        self.assertEqual(result, expected)
+
+    @patch('hooks.config_get')
+    def test_creates_haproxy_globals_quietly_with_debug(self, config_get):
+        config_get.return_value = {
+            'global_log': 'foo-log, bar-log',
+            'global_maxconn': 123,
+            'global_user': 'foo-user',
+            'global_group': 'foo-group',
+            'global_spread_checks': 234,
+            'global_debug': True,
+            'global_quiet': True,
+        }
+        result = hooks.create_haproxy_globals()
+
+        expected = '\n'.join([
+            'global',
+            '    log foo-log',
+            '    log bar-log',
+            '    maxconn 123',
+            '    user foo-user',
+            '    group foo-group',
+            '    debug',
+            '    quiet',
+            '    spread-checks 234',
+        ])
+        self.assertEqual(result, expected)
+
+    def test_enables_haproxy(self):
+        mock_file = MagicMock()
+
+        @contextmanager
+        def mock_open(*args, **kwargs):
+            yield mock_file
+
+        initial_content = """
+        foo
+        ENABLED=0
+        bar
+        """
+        ending_content = initial_content.replace('ENABLED=0', 'ENABLED=1')
+
+        with patch('__builtin__.open', mock_open):
+            mock_file.read.return_value = initial_content
+
+            hooks.enable_haproxy()
+
+            mock_file.write.assert_called_with(ending_content)
+
+    @patch('hooks.config_get')
+    def test_creates_haproxy_defaults(self, config_get):
+        config_get.return_value = {
+            'default_options': 'foo-option, bar-option',
+            'default_timeouts': '234, 456',
+            'default_log': 'foo-log',
+            'default_mode': 'foo-mode',
+            'default_retries': 321,
+        }
+        result = hooks.create_haproxy_defaults()
+
+        expected = '\n'.join([
+            'defaults',
+            '    log foo-log',
+            '    mode foo-mode',
+            '    option foo-option',
+            '    option bar-option',
+            '    retries 321',
+            '    timeout 234',
+            '    timeout 456',
+        ])
+        self.assertEqual(result, expected)
+
+    def test_returns_none_when_haproxy_config_doesnt_exist(self):
+        self.assertIsNone(hooks.load_haproxy_config('/some/foo/file'))
+
+    @patch('__builtin__.open')
+    @patch('os.path.isfile')
+    def test_loads_haproxy_config_file(self, isfile, mock_open):
+        content = 'some content'
+        config_file = '/etc/haproxy/haproxy.cfg'
+        file_object = StringIO(content)
+        isfile.return_value = True
+        mock_open.return_value = file_object
+
+        result = hooks.load_haproxy_config()
+
+        self.assertEqual(result, content)
+        isfile.assert_called_with(config_file)
+        mock_open.assert_called_with(config_file)
+
+    @patch('hooks.load_haproxy_config')
+    def test_gets_monitoring_password(self, load_haproxy_config):
+        load_haproxy_config.return_value = 'stats auth foo:bar'
+
+        password = hooks.get_monitoring_password()
+
+        self.assertEqual(password, 'bar')
+
+    @patch('hooks.load_haproxy_config')
+    def test_gets_none_if_different_pattern(self, load_haproxy_config):
+        load_haproxy_config.return_value = 'some other pattern'
+
+        password = hooks.get_monitoring_password()
+
+        self.assertIsNone(password)
+
+    def test_gets_none_pass_if_config_doesnt_exist(self):
+        password = hooks.get_monitoring_password('/some/foo/path')
+
+        self.assertIsNone(password)
+
+    @patch('hooks.load_haproxy_config')
+    def test_gets_service_ports(self, load_haproxy_config):
+        load_haproxy_config.return_value = '''
+        listen foo.internal 1.2.3.4:123
+        listen bar.internal 1.2.3.5:234
+        '''
+
+        ports = hooks.get_service_ports()
+
+        self.assertEqual(ports, (123, 234))
+
+    @patch('hooks.load_haproxy_config')
+    def test_get_listen_stanzas(self, load_haproxy_config):
+        load_haproxy_config.return_value = '''
+        listen   foo.internal  1.2.3.4:123
+        listen bar.internal    1.2.3.5:234
+        '''
+
+        stanzas = hooks.get_listen_stanzas()
+
+        self.assertEqual((('foo.internal', '1.2.3.4', 123),
+                          ('bar.internal', '1.2.3.5', 234)),
+                         stanzas)
+
+    @patch('hooks.load_haproxy_config')
+    def test_get_listen_stanzas_with_frontend(self, load_haproxy_config):
+        load_haproxy_config.return_value = '''
+        frontend foo-2-123
+            bind 1.2.3.4:123
+            default_backend foo.internal
+        frontend foo-2-234
+            bind 1.2.3.5:234
+            default_backend bar.internal
+        '''
+
+        stanzas = hooks.get_listen_stanzas()
+
+        self.assertEqual((('foo.internal', '1.2.3.4', 123),
+                          ('bar.internal', '1.2.3.5', 234)),
+                         stanzas)
+
+    @patch('hooks.load_haproxy_config')
+    def test_get_empty_tuple_when_no_stanzas(self, load_haproxy_config):
+        load_haproxy_config.return_value = '''
+        '''
+
+        stanzas = hooks.get_listen_stanzas()
+
+        self.assertEqual((), stanzas)
+
+    @patch('hooks.load_haproxy_config')
+    def test_get_listen_stanzas_none_configured(self, load_haproxy_config):
+        load_haproxy_config.return_value = ""
+
+        stanzas = hooks.get_listen_stanzas()
+
+        self.assertEqual((), stanzas)
+
+    def test_gets_no_ports_if_config_doesnt_exist(self):
+        ports = hooks.get_service_ports('/some/foo/path')
+        self.assertEqual((), ports)
+
+    @patch('hooks.open_port')
+    @patch('hooks.close_port')
+    def test_updates_service_ports(self, close_port, open_port):
+        old_service_ports = [123, 234, 345]
+        new_service_ports = [345, 456, 567]
+
+        hooks.update_service_ports(old_service_ports, new_service_ports)
+
+        self.assertEqual(close_port.mock_calls, [call(123), call(234)])
+        self.assertEqual(open_port.mock_calls,
+                         [call(345), call(456), call(567)])
+
+    @patch('hooks.open_port')
+    @patch('hooks.close_port')
+    def test_updates_none_if_service_ports_not_provided(self, close_port,
+                                                        open_port):
+        hooks.update_service_ports()
+
+        self.assertFalse(close_port.called)
+        self.assertFalse(open_port.called)
+
+    @patch.dict(os.environ, {"JUJU_UNIT_NAME": "haproxy/2"})
+    def test_creates_a_listen_stanza(self):
+        service_name = 'some-name'
+        service_ip = '10.11.12.13'
+        service_port = 1234
+        service_options = ('foo', 'bar')
+        server_entries = [
+            ('name-1', 'ip-1', 'port-1', ('foo1', 'bar1')),
+            ('name-2', 'ip-2', 'port-2', ('foo2', 'bar2')),
+        ]
+
+        result = hooks.create_listen_stanza(service_name, service_ip,
+                                            service_port, service_options,
+                                            server_entries)
+
+        expected = '\n'.join((
+            'frontend haproxy-2-1234',
+            '    bind 10.11.12.13:1234',
+            '    default_backend some-name',
+            '',
+            'backend some-name',
+            '    foo',
+            '    bar',
+            '    server name-1 ip-1:port-1 foo1 bar1',
+            '    server name-2 ip-2:port-2 foo2 bar2',
+        ))
+
+        self.assertEqual(expected, result)
+
+    @patch.dict(os.environ, {"JUJU_UNIT_NAME": "haproxy/2"})
+    def test_create_listen_stanza_filters_frontend_options(self):
+        service_name = 'some-name'
+        service_ip = '10.11.12.13'
+        service_port = 1234
+        service_options = ('capture request header X-Man',
+                           'retries 3', 'balance uri', 'option logasap')
+        server_entries = [
+            ('name-1', 'ip-1', 'port-1', ('foo1', 'bar1')),
+            ('name-2', 'ip-2', 'port-2', ('foo2', 'bar2')),
+        ]
+
+        result = hooks.create_listen_stanza(service_name, service_ip,
+                                            service_port, service_options,
+                                            server_entries)
+
+        expected = '\n'.join((
+            'frontend haproxy-2-1234',
+            '    bind 10.11.12.13:1234',
+            '    default_backend some-name',
+            '    capture request header X-Man',
+            '    option logasap',
+            '',
+            'backend some-name',
+            '    retries 3',
+            '    balance uri',
+            '    server name-1 ip-1:port-1 foo1 bar1',
+            '    server name-2 ip-2:port-2 foo2 bar2',
+        ))
+
+        self.assertEqual(expected, result)
+
+    @patch.dict(os.environ, {"JUJU_UNIT_NAME": "haproxy/2"})
+    def test_creates_a_listen_stanza_with_tuple_entries(self):
+        service_name = 'some-name'
+        service_ip = '10.11.12.13'
+        service_port = 1234
+        service_options = ('foo', 'bar')
+        server_entries = (
+            ('name-1', 'ip-1', 'port-1', ('foo1', 'bar1')),
+            ('name-2', 'ip-2', 'port-2', ('foo2', 'bar2')),
+        )
+
+        result = hooks.create_listen_stanza(service_name, service_ip,
+                                            service_port, service_options,
+                                            server_entries)
+
+        expected = '\n'.join((
+            'frontend haproxy-2-1234',
+            '    bind 10.11.12.13:1234',
+            '    default_backend some-name',
+            '',
+            'backend some-name',
+            '    foo',
+            '    bar',
+            '    server name-1 ip-1:port-1 foo1 bar1',
+            '    server name-2 ip-2:port-2 foo2 bar2',
+        ))
+
+        self.assertEqual(expected, result)
+
+    def test_doesnt_create_listen_stanza_if_args_not_provided(self):
+        self.assertIsNone(hooks.create_listen_stanza())
+
+    @patch('hooks.create_listen_stanza')
+    @patch('hooks.config_get')
+    @patch('hooks.get_monitoring_password')
+    def test_creates_a_monitoring_stanza(self, get_monitoring_password,
+                                         config_get, create_listen_stanza):
+        config_get.return_value = {
+            'enable_monitoring': True,
+            'monitoring_allowed_cidr': 'some-cidr',
+            'monitoring_password': 'some-pass',
+            'monitoring_username': 'some-user',
+            'monitoring_stats_refresh': 123,
+            'monitoring_port': 1234,
+        }
+        create_listen_stanza.return_value = 'some result'
+
+        result = hooks.create_monitoring_stanza(service_name="some-service")
+
+        self.assertEqual('some result', result)
+        get_monitoring_password.assert_called_with()
+        create_listen_stanza.assert_called_with(
+            'some-service', '0.0.0.0', 1234, [
+                'mode http',
+                'acl allowed_cidr src some-cidr',
+                'block unless allowed_cidr',
+                'stats enable',
+                'stats uri /',
+                'stats realm Haproxy\\ Statistics',
+                'stats auth some-user:some-pass',
+                'stats refresh 123',
+            ])
+
+    @patch('hooks.create_listen_stanza')
+    @patch('hooks.config_get')
+    @patch('hooks.get_monitoring_password')
+    def test_doesnt_create_a_monitoring_stanza_if_monitoring_disabled(
+            self, get_monitoring_password, config_get, create_listen_stanza):
+        config_get.return_value = {
+            'enable_monitoring': False,
+        }
+
+        result = hooks.create_monitoring_stanza(service_name="some-service")
+
+        self.assertIsNone(result)
+        self.assertFalse(get_monitoring_password.called)
+        self.assertFalse(create_listen_stanza.called)
+
+    @patch('hooks.create_listen_stanza')
+    @patch('hooks.config_get')
+    @patch('hooks.get_monitoring_password')
+    def test_uses_monitoring_password_for_stanza(self, get_monitoring_password,
+                                                 config_get,
+                                                 create_listen_stanza):
+        config_get.return_value = {
+            'enable_monitoring': True,
+            'monitoring_allowed_cidr': 'some-cidr',
+            'monitoring_password': 'changeme',
+            'monitoring_username': 'some-user',
+            'monitoring_stats_refresh': 123,
+            'monitoring_port': 1234,
+        }
+        create_listen_stanza.return_value = 'some result'
+        get_monitoring_password.return_value = 'some-monitoring-pass'
+
+        hooks.create_monitoring_stanza(service_name="some-service")
+
+        get_monitoring_password.assert_called_with()
+        create_listen_stanza.assert_called_with(
+            'some-service', '0.0.0.0', 1234, [
+                'mode http',
+                'acl allowed_cidr src some-cidr',
+                'block unless allowed_cidr',
+                'stats enable',
+                'stats uri /',
+                'stats realm Haproxy\\ Statistics',
+                'stats auth some-user:some-monitoring-pass',
+                'stats refresh 123',
+            ])
+
+    @patch('hooks.pwgen')
+    @patch('hooks.create_listen_stanza')
+    @patch('hooks.config_get')
+    @patch('hooks.get_monitoring_password')
+    def test_uses_new_password_for_stanza(self, get_monitoring_password,
+                                          config_get, create_listen_stanza,
+                                          pwgen):
+        config_get.return_value = {
+            'enable_monitoring': True,
+            'monitoring_allowed_cidr': 'some-cidr',
+            'monitoring_password': 'changeme',
+            'monitoring_username': 'some-user',
+            'monitoring_stats_refresh': 123,
+            'monitoring_port': 1234,
+        }
+        create_listen_stanza.return_value = 'some result'
+        get_monitoring_password.return_value = None
+        pwgen.return_value = 'some-new-pass'
+
+        hooks.create_monitoring_stanza(service_name="some-service")
+
+        get_monitoring_password.assert_called_with()
+        create_listen_stanza.assert_called_with(
+            'some-service', '0.0.0.0', 1234, [
+                'mode http',
+                'acl allowed_cidr src some-cidr',
+                'block unless allowed_cidr',
+                'stats enable',
+                'stats uri /',
+                'stats realm Haproxy\\ Statistics',
+                'stats auth some-user:some-new-pass',
+                'stats refresh 123',
+            ])
+
+    @patch('hooks.is_proxy')
+    @patch('hooks.config_get')
+    @patch('yaml.safe_load')
+    def test_gets_config_services(self, safe_load, config_get, is_proxy):
+        config_get.return_value = {
+            'services': 'some-services',
+        }
+        safe_load.return_value = [
+            {
+                'service_name': 'foo',
+                'service_options': {
+                    'foo-1': 123,
+                },
+                'service_options': ['foo1', 'foo2'],
+                'server_options': ['baz1', 'baz2'],
+            },
+            {
+                'service_name': 'bar',
+                'service_options': ['bar1', 'bar2'],
+                'server_options': ['baz1', 'baz2'],
+            },
+        ]
+        is_proxy.return_value = False
+
+        result = hooks.get_config_services()
+        expected = {
+            None: {
+                'service_name': 'foo',
+            },
+            'foo': {
+                'service_name': 'foo',
+                'service_options': ['foo1', 'foo2'],
+                'server_options': ['baz1', 'baz2'],
+            },
+            'bar': {
+                'service_name': 'bar',
+                'service_options': ['bar1', 'bar2'],
+                'server_options': ['baz1', 'baz2'],
+            },
+        }
+
+        self.assertEqual(expected, result)
+
+    @patch('hooks.is_proxy')
+    @patch('hooks.config_get')
+    @patch('yaml.safe_load')
+    def test_gets_config_services_with_forward_option(self, safe_load,
+                                                      config_get, is_proxy):
+        config_get.return_value = {
+            'services': 'some-services',
+        }
+        safe_load.return_value = [
+            {
+                'service_name': 'foo',
+                'service_options': {
+                    'foo-1': 123,
+                },
+                'service_options': ['foo1', 'foo2'],
+                'server_options': ['baz1', 'baz2'],
+            },
+            {
+                'service_name': 'bar',
+                'service_options': ['bar1', 'bar2'],
+                'server_options': ['baz1', 'baz2'],
+            },
+        ]
+        is_proxy.return_value = True
+
+        result = hooks.get_config_services()
+        expected = {
+            None: {
+                'service_name': 'foo',
+            },
+            'foo': {
+                'service_name': 'foo',
+                'service_options': ['foo1', 'foo2', 'option forwardfor'],
+                'server_options': ['baz1', 'baz2'],
+            },
+            'bar': {
+                'service_name': 'bar',
+                'service_options': ['bar1', 'bar2', 'option forwardfor'],
+                'server_options': ['baz1', 'baz2'],
+            },
+        }
+
+        self.assertEqual(expected, result)
+
+    @patch('hooks.is_proxy')
+    @patch('hooks.config_get')
+    @patch('yaml.safe_load')
+    def test_gets_config_services_with_options_string(self, safe_load,
+                                                      config_get, is_proxy):
+        config_get.return_value = {
+            'services': 'some-services',
+        }
+        safe_load.return_value = [
+            {
+                'service_name': 'foo',
+                'service_options': {
+                    'foo-1': 123,
+                },
+                'service_options': ['foo1', 'foo2'],
+                'server_options': 'baz1 baz2',
+            },
+            {
+                'service_name': 'bar',
+                'service_options': ['bar1', 'bar2'],
+                'server_options': 'baz1 baz2',
+            },
+        ]
+        is_proxy.return_value = False
+
+        result = hooks.get_config_services()
+        expected = {
+            None: {
+                'service_name': 'foo',
+            },
+            'foo': {
+                'service_name': 'foo',
+                'service_options': ['foo1', 'foo2'],
+                'server_options': ['baz1', 'baz2'],
+            },
+            'bar': {
+                'service_name': 'bar',
+                'service_options': ['bar1', 'bar2'],
+                'server_options': ['baz1', 'baz2'],
+            },
+        }
+
+        self.assertEqual(expected, result)
+
+    @patch('hooks.get_config_services')
+    def test_gets_a_service_config(self, get_config_services):
+        get_config_services.return_value = {
+            'foo': 'bar',
+        }
+
+        self.assertEqual('bar', hooks.get_config_service('foo'))
+
+    @patch('hooks.get_config_services')
+    def test_gets_a_service_config_from_none(self, get_config_services):
+        get_config_services.return_value = {
+            None: 'bar',
+        }
+
+        self.assertEqual('bar', hooks.get_config_service())
+
+    @patch('hooks.get_config_services')
+    def test_gets_a_service_config_as_none(self, get_config_services):
+        get_config_services.return_value = {
+            'baz': 'bar',
+        }
+
+        self.assertIsNone(hooks.get_config_service())
+
+    @patch('os.path.exists')
+    def test_mark_as_proxy_when_path_exists(self, path_exists):
+        path_exists.return_value = True
+
+        self.assertTrue(hooks.is_proxy('foo'))
+        path_exists.assert_called_with('/var/run/haproxy/foo.is.proxy')
+
+    @patch('os.path.exists')
+    def test_doesnt_mark_as_proxy_when_path_doesnt_exist(self, path_exists):
+        path_exists.return_value = False
+
+        self.assertFalse(hooks.is_proxy('foo'))
+        path_exists.assert_called_with('/var/run/haproxy/foo.is.proxy')
+
+    @patch('os.path.exists')
+    def test_loads_services_by_name(self, path_exists):
+        with patch_open() as (mock_open, mock_file):
+            path_exists.return_value = True
+            mock_file.read.return_value = 'some content'
+
+            result = hooks.load_services('some-service')
+
+            self.assertEqual('some content', result)
+            mock_open.assert_called_with(
+                '/var/run/haproxy/some-service.service')
+            mock_file.read.assert_called_with()
+
+    @patch('os.path.exists')
+    def test_loads_no_service_if_path_doesnt_exist(self, path_exists):
+        path_exists.return_value = False
+
+        result = hooks.load_services('some-service')
+
+        self.assertIsNone(result)
+
+    @patch('glob.glob')
+    def test_loads_services_within_dir_if_no_name_provided(self, glob):
+        with patch_open() as (mock_open, mock_file):
+            mock_file.read.side_effect = ['foo', 'bar']
+            glob.return_value = ['foo-file', 'bar-file']
+
+            result = hooks.load_services()
+
+            self.assertEqual('foo\n\nbar\n\n', result)
+            mock_open.assert_has_calls([call('foo-file'), call('bar-file')])
+            mock_file.read.assert_has_calls([call(), call()])
+
+    @patch('hooks.os')
+    def test_removes_services_by_name(self, os_):
+        service_path = '/var/run/haproxy/some-service.service'
+        os_.path.exists.return_value = True
+
+        self.assertTrue(hooks.remove_services('some-service'))
+
+        os_.path.exists.assert_called_with(service_path)
+        os_.remove.assert_called_with(service_path)
+
+    @patch('hooks.os')
+    def test_removes_nothing_if_service_doesnt_exist(self, os_):
+        service_path = '/var/run/haproxy/some-service.service'
+        os_.path.exists.return_value = False
+
+        self.assertTrue(hooks.remove_services('some-service'))
+
+        os_.path.exists.assert_called_with(service_path)
+
+    @patch('hooks.os')
+    @patch('glob.glob')
+    def test_removes_all_services_in_dir_if_name_not_provided(self, glob, os_):
+        glob.return_value = ['foo', 'bar']
+
+        self.assertTrue(hooks.remove_services())
+
+        os_.remove.assert_has_calls([call('foo'), call('bar')])
+
+    @patch('hooks.os')
+    @patch('hooks.log')
+    def test_logs_error_when_failing_to_remove_service_by_name(self, log, os_):
+        error = Exception('some error')
+        os_.path.exists.return_value = True
+        os_.remove.side_effect = error
+
+        self.assertFalse(hooks.remove_services('some-service'))
+
+        log.assert_called_with(str(error))
+
+    @patch('hooks.os')
+    @patch('hooks.log')
+    @patch('glob.glob')
+    def test_logs_error_when_failing_to_remove_services(self, glob, log, os_):
+        errors = [Exception('some error 1'), Exception('some error 2')]
+        os_.remove.side_effect = errors
+        glob.return_value = ['foo', 'bar']
+
+        self.assertTrue(hooks.remove_services())
+
+        log.assert_has_calls([
+            call(str(errors[0])),
+            call(str(errors[1])),
+        ])
+
+    @patch('subprocess.call')
+    def test_calls_check_action(self, mock_call):
+        mock_call.return_value = 0
+
+        result = hooks.service_haproxy('check')
+
+        self.assertTrue(result)
+        mock_call.assert_called_with(['/usr/sbin/haproxy', '-f',
+                                      hooks.default_haproxy_config, '-c'])
+
+    @patch('subprocess.call')
+    def test_calls_check_action_with_different_config(self, mock_call):
+        mock_call.return_value = 0
+
+        result = hooks.service_haproxy('check', 'some-config')
+
+        self.assertTrue(result)
+        mock_call.assert_called_with(['/usr/sbin/haproxy', '-f',
+                                      'some-config', '-c'])
+
+    @patch('subprocess.call')
+    def test_fails_to_check_config(self, mock_call):
+        mock_call.return_value = 1
+
+        result = hooks.service_haproxy('check')
+
+        self.assertFalse(result)
+
+    @patch('subprocess.call')
+    def test_calls_different_actions(self, mock_call):
+        mock_call.return_value = 0
+
+        result = hooks.service_haproxy('foo')
+
+        self.assertTrue(result)
+        mock_call.assert_called_with(['service', 'haproxy', 'foo'])
+
+    @patch('subprocess.call')
+    def test_fails_to_call_different_actions(self, mock_call):
+        mock_call.return_value = 1
+
+        result = hooks.service_haproxy('foo')
+
+        self.assertFalse(result)
+
+    @patch('subprocess.call')
+    def test_doesnt_call_actions_if_action_not_provided(self, mock_call):
+        self.assertIsNone(hooks.service_haproxy())
+        self.assertFalse(mock_call.called)
+
+    @patch('subprocess.call')
+    def test_doesnt_call_actions_if_config_is_none(self, mock_call):
+        self.assertIsNone(hooks.service_haproxy('foo', None))
+        self.assertFalse(mock_call.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:34:35 +0000
@@ -0,0 +1,24 @@
+from testtools import TestCase
+from mock import call, patch, MagicMock
+
+import hooks
+
+
+class NRPEHooksTest(TestCase):
+
+    @patch('hooks.install_nrpe_scripts')
+    @patch('charmhelpers.contrib.charmsupport.nrpe.NRPE')
+    def test_update_nrpe_config(self, nrpe, install_nrpe_scripts):
+        nrpe_compat = MagicMock()
+        nrpe_compat.checks = [MagicMock(shortname="haproxy"),
+                              MagicMock(shortname="haproxy_queue")]
+        nrpe.return_value = nrpe_compat
+
+        hooks.update_nrpe_config()
+
+        self.assertEqual(
+            nrpe_compat.mock_calls,
+            [call.add_check('haproxy', 'Check HAProxy', 'check_haproxy.sh'),
+             call.add_check('haproxy_queue', 'Check HAProxy queue depth',
+                            'check_haproxy_queue_depth.sh'),
+             call.write()])

=== added file 'hooks/tests/test_peer_hooks.py'
--- hooks/tests/test_peer_hooks.py	1970-01-01 00:00:00 +0000
+++ hooks/tests/test_peer_hooks.py	2013-10-10 22:34:35 +0000
@@ -0,0 +1,200 @@
+import os
+import yaml
+
+from testtools import TestCase
+from mock import patch
+
+import hooks
+from utils_for_tests import patch_open
+
+
+class PeerRelationTest(TestCase):
+
+    def setUp(self):
+        super(PeerRelationTest, self).setUp()
+
+        self.relations_of_type = self.patch_hook("relations_of_type")
+        self.log = self.patch_hook("log")
+        self.unit_get = self.patch_hook("unit_get")
+
+    def patch_hook(self, hook_name):
+        mock_controller = patch.object(hooks, hook_name)
+        mock = mock_controller.start()
+        self.addCleanup(mock_controller.stop)
+        return mock
+
+    @patch.dict(os.environ, {"JUJU_UNIT_NAME": "haproxy/2"})
+    def test_with_peer_same_services(self):
+        self.unit_get.return_value = "1.2.4.5"
+        self.relations_of_type.return_value = [
+            {"__unit__": "haproxy/1",
+             "hostname": "haproxy-1",
+             "private-address": "1.2.4.4",
+             "all_services": yaml.dump([
+                 {"service_name": "foo_service",
+                  "service_host": "0.0.0.0",
+                  "service_options": ["balance leastconn"],
+                  "service_port": 4242},
+                 ])
+             }
+            ]
+
+        services_dict = {
+            "foo_service": {
+                "service_name": "foo_service",
+                "service_host": "0.0.0.0",
+                "service_port": 4242,
+                "service_options": ["balance leastconn"],
+                "server_options": ["maxconn 4"],
+                "servers": [("backend_1__8080", "1.2.3.4",
+                             8080, ["maxconn 4"])],
+                },
+            }
+
+        expected = {
+            "foo_service": {
+                "service_name": "foo_service",
+                "service_host": "0.0.0.0",
+                "service_port": 4242,
+                "service_options": ["balance leastconn",
+                                    "mode tcp",
+                                    "option tcplog"],
+                "servers": [
+                    ("haproxy-1", "1.2.4.4", 4243, ["check"]),
+                    ("haproxy-2", "1.2.4.5", 4243, ["check", "backup"])
+                    ],
+                },
+            "foo_service_be": {
+                "service_name": "foo_service_be",
+                "service_host": "0.0.0.0",
+                "service_port": 4243,
+                "service_options": ["balance leastconn"],
+                "server_options": ["maxconn 4"],
+                "servers": [("backend_1__8080", "1.2.3.4",
+                             8080, ["maxconn 4"])],
+                },
+            }
+        self.assertEqual(expected, hooks.apply_peer_config(services_dict))
+
+    @patch.dict(os.environ, {"JUJU_UNIT_NAME": "haproxy/2"})
+    def test_inherit_timeout_settings(self):
+        self.unit_get.return_value = "1.2.4.5"
+        self.relations_of_type.return_value = [
+            {"__unit__": "haproxy/1",
+             "hostname": "haproxy-1",
+             "private-address": "1.2.4.4",
+             "all_services": yaml.dump([
+                 {"service_name": "foo_service",
+                  "service_host": "0.0.0.0",
+                  "service_options": ["timeout server 5000"],
+                  "service_port": 4242},
+                 ])
+             }
+            ]
+
+        services_dict = {
+            "foo_service": {
+                "service_name": "foo_service",
+                "service_host": "0.0.0.0",
+                "service_port": 4242,
+                "service_options": ["timeout server 5000"],
+                "server_options": ["maxconn 4"],
+                "servers": [("backend_1__8080", "1.2.3.4",
+                             8080, ["maxconn 4"])],
+                },
+            }
+
+        expected = {
+            "foo_service": {
+                "service_name": "foo_service",
+                "service_host": "0.0.0.0",
+                "service_port": 4242,
+                "service_options": ["balance leastconn",
+                                    "mode tcp",
+                                    "option tcplog",
+                                    "timeout server 5000"],
+                "servers": [
+                    ("haproxy-1", "1.2.4.4", 4243, ["check"]),
+                    ("haproxy-2", "1.2.4.5", 4243, ["check", "backup"])
+                    ],
+                },
+            "foo_service_be": {
+                "service_name": "foo_service_be",
+                "service_host": "0.0.0.0",
+                "service_port": 4243,
+                "service_options": ["timeout server 5000"],
+                "server_options": ["maxconn 4"],
+                "servers": [("backend_1__8080", "1.2.3.4",
+                             8080, ["maxconn 4"])],
+                },
+            }
+        self.assertEqual(expected, hooks.apply_peer_config(services_dict))
+
+    @patch.dict(os.environ, {"JUJU_UNIT_NAME": "haproxy/2"})
+    def test_with_no_relation_data(self):
+        self.unit_get.return_value = "1.2.4.5"
+        self.relations_of_type.return_value = []
+
+        services_dict = {
+            "foo_service": {
+                "service_name": "foo_service",
+                "service_host": "0.0.0.0",
+                "service_port": 4242,
+                "service_options": ["balance leastconn"],
+                "server_options": ["maxconn 4"],
+                "servers": [("backend_1__8080", "1.2.3.4",
+                             8080, ["maxconn 4"])],
+                },
+            }
+
+        expected = services_dict
+        self.assertEqual(expected, hooks.apply_peer_config(services_dict))
+
+    @patch.dict(os.environ, {"JUJU_UNIT_NAME": "haproxy/2"})
+    def test_with_missing_all_services(self):
+        self.unit_get.return_value = "1.2.4.5"
+        self.relations_of_type.return_value = [
+            {"__unit__": "haproxy/1",
+             "hostname": "haproxy-1",
+             "private-address": "1.2.4.4",
+             }
+            ]
+
+        services_dict = {
+            "foo_service": {
+                "service_name": "foo_service",
+                "service_host": "0.0.0.0",
+                "service_port": 4242,
+                "service_options": ["balance leastconn"],
+                "server_options": ["maxconn 4"],
+                "servers": [("backend_1__8080", "1.2.3.4",
+                             8080, ["maxconn 4"])],
+                },
+            }
+
+        expected = services_dict
+        self.assertEqual(expected, hooks.apply_peer_config(services_dict))
+
+    @patch('hooks.create_listen_stanza')
+    def test_writes_service_config(self, create_listen_stanza):
+        create_listen_stanza.return_value = 'some content'
+        services_dict = {
+            'foo': {
+                'service_name': 'bar',
+                'service_host': 'some-host',
+                'service_port': 'some-port',
+                'service_options': 'some-options',
+                'servers': (1, 2),
+            },
+        }
+
+        with patch.object(os.path, "exists") as exists:
+            exists.return_value = True
+            with patch_open() as (mock_open, mock_file):
+                hooks.write_service_config(services_dict)
+
+                create_listen_stanza.assert_called_with(
+                    'bar', 'some-host', 'some-port', 'some-options', (1, 2))
+                mock_open.assert_called_with(
+                    '/var/run/haproxy/bar.service', 'w')
+                mock_file.write.assert_called_with('some content')

=== added file 'hooks/tests/test_reverseproxy_hooks.py'
--- hooks/tests/test_reverseproxy_hooks.py	1970-01-01 00:00:00 +0000
+++ hooks/tests/test_reverseproxy_hooks.py	2013-10-10 22:34:35 +0000
@@ -0,0 +1,345 @@
+from testtools import TestCase
+from mock import patch, call
+
+import hooks
+
+
+class ReverseProxyRelationTest(TestCase):
+
+    def setUp(self):
+        super(ReverseProxyRelationTest, self).setUp()
+
+        self.relations_of_type = self.patch_hook("relations_of_type")
+        self.get_config_services = self.patch_hook("get_config_services")
+        self.log = self.patch_hook("log")
+        self.write_service_config = self.patch_hook("write_service_config")
+        self.apply_peer_config = self.patch_hook("apply_peer_config")
+        self.apply_peer_config.side_effect = lambda value: value
+
+    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_none(self):
+        self.get_config_services.return_value = {
+            "service": {
+                "service_name": "service",
+                },
+            }
+        self.relations_of_type.return_value = []
+        self.assertIs(None, hooks.create_services())
+        self.log.assert_called_once_with("No backend servers, exiting.")
+        self.write_service_config.assert_not_called()
+
+    def test_relation_data_returns_no_relations(self):
+        self.get_config_services.return_value = {
+            "service": {
+                "service_name": "service",
+                },
+            }
+        self.relations_of_type.return_value = []
+        self.assertIs(None, hooks.create_services())
+        self.log.assert_called_once_with("No backend servers, exiting.")
+        self.write_service_config.assert_not_called()
+
+    def test_relation_no_services(self):
+        self.get_config_services.return_value = {}
+        self.relations_of_type.return_value = [
+            {"port": 4242,
+             "__unit__": "foo/0",
+             "hostname": "backend.1",
+             "private-address": "1.2.3.4"},
+        ]
+        self.assertIs(None, hooks.create_services())
+        self.log.assert_called_once_with("No services configured, exiting.")
+        self.write_service_config.assert_not_called()
+
+    def test_no_port_in_relation_data(self):
+        self.get_config_services.return_value = {
+            "service": {
+                "service_name": "service",
+                },
+            }
+        self.relations_of_type.return_value = [
+            {"private-address": "1.2.3.4",
+             "__unit__": "foo/0"},
+        ]
+        self.assertIs(None, hooks.create_services())
+        self.log.assert_has_calls([call.log(
+            "No port in relation data for 'foo/0', skipping.")])
+        self.write_service_config.assert_not_called()
+
+    def test_no_private_address_in_relation_data(self):
+        self.get_config_services.return_value = {
+            "service": {
+                "service_name": "service",
+                },
+            }
+        self.relations_of_type.return_value = [
+            {"port": 4242,
+             "__unit__": "foo/0"},
+        ]
+        self.assertIs(None, hooks.create_services())
+        self.log.assert_has_calls([call.log(
+            "No private-address in relation data for 'foo/0', skipping.")])
+        self.write_service_config.assert_not_called()
+
+    def test_no_hostname_in_relation_data(self):
+        self.get_config_services.return_value = {
+            "service": {
+                "service_name": "service",
+                },
+            }
+        self.relations_of_type.return_value = [
+            {"port": 4242,
+             "private-address": "1.2.3.4",
+             "__unit__": "foo/0"},
+        ]
+        self.assertIs(None, hooks.create_services())
+        self.log.assert_has_calls([call.log(
+            "No hostname in relation data for 'foo/0', skipping.")])
+        self.write_service_config.assert_not_called()
+
+    def test_relation_unknown_service(self):
+        self.get_config_services.return_value = {
+            "service": {
+                "service_name": "service",
+                },
+            }
+        self.relations_of_type.return_value = [
+            {"port": 4242,
+             "hostname": "backend.1",
+             "service_name": "invalid",
+             "private-address": "1.2.3.4",
+             "__unit__": "foo/0"},
+        ]
+        self.assertIs(None, hooks.create_services())
+        self.log.assert_has_calls([call.log(
+            "Service 'invalid' does not exist.")])
+        self.write_service_config.assert_not_called()
+
+    def test_no_relation_but_has_servers_from_config(self):
+        self.get_config_services.return_value = {
+            None: {
+                "service_name": "service",
+                },
+            "service": {
+                "service_name": "service",
+                "servers": [
+                    ("legacy-backend", "1.2.3.1", 4242, ["maxconn 42"]),
+                    ]
+                },
+            }
+        self.relations_of_type.return_value = []
+
+        expected = {
+            'service': {
+                'service_name': 'service',
+                'servers': [
+                    ("legacy-backend", "1.2.3.1", 4242, ["maxconn 42"]),
+                    ],
+                },
+            }
+        self.assertEqual(expected, hooks.create_services())
+        self.write_service_config.assert_called_with(expected)
+
+    def test_relation_default_service(self):
+        self.get_config_services.return_value = {
+            None: {
+                "service_name": "service",
+                },
+            "service": {
+                "service_name": "service",
+                },
+            }
+        self.relations_of_type.return_value = [
+            {"port": 4242,
+             "hostname": "backend.1",
+             "private-address": "1.2.3.4",
+             "__unit__": "foo/0"},
+        ]
+
+        expected = {
+            'service': {
+                'service_name': 'service',
+                'servers': [('foo-0-4242', '1.2.3.4', 4242, [])],
+                },
+            }
+        self.assertEqual(expected, hooks.create_services())
+        self.write_service_config.assert_called_with(expected)
+
+    def test_with_service_options(self):
+        self.get_config_services.return_value = {
+            None: {
+                "service_name": "service",
+                },
+            "service": {
+                "service_name": "service",
+                "server_options": ["maxconn 4"],
+                },
+            }
+        self.relations_of_type.return_value = [
+            {"port": 4242,
+             "hostname": "backend.1",
+             "private-address": "1.2.3.4",
+             "__unit__": "foo/0"},
+        ]
+
+        expected = {
+            'service': {
+                'service_name': 'service',
+                'server_options': ["maxconn 4"],
+                'servers': [('foo-0-4242', '1.2.3.4',
+                             4242, ["maxconn 4"])],
+                },
+            }
+        self.assertEqual(expected, hooks.create_services())
+        self.write_service_config.assert_called_with(expected)
+
+    def test_with_service_name(self):
+        self.get_config_services.return_value = {
+            None: {
+                "service_name": "service",
+                },
+            "foo_service": {
+                "service_name": "foo_service",
+                "server_options": ["maxconn 4"],
+                },
+            }
+        self.relations_of_type.return_value = [
+            {"port": 4242,
+             "hostname": "backend.1",
+             "service_name": "foo_service",
+             "private-address": "1.2.3.4",
+             "__unit__": "foo/0"},
+        ]
+
+        expected = {
+            'foo_service': {
+                'service_name': 'foo_service',
+                'server_options': ["maxconn 4"],
+                'servers': [('foo-0-4242', '1.2.3.4',
+                             4242, ["maxconn 4"])],
+                },
+            }
+        self.assertEqual(expected, hooks.create_services())
+        self.write_service_config.assert_called_with(expected)
+
+    def test_no_service_name_unit_name_match_service_name(self):
+        self.get_config_services.return_value = {
+            None: {
+                "service_name": "foo_service",
+                },
+            "foo_service": {
+                "service_name": "foo_service",
+                "server_options": ["maxconn 4"],
+                },
+            }
+        self.relations_of_type.return_value = [
+            {"port": 4242,
+             "hostname": "backend.1",
+             "private-address": "1.2.3.4",
+             "__unit__": "foo/1"},
+        ]
+
+        expected = {
+            'foo_service': {
+                'service_name': 'foo_service',
+                'server_options': ["maxconn 4"],
+                'servers': [('foo-1-4242', '1.2.3.4',
+                             4242, ["maxconn 4"])],
+                },
+            }
+        self.assertEqual(expected, hooks.create_services())
+        self.write_service_config.assert_called_with(expected)
+
+    def test_with_sitenames_match_service_name(self):
+        self.get_config_services.return_value = {
+            None: {
+                "service_name": "service",
+                },
+            "foo_srv": {
+                "service_name": "foo_srv",
+                "server_options": ["maxconn 4"],
+                },
+            }
+        self.relations_of_type.return_value = [
+            {"port": 4242,
+             "hostname": "backend.1",
+             "sitenames": "foo_srv bar_srv",
+             "private-address": "1.2.3.4",
+             "__unit__": "foo/0"},
+        ]
+
+        expected = {
+            'foo_srv': {
+                'service_name': 'foo_srv',
+                'server_options': ["maxconn 4"],
+                'servers': [('foo-0-4242', '1.2.3.4',
+                             4242, ["maxconn 4"])],
+                },
+            }
+        self.assertEqual(expected, hooks.create_services())
+        self.write_service_config.assert_called_with(expected)
+
+    def test_with_juju_services_match_service_name(self):
+        self.get_config_services.return_value = {
+            None: {
+                "service_name": "service",
+                },
+            "foo_service": {
+                "service_name": "foo_service",
+                "server_options": ["maxconn 4"],
+                },
+            }
+        self.relations_of_type.return_value = [
+            {"port": 4242,
+             "hostname": "backend.1",
+             "private-address": "1.2.3.4",
+             "__unit__": "foo/1"},
+        ]
+
+        expected = {
+            'foo_service': {
+                'service_name': 'foo_service',
+                'server_options': ["maxconn 4"],
+                'servers': [('foo-1-4242', '1.2.3.4',
+                             4242, ["maxconn 4"])],
+                },
+            }
+
+        result = hooks.create_services()
+
+        self.assertEqual(expected, result)
+        self.write_service_config.assert_called_with(expected)
+
+    def test_with_sitenames_no_match_but_unit_name(self):
+        self.get_config_services.return_value = {
+            None: {
+                "service_name": "service",
+                },
+            "foo": {
+                "service_name": "foo",
+                "server_options": ["maxconn 4"],
+                },
+            }
+        self.relations_of_type.return_value = [
+            {"port": 4242,
+             "hostname": "backend.1",
+             "sitenames": "bar_service baz_service",
+             "private-address": "1.2.3.4",
+             "__unit__": "foo/0"},
+        ]
+
+        expected = {
+            'foo': {
+                'service_name': 'foo',
+                'server_options': ["maxconn 4"],
+                'servers': [('foo-0-4242', '1.2.3.4',
+                             4242, ["maxconn 4"])],
+                },
+            }
+        self.assertEqual(expected, hooks.create_services())
+        self.write_service_config.assert_called_with(expected)

=== added file 'hooks/tests/test_website_hooks.py'
--- hooks/tests/test_website_hooks.py	1970-01-01 00:00:00 +0000
+++ hooks/tests/test_website_hooks.py	2013-10-10 22:34:35 +0000
@@ -0,0 +1,145 @@
+from testtools import TestCase
+from mock import patch, call
+
+import hooks
+
+
+class WebsiteRelationTest(TestCase):
+
+    def setUp(self):
+        super(WebsiteRelationTest, self).setUp()
+        self.notify_website = self.patch_hook("notify_website")
+
+    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_website_interface_none(self):
+        self.assertEqual(None, hooks.website_interface(hook_name=None))
+        self.notify_website.assert_not_called()
+
+    def test_website_interface_joined(self):
+        hooks.website_interface(hook_name="joined")
+        self.notify_website.assert_called_once_with(
+            changed=False, relation_ids=(None,))
+
+    def test_website_interface_changed(self):
+        hooks.website_interface(hook_name="changed")
+        self.notify_website.assert_called_once_with(
+            changed=True, relation_ids=(None,))
+
+
+class NotifyRelationTest(TestCase):
+
+    def setUp(self):
+        super(NotifyRelationTest, self).setUp()
+
+        self.relations_for_id = self.patch_hook("relations_for_id")
+        self.relation_set = self.patch_hook("relation_set")
+        self.config_get = self.patch_hook("config_get")
+        self.get_relation_ids = self.patch_hook("get_relation_ids")
+        self.get_hostname = self.patch_hook("get_hostname")
+        self.log = self.patch_hook("log")
+        self.get_config_services = self.patch_hook("get_config_service")
+
+    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_notify_website_relation_no_relation_ids(self):
+        hooks.notify_relation("website")
+        self.get_relation_ids.return_value = ()
+        self.relation_set.assert_not_called()
+        self.get_relation_ids.assert_called_once_with("website")
+
+    def test_notify_website_relation_with_default_relation(self):
+        self.get_relation_ids.return_value = ()
+        self.get_hostname.return_value = "foo.local"
+        self.relations_for_id.return_value = [{}]
+        self.config_get.return_value = {"services": ""}
+
+        hooks.notify_relation("website", relation_ids=(None,))
+
+        self.get_hostname.assert_called_once_with()
+        self.relations_for_id.assert_called_once_with(None)
+        self.relation_set.assert_called_once_with(
+            relation_id=None, port="80", hostname="foo.local",
+            all_services="")
+        self.get_relation_ids.assert_not_called()
+
+    def test_notify_website_relation_with_relations(self):
+        self.get_relation_ids.return_value = ("website:1",
+                                              "website:2")
+        self.get_hostname.return_value = "foo.local"
+        self.relations_for_id.return_value = [{}]
+        self.config_get.return_value = {"services": ""}
+
+        hooks.notify_relation("website")
+
+        self.get_hostname.assert_called_once_with()
+        self.get_relation_ids.assert_called_once_with("website")
+        self.relations_for_id.assert_has_calls([
+            call("website:1"),
+            call("website:2"),
+            ])
+
+        self.relation_set.assert_has_calls([
+            call(relation_id="website:1", port="80", hostname="foo.local",
+                 all_services=""),
+            call(relation_id="website:2", port="80", hostname="foo.local",
+                 all_services=""),
+            ])
+
+    def test_notify_website_relation_with_different_sitenames(self):
+        self.get_relation_ids.return_value = ("website:1",)
+        self.get_hostname.return_value = "foo.local"
+        self.relations_for_id.return_value = [{"service_name": "foo"},
+                                              {"service_name": "bar"}]
+        self.config_get.return_value = {"services": ""}
+
+        hooks.notify_relation("website")
+
+        self.get_hostname.assert_called_once_with()
+        self.get_relation_ids.assert_called_once_with("website")
+        self.relations_for_id.assert_has_calls([
+            call("website:1"),
+            ])
+
+        self.relation_set.assert_has_calls([
+            call.relation_set(
+                relation_id="website:1", port="80", hostname="foo.local",
+                all_services=""),
+            ])
+        self.log.assert_called_once_with(
+            "Remote units requested than a single service name."
+            "Falling back to default host/port.")
+
+    def test_notify_website_relation_with_same_sitenames(self):
+        self.get_relation_ids.return_value = ("website:1",)
+        self.get_hostname.side_effect = ["foo.local", "bar.local"]
+        self.relations_for_id.return_value = [{"service_name": "bar"},
+                                              {"service_name": "bar"}]
+        self.config_get.return_value = {"services": ""}
+        self.get_config_services.return_value = {"service_host": "bar.local",
+                                                 "service_port": "4242"}
+
+        hooks.notify_relation("website")
+
+        self.get_hostname.assert_has_calls([
+            call(),
+            call("bar.local")])
+        self.get_relation_ids.assert_called_once_with("website")
+        self.relations_for_id.assert_has_calls([
+            call("website:1"),
+            ])
+
+        self.relation_set.assert_has_calls([