Merge lp:~dbuliga/charm-helpers/charm-helpers into lp:charm-helpers

[Denis Buliga]

Considering that now there is CentOS support in Juju, it would be great to also support this platform in charmhelpers. As a result, this branch attempts to add cross platform support for RPM based systems, with CentOS as the first such OS.

This branch introduces a factory that based on platform, loads the proper functionality for that platform. There is currently a module "ubuntu", which is basically the old code moved into its own submodule, and a "centos" which implements the same functionality. The factory itself defines a number of functions that are common between the 2 OSs. For backwards compatibility, it also does a:

from .ubuntu import *

So you still get the same behavior as you previously did. So far only 2 modules have been touched by this branch: core and fetch. Most of the others are not really needed for basic charm building (contrib/openstack for example)

There was the need of a method in charmhelpers/__init__.py which returns the current platform. It is called "get_platform" and returns at the moment a string "ubuntu" when the platform is Ubuntu, and "centos" when the platform is CentOS. These strings are used to determine in which folder the code should look for the methods.

The need of changing methods name in fetch appeared because, in CentOS it was not feasible to have methods with name such as: (apt_install for example)
It will be easier to transition charms from using functions like: "apt_install" to just "install". More than this, at the bottom of the fetch/__init__.py there are some aliases created for backwards compatibility.

Initial code review comment from Charles Butler(lazypower):
https://code.launchpad.net/~dbuliga/charm-helpers/charm-helpers/+merge/285044/comments/730488

[Matt Bruzek (mbruzek)]

Denis,

Thanks for this merge proposal! I am very interested in adding support for CentOS.

Added a few comments in the code about _removing_ docstrings or changing docstring quotes to be inconsistent in the file. Since this is a library we should docstring every non private method.

Tried running `make test` in this branch and the "lint" target failed with several errors in the files you added, edited. Please make sure this branch passes lint and test make targets.

This is a big change, and many charms use charm-helpers. If you could help identify a way (or a charm) to verify this does not break backward compatibility with charms that install charm-helpers that would be most appreciated.

[lp:~dbuliga/charm-helpers/charm-helpers]

581. By Matt Bruzek on 2016-06-02

[jamesbeedy] Added uid and gid specification functionality for adduser and addgroup.
[mbruzek] Added a newline to fix lint.

[Denis Buliga (dbuliga)]

> Denis,
>
> Thanks for this merge proposal! I am very interested in adding support for
> CentOS.
>
> Added a few comments in the code about _removing_ docstrings or changing
> docstring quotes to be inconsistent in the file. Since this is a library we
> should docstring every non private method.
>
> Tried running `make test` in this branch and the "lint" target failed with
> several errors in the files you added, edited. Please make sure this branch
> passes lint and test make targets.
>
> This is a big change, and many charms use charm-helpers. If you could help
> identify a way (or a charm) to verify this does not break backward
> compatibility with charms that install charm-helpers that would be most
> appreciated.

I have implemented the necessary changes in order to meet your requirements. There might be a way you can test this PR. I have implemented a refactor of squid_reverseproxy charm to work on centos without breaking ubuntu's old functionality. It can be found here:
https://code.launchpad.net/~dbuliga/charms/trusty/squid-reverseproxy/centos

[lp:~dbuliga/charm-helpers/charm-helpers]

582. By Ryan Beisner on 2016-06-13

[jamespage,r=1chb1n] Update amulet helpers to deploy charms from the charm store

As part of the migration to git/gerrit and with the introduction of
layered charms, the charm store really needs to be the definative
source of truth for all charms during test.

Switch the charm resolver code to pick the correct charms from the
charm store for amulet tests.

This does change behaviour in that base charms are deployed aligned
to the test series where possible; otherwise the most recent Ubuntu
series is used instead - results in mysql/trusty + keystone/xenial
for example.

583. By James Page on 2016-06-14

Enable default git repo generation if a default openstack-origin-git value is specified.

584. By David Ames on 2016-06-14

[thedac, r=tinwood] DNS HA Helpers

Start the process of moving HA helpers into the openstack contrib area
Add the helper for API charms to use DNS HA
Add validation for new DNS config options in HA
Allow resolve_address to override with DNS or not

585. By Stuart Bishop on 2016-06-16

[marcoceppi, r=stub] Fix bzr branch installer

586. By Stuart Bishop on 2016-06-16

[george-edison55, r=stub] Fix fetch.install_remote() when multiple handlers match the URL

587. By Stuart Bishop on 2016-06-16

[chris-gondolin, r=stub] Option to specify a revno when fetching from a bzr repo

588. By Stuart Bishop on 2016-06-16

[stub] Add test to bzr revno fetcher, fix casting of bzr revno

589. By Stuart Bishop on 2016-06-17

[freyes, r=stub] Mock contrib.network.ufw.modprobe in tests as required

590. By James Page on 2016-06-23

Updates for DNS-HA support in non-api OpenStack charms.

591. By James Page on 2016-06-23

Rebase

592. By Liam Young on 2016-06-23

[gnuoy, r=james-page] Decode result of check_output in network_get_primary_address

Under python3.5 check_output returns bytes which need decoding. This change
adds the decode to network_get_primary_address and brings it in line with other
core hookenv functions.

593. By James Page on 2016-06-23

Fixes for deploy from source for openstack

594. By James Page on 2016-07-01

Fixes for apparmor support for openstack contrib module

595. By James Page on 2016-07-05

Misc fixes and improvements for deploy-from-source.

596. By James Page on 2016-07-05

Add missing openstack.ha package to setup.py

597. By Marco Ceppi <marco@T430> on 2016-07-06

[james-page] Re-license charm-helpers inline with agreed licensing approaches for charms, interfaces and layers.

598. By Marco Ceppi <marco@T430> on 2016-07-06

version bump

599. By Marco Ceppi <marco@T430> on 2016-07-06

flake8 fixes

600. By James Page on 2016-07-07

[trivial] Support nrpe for testing on wily and xenial

601. By James Page on 2016-07-08

Add option to allow location of user home directory to be provided when creating users.

602. By Ryan Beisner on 2016-07-12

[chris.macnaughton, r=1chb1n] Add ceph-proxy to source charms for openstack amulet helper

603. By Ryan Beisner on 2016-07-12

[thedac, r=1chb1n] Send LSB release to apparmor context templates

Set the LSB release to be consumed by apparmor context profiles

604. By David Ames on 2016-07-12

[billy-olsen, r=thedac] Allow float for worker-multiplier.

605. By James Page on 2016-07-13

Misc updates for deploy from source

Improve OpenStack release determination.

606. By Jorge Niedbalski on 2016-07-13

[billy-olsen, r=niedbalski, cholcombe] Partially fixes bug LP: #1492742

607. By Jorge Niedbalski on 2016-07-13

[niedbalski, r=] Fix broken tests for py2.7

608. By Stuart Bishop on 2016-07-14

[stub,r=james-page] Make fetch.apt_cache() quiet by default

609. By Stuart Bishop on 2016-07-15

[fginther, r=stub] Install python3-jinja2 when running Python3

610. By James Page on 2016-07-18

Add 2.9.0 to list of releases for newton

611. By David Ames on 2016-07-18

[thedac, r=gnuoy] Make apt_install fatal=True for dnspython install

612. By Liam Young on 2016-07-21

[gnuoy, r=jamespage] Only write out CA cert if it has changed

Only write out CA cert and run the update-ca-certificates if the cert has
actually changed. This reduces the risk of certs being pulled from under services
which are trying to do client side certificate validation on remote https
endpoints.

613. By Liam Young on 2016-07-21

[1chb1n, r=gnuoy] Consume env var AMULET_SETUP_TIMEOUT if set

614. By Liam Young on 2016-07-21

[corey.bryant, r=gnuoy] Install networking-hyperv when deploying neutron-api from source.

615. By Stuart Bishop on 2016-07-29

[axino, r=stub] nrpe: make add_init_service_checks support systemd

[Alex Kavanagh (ajkavanagh)]

Hi Dennis

A huge amount of work has gone into this. I, too, like the general
approach. However, I would like to suggest a slightly radical change on approach to the
module that I think will simplify its merging and make it easier to maintain in the future.

However, firstly, the changes don't pass the 'make lint' command (e.g. PEP8
compliance).

Also, I also believe that charm-helpers has had a few more commits since your
last revision which means that it'll need to be brought back up to tip.

My suggestion is to not use classes, but instead just use sub-modules for the differences
between (in this case CentOS and Ubuntu). Hopefully, my comments will make sense below:

Comments

get_platform() in charmhelpers/__init__.py

This function is at a top level, but isn't needed by the vast majority of
charmhelpers. I would propose to put it into its own module.

Also, the function could be more defensive and raise a RuntimeError() in the
case where the platform is neither Ubuntu nor CentOS. e.g.

def get_platform():
    """
        Return the current OS platform

        For example: if current os platform is Ubuntu then a string "ubuntu"
        will be returned (which is the name of the module).
        This string is used to decide which platform module should be imported.
    """
    tuple_platform = platform.linux_distribution()
    current_platform = tuple_platform[0]
    if "Ubuntu" in current_platform:
        return "ubuntu"
    elif "CentOS" in current_platform:
        return "centos"
    else:
        raise RuntimeError("This module is not supported on {}."
                           .format(current_platform))

charmhelpers/core/host_factory/__init__.py

I think that the use of classes to separate common code from host specific code
is over-complicating this code and looks very different to the rest of the
charmhelpers code.

I'd like to suggest that this be refactored into a simpler module system with a
host selector that selectively imports specific host functions as the 'generic'
function.

i.e. charmhelpers/core/host.py

import os

from contextlib import contextmanager
from charmhelpers.core import host_factory

__platform = ... determine the platform ...
if __platform == 'ubuntu':
    from charmhelpers.core.host.ubuntu import (
        service_available,
        add_group,
        lsb_release,
        cmp_pkgrevno,
    )
elif __platform = 'centos':
    from charmhelpers.core.host.centos import (
        service_available,
        add_group,
        lsb_release,
        cmp_pkgrevno,
    )

... the rest of the common code.

If there is common code in functions, there's no reason you can't import an
'service_available_host' function and use that in the service_available()
function.

This will make the patch set much smaller (as there are fewer functions being
changed) yet the host specific code can still be used transparently from the
calling code.

charmhelpers/core/kernel.py

I think the same thing can be done with the kernel files. There are only two
functions that are different, thus:

__platform = ... determine the platform ...
if __platform == 'ubuntu':
    from charmhelpers.core.kernel.ubuntu import (
       modprobe...

[lp:~dbuliga/charm-helpers/charm-helpers]

616. By Liam Young on 2016-08-01

[ajkavanagh r=gnuoy] Add a v3 version of service catalog checking

This adds a keystone v3 version of service catalog checking to the
contrib/openstack/amulet/utils.py file.

617. By Liam Young on 2016-08-01

[gnuoy, trivial] Lint fix

618. By James Page on 2016-08-02

Set a minimum PG count of 2, to avoid math domain errors in small OSD setups

619. By Denis Buliga on 2016-08-10

Added Support for CentOS and unit tests. Addressed review comments

[Alex Kavanagh (ajkavanagh)]

Hi Dennis

Definitely getting there. I've included some comments to try to simplify some small bits of code, and be a bit more idiomatic Python, but otherwise it's now very close. I'll also try to run the tests and comment back here.

Thanks again.

review: Needs Fixing

[Alex Kavanagh (ajkavanagh)]

I've run the 'make lint' and that passes for both Py2 and Py3 - great stuff.

The make test2 and test3 are still failing for me on a clean box - it's missing the yum module which either needs mocking out or including in test_requirements.txt as needed. I suspect it just needs mocking out. Note, to mock it out for tests, it has to be got at before the file-under-test is loaded, which usually means mocking it out in an __init__.py in the tests folder.

[lp:~dbuliga/charm-helpers/charm-helpers]

620. By Denis Buliga on 2016-08-11

Implemented changes. Addressed review comments.

621. By Denis Buliga on 2016-08-12

Using getenv method instead of mocking os.environ

[Alex Kavanagh (ajkavanagh)]

I've worked with Dennis and it nows passes lint on Py2, Py3 and it passes all of it's test2 and test3 tests. I think it's now ready to merge.

Thanks very much Dennis!

review: Approve

[Marco Ceppi (marcoceppi)]

LGTM +1

review: Approve

=== modified file 'charmhelpers/core/host.py'
--- charmhelpers/core/host.py	2016-07-07 14:08:38 +0000
+++ charmhelpers/core/host.py	2016-08-12 07:09:49 +0000
@@ -30,13 +30,29 @@
 import hashlib
 import functools
 import itertools
+import six
+
 from contextlib import contextmanager
 from collections import OrderedDict
-
-import six
-
 from .hookenv import log
 from .fstab import Fstab
+from charmhelpers.osplatform import get_platform
+
+__platform__ = get_platform()
+if __platform__ == "ubuntu":
+    from charmhelpers.core.host_factory.ubuntu import (
+        service_available,
+        add_new_group,
+        lsb_release,
+        cmp_pkgrevno,
+    )  # flake8: noqa -- ignore F401 for this import
+elif __platform__ == "centos":
+    from charmhelpers.core.host_factory.centos import (
+        service_available,
+        add_new_group,
+        lsb_release,
+        cmp_pkgrevno,
+    )  # flake8: noqa -- ignore F401 for this import
 
 
 def service_start(service_name):
@@ -144,8 +160,11 @@
                 return False
             else:
                 # This works for upstart scripts where the 'service' command
-                # returns a consistent string to represent running 'start/running'
-                if "start/running" in output:
+                # returns a consistent string to represent running
+                # 'start/running'
+                if ("start/running" in output or
+                        "is running" in output or
+                        "up and running" in output):
                     return True
         elif os.path.exists(_INIT_D_CONF.format(service_name)):
             # Check System V scripts init script return codes
@@ -153,18 +172,6 @@
         return False
 
 
-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 b'unrecognized service' not in e.output
-    else:
-        return True
-
-
 SYSTEMD_SYSTEM = '/run/systemd/system'
 
 
@@ -173,8 +180,9 @@
     return os.path.isdir(SYSTEMD_SYSTEM)
 
 
-def adduser(username, password=None, shell='/bin/bash', system_user=False,
-            primary_group=None, secondary_groups=None, uid=None, home_dir=None):
+def adduser(username, password=None, shell='/bin/bash',
+            system_user=False, primary_group=None,
+            secondary_groups=None, uid=None, home_dir=None):
     """Add a user to the system.
 
     Will log but otherwise succeed if the user already exists.
@@ -286,17 +294,7 @@
             log('group with gid {0} already exists!'.format(gid))
     except KeyError:
         log('creating group {0}'.format(group_name))
-        cmd = ['addgroup']
-        if gid:
-            cmd.extend(['--gid', str(gid)])
-        if system_group:
-            cmd.append('--system')
-        else:
-            cmd.extend([
-                '--group',
-            ])
-        cmd.append(group_name)
-        subprocess.check_call(cmd)
+        add_new_group(group_name, system_group, gid)
         group_info = grp.getgrnam(group_name)
     return group_info
 
@@ -541,16 +539,6 @@
     return r
 
 
-def lsb_release():
-    """Return /etc/lsb-release in a dict"""
-    d = {}
-    with open('/etc/lsb-release', 'r') as lsb:
-        for l in lsb:
-            k, v = l.split('=')
-            d[k.strip()] = v.strip()
-    return d
-
-
 def pwgen(length=None):
     """Generate a random pasword."""
     if length is None:
@@ -674,25 +662,6 @@
     return hwaddr
 
 
-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)
-
-
 @contextmanager
 def chdir(directory):
     """Change the current working directory to a different directory for a code

=== added directory 'charmhelpers/core/host_factory'
=== added file 'charmhelpers/core/host_factory/__init__.py'
=== added file 'charmhelpers/core/host_factory/centos.py'
--- charmhelpers/core/host_factory/centos.py	1970-01-01 00:00:00 +0000
+++ charmhelpers/core/host_factory/centos.py	2016-08-12 07:09:49 +0000
@@ -0,0 +1,56 @@
+import subprocess
+import yum
+import os
+
+
+def service_available(service_name):
+    # """Determine whether a system service is available."""
+    if os.path.isdir('/run/systemd/system'):
+        cmd = ['systemctl', 'is-enabled', service_name]
+    else:
+        cmd = ['service', service_name, 'is-enabled']
+    return subprocess.call(cmd) == 0
+
+
+def add_new_group(group_name, system_group=False, gid=None):
+    cmd = ['groupadd']
+    if gid:
+        cmd.extend(['--gid', str(gid)])
+    if system_group:
+        cmd.append('-r')
+    cmd.append(group_name)
+    subprocess.check_call(cmd)
+
+
+def lsb_release():
+    """Return /etc/os-release in a dict."""
+    d = {}
+    with open('/etc/os-release', 'r') as lsb:
+        for l in lsb:
+            s = l.split('=')
+            if len(s) != 2:
+                continue
+            d[s[0].strip()] = s[1].strip()
+    return d
+
+
+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 YumBase function if the pkgcache argument
+    is None.
+    """
+    if not pkgcache:
+        y = yum.YumBase()
+        packages = y.doPackageLists()
+        pkgcache = {i.Name: i.version for i in packages['installed']}
+    pkg = pkgcache[package]
+    if pkg > revno:
+        return 1
+    if pkg < revno:
+        return -1
+    return 0

=== added file 'charmhelpers/core/host_factory/ubuntu.py'
--- charmhelpers/core/host_factory/ubuntu.py	1970-01-01 00:00:00 +0000
+++ charmhelpers/core/host_factory/ubuntu.py	2016-08-12 07:09:49 +0000
@@ -0,0 +1,56 @@
+import subprocess
+
+
+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 b'unrecognized service' not in e.output
+    else:
+        return True
+
+
+def add_new_group(group_name, system_group=False, gid=None):
+    cmd = ['addgroup']
+    if gid:
+        cmd.extend(['--gid', str(gid)])
+    if system_group:
+        cmd.append('--system')
+    else:
+        cmd.extend([
+            '--group',
+        ])
+    cmd.append(group_name)
+    subprocess.check_call(cmd)
+
+
+def lsb_release():
+    """Return /etc/lsb-release in a dict"""
+    d = {}
+    with open('/etc/lsb-release', 'r') as lsb:
+        for l in lsb:
+            k, v = l.split('=')
+            d[k.strip()] = v.strip()
+    return d
+
+
+def 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)

=== modified file 'charmhelpers/core/kernel.py'
--- charmhelpers/core/kernel.py	2016-07-06 14:41:05 +0000
+++ charmhelpers/core/kernel.py	2016-08-12 07:09:49 +0000
@@ -15,15 +15,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__author__ = "Jorge Niedbalski <[e-mail]>"
+import re
+import subprocess
 
+from charmhelpers.osplatform import get_platform
 from charmhelpers.core.hookenv import (
     log,
     INFO
 )
 
-from subprocess import check_call, check_output
-import re
+__platform__ = get_platform()
+if __platform__ == "ubuntu":
+    from charmhelpers.core.kernel_factory.ubuntu import (
+        persistent_modprobe,
+        update_initramfs,
+    )  # flake8: noqa -- ignore F401 for this import
+elif __platform__ == "centos":
+    from charmhelpers.core.kernel_factory.centos import (
+        persistent_modprobe,
+        update_initramfs,
+    )  # flake8: noqa -- ignore F401 for this import
+
+__author__ = "Jorge Niedbalski <[e-mail]>"
 
 
 def modprobe(module, persist=True):
@@ -32,11 +45,9 @@
 
     log('Loading kernel module %s' % module, level=INFO)
 
-    check_call(cmd)
+    subprocess.check_call(cmd)
     if persist:
-        with open('/etc/modules', 'r+') as modules:
-            if module not in modules.read():
-                modules.write(module)
+        persistent_modprobe(module)
 
 
 def rmmod(module, force=False):
@@ -46,21 +57,16 @@
         cmd.append('-f')
     cmd.append(module)
     log('Removing kernel module %s' % module, level=INFO)
-    return check_call(cmd)
+    return subprocess.check_call(cmd)
 
 
 def lsmod():
     """Shows what kernel modules are currently loaded"""
-    return check_output(['lsmod'],
-                        universal_newlines=True)
+    return subprocess.check_output(['lsmod'],
+                                   universal_newlines=True)
 
 
 def is_module_loaded(module):
     """Checks if a kernel module is already loaded"""
     matches = re.findall('^%s[ ]+' % module, lsmod(), re.M)
     return len(matches) > 0
-
-
-def update_initramfs(version='all'):
-    """Updates an initramfs image"""
-    return check_call(["update-initramfs", "-k", version, "-u"])

=== added directory 'charmhelpers/core/kernel_factory'
=== added file 'charmhelpers/core/kernel_factory/__init__.py'
=== added file 'charmhelpers/core/kernel_factory/centos.py'
--- charmhelpers/core/kernel_factory/centos.py	1970-01-01 00:00:00 +0000
+++ charmhelpers/core/kernel_factory/centos.py	2016-08-12 07:09:49 +0000
@@ -0,0 +1,17 @@
+import subprocess
+import os
+
+
+def persistent_modprobe(module):
+    """Load a kernel module and configure for auto-load on reboot."""
+    if not os.path.exists('/etc/rc.modules'):
+        open('/etc/rc.modules', 'a')
+        os.chmod('/etc/rc.modules', 111)
+    with open('/etc/rc.modules', 'r+') as modules:
+        if module not in modules.read():
+            modules.write('modprobe %s\n' % module)
+
+
+def update_initramfs(version='all'):
+    """Updates an initramfs image."""
+    return subprocess.check_call(["dracut", "-f", version])

=== added file 'charmhelpers/core/kernel_factory/ubuntu.py'
--- charmhelpers/core/kernel_factory/ubuntu.py	1970-01-01 00:00:00 +0000
+++ charmhelpers/core/kernel_factory/ubuntu.py	2016-08-12 07:09:49 +0000
@@ -0,0 +1,13 @@
+import subprocess
+
+
+def persistent_modprobe(module):
+    """Load a kernel module and configure for auto-load on reboot."""
+    with open('/etc/modules', 'r+') as modules:
+        if module not in modules.read():
+            modules.write(module)
+
+
+def update_initramfs(version='all'):
+    """Updates an initramfs image."""
+    return subprocess.check_call(["update-initramfs", "-k", version, "-u"])

=== modified file 'charmhelpers/fetch/__init__.py'
--- charmhelpers/fetch/__init__.py	2016-07-14 10:22:50 +0000
+++ charmhelpers/fetch/__init__.py	2016-08-12 07:09:49 +0000
@@ -13,18 +13,12 @@
 # limitations under the License.
 
 import importlib
-from tempfile import NamedTemporaryFile
-import time
+from charmhelpers.osplatform import get_platform
 from yaml import safe_load
-from charmhelpers.core.host import (
-    lsb_release
-)
-import subprocess
 from charmhelpers.core.hookenv import (
     config,
     log,
 )
-import os
 
 import six
 if six.PY3:
@@ -33,87 +27,6 @@
     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',
-    # 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',
-    # Newton
-    'newton': 'xenial-updates/newton',
-    'xenial-newton': 'xenial-updates/newton',
-    'xenial-newton/updates': 'xenial-updates/newton',
-    'xenial-updates/newton': 'xenial-updates/newton',
-    'newton/proposed': 'xenial-proposed/newton',
-    'xenial-newton/proposed': 'xenial-proposed/newton',
-    'xenial-proposed/newton': 'xenial-proposed/newton',
-}
-
 # The order of this list is very important. Handlers should be listed in from
 # least- to most-specific URL matching.
 FETCH_HANDLERS = (
@@ -122,10 +35,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
@@ -163,180 +72,37 @@
         return urlunparse(parts)
 
 
-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, progress=None):
-    """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(progress)
-
-
-def apt_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):
-    """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):
-    """Update local apt cache"""
-    cmd = ['apt-get', 'update']
-    _run_apt_command(cmd, fatal)
-
-
-def apt_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:'):
-        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])
+__platform__ = get_platform()
+module = "charmhelpers.fetch.%s" % __platform__
+fetch = importlib.import_module(module)
+
+filter_installed_packages = fetch.filter_installed_packages
+install = fetch.install
+upgrade = fetch.upgrade
+update = fetch.update
+purge = fetch.purge
+add_source = fetch.add_source
+
+if __platform__ == "ubuntu":
+    apt_cache = fetch.apt_cache
+    apt_install = fetch.install
+    apt_update = fetch.update
+    apt_upgrade = fetch.upgrade
+    apt_purge = fetch.purge
+    apt_mark = fetch.apt_mark
+    apt_hold = fetch.apt_hold
+    apt_unhold = fetch.apt_unhold
+elif __platform__ == "centos":
+    yum_search = fetch.yum_search
 
 
 def configure_sources(update=False,
                       sources_var='install_sources',
                       keys_var='install_keys'):
-    """
-    Configure multiple sources from charm configuration.
+    """Configure multiple sources from charm configuration.
 
     The lists are encoded as yaml fragments in the configuration.
-    The frament needs to be included as a string. Sources and their
+    The fragment needs to be included as a string. Sources and their
     corresponding keys are of the types supported by add_source().
 
     Example config:
@@ -368,12 +134,11 @@
         for source, key in zip(sources, keys):
             add_source(source, key)
     if update:
-        apt_update(fatal=True)
+        fetch.update(fatal=True)
 
 
 def install_remote(source, *args, **kwargs):
-    """
-    Install a file tree from a remote source
+    """Install a file tree from a remote source.
 
     The specified source should be a url of the form:
         scheme://[host]/path[#[option=value][&...]]
@@ -406,6 +171,7 @@
 
 
 def install_from_config(config_var_name):
+    """Install a file from config."""
     charm_config = config()
     source = charm_config[config_var_name]
     return install_remote(source)
@@ -428,40 +194,3 @@
             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)

=== modified file 'charmhelpers/fetch/bzrurl.py'
--- charmhelpers/fetch/bzrurl.py	2016-07-06 14:41:05 +0000
+++ charmhelpers/fetch/bzrurl.py	2016-08-12 07:09:49 +0000
@@ -18,19 +18,20 @@
     BaseFetchHandler,
     UnhandledSource,
     filter_installed_packages,
-    apt_install,
+    install,
 )
 from charmhelpers.core.host import mkdir
 
 
 if filter_installed_packages(['bzr']) != []:
-    apt_install(['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"""
+    """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', ''):

=== added file 'charmhelpers/fetch/centos.py'
--- charmhelpers/fetch/centos.py	1970-01-01 00:00:00 +0000
+++ charmhelpers/fetch/centos.py	2016-08-12 07:09:49 +0000
@@ -0,0 +1,171 @@
+# Copyright 2014-2015 Canonical Limited.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+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):
+    """Return a list of packages that require installation."""
+    yb = yum.YumBase()
+    package_list = yb.doPackageLists()
+    temp_cache = {p.base_package_name: 1 for p in package_list['installed']}
+
+    _pkgs = [p for p in packages if not temp_cache.get(p, False)]
+    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 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 update(fatal=False):
+    """Update local yum cache."""
+    cmd = ['yum', '--assumeyes', 'update']
+    log("Update with fatal: {}".format(fatal))
+    _run_yum_command(cmd, fatal)
+
+
+def purge(packages, fatal=False):
+    """Purge one or more packages."""
+    cmd = ['yum', '--assumeyes', 'remove']
+    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):
+        output[package] = package in result
+    return output
+
+
+def add_source(source, key=None):
+    """Add a package source to this system.
+
+    @param source: a URL with a rpm package
+
+    @param key: A key to be added to the system's 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.
+    """
+    if source is None:
+        log('Source is not present. Skipping')
+        return
+
+    if source.startswith('http'):
+        directory = '/etc/yum.repos.d/'
+        for filename in os.listdir(directory):
+            with open(directory + filename, 'r') as rpm_file:
+                if source in rpm_file.read():
+                    break
+        else:
+            log("Add source: {!r}".format(source))
+            # 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.
+
+    Checks the output and retry 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 'charmhelpers/fetch/giturl.py'
--- charmhelpers/fetch/giturl.py	2016-07-06 14:41:05 +0000
+++ charmhelpers/fetch/giturl.py	2016-08-12 07:09:49 +0000
@@ -18,17 +18,18 @@
     BaseFetchHandler,
     UnhandledSource,
     filter_installed_packages,
-    apt_install,
+    install,
 )
 
 if filter_installed_packages(['git']) != []:
-    apt_install(['git'])
+    install(['git'])
     if filter_installed_packages(['git']) != []:
         raise NotImplementedError('Unable to install git')
 
 
 class GitUrlFetchHandler(BaseFetchHandler):
-    """Handler for git branches via generic and github URLs"""
+    """Handler for git branches via generic and github URLs."""
+
     def can_handle(self, source):
         url_parts = self.parse_url(source)
         # TODO (mattyw) no support for ssh git@ yet

=== added file 'charmhelpers/fetch/ubuntu.py'
--- charmhelpers/fetch/ubuntu.py	1970-01-01 00:00:00 +0000
+++ charmhelpers/fetch/ubuntu.py	2016-08-12 07:09:49 +0000
@@ -0,0 +1,313 @@
+# Copyright 2014-2015 Canonical Limited.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+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',
+    # Newton
+    'newton': 'xenial-updates/newton',
+    'xenial-newton': 'xenial-updates/newton',
+    'xenial-newton/updates': 'xenial-updates/newton',
+    'xenial-updates/newton': 'xenial-updates/newton',
+    'newton/proposed': 'xenial-proposed/newton',
+    'xenial-newton/proposed': 'xenial-proposed/newton',
+    'xenial-proposed/newton': 'xenial-proposed/newton',
+}
+
+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):
+    """Return 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, progress=None):
+    """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(progress)
+
+
+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.
+
+    Checks the output and retries 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)

=== added file 'charmhelpers/osplatform.py'
--- charmhelpers/osplatform.py	1970-01-01 00:00:00 +0000
+++ charmhelpers/osplatform.py	2016-08-12 07:09:49 +0000
@@ -0,0 +1,19 @@
+import platform
+
+
+def get_platform():
+    """Return the current OS platform.
+
+    For example: if current os platform is Ubuntu then a string "ubuntu"
+    will be returned (which is the name of the module).
+    This string is used to decide which platform module should be imported.
+    """
+    tuple_platform = platform.linux_distribution()
+    current_platform = tuple_platform[0]
+    if "Ubuntu" in current_platform:
+        return "ubuntu"
+    elif "CentOS" in current_platform:
+        return "centos"
+    else:
+        raise RuntimeError("This module is not supported on {}."
+                           .format(current_platform))

=== modified file 'tests/__init__.py'
--- tests/__init__.py	2013-05-11 19:55:58 +0000
+++ tests/__init__.py	2016-08-12 07:09:49 +0000
@@ -0,0 +1,4 @@
+import sys
+import mock
+
+sys.modules['yum'] = mock.MagicMock()

=== modified file 'tests/core/test_host.py'
--- tests/core/test_host.py	2016-07-08 12:56:50 +0000
+++ tests/core/test_host.py	2016-08-12 07:09:49 +0000
@@ -6,7 +6,9 @@
 from textwrap import dedent
 
 import apt_pkg
+import imp
 
+from charmhelpers import osplatform
 from mock import patch, call
 from testtools import TestCase
 from tests.helpers import patch_open
@@ -31,6 +33,22 @@
 DISTRIB_DESCRIPTION="Ubuntu Saucy Salamander (development branch)"
 '''
 
+OS_RELEASE = '''NAME="CentOS Linux"
+ANSI_COLOR="0;31"
+ID_LIKE="rhel fedora"
+VERSION_ID="7"
+BUG_REPORT_URL="https://bugs.centos.org/"
+CENTOS_MANTISBT_PROJECT="CentOS-7"
+PRETTY_NAME="CentOS Linux 7 (Core)"
+VERSION="7 (Core)"
+REDHAT_SUPPORT_PRODUCT_VERSION="7"
+CENTOS_MANTISBT_PROJECT_VERSION="7"
+REDHAT_SUPPORT_PRODUCT="centos"
+HOME_URL="https://www.centos.org/"
+CPE_NAME="cpe:/o:centos:centos:7"
+ID="centos"
+'''
+
 IP_LINE_ETH0 = b"""
 2: eth0: <BROADCAST,MULTICAST,SLAVE,UP,LOWER_UP> mtu 1500 qdisc mq master bond0 state UP qlen 1000
     link/ether e4:11:5b:ab:a7:3c brd ff:ff:ff:ff:ff:ff
@@ -288,8 +306,8 @@
     @patch.object(host, 'init_is_systemd')
     @patch('subprocess.check_output')
     @patch.object(host, 'service')
-    def test_resumes_a_running_upstart_service(self, service, check_output, systemd,
-                                               service_running):
+    def test_resumes_a_running_upstart_service(self, service, check_output,
+                                               systemd, service_running):
         """When the service is already running, service start isn't called."""
         service_name = 'foo-service'
         service.side_effect = [True]
@@ -312,8 +330,8 @@
     @patch.object(host, 'init_is_systemd')
     @patch('subprocess.check_output')
     @patch.object(host, 'service')
-    def test_resumes_a_stopped_upstart_service(self, service, check_output, systemd,
-                                               service_running):
+    def test_resumes_a_stopped_upstart_service(self, service, check_output,
+                                               systemd, service_running):
         """When the service is stopped, service start is called."""
         check_output.return_value = b'foo-service stop/waiting'
         service_name = 'foo-service'
@@ -524,7 +542,8 @@
     @patch('pwd.getpwnam')
     @patch('subprocess.check_call')
     @patch.object(host, 'log')
-    def test_adds_a_user_if_it_doesnt_exist(self, log, check_call, getpwnam, getgrnam):
+    def test_adds_a_user_if_it_doesnt_exist(self, log, check_call,
+                                            getpwnam, getgrnam):
         username = 'johndoe'
         password = 'eodnhoj'
         shell = '/bin/bash'
@@ -734,49 +753,102 @@
             group
         ])
 
+    @patch.object(osplatform, 'get_platform')
     @patch('grp.getgrnam')
     @patch('subprocess.check_call')
-    @patch.object(host, 'log')
-    def test_add_a_group_if_it_doesnt_exist(self, log, check_call, getgrnam):
+    def test_add_a_group_if_it_doesnt_exist_ubuntu(self, check_call,
+                                                   getgrnam, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(host)
+
         group_name = 'testgroup'
         existing_group_grnam = KeyError('group not found')
         new_group_grnam = 'some group grnam'
 
         getgrnam.side_effect = [existing_group_grnam, new_group_grnam]
-
-        result = host.add_group(group_name)
+        with patch("charmhelpers.core.host.log"):
+            result = host.add_group(group_name)
 
         self.assertEqual(result, new_group_grnam)
         check_call.assert_called_with(['addgroup', '--group', group_name])
         getgrnam.assert_called_with(group_name)
 
-    @patch('grp.getgrnam')
-    @patch('subprocess.check_call')
-    @patch.object(host, 'log')
-    def test_doesnt_add_group_if_it_already_exists(self, log, check_call,
-                                                   getgrnam):
-        group_name = 'testgroup'
-        existing_group_grnam = 'some group grnam'
-
-        getgrnam.return_value = existing_group_grnam
-
-        result = host.add_group(group_name)
-
-        self.assertEqual(result, existing_group_grnam)
-        self.assertFalse(check_call.called)
-        getgrnam.assert_called_with(group_name)
-
-    @patch('grp.getgrnam')
-    @patch('subprocess.check_call')
-    @patch.object(host, 'log')
-    def test_add_a_system_group(self, log, check_call, getgrnam):
-        group_name = 'testgroup'
-        existing_group_grnam = KeyError('group not found')
-        new_group_grnam = 'some group grnam'
-
-        getgrnam.side_effect = [existing_group_grnam, new_group_grnam]
-
-        result = host.add_group(group_name, system_group=True)
+    @patch.object(osplatform, 'get_platform')
+    @patch('grp.getgrnam')
+    @patch('subprocess.check_call')
+    def test_add_a_group_if_it_doesnt_exist_centos(self, check_call,
+                                                   getgrnam, platform):
+        platform.return_value = 'centos'
+        imp.reload(host)
+
+        group_name = 'testgroup'
+        existing_group_grnam = KeyError('group not found')
+        new_group_grnam = 'some group grnam'
+
+        getgrnam.side_effect = [existing_group_grnam, new_group_grnam]
+
+        with patch("charmhelpers.core.host.log"):
+            result = host.add_group(group_name)
+
+        self.assertEqual(result, new_group_grnam)
+        check_call.assert_called_with(['groupadd', group_name])
+        getgrnam.assert_called_with(group_name)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('grp.getgrnam')
+    @patch('subprocess.check_call')
+    def test_doesnt_add_group_if_it_already_exists_ubuntu(self, check_call,
+                                                          getgrnam, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(host)
+
+        group_name = 'testgroup'
+        existing_group_grnam = 'some group grnam'
+
+        getgrnam.return_value = existing_group_grnam
+
+        with patch("charmhelpers.core.host.log"):
+            result = host.add_group(group_name)
+
+        self.assertEqual(result, existing_group_grnam)
+        self.assertFalse(check_call.called)
+        getgrnam.assert_called_with(group_name)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('grp.getgrnam')
+    @patch('subprocess.check_call')
+    def test_doesnt_add_group_if_it_already_exists_centos(self, check_call,
+                                                          getgrnam, platform):
+        platform.return_value = 'centos'
+        imp.reload(host)
+
+        group_name = 'testgroup'
+        existing_group_grnam = 'some group grnam'
+
+        getgrnam.return_value = existing_group_grnam
+
+        with patch("charmhelpers.core.host.log"):
+            result = host.add_group(group_name)
+
+        self.assertEqual(result, existing_group_grnam)
+        self.assertFalse(check_call.called)
+        getgrnam.assert_called_with(group_name)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('grp.getgrnam')
+    @patch('subprocess.check_call')
+    def test_add_a_system_group_ubuntu(self, check_call, getgrnam, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(host)
+
+        group_name = 'testgroup'
+        existing_group_grnam = KeyError('group not found')
+        new_group_grnam = 'some group grnam'
+
+        getgrnam.side_effect = [existing_group_grnam, new_group_grnam]
+
+        with patch("charmhelpers.core.host.log"):
+            result = host.add_group(group_name, system_group=True)
 
         self.assertEqual(result, new_group_grnam)
         check_call.assert_called_with([
@@ -786,6 +858,30 @@
         ])
         getgrnam.assert_called_with(group_name)
 
+    @patch.object(osplatform, 'get_platform')
+    @patch('grp.getgrnam')
+    @patch('subprocess.check_call')
+    def test_add_a_system_group_centos(self, check_call, getgrnam, platform):
+        platform.return_value = 'centos'
+        imp.reload(host)
+
+        group_name = 'testgroup'
+        existing_group_grnam = KeyError('group not found')
+        new_group_grnam = 'some group grnam'
+
+        getgrnam.side_effect = [existing_group_grnam, new_group_grnam]
+
+        with patch("charmhelpers.core.host.log"):
+            result = host.add_group(group_name, system_group=True)
+
+        self.assertEqual(result, new_group_grnam)
+        check_call.assert_called_with([
+            'groupadd',
+            '-r',
+            group_name
+        ])
+        getgrnam.assert_called_with(group_name)
+
     @patch('subprocess.check_output')
     @patch.object(host, 'log')
     def test_rsyncs_a_path(self, log, check_output):
@@ -1133,7 +1229,8 @@
     @patch.object(host, 'file_hash')
     def test_check_hash(self, file_hash):
         file_hash.return_value = 'good-hash'
-        self.assertRaises(host.ChecksumError, host.check_hash, 'file', 'bad-hash')
+        self.assertRaises(host.ChecksumError, host.check_hash,
+                          'file', 'bad-hash')
         host.check_hash('file', 'good-hash', 'sha256')
         self.assertEqual(file_hash.call_args_list, [
             call('file', 'md5'),
@@ -1219,7 +1316,8 @@
     @patch.object(host, 'service')
     @patch('os.path.exists')
     @patch('glob.iglob')
-    def test_multiservice_restart_on_change_in_order(self, iglob, exists, service):
+    def test_multiservice_restart_on_change_in_order(self, iglob, exists,
+                                                     service):
         file_name_one = '/etc/cinder/cinder.conf'
         file_name_two = '/etc/haproxy/haproxy.conf'
         restart_map = OrderedDict([
@@ -1377,7 +1475,11 @@
         self.assertEquals([call('restart', 'haproxy')], service.call_args_list)
         self.assertEquals([call('some-api')], service_reload.call_args_list)
 
-    def test_lsb_release(self):
+    @patch.object(osplatform, 'get_platform')
+    def test_lsb_release_ubuntu(self, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(host)
+
         result = {
             "DISTRIB_ID": "Ubuntu",
             "DISTRIB_RELEASE": "13.10",
@@ -1390,6 +1492,32 @@
             for key in result:
                 self.assertEqual(result[key], lsb_release[key])
 
+    @patch.object(osplatform, 'get_platform')
+    def test_lsb_release_centos(self, platform):
+        platform.return_value = 'centos'
+        imp.reload(host)
+
+        result = {
+            'NAME': '"CentOS Linux"',
+            'ANSI_COLOR': '"0;31"',
+            'ID_LIKE': '"rhel fedora"',
+            'VERSION_ID': '"7"',
+            'BUG_REPORT_URL': '"https://bugs.centos.org/"',
+            'CENTOS_MANTISBT_PROJECT': '"CentOS-7"',
+            'PRETTY_NAME': '"CentOS Linux 7 (Core)"',
+            'VERSION': '"7 (Core)"',
+            'REDHAT_SUPPORT_PRODUCT_VERSION': '"7"',
+            'CENTOS_MANTISBT_PROJECT_VERSION': '"7"',
+            'REDHAT_SUPPORT_PRODUCT': '"centos"',
+            'HOME_URL': '"https://www.centos.org/"',
+            'CPE_NAME': '"cpe:/o:centos:centos:7"',
+            'ID': '"centos"'
+        }
+        with mocked_open('/etc/os-release', OS_RELEASE):
+            lsb_release = host.lsb_release()
+            for key in result:
+                self.assertEqual(result[key], lsb_release[key])
+
     def test_pwgen(self):
         pw = host.pwgen()
         self.assert_(len(pw) >= 35, 'Password is too short')
@@ -1410,8 +1538,8 @@
 
         def fake_realpath(soft):
             if soft.endswith('/eth0'):
-                hard = \
-                    '/sys/devices/pci0000:00/0000:00:1c.4/0000:02:00.1/net/eth0'
+                hard = ('/sys/devices/pci0000:00/0000:00:1c.4'
+                        '/0000:02:00.1/net/eth0')
             else:
                 hard = '/sys/devices/virtual/net/veth0'
 
@@ -1429,8 +1557,8 @@
 
         def fake_realpath(soft):
             if soft.endswith('/eth0'):
-                return \
-                    '/sys/devices/pci0000:00/0000:00:1c.4/0000:02:00.1/net/eth0'
+                return ('/sys/devices/pci0000:00/0000:00:1c.4'
+                        '/0000:02:00.1/net/eth0')
             elif soft.endswith('/br0'):
                 return '/sys/devices/virtual/net/br0'
             elif soft.endswith('/master'):
@@ -1498,8 +1626,12 @@
         hwaddr = host.get_nic_hwaddr(nic)
         self.assertEqual(hwaddr, 'e4:11:5b:ab:a7:3c')
 
+    @patch.object(osplatform, 'get_platform')
     @patch.object(apt_pkg, 'Cache')
-    def test_cmp_pkgrevno_revnos(self, pkg_cache):
+    def test_cmp_pkgrevno_revnos_ubuntu(self, pkg_cache, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(host)
+
         class MockPackage:
             class MockPackageRevno:
                 def __init__(self, ver_str):
@@ -1516,6 +1648,30 @@
         self.assertEqual(host.cmp_pkgrevno('python', '2.4'), 0)
         self.assertEqual(host.cmp_pkgrevno('python', '2.5'), -1)
 
+    @patch.object(osplatform, 'get_platform')
+    def test_cmp_pkgrevno_revnos_centos(self, platform):
+        platform.return_value = 'centos'
+        imp.reload(host)
+
+        class MockPackage:
+            def __init__(self, name, version):
+                self.Name = name
+                self.version = version
+
+        yum_dict = {
+            'installed': {
+                MockPackage('python', '2.4')
+            }
+        }
+
+        import yum
+        yum.YumBase.return_value.doPackageLists.return_value = (
+            yum_dict)
+
+        self.assertEqual(host.cmp_pkgrevno('python', '2.3'), 1)
+        self.assertEqual(host.cmp_pkgrevno('python', '2.4'), 0)
+        self.assertEqual(host.cmp_pkgrevno('python', '2.5'), -1)
+
     def test_get_total_ram(self):
         raw = dedent('''\
                      MemFree:          183868 kB

=== modified file 'tests/core/test_kernel.py'
--- tests/core/test_kernel.py	2015-10-26 10:17:10 +0000
+++ tests/core/test_kernel.py	2016-08-12 07:09:49 +0000
@@ -1,67 +1,113 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import unittest
+import imp
+
+from charmhelpers import osplatform
 from mock import patch
-import unittest
-
 from tests.helpers import patch_open
 from charmhelpers.core import kernel
 
-TO_PATCH = [
-    'log',
-    'check_call',
-    'check_output',
-]
-
 
 class TestKernel(unittest.TestCase):
 
-    def setUp(self):
-        for m in TO_PATCH:
-            setattr(self, m, self._patch(m))
-
-    def _patch(self, method):
-        _m = patch('charmhelpers.core.kernel.' + method)
-        mock = _m.start()
-        self.addCleanup(_m.stop)
-        return mock
-
-    def test_modprobe_persistent(self):
+    @patch('subprocess.check_call')
+    @patch.object(osplatform, 'get_platform')
+    def test_modprobe_persistent_ubuntu(self, platform, check_call):
+        platform.return_value = 'ubuntu'
+        imp.reload(kernel)
+
         with patch_open() as (_open, _file):
             _file.read.return_value = 'anothermod\n'
-            kernel.modprobe('mymod')
+            with patch("charmhelpers.core.kernel.log"):
+                kernel.modprobe('mymod')
             _open.assert_called_with('/etc/modules', 'r+')
             _file.read.assert_called_with()
             _file.write.assert_called_with('mymod')
-        self.check_call.assert_called_with(['modprobe', 'mymod'])
-
-    def test_modprobe_not_persistent(self):
-        with patch_open() as (_open, _file):
-            _file.read.return_value = 'anothermod\n'
-            kernel.modprobe('mymod', persist=False)
-            assert not _open.called
-        self.check_call.assert_called_with(['modprobe', 'mymod'])
-
-    def test_rmmod_not_forced(self):
+        check_call.assert_called_with(['modprobe', 'mymod'])
+
+    @patch('os.chmod')
+    @patch('subprocess.check_call')
+    @patch.object(osplatform, 'get_platform')
+    def test_modprobe_persistent_centos(self, platform, check_call, os):
+        platform.return_value = 'centos'
+        imp.reload(kernel)
+
+        with patch_open() as (_open, _file):
+            _file.read.return_value = 'anothermod\n'
+            with patch("charmhelpers.core.kernel.log"):
+                kernel.modprobe('mymod')
+            _open.assert_called_with('/etc/rc.modules', 'r+')
+            os.assert_called_with('/etc/rc.modules', 111)
+            _file.read.assert_called_with()
+            _file.write.assert_called_with('modprobe mymod\n')
+        check_call.assert_called_with(['modprobe', 'mymod'])
+
+    @patch('subprocess.check_call')
+    @patch.object(osplatform, 'get_platform')
+    def test_modprobe_not_persistent_ubuntu(self, platform, check_call):
+        platform.return_value = 'ubuntu'
+        imp.reload(kernel)
+
+        with patch_open() as (_open, _file):
+            _file.read.return_value = 'anothermod\n'
+            with patch("charmhelpers.core.kernel.log"):
+                kernel.modprobe('mymod', persist=False)
+            assert not _open.called
+        check_call.assert_called_with(['modprobe', 'mymod'])
+
+    @patch('subprocess.check_call')
+    @patch.object(osplatform, 'get_platform')
+    def test_modprobe_not_persistent_centos(self, platform, check_call):
+        platform.return_value = 'centos'
+        imp.reload(kernel)
+
+        with patch_open() as (_open, _file):
+            _file.read.return_value = 'anothermod\n'
+            with patch("charmhelpers.core.kernel.log"):
+                kernel.modprobe('mymod', persist=False)
+            assert not _open.called
+        check_call.assert_called_with(['modprobe', 'mymod'])
+
+    @patch.object(kernel, 'log')
+    @patch('subprocess.check_call')
+    def test_rmmod_not_forced(self, check_call, log):
         kernel.rmmod('mymod')
-        self.check_call.assert_called_with(['rmmod', 'mymod'])
+        check_call.assert_called_with(['rmmod', 'mymod'])
 
-    def test_rmmod_forced(self):
+    @patch.object(kernel, 'log')
+    @patch('subprocess.check_call')
+    def test_rmmod_forced(self, check_call, log):
         kernel.rmmod('mymod', force=True)
-        self.check_call.assert_called_with(['rmmod', '-f', 'mymod'])
+        check_call.assert_called_with(['rmmod', '-f', 'mymod'])
 
-    def test_lsmod(self):
+    @patch.object(kernel, 'log')
+    @patch('subprocess.check_output')
+    def test_lsmod(self, check_output, log):
         kernel.lsmod()
-        self.check_output.assert_called_with(['lsmod'],
-                                             universal_newlines=True)
+        check_output.assert_called_with(['lsmod'],
+                                        universal_newlines=True)
 
     @patch('charmhelpers.core.kernel.lsmod')
     def test_is_module_loaded(self, lsmod):
         lsmod.return_value = "ip6_tables 28672  1 ip6table_filter"
-        self.assertTrue(kernel.is_module_loaded(
-            "ip6_tables"))
-
-    def test_update_initramfs(self):
-        kernel.update_initramfs()
-        self.check_call.assert_called_with([
-            "update-initramfs", "-k", "all", "-u"])
+        self.assertTrue(kernel.is_module_loaded("ip6_tables"))
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    def test_update_initramfs_ubuntu(self, check_call, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(kernel)
+
+        kernel.update_initramfs()
+        check_call.assert_called_with(["update-initramfs", "-k", "all", "-u"])
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    def test_update_initramfs_centos(self, check_call, platform):
+        platform.return_value = 'centos'
+        imp.reload(kernel)
+
+        kernel.update_initramfs()
+        check_call.assert_called_with(['dracut', '-f', 'all'])

=== modified file 'tests/fetch/test_archiveurl.py'
--- tests/fetch/test_archiveurl.py	2015-12-10 05:23:53 +0000
+++ tests/fetch/test_archiveurl.py	2016-08-12 07:09:49 +0000
@@ -65,7 +65,8 @@
             _urlopen.return_value = response
 
             _open = mock_open()
-            with patch('charmhelpers.fetch.archiveurl.open', _open, create=True):
+            with patch('charmhelpers.fetch.archiveurl.open',
+                       _open, create=True):
                 self.fh.download(url, "foo")
 
             response.read.assert_called_with()

=== modified file 'tests/fetch/test_bzrurl.py'
--- tests/fetch/test_bzrurl.py	2016-06-16 03:28:45 +0000
+++ tests/fetch/test_bzrurl.py	2016-08-12 07:09:49 +0000
@@ -74,7 +74,8 @@
 
         for url in self.invalid_urls:
             with patch.dict('os.environ', {'CHARM_DIR': 'foo'}):
-                self.assertRaises(UnhandledSource, self.fh.branch, url, dest_path)
+                self.assertRaises(UnhandledSource, self.fh.branch,
+                                  url, dest_path)
 
     @patch('charmhelpers.fetch.bzrurl.check_call')
     def test_branch_revno(self, check_call):

=== modified file 'tests/fetch/test_fetch.py'
--- tests/fetch/test_fetch.py	2016-07-14 10:22:50 +0000
+++ tests/fetch/test_fetch.py	2016-08-12 07:09:49 +0000
@@ -1,5 +1,11 @@
 import subprocess
+import six
+import os
+import yaml
+import imp
+import tempfile
 
+from charmhelpers import osplatform
 from tests.helpers import patch_open
 from testtools import TestCase
 from mock import (
@@ -9,10 +15,6 @@
     sentinel,
 )
 from charmhelpers import fetch
-import os
-import yaml
-
-import six
 from six.moves import StringIO
 if six.PY3:
     from urllib.parse import urlparse
@@ -58,156 +60,378 @@
 
 class FetchTest(TestCase):
 
-    @patch('apt_pkg.Cache')
-    def test_filter_packages_missing(self, cache):
-        cache.side_effect = fake_apt_cache
-        result = fetch.filter_installed_packages(['vim', 'emacs'])
-        self.assertEquals(result, ['emacs'])
-
-    @patch('apt_pkg.Cache')
-    def test_filter_packages_none_missing(self, cache):
-        cache.side_effect = fake_apt_cache
-        result = fetch.filter_installed_packages(['vim'])
-        self.assertEquals(result, [])
-
-    @patch.object(fetch, 'log')
-    @patch('apt_pkg.Cache')
-    def test_filter_packages_not_available(self, cache, log):
+    @patch("charmhelpers.fetch.ubuntu.log")
+    @patch.object(osplatform, 'get_platform')
+    @patch('apt_pkg.Cache')
+    def test_filter_packages_missing_ubuntu(self, cache, platform, log):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
+        cache.side_effect = fake_apt_cache
+        result = fetch.filter_installed_packages(['vim', 'emacs'])
+        self.assertEquals(result, ['emacs'])
+
+    @patch("charmhelpers.fetch.centos.log")
+    @patch('yum.YumBase.doPackageLists')
+    @patch.object(osplatform, 'get_platform')
+    def test_filter_packages_missing_centos(self, platform, yumBase, log):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        class MockPackage:
+            def __init__(self, name):
+                self.base_package_name = name
+
+        yum_dict = {
+            'installed': {
+                MockPackage('vim')
+            },
+            'available': {
+                MockPackage('vim')
+            }
+        }
+        import yum
+        yum.YumBase.return_value.doPackageLists.return_value = yum_dict
+        result = fetch.filter_installed_packages(['vim', 'emacs'])
+        self.assertEquals(result, ['emacs'])
+
+    @patch("charmhelpers.fetch.ubuntu.log")
+    @patch.object(osplatform, 'get_platform')
+    @patch('apt_pkg.Cache')
+    def test_filter_packages_none_missing_ubuntu(self, cache, platform, log):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
+        cache.side_effect = fake_apt_cache
+        result = fetch.filter_installed_packages(['vim'])
+        self.assertEquals(result, [])
+
+    @patch("charmhelpers.fetch.centos.log")
+    @patch.object(osplatform, 'get_platform')
+    def test_filter_packages_none_missing_centos(self, platform, log):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        class MockPackage:
+            def __init__(self, name):
+                self.base_package_name = name
+
+        yum_dict = {
+            'installed': {
+                MockPackage('vim')
+            },
+            'available': {
+                MockPackage('vim')
+            }
+        }
+        import yum
+        yum.yumBase.return_value.doPackageLists.return_value = yum_dict
+        result = fetch.filter_installed_packages(['vim'])
+        self.assertEquals(result, [])
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('charmhelpers.fetch.ubuntu.log')
+    @patch('apt_pkg.Cache')
+    def test_filter_packages_not_available_ubuntu(self, cache, log, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         cache.side_effect = fake_apt_cache
         result = fetch.filter_installed_packages(['vim', 'joe'])
         self.assertEquals(result, ['joe'])
         log.assert_called_with('Package joe has no installation candidate.',
                                level='WARNING')
 
-    @patch.object(fetch, 'log')
-    def test_add_source_none(self, log):
-        fetch.add_source(source=None)
-        self.assertTrue(log.called)
-
+    @patch.object(osplatform, 'get_platform')
+    @patch('charmhelpers.fetch.centos.log')
+    @patch('yum.YumBase.doPackageLists')
+    def test_filter_packages_not_available_centos(self, yumBase,
+                                                  log, platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        class MockPackage:
+            def __init__(self, name):
+                self.base_package_name = name
+
+        yum_dict = {
+            'installed': {
+                MockPackage('vim')
+            }
+        }
+        import yum
+        yum.YumBase.return_value.doPackageLists.return_value = yum_dict
+
+        result = fetch.filter_installed_packages(['vim', 'joe'])
+        self.assertEquals(result, ['joe'])
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_add_source_none_ubuntu(self, log, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
+        fetch.add_source(source=None)
+        self.assertTrue(log.called)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('charmhelpers.fetch.centos.log')
+    def test_add_source_none_centos(self, log, platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        fetch.add_source(source=None)
+        self.assertTrue(log.called)
+
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.check_call')
-    def test_add_source_ppa(self, check_call):
+    def test_add_source_ppa(self, check_call, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         source = "ppa:test-ppa"
         fetch.add_source(source=source)
-        check_call.assert_called_with(['add-apt-repository',
-                                       '--yes',
-                                       source])
+        check_call.assert_called_with(
+            ['add-apt-repository', '--yes', source])
 
+    @patch('charmhelpers.fetch.ubuntu.log')
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.check_call')
-    def test_add_source_http(self, check_call):
+    def test_add_source_http_ubuntu(self, check_call, platform, log):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         source = "http://archive.ubuntu.com/ubuntu raring-backports main"
         fetch.add_source(source=source)
-        check_call.assert_called_with(['add-apt-repository',
-                                       '--yes',
-                                       source])
-
+        check_call.assert_called_with(
+            ['add-apt-repository', '--yes', source])
+
+    @patch('charmhelpers.fetch.centos.log')
+    @patch.object(osplatform, 'get_platform')
+    @patch('os.listdir')
+    def test_add_source_http_centos(self, listdir, platform, log):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        source = "http://archive.ubuntu.com/ubuntu raring-backports main"
+        with patch_open() as (mock_open, mock_file):
+            fetch.add_source(source=source)
+            listdir.assert_called_with('/etc/yum.repos.d/')
+            mock_file.write.assert_has_calls([
+                call("[archive.ubuntu.com_ubuntu raring-backports main]\n"),
+                call("name=archive.ubuntu.com/ubuntu raring-backports main\n"),
+                call("baseurl=http://archive.ubuntu.com/ubuntu raring"
+                     "-backports main\n\n")])
+
+    @patch('charmhelpers.fetch.ubuntu.log')
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.check_call')
-    def test_add_source_https(self, check_call):
+    def test_add_source_https(self, check_call, platform, log):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         source = "https://example.com"
         fetch.add_source(source=source)
-        check_call.assert_called_with(['add-apt-repository',
-                                       '--yes',
-                                       source])
+        check_call.assert_called_with(
+            ['add-apt-repository', '--yes', source])
 
+    @patch('charmhelpers.fetch.ubuntu.log')
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.check_call')
-    def test_add_source_deb(self, check_call):
+    def test_add_source_deb(self, check_call, platform, log):
         """add-apt-repository behaves differently when using the deb prefix.
 
-        $ add-apt-repository --yes "http://special.example.com/ubuntu precise-special main"
+        $ add-apt-repository --yes "http://special.example.com/ubuntu
+        precise-special main"
         $ grep special /etc/apt/sources.list
         deb http://special.example.com/ubuntu precise precise-special main
         deb-src http://special.example.com/ubuntu precise precise-special main
 
-        $ add-apt-repository --yes "deb http://special.example.com/ubuntu precise-special main"
+        $ add-apt-repository --yes "deb http://special.example.com/ubuntu
+        precise-special main"
         $ grep special /etc/apt/sources.list
         deb http://special.example.com/ubuntu precise precise-special main
         deb-src http://special.example.com/ubuntu precise precise-special main
         deb http://special.example.com/ubuntu precise-special main
         deb-src http://special.example.com/ubuntu precise-special main
         """
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         source = "deb http://archive.ubuntu.com/ubuntu raring-backports main"
         fetch.add_source(source=source)
-        check_call.assert_called_with(['add-apt-repository',
-                                       '--yes',
-                                       source])
-
-    @patch.object(fetch, 'filter_installed_packages')
-    @patch.object(fetch, 'apt_install')
-    def test_add_source_cloud_invalid_pocket(self, apt_install, filter_pkg):
+        check_call.assert_called_with(
+            ['add-apt-repository', '--yes', source])
+
+    @patch.object(osplatform, 'get_platform')
+    @patch.object(fetch.ubuntu, 'filter_installed_packages')
+    @patch.object(fetch.ubuntu, 'install')
+    def test_add_source_cloud_invalid_pocket(self, install,
+                                             filter_pkg, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         source = "cloud:havana-updates"
-        self.assertRaises(fetch.SourceConfigError, fetch.add_source, source)
+        self.assertRaises(fetch.ubuntu.SourceConfigError,
+                          fetch.add_source, source)
         filter_pkg.assert_called_with(['ubuntu-cloud-keyring'])
 
-    @patch.object(fetch, 'filter_installed_packages')
-    @patch.object(fetch, 'apt_install')
-    def test_add_source_cloud_pocket_style(self, apt_install, filter_pkg):
+    @patch('charmhelpers.fetch.ubuntu.log')
+    @patch.object(osplatform, 'get_platform')
+    @patch.object(fetch.ubuntu, 'filter_installed_packages')
+    @patch.object(fetch.ubuntu, 'install')
+    def test_add_source_cloud_pocket_style(self, install, filter_pkg,
+                                           platform, log):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         source = "cloud:precise-updates/havana"
-        result = '''# Ubuntu Cloud Archive
-deb http://ubuntu-cloud.archive.canonical.com/ubuntu precise-updates/havana main
-'''
+        result = ('# Ubuntu Cloud Archive'
+                  ' deb http://ubuntu-cloud.archive.canonical.com/ubuntu'
+                  ' precise-updates/havana main')
+
         with patch_open() as (mock_open, mock_file):
             fetch.add_source(source=source)
             mock_file.write.assert_called_with(result)
         filter_pkg.assert_called_with(['ubuntu-cloud-keyring'])
 
-    @patch.object(fetch, 'filter_installed_packages')
-    @patch.object(fetch, 'apt_install')
-    def test_add_source_cloud_os_style(self, apt_install, filter_pkg):
+    @patch('charmhelpers.fetch.ubuntu.log')
+    @patch.object(osplatform, 'get_platform')
+    @patch.object(fetch.ubuntu, 'filter_installed_packages')
+    @patch.object(fetch.ubuntu, 'install')
+    def test_add_source_cloud_os_style(self, install, filter_pkg,
+                                       platform, log):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         source = "cloud:precise-havana"
-        result = '''# Ubuntu Cloud Archive
-deb http://ubuntu-cloud.archive.canonical.com/ubuntu precise-updates/havana main
-'''
+        result = ('# Ubuntu Cloud Archive'
+                  ' deb http://ubuntu-cloud.archive.canonical.com/ubuntu'
+                  ' precise-updates/havana main')
         with patch_open() as (mock_open, mock_file):
             fetch.add_source(source=source)
             mock_file.write.assert_called_with(result)
         filter_pkg.assert_called_with(['ubuntu-cloud-keyring'])
 
-    @patch.object(fetch, 'filter_installed_packages')
-    @patch.object(fetch, 'apt_install')
-    def test_add_source_cloud_distroless_style(self, apt_install, filter_pkg):
+    @patch('charmhelpers.fetch.ubuntu.log')
+    @patch.object(osplatform, 'get_platform')
+    @patch.object(fetch.ubuntu, 'filter_installed_packages')
+    @patch.object(fetch.ubuntu, 'install')
+    def test_add_source_cloud_distroless_style(self, install, filter_pkg,
+                                               platform, log):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         source = "cloud:havana"
-        result = '''# Ubuntu Cloud Archive
-deb http://ubuntu-cloud.archive.canonical.com/ubuntu precise-updates/havana main
-'''
+        result = ('# Ubuntu Cloud Archive'
+                  ' deb http://ubuntu-cloud.archive.canonical.com/ubuntu'
+                  ' precise-updates/havana main')
         with patch_open() as (mock_open, mock_file):
             fetch.add_source(source=source)
             mock_file.write.assert_called_with(result)
         filter_pkg.assert_called_with(['ubuntu-cloud-keyring'])
 
-    @patch.object(fetch, 'lsb_release')
-    def test_add_source_proposed(self, lsb_release):
+    @patch('charmhelpers.fetch.ubuntu.log')
+    @patch.object(osplatform, 'get_platform')
+    @patch.object(fetch.ubuntu, 'lsb_release')
+    def test_add_source_proposed(self, lsb_release, platform, log):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         source = "proposed"
-        result = """# Proposed
-deb http://archive.ubuntu.com/ubuntu precise-proposed main universe multiverse restricted
-"""
+        result = ('# Proposed'
+                  ' deb http://archive.ubuntu.com/ubuntu precise-proposed'
+                  ' main universe multiverse restricted')
         lsb_release.return_value = {'DISTRIB_CODENAME': 'precise'}
         with patch_open() as (mock_open, mock_file):
             fetch.add_source(source=source)
             mock_file.write.assert_called_with(result)
 
-    @patch('subprocess.check_call')
-    def test_add_source_http_and_key_id(self, check_call):
-        source = "http://archive.ubuntu.com/ubuntu raring-backports main"
-        key_id = "akey"
-        fetch.add_source(source=source, key=key_id)
-        check_call.assert_has_calls([
-            call(['add-apt-repository', '--yes', source]),
-            call(['apt-key', 'adv', '--keyserver',
-                  'hkp://keyserver.ubuntu.com:80', '--recv', key_id])
-        ])
-
-    @patch('subprocess.check_call')
-    def test_add_source_https_and_key_id(self, check_call):
-        source = "https://USER:[e-mail]/project/awesome"
-        key_id = "GPGPGP"
-        fetch.add_source(source=source, key=key_id)
-        check_call.assert_has_calls([
-            call(['add-apt-repository', '--yes', source]),
-            call(['apt-key', 'adv', '--keyserver',
-                  'hkp://keyserver.ubuntu.com:80', '--recv', key_id])
-        ])
-
-    @patch('subprocess.check_call')
-    def test_add_source_http_and_key(self, check_call):
+    @patch('charmhelpers.fetch.ubuntu.log')
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    def test_add_source_http_and_key_id_ubuntu(self, check_call,
+                                               platform, log):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
+        source = "http://archive.ubuntu.com/ubuntu raring-backports main"
+        key_id = "akey"
+        fetch.add_source(source=source, key=key_id)
+        check_call.assert_has_calls([
+            call(['add-apt-repository', '--yes', source]),
+            call(['apt-key', 'adv', '--keyserver',
+                  'hkp://keyserver.ubuntu.com:80', '--recv', key_id])
+        ])
+
+    @patch('charmhelpers.fetch.centos.log')
+    @patch('os.listdir')
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    def test_add_source_http_and_key_id_centos(self, check_call,
+                                               platform, listdir, log):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        source = "http://archive.ubuntu.com/ubuntu raring-backports main"
+        key_id = "akey"
+        with patch_open() as (mock_open, mock_file):
+            fetch.add_source(source=source, key=key_id)
+            listdir.assert_called_with('/etc/yum.repos.d/')
+            mock_file.write.assert_has_calls([
+                call("[archive.ubuntu.com_ubuntu raring-backports main]\n"),
+                call("name=archive.ubuntu.com/ubuntu raring-backports main\n"),
+                call("baseurl=http://archive.ubuntu.com/ubuntu raring"
+                     "-backports main\n\n")])
+        check_call.assert_called_with(['rpm', '--import', key_id])
+
+    @patch('charmhelpers.fetch.ubuntu.log')
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    def test_add_source_https_and_key_id_ubuntu(self, check_call,
+                                                platform, log):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
+        source = "https://USER:[e-mail]/project/awesome"
+        key_id = "GPGPGP"
+        fetch.add_source(source=source, key=key_id)
+        check_call.assert_has_calls([
+            call(['add-apt-repository', '--yes', source]),
+            call(['apt-key', 'adv', '--keyserver',
+                  'hkp://keyserver.ubuntu.com:80', '--recv', key_id])
+        ])
+
+    @patch('charmhelpers.fetch.centos.log')
+    @patch('os.listdir')
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    def test_add_source_https_and_key_id_centos(self, check_call,
+                                                platform, listdir, log):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        source = "https://USER:[e-mail]/project/awesome"
+        key_id = "GPGPGP"
+        with patch_open() as (mock_open, mock_file):
+            fetch.add_source(source=source, key=key_id)
+            listdir.assert_called_with('/etc/yum.repos.d/')
+            mock_file.write.assert_has_calls([
+                call("[_USER:[e-mail]"
+                     ".net_project_awesome]\n"),
+                call("name=/USER:[e-mail]"
+                     "/project/awesome\n"),
+                call("baseurl=https://USER:[e-mail]"
+                     "/project/awesome\n\n")])
+        check_call.assert_called_with(['rpm', '--import', key_id])
+
+    @patch('charmhelpers.fetch.ubuntu.log')
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    def test_add_source_http_and_key_ubuntu(self, check_call, platform, log):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         source = "http://archive.ubuntu.com/ubuntu raring-backports main"
         key = '''
             -----BEGIN PGP PUBLIC KEY BLOCK-----
@@ -231,20 +455,55 @@
             self.assertEqual(['apt-key', 'add', '-'], received_args)
             self.assertEqual(key, received_key.getvalue())
 
-    @patch('charmhelpers.fetch.log')
-    def test_add_unparsable_source(self, log_):
+    @patch('charmhelpers.fetch.centos.log')
+    @patch.object(tempfile, 'NamedTemporaryFile')
+    @patch('os.listdir')
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    def test_add_source_http_and_key_centos(self, check_call, platform,
+                                            listdir, temp_file, log):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        source = "http://archive.ubuntu.com/ubuntu raring-backports main"
+        key = '''
+            -----BEGIN PGP PUBLIC KEY BLOCK-----
+            [...]
+            -----END PGP PUBLIC KEY BLOCK-----
+            '''
+        temp_file.return_value.__enter__.return_value = key
+        temp_file.return_value.__exit__.return_value = key
+
+        with patch_open() as (mock_open, mock_file):
+            fetch.add_source(source=source, key=key)
+            listdir.assert_called_with('/etc/yum.repos.d/')
+            self.assertTrue(log.called)
+        check_call.assert_called_with(['rpm', '--import', key])
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_add_unparsable_source(self, log_, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         source = "propsed"  # Minor typo
         fetch.add_source(source=source)
         self.assertEqual(1, log_.call_count)
 
-    def test_add_distro_source(self):
+    @patch('charmhelpers.fetch.ubuntu.log')
+    @patch.object(osplatform, 'get_platform')
+    def test_add_distro_source(self, platform, log):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         source = "distro"
         # distro is a noop but test validate no exception is thrown
         fetch.add_source(source=source)
 
+    @patch('charmhelpers.fetch.ubuntu.log')
     @patch.object(fetch, 'config')
     @patch.object(fetch, 'add_source')
-    def test_configure_sources_single_source(self, add_source, config):
+    def test_configure_sources_single_source(self, add_source, config, log):
         config.side_effect = ['source', 'key']
         fetch.configure_sources()
         add_source.assert_called_with('source', 'key')
@@ -296,15 +555,16 @@
         ]
         self.assertRaises(fetch.SourceConfigError, fetch.configure_sources)
 
-    @patch.object(fetch, 'apt_update')
+    @patch.object(osplatform, 'get_platform')
+    @patch('charmhelpers.fetch.ubuntu.update')
     @patch.object(fetch, 'config')
     @patch.object(fetch, 'add_source')
-    def test_configure_sources_apt_update_called(self, add_source, config,
-                                                 apt_update):
+    def test_configure_sources_update_called_ubuntu(self, add_source, config,
+                                                    update, platform):
         config.side_effect = ['source', 'key']
         fetch.configure_sources(update=True)
         add_source.assert_called_with('source', 'key')
-        self.assertTrue(apt_update.called)
+        self.assertTrue(update.called)
 
 
 class InstallTest(TestCase):
@@ -403,7 +663,8 @@
     @patch('charmhelpers.fetch.importlib.import_module')
     def test_skips_and_logs_missing_plugins(self, import_, log_):
         fetch_handlers = ['a.foo', 'b.foo', 'c.foo']
-        import_.side_effect = (NotImplementedError, NotImplementedError, MagicMock())
+        import_.side_effect = (NotImplementedError, NotImplementedError,
+                               MagicMock())
         plugins = fetch.plugins(fetch_handlers)
 
         self.assertEqual(1, len(plugins))
@@ -453,226 +714,330 @@
 
 class AptTests(TestCase):
 
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.call')
-    @patch.object(fetch, 'log')
-    def test_apt_upgrade_non_fatal(self, log, mock_call):
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_apt_upgrade_non_fatal(self, log, mock_call, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         options = ['--foo', '--bar']
         fetch.apt_upgrade(options)
 
-        mock_call.assert_called_with(['apt-get', '--assume-yes',
-                                      '--foo', '--bar', 'upgrade'],
-                                     env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
+        mock_call.assert_called_with(
+            ['apt-get', '--assume-yes',
+             '--foo', '--bar', 'upgrade'],
+            env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
 
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.check_call')
-    @patch.object(fetch, 'log')
-    def test_apt_upgrade_fatal(self, log, mock_call):
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_apt_upgrade_fatal(self, log, mock_call, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         options = ['--foo', '--bar']
         fetch.apt_upgrade(options, fatal=True)
 
-        mock_call.assert_called_with(['apt-get', '--assume-yes',
-                                      '--foo', '--bar', 'upgrade'],
-                                     env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
+        mock_call.assert_called_with(
+            ['apt-get', '--assume-yes',
+             '--foo', '--bar', 'upgrade'],
+            env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
 
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.check_call')
-    @patch.object(fetch, 'log')
-    def test_apt_dist_upgrade_fatal(self, log, mock_call):
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_apt_dist_upgrade_fatal(self, log, mock_call, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         options = ['--foo', '--bar']
         fetch.apt_upgrade(options, fatal=True, dist=True)
 
-        mock_call.assert_called_with(['apt-get', '--assume-yes',
-                                      '--foo', '--bar', 'dist-upgrade'],
-                                     env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
+        mock_call.assert_called_with(
+            ['apt-get', '--assume-yes',
+             '--foo', '--bar', 'dist-upgrade'],
+            env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
 
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.call')
-    @patch.object(fetch, 'log')
-    def test_installs_apt_packages(self, log, mock_call):
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_installs_apt_packages(self, log, mock_call, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         packages = ['foo', 'bar']
         options = ['--foo', '--bar']
 
         fetch.apt_install(packages, options)
 
-        mock_call.assert_called_with(['apt-get', '--assume-yes',
-                                      '--foo', '--bar', 'install', 'foo', 'bar'],
-                                     env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
+        mock_call.assert_called_with(
+            ['apt-get', '--assume-yes',
+             '--foo', '--bar', 'install', 'foo', 'bar'],
+            env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
 
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.call')
-    @patch.object(fetch, 'log')
-    def test_installs_apt_packages_without_options(self, log, mock_call):
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_installs_apt_packages_without_options(self, log, mock_call,
+                                                   platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         packages = ['foo', 'bar']
 
         fetch.apt_install(packages)
 
-        expected = ['apt-get', '--assume-yes',
-                    '--option=Dpkg::Options::=--force-confold',
-                    'install', 'foo', 'bar']
-
-        mock_call.assert_called_with(expected,
-                                     env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
-
+        mock_call.assert_called_with(
+            ['apt-get', '--assume-yes',
+             '--option=Dpkg::Options::=--force-confold',
+             'install', 'foo', 'bar'],
+            env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
+
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.call')
-    @patch.object(fetch, 'log')
-    def test_installs_apt_packages_as_string(self, log, mock_call):
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_installs_apt_packages_as_string(self, log, mock_call, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         packages = 'foo bar'
         options = ['--foo', '--bar']
 
         fetch.apt_install(packages, options)
 
-        expected = ['apt-get', '--assume-yes',
-                    '--foo', '--bar', 'install', 'foo bar']
-
-        mock_call.assert_called_with(expected,
-                                     env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
-
+        mock_call.assert_called_with(
+            ['apt-get', '--assume-yes',
+             '--foo', '--bar', 'install', 'foo bar'],
+            env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
+
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.check_call')
-    @patch.object(fetch, 'log')
-    def test_installs_apt_packages_with_possible_errors(self, log, check_call):
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_installs_apt_packages_with_possible_errors(self, log,
+                                                        check_call, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         packages = ['foo', 'bar']
         options = ['--foo', '--bar']
 
         fetch.apt_install(packages, options, fatal=True)
 
-        check_call.assert_called_with(['apt-get', '--assume-yes',
-                                       '--foo', '--bar', 'install', 'foo', 'bar'],
-                                      env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
-
-    @patch('subprocess.check_call')
-    @patch.object(fetch, 'log')
-    def test_purges_apt_packages_as_string_fatal(self, log, mock_call):
-        packages = 'irrelevant names'
-        mock_call.side_effect = OSError('fail')
-
-        self.assertRaises(OSError, fetch.apt_purge, packages, fatal=True)
-        self.assertTrue(log.called)
-
-    @patch('subprocess.check_call')
-    @patch.object(fetch, 'log')
-    def test_purges_apt_packages_fatal(self, log, mock_call):
-        packages = ['irrelevant', 'names']
-        mock_call.side_effect = OSError('fail')
-
-        self.assertRaises(OSError, fetch.apt_purge, packages, fatal=True)
-        self.assertTrue(log.called)
-
-    @patch('subprocess.call')
-    @patch.object(fetch, 'log')
-    def test_purges_apt_packages_as_string_nofatal(self, log, mock_call):
-        packages = 'foo bar'
-
-        fetch.apt_purge(packages)
-
-        self.assertTrue(log.called)
-        mock_call.assert_called_with(
-            ['apt-get', '--assume-yes', 'purge', 'foo bar'], env=getenv(
-                {'DEBIAN_FRONTEND': 'noninteractive'}))
-
-    @patch('subprocess.call')
-    @patch.object(fetch, 'log')
-    def test_purges_apt_packages_nofatal(self, log, mock_call):
-        packages = ['foo', 'bar']
-
-        fetch.apt_purge(packages)
-
-        self.assertTrue(log.called)
-        mock_call.assert_called_with(
-            ['apt-get', '--assume-yes', 'purge', 'foo', 'bar'], env=getenv(
-                {'DEBIAN_FRONTEND': 'noninteractive'}))
-
-    @patch('subprocess.check_call')
-    @patch.object(fetch, 'log')
-    def test_mark_apt_packages_as_string_fatal(self, log, mock_call):
-        packages = 'irrelevant names'
-        mock_call.side_effect = OSError('fail')
-
-        self.assertRaises(OSError, fetch.apt_mark, packages, sentinel.mark,
-                          fatal=True)
-        self.assertTrue(log.called)
-
-    @patch('subprocess.check_call')
-    @patch.object(fetch, 'log')
-    def test_mark_apt_packages_fatal(self, log, mock_call):
-        packages = ['irrelevant', 'names']
-        mock_call.side_effect = OSError('fail')
-
-        self.assertRaises(OSError, fetch.apt_mark, packages, sentinel.mark,
-                          fatal=True)
-        self.assertTrue(log.called)
-
-    @patch('subprocess.call')
-    @patch.object(fetch, 'log')
-    def test_mark_apt_packages_as_string_nofatal(self, log, mock_call):
-        packages = 'foo bar'
-
-        fetch.apt_mark(packages, sentinel.mark)
-
-        self.assertTrue(log.called)
-        mock_call.assert_called_with(['apt-mark', sentinel.mark, 'foo bar'],
-                                     universal_newlines=True)
-
-    @patch('subprocess.call')
-    @patch.object(fetch, 'log')
-    def test_mark_apt_packages_nofatal(self, log, mock_call):
-        packages = ['foo', 'bar']
-
-        fetch.apt_mark(packages, sentinel.mark)
-
-        self.assertTrue(log.called)
-        mock_call.assert_called_with(['apt-mark', sentinel.mark, 'foo', 'bar'],
-                                     universal_newlines=True)
-
-    @patch('subprocess.check_call')
-    @patch.object(fetch, 'log')
-    def test_mark_apt_packages_nofatal_abortonfatal(self, log, mock_call):
+        check_call.assert_called_with(
+            ['apt-get', '--assume-yes',
+             '--foo', '--bar', 'install', 'foo', 'bar'],
+            env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_purges_apt_packages_as_string_fatal(self, log, mock_call,
+                                                 platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
+        packages = 'irrelevant names'
+        mock_call.side_effect = OSError('fail')
+
+        self.assertRaises(OSError, fetch.apt_purge, packages, fatal=True)
+        self.assertTrue(log.called)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_purges_apt_packages_fatal(self, log, mock_call, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
+        packages = ['irrelevant', 'names']
+        mock_call.side_effect = OSError('fail')
+
+        self.assertRaises(OSError, fetch.apt_purge, packages, fatal=True)
+        self.assertTrue(log.called)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.call')
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_purges_apt_packages_as_string_nofatal(self, log, mock_call,
+                                                   platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
+        packages = 'foo bar'
+
+        fetch.apt_purge(packages)
+
+        self.assertTrue(log.called)
+        mock_call.assert_called_with(
+            ['apt-get', '--assume-yes', 'purge', 'foo bar'],
+            env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.call')
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_purges_apt_packages_nofatal(self, log, mock_call, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
+        packages = ['foo', 'bar']
+
+        fetch.apt_purge(packages)
+
+        self.assertTrue(log.called)
+        mock_call.assert_called_with(
+            ['apt-get', '--assume-yes', 'purge', 'foo', 'bar'],
+            env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_mark_apt_packages_as_string_fatal(self, log, mock_call,
+                                               platform):
+        packages = 'irrelevant names'
+        mock_call.side_effect = OSError('fail')
+
+        self.assertRaises(OSError, fetch.apt_mark, packages, sentinel.mark,
+                          fatal=True)
+        self.assertTrue(log.called)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_mark_apt_packages_fatal(self, log, mock_call, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
+        packages = ['irrelevant', 'names']
+        mock_call.side_effect = OSError('fail')
+
+        self.assertRaises(OSError, fetch.apt_mark, packages, sentinel.mark,
+                          fatal=True)
+        self.assertTrue(log.called)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.call')
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_mark_apt_packages_as_string_nofatal(self, log, mock_call,
+                                                 platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
+        packages = 'foo bar'
+
+        fetch.apt_mark(packages, sentinel.mark)
+
+        self.assertTrue(log.called)
+        mock_call.assert_called_with(
+            ['apt-mark', sentinel.mark, 'foo bar'],
+            universal_newlines=True)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.call')
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_mark_apt_packages_nofatal(self, log, mock_call,
+                                       platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
+        packages = ['foo', 'bar']
+
+        fetch.apt_mark(packages, sentinel.mark)
+
+        self.assertTrue(log.called)
+        mock_call.assert_called_with(
+            ['apt-mark', sentinel.mark, 'foo', 'bar'],
+            universal_newlines=True)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    @patch('charmhelpers.fetch.ubuntu.log')
+    def test_mark_apt_packages_nofatal_abortonfatal(self, log, mock_call,
+                                                    platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         packages = ['foo', 'bar']
 
         fetch.apt_mark(packages, sentinel.mark, fatal=True)
 
         self.assertTrue(log.called)
-        mock_call.assert_called_with(['apt-mark', sentinel.mark, 'foo', 'bar'],
-                                     universal_newlines=True)
-
-    @patch.object(fetch, 'apt_mark')
-    def test_apt_hold(self, apt_mark):
+        mock_call.assert_called_with(
+            ['apt-mark', sentinel.mark, 'foo', 'bar'],
+            universal_newlines=True)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('charmhelpers.fetch.ubuntu.apt_mark')
+    def test_apt_hold(self, apt_mark, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         fetch.apt_hold(sentinel.packages)
         apt_mark.assert_called_once_with(sentinel.packages, 'hold',
                                          fatal=False)
 
-    @patch.object(fetch, 'apt_mark')
-    def test_apt_hold_fatal(self, apt_mark):
+    @patch.object(osplatform, 'get_platform')
+    @patch('charmhelpers.fetch.ubuntu.apt_mark')
+    def test_apt_hold_fatal(self, apt_mark, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         fetch.apt_hold(sentinel.packages, fatal=sentinel.fatal)
         apt_mark.assert_called_once_with(sentinel.packages, 'hold',
                                          fatal=sentinel.fatal)
 
-    @patch.object(fetch, 'apt_mark')
-    def test_apt_unhold(self, apt_mark):
+    @patch.object(osplatform, 'get_platform')
+    @patch('charmhelpers.fetch.ubuntu.apt_mark')
+    def test_apt_unhold(self, apt_mark, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         fetch.apt_unhold(sentinel.packages)
         apt_mark.assert_called_once_with(sentinel.packages, 'unhold',
                                          fatal=False)
 
-    @patch.object(fetch, 'apt_mark')
-    def test_apt_unhold_fatal(self, apt_mark):
+    @patch.object(osplatform, 'get_platform')
+    @patch('charmhelpers.fetch.ubuntu.apt_mark')
+    def test_apt_unhold_fatal(self, apt_mark, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         fetch.apt_unhold(sentinel.packages, fatal=sentinel.fatal)
         apt_mark.assert_called_once_with(sentinel.packages, 'unhold',
                                          fatal=sentinel.fatal)
 
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.check_call')
-    def test_apt_update_fatal(self, check_call):
+    def test_apt_update_fatal(self, check_call, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         fetch.apt_update(fatal=True)
         check_call.assert_called_with(
-            ['apt-get', 'update'], env=getenv(
-                {'DEBIAN_FRONTEND': 'noninteractive'}))
+            ['apt-get', 'update'],
+            env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
 
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.call')
-    def test_apt_update_nonfatal(self, call):
+    def test_apt_update_nonfatal(self, call, platform):
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         fetch.apt_update()
         call.assert_called_with(
-            ['apt-get', 'update'], env=getenv(
-                {'DEBIAN_FRONTEND': 'noninteractive'}))
+            ['apt-get', 'update'],
+            env=getenv({'DEBIAN_FRONTEND': 'noninteractive'}))
 
+    @patch.object(osplatform, 'get_platform')
     @patch('subprocess.check_call')
     @patch('time.sleep')
-    def test_run_apt_command_retries_if_fatal(self, check_call, sleep):
+    def test_run_apt_command_retries_if_fatal(self, check_call,
+                                              sleep, platform):
         """The _run_apt_command function retries the command if it can't get
         the APT lock."""
+        platform.return_value = 'ubuntu'
+        imp.reload(fetch)
+
         self.called = False
 
         def side_effect(*args, **kwargs):
@@ -690,5 +1055,217 @@
         check_call.side_effect = side_effect
         check_call.return_value = 0
 
-        fetch._run_apt_command(["some", "command"], fatal=True)
+        from charmhelpers.fetch.ubuntu import _run_apt_command
+        _run_apt_command(["some", "command"], fatal=True)
+        self.assertTrue(sleep.called)
+
+
+class YumTests(TestCase):
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.call')
+    @patch('charmhelpers.fetch.centos.log')
+    def test_yum_upgrade_non_fatal(self, log, mock_call, platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        options = ['--foo', '--bar']
+        fetch.upgrade(options)
+
+        mock_call.assert_called_with(['yum', '--assumeyes',
+                                      '--foo', '--bar', 'upgrade'],
+                                     env=getenv())
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.call')
+    @patch('charmhelpers.fetch.centos.log')
+    def test_yum_upgrade_fatal(self, log, mock_call, platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        options = ['--foo', '--bar']
+        fetch.upgrade(options, fatal=True)
+
+        mock_call.assert_called_with(['yum', '--assumeyes',
+                                      '--foo', '--bar', 'upgrade'],
+                                     env=getenv())
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.call')
+    @patch('charmhelpers.fetch.centos.log')
+    def test_installs_yum_packages(self, log, mock_call, platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        packages = ['foo', 'bar']
+        options = ['--foo', '--bar']
+
+        fetch.install(packages, options)
+
+        mock_call.assert_called_with(['yum', '--assumeyes',
+                                      '--foo', '--bar', 'install',
+                                      'foo', 'bar'],
+                                     env=getenv())
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.call')
+    @patch('charmhelpers.fetch.centos.log')
+    def test_installs_yum_packages_without_options(self, log, mock_call,
+                                                   platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        packages = ['foo', 'bar']
+        fetch.install(packages)
+
+        mock_call.assert_called_with(['yum', '--assumeyes',
+                                      'install', 'foo', 'bar'],
+                                     env=getenv())
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.call')
+    @patch('charmhelpers.fetch.centos.log')
+    def test_installs_yum_packages_as_string(self, log, mock_call,
+                                             platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        packages = 'foo bar'
+        fetch.install(packages)
+
+        mock_call.assert_called_with(['yum', '--assumeyes',
+                                      'install', 'foo bar'],
+                                     env=getenv())
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.call')
+    @patch('charmhelpers.fetch.centos.log')
+    def test_installs_yum_packages_with_possible_errors(self, log, mock_call,
+                                                        platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        packages = ['foo', 'bar']
+        options = ['--foo', '--bar']
+
+        fetch.install(packages, options, fatal=True)
+
+        mock_call.assert_called_with(['yum', '--assumeyes',
+                                      '--foo', '--bar',
+                                      'install', 'foo', 'bar'],
+                                     env=getenv())
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    @patch('charmhelpers.fetch.centos.log')
+    def test_purges_yum_packages_as_string_fatal(self, log, mock_call,
+                                                 platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        packages = 'irrelevant names'
+        mock_call.side_effect = OSError('fail')
+
+        self.assertRaises(OSError, fetch.purge, packages, fatal=True)
+        self.assertTrue(log.called)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    @patch('charmhelpers.fetch.centos.log')
+    def test_purges_yum_packages_fatal(self, log, mock_call, platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        packages = ['irrelevant', 'names']
+        mock_call.side_effect = OSError('fail')
+
+        self.assertRaises(OSError, fetch.purge, packages, fatal=True)
+        self.assertTrue(log.called)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.call')
+    @patch('charmhelpers.fetch.centos.log')
+    def test_purges_yum_packages_as_string_nofatal(self, log, mock_call,
+                                                   platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        packages = 'foo bar'
+        fetch.purge(packages)
+
+        self.assertTrue(log.called)
+        mock_call.assert_called_with(['yum', '--assumeyes',
+                                      'remove', 'foo bar'],
+                                     env=getenv())
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.call')
+    @patch('charmhelpers.fetch.centos.log')
+    def test_purges_yum_packages_nofatal(self, log, mock_call,
+                                         platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        packages = ['foo', 'bar']
+        fetch.purge(packages)
+
+        self.assertTrue(log.called)
+        mock_call.assert_called_with(['yum', '--assumeyes',
+                                      'remove', 'foo', 'bar'],
+                                     env=getenv())
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    @patch('charmhelpers.fetch.centos.log')
+    def test_yum_update_fatal(self, log, check_call, platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        fetch.update(fatal=True)
+        check_call.assert_called_with(['yum', '--assumeyes', 'update'],
+                                      env=getenv())
+        self.assertTrue(log.called)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_output')
+    @patch('charmhelpers.fetch.centos.log')
+    def test_yum_search(self, log, check_output, platform):
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        package = ['irrelevant']
+
+        from charmhelpers.fetch.centos import yum_search
+        yum_search(package)
+        check_output.assert_called_with(['yum', 'search', 'irrelevant'])
+        self.assertTrue(log.called)
+
+    @patch.object(osplatform, 'get_platform')
+    @patch('subprocess.check_call')
+    @patch('time.sleep')
+    def test_run_yum_command_retries_if_fatal(self, check_call,
+                                              sleep, platform):
+        """The _run_yum_command function retries the command if it can't get
+        the YUM lock."""
+        platform.return_value = 'centos'
+        imp.reload(fetch)
+
+        self.called = False
+
+        def side_effect(*args, **kwargs):
+            """
+            First, raise an exception (can't acquire lock), then return 0
+            (the lock is grabbed).
+            """
+            if not self.called:
+                self.called = True
+                raise subprocess.CalledProcessError(
+                    returncode=1, cmd="some command")
+            else:
+                return 0
+
+        check_call.side_effect = side_effect
+        check_call.return_value = 0
+        from charmhelpers.fetch.centos import _run_yum_command
+        _run_yum_command(["some", "command"], fatal=True)
         self.assertTrue(sleep.called)

=== modified file 'tests/fetch/test_giturl.py'
--- tests/fetch/test_giturl.py	2016-01-08 13:27:39 +0000
+++ tests/fetch/test_giturl.py	2016-08-12 07:09:49 +0000
@@ -7,6 +7,7 @@
     MagicMock,
     patch,
 )
+from charmhelpers.core.host import chdir
 
 import six
 if six.PY3:
@@ -14,7 +15,7 @@
 else:
     from urlparse import urlparse
 
-from charmhelpers.core.host import chdir
+
 try:
     from charmhelpers.fetch import (
         giturl,
@@ -57,7 +58,8 @@
             self.fh.load_plugins = MagicMock()
             self.fh.clone(url, dest_path, branch, None)
 
-            check_call.assert_called_with(['git', 'clone', url, dest_path, '--branch', branch])
+            check_call.assert_called_with(
+                ['git', 'clone', url, dest_path, '--branch', branch])
 
         for url in self.invalid_urls:
             with patch.dict('os.environ', {'CHARM_DIR': 'foo'}):
@@ -73,7 +75,8 @@
             with chdir(src):
                 subprocess.check_call(['git', 'init'])
                 subprocess.check_call(['git', 'config', 'user.name', 'Joe'])
-                subprocess.check_call(['git', 'config', 'user.email', '[e-mail]'])
+                subprocess.check_call(
+                    ['git', 'config', 'user.email', '[e-mail]'])
                 subprocess.check_call(['touch', 'foo'])
                 subprocess.check_call(['git', 'add', 'foo'])
                 subprocess.check_call(['git', 'commit', '-m', 'test'])