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.

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

87. By JuanJo Ciarlante on 2013-10-15

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

[Marco Ceppi (marcoceppi)]

LGTM +1, only comment is from the previous merge about using Hooks.hook() https://code.launchpad.net/~sidnei/charms/precise/apache2/trunk/+merge/190504/comments/440317

review: Approve

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2013-10-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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,59 @@
 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']
+
+dupe_options = [
+    "mode tcp",
+    "option tcplog",
+    "mode http",
+    "option httplog",
+    ]
+
+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 +94,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 +118,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 +138,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 +149,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 +163,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 +178,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 +210,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 +248,47 @@
                          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:
+        # For options that should be duplicated in both frontend and backend,
+        # copy them to both.
+        for o in dupe_options:
+            if any(map(o.strip().startswith, service_options)):
+                fe_options.append(o)
+                be_options.append(o)
+        # 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 and option not in out)
     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 +298,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 +536,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 +559,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 +589,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 +608,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 +648,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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +0000
@@ -0,0 +1,750 @@
+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', 'mode http',
+                           'option httplog', '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',
+            '    mode http',
+            '    option httplog',
+            '    capture request header X-Man',
+            '    option logasap',
+            '',
+            'backend some-name',
+            '    mode http',
+            '    option httplog',
+            '    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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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-16 14:05:24 +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):