Merge lp:~dbuliga/charms/trusty/nrpe/nrpe into lp:charms/trusty/nrpe

[Denis Buliga]

This branch introduces a factory that based on platform, loads the proper functionality for that platform. It deploys NRPE as a subordinate charm to a charm which is deployed on CentOS as well as for a charm which is deployed on Ubuntu.

A new parameter was added in the 'monitors' relation which is supposed to send the platform for the subordinate charm. This helps for instance, NAGIOS, to set icon and description for that charm based on the parameter.

The need for a template for CentOS appeared because that pid_file has to be under the user nrpe on CentOS instead of nagios on Ubuntu.

[lp:~dbuliga/charms/trusty/nrpe/nrpe]

41. By David Ames on 2016-03-22

[gnuoy, r=thedac] Add support for multiple charms to be related to nrpe via the nrpe, juju-info or local-monitors relation. This is useful when joining an additional local subordinate to this charm. See README changes.

42. By Denis Buliga on 2016-04-29

Updated nrpe to work on CentOS

[Adam Israel (aisrael)]

Hi Denis,

I've had a chance to review your merge proposal. I've run into a few errors running the amulet tests related to missing config files. Could you check the logs at the pastebin link below and fix the tests? Once they pass, I'll be happy to re-review and get this promulgated.

http://pastebin.ubuntu.com/17298099/

review: Needs Fixing

[Antonio Rosales (arosales)]

@Denis,

Thanks for your contribution.

Given this is a CentoOS update this may actually be better as a separate CentOS charm. Specifically, the metadata stating it is a CentOS charm so Juju can deploy it as such and it can be discoverable in the Charm Store.

It looks like there is some feedback on the tests, but it would be great to see this in a stand-alone CentOS charm.

-thanks,
Antonio

Unmerged revisions

42. By Denis Buliga on 2016-04-29

Updated nrpe to work on CentOS

=== added file 'hooks/centos.py'
--- hooks/centos.py	1970-01-01 00:00:00 +0000
+++ hooks/centos.py	2016-04-29 11:54:41 +0000
@@ -0,0 +1,29 @@
+from charmhelpers.core import host
+from charmhelpers.core import hookenv
+from charmhelpers.core.services import helpers
+
+
+def determine_packages():
+    """ List of packages this charm needs installed """
+    pkgs = [
+        'epel-release',
+        'nagios',
+        'nagios-plugins-nrpe',
+        'nagios-plugins-all',
+        'nrpe'
+    ]
+    if hookenv.config('export_nagios_definitions'):
+        pkgs.append('rsync')
+    return pkgs
+
+
+def restart_nrpe(service_name):
+    """ Restart nrpe """
+    host.service_restart('nrpe')
+
+
+def render_nrpe_template():
+    return helpers.render_template(
+                    source='nrpe-centos.tmpl',
+                    target='/etc/nagios/nrpe.cfg'
+                    )

=== modified file 'hooks/charmhelpers/__init__.py' (properties changed: -x to +x)
--- hooks/charmhelpers/__init__.py	2015-03-23 09:45:10 +0000
+++ hooks/charmhelpers/__init__.py	2016-04-29 11:54:41 +0000
@@ -18,6 +18,7 @@
 # only standard libraries.
 import subprocess
 import sys
+import platform
 
 try:
     import six  # flake8: noqa
@@ -36,3 +37,12 @@
     else:
         subprocess.check_call(['apt-get', 'install', '-y', 'python3-yaml'])
     import yaml  # flake8: noqa
+
+
+def get_platform():
+    tuple_platform = platform.linux_distribution()
+    current_platform = tuple_platform[0]
+    if "Ubuntu" in current_platform:
+        return "ubuntu"
+    elif "CentOS" in current_platform:
+        return "centos"

=== modified file 'hooks/charmhelpers/core/__init__.py' (properties changed: -x to +x)
=== modified file 'hooks/charmhelpers/core/decorators.py' (properties changed: -x to +x)
=== modified file 'hooks/charmhelpers/core/fstab.py' (properties changed: -x to +x)
=== modified file 'hooks/charmhelpers/core/hookenv.py' (properties changed: -x to +x)
=== modified file 'hooks/charmhelpers/core/host.py' (properties changed: -x to +x)
--- hooks/charmhelpers/core/host.py	2015-03-23 09:45:10 +0000
+++ hooks/charmhelpers/core/host.py	2016-04-29 11:54:41 +0000
@@ -21,236 +21,123 @@
 #  Nick Moffitt <[e-mail]>
 #  Matthew Wedgwood <[e-mail]>
 
-import os
-import re
-import pwd
-import grp
-import random
-import string
-import subprocess
-import hashlib
 from contextlib import contextmanager
-from collections import OrderedDict
-
-import six
-
-from .hookenv import log
-from .fstab import Fstab
+from charmhelpers.core.host_factory import Host
+
+host = Host()
 
 
 def service_start(service_name):
     """Start a system service"""
-    return service('start', service_name)
+    return host.service_start(service_name)
 
 
 def service_stop(service_name):
     """Stop a system service"""
-    return service('stop', service_name)
+    return host.service_stop(service_name)
 
 
 def service_restart(service_name):
     """Restart a system service"""
-    return service('restart', service_name)
+    return host.service_restart(service_name)
 
 
 def service_reload(service_name, restart_on_failure=False):
     """Reload a system service, optionally falling back to restart if
     reload fails"""
-    service_result = service('reload', service_name)
-    if not service_result and restart_on_failure:
-        service_result = service('restart', service_name)
-    return service_result
+    return host.service_reload(service_name, restart_on_failure)
 
 
 def service(action, service_name):
     """Control a system service"""
-    cmd = ['service', service_name, action]
-    return subprocess.call(cmd) == 0
+    return host.service(action, service_name)
 
 
 def service_running(service):
-    """Determine whether a system service is running"""
-    try:
-        output = subprocess.check_output(
-            ['service', service, 'status'],
-            stderr=subprocess.STDOUT).decode('UTF-8')
-    except subprocess.CalledProcessError:
-        return False
-    else:
-        if ("start/running" in output or "is running" in output):
-            return True
-        else:
-            return False
+    return host.service_running(service)
 
 
 def service_available(service_name):
     """Determine whether a system service is available"""
-    try:
-        subprocess.check_output(
-            ['service', service_name, 'status'],
-            stderr=subprocess.STDOUT).decode('UTF-8')
-    except subprocess.CalledProcessError as e:
-        return 'unrecognized service' not in e.output
-    else:
-        return True
-
-
-def adduser(username, password=None, shell='/bin/bash', system_user=False):
-    """Add a user to the system"""
-    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
+    return host.service_available(service_name)
+
+
+def adduser(username, password=None, shell='/bin/bash', system_user=False,
+            primary_group=None, secondary_groups=None):
+    """
+    Add a user to the system.
+
+    Will log but otherwise succeed if the user already exists.
+
+    :param str username: Username to create
+    :param str password: Password for user; if ``None``, create a system user
+    :param str shell: The default shell for the user
+    :param bool system_user: Whether to create a login or system user
+    :param str primary_group: Primary group for user; defaults to their username
+    :param list secondary_groups: Optional list of additional groups
+
+    :returns: The password database entry struct, as returned by `pwd.getpwnam`
+    """
+    return host.adduser(username, password, shell, system_user,
+                        primary_group, secondary_groups)
+
+
+def user_exists(username):
+    """Check if a user exists"""
+    return host.user_exists(username)
 
 
 def add_group(group_name, system_group=False):
-    """Add a group to the system"""
-    try:
-        group_info = grp.getgrnam(group_name)
-        log('group {0} already exists!'.format(group_name))
-    except KeyError:
-        log('creating group {0}'.format(group_name))
-        cmd = ['addgroup']
-        if system_group:
-            cmd.append('--system')
-        else:
-            cmd.extend([
-                '--group',
-            ])
-        cmd.append(group_name)
-        subprocess.check_call(cmd)
-        group_info = grp.getgrnam(group_name)
-    return group_info
+    return host.add_group(group_name, system_group)
 
 
 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)
+    host.add_user_to_group(username, group)
 
 
 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).decode('UTF-8').strip()
+    return host.rsync(from_path, to_path, flags, options)
 
 
 def symlink(source, destination):
     """Create a symbolic link"""
-    log("Symlinking {} as {}".format(source, destination))
-    cmd = [
-        'ln',
-        '-sf',
-        source,
-        destination,
-    ]
-    subprocess.check_call(cmd)
+    host.symlink(source, destination)
 
 
 def mkdir(path, owner='root', group='root', perms=0o555, 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)
-    path_exists = os.path.exists(realpath)
-    if path_exists and force:
-        if not os.path.isdir(realpath):
-            log("Removing non-directory file {} prior to mkdir()".format(path))
-            os.unlink(realpath)
-            os.makedirs(realpath, perms)
-    elif not path_exists:
-        os.makedirs(realpath, perms)
-    os.chown(realpath, uid, gid)
-    os.chmod(realpath, perms)
+    host.mkdir(path, owner, group, perms, force)
 
 
 def write_file(path, content, owner='root', group='root', perms=0o444):
     """Create or overwrite a file with the contents of a byte 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, 'wb') as target:
-        os.fchown(target.fileno(), uid, gid)
-        os.fchmod(target.fileno(), perms)
-        target.write(content)
+    host.write_file(path, content, owner, group, perms)
 
 
 def fstab_remove(mp):
-    """Remove the given mountpoint entry from /etc/fstab
-    """
-    return Fstab.remove_by_mountpoint(mp)
+    """Remove the given mountpoint entry from /etc/fstab"""
+    return host.fstab_remove(mp)
 
 
 def fstab_add(dev, mp, fs, options=None):
-    """Adds the given device entry to the /etc/fstab file
-    """
-    return Fstab.add(dev, mp, fs, options=options)
+    """Adds the given device entry to the /etc/fstab file"""
+    return host.fstab_add(dev, mp, fs, options)
 
 
 def mount(device, mountpoint, options=None, persist=False, filesystem="ext3"):
     """Mount a filesystem at a particular mountpoint"""
-    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 as e:
-        log('Error mounting {} at {}\n{}'.format(device, mountpoint, e.output))
-        return False
-
-    if persist:
-        return fstab_add(device, mountpoint, filesystem, options=options)
-    return True
+    return host.mount(device, mountpoint, options, persist, filesystem)
 
 
 def umount(mountpoint, persist=False):
     """Unmount a filesystem"""
-    cmd_args = ['umount', mountpoint]
-    try:
-        subprocess.check_output(cmd_args)
-    except subprocess.CalledProcessError as e:
-        log('Error unmounting {}\n{}'.format(mountpoint, e.output))
-        return False
-
-    if persist:
-        return fstab_remove(mountpoint)
-    return True
+    return host.umount(mountpoint, persist)
 
 
 def mounts():
     """Get a 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
+    return host.mounts()
 
 
 def file_hash(path, hash_type='md5'):
@@ -260,13 +147,7 @@
     :param str hash_type: Any hash alrgorithm supported by :mod:`hashlib`,
                           such as md5, sha1, sha256, sha512, etc.
     """
-    if os.path.exists(path):
-        h = getattr(hashlib, hash_type)()
-        with open(path, 'rb') as source:
-            h.update(source.read())
-        return h.hexdigest()
-    else:
-        return None
+    return host.file_hash(path, hash_type)
 
 
 def check_hash(path, checksum, hash_type='md5'):
@@ -280,9 +161,7 @@
     :raises ChecksumError: If the file fails the checksum
 
     """
-    actual_checksum = file_hash(path, hash_type)
-    if checksum != actual_checksum:
-        raise ChecksumError("'%s' != '%s'" % (checksum, actual_checksum))
+    host.check_hash(path, checksum, hash_type)
 
 
 class ChecksumError(ValueError):
@@ -296,154 +175,68 @@
 
         @restart_on_change({
             '/etc/ceph/ceph.conf': [ 'cinder-api', 'cinder-volume' ]
+            '/etc/apache/sites-enabled/*': [ 'apache2' ]
             })
-        def ceph_client_changed():
+        def config_changed():
             pass  # your code here
 
     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.
+    ceph_client_changed function. The apache2 service would be
+    restarted if any file matching the pattern got changed, created
+    or removed. Standard wildcards are supported, see documentation
+    for the 'glob' module for more information.
     """
-    def wrap(f):
-        def wrapped_f(*args, **kwargs):
-            checksums = {}
-            for path in restart_map:
-                checksums[path] = file_hash(path)
-            f(*args, **kwargs)
-            restarts = []
-            for path in restart_map:
-                if checksums[path] != file_hash(path):
-                    restarts += restart_map[path]
-            services_list = list(OrderedDict.fromkeys(restarts))
-            if not stopstart:
-                for service_name in services_list:
-                    service('restart', service_name)
-            else:
-                for action in ['stop', 'start']:
-                    for service_name in services_list:
-                        service(action, service_name)
-        return wrapped_f
-    return wrap
+    return host.restart_on_change(restart_map, stopstart)
 
 
 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
+    """Return /etc/os-release in a dict"""
+    return host.lsb_release()
 
 
 def pwgen(length=None):
     """Generate a random pasword."""
-    if length is None:
-        # A random length is ok to use a weak PRNG
-        length = random.choice(range(35, 45))
-    alphanumeric_chars = [
-        l for l in (string.ascii_letters + string.digits)
-        if l not in 'l0QD1vAEIOUaeiou']
-    # Use a crypto-friendly PRNG (e.g. /dev/urandom) for making the
-    # actual password
-    random_generator = random.SystemRandom()
-    random_chars = [
-        random_generator.choice(alphanumeric_chars) for _ in range(length)]
-    return(''.join(random_chars))
-
-
-def list_nics(nic_type):
+    return host.pwgen(length)
+
+
+def list_nics(nic_type=None):
     '''Return a list of nics of given type(s)'''
-    if isinstance(nic_type, six.string_types):
-        int_types = [nic_type]
-    else:
-        int_types = nic_type
-    interfaces = []
-    for int_type in int_types:
-        cmd = ['ip', 'addr', 'show', 'label', int_type + '*']
-        ip_output = subprocess.check_output(cmd).decode('UTF-8').split('\n')
-        ip_output = (line for line in ip_output if line)
-        for line in ip_output:
-            if line.split()[1].startswith(int_type):
-                matched = re.search('.*: (' + int_type + r'[0-9]+\.[0-9]+)@.*', line)
-                if matched:
-                    interface = matched.groups()[0]
-                else:
-                    interface = line.split()[1].replace(":", "")
-                interfaces.append(interface)
-
-    return interfaces
+    return host.list_nics(nic_type)
 
 
 def set_nic_mtu(nic, mtu):
     '''Set MTU on a network interface'''
-    cmd = ['ip', 'link', 'set', nic, 'mtu', mtu]
-    subprocess.check_call(cmd)
+    host.set_nic_mtu(nic, mtu)
 
 
 def get_nic_mtu(nic):
-    cmd = ['ip', 'addr', 'show', nic]
-    ip_output = subprocess.check_output(cmd).decode('UTF-8').split('\n')
-    mtu = ""
-    for line in ip_output:
-        words = line.split()
-        if 'mtu' in words:
-            mtu = words[words.index("mtu") + 1]
-    return mtu
+    '''Get MTU of a network interface'''
+    return host.get_nic_mtu(nic)
 
 
 def get_nic_hwaddr(nic):
-    cmd = ['ip', '-o', '-0', 'addr', 'show', nic]
-    ip_output = subprocess.check_output(cmd).decode('UTF-8')
-    hwaddr = ""
-    words = ip_output.split()
-    if 'link/ether' in words:
-        hwaddr = words[words.index('link/ether') + 1]
-    return hwaddr
+    return host.get_nic_hwaddr(nic)
 
 
 def cmp_pkgrevno(package, revno, pkgcache=None):
-    '''Compare supplied revno with the revno of the installed package
-
-    *  1 => Installed revno is greater than supplied arg
-    *  0 => Installed revno is the same as supplied arg
-    * -1 => Installed revno is less than supplied arg
-
-    This function imports apt_cache function from charmhelpers.fetch if
-    the pkgcache argument is None. Be sure to add charmhelpers.fetch if
-    you call this function, or pass an apt_pkg.Cache() instance.
-    '''
-    import apt_pkg
-    if not pkgcache:
-        from charmhelpers.fetch import apt_cache
-        pkgcache = apt_cache()
-    pkg = pkgcache[package]
-    return apt_pkg.version_compare(pkg.current_ver.ver_str, revno)
+    return host.cmp_pkgrevno(package, revno, pkgcache)
 
 
 @contextmanager
 def chdir(d):
-    cur = os.getcwd()
-    try:
-        yield os.chdir(d)
-    finally:
-        os.chdir(cur)
-
-
-def chownr(path, owner, group, follow_links=True):
-    uid = pwd.getpwnam(owner).pw_uid
-    gid = grp.getgrnam(group).gr_gid
-    if follow_links:
-        chown = os.chown
-    else:
-        chown = os.lchown
-
-    for root, dirs, files in os.walk(path):
-        for name in dirs + files:
-            full = os.path.join(root, name)
-            broken_symlink = os.path.lexists(full) and not os.path.exists(full)
-            if not broken_symlink:
-                chown(full, uid, gid)
+    host.chdir(d)
+
+
+def chownr(path, owner, group, follow_links=True, chowntopdir=False):
+    """
+    Recursively change user and group ownership of files and directories
+    in given path. Doesn't chown path itself by default, only its children.
+
+    :param bool follow_links: Also Chown links if True
+    :param bool chowntopdir: Also chown path itself if True
+    """
+    host.chownr(path, owner, group, follow_links, chowntopdir)
 
 
 def lchownr(path, owner, group):

=== added directory 'hooks/charmhelpers/core/host_factory'
=== added file 'hooks/charmhelpers/core/host_factory/__init__.py'
--- hooks/charmhelpers/core/host_factory/__init__.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/core/host_factory/__init__.py	2016-04-29 11:54:41 +0000
@@ -0,0 +1,492 @@
+import os
+import re
+import pwd
+import glob
+import grp
+import random
+import string
+import subprocess
+import hashlib
+import importlib
+import six
+
+from contextlib import contextmanager
+from collections import OrderedDict
+from ..hookenv import log
+from ..fstab import Fstab
+from charmhelpers import get_platform
+
+SYSTEMD_SYSTEM = '/run/systemd/system'
+
+
+class HostBase(object):
+
+    def service_start(self, service_name):
+        """Start a system service"""
+        return self.service('start', service_name)
+
+    def service_stop(self, service_name):
+        """Stop a system service"""
+        return self.service('stop', service_name)
+
+    def service_restart(self, service_name):
+        """Restart a system service"""
+        return self.service('restart', service_name)
+
+    def service_reload(self, service_name, restart_on_failure=False):
+        """Reload a system service, optionally falling back to restart if
+        reload fails"""
+        service_result = self.service('reload', service_name)
+        if not service_result and restart_on_failure:
+            service_result = self.service('restart', service_name)
+        return service_result
+
+    def service(self, action, service_name):
+        """Control a system service"""
+        if self.init_is_systemd():
+            cmd = ['systemctl', action, service_name]
+        else:
+            cmd = ['service', service_name, action]
+        return subprocess.call(cmd) == 0
+
+    def service_running(self, service_name):
+        """Determine whether a system service is running"""
+        if self.init_is_systemd():
+            return self.service('is-active', service_name)
+        else:
+            try:
+                output = subprocess.check_output(
+                    ['service', service_name, 'status'],
+                    stderr=subprocess.STDOUT).decode('UTF-8')
+            except subprocess.CalledProcessError:
+                return False
+            else:
+                if ("start/running" in output or "is running" in output):
+                    return True
+                else:
+                    return False
+
+    def service_available(self, service_name):
+        """Determine whether a system service is available"""
+        if self.init_is_systemd():
+            return self.service('is-enabled', service_name)
+        try:
+            subprocess.check_output(
+                ['service', service_name, 'status'],
+                stderr=subprocess.STDOUT).decode('UTF-8')
+        except subprocess.CalledProcessError as e:
+            return b'unrecognized service' not in e.output
+        else:
+            return True
+
+    def init_is_systemd(self):
+        """Return True if the host system uses systemd, False otherwise."""
+        return os.path.isdir(SYSTEMD_SYSTEM)
+
+    def adduser(self, username, password=None, shell='/bin/bash',
+                system_user=False, primary_group=None, secondary_groups=None):
+        """Add a user to the system.
+
+        Will log but otherwise succeed if the user already exists.
+
+        :param str username: Username to create
+        :param str password: Password for user;
+                             if ``None``, create a system user
+        :param str shell: The default shell for the user
+        :param bool system_user: Whether to create a login or system user
+        :param str primary_group: Primary group for user; defaults to username
+        :param list secondary_groups: Optional list of additional groups
+
+        :returns: The password database entry struct,
+                  as returned by `pwd.getpwnam`
+        """
+        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,
+                ])
+            if not primary_group:
+                try:
+                    grp.getgrnam(username)
+                    primary_group = username  # avoid "group exists" error
+                except KeyError:
+                    pass
+            if primary_group:
+                cmd.extend(['-g', primary_group])
+            if secondary_groups:
+                cmd.extend(['-G', ','.join(secondary_groups)])
+            cmd.append(username)
+            subprocess.check_call(cmd)
+            user_info = pwd.getpwnam(username)
+        return user_info
+
+    def _add_group(self, group_name, system_group=False):
+        raise NotImplementedError()
+
+    def add_group(self, group_name, system_group=False):
+        try:
+            group_info = grp.getgrnam(group_name)
+            log('group {0} already exists!'.format(group_name))
+        except KeyError:
+            log('creating group {0}'.format(group_name))
+            self._add_group(group_name, system_group)
+            group_info = grp.getgrnam(group_name)
+        return group_info
+
+    def add_user_to_group(self, 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(self, 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).decode('UTF-8').strip()
+
+    def symlink(self, source, destination):
+        """Create a symbolic link"""
+        log("Symlinking {} as {}".format(source, destination))
+        cmd = [
+            'ln',
+            '-sf',
+            source,
+            destination,
+        ]
+        subprocess.check_call(cmd)
+
+    def mkdir(self, path, owner='root', group='root',
+              perms=0o555, 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)
+        path_exists = os.path.exists(realpath)
+        if path_exists and force:
+            if not os.path.isdir(realpath):
+                log("Removing non-directory file {}"
+                    " prior to mkdir()".format(path))
+                os.unlink(realpath)
+                os.makedirs(realpath, perms)
+        elif not path_exists:
+            os.makedirs(realpath, perms)
+        os.chown(realpath, uid, gid)
+        os.chmod(realpath, perms)
+
+    def write_file(self, path, content, owner='root',
+                   group='root', perms=0o444):
+        """Create or overwrite a file with the contents of a byte 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, 'wb') as target:
+            os.fchown(target.fileno(), uid, gid)
+            os.fchmod(target.fileno(), perms)
+            target.write(content)
+
+    def fstab_remove(self, mp):
+        """Remove the given mountpoint entry from /etc/fstab"""
+        return Fstab.remove_by_mountpoint(mp)
+
+    def fstab_add(self, dev, mp, fs, options=None):
+        """Adds the given device entry to the /etc/fstab file"""
+        return Fstab.add(dev, mp, fs, options=options)
+
+    def mount(self, device, mountpoint, options=None,
+              persist=False, filesystem="ext3"):
+        """Mount a filesystem at a particular mountpoint"""
+        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 as e:
+            log('Error mounting {} at {}\n{}'.format(
+                device, mountpoint, e.output))
+            return False
+
+        if persist:
+            return self.fstab_add(device, mountpoint,
+                                  filesystem, options=options)
+        return True
+
+    def umount(self, mountpoint, persist=False):
+        """Unmount a filesystem"""
+        cmd_args = ['umount', mountpoint]
+        try:
+            subprocess.check_output(cmd_args)
+        except subprocess.CalledProcessError as e:
+            log('Error unmounting {}\n{}'.format(mountpoint, e.output))
+            return False
+
+        if persist:
+            return self.fstab_remove(mountpoint)
+        return True
+
+    def mounts(self):
+        """Get a 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(self, path, hash_type='md5'):
+        """Generate a hash checksum of the contents of 'path' or None if not found.
+
+        :param str hash_type: Any hash alrgorithm supported by :mod:`hashlib`,
+                              such as md5, sha1, sha256, sha512, etc.
+        """
+        if os.path.exists(path):
+            h = getattr(hashlib, hash_type)()
+            with open(path, 'rb') as source:
+                h.update(source.read())
+            return h.hexdigest()
+        else:
+            return None
+
+    def check_hash(self, path, checksum, hash_type='md5'):
+        """Validate a file using a cryptographic checksum.
+
+        :param str checksum: Value of the checksum used to validate the file.
+        :param str hash_type: Hash algorithm used to generate `checksum`.
+            Can be any hash alrgorithm supported by :mod:`hashlib`,
+            such as md5, sha1, sha256, sha512, etc.
+        :raises ChecksumError: If the file fails the checksum
+
+        """
+        actual_checksum = self.file_hash(path, hash_type)
+        if checksum != actual_checksum:
+            raise ChecksumError("'%s' != '%s'" % (checksum, actual_checksum))
+
+    def restart_on_change(self, restart_map, stopstart=False):
+        """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' ]
+                '/etc/apache/sites-enabled/*': [ 'apache2' ]
+                })
+            def config_changed():
+                pass  # your code here
+
+        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. The apache2 service would be
+        restarted if any file matching the pattern got changed, created
+        or removed. Standard wildcards are supported, see documentation
+        for the 'glob' module for more information.
+        """
+        def wrap(f):
+            def wrapped_f(*args, **kwargs):
+                checksums = {path: self.path_hash(path)
+                             for path in restart_map}
+                f(*args, **kwargs)
+                restarts = []
+                for path in restart_map:
+                    if self.path_hash(path) != checksums[path]:
+                        restarts += restart_map[path]
+                services_list = list(OrderedDict.fromkeys(restarts))
+                if not stopstart:
+                    for service_name in services_list:
+                        self.service('restart', service_name)
+                else:
+                    for action in ['stop', 'start']:
+                        for service_name in services_list:
+                            self.service(action, service_name)
+            return wrapped_f
+        return wrap
+
+    def lsb_release(self):
+        return self._lsb_release()
+
+    def _lsb_release(self):
+        raise NotImplementedError()
+
+    def pwgen(self, length=None):
+        """Generate a random pasword."""
+        if length is None:
+            # A random length is ok to use a weak PRNG
+            length = random.choice(range(35, 45))
+        alphanumeric_chars = [
+            l for l in (string.ascii_letters + string.digits)
+            if l not in 'l0QD1vAEIOUaeiou']
+        # Use a crypto-friendly PRNG (e.g. /dev/urandom) for making the
+        # actual password
+        random_generator = random.SystemRandom()
+        random_chars = [
+            random_generator.choice(alphanumeric_chars) for _ in range(length)]
+        return(''.join(random_chars))
+
+    def list_nics(self, nic_type=None):
+        """Return a list of nics of given type(s)"""
+        if isinstance(nic_type, six.string_types):
+            int_types = [nic_type]
+        else:
+            int_types = nic_type
+
+        interfaces = []
+        if nic_type:
+            for int_type in int_types:
+                cmd = ['ip', 'addr', 'show', 'label', int_type + '*']
+                ip_output = subprocess.check_output(cmd).decode('UTF-8')
+                ip_output = ip_output.split('\n')
+                ip_output = (line for line in ip_output if line)
+                for line in ip_output:
+                    if line.split()[1].startswith(int_type):
+                        matched = re.search('.*: (' + int_type +
+                                            r'[0-9]+\.[0-9]+)@.*', line)
+                        if matched:
+                            iface = matched.groups()[0]
+                        else:
+                            iface = line.split()[1].replace(":", "")
+
+                        if iface not in interfaces:
+                            interfaces.append(iface)
+        else:
+            cmd = ['ip', 'a']
+            ip_output = subprocess.check_output(
+                        cmd).decode('UTF-8').split('\n')
+            ip_output = (line.strip() for line in ip_output if line)
+
+            key = re.compile('^[0-9]+:\s+(.+):')
+            for line in ip_output:
+                matched = re.search(key, line)
+                if matched:
+                    iface = matched.group(1)
+                    iface = iface.partition("@")[0]
+                    if iface not in interfaces:
+                        interfaces.append(iface)
+        return interfaces
+
+    def set_nic_mtu(self, nic, mtu):
+        """Set the Maximum Transmission Unit (MTU) on a network interface."""
+        cmd = ['ip', 'link', 'set', nic, 'mtu', mtu]
+        subprocess.check_call(cmd)
+
+    def get_nic_mtu(self, nic):
+        """
+        Return the Maximum Transmission Unit (MTU) for a network interface.
+        """
+        cmd = ['ip', 'addr', 'show', nic]
+        ip_output = subprocess.check_output(cmd).decode('UTF-8').split('\n')
+        mtu = ""
+        for line in ip_output:
+            words = line.split()
+            if 'mtu' in words:
+                mtu = words[words.index("mtu") + 1]
+        return mtu
+
+    def get_nic_hwaddr(self, nic):
+        """Return the Media Access Control (MAC) for a network interface."""
+        cmd = ['ip', '-o', '-0', 'addr', 'show', nic]
+        ip_output = subprocess.check_output(cmd).decode('UTF-8')
+        hwaddr = ""
+        words = ip_output.split()
+        if 'link/ether' in words:
+            hwaddr = words[words.index('link/ether') + 1]
+        return hwaddr
+
+    def cmp_pkgrevno(self, package, revno, pkgcache=None):
+        """Compare supplied revno with the revno of the installed package
+
+        *  1 => Installed revno is greater than supplied arg
+        *  0 => Installed revno is the same as supplied arg
+        * -1 => Installed revno is less than supplied arg
+
+        This function imports apt_cache function from charmhelpers.fetch if
+        the pkgcache argument is None. Be sure to add charmhelpers.fetch if
+        you call this function, or pass an apt_pkg.Cache() instance.
+        """
+        return self._cmp_pkgrevno(package, revno, pkgcache)
+
+    def _cmp_pkgrevno(self, package, revno, pkgcache=None):
+        raise NotImplementedError()
+
+    @contextmanager
+    def chdir(self, directory):
+        """
+        Change the current working directory to a different directory for a
+        code block and return the previous directory after the block exits.
+        Useful to run commands from a specificed directory.
+
+        :param str directory: The directory path to change to for this context.
+        """
+        cur = os.getcwd()
+        try:
+            yield os.chdir(directory)
+        finally:
+            os.chdir(cur)
+
+    def chownr(self, path, owner, group, follow_links=True, chowntopdir=False):
+        """Recursively change user and group ownership of files and directories
+        in given path. Doesn't chown path itself by default, only its children.
+
+        :param str path: The string path to start changing ownership.
+        :param str owner: The owner string to use when looking up the uid.
+        :param str group: The group string to use when looking up the gid.
+        :param bool follow_links: Also Chown links if True
+        :param bool chowntopdir: Also chown path itself if True
+        """
+        uid = pwd.getpwnam(owner).pw_uid
+        gid = grp.getgrnam(group).gr_gid
+        if follow_links:
+            chown = os.chown
+        else:
+            chown = os.lchown
+
+        if chowntopdir:
+            broken_symlink = os.path.lexists(path) and not os.path.exists(path)
+            if not broken_symlink:
+                chown(path, uid, gid)
+        for root, dirs, files in os.walk(path):
+            for name in dirs + files:
+                full = os.path.join(root, name)
+                broken_symlink = os.path.lexists(
+                                    full
+                                ) and not os.path.exists(full)
+                if not broken_symlink:
+                    chown(full, uid, gid)
+
+    def lchownr(self, path, owner, group):
+        """
+        Recursively change user and group ownership of files and directories
+        in a given path, not following symbolic links. See the documentation
+        for 'os.lchown' for more information.
+
+        :param str path: The string path to start changing ownership.
+        :param str owner: The owner string to use when looking up the uid.
+        :param str group: The group string to use when looking up the gid.
+        """
+        self.chownr(path, owner, group, follow_links=False)
+
+
+class ChecksumError(ValueError):
+    """A class derived from Value error to indicate the checksum failed."""
+    pass
+
+
+module = "charmhelpers.core.host_factory.%s" % get_platform()
+host = importlib.import_module(module)
+
+
+class Host(host.Host):
+    pass

=== added directory 'hooks/charmhelpers/core/host_factory/centos'
=== added file 'hooks/charmhelpers/core/host_factory/centos/__init__.py'
--- hooks/charmhelpers/core/host_factory/centos/__init__.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/core/host_factory/centos/__init__.py	2016-04-29 11:54:41 +0000
@@ -0,0 +1,53 @@
+import subprocess
+import yum
+
+from .. import HostBase
+
+
+class Host(HostBase):
+    '''
+    Implementation of HostBase for CentOS
+    '''
+
+    def _add_group(self, group_name, system_group=False):
+        cmd = ['groupadd']
+        if system_group:
+            cmd.append('-r')
+        cmd.append(group_name)
+        subprocess.check_call(cmd)
+
+    def _lsb_release(self):
+        """Return /etc/os-release in a dict"""
+        d = {}
+        with open('/etc/os-release', 'r') as lsb:
+            for l in lsb:
+                if len(l.split('=')) != 2:
+                    continue
+                k, v = l.split('=')
+                d[k.strip()] = v.strip()
+        return d
+
+    def _cmp_pkgrevno(self, package, revno, pkgcache=None):
+        """Compare supplied revno with the revno of the installed package
+
+        *  1 => Installed revno is greater than supplied arg
+        *  0 => Installed revno is the same as supplied arg
+        * -1 => Installed revno is less than supplied arg
+
+        This function imports apt_cache function from charmhelpers.fetch if
+        the pkgcache argument is None. Be sure to add charmhelpers.fetch if
+        you call this function, or pass an apt_pkg.Cache() instance.
+        """
+        if not pkgcache:
+            y = yum.YumBase()
+            packages = y.doPackageLists()
+            pck = {}
+            for i in packages["installed"]:
+                pck[i.Name] = i.version
+                pkgcache = pck
+        pkg = pkgcache[package]
+        if pkg > revno:
+            return 1
+        if pkg < revno:
+            return -1
+        return 0

=== added directory 'hooks/charmhelpers/core/host_factory/ubuntu'
=== added file 'hooks/charmhelpers/core/host_factory/ubuntu/__init__.py'
--- hooks/charmhelpers/core/host_factory/ubuntu/__init__.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/core/host_factory/ubuntu/__init__.py	2016-04-29 11:54:41 +0000
@@ -0,0 +1,47 @@
+import subprocess
+
+from .. import HostBase
+
+
+class Host(HostBase):
+    '''
+    Implementation of HostBase for Ubuntu
+    '''
+
+    def _add_group(self, group_name, system_group=False):
+        cmd = ['addgroup']
+        if system_group:
+            cmd.append('--system')
+        else:
+            cmd.extend([
+                '--group',
+            ])
+        cmd.append(group_name)
+        subprocess.check_call(cmd)
+
+    def _lsb_release(self):
+        """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 _cmp_pkgrevno(self, package, revno, pkgcache=None):
+        """Compare supplied revno with the revno of the installed package
+
+        *  1 => Installed revno is greater than supplied arg
+        *  0 => Installed revno is the same as supplied arg
+        * -1 => Installed revno is less than supplied arg
+
+        This function imports apt_cache function from charmhelpers.fetch if
+        the pkgcache argument is None. Be sure to add charmhelpers.fetch if
+        you call this function, or pass an apt_pkg.Cache() instance.
+        """
+        import apt_pkg
+        if not pkgcache:
+            from charmhelpers.fetch import apt_cache
+            pkgcache = apt_cache()
+        pkg = pkgcache[package]
+        return apt_pkg.version_compare(pkg.current_ver.ver_str, revno)

=== modified file 'hooks/charmhelpers/core/services/__init__.py' (properties changed: -x to +x)
=== modified file 'hooks/charmhelpers/core/services/base.py' (properties changed: -x to +x)
=== modified file 'hooks/charmhelpers/core/services/helpers.py' (properties changed: -x to +x)
=== modified file 'hooks/charmhelpers/core/strutils.py' (properties changed: -x to +x)
=== modified file 'hooks/charmhelpers/core/sysctl.py' (properties changed: -x to +x)
=== modified file 'hooks/charmhelpers/core/templating.py' (properties changed: -x to +x)
=== modified file 'hooks/charmhelpers/core/unitdata.py' (properties changed: -x to +x)
=== modified file 'hooks/charmhelpers/fetch/__init__.py' (properties changed: -x to +x)
--- hooks/charmhelpers/fetch/__init__.py	2015-03-23 09:45:10 +0000
+++ hooks/charmhelpers/fetch/__init__.py	2016-04-29 11:54:41 +0000
@@ -14,84 +14,21 @@
 # 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
 import importlib
-from tempfile import NamedTemporaryFile
-import time
+
 from yaml import safe_load
-from charmhelpers.core.host import (
-    lsb_release
-)
-import subprocess
-from charmhelpers.core.hookenv import (
+from charmhelpers import get_platform
+from charmhelpers.core.hookenv import(
     config,
-    log,
+    log
 )
-import os
-
-import six
 if six.PY3:
     from urllib.parse import urlparse, urlunparse
 else:
     from urlparse import urlparse, urlunparse
 
 
-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
-"""
-CLOUD_ARCHIVE_POCKETS = {
-    # Folsom
-    'folsom': 'precise-updates/folsom',
-    'precise-folsom': 'precise-updates/folsom',
-    'precise-folsom/updates': 'precise-updates/folsom',
-    'precise-updates/folsom': 'precise-updates/folsom',
-    'folsom/proposed': 'precise-proposed/folsom',
-    'precise-folsom/proposed': 'precise-proposed/folsom',
-    'precise-proposed/folsom': 'precise-proposed/folsom',
-    # Grizzly
-    'grizzly': 'precise-updates/grizzly',
-    'precise-grizzly': 'precise-updates/grizzly',
-    'precise-grizzly/updates': 'precise-updates/grizzly',
-    'precise-updates/grizzly': 'precise-updates/grizzly',
-    'grizzly/proposed': 'precise-proposed/grizzly',
-    'precise-grizzly/proposed': 'precise-proposed/grizzly',
-    'precise-proposed/grizzly': 'precise-proposed/grizzly',
-    # Havana
-    'havana': 'precise-updates/havana',
-    'precise-havana': 'precise-updates/havana',
-    'precise-havana/updates': 'precise-updates/havana',
-    'precise-updates/havana': 'precise-updates/havana',
-    'havana/proposed': 'precise-proposed/havana',
-    'precise-havana/proposed': 'precise-proposed/havana',
-    'precise-proposed/havana': 'precise-proposed/havana',
-    # Icehouse
-    'icehouse': 'precise-updates/icehouse',
-    'precise-icehouse': 'precise-updates/icehouse',
-    'precise-icehouse/updates': 'precise-updates/icehouse',
-    'precise-updates/icehouse': 'precise-updates/icehouse',
-    'icehouse/proposed': 'precise-proposed/icehouse',
-    'precise-icehouse/proposed': 'precise-proposed/icehouse',
-    'precise-proposed/icehouse': 'precise-proposed/icehouse',
-    # Juno
-    'juno': 'trusty-updates/juno',
-    'trusty-juno': 'trusty-updates/juno',
-    'trusty-juno/updates': 'trusty-updates/juno',
-    'trusty-updates/juno': 'trusty-updates/juno',
-    'juno/proposed': 'trusty-proposed/juno',
-    'trusty-juno/proposed': 'trusty-proposed/juno',
-    'trusty-proposed/juno': 'trusty-proposed/juno',
-    # Kilo
-    'kilo': 'trusty-updates/kilo',
-    'trusty-kilo': 'trusty-updates/kilo',
-    'trusty-kilo/updates': 'trusty-updates/kilo',
-    'trusty-updates/kilo': 'trusty-updates/kilo',
-    'kilo/proposed': 'trusty-proposed/kilo',
-    'trusty-kilo/proposed': 'trusty-proposed/kilo',
-    'trusty-proposed/kilo': 'trusty-proposed/kilo',
-}
-
 # The order of this list is very important. Handlers should be listed in from
 # least- to most-specific URL matching.
 FETCH_HANDLERS = (
@@ -100,10 +37,6 @@
     'charmhelpers.fetch.giturl.GitUrlFetchHandler',
 )
 
-APT_NO_LOCK = 100  # The return code for "couldn't acquire lock" in APT.
-APT_NO_LOCK_RETRY_DELAY = 10  # Wait 10 seconds between apt lock checks.
-APT_NO_LOCK_RETRY_COUNT = 30  # Retry to acquire the lock X times.
-
 
 class SourceConfigError(Exception):
     pass
@@ -141,162 +74,38 @@
         return urlunparse(parts)
 
 
+module = "charmhelpers.fetch.%s" % get_platform()
+fetch = importlib.import_module(module)
+
+
 def filter_installed_packages(packages):
     """Returns a list of packages that require installation"""
-    cache = apt_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_cache(in_memory=True):
-    """Build and return an apt cache"""
-    import apt_pkg
-    apt_pkg.init()
-    if in_memory:
-        apt_pkg.config.set("Dir::Cache::pkgcache", "")
-        apt_pkg.config.set("Dir::Cache::srcpkgcache", "")
-    return apt_pkg.Cache()
-
-
-def apt_install(packages, options=None, fatal=False):
+    return fetch.filter_installed_packages(packages)
+
+
+def install(packages, options=None, fatal=False):
     """Install one or more packages"""
-    if options is None:
-        options = ['--option=Dpkg::Options::=--force-confold']
-
-    cmd = ['apt-get', '--assume-yes']
-    cmd.extend(options)
-    cmd.append('install')
-    if isinstance(packages, six.string_types):
-        cmd.append(packages)
-    else:
-        cmd.extend(packages)
-    log("Installing {} with options: {}".format(packages,
-                                                options))
-    _run_apt_command(cmd, fatal)
-
-
-def apt_upgrade(options=None, fatal=False, dist=False):
+    fetch.install(packages, options, fatal)
+
+
+def upgrade(options=None, fatal=False, dist=False):
     """Upgrade all packages"""
-    if options is None:
-        options = ['--option=Dpkg::Options::=--force-confold']
-
-    cmd = ['apt-get', '--assume-yes']
-    cmd.extend(options)
-    if dist:
-        cmd.append('dist-upgrade')
-    else:
-        cmd.append('upgrade')
-    log("Upgrading with options: {}".format(options))
-    _run_apt_command(cmd, fatal)
-
-
-def apt_update(fatal=False):
+    fetch.upgrade(options, fatal, dist)
+
+
+def update(fatal=False):
     """Update local apt cache"""
-    cmd = ['apt-get', 'update']
-    _run_apt_command(cmd, fatal)
-
-
-def apt_purge(packages, fatal=False):
+    fetch.update(fatal)
+
+
+def purge(packages, fatal=False):
     """Purge one or more packages"""
-    cmd = ['apt-get', '--assume-yes', 'purge']
-    if isinstance(packages, six.string_types):
-        cmd.append(packages)
-    else:
-        cmd.extend(packages)
-    log("Purging {}".format(packages))
-    _run_apt_command(cmd, fatal)
-
-
-def apt_hold(packages, fatal=False):
-    """Hold one or more packages"""
-    cmd = ['apt-mark', 'hold']
-    if isinstance(packages, six.string_types):
-        cmd.append(packages)
-    else:
-        cmd.extend(packages)
-    log("Holding {}".format(packages))
-
-    if fatal:
-        subprocess.check_call(cmd)
-    else:
-        subprocess.call(cmd)
-
-
+    fetch.purge(packages, fatal)
+
+
+# PPA only works with .DEB packed and not with .RPM
 def add_source(source, key=None):
-    """Add a package source to this system.
-
-    @param source: a URL or sources.list entry, as supported by
-    add-apt-repository(1). Examples::
-
-        ppa:charmers/example
-        deb https://stub:[e-mail]/ubuntu trusty main
-
-    In addition:
-        'proposed:' may be used to enable the standard 'proposed'
-        pocket for the release.
-        'cloud:' may be used to activate official cloud archive pockets,
-        such as 'cloud:icehouse'
-        'distro' may be used as a noop
-
-    @param key: A key to be added to the system's APT keyring and used
-    to verify the signatures on packages. Ideally, this should be an
-    ASCII format GPG public key including the block headers. A GPG key
-    id may also be used, but be aware that only insecure protocols are
-    available to retrieve the actual public key from a public keyserver
-    placing your Juju environment at risk. ppa and cloud archive keys
-    are securely added automtically, so sould not be provided.
-    """
-    if source is None:
-        log('Source is not present. Skipping')
-        return
-
-    if (source.startswith('ppa:') or
-        source.startswith('http') or
-        source.startswith('deb ') or
-            source.startswith('cloud-archive:')):
-        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]
-        if pocket not in CLOUD_ARCHIVE_POCKETS:
-            raise SourceConfigError(
-                'Unsupported cloud: source option %s' %
-                pocket)
-        actual_pocket = CLOUD_ARCHIVE_POCKETS[pocket]
-        with open('/etc/apt/sources.list.d/cloud-archive.list', 'w') as apt:
-            apt.write(CLOUD_ARCHIVE.format(actual_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))
-    elif source == 'distro':
-        pass
-    else:
-        log("Unknown source: {!r}".format(source))
-
-    if key:
-        if '-----BEGIN PGP PUBLIC KEY BLOCK-----' in key:
-            with NamedTemporaryFile('w+') as key_file:
-                key_file.write(key)
-                key_file.flush()
-                key_file.seek(0)
-                subprocess.check_call(['apt-key', 'add', '-'], stdin=key_file)
-        else:
-            # Note that hkp: is in no way a secure protocol. Using a
-            # GPG key id is pointless from a security POV unless you
-            # absolutely trust your network and DNS.
-            subprocess.check_call(['apt-key', 'adv', '--keyserver',
-                                   'hkp://keyserver.ubuntu.com:80', '--recv',
-                                   key])
+    fetch.add_source(source, key)
 
 
 def configure_sources(update=False,
@@ -338,7 +147,32 @@
         for source, key in zip(sources, keys):
             add_source(source, key)
     if update:
-        apt_update(fatal=True)
+        update(fatal=True)
+
+
+def install_from_config(config_var_name):
+    charm_config = config()
+    source = charm_config[config_var_name]
+    return install_remote(source)
+
+
+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 NotImplementedError:
+            # 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
 
 
 def install_remote(source, *args, **kwargs):
@@ -370,70 +204,17 @@
     for handler in handlers:
         try:
             installed_to = handler.install(source, *args, **kwargs)
-        except UnhandledSource:
-            pass
+        except UnhandledSource as e:
+            log('Install source attempt unsuccessful: {}'.format(e),
+                level='WARNING')
     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)
-
-
-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
-
-
-def _run_apt_command(cmd, fatal=False):
-    """
-    Run an APT command, checking output and retrying if the fatal flag is set
-    to True.
-
-    :param: cmd: str: The apt command to run.
-    :param: fatal: bool: Whether the command's output should be checked and
-        retried.
-    """
-    env = os.environ.copy()
-
-    if 'DEBIAN_FRONTEND' not in env:
-        env['DEBIAN_FRONTEND'] = 'noninteractive'
-
-    if fatal:
-        retry_count = 0
-        result = None
-
-        # If the command is considered "fatal", we need to retry if the apt
-        # lock was not acquired.
-
-        while result is None or result == APT_NO_LOCK:
-            try:
-                result = subprocess.check_call(cmd, env=env)
-            except subprocess.CalledProcessError as e:
-                retry_count = retry_count + 1
-                if retry_count > APT_NO_LOCK_RETRY_COUNT:
-                    raise
-                result = e.returncode
-                log("Couldn't acquire DPKG lock. Will retry in {} seconds."
-                    "".format(APT_NO_LOCK_RETRY_DELAY))
-                time.sleep(APT_NO_LOCK_RETRY_DELAY)
-
-    else:
-        subprocess.call(cmd, env=env)
+# Backwards compatibility
+if get_platform() == "ubuntu":
+    from charmhelpers.fetch.ubuntu import *
+    apt_install = install
+    apt_update = update
+    apt_upgrade = upgrade
+    apt_purge = purge

=== modified file 'hooks/charmhelpers/fetch/archiveurl.py' (properties changed: -x to +x)
=== modified file 'hooks/charmhelpers/fetch/bzrurl.py' (properties changed: -x to +x)
--- hooks/charmhelpers/fetch/bzrurl.py	2015-03-23 09:45:10 +0000
+++ hooks/charmhelpers/fetch/bzrurl.py	2016-04-29 11:54:41 +0000
@@ -15,60 +15,51 @@
 # along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
 
 import os
+
+from subprocess import check_call
 from charmhelpers.fetch import (
     BaseFetchHandler,
-    UnhandledSource
+    UnhandledSource,
+    filter_installed_packages,
+    install,
 )
 from charmhelpers.core.host import mkdir
 
-import six
-if six.PY3:
-    raise ImportError('bzrlib does not support Python3')
 
-try:
-    from bzrlib.branch import Branch
-    from bzrlib import bzrdir, workingtree, errors
-except ImportError:
-    from charmhelpers.fetch import apt_install
-    apt_install("python-bzrlib")
-    from bzrlib.branch import Branch
-    from bzrlib import bzrdir, workingtree, errors
+if filter_installed_packages(['bzr']) != []:
+    install(['bzr'])
+    if filter_installed_packages(['bzr']) != []:
+        raise NotImplementedError('Unable to install bzr')
 
 
 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'):
+        if url_parts.scheme not in ('bzr+ssh', 'lp', ''):
             return False
+        elif not url_parts.scheme:
+            return os.path.exists(os.path.join(source, '.bzr'))
         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:
-            local_branch = bzrdir.BzrDir.create_branch_convenience(dest)
-        except errors.AlreadyControlDirError:
-            local_branch = Branch.open(dest)
-        try:
-            remote_branch = Branch.open(source)
-            remote_branch.push(local_branch)
-            tree = workingtree.WorkingTree.open(dest)
-            tree.update()
-        except Exception as e:
-            raise e
+        if os.path.exists(dest):
+            check_call(['bzr', 'pull', '--overwrite', '-d', dest, source])
+        else:
+            check_call(['bzr', 'branch', source, dest])
 
-    def install(self, source):
+    def install(self, source, dest=None):
         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 dest:
+            dest_dir = os.path.join(dest, branch_name)
+        else:
+            dest_dir = os.path.join(os.environ.get('CHARM_DIR'), "fetched",
+                                    branch_name)
+
         if not os.path.exists(dest_dir):
             mkdir(dest_dir, perms=0o755)
         try:

=== added directory 'hooks/charmhelpers/fetch/centos'
=== added file 'hooks/charmhelpers/fetch/centos/__init__.py'
--- hooks/charmhelpers/fetch/centos/__init__.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/fetch/centos/__init__.py	2016-04-29 11:54:41 +0000
@@ -0,0 +1,158 @@
+import subprocess
+import os
+import time
+import six
+import yum
+
+from tempfile import NamedTemporaryFile
+from charmhelpers.core.hookenv import (
+    log,
+)
+
+YUM_NO_LOCK = 1  # The return code for "couldn't acquire lock" in YUM.
+YUM_NO_LOCK_RETRY_DELAY = 10  # Wait 10 seconds between apt lock checks.
+YUM_NO_LOCK_RETRY_COUNT = 30  # Retry to acquire the lock X times.
+
+
+def filter_installed_packages(packages):
+    """Returns a list of packages that require installation"""
+    yb = yum.YumBase()
+    pkgs = []
+    for package in yb.doPackageLists().installed:
+        pkgs.append(package.base_package_name)
+    _pkgs = []
+    for package in packages:
+        if package not in pkgs:
+            _pkgs.append(package)
+    return _pkgs
+
+
+def install(packages, options=None, fatal=False):
+    """Install one or more packages"""
+    cmd = ['yum', '--assumeyes']
+    if options is not None:
+        cmd.extend(options)
+    cmd.append('install')
+    if isinstance(packages, six.string_types):
+        cmd.append(packages)
+    else:
+        cmd.extend(packages)
+    log("Installing {} with options: {}".format(packages,
+                                                options))
+    _run_yum_command(cmd, fatal)
+
+
+def update(fatal=False):
+    """Update local yum cache"""
+    cmd = ['yum', 'update', '--assumeyes']
+    log("Update with fatal: {}".format(fatal))
+    _run_yum_command(cmd, fatal)
+
+
+def upgrade(options=None, fatal=False, dist=False):
+    """Upgrade all packages"""
+    cmd = ['yum', '--assumeyes']
+    if options is not None:
+        cmd.extend(options)
+    cmd.append('upgrade')
+    log("Upgrading with options: {}".format(options))
+    _run_yum_command(cmd, fatal)
+
+
+def purge(packages, fatal=False):
+    """Purge one or more packages"""
+    cmd = ['yum', 'remove', '--assumeyes']
+    if isinstance(packages, six.string_types):
+        cmd.append(packages)
+    else:
+        cmd.extend(packages)
+    log("Purging {}".format(packages))
+    _run_yum_command(cmd, fatal)
+
+
+def yum_search(packages):
+    """Search for a package"""
+    output = {}
+    cmd = ['yum', 'search']
+    if isinstance(packages, six.string_types):
+        cmd.append(packages)
+    else:
+        cmd.extend(packages)
+    log("Searching for {}".format(packages))
+    result = subprocess.check_output(cmd)
+    for package in list(packages):
+        if package not in result:
+            output[package] = False
+        else:
+            output[package] = True
+    return output
+
+
+def add_source(source, key=None):
+    if source is None:
+        log('Source is not present. Skipping')
+        return
+
+    if source.startswith('http'):
+        log("Add source: {!r}".format(source))
+
+        found = False
+        # search if already exists
+        directory = '/etc/yum.repos.d/'
+        for filename in os.listdir(directory):
+            with open(directory+filename, 'r') as rpm_file:
+                if source in rpm_file:
+                    found = True
+
+        if not found:
+            # write in the charms.repo
+            with open(directory+'Charms.repo', 'a') as rpm_file:
+                rpm_file.write('[%s]\n' % source[7:].replace('/', '_'))
+                rpm_file.write('name=%s\n' % source[7:])
+                rpm_file.write('baseurl=%s\n\n' % source)
+    else:
+        log("Unknown source: {!r}".format(source))
+
+    if key:
+        if '-----BEGIN PGP PUBLIC KEY BLOCK-----' in key:
+            with NamedTemporaryFile('w+') as key_file:
+                key_file.write(key)
+                key_file.flush()
+                key_file.seek(0)
+            subprocess.check_call(['rpm', '--import', key_file])
+        else:
+            subprocess.check_call(['rpm', '--import', key])
+
+
+def _run_yum_command(cmd, fatal=False):
+    """
+    Run an YUM command, checking output and retrying if the fatal flag is set
+    to True.
+
+    :param: cmd: str: The yum command to run.
+    :param: fatal: bool: Whether the command's output should be checked and
+        retried.
+    """
+    env = os.environ.copy()
+
+    if fatal:
+        retry_count = 0
+        result = None
+
+        # If the command is considered "fatal", we need to retry if the yum
+        # lock was not acquired.
+
+        while result is None or result == YUM_NO_LOCK:
+            try:
+                result = subprocess.check_call(cmd, env=env)
+            except subprocess.CalledProcessError as e:
+                retry_count = retry_count + 1
+                if retry_count > YUM_NO_LOCK_RETRY_COUNT:
+                    raise
+                result = e.returncode
+                log("Couldn't acquire YUM lock. Will retry in {} seconds."
+                    "".format(YUM_NO_LOCK_RETRY_DELAY))
+                time.sleep(YUM_NO_LOCK_RETRY_DELAY)
+
+    else:
+        subprocess.call(cmd, env=env)

=== modified file 'hooks/charmhelpers/fetch/giturl.py' (properties changed: -x to +x)
--- hooks/charmhelpers/fetch/giturl.py	2015-03-23 09:45:10 +0000
+++ hooks/charmhelpers/fetch/giturl.py	2016-04-29 11:54:41 +0000
@@ -15,24 +15,18 @@
 # along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
 
 import os
+from subprocess import check_call, CalledProcessError
 from charmhelpers.fetch import (
     BaseFetchHandler,
-    UnhandledSource
+    UnhandledSource,
+    filter_installed_packages,
+    install,
 )
-from charmhelpers.core.host import mkdir
-
-import six
-if six.PY3:
-    raise ImportError('GitPython does not support Python 3')
-
-try:
-    from git import Repo
-except ImportError:
-    from charmhelpers.fetch import apt_install
-    apt_install("python-git")
-    from git import Repo
-
-from git.exc import GitCommandError  # noqa E402
+
+if filter_installed_packages(['git']) != []:
+    install(['git'])
+    if filter_installed_packages(['git']) != []:
+        raise NotImplementedError('Unable to install git')
 
 
 class GitUrlFetchHandler(BaseFetchHandler):
@@ -40,19 +34,26 @@
     def can_handle(self, source):
         url_parts = self.parse_url(source)
         # TODO (mattyw) no support for ssh git@ yet
-        if url_parts.scheme not in ('http', 'https', 'git'):
+        if url_parts.scheme not in ('http', 'https', 'git', ''):
             return False
+        elif not url_parts.scheme:
+            return os.path.exists(os.path.join(source, '.git'))
         else:
             return True
 
-    def clone(self, source, dest, branch):
+    def clone(self, source, dest, branch="master", 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 os.path.exists(dest):
+            cmd = ['git', '-C', dest, 'pull', source, branch]
+        else:
+            cmd = ['git', 'clone', source, dest, '--branch', branch]
+            if depth:
+                cmd.extend(['--depth', depth])
+        check_call(cmd)
 
-    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:
@@ -60,12 +61,10 @@
         else:
             dest_dir = os.path.join(os.environ.get('CHARM_DIR'), "fetched",
                                     branch_name)
-        if not os.path.exists(dest_dir):
-            mkdir(dest_dir, perms=0o755)
         try:
-            self.clone(source, dest_dir, branch)
-        except GitCommandError as e:
-            raise UnhandledSource(e.message)
+            self.clone(source, dest_dir, branch, depth)
+        except CalledProcessError as e:
+            raise UnhandledSource(e)
         except OSError as e:
             raise UnhandledSource(e.strerror)
         return dest_dir

=== added directory 'hooks/charmhelpers/fetch/ubuntu'
=== added file 'hooks/charmhelpers/fetch/ubuntu/__init__.py'
--- hooks/charmhelpers/fetch/ubuntu/__init__.py	1970-01-01 00:00:00 +0000
+++ hooks/charmhelpers/fetch/ubuntu/__init__.py	2016-04-29 11:54:41 +0000
@@ -0,0 +1,296 @@
+import os
+import six
+import time
+import subprocess
+
+from tempfile import NamedTemporaryFile
+from charmhelpers.core.host import (
+    lsb_release
+)
+from charmhelpers.core.hookenv import (
+    log,
+)
+from charmhelpers.fetch import (
+    SourceConfigError,
+)
+
+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
+"""
+CLOUD_ARCHIVE_POCKETS = {
+    # Folsom
+    'folsom': 'precise-updates/folsom',
+    'precise-folsom': 'precise-updates/folsom',
+    'precise-folsom/updates': 'precise-updates/folsom',
+    'precise-updates/folsom': 'precise-updates/folsom',
+    'folsom/proposed': 'precise-proposed/folsom',
+    'precise-folsom/proposed': 'precise-proposed/folsom',
+    'precise-proposed/folsom': 'precise-proposed/folsom',
+    # Grizzly
+    'grizzly': 'precise-updates/grizzly',
+    'precise-grizzly': 'precise-updates/grizzly',
+    'precise-grizzly/updates': 'precise-updates/grizzly',
+    'precise-updates/grizzly': 'precise-updates/grizzly',
+    'grizzly/proposed': 'precise-proposed/grizzly',
+    'precise-grizzly/proposed': 'precise-proposed/grizzly',
+    'precise-proposed/grizzly': 'precise-proposed/grizzly',
+    # Havana
+    'havana': 'precise-updates/havana',
+    'precise-havana': 'precise-updates/havana',
+    'precise-havana/updates': 'precise-updates/havana',
+    'precise-updates/havana': 'precise-updates/havana',
+    'havana/proposed': 'precise-proposed/havana',
+    'precise-havana/proposed': 'precise-proposed/havana',
+    'precise-proposed/havana': 'precise-proposed/havana',
+    # Icehouse
+    'icehouse': 'precise-updates/icehouse',
+    'precise-icehouse': 'precise-updates/icehouse',
+    'precise-icehouse/updates': 'precise-updates/icehouse',
+    'precise-updates/icehouse': 'precise-updates/icehouse',
+    'icehouse/proposed': 'precise-proposed/icehouse',
+    'precise-icehouse/proposed': 'precise-proposed/icehouse',
+    'precise-proposed/icehouse': 'precise-proposed/icehouse',
+    # Juno
+    'juno': 'trusty-updates/juno',
+    'trusty-juno': 'trusty-updates/juno',
+    'trusty-juno/updates': 'trusty-updates/juno',
+    'trusty-updates/juno': 'trusty-updates/juno',
+    'juno/proposed': 'trusty-proposed/juno',
+    'trusty-juno/proposed': 'trusty-proposed/juno',
+    'trusty-proposed/juno': 'trusty-proposed/juno',
+    # Kilo
+    'kilo': 'trusty-updates/kilo',
+    'trusty-kilo': 'trusty-updates/kilo',
+    'trusty-kilo/updates': 'trusty-updates/kilo',
+    'trusty-updates/kilo': 'trusty-updates/kilo',
+    'kilo/proposed': 'trusty-proposed/kilo',
+    'trusty-kilo/proposed': 'trusty-proposed/kilo',
+    'trusty-proposed/kilo': 'trusty-proposed/kilo',
+    # Liberty
+    'liberty': 'trusty-updates/liberty',
+    'trusty-liberty': 'trusty-updates/liberty',
+    'trusty-liberty/updates': 'trusty-updates/liberty',
+    'trusty-updates/liberty': 'trusty-updates/liberty',
+    'liberty/proposed': 'trusty-proposed/liberty',
+    'trusty-liberty/proposed': 'trusty-proposed/liberty',
+    'trusty-proposed/liberty': 'trusty-proposed/liberty',
+    # Mitaka
+    'mitaka': 'trusty-updates/mitaka',
+    'trusty-mitaka': 'trusty-updates/mitaka',
+    'trusty-mitaka/updates': 'trusty-updates/mitaka',
+    'trusty-updates/mitaka': 'trusty-updates/mitaka',
+    'mitaka/proposed': 'trusty-proposed/mitaka',
+    'trusty-mitaka/proposed': 'trusty-proposed/mitaka',
+    'trusty-proposed/mitaka': 'trusty-proposed/mitaka',
+}
+
+
+APT_NO_LOCK = 100  # The return code for "couldn't acquire lock" in APT.
+APT_NO_LOCK_RETRY_DELAY = 10  # Wait 10 seconds between apt lock checks.
+APT_NO_LOCK_RETRY_COUNT = 30  # Retry to acquire the lock X times.
+
+
+def filter_installed_packages(packages):
+    """Returns a list of packages that require installation"""
+    temp_cache = apt_cache()
+    _pkgs = []
+    for package in packages:
+        try:
+            p = temp_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_cache(in_memory=True):
+    """Build and return an apt cache"""
+    from apt import apt_pkg
+    apt_pkg.init()
+    if in_memory:
+        apt_pkg.config.set("Dir::Cache::pkgcache", "")
+        apt_pkg.config.set("Dir::Cache::srcpkgcache", "")
+    return apt_pkg.Cache()
+
+
+def install(packages, options=None, fatal=False):
+    """Install one or more packages"""
+    if options is None:
+        options = ['--option=Dpkg::Options::=--force-confold']
+
+    cmd = ['apt-get', '--assume-yes']
+    cmd.extend(options)
+    cmd.append('install')
+    if isinstance(packages, six.string_types):
+        cmd.append(packages)
+    else:
+        cmd.extend(packages)
+    log("Installing {} with options: {}".format(packages,
+                                                options))
+    _run_apt_command(cmd, fatal)
+
+
+def upgrade(options=None, fatal=False, dist=False):
+    """Upgrade all packages"""
+    if options is None:
+        options = ['--option=Dpkg::Options::=--force-confold']
+
+    cmd = ['apt-get', '--assume-yes']
+    cmd.extend(options)
+    if dist:
+        cmd.append('dist-upgrade')
+    else:
+        cmd.append('upgrade')
+    log("Upgrading with options: {}".format(options))
+    _run_apt_command(cmd, fatal)
+
+
+def update(fatal=False):
+    """Update local apt cache"""
+    cmd = ['apt-get', 'update']
+    _run_apt_command(cmd, fatal)
+
+
+def purge(packages, fatal=False):
+    """Purge one or more packages"""
+    cmd = ['apt-get', '--assume-yes', 'purge']
+    if isinstance(packages, six.string_types):
+        cmd.append(packages)
+    else:
+        cmd.extend(packages)
+    log("Purging {}".format(packages))
+    _run_apt_command(cmd, fatal)
+
+
+def apt_mark(packages, mark, fatal=False):
+    """Flag one or more packages using apt-mark"""
+    log("Marking {} as {}".format(packages, mark))
+    cmd = ['apt-mark', mark]
+    if isinstance(packages, six.string_types):
+        cmd.append(packages)
+    else:
+        cmd.extend(packages)
+
+    if fatal:
+        subprocess.check_call(cmd, universal_newlines=True)
+    else:
+        subprocess.call(cmd, universal_newlines=True)
+
+
+def apt_hold(packages, fatal=False):
+    return apt_mark(packages, 'hold', fatal=fatal)
+
+
+def apt_unhold(packages, fatal=False):
+    return apt_mark(packages, 'unhold', fatal=fatal)
+
+
+def add_source(source, key=None):
+    """Add a package source to this system.
+
+    @param source: a URL or sources.list entry, as supported by
+    add-apt-repository(1). Examples::
+
+        ppa:charmers/example
+        deb https://stub:[e-mail]/ubuntu trusty main
+
+    In addition:
+        'proposed:' may be used to enable the standard 'proposed'
+        pocket for the release.
+        'cloud:' may be used to activate official cloud archive pockets,
+        such as 'cloud:icehouse'
+        'distro' may be used as a noop
+
+    @param key: A key to be added to the system's APT keyring and used
+    to verify the signatures on packages. Ideally, this should be an
+    ASCII format GPG public key including the block headers. A GPG key
+    id may also be used, but be aware that only insecure protocols are
+    available to retrieve the actual public key from a public keyserver
+    placing your Juju environment at risk. ppa and cloud archive keys
+    are securely added automtically, so sould not be provided.
+    """
+    if source is None:
+        log('Source is not present. Skipping')
+        return
+
+    if (source.startswith('ppa:') or
+        source.startswith('http') or
+        source.startswith('deb ') or
+            source.startswith('cloud-archive:')):
+        subprocess.check_call(['add-apt-repository', '--yes', source])
+    elif source.startswith('cloud:'):
+        install(filter_installed_packages(['ubuntu-cloud-keyring']),
+                fatal=True)
+        pocket = source.split(':')[-1]
+        if pocket not in CLOUD_ARCHIVE_POCKETS:
+            raise SourceConfigError(
+                'Unsupported cloud: source option %s' %
+                pocket)
+        actual_pocket = CLOUD_ARCHIVE_POCKETS[pocket]
+        with open('/etc/apt/sources.list.d/cloud-archive.list', 'w') as apt:
+            apt.write(CLOUD_ARCHIVE.format(actual_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))
+    elif source == 'distro':
+        pass
+    else:
+        log("Unknown source: {!r}".format(source))
+
+    if key:
+        if '-----BEGIN PGP PUBLIC KEY BLOCK-----' in key:
+            with NamedTemporaryFile('w+') as key_file:
+                key_file.write(key)
+                key_file.flush()
+                key_file.seek(0)
+                subprocess.check_call(['apt-key', 'add', '-'], stdin=key_file)
+        else:
+            # Note that hkp: is in no way a secure protocol. Using a
+            # GPG key id is pointless from a security POV unless you
+            # absolutely trust your network and DNS.
+            subprocess.check_call(['apt-key', 'adv', '--keyserver',
+                                   'hkp://keyserver.ubuntu.com:80', '--recv',
+                                   key])
+
+
+def _run_apt_command(cmd, fatal=False):
+    """
+    Run an APT command, checking output and retrying if the fatal flag is set
+    to True.
+
+    :param: cmd: str: The apt command to run.
+    :param: fatal: bool: Whether the command's output should be checked and
+        retried.
+    """
+    env = os.environ.copy()
+
+    if 'DEBIAN_FRONTEND' not in env:
+        env['DEBIAN_FRONTEND'] = 'noninteractive'
+
+    if fatal:
+        retry_count = 0
+        result = None
+
+        # If the command is considered "fatal", we need to retry if the apt
+        # lock was not acquired.
+
+        while result is None or result == APT_NO_LOCK:
+            try:
+                result = subprocess.check_call(cmd, env=env)
+            except subprocess.CalledProcessError as e:
+                retry_count = retry_count + 1
+                if retry_count > APT_NO_LOCK_RETRY_COUNT:
+                    raise
+                result = e.returncode
+                log("Couldn't acquire DPKG lock. Will retry in {} seconds."
+                    "".format(APT_NO_LOCK_RETRY_DELAY))
+                time.sleep(APT_NO_LOCK_RETRY_DELAY)
+
+    else:
+        subprocess.call(cmd, env=env)

=== modified file 'hooks/nrpe_helpers.py' (properties changed: -x to +x)
=== modified file 'hooks/nrpe_utils.py' (properties changed: -x to +x)
--- hooks/nrpe_utils.py	2016-01-18 22:54:35 +0000
+++ hooks/nrpe_utils.py	2016-04-29 11:54:41 +0000
@@ -1,14 +1,18 @@
 import os
 import shutil
 import glob
+import importlib
 
 from charmhelpers import fetch
 from charmhelpers.core import host
 from charmhelpers.core.templating import render
 from charmhelpers.core import hookenv
+from charmhelpers import get_platform
 
 import nrpe_helpers
 
+platform = importlib.import_module(get_platform())
+
 
 def restart_rsync(service_name):
     """ Restart rsync """
@@ -17,25 +21,18 @@
 
 def restart_nrpe(service_name):
     """ Restart nrpe """
-    host.service_restart('nagios-nrpe-server')
+    platform.restart_nrpe(service_name)
 
 
 def determine_packages():
     """ List of packages this charm needs installed """
-    pkgs = [
-        'nagios-nrpe-server',
-        'nagios-plugins-basic',
-        'nagios-plugins-standard'
-    ]
-    if hookenv.config('export_nagios_definitions'):
-        pkgs.append('rsync')
-    return pkgs
+    return platform.determine_packages()
 
 
 def install_packages(service_name):
     """ Install packages """
-    fetch.apt_update()
-    fetch.apt_install(determine_packages(), fatal=True)
+    fetch.update()
+    fetch.install(determine_packages(), fatal=True)
 
 
 def remove_host_export_fragments(service_name):
@@ -139,5 +136,6 @@
     for rid in hookenv.relation_ids('monitors'):
         hookenv.relation_set(
             relation_id=rid,
-            relation_settings=monitor_relation.provide_data()
+            relation_settings=monitor_relation.provide_data(),
+            charm_platform=get_platform()
         )

=== modified file 'hooks/services.py' (properties changed: -x to +x)
--- hooks/services.py	2016-01-19 19:29:15 +0000
+++ hooks/services.py	2016-04-29 11:54:41 +0000
@@ -1,9 +1,13 @@
+import nrpe_utils
+import nrpe_helpers
+import importlib
+
 from charmhelpers.core import hookenv
 from charmhelpers.core.services.base import ServiceManager
 from charmhelpers.core.services import helpers
+from charmhelpers import get_platform
 
-import nrpe_utils
-import nrpe_helpers
+platform = importlib.import_module(get_platform())
 
 
 def manage():
@@ -29,10 +33,7 @@
                 nrpe_utils.update_nrpe_external_master_relation,
                 nrpe_utils.update_monitor_relation,
                 nrpe_utils.render_nrped_files,
-                helpers.render_template(
-                    source='nrpe.tmpl',
-                    target='/etc/nagios/nrpe.cfg'
-                ),
+                platform.render_nrpe_template(),
             ],
             'provided_data': [nrpe_helpers.PrincipleRelation()],
             'start': [nrpe_utils.restart_nrpe],

=== added file 'hooks/ubuntu.py'
--- hooks/ubuntu.py	1970-01-01 00:00:00 +0000
+++ hooks/ubuntu.py	2016-04-29 11:54:41 +0000
@@ -0,0 +1,27 @@
+from charmhelpers.core import host
+from charmhelpers.core import hookenv
+from charmhelpers.core.services import helpers
+
+
+def determine_packages():
+    """ List of packages this charm needs installed """
+    pkgs = [
+        'nagios-nrpe-server',
+        'nagios-plugins-basic',
+        'nagios-plugins-standard'
+    ]
+    if hookenv.config('export_nagios_definitions'):
+        pkgs.append('rsync')
+    return pkgs
+
+
+def restart_nrpe(service_name):
+    """ Restart nrpe """
+    host.service_restart('nagios-nrpe-server')
+
+
+def render_nrpe_template():
+    return helpers.render_template(
+                    source='nrpe.tmpl',
+                    target='/etc/nagios/nrpe.cfg'
+                    )

=== added file 'templates/nrpe-centos.tmpl'
--- templates/nrpe-centos.tmpl	1970-01-01 00:00:00 +0000
+++ templates/nrpe-centos.tmpl	2016-04-29 11:54:41 +0000
@@ -0,0 +1,16 @@
+#--------------------------------------------------------
+# This file is managed by Juju
+#--------------------------------------------------------
+
+server_port={{ server_port }}
+allowed_hosts={{ external_nagios_master }},{{ monitor_allowed_hosts }}
+nrpe_user=nrpe
+nrpe_group=nrpe
+dont_blame_nrpe=0cat 
+debug=0
+command_timeout=60
+pid_file=/var/run/nrpe/nrpe.pid
+
+# All configuration snippets go into nrpe.d/
+include_dir=/etc/nagios/nrpe.d/
+

=== modified file 'tests/11-monitors-configurations'
--- tests/11-monitors-configurations	2016-02-03 22:17:17 +0000
+++ tests/11-monitors-configurations	2016-04-29 11:54:41 +0000
@@ -37,11 +37,11 @@
     # look for procrunning in nrpe config
     try:
         mysql_unit.file_contents('/etc/nagios/nrpe.d/'
-                                 'check_proc_mysqld_principle.cfg')
+                                 'check_total_procs_testing.cfg')
     except IOError as e:
-        amulet.raise_status(amulet.ERROR,
-                            msg="procrunning config not found. Error:" +
-                            e.args[1])
+        amulet.raise_status(amulet.FAIL,
+                            msg="procrunning config not found. Error: {0}".format(e)
+                            )
 
 
 def test_nagios_monitors_response():
@@ -52,7 +52,7 @@
     r = requests.get(host_url % nagios_unit.info['public-address'],
                      auth=('nagiosadmin', nagpwd))
     if not r.text.find('mysql-0-basic'):
-        amulet.raise_status(amulet.ERROR,
+        amulet.raise_status(amulet.FAIL,
                             msg='Nagios is not monitoring the' +
                             ' hosts it supposed to.')
 

=== modified file 'tests/13-monitors-config'
--- tests/13-monitors-config	2016-02-03 22:17:17 +0000
+++ tests/13-monitors-config	2016-04-29 11:54:41 +0000
@@ -49,11 +49,11 @@
     # look for procrunning in nrpe config
     try:
         mysql_unit.file_contents('/etc/nagios/nrpe.d/'
-                                 'check_proc_mysqld_principle.cfg')
+                                 'check_total_procs_testing.cfg')
     except IOError as e:
-        amulet.raise_status(amulet.ERROR,
-                            msg="procrunning config not found. Error:" +
-                            e.args[1])
+        amulet.raise_status(amulet.FAIL,
+                            msg="procrunning config not found. Error: {0}".format(e)
+                            )
 
 
 def test_nagios_monitors_response():
@@ -64,7 +64,7 @@
     r = requests.get(host_url % nagios_unit.info['public-address'],
                      auth=('nagiosadmin', nagpwd))
     if not r.text.find('processcount'):
-        amulet.raise_status(amulet.ERROR,
+        amulet.raise_status(amulet.FAIL,
                             msg='Nagios is not monitoring the' +
                             ' hosts it supposed to.')