Merge lp:~le-charmers/charms/trusty/hacluster/leadership-election into lp:~openstack-charmers/charms/trusty/hacluster/next

[Edward Hope-Morley]

[lp:~le-charmers/charms/trusty/hacluster/leadership-election]

63. By James Page on 2015-06-09

Use trunk helpers

64. By James Page on 2015-06-09

Resync helpers

Unmerged revisions

64. By James Page on 2015-06-09

Resync helpers

63. By James Page on 2015-06-09

Use trunk helpers

62. By Edward Hope-Morley on 2015-04-01

synced l/e ch

61. By Edward Hope-Morley on 2015-03-26

synced /next and le ch

60. By Edward Hope-Morley on 2015-03-26

synced charm-helpers

59. By Billy Olsen on 2015-03-13

Add wait between stop/start because a restart wedges pacemaker

58. By Billy Olsen on 2015-03-13

Update quorum expected vote count for multicast.

57. By Billy Olsen on 2015-03-13

Fix check for two_node check

56. By Billy Olsen on 2015-03-12

Remove two_node and transport change checks for now.

55. By Billy Olsen on 2015-03-12

ch sync and lint cleanup

=== modified file 'hooks/charmhelpers/contrib/hahelpers/cluster.py'
--- hooks/charmhelpers/contrib/hahelpers/cluster.py	2015-04-30 19:35:31 +0000
+++ hooks/charmhelpers/contrib/hahelpers/cluster.py	2015-06-09 10:12:24 +0000
@@ -44,13 +44,22 @@
     ERROR,
     WARNING,
     unit_get,
+    is_leader as juju_is_leader
 )
 from charmhelpers.core.decorators import (
     retry_on_exception,
 )
-from charmhelpers.core.strutils import (
-    bool_from_string,
-)
+<<<<<<< TREE
+from charmhelpers.core.strutils import (
+    bool_from_string,
+)
+=======
+from charmhelpers.core.strutils import (
+    bool_from_string,
+)
+
+DC_RESOURCE_NAME = 'DC'
+>>>>>>> MERGE-SOURCE
 
 
 class HAIncompleteConfig(Exception):
@@ -61,17 +70,30 @@
     pass
 
 
+class CRMDCNotFound(Exception):
+    pass
+
+
 def is_elected_leader(resource):
     """
     Returns True if the charm executing this is the elected cluster leader.
 
     It relies on two mechanisms to determine leadership:
-        1. If the charm is part of a corosync cluster, call corosync to
+        1. If juju is sufficiently new and leadership election is supported,
+        the is_leader command will be used.
+        2. If the charm is part of a corosync cluster, call corosync to
         determine leadership.
-        2. If the charm is not part of a corosync cluster, the leader is
+        3. If the charm is not part of a corosync cluster, the leader is
         determined as being "the alive unit with the lowest unit numer". In
         other words, the oldest surviving unit.
     """
+    try:
+        return juju_is_leader()
+    except NotImplementedError:
+        log('Juju leadership election feature not enabled'
+            ', using fallback support',
+            level=WARNING)
+
     if is_clustered():
         if not is_crm_leader(resource):
             log('Deferring action to CRM leader.', level=INFO)
@@ -95,7 +117,33 @@
     return False
 
 
-@retry_on_exception(5, base_delay=2, exc_type=CRMResourceNotFound)
+def is_crm_dc():
+    """
+    Determine leadership by querying the pacemaker Designated Controller
+    """
+    cmd = ['crm', 'status']
+    try:
+        status = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        if not isinstance(status, six.text_type):
+            status = six.text_type(status, "utf-8")
+    except subprocess.CalledProcessError as ex:
+        raise CRMDCNotFound(str(ex))
+
+    current_dc = ''
+    for line in status.split('\n'):
+        if line.startswith('Current DC'):
+            # Current DC: juju-lytrusty-machine-2 (168108163) - partition with quorum
+            current_dc = line.split(':')[1].split()[0]
+    if current_dc == get_unit_hostname():
+        return True
+    elif current_dc == 'NONE':
+        raise CRMDCNotFound('Current DC: NONE')
+
+    return False
+
+
+@retry_on_exception(5, base_delay=2,
+                    exc_type=(CRMResourceNotFound, CRMDCNotFound))
 def is_crm_leader(resource, retry=False):
     """
     Returns True if the charm calling this is the elected corosync leader,
@@ -104,6 +152,8 @@
     We allow this operation to be retried to avoid the possibility of getting a
     false negative. See LP #1396246 for more info.
     """
+    if resource == DC_RESOURCE_NAME:
+        return is_crm_dc()
     cmd = ['crm', 'resource', 'show', resource]
     try:
         status = subprocess.check_output(cmd, stderr=subprocess.STDOUT)

=== modified file 'hooks/charmhelpers/contrib/openstack/utils.py'
--- hooks/charmhelpers/contrib/openstack/utils.py	2015-04-30 19:35:31 +0000
+++ hooks/charmhelpers/contrib/openstack/utils.py	2015-06-09 10:12:24 +0000
@@ -53,9 +53,13 @@
     get_ipv6_addr
 )
 
+from charmhelpers.contrib.python.packages import (
+    pip_create_virtualenv,
+    pip_install,
+)
+
 from charmhelpers.core.host import lsb_release, mounts, umount
 from charmhelpers.fetch import apt_install, apt_cache, install_remote
-from charmhelpers.contrib.python.packages import pip_install
 from charmhelpers.contrib.storage.linux.utils import is_block_device, zap_disk
 from charmhelpers.contrib.storage.linux.loopback import ensure_loopback_device
 
@@ -497,6 +501,7 @@
 requirements_dir = None
 
 
+<<<<<<< TREE
 def git_clone_and_install(projects_yaml, core_project):
     """
     Clone/install all specified OpenStack repositories.
@@ -584,10 +589,118 @@
         juju_log('Directory already exists at {}. '
                  'No need to create directory.'.format(parent_dir))
         os.mkdir(parent_dir)
+=======
+def _git_yaml_load(projects_yaml):
+    """
+    Load the specified yaml into a dictionary.
+    """
+    if not projects_yaml:
+        return None
+
+    return yaml.load(projects_yaml)
+
+
+def git_clone_and_install(projects_yaml, core_project, depth=1):
+    """
+    Clone/install all specified OpenStack repositories.
+
+    The expected format of projects_yaml is:
+        repositories:
+          - {name: keystone,
+             repository: 'git://git.openstack.org/openstack/keystone.git',
+             branch: 'stable/icehouse'}
+          - {name: requirements,
+             repository: 'git://git.openstack.org/openstack/requirements.git',
+             branch: 'stable/icehouse'}
+        directory: /mnt/openstack-git
+        http_proxy: squid-proxy-url
+        https_proxy: squid-proxy-url
+
+        The directory, http_proxy, and https_proxy keys are optional.
+    """
+    global requirements_dir
+    parent_dir = '/mnt/openstack-git'
+    http_proxy = None
+
+    projects = _git_yaml_load(projects_yaml)
+    _git_validate_projects_yaml(projects, core_project)
+
+    old_environ = dict(os.environ)
+
+    if 'http_proxy' in projects.keys():
+        http_proxy = projects['http_proxy']
+        os.environ['http_proxy'] = projects['http_proxy']
+    if 'https_proxy' in projects.keys():
+        os.environ['https_proxy'] = projects['https_proxy']
+
+    if 'directory' in projects.keys():
+        parent_dir = projects['directory']
+
+    pip_create_virtualenv(os.path.join(parent_dir, 'venv'))
+
+    for p in projects['repositories']:
+        repo = p['repository']
+        branch = p['branch']
+        if p['name'] == 'requirements':
+            repo_dir = _git_clone_and_install_single(repo, branch, depth,
+                                                     parent_dir, http_proxy,
+                                                     update_requirements=False)
+            requirements_dir = repo_dir
+        else:
+            repo_dir = _git_clone_and_install_single(repo, branch, depth,
+                                                     parent_dir, http_proxy,
+                                                     update_requirements=True)
+
+    os.environ = old_environ
+
+
+def _git_validate_projects_yaml(projects, core_project):
+    """
+    Validate the projects yaml.
+    """
+    _git_ensure_key_exists('repositories', projects)
+
+    for project in projects['repositories']:
+        _git_ensure_key_exists('name', project.keys())
+        _git_ensure_key_exists('repository', project.keys())
+        _git_ensure_key_exists('branch', project.keys())
+
+    if projects['repositories'][0]['name'] != 'requirements':
+        error_out('{} git repo must be specified first'.format('requirements'))
+
+    if projects['repositories'][-1]['name'] != core_project:
+        error_out('{} git repo must be specified last'.format(core_project))
+
+
+def _git_ensure_key_exists(key, keys):
+    """
+    Ensure that key exists in keys.
+    """
+    if key not in keys:
+        error_out('openstack-origin-git key \'{}\' is missing'.format(key))
+
+
+def _git_clone_and_install_single(repo, branch, depth, parent_dir, http_proxy,
+                                  update_requirements):
+    """
+    Clone and install a single git repository.
+    """
+    dest_dir = os.path.join(parent_dir, os.path.basename(repo))
+
+    if not os.path.exists(parent_dir):
+        juju_log('Directory already exists at {}. '
+                 'No need to create directory.'.format(parent_dir))
+        os.mkdir(parent_dir)
+>>>>>>> MERGE-SOURCE
 
     if not os.path.exists(dest_dir):
         juju_log('Cloning git repo: {}, branch: {}'.format(repo, branch))
+<<<<<<< TREE
         repo_dir = install_remote(repo, dest=parent_dir, branch=branch)
+=======
+        repo_dir = install_remote(repo, dest=parent_dir, branch=branch,
+                                  depth=depth)
+>>>>>>> MERGE-SOURCE
     else:
         repo_dir = dest_dir
 
@@ -598,7 +711,12 @@
         _git_update_requirements(repo_dir, requirements_dir)
 
     juju_log('Installing git repo from dir: {}'.format(repo_dir))
-    pip_install(repo_dir)
+    if http_proxy:
+        pip_install(repo_dir, proxy=http_proxy,
+                    venv=os.path.join(parent_dir, 'venv'))
+    else:
+        pip_install(repo_dir,
+                    venv=os.path.join(parent_dir, 'venv'))
 
     return repo_dir
 
@@ -619,6 +737,7 @@
         package = os.path.basename(package_dir)
         error_out("Error updating {} from global-requirements.txt".format(package))
     os.chdir(orig_dir)
+<<<<<<< TREE
 
 
 def git_src_dir(projects_yaml, project):
@@ -640,3 +759,49 @@
             return os.path.join(parent_dir, os.path.basename(p['repository']))
 
     return None
+=======
+
+
+def git_pip_venv_dir(projects_yaml):
+    """
+    Return the pip virtualenv path.
+    """
+    parent_dir = '/mnt/openstack-git'
+
+    projects = _git_yaml_load(projects_yaml)
+
+    if 'directory' in projects.keys():
+        parent_dir = projects['directory']
+
+    return os.path.join(parent_dir, 'venv')
+
+
+def git_src_dir(projects_yaml, project):
+    """
+    Return the directory where the specified project's source is located.
+    """
+    parent_dir = '/mnt/openstack-git'
+
+    projects = _git_yaml_load(projects_yaml)
+
+    if 'directory' in projects.keys():
+        parent_dir = projects['directory']
+
+    for p in projects['repositories']:
+        if p['name'] == project:
+            return os.path.join(parent_dir, os.path.basename(p['repository']))
+
+    return None
+
+
+def git_yaml_value(projects_yaml, key):
+    """
+    Return the value in projects_yaml for the specified key.
+    """
+    projects = _git_yaml_load(projects_yaml)
+
+    if key in projects.keys():
+        return projects[key]
+
+    return None
+>>>>>>> MERGE-SOURCE

=== modified file 'hooks/charmhelpers/contrib/python/packages.py'
--- hooks/charmhelpers/contrib/python/packages.py	2015-04-30 19:35:31 +0000
+++ hooks/charmhelpers/contrib/python/packages.py	2015-06-09 10:12:24 +0000
@@ -17,8 +17,14 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
 
+<<<<<<< TREE
+=======
+import os
+import subprocess
+
+>>>>>>> MERGE-SOURCE
 from charmhelpers.fetch import apt_install, apt_update
-from charmhelpers.core.hookenv import log
+from charmhelpers.core.hookenv import charm_dir, log
 
 try:
     from pip import main as pip_execute
@@ -51,11 +57,15 @@
     pip_execute(command)
 
 
-def pip_install(package, fatal=False, upgrade=False, **options):
+def pip_install(package, fatal=False, upgrade=False, venv=None, **options):
     """Install a python package"""
-    command = ["install"]
+    if venv:
+        venv_python = os.path.join(venv, 'bin/pip')
+        command = [venv_python, "install"]
+    else:
+        command = ["install"]
 
-    available_options = ('proxy', 'src', 'log', "index-url", )
+    available_options = ('proxy', 'src', 'log', 'index-url', )
     for option in parse_options(options, available_options):
         command.append(option)
 
@@ -69,7 +79,10 @@
 
     log("Installing {} package with options: {}".format(package,
                                                         command))
-    pip_execute(command)
+    if venv:
+        subprocess.check_call(command)
+    else:
+        pip_execute(command)
 
 
 def pip_uninstall(package, **options):
@@ -94,3 +107,16 @@
     """Returns the list of current python installed packages
     """
     return pip_execute(["list"])
+
+
+def pip_create_virtualenv(path=None):
+    """Create an isolated Python environment."""
+    apt_install('python-virtualenv')
+
+    if path:
+        venv_path = path
+    else:
+        venv_path = os.path.join(charm_dir(), 'venv')
+
+    if not os.path.exists(venv_path):
+        subprocess.check_call(['virtualenv', venv_path])

=== modified file 'hooks/charmhelpers/core/hookenv.py'
--- hooks/charmhelpers/core/hookenv.py	2015-04-30 19:35:31 +0000
+++ hooks/charmhelpers/core/hookenv.py	2015-06-09 10:12:24 +0000
@@ -20,13 +20,23 @@
 # Authors:
 #  Charm Helpers Developers <[e-mail]>
 
-from __future__ import print_function
+<<<<<<< TREE
+from __future__ import print_function
+=======
+from __future__ import print_function
+from functools import wraps
+>>>>>>> MERGE-SOURCE
 import os
 import json
 import yaml
 import subprocess
 import sys
-import errno
+<<<<<<< TREE
+import errno
+=======
+import errno
+import tempfile
+>>>>>>> MERGE-SOURCE
 from subprocess import CalledProcessError
 
 import six
@@ -58,15 +68,17 @@
 
     will cache the result of unit_get + 'test' for future calls.
     """
+    @wraps(func)
     def wrapper(*args, **kwargs):
         global cache
         key = str((func, args, kwargs))
         try:
             return cache[key]
         except KeyError:
-            res = func(*args, **kwargs)
-            cache[key] = res
-            return res
+            pass  # Drop out of the exception handler scope.
+        res = func(*args, **kwargs)
+        cache[key] = res
+        return res
     return wrapper
 
 
@@ -178,7 +190,7 @@
 
 def remote_unit():
     """The remote unit for the current relation hook"""
-    return os.environ['JUJU_REMOTE_UNIT']
+    return os.environ.get('JUJU_REMOTE_UNIT', None)
 
 
 def service_name():
@@ -250,6 +262,12 @@
         except KeyError:
             return (self._prev_dict or {})[key]
 
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
     def keys(self):
         prev_keys = []
         if self._prev_dict is not None:
@@ -353,18 +371,49 @@
     """Set relation information for the current unit"""
     relation_settings = relation_settings if relation_settings else {}
     relation_cmd_line = ['relation-set']
+    accepts_file = "--file" in subprocess.check_output(
+        relation_cmd_line + ["--help"], universal_newlines=True)
     if relation_id is not None:
         relation_cmd_line.extend(('-r', relation_id))
-    for k, v in (list(relation_settings.items()) + list(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)
+    settings = relation_settings.copy()
+    settings.update(kwargs)
+    for key, value in settings.items():
+        # Force value to be a string: it always should, but some call
+        # sites pass in things like dicts or numbers.
+        if value is not None:
+            settings[key] = "{}".format(value)
+    if accepts_file:
+        # --file was introduced in Juju 1.23.2. Use it by default if
+        # available, since otherwise we'll break if the relation data is
+        # too big. Ideally we should tell relation-set to read the data from
+        # stdin, but that feature is broken in 1.23.2: Bug #1454678.
+        with tempfile.NamedTemporaryFile(delete=False) as settings_file:
+            settings_file.write(yaml.safe_dump(settings).encode("utf-8"))
+        subprocess.check_call(
+            relation_cmd_line + ["--file", settings_file.name])
+        os.remove(settings_file.name)
+    else:
+        for key, value in settings.items():
+            if value is None:
+                relation_cmd_line.append('{}='.format(key))
+            else:
+                relation_cmd_line.append('{}={}'.format(key, value))
+        subprocess.check_call(relation_cmd_line)
     # Flush cache of any relation-gets for local unit
     flush(local_unit())
 
 
+def relation_clear(r_id=None):
+    ''' Clears any relation data already set on relation r_id '''
+    settings = relation_get(rid=r_id,
+                            unit=local_unit())
+    for setting in settings:
+        if setting not in ['public-address', 'private-address']:
+            settings[setting] = None
+    relation_set(relation_id=r_id,
+                 **settings)
+
+
 @cached
 def relation_ids(reltype=None):
     """A list of relation_ids"""
@@ -509,6 +558,11 @@
         return None
 
 
+def unit_public_ip():
+    """Get this unit's public IP address"""
+    return unit_get('public-address')
+
+
 def unit_private_ip():
     """Get this unit's private IP address"""
     return unit_get('private-address')
@@ -579,29 +633,149 @@
 def charm_dir():
     """Return the root directory of the current charm"""
     return os.environ.get('CHARM_DIR')
-
-
-@cached
-def action_get(key=None):
-    """Gets the value of an action parameter, or all key/value param pairs"""
-    cmd = ['action-get']
-    if key is not None:
-        cmd.append(key)
-    cmd.append('--format=json')
-    action_data = json.loads(subprocess.check_output(cmd).decode('UTF-8'))
-    return action_data
-
-
-def action_set(values):
-    """Sets the values to be returned after the action finishes"""
-    cmd = ['action-set']
-    for k, v in list(values.items()):
-        cmd.append('{}={}'.format(k, v))
-    subprocess.check_call(cmd)
-
-
-def action_fail(message):
-    """Sets the action status to failed and sets the error message.
-
-    The results set by action_set are preserved."""
-    subprocess.check_call(['action-fail', message])
+<<<<<<< TREE
+
+
+@cached
+def action_get(key=None):
+    """Gets the value of an action parameter, or all key/value param pairs"""
+    cmd = ['action-get']
+    if key is not None:
+        cmd.append(key)
+    cmd.append('--format=json')
+    action_data = json.loads(subprocess.check_output(cmd).decode('UTF-8'))
+    return action_data
+
+
+def action_set(values):
+    """Sets the values to be returned after the action finishes"""
+    cmd = ['action-set']
+    for k, v in list(values.items()):
+        cmd.append('{}={}'.format(k, v))
+    subprocess.check_call(cmd)
+
+
+def action_fail(message):
+    """Sets the action status to failed and sets the error message.
+
+    The results set by action_set are preserved."""
+    subprocess.check_call(['action-fail', message])
+=======
+
+
+@cached
+def action_get(key=None):
+    """Gets the value of an action parameter, or all key/value param pairs"""
+    cmd = ['action-get']
+    if key is not None:
+        cmd.append(key)
+    cmd.append('--format=json')
+    action_data = json.loads(subprocess.check_output(cmd).decode('UTF-8'))
+    return action_data
+
+
+def action_set(values):
+    """Sets the values to be returned after the action finishes"""
+    cmd = ['action-set']
+    for k, v in list(values.items()):
+        cmd.append('{}={}'.format(k, v))
+    subprocess.check_call(cmd)
+
+
+def action_fail(message):
+    """Sets the action status to failed and sets the error message.
+
+    The results set by action_set are preserved."""
+    subprocess.check_call(['action-fail', message])
+
+
+def status_set(workload_state, message):
+    """Set the workload state with a message
+
+    Use status-set to set the workload state with a message which is visible
+    to the user via juju status. If the status-set command is not found then
+    assume this is juju < 1.23 and juju-log the message unstead.
+
+    workload_state -- valid juju workload state.
+    message        -- status update message
+    """
+    valid_states = ['maintenance', 'blocked', 'waiting', 'active']
+    if workload_state not in valid_states:
+        raise ValueError(
+            '{!r} is not a valid workload state'.format(workload_state)
+        )
+    cmd = ['status-set', workload_state, message]
+    try:
+        ret = subprocess.call(cmd)
+        if ret == 0:
+            return
+    except OSError as e:
+        if e.errno != errno.ENOENT:
+            raise
+    log_message = 'status-set failed: {} {}'.format(workload_state,
+                                                    message)
+    log(log_message, level='INFO')
+
+
+def status_get():
+    """Retrieve the previously set juju workload state
+
+    If the status-set command is not found then assume this is juju < 1.23 and
+    return 'unknown'
+    """
+    cmd = ['status-get']
+    try:
+        raw_status = subprocess.check_output(cmd, universal_newlines=True)
+        status = raw_status.rstrip()
+        return status
+    except OSError as e:
+        if e.errno == errno.ENOENT:
+            return 'unknown'
+        else:
+            raise
+
+
+def translate_exc(from_exc, to_exc):
+    def inner_translate_exc1(f):
+        def inner_translate_exc2(*args, **kwargs):
+            try:
+                return f(*args, **kwargs)
+            except from_exc:
+                raise to_exc
+
+        return inner_translate_exc2
+
+    return inner_translate_exc1
+
+
+@translate_exc(from_exc=OSError, to_exc=NotImplementedError)
+def is_leader():
+    """Does the current unit hold the juju leadership
+
+    Uses juju to determine whether the current unit is the leader of its peers
+    """
+    cmd = ['is-leader', '--format=json']
+    return json.loads(subprocess.check_output(cmd).decode('UTF-8'))
+
+
+@translate_exc(from_exc=OSError, to_exc=NotImplementedError)
+def leader_get(attribute=None):
+    """Juju leader get value(s)"""
+    cmd = ['leader-get', '--format=json'] + [attribute or '-']
+    return json.loads(subprocess.check_output(cmd).decode('UTF-8'))
+
+
+@translate_exc(from_exc=OSError, to_exc=NotImplementedError)
+def leader_set(settings=None, **kwargs):
+    """Juju leader set value(s)"""
+    log("Juju leader-set '%s'" % (settings), level=DEBUG)
+    cmd = ['leader-set']
+    settings = settings or {}
+    settings.update(kwargs)
+    for k, v in settings.iteritems():
+        if v is None:
+            cmd.append('{}='.format(k))
+        else:
+            cmd.append('{}={}'.format(k, v))
+    subprocess.check_call(cmd)
+>>>>>>> MERGE-SOURCE

=== modified file 'hooks/charmhelpers/core/host.py'
--- hooks/charmhelpers/core/host.py	2015-04-30 19:35:31 +0000
+++ hooks/charmhelpers/core/host.py	2015-06-09 10:12:24 +0000
@@ -90,7 +90,7 @@
             ['service', service_name, 'status'],
             stderr=subprocess.STDOUT).decode('UTF-8')
     except subprocess.CalledProcessError as e:
-        return 'unrecognized service' not in e.output
+        return b'unrecognized service' not in e.output
     else:
         return True
 

=== modified file 'hooks/charmhelpers/core/services/base.py'
--- hooks/charmhelpers/core/services/base.py	2015-01-26 10:44:46 +0000
+++ hooks/charmhelpers/core/services/base.py	2015-06-09 10:12:24 +0000
@@ -15,9 +15,9 @@
 # along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
 
 import os
-import re
 import json
-from collections import Iterable
+from inspect import getargspec
+from collections import Iterable, OrderedDict
 
 from charmhelpers.core import host
 from charmhelpers.core import hookenv
@@ -119,7 +119,7 @@
         """
         self._ready_file = os.path.join(hookenv.charm_dir(), 'READY-SERVICES.json')
         self._ready = None
-        self.services = {}
+        self.services = OrderedDict()
         for service in services or []:
             service_name = service['service']
             self.services[service_name] = service
@@ -132,8 +132,8 @@
         if hook_name == 'stop':
             self.stop_services()
         else:
+            self.reconfigure_services()
             self.provide_data()
-            self.reconfigure_services()
         cfg = hookenv.config()
         if cfg.implicit_save:
             cfg.save()
@@ -145,15 +145,36 @@
         A provider must have a `name` attribute, which indicates which relation
         to set data on, and a `provide_data()` method, which returns a dict of
         data to set.
+
+        The `provide_data()` method can optionally accept two parameters:
+
+          * ``remote_service`` The name of the remote service that the data will
+            be provided to.  The `provide_data()` method will be called once
+            for each connected service (not unit).  This allows the method to
+            tailor its data to the given service.
+          * ``service_ready`` Whether or not the service definition had all of
+            its requirements met, and thus the ``data_ready`` callbacks run.
+
+        Note that the ``provided_data`` methods are now called **after** the
+        ``data_ready`` callbacks are run.  This gives the ``data_ready`` callbacks
+        a chance to generate any data necessary for the providing to the remote
+        services.
         """
-        hook_name = hookenv.hook_name()
-        for service in self.services.values():
+        for service_name, service in self.services.items():
+            service_ready = self.is_ready(service_name)
             for provider in service.get('provided_data', []):
-                if re.match(r'{}-relation-(joined|changed)'.format(provider.name), hook_name):
-                    data = provider.provide_data()
-                    _ready = provider._is_ready(data) if hasattr(provider, '_is_ready') else data
-                    if _ready:
-                        hookenv.relation_set(None, data)
+                for relid in hookenv.relation_ids(provider.name):
+                    units = hookenv.related_units(relid)
+                    if not units:
+                        continue
+                    remote_service = units[0].split('/')[0]
+                    argspec = getargspec(provider.provide_data)
+                    if len(argspec.args) > 1:
+                        data = provider.provide_data(remote_service, service_ready)
+                    else:
+                        data = provider.provide_data()
+                    if data:
+                        hookenv.relation_set(relid, data)
 
     def reconfigure_services(self, *service_names):
         """

=== added file 'hooks/charmhelpers/core/strutils.py'
--- hooks/charmhelpers/core/strutils.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/core/strutils.py	2015-06-09 10:12:24 +0000
@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2014-2015 Canonical Limited.
+#
+# This file is part of charm-helpers.
+#
+# charm-helpers is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# charm-helpers is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
+
+import six
+
+
+def bool_from_string(value):
+    """Interpret string value as boolean.
+
+    Returns True if value translates to True otherwise False.
+    """
+    if isinstance(value, six.string_types):
+        value = six.text_type(value)
+    else:
+        msg = "Unable to interpret non-string value '%s' as boolean" % (value)
+        raise ValueError(msg)
+
+    value = value.strip().lower()
+
+    if value in ['y', 'yes', 'true', 't', 'on']:
+        return True
+    elif value in ['n', 'no', 'false', 'f', 'off']:
+        return False
+
+    msg = "Unable to interpret string value '%s' as boolean" % (value)
+    raise ValueError(msg)

=== renamed file 'hooks/charmhelpers/core/strutils.py' => 'hooks/charmhelpers/core/strutils.py.moved'
=== added file 'hooks/charmhelpers/core/unitdata.py'
--- hooks/charmhelpers/core/unitdata.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/core/unitdata.py	2015-06-09 10:12:24 +0000
@@ -0,0 +1,477 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014-2015 Canonical Limited.
+#
+# This file is part of charm-helpers.
+#
+# charm-helpers is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# charm-helpers is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+# Authors:
+#  Kapil Thangavelu <[e-mail]>
+#
+"""
+Intro
+-----
+
+A simple way to store state in units. This provides a key value
+storage with support for versioned, transactional operation,
+and can calculate deltas from previous values to simplify unit logic
+when processing changes.
+
+
+Hook Integration
+----------------
+
+There are several extant frameworks for hook execution, including
+
+ - charmhelpers.core.hookenv.Hooks
+ - charmhelpers.core.services.ServiceManager
+
+The storage classes are framework agnostic, one simple integration is
+via the HookData contextmanager. It will record the current hook
+execution environment (including relation data, config data, etc.),
+setup a transaction and allow easy access to the changes from
+previously seen values. One consequence of the integration is the
+reservation of particular keys ('rels', 'unit', 'env', 'config',
+'charm_revisions') for their respective values.
+
+Here's a fully worked integration example using hookenv.Hooks::
+
+       from charmhelper.core import hookenv, unitdata
+
+       hook_data = unitdata.HookData()
+       db = unitdata.kv()
+       hooks = hookenv.Hooks()
+
+       @hooks.hook
+       def config_changed():
+           # Print all changes to configuration from previously seen
+           # values.
+           for changed, (prev, cur) in hook_data.conf.items():
+               print('config changed', changed,
+                     'previous value', prev,
+                     'current value',  cur)
+
+           # Get some unit specific bookeeping
+           if not db.get('pkg_key'):
+               key = urllib.urlopen('https://example.com/pkg_key').read()
+               db.set('pkg_key', key)
+
+           # Directly access all charm config as a mapping.
+           conf = db.getrange('config', True)
+
+           # Directly access all relation data as a mapping
+           rels = db.getrange('rels', True)
+
+       if __name__ == '__main__':
+           with hook_data():
+               hook.execute()
+
+
+A more basic integration is via the hook_scope context manager which simply
+manages transaction scope (and records hook name, and timestamp)::
+
+  >>> from unitdata import kv
+  >>> db = kv()
+  >>> with db.hook_scope('install'):
+  ...    # do work, in transactional scope.
+  ...    db.set('x', 1)
+  >>> db.get('x')
+  1
+
+
+Usage
+-----
+
+Values are automatically json de/serialized to preserve basic typing
+and complex data struct capabilities (dicts, lists, ints, booleans, etc).
+
+Individual values can be manipulated via get/set::
+
+   >>> kv.set('y', True)
+   >>> kv.get('y')
+   True
+
+   # We can set complex values (dicts, lists) as a single key.
+   >>> kv.set('config', {'a': 1, 'b': True'})
+
+   # Also supports returning dictionaries as a record which
+   # provides attribute access.
+   >>> config = kv.get('config', record=True)
+   >>> config.b
+   True
+
+
+Groups of keys can be manipulated with update/getrange::
+
+   >>> kv.update({'z': 1, 'y': 2}, prefix="gui.")
+   >>> kv.getrange('gui.', strip=True)
+   {'z': 1, 'y': 2}
+
+When updating values, its very helpful to understand which values
+have actually changed and how have they changed. The storage
+provides a delta method to provide for this::
+
+   >>> data = {'debug': True, 'option': 2}
+   >>> delta = kv.delta(data, 'config.')
+   >>> delta.debug.previous
+   None
+   >>> delta.debug.current
+   True
+   >>> delta
+   {'debug': (None, True), 'option': (None, 2)}
+
+Note the delta method does not persist the actual change, it needs to
+be explicitly saved via 'update' method::
+
+   >>> kv.update(data, 'config.')
+
+Values modified in the context of a hook scope retain historical values
+associated to the hookname.
+
+   >>> with db.hook_scope('config-changed'):
+   ...      db.set('x', 42)
+   >>> db.gethistory('x')
+   [(1, u'x', 1, u'install', u'2015-01-21T16:49:30.038372'),
+    (2, u'x', 42, u'config-changed', u'2015-01-21T16:49:30.038786')]
+
+"""
+
+import collections
+import contextlib
+import datetime
+import json
+import os
+import pprint
+import sqlite3
+import sys
+
+__author__ = 'Kapil Thangavelu <[e-mail]>'
+
+
+class Storage(object):
+    """Simple key value database for local unit state within charms.
+
+    Modifications are automatically committed at hook exit. That's
+    currently regardless of exit code.
+
+    To support dicts, lists, integer, floats, and booleans values
+    are automatically json encoded/decoded.
+    """
+    def __init__(self, path=None):
+        self.db_path = path
+        if path is None:
+            self.db_path = os.path.join(
+                os.environ.get('CHARM_DIR', ''), '.unit-state.db')
+        self.conn = sqlite3.connect('%s' % self.db_path)
+        self.cursor = self.conn.cursor()
+        self.revision = None
+        self._closed = False
+        self._init()
+
+    def close(self):
+        if self._closed:
+            return
+        self.flush(False)
+        self.cursor.close()
+        self.conn.close()
+        self._closed = True
+
+    def _scoped_query(self, stmt, params=None):
+        if params is None:
+            params = []
+        return stmt, params
+
+    def get(self, key, default=None, record=False):
+        self.cursor.execute(
+            *self._scoped_query(
+                'select data from kv where key=?', [key]))
+        result = self.cursor.fetchone()
+        if not result:
+            return default
+        if record:
+            return Record(json.loads(result[0]))
+        return json.loads(result[0])
+
+    def getrange(self, key_prefix, strip=False):
+        stmt = "select key, data from kv where key like '%s%%'" % key_prefix
+        self.cursor.execute(*self._scoped_query(stmt))
+        result = self.cursor.fetchall()
+
+        if not result:
+            return None
+        if not strip:
+            key_prefix = ''
+        return dict([
+            (k[len(key_prefix):], json.loads(v)) for k, v in result])
+
+    def update(self, mapping, prefix=""):
+        for k, v in mapping.items():
+            self.set("%s%s" % (prefix, k), v)
+
+    def unset(self, key):
+        self.cursor.execute('delete from kv where key=?', [key])
+        if self.revision and self.cursor.rowcount:
+            self.cursor.execute(
+                'insert into kv_revisions values (?, ?, ?)',
+                [key, self.revision, json.dumps('DELETED')])
+
+    def set(self, key, value):
+        serialized = json.dumps(value)
+
+        self.cursor.execute(
+            'select data from kv where key=?', [key])
+        exists = self.cursor.fetchone()
+
+        # Skip mutations to the same value
+        if exists:
+            if exists[0] == serialized:
+                return value
+
+        if not exists:
+            self.cursor.execute(
+                'insert into kv (key, data) values (?, ?)',
+                (key, serialized))
+        else:
+            self.cursor.execute('''
+            update kv
+            set data = ?
+            where key = ?''', [serialized, key])
+
+        # Save
+        if not self.revision:
+            return value
+
+        self.cursor.execute(
+            'select 1 from kv_revisions where key=? and revision=?',
+            [key, self.revision])
+        exists = self.cursor.fetchone()
+
+        if not exists:
+            self.cursor.execute(
+                '''insert into kv_revisions (
+                revision, key, data) values (?, ?, ?)''',
+                (self.revision, key, serialized))
+        else:
+            self.cursor.execute(
+                '''
+                update kv_revisions
+                set data = ?
+                where key = ?
+                and   revision = ?''',
+                [serialized, key, self.revision])
+
+        return value
+
+    def delta(self, mapping, prefix):
+        """
+        return a delta containing values that have changed.
+        """
+        previous = self.getrange(prefix, strip=True)
+        if not previous:
+            pk = set()
+        else:
+            pk = set(previous.keys())
+        ck = set(mapping.keys())
+        delta = DeltaSet()
+
+        # added
+        for k in ck.difference(pk):
+            delta[k] = Delta(None, mapping[k])
+
+        # removed
+        for k in pk.difference(ck):
+            delta[k] = Delta(previous[k], None)
+
+        # changed
+        for k in pk.intersection(ck):
+            c = mapping[k]
+            p = previous[k]
+            if c != p:
+                delta[k] = Delta(p, c)
+
+        return delta
+
+    @contextlib.contextmanager
+    def hook_scope(self, name=""):
+        """Scope all future interactions to the current hook execution
+        revision."""
+        assert not self.revision
+        self.cursor.execute(
+            'insert into hooks (hook, date) values (?, ?)',
+            (name or sys.argv[0],
+             datetime.datetime.utcnow().isoformat()))
+        self.revision = self.cursor.lastrowid
+        try:
+            yield self.revision
+            self.revision = None
+        except:
+            self.flush(False)
+            self.revision = None
+            raise
+        else:
+            self.flush()
+
+    def flush(self, save=True):
+        if save:
+            self.conn.commit()
+        elif self._closed:
+            return
+        else:
+            self.conn.rollback()
+
+    def _init(self):
+        self.cursor.execute('''
+            create table if not exists kv (
+               key text,
+               data text,
+               primary key (key)
+               )''')
+        self.cursor.execute('''
+            create table if not exists kv_revisions (
+               key text,
+               revision integer,
+               data text,
+               primary key (key, revision)
+               )''')
+        self.cursor.execute('''
+            create table if not exists hooks (
+               version integer primary key autoincrement,
+               hook text,
+               date text
+               )''')
+        self.conn.commit()
+
+    def gethistory(self, key, deserialize=False):
+        self.cursor.execute(
+            '''
+            select kv.revision, kv.key, kv.data, h.hook, h.date
+            from kv_revisions kv,
+                 hooks h
+            where kv.key=?
+             and kv.revision = h.version
+            ''', [key])
+        if deserialize is False:
+            return self.cursor.fetchall()
+        return map(_parse_history, self.cursor.fetchall())
+
+    def debug(self, fh=sys.stderr):
+        self.cursor.execute('select * from kv')
+        pprint.pprint(self.cursor.fetchall(), stream=fh)
+        self.cursor.execute('select * from kv_revisions')
+        pprint.pprint(self.cursor.fetchall(), stream=fh)
+
+
+def _parse_history(d):
+    return (d[0], d[1], json.loads(d[2]), d[3],
+            datetime.datetime.strptime(d[-1], "%Y-%m-%dT%H:%M:%S.%f"))
+
+
+class HookData(object):
+    """Simple integration for existing hook exec frameworks.
+
+    Records all unit information, and stores deltas for processing
+    by the hook.
+
+    Sample::
+
+       from charmhelper.core import hookenv, unitdata
+
+       changes = unitdata.HookData()
+       db = unitdata.kv()
+       hooks = hookenv.Hooks()
+
+       @hooks.hook
+       def config_changed():
+           # View all changes to configuration
+           for changed, (prev, cur) in changes.conf.items():
+               print('config changed', changed,
+                     'previous value', prev,
+                     'current value',  cur)
+
+           # Get some unit specific bookeeping
+           if not db.get('pkg_key'):
+               key = urllib.urlopen('https://example.com/pkg_key').read()
+               db.set('pkg_key', key)
+
+       if __name__ == '__main__':
+           with changes():
+               hook.execute()
+
+    """
+    def __init__(self):
+        self.kv = kv()
+        self.conf = None
+        self.rels = None
+
+    @contextlib.contextmanager
+    def __call__(self):
+        from charmhelpers.core import hookenv
+        hook_name = hookenv.hook_name()
+
+        with self.kv.hook_scope(hook_name):
+            self._record_charm_version(hookenv.charm_dir())
+            delta_config, delta_relation = self._record_hook(hookenv)
+            yield self.kv, delta_config, delta_relation
+
+    def _record_charm_version(self, charm_dir):
+        # Record revisions.. charm revisions are meaningless
+        # to charm authors as they don't control the revision.
+        # so logic dependnent on revision is not particularly
+        # useful, however it is useful for debugging analysis.
+        charm_rev = open(
+            os.path.join(charm_dir, 'revision')).read().strip()
+        charm_rev = charm_rev or '0'
+        revs = self.kv.get('charm_revisions', [])
+        if charm_rev not in revs:
+            revs.append(charm_rev.strip() or '0')
+            self.kv.set('charm_revisions', revs)
+
+    def _record_hook(self, hookenv):
+        data = hookenv.execution_environment()
+        self.conf = conf_delta = self.kv.delta(data['conf'], 'config')
+        self.rels = rels_delta = self.kv.delta(data['rels'], 'rels')
+        self.kv.set('env', dict(data['env']))
+        self.kv.set('unit', data['unit'])
+        self.kv.set('relid', data.get('relid'))
+        return conf_delta, rels_delta
+
+
+class Record(dict):
+
+    __slots__ = ()
+
+    def __getattr__(self, k):
+        if k in self:
+            return self[k]
+        raise AttributeError(k)
+
+
+class DeltaSet(Record):
+
+    __slots__ = ()
+
+
+Delta = collections.namedtuple('Delta', ['previous', 'current'])
+
+
+_KV = None
+
+
+def kv():
+    global _KV
+    if _KV is None:
+        _KV = Storage()
+    return _KV

=== renamed file 'hooks/charmhelpers/core/unitdata.py' => 'hooks/charmhelpers/core/unitdata.py.moved'
=== modified file 'hooks/charmhelpers/fetch/__init__.py'
--- hooks/charmhelpers/fetch/__init__.py	2015-01-26 10:44:46 +0000
+++ hooks/charmhelpers/fetch/__init__.py	2015-06-09 10:12:24 +0000
@@ -158,7 +158,7 @@
 
 def apt_cache(in_memory=True):
     """Build and return an apt cache"""
-    import apt_pkg
+    from apt import apt_pkg
     apt_pkg.init()
     if in_memory:
         apt_pkg.config.set("Dir::Cache::pkgcache", "")

=== modified file 'hooks/charmhelpers/fetch/giturl.py'
--- hooks/charmhelpers/fetch/giturl.py	2015-04-30 19:35:31 +0000
+++ hooks/charmhelpers/fetch/giturl.py	2015-06-09 10:12:24 +0000
@@ -45,14 +45,16 @@
         else:
             return True
 
-    def clone(self, source, dest, branch):
+    def clone(self, source, dest, branch, depth=None):
         if not self.can_handle(source):
             raise UnhandledSource("Cannot handle {}".format(source))
 
-        repo = Repo.clone_from(source, dest)
-        repo.git.checkout(branch)
+        if depth:
+            Repo.clone_from(source, dest, branch=branch, depth=depth)
+        else:
+            Repo.clone_from(source, dest, branch=branch)
 
-    def install(self, source, branch="master", dest=None):
+    def install(self, source, branch="master", dest=None, depth=None):
         url_parts = self.parse_url(source)
         branch_name = url_parts.path.strip("/").split("/")[-1]
         if dest:
@@ -63,7 +65,7 @@
         if not os.path.exists(dest_dir):
             mkdir(dest_dir, perms=0o755)
         try:
-            self.clone(source, dest_dir, branch)
+            self.clone(source, dest_dir, branch, depth)
         except GitCommandError as e:
             raise UnhandledSource(e.message)
         except OSError as e:

=== added file 'hooks/cmap.py'
--- hooks/cmap.py	1970-01-01 00:00:00 +0000
+++ hooks/cmap.py	2015-06-09 10:12:24 +0000
@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright 2015 Canonical Limited.
+#
+
+import subprocess
+from __builtin__ import classmethod
+
+
+class CMap(object):
+
+    UINT_32 = 'u32'
+
+    STRING = 'str'
+
+    class Property(object):
+        """Represents a property within the corosync cmap"""
+
+        def __init__(self, key, k_type, value):
+            self.key = key
+            if k_type.startswith('('):
+                self.k_type = k_type[1:-1]
+            else:
+                self.k_type = k_type
+            self.value = value
+
+        def __eq__(self, o):
+            return str(self) == str(o)
+
+        def __str__(self):
+            return self.key
+
+    def __init__(self):
+        super(CMap, self).__init__()
+
+    def _parse_property(self, line):
+        """Creates a property from an output line from the corosync-cmapctl
+        command output."""
+        k, t, _, v = line.split(' ')
+        return CMap.Property(k, t, v)
+
+    @property
+    def nodelist(self):
+        """Returns the nodelist properties in the current cmap for corosync."""
+        return self.get_properties('nodelist')
+
+    def get_property(self, key):
+        """Returns the current values of a property in the current cmap."""
+        props = self.get_properties(key)
+        if props:
+            return props[0]
+        else:
+            return None
+
+    def get_properties(self, key):
+        """Returns a list of Property objects containing the values."""
+        output = subprocess.check_output(['corosync-cmapctl', key])
+        output = output.strip()
+        return [self._parse_property(line) for line in output.split('\n')]
+
+    @classmethod
+    def add(cls, key, k_type, value):
+        """Add an entry to the cmap."""
+        subprocess.check_call(['corosync-cmapctl', '-s', key,
+                               k_type, str(value)])
+
+    # Alias set to add
+    set = add
+
+    @classmethod
+    def add_property(cls, prop):
+        """Adds a CMap.Property to the corosync cmap.
+
+        :param prop: a CMap.Property which should be added.
+        """
+        cls.add(prop.key, prop.k_type, prop.value)
+
+    @classmethod
+    def delete(cls, key, delete_all=False):
+        delete_me = key
+        if hasattr(key, 'key'):
+            delete_me = key.key
+        flag = '-D' if delete_all else '-d'
+        subprocess.check_call(['corosync-cmapctl', flag, delete_me])

=== added symlink 'hooks/hanode-relation-departed'
=== target is u'hooks.py'
=== modified file 'hooks/hooks.py'
--- hooks/hooks.py	2015-06-03 12:18:49 +0000
+++ hooks/hooks.py	2015-06-09 10:12:24 +0000
@@ -9,11 +9,20 @@
 
 import pcmk
 import socket
+import six
+import time
+
+from cmap import CMap
 
 from charmhelpers.core.hookenv import (
     log,
+<<<<<<< TREE
     DEBUG,
     INFO,
+=======
+    WARNING,
+    relation_get,
+>>>>>>> MERGE-SOURCE
     related_units,
     relation_ids,
     relation_get,
@@ -22,6 +31,14 @@
     Hooks,
     UnregisteredHookError,
     local_unit,
+<<<<<<< TREE
+=======
+    unit_private_ip,
+    is_leader,
+    leader_set, leader_get,
+    INFO,
+    ERROR,
+>>>>>>> MERGE-SOURCE
 )
 
 from charmhelpers.core.host import (
@@ -117,6 +134,8 @@
 
 @hooks.hook()
 def config_changed():
+    store_cluster_size()
+
     if config('prefer-ipv6'):
         assert_charm_supports_ipv6()
 
@@ -143,6 +162,7 @@
 def upgrade_charm():
     install()
 
+<<<<<<< TREE
     update_nrpe_config()
 
 
@@ -153,11 +173,303 @@
         ensure_ipv6_requirements(None)
 
     ha_relation_changed()
+=======
+
+def restart_corosync():
+    if service_running("pacemaker"):
+        service_stop("pacemaker")
+    service_stop('corosync')
+    # If using a simple restart then there are cases in which
+    # the pacemaker service cannot talk to corosync and times
+    # out, causing long durations of when pacemaker is not available.
+    time.sleep(5)
+    service_start("corosync")
+    service_start("pacemaker")
+
+
+def restart_corosync_on_change():
+    '''Simple decorator to restart corosync if any of its config changes'''
+    def wrap(f):
+        def wrapped_f(*args):
+            checksums = {}
+            for path in COROSYNC_CONF_FILES:
+                checksums[path] = file_hash(path)
+            return_data = f(*args)
+            # NOTE: this assumes that this call is always done around
+            # configure_corosync, which returns true if configuration
+            # files where actually generated
+            if return_data:
+                for path in COROSYNC_CONF_FILES:
+                    if checksums[path] != file_hash(path):
+                        if not path == COROSYNC_CONF:
+                            restart_corosync()
+                            break
+                        if not update_corosync_dynamically():
+                            restart_corosync()
+                            break
+            return return_data
+        return wrapped_f
+    return wrap
+
+
+def update_corosync_dynamically():
+    """
+    Attempts to update corosync dynamically rather than triggering a restart.
+
+    If corosync is using unicast (udpu) transport new nodes are added in by
+    updating the nodelist in the corosync cmap. The quorum and vote count is
+    determined based upon the nodelist (unicast) or the expected vote count
+    (multicast).
+
+    Switching in and out of two_node vote quorum mode requires a restart of
+    the corosync and pacemaker services.
+
+    :returns: True if the corosync configuration was able to be updated on
+              the fly, False if the corosync configuration was not able to
+              be updated on the fly and needs a restart.
+    """
+    # If the corosync services aren't running, then just need to restart.
+    if not service_running('corosync') or not service_running('pacemaker'):
+        return False
+
+    if quorum_two_node_changed():
+        log('Changed the value for the two_node votequorum. '
+            'Restart required.', INFO)
+        return False
+
+    if did_corosync_transport_change():
+        log('Corosync transport changed between unicast and multicast',
+            'Restart required.', INFO)
+        return False
+
+    if get_transport() == 'udpu':
+        # Only need to add in the nodes for unicast because membership
+        # is dynamic for multicast by the nature of multicast.
+        try:
+            add_udp_nodes_into_corosync()
+        except Exception as e:
+            log('Error occurred adding nodes into corosync.', ERROR)
+            log(e, ERROR)
+            return False
+    else:
+        # Need to update the vote count to the expected value.
+        update_multicast_votecount()
+
+    return True
+
+
+def quorum_two_node_changed():
+    """
+    Determines if the current value for the two_node votequorum behavior
+    would be specified differently based on the current in-memory config
+    versus the value being written to disk.
+
+    :returns: True if the two_node value would differ, False otherwise.
+    """
+    corosync_cmap = CMap()
+    prop = corosync_cmap.get_property('runtime.votequorum.two_node')
+    log('Current runtime.votequorum.two_node value is: %s' % prop.value)
+    assert prop is not None
+    expected = '0'
+    if len(get_ha_nodes()) == 2:
+        expected = '1'
+
+    if str(prop.value) == str(expected):
+        return False
+    else:
+        return True
+
+
+def did_corosync_transport_change():
+    """
+    Determines if the current transport mode for corosync changed.
+
+    There's no straightforward way of asking the running corosync which
+    particular transport mode it is using. However, we know that the
+    cluster which is running a unicast (udpu) transport relies on having
+    a nodelist configured, which is available by querying the cmap. Thus
+    if the written mode is 'udp' and there exists a nodelist, then the
+    corosync transport must have changed. The same is true for the opposite
+    scenario.
+
+    :returns: True if the corosync transport changed between unicast and
+              multicast. False if they are the same.
+    """
+    corosync_cmap = CMap()
+    nodelist = corosync_cmap.nodelist
+    transport = get_transport()
+
+    if not nodelist and transport == 'udpu':
+        return True
+    elif nodelist and transport == 'udp':
+        return True
+    else:
+        return False
+
+
+def add_udp_nodes_into_corosync():
+    """
+    Adds a new node dynamically to the cluster for udp nodes.
+
+    Attempts to add a udp node by directly adding the node to the corosync
+    cmap information.
+    """
+    corosync_cmap = CMap()
+    node_props = sorted(corosync_cmap.nodelist, key=lambda x: x.key)
+
+    # Determine the next node index in the node list.
+    node_ids = [int(p.value) for p in node_props if p.key.endswith('nodeid')]
+    nodes_to_add = get_ha_nodes()
+    # Remove the nodes from the node map which are already in the
+    for node_id in node_ids:
+        nodes_to_add.pop(node_id, None)
+        # TODO(wolsen) - a return value of None above will indicate that
+        # there exists an extra node within the configuration and it should
+        # (maybe?) be removed. Revisit this later.
+
+    # For each node which needs to be added, tell the current corosync node
+    # that there is a new node available.
+    for node_id, node_ip in six.iteritems(nodes_to_add):
+        log('Adding node %s with ip %s...' % (node_id, node_ip), INFO)
+        CMap.add('nodelist.node.%s.nodeid' % node_id, CMap.UINT_32, node_id)
+        CMap.add('nodelist.node.%s.ring0_addr' % node_id, CMap.STRING, node_ip)
+
+
+def update_multicast_votecount():
+    """
+    Update the corosync expected vote count dynamically on a running cluster.
+    """
+    corosync_cmap = CMap()
+    current_vote_prop = corosync_cmap.get('quorum.expected_votes')
+    ha_nodes = get_ha_nodes()
+    node_count = len(ha_nodes)
+    expected_value = target_cluster_size()
+    try:
+        # Feature sniff to see if the leadership election capabilities
+        # are present in order to determine what is correct for the
+        # expected vote count.
+        is_leader()
+    except NotImplementedError:
+        expected_value = max(node_count, int(config('cluster-count')))
+
+    if not int(current_vote_prop.value) == expected_value:
+        log('Updating quorum.expected_votes from %s to %s' %
+            (current_vote_prop.value, expected_value), INFO)
+        CMap.set('quorum.expected_votes', CMap.UINT_32, expected_value)
+
+
+@restart_corosync_on_change()
+def configure_corosync():
+    log('Configuring and (maybe) restarting corosync')
+    return emit_base_conf() and emit_corosync_conf()
+
+
+def configure_monitor_host():
+    '''Configure extra monitor host for better network failure detection'''
+    log('Checking monitor host configuration')
+    monitor_host = config('monitor_host')
+    if monitor_host:
+        if not pcmk.crm_opt_exists('ping'):
+            log('Implementing monitor host'
+                ' configuration (host: %s)' % monitor_host)
+            monitor_interval = config('monitor_interval')
+            cmd = 'crm -w -F configure primitive ping' \
+                ' ocf:pacemaker:ping params host_list="%s"' \
+                ' multiplier="100" op monitor interval="%s"' %\
+                (monitor_host, monitor_interval)
+            pcmk.commit(cmd)
+            cmd = 'crm -w -F configure clone cl_ping ping' \
+                ' meta interleave="true"'
+            pcmk.commit(cmd)
+        else:
+            log('Reconfiguring monitor host'
+                ' configuration (host: %s)' % monitor_host)
+            cmd = 'crm -w -F resource param ping set host_list="%s"' %\
+                monitor_host
+    else:
+        if pcmk.crm_opt_exists('ping'):
+            log('Disabling monitor host configuration')
+            pcmk.commit('crm -w -F resource stop ping')
+            pcmk.commit('crm -w -F configure delete ping')
+
+
+def configure_cluster_global():
+    '''Configure global cluster options'''
+    log('Applying global cluster configuration')
+    if int(config('cluster_count')) >= 3:
+        # NOTE(jamespage) if 3 or more nodes, then quorum can be
+        # managed effectively, so stop if quorum lost
+        log('Configuring no-quorum-policy to stop')
+        cmd = "crm configure property no-quorum-policy=stop"
+    else:
+        # NOTE(jamespage) if less that 3 nodes, quorum not possible
+        # so ignore
+        log('Configuring no-quorum-policy to ignore')
+        cmd = "crm configure property no-quorum-policy=ignore"
+    pcmk.commit(cmd)
+
+    cmd = 'crm configure rsc_defaults $id="rsc-options"' \
+          ' resource-stickiness="100"'
+    pcmk.commit(cmd)
+
+
+def parse_data(relid, unit, key):
+    '''Simple helper to ast parse relation data'''
+    data = relation_get(key, unit, relid)
+    if data:
+        return ast.literal_eval(data)
+    else:
+        return {}
+>>>>>>> MERGE-SOURCE
+
+
[e-mail]('hanode-relation-joined')
+def hanode_joined():
+    configure_principle_cluster_resources()
+    store_cluster_size()
+
+
[e-mail]('hanode-relation-departed')
+def hanode_departed():
+    store_cluster_size()
+
+
+def store_cluster_size():
+    try:
+        if is_leader():
+            cluster_count = int(config('cluster_count'))
+            actual_size = len(peer_units('hanode')) + 1
+            if actual_size < cluster_count:
+                leader_set(settings={'cluster-size': cluster_count})
+            else:
+                leader_set(settings={'cluster-size': actual_size})
+    except NotImplementedError:
+        log("Unable to use leader storage to configure target cluster size"
+            ", expanding clusters will be unreliable without changing "
+            "cluster_count first", level=WARNING)
+
+
+def target_cluster_size():
+    try:
+        leader_cluster_size = leader_get('cluster-size')
+        if leader_cluster_size:
+            return int(leader_cluster_size)
+    except NotImplementedError:
+        log("Unable to use leader storage to configure target cluster size"
+            ", expanding clusters will be unreliable without changing "
+            "cluster_count first", level=WARNING)
+    return int(config('cluster_count'))
 
 
 @hooks.hook('ha-relation-joined',
+<<<<<<< TREE
             'ha-relation-changed')
 def ha_relation_changed():
+=======
+            'ha-relation-changed',
+            'hanode-relation-changed')
+def configure_principle_cluster_resources():
+>>>>>>> MERGE-SOURCE
     # Check that we are related to a principle and that
     # it has already provided the required corosync configuration
     if not get_corosync_conf():
@@ -175,9 +487,14 @@
 
     # Check that there's enough nodes in order to perform the
     # configuration of the HA cluster
+<<<<<<< TREE
     if len(get_cluster_nodes()) < int(config('cluster_count')):
         log('Not enough nodes in cluster, deferring configuration',
             level=INFO)
+=======
+    if (len(get_cluster_nodes()) < target_cluster_size()):
+        log('Not enough nodes in cluster, deferring configuration')
+>>>>>>> MERGE-SOURCE
         return
 
     relids = relation_ids('ha')

=== modified file 'hooks/pcmk.py'
--- hooks/pcmk.py	2015-04-30 19:35:31 +0000
+++ hooks/pcmk.py	2015-06-09 10:12:24 +0000
@@ -1,6 +1,7 @@
 import commands
 import subprocess
 import socket
+import time
 
 from charmhelpers.core.hookenv import (
     log,
@@ -14,6 +15,9 @@
     while not crm_up:
         output = commands.getstatusoutput("crm node list")[1]
         crm_up = hostname in output
+        # Sleep between attempts to give corosync and pacemaker
+        # a chance to wake up.
+        time.sleep(5)
 
 
 def commit(cmd):