Merge ~raharper/curtin:ubuntu/devel/newupstream-20180921 into curtin:ubuntu/devel

[Ryan Harper]

curtin (18.1-52-g5f0082d1-0ubuntu1) cosmic; urgency=medium

  * New upstream snapshot.
    - Enable custom storage configuration for centos images

 -- Ryan Harper <email address hidden> Fri, 21 Sep 2018 03:04:42 -0500

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:b1c28d72020a6a987afa78d0441786e0b1d9d9b0
https://jenkins.ubuntu.com/server/job/curtin-ci/1063/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/1063
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/1063
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/1063
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=torkoal/1063

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/curtin-ci/1063/rebuild

review: Approve (continuous-integration)

diff --git a/curtin/__init__.py b/curtin/__init__.py
index 002454b..ee35ca3 100644
--- a/curtin/__init__.py
+++ b/curtin/__init__.py
@@ -10,6 +10,8 @@ KERNEL_CMDLINE_COPY_TO_INSTALL_SEP = "---"
 FEATURES = [
     # curtin can apply centos networking via centos_apply_network_config
     'CENTOS_APPLY_NETWORK_CONFIG',
+    # curtin can configure centos storage devices and boot devices
+    'CENTOS_CURTHOOK_SUPPORT',
     # install supports the 'network' config version 1
     'NETWORK_CONFIG_V1',
     # reporter supports 'webhook' type
diff --git a/curtin/block/__init__.py b/curtin/block/__init__.py
index b771629..490c268 100644
--- a/curtin/block/__init__.py
+++ b/curtin/block/__init__.py
@@ -1003,78 +1003,6 @@ def wipe_volume(path, mode="superblock", exclusive=True):
         raise ValueError("wipe mode %s not supported" % mode)
 
 
-def storage_config_required_packages(storage_config, mapping):
-    """Read storage configuration dictionary and determine
-       which packages are required for the supplied configuration
-       to function.  Return a list of packaged to install.
-    """
-
-    if not storage_config or not isinstance(storage_config, dict):
-        raise ValueError('Invalid storage configuration.  '
-                         'Must be a dict:\n %s' % storage_config)
-
-    if not mapping or not isinstance(mapping, dict):
-        raise ValueError('Invalid storage mapping.  Must be a dict')
-
-    if 'storage' in storage_config:
-        storage_config = storage_config.get('storage')
-
-    needed_packages = []
-
-    # get reqs by device operation type
-    dev_configs = set(operation['type']
-                      for operation in storage_config['config'])
-
-    for dev_type in dev_configs:
-        if dev_type in mapping:
-            needed_packages.extend(mapping[dev_type])
-
-    # for any format operations, check the fstype and
-    # determine if we need any mkfs tools as well.
-    format_configs = set([operation['fstype']
-                         for operation in storage_config['config']
-                         if operation['type'] == 'format'])
-    for format_type in format_configs:
-        if format_type in mapping:
-            needed_packages.extend(mapping[format_type])
-
-    return needed_packages
-
-
-def detect_required_packages_mapping():
-    """Return a dictionary providing a versioned configuration which maps
-       storage configuration elements to the packages which are required
-       for functionality.
-
-       The mapping key is either a config type value, or an fstype value.
-
-    """
-    version = 1
-    mapping = {
-        version: {
-            'handler': storage_config_required_packages,
-            'mapping': {
-                'bcache': ['bcache-tools'],
-                'btrfs': ['btrfs-tools'],
-                'ext2': ['e2fsprogs'],
-                'ext3': ['e2fsprogs'],
-                'ext4': ['e2fsprogs'],
-                'jfs': ['jfsutils'],
-                'lvm_partition': ['lvm2'],
-                'lvm_volgroup': ['lvm2'],
-                'ntfs': ['ntfs-3g'],
-                'raid': ['mdadm'],
-                'reiserfs': ['reiserfsprogs'],
-                'xfs': ['xfsprogs'],
-                'zfsroot': ['zfsutils-linux', 'zfs-initramfs'],
-                'zfs': ['zfsutils-linux', 'zfs-initramfs'],
-                'zpool': ['zfsutils-linux', 'zfs-initramfs'],
-            },
-        },
-    }
-    return mapping
-
-
 def get_supported_filesystems():
     """ Return a list of filesystems that the kernel currently supports
         as read from /proc/filesystems.
diff --git a/curtin/block/deps.py b/curtin/block/deps.py
new file mode 100644
index 0000000..930f764
--- /dev/null
+++ b/curtin/block/deps.py
@@ -0,0 +1,103 @@
+# This file is part of curtin. See LICENSE file for copyright and license info.
+
+from curtin.distro import DISTROS
+from curtin.block import iscsi
+
+
+def storage_config_required_packages(storage_config, mapping):
+    """Read storage configuration dictionary and determine
+       which packages are required for the supplied configuration
+       to function.  Return a list of packaged to install.
+    """
+
+    if not storage_config or not isinstance(storage_config, dict):
+        raise ValueError('Invalid storage configuration.  '
+                         'Must be a dict:\n %s' % storage_config)
+
+    if not mapping or not isinstance(mapping, dict):
+        raise ValueError('Invalid storage mapping.  Must be a dict')
+
+    if 'storage' in storage_config:
+        storage_config = storage_config.get('storage')
+
+    needed_packages = []
+
+    # get reqs by device operation type
+    dev_configs = set(operation['type']
+                      for operation in storage_config['config'])
+
+    for dev_type in dev_configs:
+        if dev_type in mapping:
+            needed_packages.extend(mapping[dev_type])
+
+    # for disks with path: iscsi: we need iscsi tools
+    iscsi_vols = iscsi.get_iscsi_volumes_from_config(storage_config)
+    if len(iscsi_vols) > 0:
+        needed_packages.extend(mapping['iscsi'])
+
+    # for any format operations, check the fstype and
+    # determine if we need any mkfs tools as well.
+    format_configs = set([operation['fstype']
+                         for operation in storage_config['config']
+                         if operation['type'] == 'format'])
+    for format_type in format_configs:
+        if format_type in mapping:
+            needed_packages.extend(mapping[format_type])
+
+    return needed_packages
+
+
+def detect_required_packages_mapping(osfamily=DISTROS.debian):
+    """Return a dictionary providing a versioned configuration which maps
+       storage configuration elements to the packages which are required
+       for functionality.
+
+       The mapping key is either a config type value, or an fstype value.
+
+    """
+    distro_mapping = {
+        DISTROS.debian: {
+            'bcache': ['bcache-tools'],
+            'btrfs': ['btrfs-tools'],
+            'ext2': ['e2fsprogs'],
+            'ext3': ['e2fsprogs'],
+            'ext4': ['e2fsprogs'],
+            'jfs': ['jfsutils'],
+            'iscsi': ['open-iscsi'],
+            'lvm_partition': ['lvm2'],
+            'lvm_volgroup': ['lvm2'],
+            'ntfs': ['ntfs-3g'],
+            'raid': ['mdadm'],
+            'reiserfs': ['reiserfsprogs'],
+            'xfs': ['xfsprogs'],
+            'zfsroot': ['zfsutils-linux', 'zfs-initramfs'],
+            'zfs': ['zfsutils-linux', 'zfs-initramfs'],
+            'zpool': ['zfsutils-linux', 'zfs-initramfs'],
+        },
+        DISTROS.redhat: {
+            'bcache': [],
+            'btrfs': ['btrfs-progs'],
+            'ext2': ['e2fsprogs'],
+            'ext3': ['e2fsprogs'],
+            'ext4': ['e2fsprogs'],
+            'jfs': [],
+            'iscsi': ['iscsi-initiator-utils'],
+            'lvm_partition': ['lvm2'],
+            'lvm_volgroup': ['lvm2'],
+            'ntfs': [],
+            'raid': ['mdadm'],
+            'reiserfs': [],
+            'xfs': ['xfsprogs'],
+            'zfsroot': [],
+            'zfs': [],
+            'zpool': [],
+        },
+    }
+    if osfamily not in distro_mapping:
+        raise ValueError('No block package mapping for distro: %s' % osfamily)
+
+    return {1: {'handler': storage_config_required_packages,
+                'mapping': distro_mapping.get(osfamily)}}
+
+
+# vi: ts=4 expandtab syntax=python
diff --git a/curtin/block/iscsi.py b/curtin/block/iscsi.py
index 0c666b6..3c46500 100644
--- a/curtin/block/iscsi.py
+++ b/curtin/block/iscsi.py
@@ -9,7 +9,7 @@ import os
 import re
 import shutil
 
-from curtin import (util, udev)
+from curtin import (paths, util, udev)
 from curtin.block import (get_device_slave_knames,
                           path_to_kname)
 
@@ -230,29 +230,45 @@ def connected_disks():
     return _ISCSI_DISKS
 
 
-def get_iscsi_disks_from_config(cfg):
+def get_iscsi_volumes_from_config(cfg):
     """Parse a curtin storage config and return a list
-       of iscsi disk objects for each configuration present
+       of iscsi disk rfc4173 uris for each configuration present.
     """
     if not cfg:
         cfg = {}
 
-    sconfig = cfg.get('storage', {}).get('config', {})
-    if not sconfig:
+    if 'storage' in cfg:
+        sconfig = cfg.get('storage', {}).get('config', [])
+    else:
+        sconfig = cfg.get('config', [])
+    if not sconfig or not isinstance(sconfig, list):
         LOG.warning('Configuration dictionary did not contain'
                     ' a storage configuration')
         return []
 
+    return [disk['path'] for disk in sconfig
+            if disk['type'] == 'disk' and
+            disk.get('path', "").startswith('iscsi:')]
+
+
+def get_iscsi_disks_from_config(cfg):
+    """Return a list of IscsiDisk objects for each iscsi volume present."""
     # Construct IscsiDisk objects for each iscsi volume present
-    iscsi_disks = [IscsiDisk(disk['path']) for disk in sconfig
-                   if disk['type'] == 'disk' and
-                   disk.get('path', "").startswith('iscsi:')]
+    iscsi_disks = [IscsiDisk(volume) for volume in
+                   get_iscsi_volumes_from_config(cfg)]
     LOG.debug('Found %s iscsi disks in storage config', len(iscsi_disks))
     return iscsi_disks
 
 
+def get_iscsi_ports_from_config(cfg):
+    """Return a set of ports that may be used when connecting to volumes."""
+    ports = set([d.port for d in get_iscsi_disks_from_config(cfg)])
+    LOG.debug('Found iscsi ports in use: %s', ports)
+    return ports
+
+
 def disconnect_target_disks(target_root_path=None):
-    target_nodes_path = util.target_path(target_root_path, '/etc/iscsi/nodes')
+    target_nodes_path = paths.target_path(target_root_path, '/etc/iscsi/nodes')
     fails = []
     if os.path.isdir(target_nodes_path):
         for target in os.listdir(target_nodes_path):
diff --git a/curtin/block/lvm.py b/curtin/block/lvm.py
index eca64f6..b3f8bcb 100644
--- a/curtin/block/lvm.py
+++ b/curtin/block/lvm.py
@@ -4,6 +4,7 @@
 This module provides some helper functions for manipulating lvm devices
 """
 
+from curtin import distro
 from curtin import util
 from curtin.log import LOG
 import os
@@ -88,7 +89,7 @@ def lvm_scan(activate=True):
     # before appending the cache flag though, check if lvmetad is running. this
     # ensures that we do the right thing even if lvmetad is supported but is
     # not running
-    release = util.lsb_release().get('codename')
+    release = distro.lsb_release().get('codename')
     if release in [None, 'UNAVAILABLE']:
         LOG.warning('unable to find release number, assuming xenial or later')
         release = 'xenial'
diff --git a/curtin/block/mdadm.py b/curtin/block/mdadm.py
index 8eff7fb..4ad6aa7 100644
--- a/curtin/block/mdadm.py
+++ b/curtin/block/mdadm.py
@@ -13,6 +13,7 @@ import time
 
 from curtin.block import (dev_short, dev_path, is_valid_device, sys_block_path)
 from curtin.block import get_holders
+from curtin.distro import lsb_release
 from curtin import (util, udev)
 from curtin.log import LOG
 
@@ -95,7 +96,7 @@ VALID_RAID_ARRAY_STATES = (
     checks the mdadm version and will return True if we can use --export
     for key=value list with enough info, false if version is less than
 '''
-MDADM_USE_EXPORT = util.lsb_release()['codename'] not in ['precise', 'trusty']
+MDADM_USE_EXPORT = lsb_release()['codename'] not in ['precise', 'trusty']
 
 #
 # mdadm executors
diff --git a/curtin/block/mkfs.py b/curtin/block/mkfs.py
index f39017c..4a1e1f9 100644
--- a/curtin/block/mkfs.py
+++ b/curtin/block/mkfs.py
@@ -3,8 +3,9 @@
 # This module wraps calls to mkfs.<fstype> and determines the appropriate flags
 # for each filesystem type
 
-from curtin import util
 from curtin import block
+from curtin import distro
+from curtin import util
 
 import string
 import os
@@ -102,7 +103,7 @@ def valid_fstypes():
 
 def get_flag_mapping(flag_name, fs_family, param=None, strict=False):
     ret = []
-    release = util.lsb_release()['codename']
+    release = distro.lsb_release()['codename']
     overrides = release_flag_mapping_overrides.get(release, {})
     if flag_name in overrides and fs_family in overrides[flag_name]:
         flag_sym = overrides[flag_name][fs_family]
diff --git a/curtin/block/zfs.py b/curtin/block/zfs.py
index e279ab6..5615144 100644
--- a/curtin/block/zfs.py
+++ b/curtin/block/zfs.py
@@ -7,6 +7,7 @@ and volumes."""
 import os
 
 from curtin.config import merge_config
+from curtin import distro
 from curtin import util
 from . import blkid, get_supported_filesystems
 
@@ -90,7 +91,7 @@ def zfs_assert_supported():
     if arch in ZFS_UNSUPPORTED_ARCHES:
         raise RuntimeError("zfs is not supported on architecture: %s" % arch)
 
-    release = util.lsb_release()['codename']
+    release = distro.lsb_release()['codename']
     if release in ZFS_UNSUPPORTED_RELEASES:
         raise RuntimeError("zfs is not supported on release: %s" % release)
 
diff --git a/curtin/commands/apply_net.py b/curtin/commands/apply_net.py
index ffd474e..ddc5056 100644
--- a/curtin/commands/apply_net.py
+++ b/curtin/commands/apply_net.py
@@ -7,6 +7,7 @@ from .. import log
 import curtin.net as net
 import curtin.util as util
 from curtin import config
+from curtin import paths
 from . import populate_one_subcmd
 
 
@@ -123,7 +124,7 @@ def _patch_ifupdown_ipv6_mtu_hook(target,
 
     for hook in ['prehook', 'posthook']:
         fn = hookfn[hook]
-        cfg = util.target_path(target, path=fn)
+        cfg = paths.target_path(target, path=fn)
         LOG.info('Injecting fix for ipv6 mtu settings: %s', cfg)
         util.write_file(cfg, contents[hook], mode=0o755)
 
@@ -136,7 +137,7 @@ def _disable_ipv6_privacy_extensions(target,
        Resolve this by allowing the cloud-image setting to win. """
 
     LOG.debug('Attempting to remove ipv6 privacy extensions')
-    cfg = util.target_path(target, path=path)
+    cfg = paths.target_path(target, path=path)
     if not os.path.exists(cfg):
         LOG.warn('Failed to find ipv6 privacy conf file %s', cfg)
         return
@@ -182,7 +183,7 @@ def _maybe_remove_legacy_eth0(target,
          - with unknown content, leave it and warn
     """
 
-    cfg = util.target_path(target, path=path)
+    cfg = paths.target_path(target, path=path)
     if not os.path.exists(cfg):
         LOG.warn('Failed to find legacy network conf file %s', cfg)
         return
diff --git a/curtin/commands/apt_config.py b/curtin/commands/apt_config.py
index 41c329e..9ce25b3 100644
--- a/curtin/commands/apt_config.py
+++ b/curtin/commands/apt_config.py
@@ -13,7 +13,7 @@ import sys
 import yaml
 
 from curtin.log import LOG
-from curtin import (config, util, gpg)
+from curtin import (config, distro, gpg, paths, util)
 
 from . import populate_one_subcmd
 
@@ -61,7 +61,7 @@ def handle_apt(cfg, target=None):
         curthooks if a global apt config was provided or via the "apt"
         standalone command.
     """
-    release = util.lsb_release(target=target)['codename']
+    release = distro.lsb_release(target=target)['codename']
     arch = util.get_architecture(target)
     mirrors = find_apt_mirror_info(cfg, arch)
     LOG.debug("Apt Mirror info: %s", mirrors)
@@ -148,7 +148,7 @@ def apply_debconf_selections(cfg, target=None):
             pkg = re.sub(r"[:\s].*", "", line)
             pkgs_cfgd.add(pkg)
 
-    pkgs_installed = util.get_installed_packages(target)
+    pkgs_installed = distro.get_installed_packages(target)
 
     LOG.debug("pkgs_cfgd: %s", pkgs_cfgd)
     LOG.debug("pkgs_installed: %s", pkgs_installed)
@@ -164,7 +164,7 @@ def apply_debconf_selections(cfg, target=None):
 def clean_cloud_init(target):
     """clean out any local cloud-init config"""
     flist = glob.glob(
-        util.target_path(target, "/etc/cloud/cloud.cfg.d/*dpkg*"))
+        paths.target_path(target, "/etc/cloud/cloud.cfg.d/*dpkg*"))
 
     LOG.debug("cleaning cloud-init config from: %s", flist)
     for dpkg_cfg in flist:
@@ -194,7 +194,7 @@ def rename_apt_lists(new_mirrors, target=None):
     """rename_apt_lists - rename apt lists to preserve old cache data"""
     default_mirrors = get_default_mirrors(util.get_architecture(target))
 
-    pre = util.target_path(target, APT_LISTS)
+    pre = paths.target_path(target, APT_LISTS)
     for (name, omirror) in default_mirrors.items():
         nmirror = new_mirrors.get(name)
         if not nmirror:
@@ -299,7 +299,7 @@ def generate_sources_list(cfg, release, mirrors, target=None):
     if tmpl is None:
         LOG.info("No custom template provided, fall back to modify"
                  "mirrors in %s on the target system", aptsrc)
-        tmpl = util.load_file(util.target_path(target, aptsrc))
+        tmpl = util.load_file(paths.target_path(target, aptsrc))
         # Strategy if no custom template was provided:
         # - Only replacing mirrors
         # - no reason to replace "release" as it is from target anyway
@@ -310,24 +310,24 @@ def generate_sources_list(cfg, release, mirrors, target=None):
         tmpl = mirror_to_placeholder(tmpl, default_mirrors['SECURITY'],
                                      "$SECURITY")
 
-    orig = util.target_path(target, aptsrc)
+    orig = paths.target_path(target, aptsrc)
     if os.path.exists(orig):
         os.rename(orig, orig + ".curtin.old")
 
     rendered = util.render_string(tmpl, params)
     disabled = disable_suites(cfg.get('disable_suites'), rendered, release)
-    util.write_file(util.target_path(target, aptsrc), disabled, mode=0o644)
+    util.write_file(paths.target_path(target, aptsrc), disabled, mode=0o644)
 
     # protect the just generated sources.list from cloud-init
     cloudfile = "/etc/cloud/cloud.cfg.d/curtin-preserve-sources.cfg"
     # this has to work with older cloud-init as well, so use old key
     cloudconf = yaml.dump({'apt_preserve_sources_list': True}, indent=1)
     try:
-        util.write_file(util.target_path(target, cloudfile),
+        util.write_file(paths.target_path(target, cloudfile),
                         cloudconf, mode=0o644)
     except IOError:
         LOG.exception("Failed to protect source.list from cloud-init in (%s)",
-                      util.target_path(target, cloudfile))
+                      paths.target_path(target, cloudfile))
         raise
 
 
@@ -409,7 +409,7 @@ def add_apt_sources(srcdict, target=None, template_params=None,
                     raise
             continue
 
-        sourcefn = util.target_path(target, ent['filename'])
+        sourcefn = paths.target_path(target, ent['filename'])
         try:
             contents = "%s\n" % (source)
             util.write_file(sourcefn, contents, omode="a")
@@ -417,8 +417,8 @@ def add_apt_sources(srcdict, target=None, template_params=None,
             LOG.exception("failed write to file %s: %s", sourcefn, detail)
             raise
 
-    util.apt_update(target=target, force=True,
-                    comment="apt-source changed config")
+    distro.apt_update(target=target, force=True,
+                      comment="apt-source changed config")
 
     return
 
diff --git a/curtin/commands/block_meta.py b/curtin/commands/block_meta.py
index 6bd430d..197c1fd 100644
--- a/curtin/commands/block_meta.py
+++ b/curtin/commands/block_meta.py
@@ -1,8 +1,9 @@
 # This file is part of curtin. See LICENSE file for copyright and license info.
 
 from collections import OrderedDict, namedtuple
-from curtin import (block, config, util)
+from curtin import (block, config, paths, util)
 from curtin.block import (bcache, mdadm, mkfs, clear_holders, lvm, iscsi, zfs)
+from curtin import distro
 from curtin.log import LOG, logged_time
 from curtin.reporter import events
 
@@ -730,12 +731,12 @@ def mount_fstab_data(fdata, target=None):
 
     :param fdata: a FstabData type
     :return None."""
-    mp = util.target_path(target, fdata.path)
+    mp = paths.target_path(target, fdata.path)
     if fdata.device:
         device = fdata.device
     else:
         if fdata.spec.startswith("/") and not fdata.spec.startswith("/dev/"):
-            device = util.target_path(target, fdata.spec)
+            device = paths.target_path(target, fdata.spec)
         else:
             device = fdata.spec
 
@@ -856,7 +857,7 @@ def lvm_partition_handler(info, storage_config):
         # Use 'wipesignatures' (if available) and 'zero' to clear target lv
         # of any fs metadata
         cmd = ["lvcreate", volgroup, "--name", name, "--zero=y"]
-        release = util.lsb_release()['codename']
+        release = distro.lsb_release()['codename']
         if release not in ['precise', 'trusty']:
             cmd.extend(["--wipesignatures=y"])
 
diff --git a/curtin/commands/curthooks.py b/curtin/commands/curthooks.py
index f9a5a66..480eca4 100644
--- a/curtin/commands/curthooks.py
+++ b/curtin/commands/curthooks.py
@@ -11,12 +11,18 @@ import textwrap
 
 from curtin import config
 from curtin import block
+from curtin import distro
+from curtin.block import iscsi
 from curtin import net
 from curtin import futil
 from curtin.log import LOG
+from curtin import paths
 from curtin import swap
 from curtin import util
 from curtin import version as curtin_version
+from curtin.block import deps as bdeps
+from curtin.distro import DISTROS
+from curtin.net import deps as ndeps
 from curtin.reporter import events
 from curtin.commands import apply_net, apt_config
 from curtin.url_helper import get_maas_version
@@ -173,10 +179,10 @@ def install_kernel(cfg, target):
     # target only has required packages installed.  See LP:1640519
     fk_packages = get_flash_kernel_pkgs()
     if fk_packages:
-        util.install_packages(fk_packages.split(), target=target)
+        distro.install_packages(fk_packages.split(), target=target)
 
     if kernel_package:
-        util.install_packages([kernel_package], target=target)
+        distro.install_packages([kernel_package], target=target)
         return
 
     # uname[2] is kernel name (ie: 3.16.0-7-generic)
@@ -193,24 +199,24 @@ def install_kernel(cfg, target):
         LOG.warn("Couldn't detect kernel package to install for %s."
                  % kernel)
         if kernel_fallback is not None:
-            util.install_packages([kernel_fallback], target=target)
+            distro.install_packages([kernel_fallback], target=target)
         return
 
     package = "linux-{flavor}{map_suffix}".format(
         flavor=flavor, map_suffix=map_suffix)
 
-    if util.has_pkg_available(package, target):
-        if util.has_pkg_installed(package, target):
+    if distro.has_pkg_available(package, target):
+        if distro.has_pkg_installed(package, target):
             LOG.debug("Kernel package '%s' already installed", package)
         else:
             LOG.debug("installing kernel package '%s'", package)
-            util.install_packages([package], target=target)
+            distro.install_packages([package], target=target)
     else:
         if kernel_fallback is not None:
             LOG.info("Kernel package '%s' not available.  "
                      "Installing fallback package '%s'.",
                      package, kernel_fallback)
-            util.install_packages([kernel_fallback], target=target)
+            distro.install_packages([kernel_fallback], target=target)
         else:
             LOG.warn("Kernel package '%s' not available and no fallback."
                      " System may not boot.", package)
@@ -273,7 +279,7 @@ def uefi_reorder_loaders(grubcfg, target):
         LOG.debug("Currently booted UEFI loader might no longer boot.")
 
 
-def setup_grub(cfg, target):
+def setup_grub(cfg, target, osfamily=DISTROS.debian):
     # target is the path to the mounted filesystem
 
     # FIXME: these methods need moving to curtin.block
@@ -353,24 +359,6 @@ def setup_grub(cfg, target):
         else:
             instdevs = list(blockdevs)
 
-    # UEFI requires grub-efi-{arch}. If a signed version of that package
-    # exists then it will be installed.
-    if util.is_uefi_bootable():
-        arch = util.get_architecture()
-        pkgs = ['grub-efi-%s' % arch]
-
-        # Architecture might support a signed UEFI loader
-        uefi_pkg_signed = 'grub-efi-%s-signed' % arch
-        if util.has_pkg_available(uefi_pkg_signed):
-            pkgs.append(uefi_pkg_signed)
-
-        # AMD64 has shim-signed for SecureBoot support
-        if arch == "amd64":
-            pkgs.append("shim-signed")
-
-        # Install the UEFI packages needed for the architecture
-        util.install_packages(pkgs, target=target)
-
     env = os.environ.copy()
 
     replace_default = grubcfg.get('replace_linux_default', True)
@@ -399,6 +387,7 @@ def setup_grub(cfg, target):
             else:
                 LOG.debug("NOT enabling UEFI nvram updates")
                 LOG.debug("Target system may not boot")
+        args.append('--os-family=%s' % osfamily)
         args.append(target)
 
         # capture stdout and stderr joined.
@@ -435,14 +424,21 @@ def copy_crypttab(crypttab, target):
     shutil.copy(crypttab, os.path.sep.join([target, 'etc/crypttab']))
 
 
-def copy_iscsi_conf(nodes_dir, target):
+def copy_iscsi_conf(nodes_dir, target, target_nodes_dir='etc/iscsi/nodes'):
     if not nodes_dir:
         LOG.warn("nodes directory must be specified, not copying")
         return
 
     LOG.info("copying iscsi nodes database into target")
-    shutil.copytree(nodes_dir, os.path.sep.join([target,
-                    'etc/iscsi/nodes']))
+    tdir = os.path.sep.join([target, target_nodes_dir])
+    if not os.path.exists(tdir):
+        shutil.copytree(nodes_dir, tdir)
+    else:
+        # if /etc/iscsi/nodes exists, copy dirs underneath
+        for ndir in os.listdir(nodes_dir):
+            source_dir = os.path.join(nodes_dir, ndir)
+            target_dir = os.path.join(tdir, ndir)
+            shutil.copytree(source_dir, target_dir)
 
 
 def copy_mdadm_conf(mdadm_conf, target):
@@ -486,7 +482,7 @@ def copy_dname_rules(rules_d, target):
     if not rules_d:
         LOG.warn("no udev rules directory to copy")
         return
-    target_rules_dir = util.target_path(target, "etc/udev/rules.d")
+    target_rules_dir = paths.target_path(target, "etc/udev/rules.d")
     for rule in os.listdir(rules_d):
         target_file = os.path.join(target_rules_dir, rule)
         shutil.copy(os.path.join(rules_d, rule), target_file)
@@ -532,11 +528,19 @@ def add_swap(cfg, target, fstab):
                         maxsize=maxsize)
 
 
-def detect_and_handle_multipath(cfg, target):
-    DEFAULT_MULTIPATH_PACKAGES = ['multipath-tools-boot']
+def detect_and_handle_multipath(cfg, target, osfamily=DISTROS.debian):
+    DEFAULT_MULTIPATH_PACKAGES = {
+        DISTROS.debian: ['multipath-tools-boot'],
+        DISTROS.redhat: ['device-mapper-multipath'],
+    }
+    if osfamily not in DEFAULT_MULTIPATH_PACKAGES:
+        raise ValueError(
+                'No multipath package mapping for distro: %s' % osfamily)
+
     mpcfg = cfg.get('multipath', {})
     mpmode = mpcfg.get('mode', 'auto')
-    mppkgs = mpcfg.get('packages', DEFAULT_MULTIPATH_PACKAGES)
+    mppkgs = mpcfg.get('packages',
+                       DEFAULT_MULTIPATH_PACKAGES.get(osfamily))
     mpbindings = mpcfg.get('overwrite_bindings', True)
 
     if isinstance(mppkgs, str):
@@ -549,23 +553,28 @@ def detect_and_handle_multipath(cfg, target):
         return
 
     LOG.info("Detected multipath devices. Installing support via %s", mppkgs)
+    needed = [pkg for pkg in mppkgs if pkg
+              not in distro.get_installed_packages(target)]
+    if needed:
+        distro.install_packages(needed, target=target, osfamily=osfamily)
 
-    util.install_packages(mppkgs, target=target)
     replace_spaces = True
-    try:
-        # check in-target version
-        pkg_ver = util.get_package_version('multipath-tools', target=target)
-        LOG.debug("get_package_version:\n%s", pkg_ver)
-        LOG.debug("multipath version is %s (major=%s minor=%s micro=%s)",
-                  pkg_ver['semantic_version'], pkg_ver['major'],
-                  pkg_ver['minor'], pkg_ver['micro'])
-        # multipath-tools versions < 0.5.0 do _NOT_ want whitespace replaced
-        # i.e. 0.4.X in Trusty.
-        if pkg_ver['semantic_version'] < 500:
-            replace_spaces = False
-    except Exception as e:
-        LOG.warn("failed reading multipath-tools version, "
-                 "assuming it wants no spaces in wwids: %s", e)
+    if osfamily == DISTROS.debian:
+        try:
+            # check in-target version
+            pkg_ver = distro.get_package_version('multipath-tools',
+                                                 target=target)
+            LOG.debug("get_package_version:\n%s", pkg_ver)
+            LOG.debug("multipath version is %s (major=%s minor=%s micro=%s)",
+                      pkg_ver['semantic_version'], pkg_ver['major'],
+                      pkg_ver['minor'], pkg_ver['micro'])
+            # multipath-tools versions < 0.5.0 do _NOT_
+            # want whitespace replaced i.e. 0.4.X in Trusty.
+            if pkg_ver['semantic_version'] < 500:
+                replace_spaces = False
+        except Exception as e:
+            LOG.warn("failed reading multipath-tools version, "
+                     "assuming it wants no spaces in wwids: %s", e)
 
     multipath_cfg_path = os.path.sep.join([target, '/etc/multipath.conf'])
     multipath_bind_path = os.path.sep.join([target, '/etc/multipath/bindings'])
@@ -574,7 +583,7 @@ def detect_and_handle_multipath(cfg, target):
     if not os.path.isfile(multipath_cfg_path):
         # Without user_friendly_names option enabled system fails to boot
         # if any of the disks has spaces in its name. Package multipath-tools
-        # has bug opened for this issue (LP: 1432062) but it was not fixed yet.
+        # has bug opened for this issue LP: #1432062 but it was not fixed yet.
         multipath_cfg_content = '\n'.join(
             ['# This file was created by curtin while installing the system.',
              'defaults {',
@@ -593,7 +602,13 @@ def detect_and_handle_multipath(cfg, target):
         mpname = "mpath0"
         grub_dev = "/dev/mapper/" + mpname
         if partno is not None:
-            grub_dev += "-part%s" % partno
+            if osfamily == DISTROS.debian:
+                grub_dev += "-part%s" % partno
+            elif osfamily == DISTROS.redhat:
+                grub_dev += "p%s" % partno
+            else:
+                raise ValueError(
+                        'Unknown grub_dev mapping for distro: %s' % osfamily)
 
         LOG.debug("configuring multipath install for root=%s wwid=%s",
                   grub_dev, wwid)
@@ -606,31 +621,54 @@ def detect_and_handle_multipath(cfg, target):
              ''])
         util.write_file(multipath_bind_path, content=multipath_bind_content)
 
-        grub_cfg = os.path.sep.join(
-            [target, '/etc/default/grub.d/50-curtin-multipath.cfg'])
+        if osfamily == DISTROS.debian:
+            grub_cfg = os.path.sep.join(
+                [target, '/etc/default/grub.d/50-curtin-multipath.cfg'])
+            omode = 'w'
+        elif osfamily == DISTROS.redhat:
+            grub_cfg = os.path.sep.join([target, '/etc/default/grub'])
+            omode = 'a'
+        else:
+            raise ValueError(
+                    'Unknown grub_cfg mapping for distro: %s' % osfamily)
+
         msg = '\n'.join([
-            '# Written by curtin for multipath device wwid "%s"' % wwid,
+            '# Written by curtin for multipath device %s %s' % (mpname, wwid),
             'GRUB_DEVICE=%s' % grub_dev,
             'GRUB_DISABLE_LINUX_UUID=true',
             ''])
-        util.write_file(grub_cfg, content=msg)
-
+        util.write_file(grub_cfg, omode=omode, content=msg)
     else:
         LOG.warn("Not sure how this will boot")
 
-    # Initrams needs to be updated to include /etc/multipath.cfg
-    # and /etc/multipath/bindings files.
-    update_initramfs(target, all_kernels=True)
+    if osfamily == DISTROS.debian:
+        # Initrams needs to be updated to include /etc/multipath.cfg
+        # and /etc/multipath/bindings files.
+        update_initramfs(target, all_kernels=True)
+    elif osfamily == DISTROS.redhat:
+        # Write out initramfs/dracut config for multipath
+        dracut_conf_multipath = os.path.sep.join(
+            [target, '/etc/dracut.conf.d/10-curtin-multipath.conf'])
+        msg = '\n'.join([
+            '# Written by curtin for multipath device wwid "%s"' % wwid,
+            'force_drivers+=" dm-multipath "',
+            'add_dracutmodules+="multipath"',
+            'install_items+="/etc/multipath.conf /etc/multipath/bindings"',
+            ''])
+        util.write_file(dracut_conf_multipath, content=msg)
+    else:
+        raise ValueError(
+                'Unknown initramfs mapping for distro: %s' % osfamily)
 
 
-def detect_required_packages(cfg):
+def detect_required_packages(cfg, osfamily=DISTROS.debian):
     """
     detect packages that will be required in-target by custom config items
     """
 
     mapping = {
-        'storage': block.detect_required_packages_mapping(),
-        'network': net.detect_required_packages_mapping(),
+        'storage': bdeps.detect_required_packages_mapping(osfamily=osfamily),
+        'network': ndeps.detect_required_packages_mapping(osfamily=osfamily),
     }
 
     needed_packages = []
@@ -657,16 +695,16 @@ def detect_required_packages(cfg):
     return needed_packages
 
 
-def install_missing_packages(cfg, target):
+def install_missing_packages(cfg, target, osfamily=DISTROS.debian):
     ''' describe which operation types will require specific packages
 
     'custom_config_key': {
          'pkg1': ['op_name_1', 'op_name_2', ...]
      }
     '''
-
-    installed_packages = util.get_installed_packages(target)
-    needed_packages = set([pkg for pkg in detect_required_packages(cfg)
+    installed_packages = distro.get_installed_packages(target)
+    needed_packages = set([pkg for pkg in
+                           detect_required_packages(cfg, osfamily=osfamily)
                            if pkg not in installed_packages])
 
     arch_packages = {
@@ -678,6 +716,31 @@ def install_missing_packages(cfg, target):
             if pkg not in needed_packages:
                 needed_packages.add(pkg)
 
+    # UEFI requires grub-efi-{arch}. If a signed version of that package
+    # exists then it will be installed.
+    if util.is_uefi_bootable():
+        uefi_pkgs = []
+        if osfamily == DISTROS.redhat:
+            # centos/redhat doesn't support 32-bit?
+            uefi_pkgs.extend(['grub2-efi-x64-modules'])
+        elif osfamily == DISTROS.debian:
+            arch = util.get_architecture()
+            uefi_pkgs.append('grub-efi-%s' % arch)
+
+            # Architecture might support a signed UEFI loader
+            uefi_pkg_signed = 'grub-efi-%s-signed' % arch
+            if distro.has_pkg_available(uefi_pkg_signed):
+                uefi_pkgs.append(uefi_pkg_signed)
+
+            # AMD64 has shim-signed for SecureBoot support
+            if arch == "amd64":
+                uefi_pkgs.append("shim-signed")
+        else:
+            raise ValueError('Unknown grub2 package list for distro: %s' %
+                             osfamily)
+        needed_packages.update([pkg for pkg in uefi_pkgs
+                                if pkg not in installed_packages])
+
     # Filter out ifupdown network packages on netplan enabled systems.
     has_netplan = ('nplan' in installed_packages or
                    'netplan.io' in installed_packages)
@@ -696,10 +759,10 @@ def install_missing_packages(cfg, target):
                 reporting_enabled=True, level="INFO",
                 description="Installing packages on target system: " +
                 str(to_add)):
-            util.install_packages(to_add, target=target)
+            distro.install_packages(to_add, target=target, osfamily=osfamily)
 
 
-def system_upgrade(cfg, target):
+def system_upgrade(cfg, target, osfamily=DISTROS.debian):
     """run system-upgrade (apt-get dist-upgrade) or other in target.
 
     config:
@@ -718,7 +781,7 @@ def system_upgrade(cfg, target):
         LOG.debug("system_upgrade disabled by config.")
         return
 
-    util.system_upgrade(target=target)
+    distro.system_upgrade(target=target, osfamily=osfamily)
 
 
 def inject_pollinate_user_agent_config(ua_cfg, target):
@@ -728,7 +791,7 @@ def inject_pollinate_user_agent_config(ua_cfg, target):
     if not isinstance(ua_cfg, dict):
         raise ValueError('ua_cfg is not a dictionary: %s', ua_cfg)
 
-    pollinate_cfg = util.target_path(target, '/etc/pollinate/add-user-agent')
+    pollinate_cfg = paths.target_path(target, '/etc/pollinate/add-user-agent')
     comment = "# written by curtin"
     content = "\n".join(["%s/%s %s" % (ua_key, ua_val, comment)
                          for ua_key, ua_val in ua_cfg.items()]) + "\n"
@@ -751,6 +814,8 @@ def handle_pollinate_user_agent(cfg, target):
       curtin version
       maas version (via endpoint URL, if present)
     """
+    if not util.which('pollinate', target=target):
+        return
 
     pcfg = cfg.get('pollinate')
     if not isinstance(pcfg, dict):
@@ -776,6 +841,63 @@ def handle_pollinate_user_agent(cfg, target):
     inject_pollinate_user_agent_config(uacfg, target)
 
 
+def configure_iscsi(cfg, state_etcd, target, osfamily=DISTROS.debian):
+    # If a /etc/iscsi/nodes/... file was created by block_meta then it
+    # needs to be copied onto the target system
+    nodes = os.path.join(state_etcd, "nodes")
+    if not os.path.exists(nodes):
+        return
+
+    LOG.info('Iscsi configuration found, enabling service')
+    if osfamily == DISTROS.redhat:
+        # copy iscsi node config to target image
+        LOG.debug('Copying iscsi node config to target')
+        copy_iscsi_conf(nodes, target, target_nodes_dir='var/lib/iscsi/nodes')
+
+        # update in-target config
+        with util.ChrootableTarget(target) as in_chroot:
+            # enable iscsid service
+            LOG.debug('Enabling iscsi daemon')
+            in_chroot.subp(['chkconfig', 'iscsid', 'on'])
+
+            # update selinux config for iscsi ports required
+            for port in [str(port) for port in
+                         iscsi.get_iscsi_ports_from_config(cfg)]:
+                LOG.debug('Adding iscsi port %s to selinux iscsi_port_t list',
+                          port)
+                in_chroot.subp(['semanage', 'port', '-a', '-t',
+                                'iscsi_port_t', '-p', 'tcp', port])
+
+    elif osfamily == DISTROS.debian:
+        copy_iscsi_conf(nodes, target)
+    else:
+        raise ValueError(
+                'Unknown iscsi requirements for distro: %s' % osfamily)
+
+
+def configure_mdadm(cfg, state_etcd, target, osfamily=DISTROS.debian):
+    # If a mdadm.conf file was created by block_meta than it needs
+    # to be copied onto the target system
+    mdadm_location = os.path.join(state_etcd, "mdadm.conf")
+    if not os.path.exists(mdadm_location):
+        return
+
+    conf_map = {
+        DISTROS.debian: 'etc/mdadm/mdadm.conf',
+        DISTROS.redhat: 'etc/mdadm.conf',
+    }
+    if osfamily not in conf_map:
+        raise ValueError(
+                'Unknown mdadm conf mapping for distro: %s' % osfamily)
+    LOG.info('Mdadm configuration found, enabling service')
+    shutil.copy(mdadm_location, paths.target_path(target,
+                                                  conf_map[osfamily]))
+    if osfamily == DISTROS.debian:
+        # as per LP: #964052 reconfigure mdadm
+        util.subp(['dpkg-reconfigure', '--frontend=noninteractive', 'mdadm'],
+                  data=None, target=target)
+
+
 def handle_cloudconfig(cfg, base_dir=None):
     """write cloud-init configuration files into base_dir.
 
@@ -845,21 +967,11 @@ def ubuntu_core_curthooks(cfg, target=None):
                         content=config.dump_config({'network': netconfig}))
 
 
-def rpm_get_dist_id(target):
-    """Use rpm command to extract the '%rhel' distro macro which returns
-       the major os version id (6, 7, 8).  This works for centos or rhel
-    """
-    with util.ChrootableTarget(target) as in_chroot:
-        dist, _ = in_chroot.subp(['rpm', '-E', '%rhel'], capture=True)
-    return dist.rstrip()
-
-
-def centos_apply_network_config(netcfg, target=None):
+def redhat_upgrade_cloud_init(netcfg, target=None, osfamily=DISTROS.redhat):
     """ CentOS images execute built-in curthooks which only supports
         simple networking configuration.  This hook enables advanced
         network configuration via config passthrough to the target.
     """
-
     def cloud_init_repo(version):
         if not version:
             raise ValueError('Missing required version parameter')
@@ -868,9 +980,9 @@ def centos_apply_network_config(netcfg, target=None):
 
     if netcfg:
         LOG.info('Removing embedded network configuration (if present)')
-        ifcfgs = glob.glob(util.target_path(target,
-                                            'etc/sysconfig/network-scripts') +
-                           '/ifcfg-*')
+        ifcfgs = glob.glob(
+            paths.target_path(target, 'etc/sysconfig/network-scripts') +
+            '/ifcfg-*')
         # remove ifcfg-* (except ifcfg-lo)
         for ifcfg in ifcfgs:
             if os.path.basename(ifcfg) != "ifcfg-lo":
@@ -884,29 +996,27 @@ def centos_apply_network_config(netcfg, target=None):
         # if in-target cloud-init is not updated, upgrade via cloud-init repo
         if not passthrough:
             cloud_init_yum_repo = (
-                util.target_path(target,
-                                 'etc/yum.repos.d/curtin-cloud-init.repo'))
+                paths.target_path(target,
+                                  'etc/yum.repos.d/curtin-cloud-init.repo'))
             # Inject cloud-init daily yum repo
             util.write_file(cloud_init_yum_repo,
-                            content=cloud_init_repo(rpm_get_dist_id(target)))
+                            content=cloud_init_repo(
+                                distro.rpm_get_dist_id(target)))
 
             # we separate the installation of repository packages (epel,
             # cloud-init-el-release) as we need a new invocation of yum
             # to read the newly installed repo files.
-            YUM_CMD = ['yum', '-y', '--noplugins', 'install']
-            retries = [1] * 30
-            with util.ChrootableTarget(target) as in_chroot:
-                # ensure up-to-date ca-certificates to handle https mirror
-                # connections
-                in_chroot.subp(YUM_CMD + ['ca-certificates'], capture=True,
-                               log_captured=True, retries=retries)
-                in_chroot.subp(YUM_CMD + ['epel-release'], capture=True,
-                               log_captured=True, retries=retries)
-                in_chroot.subp(YUM_CMD + ['cloud-init-el-release'],
-                               log_captured=True, capture=True,
-                               retries=retries)
-                in_chroot.subp(YUM_CMD + ['cloud-init'], capture=True,
-                               log_captured=True, retries=retries)
+
+            # ensure up-to-date ca-certificates to handle https mirror
+            # connections
+            distro.install_packages(['ca-certificates'], target=target,
+                                    osfamily=osfamily)
+            distro.install_packages(['epel-release'], target=target,
+                                    osfamily=osfamily)
+            distro.install_packages(['cloud-init-el-release'], target=target,
+                                    osfamily=osfamily)
+            distro.install_packages(['cloud-init'], target=target,
+                                    osfamily=osfamily)
 
             # remove cloud-init el-stable bootstrap repo config as the
             # cloud-init-el-release package points to the correct repo
@@ -919,127 +1029,136 @@ def centos_apply_network_config(netcfg, target=None):
                                    capture=False, rcs=[0])
                 except util.ProcessExecutionError:
                     LOG.debug('Image missing bridge-utils package, installing')
-                    in_chroot.subp(YUM_CMD + ['bridge-utils'], capture=True,
-                                   log_captured=True, retries=retries)
+                    distro.install_packages(['bridge-utils'], target=target,
+                                            osfamily=osfamily)
 
     LOG.info('Passing network configuration through to target')
     net.render_netconfig_passthrough(target, netconfig={'network': netcfg})
 
 
-def target_is_ubuntu_core(target):
-    """Check if Ubuntu-Core specific directory is present at target"""
-    if target:
-        return os.path.exists(util.target_path(target,
-                                               'system-data/var/lib/snapd'))
-    return False
-
-
-def target_is_centos(target):
-    """Check if CentOS specific file is present at target"""
-    if target:
-        return os.path.exists(util.target_path(target, 'etc/centos-release'))
+# Public API, maas may call this from internal curthooks
+centos_apply_network_config = redhat_upgrade_cloud_init
 
-    return False
 
+def redhat_apply_selinux_autorelabel(target):
+    """Creates file /.autorelabel.
 
-def target_is_rhel(target):
-    """Check if RHEL specific file is present at target"""
-    if target:
-        return os.path.exists(util.target_path(target, 'etc/redhat-release'))
+    This is used by SELinux to relabel all of the
+    files on the filesystem to have the correct
+    security context. Without this SSH login will
+    fail.
+    """
+    LOG.debug('enabling selinux autorelabel')
+    open(paths.target_path(target, '.autorelabel'), 'a').close()
 
-    return False
 
+def redhat_update_dracut_config(target, cfg):
+    initramfs_mapping = {
+        'lvm': {'conf': 'lvmconf', 'modules': 'lvm'},
+        'raid': {'conf': 'mdadmconf', 'modules': 'mdraid'},
+    }
 
-def curthooks(args):
-    state = util.load_command_environment()
+    # no need to update initramfs if no custom storage
+    if 'storage' not in cfg:
+        return False
 
-    if args.target is not None:
-        target = args.target
-    else:
-        target = state['target']
+    storage_config = cfg.get('storage', {}).get('config')
+    if not storage_config:
+        raise ValueError('Invalid storage config')
+
+    add_conf = set()
+    add_modules = set()
+    for scfg in storage_config:
+        if scfg['type'] == 'raid':
+            add_conf.add(initramfs_mapping['raid']['conf'])
+            add_modules.add(initramfs_mapping['raid']['modules'])
+        elif scfg['type'] in ['lvm_volgroup', 'lvm_partition']:
+            add_conf.add(initramfs_mapping['lvm']['conf'])
+            add_modules.add(initramfs_mapping['lvm']['modules'])
+
+    dconfig = ['# Written by curtin for custom storage config']
+    dconfig.append('add_dracutmodules+="%s"' % (" ".join(add_modules)))
+    for conf in add_conf:
+        dconfig.append('%s="yes"' % conf)
+
+    # Write out initramfs/dracut config for storage config
+    dracut_conf_storage = os.path.sep.join(
+        [target, '/etc/dracut.conf.d/50-curtin-storage.conf'])
+    msg = '\n'.join(dconfig + [''])
+    LOG.debug('Updating redhat dracut config')
+    util.write_file(dracut_conf_storage, content=msg)
+    return True
+
+
+def redhat_update_initramfs(target, cfg):
+    if not redhat_update_dracut_config(target, cfg):
+        LOG.debug('Skipping redhat initramfs update, no custom storage config')
+        return
+    kver_cmd = ['rpm', '-q', '--queryformat',
+                '%{VERSION}-%{RELEASE}.%{ARCH}', 'kernel']
+    with util.ChrootableTarget(target) as in_chroot:
+        LOG.debug('Finding redhat kernel version: %s', kver_cmd)
+        kver, _err = in_chroot.subp(kver_cmd, capture=True)
+        LOG.debug('Found kver=%s' % kver)
+        initramfs = '/boot/initramfs-%s.img' % kver
+        dracut_cmd = ['dracut', '-f', initramfs, kver]
+        LOG.debug('Rebuilding initramfs with: %s', dracut_cmd)
+        in_chroot.subp(dracut_cmd, capture=True)
 
-    if target is None:
-        sys.stderr.write("Unable to find target.  "
-                         "Use --target or set TARGET_MOUNT_POINT\n")
-        sys.exit(2)
 
-    cfg = config.load_command_config(args, state)
+def builtin_curthooks(cfg, target, state):
+    LOG.info('Running curtin builtin curthooks')
     stack_prefix = state.get('report_stack_prefix', '')
-
-    # if curtin-hooks hook exists in target we can defer to the in-target hooks
-    if util.run_hook_if_exists(target, 'curtin-hooks'):
-        # For vmtests to force execute centos_apply_network_config, uncomment
-        # the value in examples/tests/centos_defaults.yaml
-        if cfg.get('_ammend_centos_curthooks'):
-            if cfg.get('cloudconfig'):
-                handle_cloudconfig(
-                    cfg['cloudconfig'],
-                    base_dir=util.target_path(target, 'etc/cloud/cloud.cfg.d'))
-
-            if target_is_centos(target) or target_is_rhel(target):
-                LOG.info('Detected RHEL/CentOS image, running extra hooks')
-                with events.ReportEventStack(
-                        name=stack_prefix, reporting_enabled=True,
-                        level="INFO",
-                        description="Configuring CentOS for first boot"):
-                    centos_apply_network_config(cfg.get('network', {}), target)
-        sys.exit(0)
-
-    if target_is_ubuntu_core(target):
-        LOG.info('Detected Ubuntu-Core image, running hooks')
+    state_etcd = os.path.split(state['fstab'])[0]
+
+    distro_info = distro.get_distroinfo(target=target)
+    if not distro_info:
+        raise RuntimeError('Failed to determine target distro')
+    osfamily = distro_info.family
+    LOG.info('Configuring target system for distro: %s osfamily: %s',
+             distro_info.variant, osfamily)
+    if osfamily == DISTROS.debian:
         with events.ReportEventStack(
-                name=stack_prefix, reporting_enabled=True, level="INFO",
-                description="Configuring Ubuntu-Core for first boot"):
-            ubuntu_core_curthooks(cfg, target)
-        sys.exit(0)
-
-    with events.ReportEventStack(
-            name=stack_prefix + '/writing-config',
-            reporting_enabled=True, level="INFO",
-            description="configuring apt configuring apt"):
-        do_apt_config(cfg, target)
-        disable_overlayroot(cfg, target)
+                name=stack_prefix + '/writing-apt-config',
+                reporting_enabled=True, level="INFO",
+                description="configuring apt configuring apt"):
+            do_apt_config(cfg, target)
+            disable_overlayroot(cfg, target)
 
-    # LP: #1742560 prevent zfs-dkms from being installed (Xenial)
-    if util.lsb_release(target=target)['codename'] == 'xenial':
-        util.apt_update(target=target)
-        with util.ChrootableTarget(target) as in_chroot:
-            in_chroot.subp(['apt-mark', 'hold', 'zfs-dkms'])
+        # LP: #1742560 prevent zfs-dkms from being installed (Xenial)
+        if distro.lsb_release(target=target)['codename'] == 'xenial':
+            distro.apt_update(target=target)
+            with util.ChrootableTarget(target) as in_chroot:
+                in_chroot.subp(['apt-mark', 'hold', 'zfs-dkms'])
 
     # packages may be needed prior to installing kernel
     with events.ReportEventStack(
             name=stack_prefix + '/installing-missing-packages',
             reporting_enabled=True, level="INFO",
             description="installing missing packages"):
-        install_missing_packages(cfg, target)
+        install_missing_packages(cfg, target, osfamily=osfamily)
 
-    # If a /etc/iscsi/nodes/... file was created by block_meta then it
-    # needs to be copied onto the target system
-    nodes_location = os.path.join(os.path.split(state['fstab'])[0],
-                                  "nodes")
-    if os.path.exists(nodes_location):
-        copy_iscsi_conf(nodes_location, target)
-        # do we need to reconfigure open-iscsi?
-
-    # If a mdadm.conf file was created by block_meta than it needs to be copied
-    # onto the target system
-    mdadm_location = os.path.join(os.path.split(state['fstab'])[0],
-                                  "mdadm.conf")
-    if os.path.exists(mdadm_location):
-        copy_mdadm_conf(mdadm_location, target)
-        # as per https://bugs.launchpad.net/ubuntu/+source/mdadm/+bug/964052
-        # reconfigure mdadm
-        util.subp(['dpkg-reconfigure', '--frontend=noninteractive', 'mdadm'],
-                  data=None, target=target)
+    with events.ReportEventStack(
+            name=stack_prefix + '/configuring-iscsi-service',
+            reporting_enabled=True, level="INFO",
+            description="configuring iscsi service"):
+        configure_iscsi(cfg, state_etcd, target, osfamily=osfamily)
 
     with events.ReportEventStack(
-            name=stack_prefix + '/installing-kernel',
+            name=stack_prefix + '/configuring-mdadm-service',
             reporting_enabled=True, level="INFO",
-            description="installing kernel"):
-        setup_zipl(cfg, target)
-        install_kernel(cfg, target)
-        run_zipl(cfg, target)
-        restore_dist_interfaces(cfg, target)
+            description="configuring raid (mdadm) service"):
+        configure_mdadm(cfg, state_etcd, target, osfamily=osfamily)
+
+    if osfamily == DISTROS.debian:
+        with events.ReportEventStack(
+                name=stack_prefix + '/installing-kernel',
+                reporting_enabled=True, level="INFO",
+                description="installing kernel"):
+            setup_zipl(cfg, target)
+            install_kernel(cfg, target)
+            run_zipl(cfg, target)
+            restore_dist_interfaces(cfg, target)
 
     with events.ReportEventStack(
             name=stack_prefix + '/setting-up-swap',
@@ -1047,6 +1166,23 @@ def curthooks(args):
             description="setting up swap"):
         add_swap(cfg, target, state.get('fstab'))
 
+    if osfamily == DISTROS.redhat:
+        # set cloud-init maas datasource for centos images
+        if cfg.get('cloudconfig'):
+            handle_cloudconfig(
+                cfg['cloudconfig'],
+                base_dir=paths.target_path(target,
+                                           'etc/cloud/cloud.cfg.d'))
+
+        # For vmtests to force execute redhat_upgrade_cloud_init, uncomment
+        # the value in examples/tests/centos_defaults.yaml
+        if cfg.get('_ammend_centos_curthooks'):
+            with events.ReportEventStack(
+                    name=stack_prefix + '/upgrading cloud-init',
+                    reporting_enabled=True, level="INFO",
+                    description="Upgrading cloud-init in target"):
+                redhat_upgrade_cloud_init(cfg.get('network', {}), target)
+
     with events.ReportEventStack(
             name=stack_prefix + '/apply-networking-config',
             reporting_enabled=True, level="INFO",
@@ -1063,29 +1199,44 @@ def curthooks(args):
             name=stack_prefix + '/configuring-multipath',
             reporting_enabled=True, level="INFO",
             description="configuring multipath"):
-        detect_and_handle_multipath(cfg, target)
+        detect_and_handle_multipath(cfg, target, osfamily=osfamily)
 
     with events.ReportEventStack(
             name=stack_prefix + '/system-upgrade',
             reporting_enabled=True, level="INFO",
             description="updating packages on target system"):
-        system_upgrade(cfg, target)
+        system_upgrade(cfg, target, osfamily=osfamily)
+
+    if osfamily == DISTROS.redhat:
+        with events.ReportEventStack(
+                name=stack_prefix + '/enabling-selinux-autorelabel',
+                reporting_enabled=True, level="INFO",
+                description="enabling selinux autorelabel mode"):
+            redhat_apply_selinux_autorelabel(target)
+
+        with events.ReportEventStack(
+                name=stack_prefix + '/updating-initramfs-configuration',
+                reporting_enabled=True, level="INFO",
+                description="updating initramfs configuration"):
+            redhat_update_initramfs(target, cfg)
 
     with events.ReportEventStack(
             name=stack_prefix + '/pollinate-user-agent',
             reporting_enabled=True, level="INFO",
-            description="configuring pollinate user-agent on target system"):
+            description="configuring pollinate user-agent on target"):
         handle_pollinate_user_agent(cfg, target)
 
-    # If a crypttab file was created by block_meta than it needs to be copied
-    # onto the target system, and update_initramfs() needs to be run, so that
-    # the cryptsetup hooks are properly configured on the installed system and
-    # it will be able to open encrypted volumes at boot.
-    crypttab_location = os.path.join(os.path.split(state['fstab'])[0],
-                                     "crypttab")
-    if os.path.exists(crypttab_location):
-        copy_crypttab(crypttab_location, target)
-        update_initramfs(target)
+    if osfamily == DISTROS.debian:
+        # If a crypttab file was created by block_meta than it needs to be
+        # copied onto the target system, and update_initramfs() needs to be
+        # run, so that the cryptsetup hooks are properly configured on the
+        # installed system and it will be able to open encrypted volumes
+        # at boot.
+        crypttab_location = os.path.join(os.path.split(state['fstab'])[0],
+                                         "crypttab")
+        if os.path.exists(crypttab_location):
+            copy_crypttab(crypttab_location, target)
+            update_initramfs(target)
 
     # If udev dname rules were created, copy them to target
     udev_rules_d = os.path.join(state['scratch'], "rules.d")
@@ -1102,8 +1253,41 @@ def curthooks(args):
             machine.startswith('aarch64') and not util.is_uefi_bootable()):
         update_initramfs(target)
     else:
-        setup_grub(cfg, target)
+        setup_grub(cfg, target, osfamily=osfamily)
+
+
+def curthooks(args):
+    state = util.load_command_environment()
+
+    if args.target is not None:
+        target = args.target
+    else:
+        target = state['target']
+
+    if target is None:
+        sys.stderr.write("Unable to find target.  "
+                         "Use --target or set TARGET_MOUNT_POINT\n")
+        sys.exit(2)
+
+    cfg = config.load_command_config(args, state)
+    stack_prefix = state.get('report_stack_prefix', '')
+    curthooks_mode = cfg.get('curthooks', {}).get('mode', 'auto')
+
+    # UC is special, handle it first.
+    if distro.is_ubuntu_core(target):
+        LOG.info('Detected Ubuntu-Core image, running hooks')
+        with events.ReportEventStack(
+                name=stack_prefix, reporting_enabled=True, level="INFO",
+                description="Configuring Ubuntu-Core for first boot"):
+            ubuntu_core_curthooks(cfg, target)
+        sys.exit(0)
+
+    # user asked for target, or auto mode
+    if curthooks_mode in ['auto', 'target']:
+        if util.run_hook_if_exists(target, 'curtin-hooks'):
+            sys.exit(0)
 
+    builtin_curthooks(cfg, target, state)
     sys.exit(0)
 
 
diff --git a/curtin/commands/in_target.py b/curtin/commands/in_target.py
index 8e839c0..c6f7abd 100644
--- a/curtin/commands/in_target.py
+++ b/curtin/commands/in_target.py
@@ -4,7 +4,7 @@ import os
 import pty
 import sys
 
-from curtin import util
+from curtin import paths, util
 
 from . import populate_one_subcmd
 
@@ -41,7 +41,7 @@ def in_target_main(args):
         sys.exit(2)
 
     daemons = args.allow_daemons
-    if util.target_path(args.target) == "/":
+    if paths.target_path(args.target) == "/":
         sys.stderr.write("WARN: Target is /, daemons are allowed.\n")
         daemons = True
     cmd = args.command_args
diff --git a/curtin/commands/install.py b/curtin/commands/install.py
index 4d2a13f..244683c 100644
--- a/curtin/commands/install.py
+++ b/curtin/commands/install.py
@@ -13,7 +13,9 @@ import tempfile
 
 from curtin.block import iscsi
 from curtin import config
+from curtin import distro
 from curtin import util
+from curtin import paths
 from curtin import version
 from curtin.log import LOG, logged_time
 from curtin.reporter.legacy import load_reporter
@@ -80,7 +82,7 @@ def copy_install_log(logfile, target, log_target_path):
     LOG.debug('Copying curtin install log from %s to target/%s',
               logfile, log_target_path)
     util.write_file(
-        filename=util.target_path(target, log_target_path),
+        filename=paths.target_path(target, log_target_path),
         content=util.load_file(logfile, decode=False),
         mode=0o400, omode="wb")
 
@@ -319,7 +321,7 @@ def apply_kexec(kexec, target):
         raise TypeError("kexec is not a dict.")
 
     if not util.which('kexec'):
-        util.install_packages('kexec-tools')
+        distro.install_packages('kexec-tools')
 
     if not os.path.isfile(target_grubcfg):
         raise ValueError("%s does not exist in target" % grubcfg)
diff --git a/curtin/commands/system_install.py b/curtin/commands/system_install.py
index 05d70af..6d7b736 100644
--- a/curtin/commands/system_install.py
+++ b/curtin/commands/system_install.py
@@ -7,6 +7,7 @@ import curtin.util as util
 
 from . import populate_one_subcmd
 from curtin.log import LOG
+from curtin import distro
 
 
 def system_install_pkgs_main(args):
@@ -16,7 +17,7 @@ def system_install_pkgs_main(args):
 
     exit_code = 0
     try:
-        util.install_packages(
+        distro.install_packages(
             pkglist=args.packages, target=args.target,
             allow_daemons=args.allow_daemons)
     except util.ProcessExecutionError as e:
diff --git a/curtin/commands/system_upgrade.py b/curtin/commands/system_upgrade.py
index fe10fac..d4f6735 100644
--- a/curtin/commands/system_upgrade.py
+++ b/curtin/commands/system_upgrade.py
@@ -7,6 +7,7 @@ import curtin.util as util
 
 from . import populate_one_subcmd
 from curtin.log import LOG
+from curtin import distro
 
 
 def system_upgrade_main(args):
@@ -16,8 +17,8 @@ def system_upgrade_main(args):
 
     exit_code = 0
     try:
-        util.system_upgrade(target=args.target,
-                            allow_daemons=args.allow_daemons)
+        distro.system_upgrade(target=args.target,
+                              allow_daemons=args.allow_daemons)
     except util.ProcessExecutionError as e:
         LOG.warn("system upgrade failed: %s" % e)
         exit_code = e.exit_code
diff --git a/curtin/deps/__init__.py b/curtin/deps/__init__.py
index 7014895..96df4f6 100644
--- a/curtin/deps/__init__.py
+++ b/curtin/deps/__init__.py
@@ -6,13 +6,13 @@ import sys
 from curtin.util import (
     ProcessExecutionError,
     get_architecture,
-    install_packages,
     is_uefi_bootable,
-    lsb_release,
     subp,
     which,
 )
 
+from curtin.distro import install_packages, lsb_release
+
 REQUIRED_IMPORTS = [
     # import string to execute, python2 package, python3 package
     ('import yaml', 'python-yaml', 'python3-yaml'),
@@ -177,7 +177,7 @@ def install_deps(verbosity=False, dry_run=False, allow_daemons=True):
     ret = 0
     try:
         install_packages(missing_pkgs, allow_daemons=allow_daemons,
-                         aptopts=["--no-install-recommends"])
+                         opts=["--no-install-recommends"])
     except ProcessExecutionError as e:
         sys.stderr.write("%s\n" % e)
         ret = e.exit_code
diff --git a/curtin/distro.py b/curtin/distro.py
new file mode 100644
index 0000000..f2a78ed
--- /dev/null
+++ b/curtin/distro.py
@@ -0,0 +1,512 @@
+# This file is part of curtin. See LICENSE file for copyright and license info.
+import glob
+from collections import namedtuple
+import os
+import re
+import shutil
+import tempfile
+
+from .paths import target_path
+from .util import (
+    ChrootableTarget,
+    find_newer,
+    load_file,
+    load_shell_content,
+    ProcessExecutionError,
+    set_unexecutable,
+    string_types,
+    subp,
+    which
+)
+from .log import LOG
+
+DistroInfo = namedtuple('DistroInfo', ('variant', 'family'))
+DISTRO_NAMES = ['arch', 'centos', 'debian', 'fedora', 'freebsd', 'gentoo',
+                'opensuse', 'redhat', 'rhel', 'sles', 'suse', 'ubuntu']
+
+
+# python2.7 lacks  PEP 435, so we must make use an alternative for py2.7/3.x
+# https://stackoverflow.com/questions/36932/how-can-i-represent-an-enum-in-python
+def distro_enum(*distros):
+    return namedtuple('Distros', distros)(*distros)
+
+
+DISTROS = distro_enum(*DISTRO_NAMES)
+
+OS_FAMILIES = {
+    DISTROS.debian: [DISTROS.debian, DISTROS.ubuntu],
+    DISTROS.redhat: [DISTROS.centos, DISTROS.fedora, DISTROS.redhat,
+                     DISTROS.rhel],
+    DISTROS.gentoo: [DISTROS.gentoo],
+    DISTROS.freebsd: [DISTROS.freebsd],
+    DISTROS.suse: [DISTROS.opensuse, DISTROS.sles, DISTROS.suse],
+    DISTROS.arch: [DISTROS.arch],
+}
+
+# invert the mapping for faster lookup of variants
+DISTRO_TO_OSFAMILY = (
+    {variant: family for family, variants in OS_FAMILIES.items()
+     for variant in variants})
+
+_LSB_RELEASE = {}
+
+
+def name_to_distro(distname):
+    try:
+        return DISTROS[DISTROS.index(distname)]
+    except (IndexError, AttributeError):
+        LOG.error('Unknown distro name: %s', distname)
+
+
+def lsb_release(target=None):
+    if target_path(target) != "/":
+        # do not use or update cache if target is provided
+        return _lsb_release(target)
+
+    global _LSB_RELEASE
+    if not _LSB_RELEASE:
+        data = _lsb_release()
+        _LSB_RELEASE.update(data)
+    return _LSB_RELEASE
+
+
+def os_release(target=None):
+    data = {}
+    os_release = target_path(target, 'etc/os-release')
+    if os.path.exists(os_release):
+        data = load_shell_content(load_file(os_release),
+                                  add_empty=False, empty_val=None)
+    if not data:
+        for relfile in [target_path(target, rel) for rel in
+                        ['etc/centos-release', 'etc/redhat-release']]:
+            data = _parse_redhat_release(release_file=relfile, target=target)
+            if data:
+                break
+
+    return data
+
+
+def _parse_redhat_release(release_file=None, target=None):
+    """Return a dictionary of distro info fields from /etc/redhat-release.
+
+    Dict keys will align with /etc/os-release keys:
+        ID, VERSION_ID, VERSION_CODENAME
+    """
+
+    if not release_file:
+        release_file = target_path('etc/redhat-release')
+    if not os.path.exists(release_file):
+        return {}
+    redhat_release = load_file(release_file)
+    redhat_regex = (
+        r'(?P<name>.+) release (?P<version>[\d\.]+) '
+        r'\((?P<codename>[^)]+)\)')
+    match = re.match(redhat_regex, redhat_release)
+    if match:
+        group = match.groupdict()
+        group['name'] = group['name'].lower().partition(' linux')[0]
+        if group['name'] == 'red hat enterprise':
+            group['name'] = 'redhat'
+        return {'ID': group['name'], 'VERSION_ID': group['version'],
+                'VERSION_CODENAME': group['codename']}
+    return {}
+
+
+def get_distroinfo(target=None):
+    variant_name = os_release(target=target)['ID']
+    variant = name_to_distro(variant_name)
+    family = DISTRO_TO_OSFAMILY.get(variant)
+    return DistroInfo(variant, family)
+
+
+def get_distro(target=None):
+    distinfo = get_distroinfo(target=target)
+    return distinfo.variant
+
+
+def get_osfamily(target=None):
+    distinfo = get_distroinfo(target=target)
+    return distinfo.family
+
+
+def is_ubuntu_core(target=None):
+    """Check if Ubuntu-Core specific directory is present at target"""
+    return os.path.exists(target_path(target, 'system-data/var/lib/snapd'))
+
+
+def is_centos(target=None):
+    """Check if CentOS specific file is present at target"""
+    return os.path.exists(target_path(target, 'etc/centos-release'))
+
+
+def is_rhel(target=None):
+    """Check if RHEL specific file is present at target"""
+    return os.path.exists(target_path(target, 'etc/redhat-release'))
+
+
+def _lsb_release(target=None):
+    fmap = {'Codename': 'codename', 'Description': 'description',
+            'Distributor ID': 'id', 'Release': 'release'}
+
+    data = {}
+    try:
+        out, _ = subp(['lsb_release', '--all'], capture=True, target=target)
+        for line in out.splitlines():
+            fname, _, val = line.partition(":")
+            if fname in fmap:
+                data[fmap[fname]] = val.strip()
+        missing = [k for k in fmap.values() if k not in data]
+        if len(missing):
+            LOG.warn("Missing fields in lsb_release --all output: %s",
+                     ','.join(missing))
+
+    except ProcessExecutionError as err:
+        LOG.warn("Unable to get lsb_release --all: %s", err)
+        data = {v: "UNAVAILABLE" for v in fmap.values()}
+
+    return data
+
+
+def apt_update(target=None, env=None, force=False, comment=None,
+               retries=None):
+
+    marker = "tmp/curtin.aptupdate"
+
+    if env is None:
+        env = os.environ.copy()
+
+    if retries is None:
+        # by default run apt-update up to 3 times to allow
+        # for transient failures
+        retries = (1, 2, 3)
+
+    if comment is None:
+        comment = "no comment provided"
+
+    if comment.endswith("\n"):
+        comment = comment[:-1]
+
+    marker = target_path(target, marker)
+    # if marker exists, check if there are files that would make it obsolete
+    listfiles = [target_path(target, "/etc/apt/sources.list")]
+    listfiles += glob.glob(
+        target_path(target, "etc/apt/sources.list.d/*.list"))
+
+    if os.path.exists(marker) and not force:
+        if len(find_newer(marker, listfiles)) == 0:
+            return
+
+    restore_perms = []
+
+    abs_tmpdir = tempfile.mkdtemp(dir=target_path(target, "/tmp"))
+    try:
+        abs_slist = abs_tmpdir + "/sources.list"
+        abs_slistd = abs_tmpdir + "/sources.list.d"
+        ch_tmpdir = "/tmp/" + os.path.basename(abs_tmpdir)
+        ch_slist = ch_tmpdir + "/sources.list"
+        ch_slistd = ch_tmpdir + "/sources.list.d"
+
+        # this file gets executed on apt-get update sometimes. (LP: #1527710)
+        motd_update = target_path(
+            target, "/usr/lib/update-notifier/update-motd-updates-available")
+        pmode = set_unexecutable(motd_update)
+        if pmode is not None:
+            restore_perms.append((motd_update, pmode),)
+
+        # create tmpdir/sources.list with all lines other than deb-src
+        # avoid apt complaining by using existing and empty dir for sourceparts
+        os.mkdir(abs_slistd)
+        with open(abs_slist, "w") as sfp:
+            for sfile in listfiles:
+                with open(sfile, "r") as fp:
+                    contents = fp.read()
+                for line in contents.splitlines():
+                    line = line.lstrip()
+                    if not line.startswith("deb-src"):
+                        sfp.write(line + "\n")
+
+        update_cmd = [
+            'apt-get', '--quiet',
+            '--option=Acquire::Languages=none',
+            '--option=Dir::Etc::sourcelist=%s' % ch_slist,
+            '--option=Dir::Etc::sourceparts=%s' % ch_slistd,
+            'update']
+
+        # do not using 'run_apt_command' so we can use 'retries' to subp
+        with ChrootableTarget(target, allow_daemons=True) as inchroot:
+            inchroot.subp(update_cmd, env=env, retries=retries)
+    finally:
+        for fname, perms in restore_perms:
+            os.chmod(fname, perms)
+        if abs_tmpdir:
+            shutil.rmtree(abs_tmpdir)
+
+    with open(marker, "w") as fp:
+        fp.write(comment + "\n")
+
+
+def run_apt_command(mode, args=None, opts=None, env=None, target=None,
+                    execute=True, allow_daemons=False):
+    defopts = ['--quiet', '--assume-yes',
+               '--option=Dpkg::options::=--force-unsafe-io',
+               '--option=Dpkg::Options::=--force-confold']
+    if args is None:
+        args = []
+
+    if opts is None:
+        opts = []
+
+    if env is None:
+        env = os.environ.copy()
+        env['DEBIAN_FRONTEND'] = 'noninteractive'
+
+    if which('eatmydata', target=target):
+        emd = ['eatmydata']
+    else:
+        emd = []
+
+    cmd = emd + ['apt-get'] + defopts + opts + [mode] + args
+    if not execute:
+        return env, cmd
+
+    apt_update(target, env=env, comment=' '.join(cmd))
+    with ChrootableTarget(target, allow_daemons=allow_daemons) as inchroot:
+        return inchroot.subp(cmd, env=env)
+
+
+def run_yum_command(mode, args=None, opts=None, env=None, target=None,
+                    execute=True, allow_daemons=False):
+    defopts = ['--assumeyes', '--quiet']
+
+    if args is None:
+        args = []
+
+    if opts is None:
+        opts = []
+
+    cmd = ['yum'] + defopts + opts + [mode] + args
+    if not execute:
+        return env, cmd
+
+    if mode in ["install", "update", "upgrade"]:
+        return yum_install(mode, args, opts=opts, env=env, target=target,
+                           allow_daemons=allow_daemons)
+
+    with ChrootableTarget(target, allow_daemons=allow_daemons) as inchroot:
+        return inchroot.subp(cmd, env=env)
+
+
+def yum_install(mode, packages=None, opts=None, env=None, target=None,
+                allow_daemons=False):
+
+    defopts = ['--assumeyes', '--quiet']
+
+    if packages is None:
+        packages = []
+
+    if opts is None:
+        opts = []
+
+    if mode not in ['install', 'update', 'upgrade']:
+        raise ValueError(
+            'Unsupported mode "%s" for yum package install/upgrade' % mode)
+
+    # download first, then install/upgrade from cache
+    cmd = ['yum'] + defopts + opts + [mode]
+    dl_opts = ['--downloadonly', '--setopt=keepcache=1']
+    inst_opts = ['--cacheonly']
+
+    # rpm requires /dev /sys and /proc be mounted, use ChrootableTarget
+    with ChrootableTarget(target, allow_daemons=allow_daemons) as inchroot:
+        inchroot.subp(cmd + dl_opts + packages,
+                      env=env, retries=[1] * 10)
+        return inchroot.subp(cmd + inst_opts + packages, env=env)
+
+
+def rpm_get_dist_id(target=None):
+    """Use rpm command to extract the '%rhel' distro macro which returns
+       the major os version id (6, 7, 8).  This works for centos or rhel
+    """
+    with ChrootableTarget(target) as in_chroot:
+        dist, _ = in_chroot.subp(['rpm', '-E', '%rhel'], capture=True)
+    return dist.rstrip()
+
+
+def system_upgrade(opts=None, target=None, env=None, allow_daemons=False,
+                   osfamily=None):
+    LOG.debug("Upgrading system in %s", target)
+
+    distro_cfg = {
+        DISTROS.debian: {'function': 'run_apt_command',
+                         'subcommands': ('dist-upgrade', 'autoremove')},
+        DISTROS.redhat: {'function': 'run_yum_command',
+                         'subcommands': ('upgrade')},
+    }
+    if osfamily not in distro_cfg:
+        raise ValueError('Distro "%s" does not have system_upgrade support',
+                         osfamily)
+
+    for mode in distro_cfg[osfamily]['subcommands']:
+        ret = distro_cfg[osfamily]['function'](
+                mode, opts=opts, target=target,
+                env=env, allow_daemons=allow_daemons)
+    return ret
+
+
+def install_packages(pkglist, osfamily=None, opts=None, target=None, env=None,
+                     allow_daemons=False):
+    if isinstance(pkglist, str):
+        pkglist = [pkglist]
+
+    if not osfamily:
+        osfamily = get_osfamily(target=target)
+
+    installer_map = {
+        DISTROS.debian: run_apt_command,
+        DISTROS.redhat: run_yum_command,
+    }
+
+    install_cmd = installer_map.get(osfamily)
+    if not install_cmd:
+        raise ValueError('No packge install command for distro: %s' %
+                         osfamily)
+
+    return install_cmd('install', args=pkglist, opts=opts, target=target,
+                       env=env, allow_daemons=allow_daemons)
+
+
+def has_pkg_available(pkg, target=None, osfamily=None):
+    if not osfamily:
+        osfamily = get_osfamily(target=target)
+
+    if osfamily not in [DISTROS.debian, DISTROS.redhat]:
+        raise ValueError('has_pkg_available: unsupported distro family: %s',
+                         osfamily)
+
+    if osfamily == DISTROS.debian:
+        out, _ = subp(['apt-cache', 'pkgnames'], capture=True, target=target)
+        for item in out.splitlines():
+            if pkg == item.strip():
+                return True
+        return False
+
+    if osfamily == DISTROS.redhat:
+        out, _ = run_yum_command('list', opts=['--cacheonly'])
+        for item in out.splitlines():
+            if item.lower().startswith(pkg.lower()):
+                return True
+        return False
+
+
+def get_installed_packages(target=None):
+    if which('dpkg-query', target=target):
+        (out, _) = subp(['dpkg-query', '--list'], target=target, capture=True)
+    elif which('rpm', target=target):
+        # rpm requires /dev /sys and /proc be mounted, use ChrootableTarget
+        with ChrootableTarget(target) as in_chroot:
+            (out, _) = in_chroot.subp(['rpm', '-qa', '--queryformat',
+                                       'ii %{NAME} %{VERSION}-%{RELEASE}\n'],
+                                      target=target, capture=True)
+    if not out:
+        raise ValueError('No package query tool')
+
+    pkgs_inst = set()
+    for line in out.splitlines():
+        try:
+            (state, pkg, other) = line.split(None, 2)
+        except ValueError:
+            continue
+        if state.startswith("hi") or state.startswith("ii"):
+            pkgs_inst.add(re.sub(":.*", "", pkg))
+
+    return pkgs_inst
+
+
+def has_pkg_installed(pkg, target=None):
+    try:
+        out, _ = subp(['dpkg-query', '--show', '--showformat',
+                       '${db:Status-Abbrev}', pkg],
+                      capture=True, target=target)
+        return out.rstrip() == "ii"
+    except ProcessExecutionError:
+        return False
+
+
+def parse_dpkg_version(raw, name=None, semx=None):
+    """Parse a dpkg version string into various parts and calcualate a
+       numerical value of the version for use in comparing package versions
+
+       Native packages (without a '-'), will have the package version treated
+       as the upstream version.
+
+       returns a dictionary with fields:
+          'major' (int), 'minor' (int), 'micro' (int),
+          'semantic_version' (int),
+          'extra' (string), 'raw' (string), 'upstream' (string),
+          'name' (present only if name is not None)
+    """
+    if not isinstance(raw, string_types):
+        raise TypeError(
+            "Invalid type %s for parse_dpkg_version" % raw.__class__)
+
+    if semx is None:
+        semx = (10000, 100, 1)
+
+    if "-" in raw:
+        upstream = raw.rsplit('-', 1)[0]
+    else:
+        # this is a native package, package version treated as upstream.
+        upstream = raw
+
+    match = re.search(r'[^0-9.]', upstream)
+    if match:
+        extra = upstream[match.start():]
+        upstream_base = upstream[:match.start()]
+    else:
+        upstream_base = upstream
+        extra = None
+
+    toks = upstream_base.split(".", 2)
+    if len(toks) == 3:
+        major, minor, micro = toks
+    elif len(toks) == 2:
+        major, minor, micro = (toks[0], toks[1], 0)
+    elif len(toks) == 1:
+        major, minor, micro = (toks[0], 0, 0)
+
+    version = {
+        'major': int(major),
+        'minor': int(minor),
+        'micro': int(micro),
+        'extra': extra,
+        'raw': raw,
+        'upstream': upstream,
+    }
+    if name:
+        version['name'] = name
+
+    if semx:
+        try:
+            version['semantic_version'] = int(
+                int(major) * semx[0] + int(minor) * semx[1] +
+                int(micro) * semx[2])
+        except (ValueError, IndexError):
+            version['semantic_version'] = None
+
+    return version
+
+
+def get_package_version(pkg, target=None, semx=None):
+    """Use dpkg-query to extract package pkg's version string
+       and parse the version string into a dictionary
+    """
+    try:
+        out, _ = subp(['dpkg-query', '--show', '--showformat',
+                       '${Version}', pkg], capture=True, target=target)
+        raw = out.rstrip()
+        return parse_dpkg_version(raw, name=pkg, semx=semx)
+    except ProcessExecutionError:
+        return None
+
+
+# vi: ts=4 expandtab syntax=python
diff --git a/curtin/futil.py b/curtin/futil.py
index 506964e..e603f88 100644
--- a/curtin/futil.py
+++ b/curtin/futil.py
@@ -5,7 +5,8 @@ import pwd
 import os
 import warnings
 
-from .util import write_file, target_path
+from .util import write_file
+from .paths import target_path
 from .log import LOG
 
 
diff --git a/curtin/net/__init__.py b/curtin/net/__init__.py
index b4c9b59..ef2ba26 100644
--- a/curtin/net/__init__.py
+++ b/curtin/net/__init__.py
@@ -572,63 +572,4 @@ def get_interface_mac(ifname):
     return read_sys_net(ifname, "address", enoent=False)
 
 
-def network_config_required_packages(network_config, mapping=None):
-
-    if network_config is None:
-        network_config = {}
-
-    if not isinstance(network_config, dict):
-        raise ValueError('Invalid network configuration.  Must be a dict')
-
-    if mapping is None:
-        mapping = {}
-
-    if not isinstance(mapping, dict):
-        raise ValueError('Invalid network mapping.  Must be a dict')
-
-    # allow top-level 'network' key
-    if 'network' in network_config:
-        network_config = network_config.get('network')
-
-    # v1 has 'config' key and uses type: devtype elements
-    if 'config' in network_config:
-        dev_configs = set(device['type']
-                          for device in network_config['config'])
-    else:
-        # v2 has no config key
-        dev_configs = set(cfgtype for (cfgtype, cfg) in
-                          network_config.items() if cfgtype not in ['version'])
-
-    needed_packages = []
-    for dev_type in dev_configs:
-        if dev_type in mapping:
-            needed_packages.extend(mapping[dev_type])
-
-    return needed_packages
-
-
-def detect_required_packages_mapping():
-    """Return a dictionary providing a versioned configuration which maps
-       network configuration elements to the packages which are required
-       for functionality.
-    """
-    mapping = {
-        1: {
-            'handler': network_config_required_packages,
-            'mapping': {
-                'bond': ['ifenslave'],
-                'bridge': ['bridge-utils'],
-                'vlan': ['vlan']},
-        },
-        2: {
-            'handler': network_config_required_packages,
-            'mapping': {
-                'bonds': ['ifenslave'],
-                'bridges': ['bridge-utils'],
-                'vlans': ['vlan']}
-        },
-    }
-
-    return mapping
-
 # vi: ts=4 expandtab syntax=python
diff --git a/curtin/net/deps.py b/curtin/net/deps.py
new file mode 100644
index 0000000..b98961d
--- /dev/null
+++ b/curtin/net/deps.py
@@ -0,0 +1,72 @@
+# This file is part of curtin. See LICENSE file for copyright and license info.
+
+from curtin.distro import DISTROS
+
+
+def network_config_required_packages(network_config, mapping=None):
+
+    if network_config is None:
+        network_config = {}
+
+    if not isinstance(network_config, dict):
+        raise ValueError('Invalid network configuration.  Must be a dict')
+
+    if mapping is None:
+        mapping = {}
+
+    if not isinstance(mapping, dict):
+        raise ValueError('Invalid network mapping.  Must be a dict')
+
+    # allow top-level 'network' key
+    if 'network' in network_config:
+        network_config = network_config.get('network')
+
+    # v1 has 'config' key and uses type: devtype elements
+    if 'config' in network_config:
+        dev_configs = set(device['type']
+                          for device in network_config['config'])
+    else:
+        # v2 has no config key
+        dev_configs = set(cfgtype for (cfgtype, cfg) in
+                          network_config.items() if cfgtype not in ['version'])
+
+    needed_packages = []
+    for dev_type in dev_configs:
+        if dev_type in mapping:
+            needed_packages.extend(mapping[dev_type])
+
+    return needed_packages
+
+
+def detect_required_packages_mapping(osfamily=DISTROS.debian):
+    """Return a dictionary providing a versioned configuration which maps
+       network configuration elements to the packages which are required
+       for functionality.
+    """
+    # keys ending with 's' are v2 values
+    distro_mapping = {
+        DISTROS.debian: {
+            'bond': ['ifenslave'],
+            'bonds': [],
+            'bridge': ['bridge-utils'],
+            'bridges': [],
+            'vlan': ['vlan'],
+            'vlans': []},
+        DISTROS.redhat: {
+            'bond': [],
+            'bonds': [],
+            'bridge': [],
+            'bridges': [],
+            'vlan': [],
+            'vlans': []},
+    }
+    if osfamily not in distro_mapping:
+        raise ValueError('No net package mapping for distro: %s' % osfamily)
+
+    return {1: {'handler': network_config_required_packages,
+                'mapping': distro_mapping.get(osfamily)},
+            2: {'handler': network_config_required_packages,
+                'mapping': distro_mapping.get(osfamily)}}
+
+
+# vi: ts=4 expandtab syntax=python
diff --git a/curtin/paths.py b/curtin/paths.py
new file mode 100644
index 0000000..064b060
--- /dev/null
+++ b/curtin/paths.py
@@ -0,0 +1,34 @@
+# This file is part of curtin. See LICENSE file for copyright and license info.
+import os
+
+try:
+    string_types = (basestring,)
+except NameError:
+    string_types = (str,)
+
+
+def target_path(target, path=None):
+    # return 'path' inside target, accepting target as None
+    if target in (None, ""):
+        target = "/"
+    elif not isinstance(target, string_types):
+        raise ValueError("Unexpected input for target: %s" % target)
+    else:
+        target = os.path.abspath(target)
+        # abspath("//") returns "//" specifically for 2 slashes.
+        if target.startswith("//"):
+            target = target[1:]
+
+    if not path:
+        return target
+
+    if not isinstance(path, string_types):
+        raise ValueError("Unexpected input for path: %s" % path)
+
+    # os.path.join("/etc", "/foo") returns "/foo". Chomp all leading /.
+    while len(path) and path[0] == "/":
+        path = path[1:]
+
+    return os.path.join(target, path)
+
+# vi: ts=4 expandtab syntax=python
diff --git a/curtin/util.py b/curtin/util.py
index 29bf06e..238d7c5 100644
--- a/curtin/util.py
+++ b/curtin/util.py
@@ -4,7 +4,6 @@ import argparse
 import collections
 from contextlib import contextmanager
 import errno
-import glob
 import json
 import os
 import platform
@@ -38,15 +37,16 @@ except NameError:
     # python3 does not have a long type.
     numeric_types = (int, float)
 
+from . import paths
 from .log import LOG, log_call
 
 _INSTALLED_HELPERS_PATH = 'usr/lib/curtin/helpers'
 _INSTALLED_MAIN = 'usr/bin/curtin'
 
-_LSB_RELEASE = {}
 _USES_SYSTEMD = None
 _HAS_UNSHARE_PID = None
 
+
 _DNS_REDIRECT_IP = None
 
 # matcher used in template rendering functions
@@ -61,7 +61,7 @@ def _subp(args, data=None, rcs=None, env=None, capture=False,
         rcs = [0]
     devnull_fp = None
 
-    tpath = target_path(target)
+    tpath = paths.target_path(target)
     chroot_args = [] if tpath == "/" else ['chroot', target]
     sh_args = ['sh', '-c'] if shell else []
     if isinstance(args, string_types):
@@ -165,7 +165,7 @@ def _get_unshare_pid_args(unshare_pid=None, target=None, euid=None):
     if euid is None:
         euid = os.geteuid()
 
-    tpath = target_path(target)
+    tpath = paths.target_path(target)
 
     unshare_pid_in = unshare_pid
     if unshare_pid is None:
@@ -595,7 +595,7 @@ def disable_daemons_in_root(target):
          'done',
          ''])
 
-    fpath = target_path(target, "/usr/sbin/policy-rc.d")
+    fpath = paths.target_path(target, "/usr/sbin/policy-rc.d")
 
     if os.path.isfile(fpath):
         return False
@@ -606,7 +606,7 @@ def disable_daemons_in_root(target):
 
 def undisable_daemons_in_root(target):
     try:
-        os.unlink(target_path(target, "/usr/sbin/policy-rc.d"))
+        os.unlink(paths.target_path(target, "/usr/sbin/policy-rc.d"))
     except OSError as e:
         if e.errno != errno.ENOENT:
             raise
@@ -618,7 +618,7 @@ class ChrootableTarget(object):
     def __init__(self, target, allow_daemons=False, sys_resolvconf=True):
         if target is None:
             target = "/"
-        self.target = target_path(target)
+        self.target = paths.target_path(target)
         self.mounts = ["/dev", "/proc", "/sys"]
         self.umounts = []
         self.disabled_daemons = False
@@ -628,14 +628,14 @@ class ChrootableTarget(object):
 
     def __enter__(self):
         for p in self.mounts:
-            tpath = target_path(self.target, p)
+            tpath = paths.target_path(self.target, p)
             if do_mount(p, tpath, opts='--bind'):
                 self.umounts.append(tpath)
 
         if not self.allow_daemons:
             self.disabled_daemons = disable_daemons_in_root(self.target)
 
-        rconf = target_path(self.target, "/etc/resolv.conf")
+        rconf = paths.target_path(self.target, "/etc/resolv.conf")
         target_etc = os.path.dirname(rconf)
         if self.target != "/" and os.path.isdir(target_etc):
             # never muck with resolv.conf on /
@@ -660,13 +660,13 @@ class ChrootableTarget(object):
             undisable_daemons_in_root(self.target)
 
         # if /dev is to be unmounted, udevadm settle (LP: #1462139)
-        if target_path(self.target, "/dev") in self.umounts:
+        if paths.target_path(self.target, "/dev") in self.umounts:
             log_call(subp, ['udevadm', 'settle'])
 
         for p in reversed(self.umounts):
             do_umount(p)
 
-        rconf = target_path(self.target, "/etc/resolv.conf")
+        rconf = paths.target_path(self.target, "/etc/resolv.conf")
         if self.sys_resolvconf and self.rconf_d:
             os.rename(os.path.join(self.rconf_d, "resolv.conf"), rconf)
             shutil.rmtree(self.rconf_d)
@@ -676,7 +676,7 @@ class ChrootableTarget(object):
         return subp(*args, **kwargs)
 
     def path(self, path):
-        return target_path(self.target, path)
+        return paths.target_path(self.target, path)
 
 
 def is_exe(fpath):
@@ -685,29 +685,29 @@ def is_exe(fpath):
 
 
 def which(program, search=None, target=None):
-    target = target_path(target)
+    target = paths.target_path(target)
 
     if os.path.sep in program:
         # if program had a '/' in it, then do not search PATH
         # 'which' does consider cwd here. (cd / && which bin/ls) = bin/ls
         # so effectively we set cwd to / (or target)
-        if is_exe(target_path(target, program)):
+        if is_exe(paths.target_path(target, program)):
             return program
 
     if search is None:
-        paths = [p.strip('"') for p in
-                 os.environ.get("PATH", "").split(os.pathsep)]
+        candpaths = [p.strip('"') for p in
+                     os.environ.get("PATH", "").split(os.pathsep)]
         if target == "/":
-            search = paths
+            search = candpaths
         else:
-            search = [p for p in paths if p.startswith("/")]
+            search = [p for p in candpaths if p.startswith("/")]
 
     # normalize path input
     search = [os.path.abspath(p) for p in search]
 
     for path in search:
         ppath = os.path.sep.join((path, program))
-        if is_exe(target_path(target, ppath)):
+        if is_exe(paths.target_path(target, ppath)):
             return ppath
 
     return None
@@ -773,116 +773,6 @@ def get_architecture(target=None):
     return out.strip()
 
 
-def has_pkg_available(pkg, target=None):
-    out, _ = subp(['apt-cache', 'pkgnames'], capture=True, target=target)
-    for item in out.splitlines():
-        if pkg == item.strip():
-            return True
-    return False
-
-
-def get_installed_packages(target=None):
-    (out, _) = subp(['dpkg-query', '--list'], target=target, capture=True)
-
-    pkgs_inst = set()
-    for line in out.splitlines():
-        try:
-            (state, pkg, other) = line.split(None, 2)
-        except ValueError:
-            continue
-        if state.startswith("hi") or state.startswith("ii"):
-            pkgs_inst.add(re.sub(":.*", "", pkg))
-
-    return pkgs_inst
-
-
-def has_pkg_installed(pkg, target=None):
-    try:
-        out, _ = subp(['dpkg-query', '--show', '--showformat',
-                       '${db:Status-Abbrev}', pkg],
-                      capture=True, target=target)
-        return out.rstrip() == "ii"
-    except ProcessExecutionError:
-        return False
-
-
-def parse_dpkg_version(raw, name=None, semx=None):
-    """Parse a dpkg version string into various parts and calcualate a
-       numerical value of the version for use in comparing package versions
-
-       Native packages (without a '-'), will have the package version treated
-       as the upstream version.
-
-       returns a dictionary with fields:
-          'major' (int), 'minor' (int), 'micro' (int),
-          'semantic_version' (int),
-          'extra' (string), 'raw' (string), 'upstream' (string),
-          'name' (present only if name is not None)
-    """
-    if not isinstance(raw, string_types):
-        raise TypeError(
-            "Invalid type %s for parse_dpkg_version" % raw.__class__)
-
-    if semx is None:
-        semx = (10000, 100, 1)
-
-    if "-" in raw:
-        upstream = raw.rsplit('-', 1)[0]
-    else:
-        # this is a native package, package version treated as upstream.
-        upstream = raw
-
-    match = re.search(r'[^0-9.]', upstream)
-    if match:
-        extra = upstream[match.start():]
-        upstream_base = upstream[:match.start()]
-    else:
-        upstream_base = upstream
-        extra = None
-
-    toks = upstream_base.split(".", 2)
-    if len(toks) == 3:
-        major, minor, micro = toks
-    elif len(toks) == 2:
-        major, minor, micro = (toks[0], toks[1], 0)
-    elif len(toks) == 1:
-        major, minor, micro = (toks[0], 0, 0)
-
-    version = {
-        'major': int(major),
-        'minor': int(minor),
-        'micro': int(micro),
-        'extra': extra,
-        'raw': raw,
-        'upstream': upstream,
-    }
-    if name:
-        version['name'] = name
-
-    if semx:
-        try:
-            version['semantic_version'] = int(
-                int(major) * semx[0] + int(minor) * semx[1] +
-                int(micro) * semx[2])
-        except (ValueError, IndexError):
-            version['semantic_version'] = None
-
-    return version
-
-
-def get_package_version(pkg, target=None, semx=None):
-    """Use dpkg-query to extract package pkg's version string
-       and parse the version string into a dictionary
-    """
-    try:
-        out, _ = subp(['dpkg-query', '--show', '--showformat',
-                       '${Version}', pkg], capture=True, target=target)
-        raw = out.rstrip()
-        return parse_dpkg_version(raw, name=pkg, semx=semx)
-    except ProcessExecutionError:
-        return None
-
-
 def find_newer(src, files):
     mtime = os.stat(src).st_mtime
     return [f for f in files if
@@ -907,134 +797,6 @@ def set_unexecutable(fname, strict=False):
     return cur
 
 
-def apt_update(target=None, env=None, force=False, comment=None,
-               retries=None):
-
-    marker = "tmp/curtin.aptupdate"
-    if target is None:
-        target = "/"
-
-    if env is None:
-        env = os.environ.copy()
-
-    if retries is None:
-        # by default run apt-update up to 3 times to allow
-        # for transient failures
-        retries = (1, 2, 3)
-
-    if comment is None:
-        comment = "no comment provided"
-
-    if comment.endswith("\n"):
-        comment = comment[:-1]
-
-    marker = target_path(target, marker)
-    # if marker exists, check if there are files that would make it obsolete
-    listfiles = [target_path(target, "/etc/apt/sources.list")]
-    listfiles += glob.glob(
-        target_path(target, "etc/apt/sources.list.d/*.list"))
-
-    if os.path.exists(marker) and not force:
-        if len(find_newer(marker, listfiles)) == 0:
-            return
-
-    restore_perms = []
-
-    abs_tmpdir = tempfile.mkdtemp(dir=target_path(target, "/tmp"))
-    try:
-        abs_slist = abs_tmpdir + "/sources.list"
-        abs_slistd = abs_tmpdir + "/sources.list.d"
-        ch_tmpdir = "/tmp/" + os.path.basename(abs_tmpdir)
-        ch_slist = ch_tmpdir + "/sources.list"
-        ch_slistd = ch_tmpdir + "/sources.list.d"
-
-        # this file gets executed on apt-get update sometimes. (LP: #1527710)
-        motd_update = target_path(
-            target, "/usr/lib/update-notifier/update-motd-updates-available")
-        pmode = set_unexecutable(motd_update)
-        if pmode is not None:
-            restore_perms.append((motd_update, pmode),)
-
-        # create tmpdir/sources.list with all lines other than deb-src
-        # avoid apt complaining by using existing and empty dir for sourceparts
-        os.mkdir(abs_slistd)
-        with open(abs_slist, "w") as sfp:
-            for sfile in listfiles:
-                with open(sfile, "r") as fp:
-                    contents = fp.read()
-                for line in contents.splitlines():
-                    line = line.lstrip()
-                    if not line.startswith("deb-src"):
-                        sfp.write(line + "\n")
-
-        update_cmd = [
-            'apt-get', '--quiet',
-            '--option=Acquire::Languages=none',
-            '--option=Dir::Etc::sourcelist=%s' % ch_slist,
-            '--option=Dir::Etc::sourceparts=%s' % ch_slistd,
-            'update']
-
-        # do not using 'run_apt_command' so we can use 'retries' to subp
-        with ChrootableTarget(target, allow_daemons=True) as inchroot:
-            inchroot.subp(update_cmd, env=env, retries=retries)
-    finally:
-        for fname, perms in restore_perms:
-            os.chmod(fname, perms)
-        if abs_tmpdir:
-            shutil.rmtree(abs_tmpdir)
-
-    with open(marker, "w") as fp:
-        fp.write(comment + "\n")
-
-
-def run_apt_command(mode, args=None, aptopts=None, env=None, target=None,
-                    execute=True, allow_daemons=False):
-    opts = ['--quiet', '--assume-yes',
-            '--option=Dpkg::options::=--force-unsafe-io',
-            '--option=Dpkg::Options::=--force-confold']
-
-    if args is None:
-        args = []
-
-    if aptopts is None:
-        aptopts = []
-
-    if env is None:
-        env = os.environ.copy()
-        env['DEBIAN_FRONTEND'] = 'noninteractive'
-
-    if which('eatmydata', target=target):
-        emd = ['eatmydata']
-    else:
-        emd = []
-
-    cmd = emd + ['apt-get'] + opts + aptopts + [mode] + args
-    if not execute:
-        return env, cmd
-
-    apt_update(target, env=env, comment=' '.join(cmd))
-    with ChrootableTarget(target, allow_daemons=allow_daemons) as inchroot:
-        return inchroot.subp(cmd, env=env)
-
-
-def system_upgrade(aptopts=None, target=None, env=None, allow_daemons=False):
-    LOG.debug("Upgrading system in %s", target)
-    for mode in ('dist-upgrade', 'autoremove'):
-        ret = run_apt_command(
-            mode, aptopts=aptopts, target=target,
-            env=env, allow_daemons=allow_daemons)
-    return ret
-
-
-def install_packages(pkglist, aptopts=None, target=None, env=None,
-                     allow_daemons=False):
-    if isinstance(pkglist, str):
-        pkglist = [pkglist]
-    return run_apt_command(
-        'install', args=pkglist,
-        aptopts=aptopts, target=target, env=env, allow_daemons=allow_daemons)
-
-
 def is_uefi_bootable():
     return os.path.exists('/sys/firmware/efi') is True
 
@@ -1106,7 +868,7 @@ def run_hook_if_exists(target, hook):
     """
     Look for "hook" in "target" and run it
     """
-    target_hook = target_path(target, '/curtin/' + hook)
+    target_hook = paths.target_path(target, '/curtin/' + hook)
     if os.path.isfile(target_hook):
         LOG.debug("running %s" % target_hook)
         subp([target_hook])
@@ -1261,41 +1023,6 @@ def is_file_not_found_exc(exc):
             exc.errno in (errno.ENOENT, errno.EIO, errno.ENXIO))
 
 
-def _lsb_release(target=None):
-    fmap = {'Codename': 'codename', 'Description': 'description',
-            'Distributor ID': 'id', 'Release': 'release'}
-
-    data = {}
-    try:
-        out, _ = subp(['lsb_release', '--all'], capture=True, target=target)
-        for line in out.splitlines():
-            fname, _, val = line.partition(":")
-            if fname in fmap:
-                data[fmap[fname]] = val.strip()
-        missing = [k for k in fmap.values() if k not in data]
-        if len(missing):
-            LOG.warn("Missing fields in lsb_release --all output: %s",
-                     ','.join(missing))
-
-    except ProcessExecutionError as err:
-        LOG.warn("Unable to get lsb_release --all: %s", err)
-        data = {v: "UNAVAILABLE" for v in fmap.values()}
-
-    return data
-
-
-def lsb_release(target=None):
-    if target_path(target) != "/":
-        # do not use or update cache if target is provided
-        return _lsb_release(target)
-
-    global _LSB_RELEASE
-    if not _LSB_RELEASE:
-        data = _lsb_release()
-        _LSB_RELEASE.update(data)
-    return _LSB_RELEASE
-
-
 class MergedCmdAppend(argparse.Action):
     """This appends to a list in order of appearence both the option string
        and the value"""
@@ -1430,31 +1157,6 @@ def is_resolvable_url(url):
     return is_resolvable(urlparse(url).hostname)
 
 
-def target_path(target, path=None):
-    # return 'path' inside target, accepting target as None
-    if target in (None, ""):
-        target = "/"
-    elif not isinstance(target, string_types):
-        raise ValueError("Unexpected input for target: %s" % target)
-    else:
-        target = os.path.abspath(target)
-        # abspath("//") returns "//" specifically for 2 slashes.
-        if target.startswith("//"):
-            target = target[1:]
-
-    if not path:
-        return target
-
-    if not isinstance(path, string_types):
-        raise ValueError("Unexpected input for path: %s" % path)
-
-    # os.path.join("/etc", "/foo") returns "/foo". Chomp all leading /.
-    while len(path) and path[0] == "/":
-        path = path[1:]
-
-    return os.path.join(target, path)
-
-
 class RunInChroot(ChrootableTarget):
     """Backwards compatibility for RunInChroot (LP: #1617375).
     It needs to work like:
diff --git a/debian/changelog b/debian/changelog
index 7d08e65..6b03a20 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,10 @@
+curtin (18.1-52-g5f0082d1-0ubuntu1) cosmic; urgency=medium
+
+  * New upstream snapshot.
+    - Enable custom storage configuration for centos images
+
+ -- Ryan Harper <[e-mail]>  Fri, 21 Sep 2018 03:04:42 -0500
+
 curtin (18.1-51-gb812ae80-0ubuntu1) cosmic; urgency=medium
 
   * New upstream snapshot.
diff --git a/doc/topics/config.rst b/doc/topics/config.rst
index 76e520d..218bc17 100644
--- a/doc/topics/config.rst
+++ b/doc/topics/config.rst
@@ -14,6 +14,7 @@ Curtin's top level config keys are as follows:
 - apt_mirrors (``apt_mirrors``)
 - apt_proxy (``apt_proxy``)
 - block-meta (``block``)
+- curthooks (``curthooks``)
 - debconf_selections (``debconf_selections``)
 - disable_overlayroot (``disable_overlayroot``)
 - grub (``grub``)
@@ -110,6 +111,45 @@ Specify the filesystem label on the boot partition.
           label: my-boot-partition
 
 
+curthooks
+~~~~~~~~~
+Configure how Curtin determines what :ref:`curthooks` to run during the installation
+process.
+
+**mode**: *<['auto', 'builtin', 'target']>*
+
+The default mode is ``auto``.
+
+In ``auto`` mode, curtin will execute curthooks within the image if present.
+For images without curthooks inside, curtin will execute its built-in hooks.
+
+Currently the built-in curthooks support the following OS families:
+
+- Ubuntu
+- Centos
+
+When specifying ``builtin``, curtin will only run the curthooks present in
+Curtin ignoring any curthooks that may be present in the target operating
+system.
+
+When specifying ``target``, curtin will attempt run the curthooks in the target
+operating system.  If the target does NOT contain any curthooks, then the
+built-in curthooks will be run instead.
+
+Any errors during execution of curthooks (built-in or target) will fail the
+installation.
+
+**Example**::
+
+  # ignore any target curthooks
+  curthooks:
+    mode: builtin
+
+  # Only run target curthooks, fall back to built-in
+  curthooks:
+    mode: target
+
+
 debconf_selections
 ~~~~~~~~~~~~~~~~~~
 Curtin will update the target with debconf set-selection values.  Users will
diff --git a/doc/topics/curthooks.rst b/doc/topics/curthooks.rst
index e5f341b..c59aeaf 100644
--- a/doc/topics/curthooks.rst
+++ b/doc/topics/curthooks.rst
@@ -1,7 +1,13 @@
+.. _curthooks:
+
 ========================================
-Curthooks / New OS Support 
+Curthooks / New OS Support
 ========================================
-Curtin has built-in support for installation of Ubuntu.
+Curtin has built-in support for installation of:
+
+ - Ubuntu
+ - Centos
+
 Other operating systems are supported through a mechanism called
 'curthooks' or 'curtin-hooks'.
 
@@ -47,11 +53,21 @@ details.  Specifically interesting to this stage are:
  - ``CONFIG``: This is a path to the curtin config file.  It is provided so
    that additional configuration could be provided through to the OS
    customization.
+ - ``WORKING_DIR``: This is a path to a temporary directory where curtin
+   stores state and configuration files.
 
 .. **TODO**: We should add 'PYTHON' or 'CURTIN_PYTHON' to this environment
    so that the hook can easily run a python program with the same python
    that curtin ran with (ie, python2 or python3).
 
+Running built-in hooks
+----------------------
+
+Curthooks may opt to run the built-in curthooks that are already provided in
+curtin itself.  To do so, an in-image curthook can import the ``curthooks``
+module and invoke the ``builtin_curthooks`` function passing in the required
+parameters: config, target, and state.
+
 
 Networking configuration
 ------------------------
diff --git a/examples/tests/filesystem_battery.yaml b/examples/tests/filesystem_battery.yaml
index 3b1edbf..4eae5b6 100644
--- a/examples/tests/filesystem_battery.yaml
+++ b/examples/tests/filesystem_battery.yaml
@@ -113,8 +113,8 @@ storage:
     - id: bind1
       fstype: "none"
       options: "bind"
-      path: "/var/lib"
-      spec: "/my/bind-over-var-lib"
+      path: "/var/cache"
+      spec: "/my/bind-over-var-cache"
       type: mount
     - id: bind2
       fstype: "none"
diff --git a/helpers/common b/helpers/common
index ac2d0f3..f9217b7 100644
--- a/helpers/common
+++ b/helpers/common
@@ -541,18 +541,18 @@ get_carryover_params() {
 }
 
 install_grub() {
-    local long_opts="uefi,update-nvram"
+    local long_opts="uefi,update-nvram,os-family:"
     local getopt_out="" mp_efi=""
     getopt_out=$(getopt --name "${0##*/}" \
         --options "" --long "${long_opts}" -- "$@") &&
         eval set -- "${getopt_out}"
 
-    local uefi=0
-    local update_nvram=0
+    local uefi=0 update_nvram=0 os_family=""
 
     while [ $# -ne 0 ]; do
         cur="$1"; next="$2";
         case "$cur" in
+            --os-family) os_family=${next};;
             --uefi) uefi=$((${uefi}+1));;
             --update-nvram) update_nvram=$((${update_nvram}+1));;
             --) shift; break;;
@@ -595,29 +595,88 @@ install_grub() {
         error "$mp_dev ($fstype) is not a block device!"; return 1;
     fi
 
-    # get dpkg arch
-    local dpkg_arch=""
-    dpkg_arch=$(chroot "$mp" dpkg --print-architecture)
-    r=$?
+    local os_variant=""
+    if [ -e "${mp}/etc/os-release" ]; then
+        os_variant=$(chroot "$mp" \
+                     /bin/sh -c 'echo $(. /etc/os-release; echo $ID)')
+    else
+        # Centos6 doesn't have os-release, so check for centos/redhat release
+        # looks like: CentOS release 6.9 (Final)
+        for rel in $(ls ${mp}/etc/*-release); do
+            os_variant=$(awk '{print tolower($1)}' $rel)
+            [ -n "$os_variant" ] && break
+        done
+    fi
+    [ $? != 0 ] &&
+        { error "Failed to read ID from $mp/etc/os-release"; return 1; }
+
+    local rhel_ver=""
+    case $os_variant in
+        debian|ubuntu) os_family="debian";;
+        centos|rhel)
+            os_family="redhat"
+            rhel_ver=$(chroot "$mp" rpm -E '%rhel')
+        ;;
+    esac
+
+    # ensure we have both settings, family and variant are needed
+    [ -n "${os_variant}" -a -n "${os_family}" ] ||
+        { error "Failed to determine os variant and family"; return 1; }
+
+    # get target arch
+    local target_arch="" r="1"
+    case $os_family in
+        debian)
+            target_arch=$(chroot "$mp" dpkg --print-architecture)
+            r=$?
+            ;;
+        redhat)
+            target_arch=$(chroot "$mp" rpm -E '%_arch')
+            r=$?
+            ;;
+    esac
     [ $r -eq 0 ] || {
-        error "failed to get dpkg architecture [$r]"
+        error "failed to get target architecture [$r]"
         return 1;
     }
 
     # grub is not the bootloader you are looking for
-    if [ "${dpkg_arch}" = "s390x" ]; then
-	return 0;
+    if [ "${target_arch}" = "s390x" ]; then
+	    return 0;
     fi
 
     # set correct grub package
-    local grub_name="grub-pc"
-    local grub_target="i386-pc"
-    if [ "${dpkg_arch#ppc64}" != "${dpkg_arch}" ]; then
+    local grub_name=""
+    local grub_target=""
+    case "$target_arch" in
+        i386|amd64)
+            # debian
+            grub_name="grub-pc"
+            grub_target="i386-pc"
+            ;;
+        x86_64)
+            case $rhel_ver in
+               6) grub_name="grub";;
+               7) grub_name="grub2-pc";;
+               *)
+                   error "Unknown rhel_ver [$rhel_ver]";
+                   return 1;
+               ;;
+            esac
+            grub_target="i386-pc"
+            ;;
+    esac
+    if [ "${target_arch#ppc64}" != "${target_arch}" ]; then
         grub_name="grub-ieee1275"
         grub_target="powerpc-ieee1275"
     elif [ "$uefi" -ge 1 ]; then
-        grub_name="grub-efi-$dpkg_arch"
-        case "$dpkg_arch" in
+        grub_name="grub-efi-$target_arch"
+        case "$target_arch" in
+            x86_64)
+                # centos 7+, no centos6 support
+                grub_name="grub2-efi-x64-modules"
+                grub_target="x86_64-efi"
+                ;;
             amd64)
                 grub_target="x86_64-efi";;
             arm64)
@@ -626,9 +685,19 @@ install_grub() {
     fi
 
     # check that the grub package is installed
-    tmp=$(chroot "$mp" dpkg-query --show \
-        --showformat='${Status}\n' $grub_name)
-    r=$?
+    local r=$?
+    case $os_family in
+        debian)
+            tmp=$(chroot "$mp" dpkg-query --show \
+                --showformat='${Status}\n' $grub_name)
+            r=$?
+            ;;
+        redhat)
+            tmp=$(chroot "$mp" rpm -q \
+                --queryformat='install ok installed\n' $grub_name)
+            r=$?
+            ;;
+    esac
     if [ $r -ne 0 -a $r -ne 1 ]; then
         error "failed to check if $grub_name installed";
         return 1;
@@ -636,11 +705,16 @@ install_grub() {
     case "$tmp" in
         install\ ok\ installed) :;;
         *) debug 1 "$grub_name not installed, not doing anything";
-            return 0;;
+            return 1;;
     esac
 
     local grub_d="etc/default/grub.d"
     local mygrub_cfg="$grub_d/50-curtin-settings.cfg"
+    case $os_family in
+        redhat)
+            grub_d="etc/default"
+            mygrub_cfg="etc/default/grub";;
+    esac
     [ -d "$mp/$grub_d" ] || mkdir -p "$mp/$grub_d" ||
         { error "Failed to create $grub_d"; return 1; }
 
@@ -659,14 +733,23 @@ install_grub() {
         error "Failed to get carryover parrameters from cmdline"; 
         return 1;
     }
+    # always append rd.auto=1 for centos
+    case $os_family in
+        redhat)
+            newargs="$newargs rd.auto=1";;
+    esac
     debug 1 "carryover command line params: $newargs"
 
-    : > "$mp/$mygrub_cfg" ||
-        { error "Failed to write '$mygrub_cfg'"; return 1; }
+    case $os_family in
+       debian)
+        : > "$mp/$mygrub_cfg" ||
+            { error "Failed to write '$mygrub_cfg'"; return 1; }
+        ;;
+    esac
     {
         [ "${REPLACE_GRUB_LINUX_DEFAULT:-1}" = "0" ] ||
             echo "GRUB_CMDLINE_LINUX_DEFAULT=\"$newargs\""
-        echo "# disable grub os prober that might find other OS installs."
+        echo "# Curtin disable grub os prober that might find other OS installs."
         echo "GRUB_DISABLE_OS_PROBER=true"
         echo "GRUB_TERMINAL=console"
     } >> "$mp/$mygrub_cfg"
@@ -692,30 +775,46 @@ install_grub() {
         nvram="--no-nvram"
         if [ "$update_nvram" -ge 1 ]; then
             nvram=""
-        fi    
+        fi
         debug 1 "curtin uefi: installing ${grub_name} to: /boot/efi"
         chroot "$mp" env DEBIAN_FRONTEND=noninteractive sh -exc '
             echo "before grub-install efiboot settings"
-            efibootmgr || echo "WARN: efibootmgr exited $?"
-            dpkg-reconfigure "$1"
-            update-grub
+            efibootmgr -v || echo "WARN: efibootmgr exited $?"
+            bootid="$4"
+            grubpost=""
+            case $bootid in
+                debian|ubuntu)
+                    grubcmd="grub-install"
+                    dpkg-reconfigure "$1"
+                    update-grub
+                    ;;
+                centos|redhat|rhel)
+                    grubcmd="grub2-install"
+                    grubpost="grub2-mkconfig -o /boot/grub2/grub.cfg"
+                    ;;
+                *)
+                    echo "Unsupported OS: $bootid" 1>&2
+                    exit 1
+                    ;;
+            esac
             # grub-install in 12.04 does not contain --no-nvram, --target,
             # or --efi-directory
             target="--target=$2"
             no_nvram="$3"
             efi_dir="--efi-directory=/boot/efi"
-            gi_out=$(grub-install --help 2>&1)
+            gi_out=$($grubcmd --help 2>&1)
             echo "$gi_out" | grep -q -- "$no_nvram" || no_nvram=""
             echo "$gi_out" | grep -q -- "--target" || target=""
             echo "$gi_out" | grep -q -- "--efi-directory" || efi_dir=""
-            grub-install $target $efi_dir \
-                --bootloader-id=ubuntu --recheck $no_nvram' -- \
-            "${grub_name}" "${grub_target}" "$nvram" </dev/null ||
+            $grubcmd $target $efi_dir \
+                --bootloader-id=$bootid --recheck $no_nvram
+            [ -z "$grubpost" ] || $grubpost;' \
+            -- "${grub_name}" "${grub_target}" "$nvram" "$os_variant" </dev/null ||
             { error "failed to install grub!"; return 1; }
 
         chroot "$mp" sh -exc '
             echo "after grub-install efiboot settings"
-            efibootmgr || echo "WARN: efibootmgr exited $?"
+            efibootmgr -v || echo "WARN: efibootmgr exited $?"
             ' -- </dev/null ||
             { error "failed to list efi boot entries!"; return 1; }
     else
@@ -728,10 +827,32 @@ install_grub() {
         debug 1 "curtin non-uefi: installing ${grub_name} to: ${grubdevs[*]}"
         chroot "$mp" env DEBIAN_FRONTEND=noninteractive sh -exc '
             pkg=$1; shift;
-            dpkg-reconfigure "$pkg"
-            update-grub
-            for d in "$@"; do grub-install "$d" || exit; done' \
-            -- "${grub_name}" "${grubdevs[@]}" </dev/null ||
+            bootid=$1; shift;
+            bootver=$1; shift;
+            grubpost=""
+            case $bootid in
+                debian|ubuntu)
+                    grubcmd="grub-install"
+                    dpkg-reconfigure "$pkg"
+                    update-grub
+                    ;;
+                centos|redhat|rhel)
+                    case $bootver in
+                        6) grubcmd="grub-install";;
+                        7) grubcmd="grub2-install"
+                           grubpost="grub2-mkconfig -o /boot/grub2/grub.cfg";;
+                    esac
+                    ;;
+                *)
+                    echo "Unsupported OS: $bootid"; 1>&2
+                    exit 1
+                    ;;
+            esac
+            for d in "$@"; do
+                echo $grubcmd "$d";
+                $grubcmd "$d" || exit; done
+            [ -z "$grubpost" ] || $grubpost;' \
+            -- "${grub_name}" "${os_variant}" "${rhel_ver}" "${grubdevs[@]}" </dev/null ||
             { error "failed to install grub!"; return 1; }
     fi
 
diff --git a/tests/unittests/test_apt_custom_sources_list.py b/tests/unittests/test_apt_custom_sources_list.py
index 5567dd5..a427ae9 100644
--- a/tests/unittests/test_apt_custom_sources_list.py
+++ b/tests/unittests/test_apt_custom_sources_list.py
@@ -11,6 +11,8 @@ from mock import call
 import textwrap
 import yaml
 
+from curtin import distro
+from curtin import paths
 from curtin import util
 from curtin.commands import apt_config
 from .helpers import CiTestCase
@@ -106,7 +108,7 @@ class TestAptSourceConfigSourceList(CiTestCase):
                     # make test independent to executing system
                     with mock.patch.object(util, 'load_file',
                                            return_value=MOCKED_APT_SRC_LIST):
-                        with mock.patch.object(util, 'lsb_release',
+                        with mock.patch.object(distro, 'lsb_release',
                                                return_value={'codename':
                                                              'fakerel'}):
                             apt_config.handle_apt(cfg, TARGET)
@@ -115,10 +117,10 @@ class TestAptSourceConfigSourceList(CiTestCase):
 
         cloudfile = '/etc/cloud/cloud.cfg.d/curtin-preserve-sources.cfg'
         cloudconf = yaml.dump({'apt_preserve_sources_list': True}, indent=1)
-        calls = [call(util.target_path(TARGET, '/etc/apt/sources.list'),
+        calls = [call(paths.target_path(TARGET, '/etc/apt/sources.list'),
                       expected,
                       mode=0o644),
-                 call(util.target_path(TARGET, cloudfile),
+                 call(paths.target_path(TARGET, cloudfile),
                       cloudconf,
                       mode=0o644)]
         mockwrite.assert_has_calls(calls)
@@ -147,19 +149,19 @@ class TestAptSourceConfigSourceList(CiTestCase):
         arch = util.get_architecture()
         # would fail inside the unittest context
         with mock.patch.object(util, 'get_architecture', return_value=arch):
-            with mock.patch.object(util, 'lsb_release',
+            with mock.patch.object(distro, 'lsb_release',
                                    return_value={'codename': 'fakerel'}):
                 apt_config.handle_apt(cfg, target)
 
         self.assertEqual(
             EXPECTED_CONVERTED_CONTENT,
-            util.load_file(util.target_path(target, "/etc/apt/sources.list")))
-        cloudfile = util.target_path(
+            util.load_file(paths.target_path(target, "/etc/apt/sources.list")))
+        cloudfile = paths.target_path(
             target, '/etc/cloud/cloud.cfg.d/curtin-preserve-sources.cfg')
         self.assertEqual({'apt_preserve_sources_list': True},
                          yaml.load(util.load_file(cloudfile)))
 
-    @mock.patch("curtin.util.lsb_release")
+    @mock.patch("curtin.distro.lsb_release")
     @mock.patch("curtin.util.get_architecture", return_value="amd64")
     def test_trusty_source_lists(self, m_get_arch, m_lsb_release):
         """Support mirror equivalency with and without trailing /.
@@ -199,7 +201,7 @@ class TestAptSourceConfigSourceList(CiTestCase):
 
         release = 'trusty'
         comps = 'main universe multiverse restricted'
-        easl = util.target_path(target, 'etc/apt/sources.list')
+        easl = paths.target_path(target, 'etc/apt/sources.list')
 
         orig_content = tmpl.format(
             mirror=orig_primary, security=orig_security,
diff --git a/tests/unittests/test_apt_source.py b/tests/unittests/test_apt_source.py
index 2ede986..353cdf8 100644
--- a/tests/unittests/test_apt_source.py
+++ b/tests/unittests/test_apt_source.py
@@ -12,8 +12,9 @@ import socket
 import mock
 from mock import call
 
-from curtin import util
+from curtin import distro
 from curtin import gpg
+from curtin import util
 from curtin.commands import apt_config
 from .helpers import CiTestCase
 
@@ -77,7 +78,7 @@ class TestAptSourceConfig(CiTestCase):
 
     @staticmethod
     def _add_apt_sources(*args, **kwargs):
-        with mock.patch.object(util, 'apt_update'):
+        with mock.patch.object(distro, 'apt_update'):
             apt_config.add_apt_sources(*args, **kwargs)
 
     @staticmethod
@@ -86,7 +87,7 @@ class TestAptSourceConfig(CiTestCase):
         Get the most basic default mrror and release info to be used in tests
         """
         params = {}
-        params['RELEASE'] = util.lsb_release()['codename']
+        params['RELEASE'] = distro.lsb_release()['codename']
         arch = util.get_architecture()
         params['MIRROR'] = apt_config.get_default_mirrors(arch)["PRIMARY"]
         return params
@@ -472,7 +473,7 @@ class TestAptSourceConfig(CiTestCase):
                              'uri':
                              'http://testsec.ubuntu.com/%s/' % component}]}
         post = ("%s_dists_%s-updates_InRelease" %
-                (component, util.lsb_release()['codename']))
+                (component, distro.lsb_release()['codename']))
         fromfn = ("%s/%s_%s" % (pre, archive, post))
         tofn = ("%s/test.ubuntu.com_%s" % (pre, post))
 
@@ -937,7 +938,7 @@ class TestDebconfSelections(CiTestCase):
         m_set_sel.assert_not_called()
 
     @mock.patch("curtin.commands.apt_config.debconf_set_selections")
-    @mock.patch("curtin.commands.apt_config.util.get_installed_packages")
+    @mock.patch("curtin.commands.apt_config.distro.get_installed_packages")
     def test_set_sel_call_has_expected_input(self, m_get_inst, m_set_sel):
         data = {
             'set1': 'pkga pkga/q1 mybool false',
@@ -960,7 +961,7 @@ class TestDebconfSelections(CiTestCase):
 
     @mock.patch("curtin.commands.apt_config.dpkg_reconfigure")
     @mock.patch("curtin.commands.apt_config.debconf_set_selections")
-    @mock.patch("curtin.commands.apt_config.util.get_installed_packages")
+    @mock.patch("curtin.commands.apt_config.distro.get_installed_packages")
     def test_reconfigure_if_intersection(self, m_get_inst, m_set_sel,
                                          m_dpkg_r):
         data = {
@@ -985,7 +986,7 @@ class TestDebconfSelections(CiTestCase):
 
     @mock.patch("curtin.commands.apt_config.dpkg_reconfigure")
     @mock.patch("curtin.commands.apt_config.debconf_set_selections")
-    @mock.patch("curtin.commands.apt_config.util.get_installed_packages")
+    @mock.patch("curtin.commands.apt_config.distro.get_installed_packages")
     def test_reconfigure_if_no_intersection(self, m_get_inst, m_set_sel,
                                             m_dpkg_r):
         data = {'set1': 'pkga pkga/q1 mybool false'}
diff --git a/tests/unittests/test_block_iscsi.py b/tests/unittests/test_block_iscsi.py
index afaf1f6..f8ef5d8 100644
--- a/tests/unittests/test_block_iscsi.py
+++ b/tests/unittests/test_block_iscsi.py
@@ -588,6 +588,13 @@ class TestBlockIscsiDiskFromConfig(CiTestCase):
         # utilize IscsiDisk str method for equality check
         self.assertEqual(str(expected_iscsi_disk), str(iscsi_disk))
 
+        # test with cfg.get('storage') since caller may already have
+        # grabbed the 'storage' value from the curtin config
+        iscsi_disk = iscsi.get_iscsi_disks_from_config(
+                        cfg.get('storage')).pop()
+        # utilize IscsiDisk str method for equality check
+        self.assertEqual(str(expected_iscsi_disk), str(iscsi_disk))
+
     def test_parse_iscsi_disk_from_config_no_iscsi(self):
         """Test parsing storage config with no iscsi disks included"""
         cfg = {
diff --git a/tests/unittests/test_block_lvm.py b/tests/unittests/test_block_lvm.py
index 22fb064..c92c1ec 100644
--- a/tests/unittests/test_block_lvm.py
+++ b/tests/unittests/test_block_lvm.py
@@ -73,7 +73,8 @@ class TestBlockLvm(CiTestCase):
 
     @mock.patch('curtin.block.lvm.lvmetad_running')
     @mock.patch('curtin.block.lvm.util')
-    def test_lvm_scan(self, mock_util, mock_lvmetad):
+    @mock.patch('curtin.block.lvm.distro')
+    def test_lvm_scan(self, mock_distro, mock_util, mock_lvmetad):
         """check that lvm_scan formats commands correctly for each release"""
         cmds = [['pvscan'], ['vgscan', '--mknodes']]
         for (count, (codename, lvmetad_status, use_cache)) in enumerate(
@@ -81,7 +82,7 @@ class TestBlockLvm(CiTestCase):
                  ('trusty', False, False),
                  ('xenial', False, False), ('xenial', True, True),
                  (None, True, True), (None, False, False)]):
-            mock_util.lsb_release.return_value = {'codename': codename}
+            mock_distro.lsb_release.return_value = {'codename': codename}
             mock_lvmetad.return_value = lvmetad_status
             lvm.lvm_scan()
             expected = [cmd for cmd in cmds]
diff --git a/tests/unittests/test_block_mdadm.py b/tests/unittests/test_block_mdadm.py
index 341e49d..d017930 100644
--- a/tests/unittests/test_block_mdadm.py
+++ b/tests/unittests/test_block_mdadm.py
@@ -15,12 +15,13 @@ class TestBlockMdadmAssemble(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmAssemble, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
         self.add_patch('curtin.block.mdadm.udev', 'mock_udev')
 
         # Common mock settings
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'precise'}
+        self.mock_lsb_release.return_value = {'codename': 'precise'}
         self.mock_util.subp.return_value = ('', '')
 
     def test_mdadm_assemble_scan(self):
@@ -88,6 +89,7 @@ class TestBlockMdadmCreate(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmCreate, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
         self.add_patch('curtin.block.mdadm.get_holders', 'mock_holders')
         self.add_patch('curtin.block.mdadm.udev.udevadm_settle',
@@ -95,7 +97,7 @@ class TestBlockMdadmCreate(CiTestCase):
 
         # Common mock settings
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'precise'}
+        self.mock_lsb_release.return_value = {'codename': 'precise'}
         self.mock_holders.return_value = []
 
     def prepare_mock(self, md_devname, raidlevel, devices, spares):
@@ -236,14 +238,15 @@ class TestBlockMdadmExamine(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmExamine, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
 
         # Common mock settings
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'precise'}
+        self.mock_lsb_release.return_value = {'codename': 'precise'}
 
     def test_mdadm_examine_export(self):
-        self.mock_util.lsb_release.return_value = {'codename': 'xenial'}
+        self.mock_lsb_release.return_value = {'codename': 'xenial'}
         self.mock_util.subp.return_value = (
             """
             MD_LEVEL=raid0
@@ -320,7 +323,7 @@ class TestBlockMdadmExamine(CiTestCase):
 class TestBlockMdadmStop(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmStop, self).setUp()
-        self.add_patch('curtin.block.mdadm.util.lsb_release', 'mock_util_lsb')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.util.subp', 'mock_util_subp')
         self.add_patch('curtin.block.mdadm.util.write_file',
                        'mock_util_write_file')
@@ -333,7 +336,7 @@ class TestBlockMdadmStop(CiTestCase):
 
         # Common mock settings
         self.mock_valid.return_value = True
-        self.mock_util_lsb.return_value = {'codename': 'xenial'}
+        self.mock_lsb_release.return_value = {'codename': 'xenial'}
         self.mock_util_subp.side_effect = iter([
             ("", ""),  # mdadm stop device
         ])
@@ -488,11 +491,12 @@ class TestBlockMdadmRemove(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmRemove, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
 
         # Common mock settings
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'xenial'}
+        self.mock_lsb_release.return_value = {'codename': 'xenial'}
         self.mock_util.subp.side_effect = [
             ("", ""),  # mdadm remove device
         ]
@@ -514,14 +518,15 @@ class TestBlockMdadmQueryDetail(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmQueryDetail, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
 
         # Common mock settings
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'precise'}
+        self.mock_lsb_release.return_value = {'codename': 'precise'}
 
     def test_mdadm_query_detail_export(self):
-        self.mock_util.lsb_release.return_value = {'codename': 'xenial'}
+        self.mock_lsb_release.return_value = {'codename': 'xenial'}
         self.mock_util.subp.return_value = (
             """
             MD_LEVEL=raid1
@@ -592,13 +597,14 @@ class TestBlockMdadmDetailScan(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmDetailScan, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
 
         # Common mock settings
         self.scan_output = ("ARRAY /dev/md0 metadata=1.2 spares=2 name=0 " +
                             "UUID=b1eae2ff:69b6b02e:1d63bb53:ddfa6e4a")
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'xenial'}
+        self.mock_lsb_release.return_value = {'codename': 'xenial'}
         self.mock_util.subp.side_effect = [
             (self.scan_output, ""),  # mdadm --detail --scan
         ]
@@ -627,10 +633,11 @@ class TestBlockMdadmMdHelpers(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmMdHelpers, self).setUp()
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
+        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
 
         self.mock_valid.return_value = True
-        self.mock_util.lsb_release.return_value = {'codename': 'xenial'}
+        self.mock_lsb_release.return_value = {'codename': 'xenial'}
 
     def test_valid_mdname(self):
         mdname = "/dev/md0"
diff --git a/tests/unittests/test_block_mkfs.py b/tests/unittests/test_block_mkfs.py
index c756281..679f85b 100644
--- a/tests/unittests/test_block_mkfs.py
+++ b/tests/unittests/test_block_mkfs.py
@@ -37,11 +37,12 @@ class TestBlockMkfs(CiTestCase):
     @mock.patch("curtin.block.mkfs.block")
     @mock.patch("curtin.block.mkfs.os")
     @mock.patch("curtin.block.mkfs.util")
+    @mock.patch("curtin.block.mkfs.distro.lsb_release")
     def _run_mkfs_with_config(self, config, expected_cmd, expected_flags,
-                              mock_util, mock_os, mock_block,
+                              mock_lsb_release, mock_util, mock_os, mock_block,
                               release="wily", strict=False):
         # Pretend we are on wily as there are no known edge cases for it
-        mock_util.lsb_release.return_value = {"codename": release}
+        mock_lsb_release.return_value = {"codename": release}
         mock_os.path.exists.return_value = True
         mock_block.get_blockdev_sector_size.return_value = (512, 512)
 
diff --git a/tests/unittests/test_block_zfs.py b/tests/unittests/test_block_zfs.py
index c18f6a3..9781946 100644
--- a/tests/unittests/test_block_zfs.py
+++ b/tests/unittests/test_block_zfs.py
@@ -384,7 +384,7 @@ class TestBlockZfsAssertZfsSupported(CiTestCase):
         super(TestBlockZfsAssertZfsSupported, self).setUp()
         self.add_patch('curtin.block.zfs.util.subp', 'mock_subp')
         self.add_patch('curtin.block.zfs.util.get_platform_arch', 'mock_arch')
-        self.add_patch('curtin.block.zfs.util.lsb_release', 'mock_release')
+        self.add_patch('curtin.block.zfs.distro.lsb_release', 'mock_release')
         self.add_patch('curtin.block.zfs.util.which', 'mock_which')
         self.add_patch('curtin.block.zfs.get_supported_filesystems',
                        'mock_supfs')
@@ -426,46 +426,52 @@ class TestAssertZfsSupported(CiTestCase):
         super(TestAssertZfsSupported, self).setUp()
 
     @mock.patch('curtin.block.zfs.get_supported_filesystems')
+    @mock.patch('curtin.block.zfs.distro')
     @mock.patch('curtin.block.zfs.util')
-    def test_zfs_assert_supported_returns_true(self, mock_util, mock_supfs):
+    def test_zfs_assert_supported_returns_true(self, mock_util, mock_distro,
+                                               mock_supfs):
         """zfs_assert_supported returns True on supported platforms"""
         mock_util.get_platform_arch.return_value = 'amd64'
-        mock_util.lsb_release.return_value = {'codename': 'bionic'}
+        mock_distro.lsb_release.return_value = {'codename': 'bionic'}
         mock_util.subp.return_value = ("", "")
         mock_supfs.return_value = ['zfs']
         mock_util.which.side_effect = iter(['/wark/zpool', '/wark/zfs'])
 
         self.assertNotIn(mock_util.get_platform_arch.return_value,
                          zfs.ZFS_UNSUPPORTED_ARCHES)
-        self.assertNotIn(mock_util.lsb_release.return_value['codename'],
+        self.assertNotIn(mock_distro.lsb_release.return_value['codename'],
                          zfs.ZFS_UNSUPPORTED_RELEASES)
         self.assertTrue(zfs.zfs_supported())
 
+    @mock.patch('curtin.block.zfs.distro')
     @mock.patch('curtin.block.zfs.util')
     def test_zfs_assert_supported_raises_exception_on_bad_arch(self,
-                                                               mock_util):
+                                                               mock_util,
+                                                               mock_distro):
         """zfs_assert_supported raises RuntimeError on unspported arches"""
-        mock_util.lsb_release.return_value = {'codename': 'bionic'}
+        mock_distro.lsb_release.return_value = {'codename': 'bionic'}
         mock_util.subp.return_value = ("", "")
         for arch in zfs.ZFS_UNSUPPORTED_ARCHES:
             mock_util.get_platform_arch.return_value = arch
             with self.assertRaises(RuntimeError):
                 zfs.zfs_assert_supported()
 
+    @mock.patch('curtin.block.zfs.distro')
     @mock.patch('curtin.block.zfs.util')
-    def test_zfs_assert_supported_raises_exc_on_bad_releases(self, mock_util):
+    def test_zfs_assert_supported_raises_exc_on_bad_releases(self, mock_util,
+                                                             mock_distro):
         """zfs_assert_supported raises RuntimeError on unspported releases"""
         mock_util.get_platform_arch.return_value = 'amd64'
         mock_util.subp.return_value = ("", "")
         for release in zfs.ZFS_UNSUPPORTED_RELEASES:
-            mock_util.lsb_release.return_value = {'codename': release}
+            mock_distro.lsb_release.return_value = {'codename': release}
             with self.assertRaises(RuntimeError):
                 zfs.zfs_assert_supported()
 
     @mock.patch('curtin.block.zfs.util.subprocess.Popen')
     @mock.patch('curtin.block.zfs.util.is_kmod_loaded')
     @mock.patch('curtin.block.zfs.get_supported_filesystems')
-    @mock.patch('curtin.block.zfs.util.lsb_release')
+    @mock.patch('curtin.block.zfs.distro.lsb_release')
     @mock.patch('curtin.block.zfs.util.get_platform_arch')
     def test_zfs_assert_supported_raises_exc_on_missing_module(self,
                                                                m_arch,
diff --git a/tests/unittests/test_commands_apply_net.py b/tests/unittests/test_commands_apply_net.py
index a55ab17..04b7f2e 100644
--- a/tests/unittests/test_commands_apply_net.py
+++ b/tests/unittests/test_commands_apply_net.py
@@ -5,7 +5,7 @@ import copy
 import os
 
 from curtin.commands import apply_net
-from curtin import util
+from curtin import paths
 from .helpers import CiTestCase
 
 
@@ -153,8 +153,8 @@ class TestApplyNetPatchIfupdown(CiTestCase):
                                                 prehookfn=prehookfn,
                                                 posthookfn=posthookfn)
 
-        precfg = util.target_path(target, path=prehookfn)
-        postcfg = util.target_path(target, path=posthookfn)
+        precfg = paths.target_path(target, path=prehookfn)
+        postcfg = paths.target_path(target, path=posthookfn)
         precontents = apply_net.IFUPDOWN_IPV6_MTU_PRE_HOOK
         postcontents = apply_net.IFUPDOWN_IPV6_MTU_POST_HOOK
 
@@ -231,7 +231,7 @@ class TestApplyNetPatchIpv6Priv(CiTestCase):
 
         apply_net._disable_ipv6_privacy_extensions(target)
 
-        cfg = util.target_path(target, path=path)
+        cfg = paths.target_path(target, path=path)
         mock_write.assert_called_with(cfg, expected_ipv6_priv_contents)
 
     @patch('curtin.util.load_file')
@@ -259,7 +259,7 @@ class TestApplyNetPatchIpv6Priv(CiTestCase):
         apply_net._disable_ipv6_privacy_extensions(target, path=path)
 
         # source file not found
-        cfg = util.target_path(target, path)
+        cfg = paths.target_path(target, path)
         mock_ospath.exists.assert_called_with(cfg)
         self.assertEqual(0, mock_load.call_count)
 
@@ -272,7 +272,7 @@ class TestApplyNetRemoveLegacyEth0(CiTestCase):
     def test_remove_legacy_eth0(self, mock_ospath, mock_load, mock_del):
         target = 'mytarget'
         path = 'eth0.cfg'
-        cfg = util.target_path(target, path)
+        cfg = paths.target_path(target, path)
         legacy_eth0_contents = (
             'auto eth0\n'
             'iface eth0 inet dhcp')
@@ -330,7 +330,7 @@ class TestApplyNetRemoveLegacyEth0(CiTestCase):
         apply_net._maybe_remove_legacy_eth0(target, path)
 
         # source file not found
-        cfg = util.target_path(target, path)
+        cfg = paths.target_path(target, path)
         mock_ospath.exists.assert_called_with(cfg)
         self.assertEqual(0, mock_load.call_count)
         self.assertEqual(0, mock_del.call_count)
diff --git a/tests/unittests/test_commands_block_meta.py b/tests/unittests/test_commands_block_meta.py
index a6a0b13..e70d6ed 100644
--- a/tests/unittests/test_commands_block_meta.py
+++ b/tests/unittests/test_commands_block_meta.py
@@ -7,7 +7,7 @@ from mock import patch, call
 import os
 
 from curtin.commands import block_meta
-from curtin import util
+from curtin import paths, util
 from .helpers import CiTestCase
 
 
@@ -688,8 +688,9 @@ class TestFstabData(CiTestCase):
         if target is None:
             target = self.tmp_dir()
 
-        expected = [a if a != "_T_MP" else util.target_path(target, fdata.path)
-                    for a in expected]
+        expected = [
+            a if a != "_T_MP" else paths.target_path(target, fdata.path)
+            for a in expected]
         with patch("curtin.util.subp") as m_subp:
             block_meta.mount_fstab_data(fdata, target=target)
 
diff --git a/tests/unittests/test_curthooks.py b/tests/unittests/test_curthooks.py
index a8275c7..8fd7933 100644
--- a/tests/unittests/test_curthooks.py
+++ b/tests/unittests/test_curthooks.py
@@ -4,6 +4,7 @@ import os
 from mock import call, patch, MagicMock
 
 from curtin.commands import curthooks
+from curtin import distro
 from curtin import util
 from curtin import config
 from curtin.reporter import events
@@ -47,8 +48,8 @@ class TestGetFlashKernelPkgs(CiTestCase):
 class TestCurthooksInstallKernel(CiTestCase):
     def setUp(self):
         super(TestCurthooksInstallKernel, self).setUp()
-        self.add_patch('curtin.util.has_pkg_available', 'mock_haspkg')
-        self.add_patch('curtin.util.install_packages', 'mock_instpkg')
+        self.add_patch('curtin.distro.has_pkg_available', 'mock_haspkg')
+        self.add_patch('curtin.distro.install_packages', 'mock_instpkg')
         self.add_patch(
             'curtin.commands.curthooks.get_flash_kernel_pkgs',
             'mock_get_flash_kernel_pkgs')
@@ -122,12 +123,21 @@ class TestInstallMissingPkgs(CiTestCase):
     def setUp(self):
         super(TestInstallMissingPkgs, self).setUp()
         self.add_patch('platform.machine', 'mock_machine')
-        self.add_patch('curtin.util.get_installed_packages',
+        self.add_patch('curtin.util.get_architecture', 'mock_arch')
+        self.add_patch('curtin.distro.get_installed_packages',
                        'mock_get_installed_packages')
         self.add_patch('curtin.util.load_command_environment',
                        'mock_load_cmd_evn')
         self.add_patch('curtin.util.which', 'mock_which')
-        self.add_patch('curtin.util.install_packages', 'mock_install_packages')
+        self.add_patch('curtin.util.is_uefi_bootable', 'mock_uefi')
+        self.add_patch('curtin.distro.has_pkg_available', 'mock_haspkg')
+        self.add_patch('curtin.distro.install_packages',
+                       'mock_install_packages')
+        self.add_patch('curtin.distro.get_osfamily', 'mock_osfamily')
+        self.distro_family = distro.DISTROS.debian
+        self.mock_osfamily.return_value = self.distro_family
+        self.mock_uefi.return_value = False
+        self.mock_haspkg.return_value = False
 
     @patch.object(events, 'ReportEventStack')
     def test_install_packages_s390x(self, mock_events):
@@ -137,8 +147,8 @@ class TestInstallMissingPkgs(CiTestCase):
         target = "not-a-real-target"
         cfg = {}
         curthooks.install_missing_packages(cfg, target=target)
-        self.mock_install_packages.assert_called_with(['s390-tools'],
-                                                      target=target)
+        self.mock_install_packages.assert_called_with(
+            ['s390-tools'], target=target, osfamily=self.distro_family)
 
     @patch.object(events, 'ReportEventStack')
     def test_install_packages_s390x_has_zipl(self, mock_events):
@@ -159,6 +169,50 @@ class TestInstallMissingPkgs(CiTestCase):
         curthooks.install_missing_packages(cfg, target=target)
         self.assertEqual([], self.mock_install_packages.call_args_list)
 
+    @patch.object(events, 'ReportEventStack')
+    def test_install_packages_on_uefi_amd64_shim_signed(self, mock_events):
+        arch = 'amd64'
+        self.mock_arch.return_value = arch
+        self.mock_machine.return_value = 'x86_64'
+        expected_pkgs = ['grub-efi-%s' % arch,
+                         'grub-efi-%s-signed' % arch,
+                         'shim-signed']
+        self.mock_machine.return_value = 'x86_64'
+        self.mock_uefi.return_value = True
+        self.mock_haspkg.return_value = True
+        target = "not-a-real-target"
+        cfg = {}
+        curthooks.install_missing_packages(cfg, target=target)
+        self.mock_install_packages.assert_called_with(
+                expected_pkgs, target=target, osfamily=self.distro_family)
+
+    @patch.object(events, 'ReportEventStack')
+    def test_install_packages_on_uefi_i386_noshim_nosigned(self, mock_events):
+        arch = 'i386'
+        self.mock_arch.return_value = arch
+        self.mock_machine.return_value = 'i386'
+        expected_pkgs = ['grub-efi-%s' % arch]
+        self.mock_machine.return_value = 'i686'
+        self.mock_uefi.return_value = True
+        target = "not-a-real-target"
+        cfg = {}
+        curthooks.install_missing_packages(cfg, target=target)
+        self.mock_install_packages.assert_called_with(
+                expected_pkgs, target=target, osfamily=self.distro_family)
+
+    @patch.object(events, 'ReportEventStack')
+    def test_install_packages_on_uefi_arm64_nosign_noshim(self, mock_events):
+        arch = 'arm64'
+        self.mock_arch.return_value = arch
+        self.mock_machine.return_value = 'aarch64'
+        expected_pkgs = ['grub-efi-%s' % arch]
+        self.mock_uefi.return_value = True
+        target = "not-a-real-target"
+        cfg = {}
+        curthooks.install_missing_packages(cfg, target=target)
+        self.mock_install_packages.assert_called_with(
+                expected_pkgs, target=target, osfamily=self.distro_family)
+
 
 class TestSetupZipl(CiTestCase):
 
@@ -192,7 +246,8 @@ class TestSetupGrub(CiTestCase):
     def setUp(self):
         super(TestSetupGrub, self).setUp()
         self.target = self.tmp_dir()
-        self.add_patch('curtin.util.lsb_release', 'mock_lsb_release')
+        self.distro_family = distro.DISTROS.debian
+        self.add_patch('curtin.distro.lsb_release', 'mock_lsb_release')
         self.mock_lsb_release.return_value = {
             'codename': 'xenial',
         }
@@ -219,11 +274,12 @@ class TestSetupGrub(CiTestCase):
             'grub_install_devices': ['/dev/vdb']
         }
         self.subp_output.append(('', ''))
-        curthooks.setup_grub(cfg, self.target)
+        curthooks.setup_grub(cfg, self.target, osfamily=self.distro_family)
         self.assertEquals(
             ([
                 'sh', '-c', 'exec "$0" "$@" 2>&1',
-                'install-grub', self.target, '/dev/vdb'],),
+                'install-grub', '--os-family=%s' % self.distro_family,
+                self.target, '/dev/vdb'],),
             self.mock_subp.call_args_list[0][0])
 
     def test_uses_install_devices_in_grubcfg(self):
@@ -233,11 +289,12 @@ class TestSetupGrub(CiTestCase):
             },
         }
         self.subp_output.append(('', ''))
-        curthooks.setup_grub(cfg, self.target)
+        curthooks.setup_grub(cfg, self.target, osfamily=self.distro_family)
         self.assertEquals(
             ([
                 'sh', '-c', 'exec "$0" "$@" 2>&1',
-                'install-grub', self.target, '/dev/vdb'],),
+                'install-grub', '--os-family=%s' % self.distro_family,
+                self.target, '/dev/vdb'],),
             self.mock_subp.call_args_list[0][0])
 
     def test_uses_grub_install_on_storage_config(self):
@@ -255,11 +312,12 @@ class TestSetupGrub(CiTestCase):
             },
         }
         self.subp_output.append(('', ''))
-        curthooks.setup_grub(cfg, self.target)
+        curthooks.setup_grub(cfg, self.target, osfamily=self.distro_family)
         self.assertEquals(
             ([
                 'sh', '-c', 'exec "$0" "$@" 2>&1',
-                'install-grub', self.target, '/dev/vdb'],),
+                'install-grub', '--os-family=%s' % self.distro_family,
+                self.target, '/dev/vdb'],),
             self.mock_subp.call_args_list[0][0])
 
     def test_grub_install_installs_to_none_if_install_devices_None(self):
@@ -269,62 +327,17 @@ class TestSetupGrub(CiTestCase):
             },
         }
         self.subp_output.append(('', ''))
-        curthooks.setup_grub(cfg, self.target)
-        self.assertEquals(
-            ([
-                'sh', '-c', 'exec "$0" "$@" 2>&1',
-                'install-grub', self.target, 'none'],),
-            self.mock_subp.call_args_list[0][0])
-
-    def test_grub_install_uefi_installs_signed_packages_for_amd64(self):
-        self.add_patch('curtin.util.install_packages', 'mock_install')
-        self.add_patch('curtin.util.has_pkg_available', 'mock_haspkg')
-        self.mock_is_uefi_bootable.return_value = True
-        cfg = {
-            'grub': {
-                'install_devices': ['/dev/vdb'],
-                'update_nvram': False,
-            },
-        }
-        self.subp_output.append(('', ''))
-        self.mock_arch.return_value = 'amd64'
-        self.mock_haspkg.return_value = True
-        curthooks.setup_grub(cfg, self.target)
-        self.assertEquals(
-            (['grub-efi-amd64', 'grub-efi-amd64-signed', 'shim-signed'],),
-            self.mock_install.call_args_list[0][0])
+        curthooks.setup_grub(cfg, self.target, osfamily=self.distro_family)
         self.assertEquals(
             ([
                 'sh', '-c', 'exec "$0" "$@" 2>&1',
-                'install-grub', '--uefi', self.target, '/dev/vdb'],),
-            self.mock_subp.call_args_list[0][0])
-
-    def test_grub_install_uefi_installs_packages_for_arm64(self):
-        self.add_patch('curtin.util.install_packages', 'mock_install')
-        self.add_patch('curtin.util.has_pkg_available', 'mock_haspkg')
-        self.mock_is_uefi_bootable.return_value = True
-        cfg = {
-            'grub': {
-                'install_devices': ['/dev/vdb'],
-                'update_nvram': False,
-            },
-        }
-        self.subp_output.append(('', ''))
-        self.mock_arch.return_value = 'arm64'
-        self.mock_haspkg.return_value = False
-        curthooks.setup_grub(cfg, self.target)
-        self.assertEquals(
-            (['grub-efi-arm64'],),
-            self.mock_install.call_args_list[0][0])
-        self.assertEquals(
-            ([
-                'sh', '-c', 'exec "$0" "$@" 2>&1',
-                'install-grub', '--uefi', self.target, '/dev/vdb'],),
+                'install-grub', '--os-family=%s' % self.distro_family,
+                self.target, 'none'],),
             self.mock_subp.call_args_list[0][0])
 
     def test_grub_install_uefi_updates_nvram_skips_remove_and_reorder(self):
-        self.add_patch('curtin.util.install_packages', 'mock_install')
-        self.add_patch('curtin.util.has_pkg_available', 'mock_haspkg')
+        self.add_patch('curtin.distro.install_packages', 'mock_install')
+        self.add_patch('curtin.distro.has_pkg_available', 'mock_haspkg')
         self.add_patch('curtin.util.get_efibootmgr', 'mock_efibootmgr')
         self.mock_is_uefi_bootable.return_value = True
         cfg = {
@@ -347,17 +360,18 @@ class TestSetupGrub(CiTestCase):
                 }
             }
         }
-        curthooks.setup_grub(cfg, self.target)
+        curthooks.setup_grub(cfg, self.target, osfamily=self.distro_family)
         self.assertEquals(
             ([
                 'sh', '-c', 'exec "$0" "$@" 2>&1',
                 'install-grub', '--uefi', '--update-nvram',
+                '--os-family=%s' % self.distro_family,
                 self.target, '/dev/vdb'],),
             self.mock_subp.call_args_list[0][0])
 
     def test_grub_install_uefi_updates_nvram_removes_old_loaders(self):
-        self.add_patch('curtin.util.install_packages', 'mock_install')
-        self.add_patch('curtin.util.has_pkg_available', 'mock_haspkg')
+        self.add_patch('curtin.distro.install_packages', 'mock_install')
+        self.add_patch('curtin.distro.has_pkg_available', 'mock_haspkg')
         self.add_patch('curtin.util.get_efibootmgr', 'mock_efibootmgr')
         self.mock_is_uefi_bootable.return_value = True
         cfg = {
@@ -392,7 +406,7 @@ class TestSetupGrub(CiTestCase):
         self.in_chroot_subp_output.append(('', ''))
         self.in_chroot_subp_output.append(('', ''))
         self.mock_haspkg.return_value = False
-        curthooks.setup_grub(cfg, self.target)
+        curthooks.setup_grub(cfg, self.target, osfamily=self.distro_family)
         self.assertEquals(
             ['efibootmgr', '-B', '-b'],
             self.mock_in_chroot_subp.call_args_list[0][0][0][:3])
@@ -406,8 +420,8 @@ class TestSetupGrub(CiTestCase):
                 self.mock_in_chroot_subp.call_args_list[1][0][0][3]]))
 
     def test_grub_install_uefi_updates_nvram_reorders_loaders(self):
-        self.add_patch('curtin.util.install_packages', 'mock_install')
-        self.add_patch('curtin.util.has_pkg_available', 'mock_haspkg')
+        self.add_patch('curtin.distro.install_packages', 'mock_install')
+        self.add_patch('curtin.distro.has_pkg_available', 'mock_haspkg')
         self.add_patch('curtin.util.get_efibootmgr', 'mock_efibootmgr')
         self.mock_is_uefi_bootable.return_value = True
         cfg = {
@@ -436,7 +450,7 @@ class TestSetupGrub(CiTestCase):
         }
         self.in_chroot_subp_output.append(('', ''))
         self.mock_haspkg.return_value = False
-        curthooks.setup_grub(cfg, self.target)
+        curthooks.setup_grub(cfg, self.target, osfamily=self.distro_family)
         self.assertEquals(
             (['efibootmgr', '-o', '0001,0000'],),
             self.mock_in_chroot_subp.call_args_list[0][0])
@@ -453,11 +467,11 @@ class TestUbuntuCoreHooks(CiTestCase):
                                         'var/lib/snapd')
         util.ensure_dir(ubuntu_core_path)
         self.assertTrue(os.path.isdir(ubuntu_core_path))
-        is_core = curthooks.target_is_ubuntu_core(self.target)
+        is_core = distro.is_ubuntu_core(self.target)
         self.assertTrue(is_core)
 
     def test_target_is_ubuntu_core_no_target(self):
-        is_core = curthooks.target_is_ubuntu_core(self.target)
+        is_core = distro.is_ubuntu_core(self.target)
         self.assertFalse(is_core)
 
     def test_target_is_ubuntu_core_noncore_target(self):
@@ -465,7 +479,7 @@ class TestUbuntuCoreHooks(CiTestCase):
         non_core_path = os.path.join(self.target, 'curtin')
         util.ensure_dir(non_core_path)
         self.assertTrue(os.path.isdir(non_core_path))
-        is_core = curthooks.target_is_ubuntu_core(self.target)
+        is_core = distro.is_ubuntu_core(self.target)
         self.assertFalse(is_core)
 
     @patch('curtin.util.write_file')
@@ -736,15 +750,15 @@ class TestDetectRequiredPackages(CiTestCase):
             ({'network': {
                 'version': 2,
                 'items': ('bridge',)}},
-             ('bridge-utils',)),
+             ()),
             ({'network': {
                 'version': 2,
                 'items': ('vlan',)}},
-             ('vlan',)),
+             ()),
             ({'network': {
                 'version': 2,
                 'items': ('vlan', 'bridge')}},
-             ('vlan', 'bridge-utils')),
+             ()),
         ))
 
     def test_mixed_storage_v1_network_v2_detect(self):
@@ -755,7 +769,7 @@ class TestDetectRequiredPackages(CiTestCase):
              'storage': {
                  'version': 1,
                  'items': ('raid', 'bcache', 'ext4')}},
-             ('vlan', 'bridge-utils', 'mdadm', 'bcache-tools', 'e2fsprogs')),
+             ('mdadm', 'bcache-tools', 'e2fsprogs')),
         ))
 
     def test_invalid_version_in_config(self):
@@ -782,7 +796,7 @@ class TestCurthooksWriteFiles(CiTestCase):
             dict((cfg[i]['path'], cfg[i]['content']) for i in cfg.keys()),
             dir2dict(tmpd, prefix=tmpd))
 
-    @patch('curtin.commands.curthooks.futil.target_path')
+    @patch('curtin.commands.curthooks.paths.target_path')
     @patch('curtin.commands.curthooks.futil.write_finfo')
     def test_handle_write_files_finfo(self, mock_write_finfo, mock_tp):
         """ Validate that futils.write_files handles target_path correctly """
@@ -816,6 +830,8 @@ class TestCurthooksPollinate(CiTestCase):
         self.add_patch('curtin.util.write_file', 'mock_write')
         self.add_patch('curtin.commands.curthooks.get_maas_version',
                        'mock_maas_version')
+        self.add_patch('curtin.util.which', 'mock_which')
+        self.mock_which.return_value = '/usr/bin/pollinate'
         self.target = self.tmp_dir()
 
     def test_handle_pollinate_user_agent_disable(self):
@@ -826,6 +842,15 @@ class TestCurthooksPollinate(CiTestCase):
         self.assertEqual(0, self.mock_maas_version.call_count)
         self.assertEqual(0, self.mock_write.call_count)
 
+    def test_handle_pollinate_returns_if_no_pollinate_binary(self):
+        """ handle_pollinate_user_agent does nothing if no pollinate binary"""
+        self.mock_which.return_value = None
+        cfg = {'reporting': {'maas': {'endpoint': 'http://127.0.0.1/foo'}}}
+        curthooks.handle_pollinate_user_agent(cfg, self.target)
+        self.assertEqual(0, self.mock_curtin_version.call_count)
+        self.assertEqual(0, self.mock_maas_version.call_count)
+        self.assertEqual(0, self.mock_write.call_count)
+
     def test_handle_pollinate_user_agent_default(self):
         """ handle_pollinate_user_agent checks curtin/maas version by default
         """
diff --git a/tests/unittests/test_distro.py b/tests/unittests/test_distro.py
new file mode 100644
index 0000000..d4e5a1e
--- /dev/null
+++ b/tests/unittests/test_distro.py
@@ -0,0 +1,302 @@
+# This file is part of curtin. See LICENSE file for copyright and license info.
+
+from unittest import skipIf
+import mock
+import sys
+
+from curtin import distro
+from curtin import paths
+from curtin import util
+from .helpers import CiTestCase
+
+
+class TestLsbRelease(CiTestCase):
+
+    def setUp(self):
+        super(TestLsbRelease, self).setUp()
+        self._reset_cache()
+
+    def _reset_cache(self):
+        keys = [k for k in distro._LSB_RELEASE.keys()]
+        for d in keys:
+            del distro._LSB_RELEASE[d]
+
+    @mock.patch("curtin.distro.subp")
+    def test_lsb_release_functional(self, mock_subp):
+        output = '\n'.join([
+            "Distributor ID: Ubuntu",
+            "Description:    Ubuntu 14.04.2 LTS",
+            "Release:    14.04",
+            "Codename:   trusty",
+        ])
+        rdata = {'id': 'Ubuntu', 'description': 'Ubuntu 14.04.2 LTS',
+                 'codename': 'trusty', 'release': '14.04'}
+
+        def fake_subp(cmd, capture=False, target=None):
+            return output, 'No LSB modules are available.'
+
+        mock_subp.side_effect = fake_subp
+        found = distro.lsb_release()
+        mock_subp.assert_called_with(
+            ['lsb_release', '--all'], capture=True, target=None)
+        self.assertEqual(found, rdata)
+
+    @mock.patch("curtin.distro.subp")
+    def test_lsb_release_unavailable(self, mock_subp):
+        def doraise(*args, **kwargs):
+            raise util.ProcessExecutionError("foo")
+        mock_subp.side_effect = doraise
+
+        expected = {k: "UNAVAILABLE" for k in
+                    ('id', 'description', 'codename', 'release')}
+        self.assertEqual(distro.lsb_release(), expected)
+
+
+class TestParseDpkgVersion(CiTestCase):
+    """test parse_dpkg_version."""
+
+    def test_none_raises_type_error(self):
+        self.assertRaises(TypeError, distro.parse_dpkg_version, None)
+
+    @skipIf(sys.version_info.major < 3, "python 2 bytes are strings.")
+    def test_bytes_raises_type_error(self):
+        self.assertRaises(TypeError, distro.parse_dpkg_version, b'1.2.3-0')
+
+    def test_simple_native_package_version(self):
+        """dpkg versions must have a -. If not present expect value error."""
+        self.assertEqual(
+            {'major': 2, 'minor': 28, 'micro': 0, 'extra': None,
+             'raw': '2.28', 'upstream': '2.28', 'name': 'germinate',
+             'semantic_version': 22800},
+            distro.parse_dpkg_version('2.28', name='germinate'))
+
+    def test_complex_native_package_version(self):
+        dver = '1.0.106ubuntu2+really1.0.97ubuntu1'
+        self.assertEqual(
+            {'major': 1, 'minor': 0, 'micro': 106,
+             'extra': 'ubuntu2+really1.0.97ubuntu1',
+             'raw': dver, 'upstream': dver, 'name': 'debootstrap',
+             'semantic_version': 100106},
+            distro.parse_dpkg_version(dver, name='debootstrap',
+                                      semx=(100000, 1000, 1)))
+
+    def test_simple_valid(self):
+        self.assertEqual(
+            {'major': 1, 'minor': 2, 'micro': 3, 'extra': None,
+             'raw': '1.2.3-0', 'upstream': '1.2.3', 'name': 'foo',
+             'semantic_version': 10203},
+            distro.parse_dpkg_version('1.2.3-0', name='foo'))
+
+    def test_simple_valid_with_semx(self):
+        self.assertEqual(
+            {'major': 1, 'minor': 2, 'micro': 3, 'extra': None,
+             'raw': '1.2.3-0', 'upstream': '1.2.3',
+             'semantic_version': 123},
+            distro.parse_dpkg_version('1.2.3-0', semx=(100, 10, 1)))
+
+    def test_upstream_with_hyphen(self):
+        """upstream versions may have a hyphen."""
+        cver = '18.2-14-g6d48d265-0ubuntu1'
+        self.assertEqual(
+            {'major': 18, 'minor': 2, 'micro': 0, 'extra': '-14-g6d48d265',
+             'raw': cver, 'upstream': '18.2-14-g6d48d265',
+             'name': 'cloud-init', 'semantic_version': 180200},
+            distro.parse_dpkg_version(cver, name='cloud-init'))
+
+    def test_upstream_with_plus(self):
+        """multipath tools has a + in it."""
+        mver = '0.5.0+git1.656f8865-5ubuntu2.5'
+        self.assertEqual(
+            {'major': 0, 'minor': 5, 'micro': 0, 'extra': '+git1.656f8865',
+             'raw': mver, 'upstream': '0.5.0+git1.656f8865',
+             'semantic_version': 500},
+            distro.parse_dpkg_version(mver))
+
+
+class TestDistros(CiTestCase):
+
+    def test_distro_names(self):
+        all_distros = list(distro.DISTROS)
+        for distro_name in distro.DISTRO_NAMES:
+            distro_enum = getattr(distro.DISTROS, distro_name)
+            self.assertIn(distro_enum, all_distros)
+
+    def test_distro_names_unknown(self):
+        distro_name = "ImNotADistro"
+        self.assertNotIn(distro_name, distro.DISTRO_NAMES)
+        with self.assertRaises(AttributeError):
+            getattr(distro.DISTROS, distro_name)
+
+    def test_distro_osfamily(self):
+        for variant, family in distro.OS_FAMILIES.items():
+            self.assertNotEqual(variant, family)
+            self.assertIn(variant, distro.DISTROS)
+            for dname in family:
+                self.assertIn(dname, distro.DISTROS)
+
+    def test_distro_osfmaily_identity(self):
+        for family, variants in distro.OS_FAMILIES.items():
+            self.assertIn(family, variants)
+
+    def test_name_to_distro(self):
+        for distro_name in distro.DISTRO_NAMES:
+            dobj = distro.name_to_distro(distro_name)
+            self.assertEqual(dobj, getattr(distro.DISTROS, distro_name))
+
+    def test_name_to_distro_unknown_value(self):
+        with self.assertRaises(ValueError):
+            distro.name_to_distro(None)
+
+    def test_name_to_distro_unknown_attr(self):
+        with self.assertRaises(ValueError):
+            distro.name_to_distro('NotADistro')
+
+    def test_distros_unknown_attr(self):
+        with self.assertRaises(AttributeError):
+            distro.DISTROS.notadistro
+
+    def test_distros_unknown_index(self):
+        with self.assertRaises(IndexError):
+            distro.DISTROS[len(distro.DISTROS)+1]
+
+
+class TestDistroInfo(CiTestCase):
+
+    def setUp(self):
+        super(TestDistroInfo, self).setUp()
+        self.add_patch('curtin.distro.os_release', 'mock_os_release')
+
+    def test_get_distroinfo(self):
+        for distro_name in distro.DISTRO_NAMES:
+            self.mock_os_release.return_value = {'ID': distro_name}
+            variant = distro.name_to_distro(distro_name)
+            family = distro.DISTRO_TO_OSFAMILY[variant]
+            distro_info = distro.get_distroinfo()
+            self.assertEqual(variant, distro_info.variant)
+            self.assertEqual(family, distro_info.family)
+
+    def test_get_distro(self):
+        for distro_name in distro.DISTRO_NAMES:
+            self.mock_os_release.return_value = {'ID': distro_name}
+            variant = distro.name_to_distro(distro_name)
+            distro_obj = distro.get_distro()
+            self.assertEqual(variant, distro_obj)
+
+    def test_get_osfamily(self):
+        for distro_name in distro.DISTRO_NAMES:
+            self.mock_os_release.return_value = {'ID': distro_name}
+            variant = distro.name_to_distro(distro_name)
+            family = distro.DISTRO_TO_OSFAMILY[variant]
+            distro_obj = distro.get_osfamily()
+            self.assertEqual(family, distro_obj)
+
+
+class TestDistroIdentity(CiTestCase):
+
+    def setUp(self):
+        super(TestDistroIdentity, self).setUp()
+        self.add_patch('curtin.distro.os.path.exists', 'mock_os_path')
+
+    def test_is_ubuntu_core(self):
+        for exists in [True, False]:
+            self.mock_os_path.return_value = exists
+            self.assertEqual(exists, distro.is_ubuntu_core())
+            self.mock_os_path.assert_called_with('/system-data/var/lib/snapd')
+
+    def test_is_centos(self):
+        for exists in [True, False]:
+            self.mock_os_path.return_value = exists
+            self.assertEqual(exists, distro.is_centos())
+            self.mock_os_path.assert_called_with('/etc/centos-release')
+
+    def test_is_rhel(self):
+        for exists in [True, False]:
+            self.mock_os_path.return_value = exists
+            self.assertEqual(exists, distro.is_rhel())
+            self.mock_os_path.assert_called_with('/etc/redhat-release')
+
+
+class TestYumInstall(CiTestCase):
+
+    @mock.patch.object(util.ChrootableTarget, "__enter__", new=lambda a: a)
+    @mock.patch('curtin.util.subp')
+    def test_yum_install(self, m_subp):
+        pkglist = ['foobar', 'wark']
+        target = 'mytarget'
+        mode = 'install'
+        expected_calls = [
+            mock.call(['yum', '--assumeyes', '--quiet', 'install',
+                       '--downloadonly', '--setopt=keepcache=1'] + pkglist,
+                      env=None, retries=[1] * 10,
+                      target=paths.target_path(target)),
+            mock.call(['yum', '--assumeyes', '--quiet', 'install',
+                       '--cacheonly'] + pkglist, env=None,
+                      target=paths.target_path(target))
+        ]
+
+        # call yum_install directly
+        distro.yum_install(mode, pkglist, target=target)
+        m_subp.assert_has_calls(expected_calls)
+
+        # call yum_install through run_yum_command
+        m_subp.reset()
+        distro.run_yum_command('install', pkglist, target=target)
+        m_subp.assert_has_calls(expected_calls)
+
+        # call yum_install through install_packages
+        m_subp.reset()
+        osfamily = distro.DISTROS.redhat
+        distro.install_packages(pkglist, osfamily=osfamily, target=target)
+        m_subp.assert_has_calls(expected_calls)
+
+
+class TestHasPkgAvailable(CiTestCase):
+
+    def setUp(self):
+        super(TestHasPkgAvailable, self).setUp()
+        self.package = 'foobar'
+        self.target = paths.target_path('mytarget')
+
+    @mock.patch.object(util.ChrootableTarget, "__enter__", new=lambda a: a)
+    @mock.patch('curtin.distro.subp')
+    def test_has_pkg_available_debian(self, m_subp):
+        osfamily = distro.DISTROS.debian
+        m_subp.return_value = (self.package, '')
+        result = distro.has_pkg_available(self.package, self.target, osfamily)
+        self.assertTrue(result)
+        m_subp.assert_has_calls([mock.call(['apt-cache', 'pkgnames'],
+                                           capture=True,
+                                           target=self.target)])
+
+    @mock.patch.object(util.ChrootableTarget, "__enter__", new=lambda a: a)
+    @mock.patch('curtin.distro.subp')
+    def test_has_pkg_available_debian_returns_false_not_avail(self, m_subp):
+        pkg = 'wark'
+        osfamily = distro.DISTROS.debian
+        m_subp.return_value = (pkg, '')
+        result = distro.has_pkg_available(self.package, self.target, osfamily)
+        self.assertEqual(pkg == self.package, result)
+        m_subp.assert_has_calls([mock.call(['apt-cache', 'pkgnames'],
+                                           capture=True,
+                                           target=self.target)])
+
+    @mock.patch.object(util.ChrootableTarget, "__enter__", new=lambda a: a)
+    @mock.patch('curtin.distro.run_yum_command')
+    def test_has_pkg_available_redhat(self, m_subp):
+        osfamily = distro.DISTROS.redhat
+        m_subp.return_value = (self.package, '')
+        result = distro.has_pkg_available(self.package, self.target, osfamily)
+        self.assertTrue(result)
+        m_subp.assert_has_calls([mock.call('list', opts=['--cacheonly'])])
+
+    @mock.patch.object(util.ChrootableTarget, "__enter__", new=lambda a: a)
+    @mock.patch('curtin.distro.run_yum_command')
+    def test_has_pkg_available_redhat_returns_false_not_avail(self, m_subp):
+        pkg = 'wark'
+        osfamily = distro.DISTROS.redhat
+        m_subp.return_value = (pkg, '')
+        result = distro.has_pkg_available(self.package, self.target, osfamily)
+        self.assertEqual(pkg == self.package, result)
+        m_subp.assert_has_calls([mock.call('list', opts=['--cacheonly'])])
+
+# vi: ts=4 expandtab syntax=python
diff --git a/tests/unittests/test_feature.py b/tests/unittests/test_feature.py
index c62e0cd..7c55882 100644
--- a/tests/unittests/test_feature.py
+++ b/tests/unittests/test_feature.py
@@ -21,4 +21,7 @@ class TestExportsFeatures(CiTestCase):
     def test_has_centos_apply_network_config(self):
         self.assertIn('CENTOS_APPLY_NETWORK_CONFIG', curtin.FEATURES)
 
+    def test_has_centos_curthook_support(self):
+        self.assertIn('CENTOS_CURTHOOK_SUPPORT', curtin.FEATURES)
+
 # vi: ts=4 expandtab syntax=python
diff --git a/tests/unittests/test_pack.py b/tests/unittests/test_pack.py
index 1aae456..cb0b135 100644
--- a/tests/unittests/test_pack.py
+++ b/tests/unittests/test_pack.py
@@ -97,6 +97,8 @@ class TestPack(TestCase):
             }}
 
         out, err, rc, log_contents = self.run_install(cfg)
+        print("out=%s" % out)
+        print("err=%s" % err)
 
         # the version string and users command output should be in output
         self.assertIn(version.version_string(), out)
diff --git a/tests/unittests/test_util.py b/tests/unittests/test_util.py
index 7fb332d..a64be16 100644
--- a/tests/unittests/test_util.py
+++ b/tests/unittests/test_util.py
@@ -4,10 +4,10 @@ from unittest import skipIf
 import mock
 import os
 import stat
-import sys
 from textwrap import dedent
 
 from curtin import util
+from curtin import paths
 from .helpers import CiTestCase, simple_mocked_open
 
 
@@ -104,48 +104,6 @@ class TestWhich(CiTestCase):
         self.assertEqual(found, "/usr/bin2/fuzz")
 
 
-class TestLsbRelease(CiTestCase):
-
-    def setUp(self):
-        super(TestLsbRelease, self).setUp()
-        self._reset_cache()
-
-    def _reset_cache(self):
-        keys = [k for k in util._LSB_RELEASE.keys()]
-        for d in keys:
-            del util._LSB_RELEASE[d]
-
-    @mock.patch("curtin.util.subp")
-    def test_lsb_release_functional(self, mock_subp):
-        output = '\n'.join([
-            "Distributor ID: Ubuntu",
-            "Description:    Ubuntu 14.04.2 LTS",
-            "Release:    14.04",
-            "Codename:   trusty",
-        ])
-        rdata = {'id': 'Ubuntu', 'description': 'Ubuntu 14.04.2 LTS',
-                 'codename': 'trusty', 'release': '14.04'}
-
-        def fake_subp(cmd, capture=False, target=None):
-            return output, 'No LSB modules are available.'
-
-        mock_subp.side_effect = fake_subp
-        found = util.lsb_release()
-        mock_subp.assert_called_with(
-            ['lsb_release', '--all'], capture=True, target=None)
-        self.assertEqual(found, rdata)
-
-    @mock.patch("curtin.util.subp")
-    def test_lsb_release_unavailable(self, mock_subp):
-        def doraise(*args, **kwargs):
-            raise util.ProcessExecutionError("foo")
-        mock_subp.side_effect = doraise
-
-        expected = {k: "UNAVAILABLE" for k in
-                    ('id', 'description', 'codename', 'release')}
-        self.assertEqual(util.lsb_release(), expected)
-
-
 class TestSubp(CiTestCase):
 
     stdin2err = ['bash', '-c', 'cat >&2']
@@ -312,7 +270,7 @@ class TestSubp(CiTestCase):
         # if target is not provided or is /, chroot should not be used
         calls = m_popen.call_args_list
         popen_args, popen_kwargs = calls[-1]
-        target = util.target_path(kwargs.get('target', None))
+        target = paths.target_path(kwargs.get('target', None))
         unshcmd = self.mock_get_unshare_pid_args.return_value
         if target == "/":
             self.assertEqual(unshcmd + list(cmd), popen_args[0])
@@ -554,44 +512,44 @@ class TestSetUnExecutable(CiTestCase):
 
 class TestTargetPath(CiTestCase):
     def test_target_empty_string(self):
-        self.assertEqual("/etc/passwd", util.target_path("", "/etc/passwd"))
+        self.assertEqual("/etc/passwd", paths.target_path("", "/etc/passwd"))
 
     def test_target_non_string_raises(self):
-        self.assertRaises(ValueError, util.target_path, False)
-        self.assertRaises(ValueError, util.target_path, 9)
-        self.assertRaises(ValueError, util.target_path, True)
+        self.assertRaises(ValueError, paths.target_path, False)
+        self.assertRaises(ValueError, paths.target_path, 9)
+        self.assertRaises(ValueError, paths.target_path, True)
 
     def test_lots_of_slashes_is_slash(self):
-        self.assertEqual("/", util.target_path("/"))
-        self.assertEqual("/", util.target_path("//"))
-        self.assertEqual("/", util.target_path("///"))
-        self.assertEqual("/", util.target_path("////"))
+        self.assertEqual("/", paths.target_path("/"))
+        self.assertEqual("/", paths.target_path("//"))
+        self.assertEqual("/", paths.target_path("///"))
+        self.assertEqual("/", paths.target_path("////"))
 
     def test_empty_string_is_slash(self):
-        self.assertEqual("/", util.target_path(""))
+        self.assertEqual("/", paths.target_path(""))
 
     def test_recognizes_relative(self):
-        self.assertEqual("/", util.target_path("/foo/../"))
-        self.assertEqual("/", util.target_path("/foo//bar/../../"))
+        self.assertEqual("/", paths.target_path("/foo/../"))
+        self.assertEqual("/", paths.target_path("/foo//bar/../../"))
 
     def test_no_path(self):
-        self.assertEqual("/my/target", util.target_path("/my/target"))
+        self.assertEqual("/my/target", paths.target_path("/my/target"))
 
     def test_no_target_no_path(self):
-        self.assertEqual("/", util.target_path(None))
+        self.assertEqual("/", paths.target_path(None))
 
     def test_no_target_with_path(self):
-        self.assertEqual("/my/path", util.target_path(None, "/my/path"))
+        self.assertEqual("/my/path", paths.target_path(None, "/my/path"))
 
     def test_trailing_slash(self):
         self.assertEqual("/my/target/my/path",
-                         util.target_path("/my/target/", "/my/path"))
+                         paths.target_path("/my/target/", "/my/path"))
 
     def test_bunch_of_slashes_in_path(self):
         self.assertEqual("/target/my/path/",
-                         util.target_path("/target/", "//my/path/"))
+                         paths.target_path("/target/", "//my/path/"))
         self.assertEqual("/target/my/path/",
-                         util.target_path("/target/", "///my/path/"))
+                         paths.target_path("/target/", "///my/path/"))
 
 
 class TestRunInChroot(CiTestCase):
@@ -1036,65 +994,4 @@ class TestLoadKernelModule(CiTestCase):
         self.assertEqual(0, self.m_subp.call_count)
 
 
-class TestParseDpkgVersion(CiTestCase):
-    """test parse_dpkg_version."""
-
-    def test_none_raises_type_error(self):
-        self.assertRaises(TypeError, util.parse_dpkg_version, None)
-
-    @skipIf(sys.version_info.major < 3, "python 2 bytes are strings.")
-    def test_bytes_raises_type_error(self):
-        self.assertRaises(TypeError, util.parse_dpkg_version, b'1.2.3-0')
-
-    def test_simple_native_package_version(self):
-        """dpkg versions must have a -. If not present expect value error."""
-        self.assertEqual(
-            {'major': 2, 'minor': 28, 'micro': 0, 'extra': None,
-             'raw': '2.28', 'upstream': '2.28', 'name': 'germinate',
-             'semantic_version': 22800},
-            util.parse_dpkg_version('2.28', name='germinate'))
-
-    def test_complex_native_package_version(self):
-        dver = '1.0.106ubuntu2+really1.0.97ubuntu1'
-        self.assertEqual(
-            {'major': 1, 'minor': 0, 'micro': 106,
-             'extra': 'ubuntu2+really1.0.97ubuntu1',
-             'raw': dver, 'upstream': dver, 'name': 'debootstrap',
-             'semantic_version': 100106},
-            util.parse_dpkg_version(dver, name='debootstrap',
-                                    semx=(100000, 1000, 1)))
-
-    def test_simple_valid(self):
-        self.assertEqual(
-            {'major': 1, 'minor': 2, 'micro': 3, 'extra': None,
-             'raw': '1.2.3-0', 'upstream': '1.2.3', 'name': 'foo',
-             'semantic_version': 10203},
-            util.parse_dpkg_version('1.2.3-0', name='foo'))
-
-    def test_simple_valid_with_semx(self):
-        self.assertEqual(
-            {'major': 1, 'minor': 2, 'micro': 3, 'extra': None,
-             'raw': '1.2.3-0', 'upstream': '1.2.3',
-             'semantic_version': 123},
-            util.parse_dpkg_version('1.2.3-0', semx=(100, 10, 1)))
-
-    def test_upstream_with_hyphen(self):
-        """upstream versions may have a hyphen."""
-        cver = '18.2-14-g6d48d265-0ubuntu1'
-        self.assertEqual(
-            {'major': 18, 'minor': 2, 'micro': 0, 'extra': '-14-g6d48d265',
-             'raw': cver, 'upstream': '18.2-14-g6d48d265',
-             'name': 'cloud-init', 'semantic_version': 180200},
-            util.parse_dpkg_version(cver, name='cloud-init'))
-
-    def test_upstream_with_plus(self):
-        """multipath tools has a + in it."""
-        mver = '0.5.0+git1.656f8865-5ubuntu2.5'
-        self.assertEqual(
-            {'major': 0, 'minor': 5, 'micro': 0, 'extra': '+git1.656f8865',
-             'raw': mver, 'upstream': '0.5.0+git1.656f8865',
-             'semantic_version': 500},
-            util.parse_dpkg_version(mver))
-
-
 # vi: ts=4 expandtab syntax=python
diff --git a/tests/vmtests/__init__.py b/tests/vmtests/__init__.py
index bd159c4..7e31491 100644
--- a/tests/vmtests/__init__.py
+++ b/tests/vmtests/__init__.py
@@ -493,18 +493,67 @@ def skip_by_date(bugnum, fixby, removeby=None, skips=None, install=True):
     return decorator
 
 
+DEFAULT_COLLECT_SCRIPTS = {
+    'common': [textwrap.dedent("""
+        cd OUTPUT_COLLECT_D
+        cp /etc/fstab ./fstab
+        cp -a /etc/udev/rules.d ./udev_rules.d
+        ifconfig -a | cat >ifconfig_a
+        ip a | cat >ip_a
+        cp -a /var/log/messages .
+        cp -a /var/log/syslog .
+        cp -a /var/log/cloud-init* .
+        cp -a /var/lib/cloud ./var_lib_cloud
+        cp -a /run/cloud-init ./run_cloud-init
+        cp -a /proc/cmdline ./proc_cmdline
+        cp -a /proc/mounts ./proc_mounts
+        cp -a /proc/partitions ./proc_partitions
+        cp -a /proc/swaps ./proc-swaps
+        # ls -al /dev/disk/*
+        mkdir -p /dev/disk/by-dname
+        ls /dev/disk/by-dname/ | cat >ls_dname
+        ls -al /dev/disk/by-dname/ | cat >ls_al_bydname
+        ls -al /dev/disk/by-id/ | cat >ls_al_byid
+        ls -al /dev/disk/by-uuid/ | cat >ls_al_byuuid
+        blkid -o export | cat >blkid.out
+        find /boot | cat > find_boot.out
+        [ -e /sys/firmware/efi ] && {
+            efibootmgr -v | cat >efibootmgr.out;
+        }
+        """)],
+    'centos': [textwrap.dedent("""
+        # XXX: command | cat >output is required for Centos under SELinux
+        # http://danwalsh.livejournal.com/22860.html
+        cd OUTPUT_COLLECT_D
+        rpm -qa | cat >rpm_qa
+        cp -a /etc/sysconfig/network-scripts .
+        rpm -q --queryformat '%{VERSION}\n' cloud-init |tee rpm_ci_version
+        rpm -E '%rhel' > rpm_dist_version_major
+        cp -a /etc/centos-release .
+        """)],
+    'ubuntu': [textwrap.dedent("""
+        cd OUTPUT_COLLECT_D
+        dpkg-query --show \
+            --showformat='${db:Status-Abbrev}\t${Package}\t${Version}\n' \
+            > debian-packages.txt 2> debian-packages.txt.err
+        cp -av /etc/network/interfaces .
+        cp -av /etc/network/interfaces.d .
+        find /etc/network/interfaces.d > find_interfacesd
+        v=""
+        out=$(apt-config shell v Acquire::HTTP::Proxy)
+        eval "$out"
+        echo "$v" > apt-proxy
+        """)]
+}
+
+
 class VMBaseClass(TestCase):
     __test__ = False
     expected_failure = False
     arch_skip = []
     boot_timeout = BOOT_TIMEOUT
-    collect_scripts = [textwrap.dedent("""
-        cd OUTPUT_COLLECT_D
-        dpkg-query --show \
-            --showformat='${db:Status-Abbrev}\t${Package}\t${Version}\n' \
-            > debian-packages.txt 2> debian-packages.txt.err
-        cat /proc/swaps > proc-swaps
-    """)]
+    collect_scripts = []
+    extra_collect_scripts = []
     conf_file = "examples/tests/basic.yaml"
     nr_cpus = None
     dirty_disks = False
@@ -528,6 +577,10 @@ class VMBaseClass(TestCase):
     conf_replace = {}
     uefi = False
     proxy = None
+    url_map = {
+        '/MAAS/api/version/': '2.0',
+        '/MAAS/api/2.0/version/':
+            json.dumps({'version': '2.5.0+curtin-vmtest'})}
 
     # these get set from base_vm_classes
     release = None
@@ -773,6 +826,16 @@ class VMBaseClass(TestCase):
                                                              cls.arch)
             raise SkipTest(reason)
 
+        # assign default collect scripts
+        if not cls.collect_scripts:
+            cls.collect_scripts = (
+                DEFAULT_COLLECT_SCRIPTS['common'] +
+                DEFAULT_COLLECT_SCRIPTS[cls.target_distro])
+
+        # append extra from subclass
+        if cls.extra_collect_scripts:
+            cls.collect_scripts.extend(cls.extra_collect_scripts)
+
         setup_start = time.time()
         logger.info(
             ('Starting setup for testclass: {__name__} '
@@ -994,7 +1057,8 @@ class VMBaseClass(TestCase):
 
         # set reporting logger
         cls.reporting_log = os.path.join(cls.td.logs, 'webhooks-events.json')
-        reporting_logger = CaptureReporting(cls.reporting_log)
+        reporting_logger = CaptureReporting(cls.reporting_log,
+                                            url_mapping=cls.url_map)
 
         # write reporting config
         reporting_config = os.path.join(cls.td.install, 'reporting.cfg')
@@ -1442,6 +1506,8 @@ class VMBaseClass(TestCase):
         if self.target_release == "trusty":
             raise SkipTest(
                 "(LP: #1523037): dname does not work on trusty kernels")
+        if self.target_distro != "ubuntu":
+            raise SkipTest("dname not present in non-ubuntu releases")
 
         if not disk_to_check:
             disk_to_check = self.disk_to_check
@@ -1449,11 +1515,9 @@ class VMBaseClass(TestCase):
             logger.debug('test_dname: no disks to check')
             return
         logger.debug('test_dname: checking disks: %s', disk_to_check)
-        path = self.collect_path("ls_dname")
-        if not os.path.exists(path):
-            logger.debug('test_dname: no "ls_dname" file: %s', path)
-            return
-        contents = util.load_file(path)
+        self.output_files_exist(["ls_dname"])
+
+        contents = self.load_collect_file("ls_dname")
         for diskname, part in self.disk_to_check:
             if part is not 0:
                 link = diskname + "-part" + str(part)
@@ -1485,6 +1549,9 @@ class VMBaseClass(TestCase):
         """ Check that curtin has removed /etc/network/interfaces.d/eth0.cfg
             by examining the output of a find /etc/network > find_interfaces.d
         """
+        # target_distro is set for non-ubuntu targets
+        if self.target_distro != 'ubuntu':
+            raise SkipTest("eni/ifupdown not present in non-ubuntu releases")
         interfacesd = self.load_collect_file("find_interfacesd")
         self.assertNotIn("/etc/network/interfaces.d/eth0.cfg",
                          interfacesd.split("\n"))
diff --git a/tests/vmtests/helpers.py b/tests/vmtests/helpers.py
index 10e20b3..6dddcc6 100644
--- a/tests/vmtests/helpers.py
+++ b/tests/vmtests/helpers.py
@@ -2,6 +2,7 @@
 # This file is part of curtin. See LICENSE file for copyright and license info.
 
 import os
+import re
 import subprocess
 import signal
 import threading
@@ -86,7 +87,26 @@ def check_call(cmd, signal=signal.SIGTERM, **kwargs):
     return Command(cmd, signal).run(**kwargs)
 
 
-def find_testcases():
+def find_testcases_by_attr(**kwargs):
+    class_match = set()
+    for test_case in find_testcases(**kwargs):
+        tc_name = str(test_case.__class__)
+        full_path = tc_name.split("'")[1].split(".")
+        class_name = full_path[-1]
+        if class_name in class_match:
+            continue
+        class_match.add(class_name)
+        filename = "/".join(full_path[0:-1]) + ".py"
+        yield "%s:%s" % (filename, class_name)
+
+
+def _attr_match(pattern, value):
+    if not value:
+        return False
+    return re.match(pattern, str(value))
+
+
+def find_testcases(**kwargs):
     # Use the TestLoder to load all test cases defined within tests/vmtests/
     # and figure out what distros and releases they are testing. Any tests
     # which are disabled will be excluded.
@@ -97,12 +117,19 @@ def find_testcases():
     root_dir = os.path.split(os.path.split(tests_dir)[0])[0]
     # Find all test modules defined in curtin/tests/vmtests/
     module_test_suites = loader.discover(tests_dir, top_level_dir=root_dir)
+    filter_attrs = [attr for attr, value in kwargs.items() if value]
     for mts in module_test_suites:
         for class_test_suite in mts:
             for test_case in class_test_suite:
                 # skip disabled tests
                 if not getattr(test_case, '__test__', False):
                     continue
+                # compare each filter attr with the specified value
+                tcmatch = [not _attr_match(kwargs[attr],
+                                           getattr(test_case, attr, False))
+                           for attr in filter_attrs]
+                if any(tcmatch):
+                    continue
                 yield test_case
 
 
diff --git a/tests/vmtests/image_sync.py b/tests/vmtests/image_sync.py
index e2cedc1..69c19ef 100644
--- a/tests/vmtests/image_sync.py
+++ b/tests/vmtests/image_sync.py
@@ -30,7 +30,9 @@ IMAGE_SRC_URL = os.environ.get(
     "http://maas.ubuntu.com/images/ephemeral-v3/daily/streams/v1/index.sjson")
 IMAGE_DIR = os.environ.get("IMAGE_DIR", "/srv/images")
 
-KEYRING = '/usr/share/keyrings/ubuntu-cloudimage-keyring.gpg'
+KEYRING = os.environ.get(
+    'IMAGE_SRC_KEYRING',
+    '/usr/share/keyrings/ubuntu-cloudimage-keyring.gpg')
 ITEM_NAME_FILTERS = \
     ['ftype~(boot-initrd|boot-kernel|root-tgz|squashfs)']
 FORMAT_JSON = 'JSON'
diff --git a/tests/vmtests/releases.py b/tests/vmtests/releases.py
index 02cbfe5..7be8feb 100644
--- a/tests/vmtests/releases.py
+++ b/tests/vmtests/releases.py
@@ -131,8 +131,8 @@ class _Releases(object):
 
 
 class _CentosReleases(object):
-    centos70fromxenial = _Centos70FromXenialBase
-    centos66fromxenial = _Centos66FromXenialBase
+    centos70_xenial = _Centos70FromXenialBase
+    centos66_xenial = _Centos66FromXenialBase
 
 
 class _UbuntuCoreReleases(object):
diff --git a/tests/vmtests/report_webhook_logger.py b/tests/vmtests/report_webhook_logger.py
index e95397c..5e7d63b 100755
--- a/tests/vmtests/report_webhook_logger.py
+++ b/tests/vmtests/report_webhook_logger.py
@@ -76,7 +76,10 @@ class ServerHandler(http_server.SimpleHTTPRequestHandler):
         self._message = None
         self.send_response(200)
         self.end_headers()
-        self.wfile.write(("content of %s\n" % self.path).encode('utf-8'))
+        if self.url_mapping and self.path in self.url_mapping:
+            self.wfile.write(self.url_mapping[self.path].encode('utf-8'))
+        else:
+            self.wfile.write(("content of %s\n" % self.path).encode('utf-8'))
 
     def do_POST(self):
         length = int(self.headers['Content-Length'])
@@ -96,13 +99,14 @@ class ServerHandler(http_server.SimpleHTTPRequestHandler):
         self.wfile.write(msg.encode('utf-8'))
 
 
-def GenServerHandlerWithResultFile(file_path):
+def GenServerHandlerWithResultFile(file_path, url_map):
     class ExtendedServerHandler(ServerHandler):
         result_log_file = file_path
+        url_mapping = url_map
     return ExtendedServerHandler
 
 
-def get_httpd(port=None, result_file=None):
+def get_httpd(port=None, result_file=None, url_mapping=None):
     # avoid 'Address already in use' after ctrl-c
     socketserver.TCPServer.allow_reuse_address = True
 
@@ -111,7 +115,7 @@ def get_httpd(port=None, result_file=None):
         port = 0
 
     if result_file:
-        Handler = GenServerHandlerWithResultFile(result_file)
+        Handler = GenServerHandlerWithResultFile(result_file, url_mapping)
     else:
         Handler = ServerHandler
     httpd = HTTPServerV6(("::", port), Handler)
@@ -143,10 +147,11 @@ def run_server(port=DEFAULT_PORT, log_data=True):
 
 class CaptureReporting:
 
-    def __init__(self, result_file):
+    def __init__(self, result_file, url_mapping=None):
+        self.url_mapping = url_mapping
         self.result_file = result_file
         self.httpd = get_httpd(result_file=self.result_file,
-                               port=None)
+                               port=None, url_mapping=self.url_mapping)
         self.httpd.server_activate()
         # socket.AF_INET6 returns
         # (host, port, flowinfo, scopeid)
diff --git a/tests/vmtests/test_apt_config_cmd.py b/tests/vmtests/test_apt_config_cmd.py
index efd04f3..f9b6a09 100644
--- a/tests/vmtests/test_apt_config_cmd.py
+++ b/tests/vmtests/test_apt_config_cmd.py
@@ -12,16 +12,14 @@ from .releases import base_vm_classes as relbase
 
 class TestAptConfigCMD(VMBaseClass):
     """TestAptConfigCMD - test standalone command"""
+    test_type = 'config'
     conf_file = "examples/tests/apt_config_command.yaml"
     interactive = False
     extra_disks = []
     fstab_expected = {}
     disk_to_check = []
-    collect_scripts = VMBaseClass.collect_scripts + [textwrap.dedent("""
+    extra_collect_scripts = [textwrap.dedent("""
         cd OUTPUT_COLLECT_D
-        cat /etc/fstab > fstab
-        ls /dev/disk/by-dname > ls_dname
-        find /etc/network/interfaces.d > find_interfacesd
         cp /etc/apt/sources.list.d/curtin-dev-ubuntu-test-archive-*.list .
         cp /etc/cloud/cloud.cfg.d/curtin-preserve-sources.cfg .
         apt-cache policy | grep proposed > proposed-enabled
diff --git a/tests/vmtests/test_apt_source.py b/tests/vmtests/test_apt_source.py
index f34913a..bb502b2 100644
--- a/tests/vmtests/test_apt_source.py
+++ b/tests/vmtests/test_apt_source.py
@@ -14,15 +14,13 @@ from curtin import util
 
 class TestAptSrcAbs(VMBaseClass):
     """TestAptSrcAbs - Basic tests for apt features of curtin"""
+    test_type = 'config'
     interactive = False
     extra_disks = []
     fstab_expected = {}
     disk_to_check = []
-    collect_scripts = VMBaseClass.collect_scripts + [textwrap.dedent("""
+    extra_collect_scripts = [textwrap.dedent("""
         cd OUTPUT_COLLECT_D
-        cat /etc/fstab > fstab
-        ls /dev/disk/by-dname > ls_dname
-        find /etc/network/interfaces.d > find_interfacesd
         apt-key list "F430BBA5" > keyid-F430BBA5
         apt-key list "0165013E" > keyppa-0165013E
         apt-key list "F470A0AC" > keylongid-F470A0AC
diff --git a/tests/vmtests/test_basic.py b/tests/vmtests/test_basic.py
index 01ffc89..54e3df8 100644
--- a/tests/vmtests/test_basic.py
+++ b/tests/vmtests/test_basic.py
@@ -4,12 +4,14 @@ from . import (
     VMBaseClass,
     get_apt_proxy)
 from .releases import base_vm_classes as relbase
+from .releases import centos_base_vm_classes as centos_relbase
 
 import textwrap
 from unittest import SkipTest
 
 
 class TestBasicAbs(VMBaseClass):
+    test_type = 'storage'
     interactive = False
     nr_cpus = 2
     dirty_disks = True
@@ -18,29 +20,18 @@ class TestBasicAbs(VMBaseClass):
     nvme_disks = ['4G']
     disk_to_check = [('main_disk_with_in---valid--dname', 1),
                      ('main_disk_with_in---valid--dname', 2)]
-    collect_scripts = VMBaseClass.collect_scripts + [textwrap.dedent("""
+    extra_collect_scripts = [textwrap.dedent("""
         cd OUTPUT_COLLECT_D
-        blkid -o export /dev/vda > blkid_output_vda
-        blkid -o export /dev/vda1 > blkid_output_vda1
-        blkid -o export /dev/vda2 > blkid_output_vda2
+        blkid -o export /dev/vda | cat >blkid_output_vda
+        blkid -o export /dev/vda1 | cat >blkid_output_vda1
+        blkid -o export /dev/vda2 | cat >blkid_output_vda2
         dev="/dev/vdd"; f="btrfs_uuid_${dev#/dev/*}";
         if command -v btrfs-debug-tree >/dev/null; then
            btrfs-debug-tree -r $dev | awk '/^uuid/ {print $2}' | grep "-"
         else
            btrfs inspect-internal dump-super $dev |
                awk '/^dev_item.fsid/ {print $2}'
-        fi > $f
-        cat /proc/partitions > proc_partitions
-        ls -al /dev/disk/by-uuid/ > ls_uuid
-        cat /etc/fstab > fstab
-        mkdir -p /dev/disk/by-dname
-        ls /dev/disk/by-dname/ > ls_dname
-        find /etc/network/interfaces.d > find_interfacesd
-
-        v=""
-        out=$(apt-config shell v Acquire::HTTP::Proxy)
-        eval "$out"
-        echo "$v" > apt-proxy
+        fi | cat >$f
         """)]
 
     def _kname_to_uuid(self, kname):
@@ -48,7 +39,7 @@ class TestBasicAbs(VMBaseClass):
         # parsing ls -al output on /dev/disk/by-uuid:
         # lrwxrwxrwx 1 root root   9 Dec  4 20:02
         #  d591e9e9-825a-4f0a-b280-3bfaf470b83c -> ../../vdg
-        ls_uuid = self.load_collect_file("ls_uuid")
+        ls_uuid = self.load_collect_file("ls_al_byuuid")
         uuid = [line.split()[8] for line in ls_uuid.split('\n')
                 if ("../../" + kname) in line.split()]
         self.assertEqual(len(uuid), 1)
@@ -57,81 +48,99 @@ class TestBasicAbs(VMBaseClass):
         self.assertEqual(len(uuid), 36)
         return uuid
 
-    def test_output_files_exist(self):
-        self.output_files_exist(
-            ["blkid_output_vda", "blkid_output_vda1", "blkid_output_vda2",
-             "btrfs_uuid_vdd", "fstab", "ls_dname", "ls_uuid",
-             "proc_partitions",
-             "root/curtin-install.log", "root/curtin-install-cfg.yaml"])
-
-    def test_ptable(self, disk_to_check=None):
+    def _test_ptable(self, blkid_output, expected):
         if self.target_release == "trusty":
             raise SkipTest("No PTTYPE blkid output on trusty")