Merge lp:~smoser/curtin/centos-passthrough into lp:~curtin-dev/curtin/trunk

[Scott Moser]

This builds on
https://code.launchpad.net/~raharper/curtin/centos-passthrough/+merge/327536
i have a vmtest run going at
 https://jenkins.ubuntu.com/server/view/Curtin/job/curtin-vmtest-devel-debug/86/console

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

PASSED: Continuous integration, rev:581
https://jenkins.ubuntu.com/server/job/curtin-ci/554/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-amd64/554
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/554
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/554
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/554
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=vm-i386/554

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

review: Approve (continuous-integration)

[lp:~smoser/curtin/centos-passthrough]

582. By Scott Moser on 2017-07-27

skip_by_date on mtu tests for CentOS.

This does a skip by date for bug 1706973 on the individual tests:
    test_ipv6_mtu_smaller_than_ipv4_v6_iface_first(cls):
    test_ipv6_mtu_smaller_than_ipv4_non_default(cls):
    test_ipv6_mtu_higher_than_default_no_ipv4_iface_up(cls):
    test_ipv6_mtu_higher_than_default_no_ipv4_iface_v6_iface_first(cls):

It also adds a 'pass' for test_ip_output, which just currently run
correctly.

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

PASSED: Continuous integration, rev:582
https://jenkins.ubuntu.com/server/job/curtin-ci/555/
Executed test runs:
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-amd64/555
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/555
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/555
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/555
    SUCCESS: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=vm-i386/555

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

review: Approve (continuous-integration)

=== modified file 'curtin/__init__.py'
--- curtin/__init__.py	2017-03-21 16:41:33 +0000
+++ curtin/__init__.py	2017-07-27 13:56:24 +0000
@@ -23,6 +23,8 @@
 # can determine which features are supported.  Each entry should have
 # a consistent meaning.
 FEATURES = [
+    # curtin can configure centos networking via curthooks function
+    'CENTOS_NETWORK_CURTHOOKS',
     # install supports the 'network' config version 1
     'NETWORK_CONFIG_V1',
     # reporter supports 'webhook' type

=== modified file 'curtin/block/__init__.py'
--- curtin/block/__init__.py	2017-05-19 18:52:21 +0000
+++ curtin/block/__init__.py	2017-07-27 13:56:24 +0000
@@ -19,7 +19,6 @@
 import errno
 import itertools
 import os
-import shlex
 import stat
 import sys
 import tempfile
@@ -204,30 +203,13 @@
         return [path_to_kname(device)]
 
 
-def _shlex_split(str_in):
-    # shlex.split takes a string
-    # but in python2 if input here is a unicode, encode it to a string.
-    # http://stackoverflow.com/questions/2365411/
-    #     python-convert-unicode-to-ascii-without-errors
-    if sys.version_info.major == 2:
-        try:
-            if isinstance(str_in, unicode):
-                str_in = str_in.encode('utf-8')
-        except NameError:
-            pass
-
-        return shlex.split(str_in)
-    else:
-        return shlex.split(str_in)
-
-
 def _lsblock_pairs_to_dict(lines):
     """
     parse lsblock output and convert to dict
     """
     ret = {}
     for line in lines.splitlines():
-        toks = _shlex_split(line)
+        toks = util.shlex_split(line)
         cur = {}
         for tok in toks:
             k, v = tok.split("=", 1)
@@ -468,7 +450,7 @@
     for line in out.splitlines():
         curdev, curdata = line.split(":", 1)
         data[curdev] = dict(tok.split('=', 1)
-                            for tok in _shlex_split(curdata))
+                            for tok in util.shlex_split(curdata))
     return data
 
 
@@ -978,4 +960,71 @@
     else:
         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'],
+                'lvm_partition': ['lvm2'],
+                'lvm_volgroup': ['lvm2'],
+                'raid': ['mdadm'],
+                'xfs': ['xfsprogs']
+            },
+        },
+    }
+    return mapping
+
+
 # vi: ts=4 expandtab syntax=python

=== modified file 'curtin/commands/apply_net.py'
--- curtin/commands/apply_net.py	2017-02-08 05:56:12 +0000
+++ curtin/commands/apply_net.py	2017-07-27 13:56:24 +0000
@@ -21,6 +21,7 @@
 from .. import log
 import curtin.net as net
 import curtin.util as util
+from curtin import config
 from . import populate_one_subcmd
 
 
@@ -89,15 +90,38 @@
         sys.stderr.write(msg + "\n")
         raise Exception(msg)
 
+    passthrough = False
     if network_state:
+        # NB: we cannot support passthrough until curtin can convert from
+        # network_state to network-config yaml
         ns = net.network_state.from_state_file(network_state)
+        raise ValueError('Not Supported; curtin lacks a network_state to '
+                         'network_config converter.')
     elif network_config:
-        ns = net.parse_net_config(network_config)
-
-    net.render_network_state(target=target, network_state=ns)
+        netcfg = config.load_config(network_config)
+
+        # curtin will pass-through the netconfig into the target
+        # for rendering at runtime unless the target OS does not
+        # support NETWORK_CONFIG_V2 feature.
+        LOG.info('Checking cloud-init in target [%s] for network '
+                 'configuration passthrough support.', target)
+        try:
+            passthrough = net.netconfig_passthrough_available(target)
+        except util.ProcessExecutionError:
+            LOG.warning('Failed to determine if passthrough is available')
+
+        if passthrough:
+            LOG.info('Passing network configuration through to target: %s',
+                     target)
+            net.render_netconfig_passthrough(target, netconfig=netcfg)
+        else:
+            ns = net.parse_net_config_data(netcfg.get('network', {}))
+
+    if not passthrough:
+        LOG.info('Rendering network configuration in target')
+        net.render_network_state(target=target, network_state=ns)
 
     _maybe_remove_legacy_eth0(target)
-    LOG.info('Attempting to remove ipv6 privacy extensions')
     _disable_ipv6_privacy_extensions(target)
     _patch_ifupdown_ipv6_mtu_hook(target)
 
@@ -130,6 +154,7 @@
        by default; this races with the cloud-image desire to disable them.
        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)
     if not os.path.exists(cfg):
         LOG.warn('Failed to find ipv6 privacy conf file %s', cfg)
@@ -143,7 +168,7 @@
         lines = [f.strip() for f in contents.splitlines()
                  if not f.startswith("#")]
         if lines == known_contents:
-            LOG.info('deleting file: %s', cfg)
+            LOG.info('Removing ipv6 privacy extension config file: %s', cfg)
             util.del_file(cfg)
             msg = "removed %s with known contents" % cfg
             curtin_contents = '\n'.join(
@@ -153,9 +178,10 @@
                  "# net.ipv6.conf.default.use_tempaddr = 2"])
             util.write_file(cfg, curtin_contents)
         else:
-            LOG.info('skipping, content didnt match')
-            LOG.debug("found content:\n%s", lines)
-            LOG.debug("expected contents:\n%s", known_contents)
+            LOG.debug('skipping removal of %s, expected content not found',
+                      cfg)
+            LOG.debug("Found content in file %s:\n%s", cfg, lines)
+            LOG.debug("Expected contents in file %s:\n%s", cfg, known_contents)
             msg = (bmsg + " '%s' exists with user configured content." % cfg)
     except Exception as e:
         msg = bmsg + " %s exists, but could not be read. %s" % (cfg, e)

=== modified file 'curtin/commands/curthooks.py'
--- curtin/commands/curthooks.py	2017-05-12 00:49:43 +0000
+++ curtin/commands/curthooks.py	2017-07-27 13:56:24 +0000
@@ -16,6 +16,7 @@
 #   along with Curtin.  If not, see <http://www.gnu.org/licenses/>.
 
 import copy
+import glob
 import os
 import platform
 import re
@@ -25,6 +26,7 @@
 
 from curtin import config
 from curtin import block
+from curtin import net
 from curtin import futil
 from curtin.log import LOG
 from curtin import swap
@@ -65,6 +67,19 @@
     }
 }
 
+CLOUD_INIT_YUM_REPO_TEMPLATE = """
+[group_cloud-init-el-stable]
+name=Copr repo for el-stable owned by @cloud-init
+baseurl=https://copr-be.cloud.fedoraproject.org/results/@cloud-init/el-stable/epel-%s-$basearch/
+type=rpm-md
+skip_if_unavailable=True
+gpgcheck=1
+gpgkey=https://copr-be.cloud.fedoraproject.org/results/@cloud-init/el-stable/pubkey.gpg
+repo_gpgcheck=0
+enabled=1
+enabled_metadata=1
+"""
+
 
 def write_files(cfg, target):
     # this takes 'write_files' entry in config and writes files in the target
@@ -648,6 +663,38 @@
     update_initramfs(target, all_kernels=True)
 
 
+def detect_required_packages(cfg):
+    """
+    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(),
+    }
+
+    needed_packages = []
+    for cfg_type, cfg_map in mapping.items():
+
+        # skip missing or invalid config items, configs may
+        # only have network or storage, not always both
+        if not isinstance(cfg.get(cfg_type), dict):
+            continue
+
+        cfg_version = cfg[cfg_type].get('version')
+        if not isinstance(cfg_version, int) or cfg_version not in cfg_map:
+            msg = ('Supplied configuration version "%s", for config type'
+                   '"%s" is not present in the known mapping.' % (cfg_version,
+                                                                  cfg_type))
+            raise ValueError(msg)
+
+        mapped_config = cfg_map[cfg_version]
+        found_reqs = mapped_config['handler'](cfg, mapped_config['mapping'])
+        needed_packages.extend(found_reqs)
+
+    return needed_packages
+
+
 def install_missing_packages(cfg, target):
     ''' describe which operation types will require specific packages
 
@@ -655,46 +702,10 @@
          'pkg1': ['op_name_1', 'op_name_2', ...]
      }
     '''
-    custom_configs = {
-        'storage': {
-            'lvm2': ['lvm_volgroup', 'lvm_partition'],
-            'mdadm': ['raid'],
-            'bcache-tools': ['bcache']},
-        'network': {
-            'vlan': ['vlan'],
-            'ifenslave': ['bond'],
-            'bridge-utils': ['bridge']},
-    }
-
-    format_configs = {
-        'xfsprogs': ['xfs'],
-        'e2fsprogs': ['ext2', 'ext3', 'ext4'],
-        'btrfs-tools': ['btrfs'],
-    }
-
-    needed_packages = []
+
     installed_packages = util.get_installed_packages(target)
-    for cust_cfg, pkg_reqs in custom_configs.items():
-        if cust_cfg not in cfg:
-            continue
-
-        all_types = set(
-            operation['type']
-            for operation in cfg[cust_cfg]['config']
-            )
-        for pkg, types in pkg_reqs.items():
-            if set(types).intersection(all_types) and \
-               pkg not in installed_packages:
-                needed_packages.append(pkg)
-
-        format_types = set(
-            [operation['fstype']
-             for operation in cfg[cust_cfg]['config']
-             if operation['type'] == 'format'])
-        for pkg, fstypes in format_configs.items():
-            if set(fstypes).intersection(format_types) and \
-               pkg not in installed_packages:
-                needed_packages.append(pkg)
+    needed_packages = [pkg for pkg in detect_required_packages(cfg)
+                       if pkg not in installed_packages]
 
     arch_packages = {
         's390x': [('s390-tools', 'zipl')],
@@ -801,11 +812,87 @@
     if netconfig:
         LOG.info('Writing network configuration')
         ubuntu_core_netconfig = os.path.join(cc_target,
-                                             "50-network-config.cfg")
+                                             "50-curtin-networking.cfg")
         util.write_file(ubuntu_core_netconfig,
                         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_network_curthooks(cfg, target=None):
+    """ 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')
+
+        return CLOUD_INIT_YUM_REPO_TEMPLATE % version
+
+    cloudconfig = cfg.get('cloudconfig', None)
+    if cloudconfig:
+        cc_target = util.target_path(target, 'etc/cloud/cloud.cfg.d')
+        handle_cloudconfig(cloudconfig, target=cc_target)
+
+    netcfg = cfg.get('network', None)
+    if netcfg:
+        LOG.info('Removing embedded network configuration (if present)')
+        ifcfgs = glob.glob(util.target_path(target,
+                                            'etc/sysconfig/network-scripts') +
+                           '/ifcfg-*')
+        # remove ifcfg-* (except ifcfg-lo)
+        for ifcfg in ifcfgs:
+            if os.path.basename(ifcfg) != "ifcfg-lo":
+                util.del_file(ifcfg)
+
+        LOG.info('Checking cloud-init in target [%s] for network '
+                 'configuration passthrough support.', target)
+        passthrough = net.netconfig_passthrough_available(target)
+        LOG.debug('passthrough available via in-target: %s', passthrough)
+
+        # 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'))
+            # Inject cloud-init daily yum repo
+            util.write_file(cloud_init_yum_repo,
+                            content=cloud_init_repo(rpm_get_dist_id(target)))
+
+            # we separate the installation of epel from cloud-init as
+            # cloud-init will depend on packages included in epel and yum needs
+            # to add the repository before we can install cloud-init
+            with util.ChrootableTarget(target) as in_chroot:
+                in_chroot.subp(['yum', '-y', 'install', 'epel-release'])
+                in_chroot.subp(['yum', '-y', 'install',
+                                'cloud-init-el-release'])
+                in_chroot.subp(['yum', '-y', 'install', 'cloud-init'])
+
+            # remove cloud-init el-stable bootstrap repo config as the
+            # cloud-init-el-release package points to the correct repo
+            util.del_file(cloud_init_yum_repo)
+
+            # install bridge-utils if needed
+            with util.ChrootableTarget(target) as in_chroot:
+                try:
+                    in_chroot.subp(['rpm', '-q', 'bridge-utils'],
+                                   capture=False, rcs=[0])
+                except util.ProcessExecutionError:
+                    LOG.debug('Image missing bridge-utils package, installing')
+                    in_chroot.subp(['yum', '-y', 'install', 'bridge-utils'])
+
+    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:
@@ -814,6 +901,22 @@
     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'))
+
+    return False
+
+
+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'))
+
+    return False
+
+
 def curthooks(args):
     state = util.load_command_environment()
 
@@ -827,14 +930,22 @@
                          "Use --target or set TARGET_MOUNT_POINT\n")
         sys.exit(2)
 
-    # if network-config hook exists in target,
-    # we do not run the builtin
-    if util.run_hook_if_exists(target, 'curtin-hooks'):
-        sys.exit(0)
-
     cfg = config.load_command_config(args, state)
     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'):
+        # XXX: For vmtest use only
+        if cfg.get('override_centos_curthooks', {}):
+            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_network_curthooks(cfg, target)
+        sys.exit(0)
+
     if target_is_ubuntu_core(target):
         LOG.info('Detected Ubuntu-Core image, running hooks')
         with events.ReportEventStack(
@@ -852,7 +963,11 @@
         disable_overlayroot(cfg, target)
 
     # packages may be needed prior to installing kernel
-    install_missing_packages(cfg, target)
+    with events.ReportEventStack(
+            name=stack_prefix + '/installing-missing-packages',
+            reporting_enabled=True, level="INFO",
+            description="installing missing packages"):
+        install_missing_packages(cfg, target)
 
     # If a /etc/iscsi/nodes/... file was created by block_meta then it
     # needs to be copied onto the target system
@@ -880,7 +995,6 @@
         setup_zipl(cfg, target)
         install_kernel(cfg, target)
         run_zipl(cfg, target)
-
         restore_dist_interfaces(cfg, target)
 
     with events.ReportEventStack(
@@ -908,12 +1022,6 @@
         detect_and_handle_multipath(cfg, target)
 
     with events.ReportEventStack(
-            name=stack_prefix + '/installing-missing-packages',
-            reporting_enabled=True, level="INFO",
-            description="installing missing packages"):
-        install_missing_packages(cfg, target)
-
-    with events.ReportEventStack(
             name=stack_prefix + '/system-upgrade',
             reporting_enabled=True, level="INFO",
             description="updating packages on target system"):

=== modified file 'curtin/net/__init__.py'
--- curtin/net/__init__.py	2017-02-06 20:58:37 +0000
+++ curtin/net/__init__.py	2017-07-27 13:56:24 +0000
@@ -520,7 +520,52 @@
     return content
 
 
+def netconfig_passthrough_available(target, feature='NETWORK_CONFIG_V2'):
+    """
+    Determine if curtin can pass v2 network config to in target cloud-init
+    """
+    LOG.debug('Checking in-target cloud-init for feature: %s', feature)
+    with util.ChrootableTarget(target) as in_chroot:
+
+        cloudinit = util.which('cloud-init', target=target)
+        if not cloudinit:
+            LOG.warning('Target does not have cloud-init installed')
+            return False
+
+        available = False
+        try:
+            out, _ = in_chroot.subp([cloudinit, 'features'], capture=True)
+            available = feature in out.splitlines()
+        except util.ProcessExecutionError:
+            # we explicitly don't dump the exception as this triggers
+            # vmtest failures when parsing the installation log file
+            LOG.warning("Failed to probe cloudinit features")
+            return False
+
+        LOG.debug('cloud-init feature %s available? %s', feature, available)
+        return available
+
+
+def render_netconfig_passthrough(target, netconfig=None):
+    """
+    Extract original network config and pass it
+    through to cloud-init in target
+    """
+    cc = 'etc/cloud/cloud.cfg.d/50-curtin-networking.cfg'
+    if not isinstance(netconfig, dict):
+        raise ValueError('Network config must be a dictionary')
+
+    if 'network' not in netconfig:
+        raise ValueError("Network config must contain the key 'network'")
+
+    content = config.dump_config(netconfig)
+    cc_passthrough = os.path.sep.join((target, cc,))
+    LOG.info('Writing network config to %s: %s', cc, cc_passthrough)
+    util.write_file(cc_passthrough, content=content)
+
+
 def render_network_state(target, network_state):
+    LOG.debug("rendering eni from netconfig")
     eni = 'etc/network/interfaces'
     netrules = 'etc/udev/rules.d/70-persistent-net.rules'
     cc = 'etc/cloud/cloud.cfg.d/curtin-disable-cloudinit-networking.cfg'
@@ -542,4 +587,65 @@
     """Returns the string value of an interface's MAC Address"""
     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

=== modified file 'curtin/util.py'
--- curtin/util.py	2017-06-05 02:55:31 +0000
+++ curtin/util.py	2017-07-27 13:56:24 +0000
@@ -23,6 +23,7 @@
 import os
 import platform
 import re
+import shlex
 import shutil
 import socket
 import subprocess
@@ -1347,6 +1348,9 @@
     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:]
@@ -1362,4 +1366,38 @@
     __call__ = ChrootableTarget.subp
 
 
+def shlex_split(str_in):
+    # shlex.split takes a string
+    # but in python2 if input here is a unicode, encode it to a string.
+    # http://stackoverflow.com/questions/2365411/
+    #     python-convert-unicode-to-ascii-without-errors
+    if sys.version_info.major == 2:
+        try:
+            if isinstance(str_in, unicode):
+                str_in = str_in.encode('utf-8')
+        except NameError:
+            pass
+
+        return shlex.split(str_in)
+    else:
+        return shlex.split(str_in)
+
+
+def load_shell_content(content, add_empty=False, empty_val=None):
+    """Given shell like syntax (key=value\nkey2=value2\n) in content
+       return the data in dictionary form.  If 'add_empty' is True
+       then add entries in to the returned dictionary for 'VAR='
+       variables.  Set their value to empty_val."""
+
+    data = {}
+    for line in shlex_split(content):
+        key, value = line.split("=", 1)
+        if not value:
+            value = empty_val
+        if add_empty or value:
+            data[key] = value
+
+    return data
+
+
 # vi: ts=4 expandtab syntax=python

=== modified file 'examples/network-ipv6-bond-vlan.yaml'
--- examples/network-ipv6-bond-vlan.yaml	2016-08-12 17:24:13 +0000
+++ examples/network-ipv6-bond-vlan.yaml	2017-07-27 13:56:24 +0000
@@ -3,10 +3,10 @@
   config:
     - name: interface0
       type: physical
-      mac_address: BC:76:4E:06:96:B3
+      mac_address: bc:76:4e:06:96:b3
     - name: interface1
       type: physical
-      mac_address: BC:76:4E:04:88:41
+      mac_address: bc:76:4e:04:88:41
     - type: bond
       bond_interfaces:
         - interface0

=== modified file 'examples/tests/bonding_network.yaml'
--- examples/tests/bonding_network.yaml	2016-06-03 19:53:18 +0000
+++ examples/tests/bonding_network.yaml	2017-07-27 13:56:24 +0000
@@ -16,8 +16,7 @@
           mac_address: "52:54:00:12:34:04"
         # Bond.
         - type: bond
-          name: bond0
-          mac_address: "52:54:00:12:34:06"
+          name: bond1
           bond_interfaces:
             - interface1
             - interface2
@@ -26,8 +25,6 @@
           subnets:
               - type: static
                 address: 10.23.23.2/24
-              - type: static
-                address: 10.23.24.2/24
 
 curthooks_commands:
     # use curtin to disable open-iscsi ifupdown hooks for precise; they're

=== modified file 'examples/tests/centos_basic.yaml'
--- examples/tests/centos_basic.yaml	2016-10-03 05:06:16 +0000
+++ examples/tests/centos_basic.yaml	2017-07-27 13:56:24 +0000
@@ -9,5 +9,6 @@
           mac_address: "52:54:00:12:34:00"
           subnets:
               - type: static
-                address: 10.0.2.15/24
+                address: 10.0.2.15
+                netmask: 255.255.255.0
                 gateway: 10.0.2.2

=== added file 'examples/tests/centos_defaults.yaml'
--- examples/tests/centos_defaults.yaml	1970-01-01 00:00:00 +0000
+++ examples/tests/centos_defaults.yaml	2017-07-27 13:56:24 +0000
@@ -0,0 +1,26 @@
+hook_commands:
+    builtin: null
+
+# Force curtin to run centos_network_curthooks for vmtest
+override_centos_curthooks: True
+
+late_commands:
+
+# centos66 images include grub 0.97 which will detect vmtests ephemeral disk
+# and the install disk which leaves grub configured with two disks.  When
+# vmtest reboots into installed disk, there is only one disk and the grub
+# map is no longer valid.  Here in 00_grub, we switch hd1 to hd0.  MAAS
+# is not affected as their ephemeral image (iscsi or http) is not discovered
+# by grub and therefor the device.map doesn't contain a second device. Cent7
+# has grub2 which uses root by UUID
+# 
+ 00_grub: [curtin, in-target, --, sed, -i.curtin, -e, 's|(hd1,0)|(hd0,0)|g',
+           -e, '$a serial --unit=0 --speed=115200\nterminal --timeout=5 serial console',
+           /boot/grub/grub.conf]
+
+# vmtest requires a serial console output
+ 01_serial: [curtin, in-target, --, sh, -c,
+             "echo 'GRUB_CMDLINE_LINUX_DEFAULT=\"console=tty0 crashkernel=auto
+             console=ttyS0,115200\" >> /etc/default/grub';
+             if command -v grub2-mkconfig &>/dev/null; then
+             grub2-mkconfig -o /boot/grub2/grub.cfg; fi;"]

=== modified file 'examples/tests/network_alias.yaml'
--- examples/tests/network_alias.yaml	2016-08-25 23:09:51 +0000
+++ examples/tests/network_alias.yaml	2017-07-27 13:56:24 +0000
@@ -8,7 +8,7 @@
           mac_address: "52:54:00:12:34:00"
           subnets:
               - type: static
-                address: 192.168.1.2/24
+                address: 10.47.98.1/24
                 mtu: 1501
               - type: static
                 address: 2001:4800:78ff:1b:be76:4eff:fe06:ffac
@@ -20,17 +20,17 @@
           mac_address: "52:54:00:12:34:02"
           subnets:
               - type: static
-                address: 192.168.2.2/22
+                address: 192.168.20.2/24
                 routes:
-                  - network: 192.168.0.0
-                    netmask: 255.255.252.0
-                    gateway: 192.168.2.1
+                  - gateway: 192.168.20.1
+                    netmask: 255.255.255.0
+                    network: 10.242.47.0
               - type: static
-                address: 10.23.23.7/23
+                address: 10.23.22.7/23
                 routes:
-                  - gateway: 10.23.23.1
-                    netmask: 255.255.254.0
-                    network: 10.23.22.0
+                  - gateway: 10.23.22.2
+                    netmask: 255.255.255.0
+                    network: 10.49.253.0
         # multi_v6_alias: multiple v6 addrs on same interface
         - type: physical
           name: interface2
@@ -51,17 +51,17 @@
           mac_address: "52:54:00:12:34:06"
           subnets:
               - type: static
-                address: 192.168.7.7/22
+                address: 192.168.80.8/24
                 routes:
-                  - network: 192.168.0.0
-                    netmask: 255.255.252.0
-                    gateway: 192.168.7.1
+                  - gateway: 192.168.80.1
+                    netmask: 255.255.255.0
+                    network: 10.189.34.0
               - type: static
-                address: 10.99.99.23/23
+                address: 10.99.10.23/23
                 routes:
-                  - gateway: 10.99.99.1
-                    netmask: 255.255.254.0
-                    network: 10.99.98.0
+                  - gateway: 10.99.10.1
+                    netmask: 255.255.255.0
+                    network: 10.77.154.0
               - type: static
                 address: 2001:4800:78ff:1b:be76:4eff:beef:4000
                 netmask: 'ffff:ffff:ffff:ffff::'
@@ -86,17 +86,17 @@
                 address: 2001:4800:78ff:1b:be76:4eff:debe:9000
                 netmask: 'ffff:ffff:ffff:ffff::'
               - type: static
-                address: 192.168.100.100/22
+                address: 192.168.100.100/24
                 routes:
-                  - network: 192.168.0.0
-                    netmask: 255.255.252.0
-                    gateway: 192.168.100.1
+                  - gateway: 192.168.100.1
+                    netmask: 255.255.255.0
+                    network: 10.28.219.0
               - type: static
                 address: 10.17.142.2/23
                 routes:
                   - gateway: 10.17.142.1
-                    netmask: 255.255.254.0
-                    network: 10.17.142.0
+                    netmask: 255.255.255.0
+                    network: 10.82.49.0
         # multi_v6_and_v4_mix_order: multiple v4 and v6 addr, mixed order
         - type: physical
           name: interface5
@@ -109,17 +109,17 @@
                 address: 2001:4800:78ff:1b:be76:4eff:baaf:c000
                 netmask: 'ffff:ffff:ffff:ffff::'
               - type: static
-                address: 192.168.200.200/22
+                address: 192.168.200.200/24
                 routes:
-                  - network: 192.168.0.0
-                    netmask: 255.255.252.0
-                    gateway: 192.168.200.1
+                  - gateway: 192.168.200.1
+                    netmask: 255.255.255.0
+                    network: 10.71.23.0
               - type: static
                 address: 10.252.2.2/23
                 routes:
                   - gateway: 10.252.2.1
-                    netmask: 255.255.254.0
-                    network: 10.252.2.0
+                    netmask: 255.255.255.0
+                    network: 10.3.7.0
               - type: static
                 address: 2001:4800:78ff:1b:be76:4eff:baaf:b000
                 netmask: 'ffff:ffff:ffff:ffff::'

=== added file 'examples/tests/network_v2_passthrough.yaml'
--- examples/tests/network_v2_passthrough.yaml	1970-01-01 00:00:00 +0000
+++ examples/tests/network_v2_passthrough.yaml	2017-07-27 13:56:24 +0000
@@ -0,0 +1,8 @@
+showtrace: true
+network:
+    version: 2
+    ethernets:
+        interface0:
+            match:
+                mac_address: "52:54:00:12:34:00"
+            dhcp4: true

=== added file 'tests/unittests/test_commands_apply_net.py'
--- tests/unittests/test_commands_apply_net.py	1970-01-01 00:00:00 +0000
+++ tests/unittests/test_commands_apply_net.py	2017-07-27 13:56:24 +0000
@@ -0,0 +1,346 @@
+from unittest import TestCase
+from mock import patch, call
+import copy
+import os
+
+from curtin.commands import apply_net
+from curtin import util
+
+
+class ApplyNetTestBase(TestCase):
+    def setUp(self):
+        super(ApplyNetTestBase, self).setUp()
+
+    def add_patch(self, target, attr):
+        """Patches specified target object and sets it as attr on test
+        instance also schedules cleanup"""
+        m = patch(target, autospec=True)
+        p = m.start()
+        self.addCleanup(m.stop)
+        setattr(self, attr, p)
+
+
+class TestApplyNet(ApplyNetTestBase):
+    def setUp(self):
+        super(TestApplyNet, self).setUp()
+
+        base = 'curtin.commands.apply_net.'
+        patches = [
+            (base + '_maybe_remove_legacy_eth0', 'm_legacy'),
+            (base + '_disable_ipv6_privacy_extensions', 'm_ipv6_priv'),
+            (base + '_patch_ifupdown_ipv6_mtu_hook', 'm_ipv6_mtu'),
+            ('curtin.net.netconfig_passthrough_available', 'm_netpass_avail'),
+            ('curtin.net.render_netconfig_passthrough', 'm_netpass_render'),
+            ('curtin.net.parse_net_config_data', 'm_net_parsedata'),
+            ('curtin.net.render_network_state', 'm_net_renderstate'),
+            ('curtin.net.network_state.from_state_file', 'm_ns_from_file'),
+            ('curtin.config.load_config', 'm_load_config'),
+        ]
+        for (tgt, attr) in patches:
+            self.add_patch(tgt, attr)
+
+        self.target = "my_target"
+        self.network_config = {
+            'network': {
+                'version': 1,
+                'config': {},
+            }
+        }
+        self.ns = {
+            'interfaces': {},
+            'routes': [],
+            'dns': {
+                'nameservers': [],
+                'search': [],
+            }
+        }
+
+    def test_apply_net_notarget(self):
+        self.assertRaises(Exception,
+                          apply_net.apply_net, None, "", "")
+
+    def test_apply_net_nostate_or_config(self):
+        self.assertRaises(Exception,
+                          apply_net.apply_net, "")
+
+    def test_apply_net_target_and_state(self):
+        self.m_ns_from_file.return_value = self.ns
+
+        self.assertRaises(ValueError,
+                          apply_net.apply_net, self.target,
+                          network_state=self.ns, network_config=None)
+
+    def test_apply_net_target_and_config(self):
+        self.m_load_config.return_value = self.network_config
+        self.m_netpass_avail.return_value = False
+        self.m_net_parsedata.return_value = self.ns
+
+        apply_net.apply_net(self.target, network_state=None,
+                            network_config=self.network_config)
+
+        self.m_netpass_avail.assert_called_with(self.target)
+
+        self.m_net_renderstate.assert_called_with(target=self.target,
+                                                  network_state=self.ns)
+        self.m_legacy.assert_called_with(self.target)
+        self.m_ipv6_priv.assert_called_with(self.target)
+        self.m_ipv6_mtu.assert_called_with(self.target)
+
+    def test_apply_net_target_and_config_passthrough(self):
+        self.m_load_config.return_value = self.network_config
+        self.m_netpass_avail.return_value = True
+
+        netcfg = "network_config.yaml"
+        apply_net.apply_net(self.target, network_state=None,
+                            network_config=netcfg)
+
+        self.assertFalse(self.m_ns_from_file.called)
+        self.m_load_config.assert_called_with(netcfg)
+        self.m_netpass_avail.assert_called_with(self.target)
+        nc = self.network_config
+        self.m_netpass_render.assert_called_with(self.target, netconfig=nc)
+
+        self.assertFalse(self.m_net_renderstate.called)
+        self.m_legacy.assert_called_with(self.target)
+        self.m_ipv6_priv.assert_called_with(self.target)
+        self.m_ipv6_mtu.assert_called_with(self.target)
+
+    def test_apply_net_target_and_config_passthrough_nonet(self):
+        nc = {'storage': {}}
+        self.m_load_config.return_value = nc
+        self.m_netpass_avail.return_value = True
+
+        netcfg = "network_config.yaml"
+
+        apply_net.apply_net(self.target, network_state=None,
+                            network_config=netcfg)
+
+        self.assertFalse(self.m_ns_from_file.called)
+        self.m_load_config.assert_called_with(netcfg)
+        self.m_netpass_avail.assert_called_with(self.target)
+        self.m_netpass_render.assert_called_with(self.target, netconfig=nc)
+
+        self.assertFalse(self.m_net_renderstate.called)
+        self.m_legacy.assert_called_with(self.target)
+        self.m_ipv6_priv.assert_called_with(self.target)
+        self.m_ipv6_mtu.assert_called_with(self.target)
+
+    def test_apply_net_target_and_config_passthrough_v2_not_available(self):
+        nc = copy.deepcopy(self.network_config)
+        nc['network']['version'] = 2
+        self.m_load_config.return_value = nc
+        self.m_netpass_avail.return_value = False
+        self.m_net_parsedata.return_value = self.ns
+
+        netcfg = "network_config.yaml"
+
+        apply_net.apply_net(self.target, network_state=None,
+                            network_config=netcfg)
+
+        self.assertFalse(self.m_ns_from_file.called)
+        self.m_load_config.assert_called_with(netcfg)
+        self.m_netpass_avail.assert_called_with(self.target)
+        self.assertFalse(self.m_netpass_render.called)
+        self.m_net_parsedata.assert_called_with(nc['network'])
+
+        self.m_net_renderstate.assert_called_with(
+            target=self.target, network_state=self.ns)
+        self.m_legacy.assert_called_with(self.target)
+        self.m_ipv6_priv.assert_called_with(self.target)
+        self.m_ipv6_mtu.assert_called_with(self.target)
+
+
+class TestApplyNetPatchIfupdown(ApplyNetTestBase):
+
+    @patch('curtin.util.write_file')
+    def test_apply_ipv6_mtu_hook(self, mock_write):
+        target = 'mytarget'
+        prehookfn = 'if-pre-up.d/mtuipv6'
+        posthookfn = 'if-up.d/mtuipv6'
+        mode = 0o755
+
+        apply_net._patch_ifupdown_ipv6_mtu_hook(target,
+                                                prehookfn=prehookfn,
+                                                posthookfn=posthookfn)
+
+        precfg = util.target_path(target, path=prehookfn)
+        postcfg = util.target_path(target, path=posthookfn)
+        precontents = apply_net.IFUPDOWN_IPV6_MTU_PRE_HOOK
+        postcontents = apply_net.IFUPDOWN_IPV6_MTU_POST_HOOK
+
+        hook_calls = [
+            call(precfg, precontents, mode=mode),
+            call(postcfg, postcontents, mode=mode),
+        ]
+        mock_write.assert_has_calls(hook_calls)
+
+    @patch('curtin.util.write_file')
+    def test_apply_ipv6_mtu_hook_write_fail(self, mock_write):
+        """Write failure raises IOError"""
+        target = 'mytarget'
+        prehookfn = 'if-pre-up.d/mtuipv6'
+        posthookfn = 'if-up.d/mtuipv6'
+        mock_write.side_effect = (IOError)
+
+        self.assertRaises(IOError,
+                          apply_net._patch_ifupdown_ipv6_mtu_hook,
+                          target,
+                          prehookfn=prehookfn,
+                          posthookfn=posthookfn)
+        self.assertEqual(1, mock_write.call_count)
+
+    @patch('curtin.util.write_file')
+    def test_apply_ipv6_mtu_hook_invalid_target(self, mock_write):
+        """Invalid target path fail before calling util.write_file"""
+        invalid_target = {}
+        prehookfn = 'if-pre-up.d/mtuipv6'
+        posthookfn = 'if-up.d/mtuipv6'
+
+        self.assertRaises(ValueError,
+                          apply_net._patch_ifupdown_ipv6_mtu_hook,
+                          invalid_target,
+                          prehookfn=prehookfn,
+                          posthookfn=posthookfn)
+        self.assertEqual(0, mock_write.call_count)
+
+    @patch('curtin.util.write_file')
+    def test_apply_ipv6_mtu_hook_invalid_prepost_fn(self, mock_write):
+        """Invalid prepost filenames fail before calling util.write_file"""
+        target = "mytarget"
+        invalid_prehookfn = {'a': 1}
+        invalid_posthookfn = {'b': 2}
+
+        self.assertRaises(ValueError,
+                          apply_net._patch_ifupdown_ipv6_mtu_hook,
+                          target,
+                          prehookfn=invalid_prehookfn,
+                          posthookfn=invalid_posthookfn)
+        self.assertEqual(0, mock_write.call_count)
+
+
+class TestApplyNetPatchIpv6Priv(ApplyNetTestBase):
+
+    @patch('curtin.util.del_file')
+    @patch('curtin.util.load_file')
+    @patch('os.path')
+    @patch('curtin.util.write_file')
+    def test_disable_ipv6_priv_extentions(self, mock_write, mock_ospath,
+                                          mock_load, mock_del):
+        target = 'mytarget'
+        path = 'etc/sysctl.d/10-ipv6-privacy.conf'
+        ipv6_priv_contents = (
+            'net.ipv6.conf.all.use_tempaddr = 2\n'
+            'net.ipv6.conf.default.use_tempaddr = 2')
+        expected_ipv6_priv_contents = '\n'.join(
+            ["# IPv6 Privacy Extensions (RFC 4941)",
+             "# Disabled by curtin",
+             "# net.ipv6.conf.all.use_tempaddr = 2",
+             "# net.ipv6.conf.default.use_tempaddr = 2"])
+        mock_ospath.exists.return_value = True
+        mock_load.side_effect = [ipv6_priv_contents]
+
+        apply_net._disable_ipv6_privacy_extensions(target)
+
+        cfg = util.target_path(target, path=path)
+        mock_write.assert_called_with(cfg, expected_ipv6_priv_contents)
+
+    @patch('curtin.util.load_file')
+    @patch('os.path')
+    def test_disable_ipv6_priv_extentions_decoderror(self, mock_ospath,
+                                                     mock_load):
+        target = 'mytarget'
+        mock_ospath.exists.return_value = True
+
+        # simulate loading of binary data
+        mock_load.side_effect = (Exception)
+
+        self.assertRaises(Exception,
+                          apply_net._disable_ipv6_privacy_extensions,
+                          target)
+
+    @patch('curtin.util.load_file')
+    @patch('os.path')
+    def test_disable_ipv6_priv_extentions_notfound(self, mock_ospath,
+                                                   mock_load):
+        target = 'mytarget'
+        path = 'foo.conf'
+        mock_ospath.exists.return_value = False
+
+        apply_net._disable_ipv6_privacy_extensions(target, path=path)
+
+        # source file not found
+        cfg = util.target_path(target, path)
+        mock_ospath.exists.assert_called_with(cfg)
+        self.assertEqual(0, mock_load.call_count)
+
+
+class TestApplyNetRemoveLegacyEth0(ApplyNetTestBase):
+
+    @patch('curtin.util.del_file')
+    @patch('curtin.util.load_file')
+    @patch('os.path')
+    def test_remove_legacy_eth0(self, mock_ospath, mock_load, mock_del):
+        target = 'mytarget'
+        path = 'eth0.cfg'
+        cfg = util.target_path(target, path)
+        legacy_eth0_contents = (
+            'auto eth0\n'
+            'iface eth0 inet dhcp')
+
+        mock_ospath.exists.return_value = True
+        mock_load.side_effect = [legacy_eth0_contents]
+
+        apply_net._maybe_remove_legacy_eth0(target, path)
+
+        mock_del.assert_called_with(cfg)
+
+    @patch('curtin.util.del_file')
+    @patch('curtin.util.load_file')
+    @patch('os.path')
+    def test_remove_legacy_eth0_nomatch(self, mock_ospath, mock_load,
+                                        mock_del):
+        target = 'mytarget'
+        path = 'eth0.cfg'
+        legacy_eth0_contents = "nomatch"
+        mock_ospath.join.side_effect = os.path.join
+        mock_ospath.exists.return_value = True
+        mock_load.side_effect = [legacy_eth0_contents]
+
+        self.assertRaises(Exception,
+                          apply_net._maybe_remove_legacy_eth0,
+                          target, path)
+
+        self.assertEqual(0, mock_del.call_count)
+
+    @patch('curtin.util.del_file')
+    @patch('curtin.util.load_file')
+    @patch('os.path')
+    def test_remove_legacy_eth0_badload(self, mock_ospath, mock_load,
+                                        mock_del):
+        target = 'mytarget'
+        path = 'eth0.cfg'
+        mock_ospath.exists.return_value = True
+        mock_load.side_effect = (Exception)
+
+        self.assertRaises(Exception,
+                          apply_net._maybe_remove_legacy_eth0,
+                          target, path)
+
+        self.assertEqual(0, mock_del.call_count)
+
+    @patch('curtin.util.del_file')
+    @patch('curtin.util.load_file')
+    @patch('os.path')
+    def test_remove_legacy_eth0_notfound(self, mock_ospath, mock_load,
+                                         mock_del):
+        target = 'mytarget'
+        path = 'eth0.conf'
+        mock_ospath.exists.return_value = False
+
+        apply_net._maybe_remove_legacy_eth0(target, path)
+
+        # source file not found
+        cfg = util.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)

=== modified file 'tests/unittests/test_curthooks.py'
--- tests/unittests/test_curthooks.py	2017-05-12 14:35:53 +0000
+++ tests/unittests/test_curthooks.py	2017-07-27 13:56:24 +0000
@@ -541,7 +541,7 @@
         netcfg_path = os.path.join(self.target,
                                    'system-data',
                                    'etc/cloud/cloud.cfg.d',
-                                   '50-network-config.cfg')
+                                   '50-curtin-networking.cfg')
         netcfg = config.dump_config({'network': cfg.get('network')})
         mock_write_file.assert_called_with(netcfg_path,
                                            content=netcfg)
@@ -577,4 +577,188 @@
         with self.assertRaises(ValueError):
             curthooks.handle_cloudconfig([], target="foobar")
 
+
+class TestDetectRequiredPackages(TestCase):
+    test_config = {
+        'storage': {
+            1: {
+                'bcache': {
+                    'type': 'bcache', 'name': 'bcache0', 'id': 'cache0',
+                    'backing_device': 'sda3', 'cache_device': 'sdb'},
+                'lvm_partition': {
+                    'id': 'lvol1', 'name': 'lv1', 'volgroup': 'vg1',
+                    'type': 'lvm_partition'},
+                'lvm_volgroup': {
+                    'id': 'vol1', 'name': 'vg1', 'devices': ['sda', 'sdb'],
+                    'type': 'lvm_volgroup'},
+                'raid': {
+                    'id': 'mddevice', 'name': 'md0', 'type': 'raid',
+                    'raidlevel': 5, 'devices': ['sda1', 'sdb1', 'sdc1']},
+                'ext2': {
+                    'id': 'format0', 'fstype': 'ext2', 'type': 'format'},
+                'ext3': {
+                    'id': 'format1', 'fstype': 'ext3', 'type': 'format'},
+                'ext4': {
+                    'id': 'format2', 'fstype': 'ext4', 'type': 'format'},
+                'btrfs': {
+                    'id': 'format3', 'fstype': 'btrfs', 'type': 'format'},
+                'xfs': {
+                    'id': 'format4', 'fstype': 'xfs', 'type': 'format'}}
+        },
+        'network': {
+            1: {
+                'bond': {
+                    'name': 'bond0', 'type': 'bond',
+                    'bond_interfaces': ['interface0', 'interface1'],
+                    'params': {'bond-mode': 'active-backup'},
+                    'subnets': [
+                        {'type': 'static', 'address': '10.23.23.2/24'},
+                        {'type': 'static', 'address': '10.23.24.2/24'}]},
+                'vlan': {
+                    'id': 'interface1.2667', 'mtu': 1500, 'name':
+                    'interface1.2667', 'type': 'vlan', 'vlan_id': 2667,
+                    'vlan_link': 'interface1',
+                    'subnets': [{'address': '10.245.184.2/24',
+                                 'dns_nameservers': [], 'type': 'static'}]},
+                'bridge': {
+                    'name': 'br0', 'bridge_interfaces': ['eth0', 'eth1'],
+                    'type': 'bridge', 'params': {
+                        'bridge_stp': 'off', 'bridge_fd': 0,
+                        'bridge_maxwait': 0},
+                    'subnets': [
+                        {'type': 'static', 'address': '192.168.14.2/24'},
+                        {'type': 'static', 'address': '2001:1::1/64'}]}},
+            2: {
+                'vlan': {
+                    'vlans': {
+                        'en-intra': {'id': 1, 'link': 'eno1', 'dhcp4': 'yes'},
+                        'en-vpn': {'id': 2, 'link': 'eno1'}}},
+                'bridge': {
+                    'bridges': {
+                        'br0': {
+                            'interfaces': ['wlp1s0', 'switchports'],
+                            'dhcp4': True}}}}
+        },
+    }
+
+    def _fmt_config(self, config_items):
+        res = {}
+        for item, item_confs in config_items.items():
+            version = item_confs['version']
+            res[item] = {'version': version}
+            if version == 1:
+                res[item]['config'] = [self.test_config[item][version][i]
+                                       for i in item_confs['items']]
+            elif version == 2 and item == 'network':
+                for cfg_item in item_confs['items']:
+                    res[item].update(self.test_config[item][version][cfg_item])
+            else:
+                raise NotImplementedError
+        return res
+
+    def _test_req_mappings(self, req_mappings):
+        for (config_items, expected_reqs) in req_mappings:
+            cfg = self._fmt_config(config_items)
+            actual_reqs = curthooks.detect_required_packages(cfg)
+            self.assertEqual(set(actual_reqs), set(expected_reqs),
+                             'failed for config: {}'.format(config_items))
+
+    def test_storage_v1_detect(self):
+        self._test_req_mappings((
+            ({'storage': {
+                'version': 1,
+                'items': ('lvm_partition', 'lvm_volgroup', 'btrfs', 'xfs')}},
+             ('lvm2', 'xfsprogs', 'btrfs-tools')),
+            ({'storage': {
+                'version': 1,
+                'items': ('raid', 'bcache', 'ext3', 'xfs')}},
+             ('mdadm', 'bcache-tools', 'e2fsprogs', 'xfsprogs')),
+            ({'storage': {
+                'version': 1,
+                'items': ('raid', 'lvm_volgroup', 'lvm_partition', 'ext3',
+                          'ext4', 'btrfs')}},
+             ('lvm2', 'mdadm', 'e2fsprogs', 'btrfs-tools')),
+            ({'storage': {
+                'version': 1,
+                'items': ('bcache', 'lvm_volgroup', 'lvm_partition', 'ext2')}},
+             ('bcache-tools', 'lvm2', 'e2fsprogs')),
+        ))
+
+    def test_network_v1_detect(self):
+        self._test_req_mappings((
+            ({'network': {
+                'version': 1,
+                'items': ('bridge',)}},
+             ('bridge-utils',)),
+            ({'network': {
+                'version': 1,
+                'items': ('vlan', 'bond')}},
+             ('vlan', 'ifenslave')),
+            ({'network': {
+                'version': 1,
+                'items': ('bond', 'bridge')}},
+             ('ifenslave', 'bridge-utils')),
+            ({'network': {
+                'version': 1,
+                'items': ('vlan', 'bridge', 'bond')}},
+             ('ifenslave', 'bridge-utils', 'vlan')),
+        ))
+
+    def test_mixed_v1_detect(self):
+        self._test_req_mappings((
+            ({'storage': {
+                'version': 1,
+                'items': ('raid', 'bcache', 'ext4')},
+              'network': {
+                  'version': 1,
+                  'items': ('vlan',)}},
+             ('mdadm', 'bcache-tools', 'e2fsprogs', 'vlan')),
+            ({'storage': {
+                'version': 1,
+                'items': ('lvm_partition', 'lvm_volgroup', 'xfs')},
+              'network': {
+                  'version': 1,
+                  'items': ('bridge', 'bond')}},
+             ('lvm2', 'xfsprogs', 'bridge-utils', 'ifenslave')),
+            ({'storage': {
+                'version': 1,
+                'items': ('ext3', 'ext4', 'btrfs')},
+              'network': {
+                  'version': 1,
+                  'items': ('bond', 'vlan')}},
+             ('e2fsprogs', 'btrfs-tools', 'vlan', 'ifenslave')),
+        ))
+
+    def test_network_v2_detect(self):
+        self._test_req_mappings((
+            ({'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):
+        self._test_req_mappings((
+            ({'network': {
+                'version': 2,
+                'items': ('bridge', 'vlan')},
+             'storage': {
+                 'version': 1,
+                 'items': ('raid', 'bcache', 'ext4')}},
+             ('vlan', 'bridge-utils', 'mdadm', 'bcache-tools', 'e2fsprogs')),
+        ))
+
+    def test_invalid_version_in_config(self):
+        with self.assertRaises(ValueError):
+            curthooks.detect_required_packages({'network': {'version': 3}})
+
+
 # vi: ts=4 expandtab syntax=python

=== modified file 'tests/unittests/test_feature.py'
--- tests/unittests/test_feature.py	2017-03-21 17:19:12 +0000
+++ tests/unittests/test_feature.py	2017-07-27 13:56:24 +0000
@@ -15,3 +15,6 @@
 
     def test_has_reporting_events_webhook(self):
         self.assertIn('REPORTING_EVENTS_WEBHOOK', curtin.FEATURES)
+
+    def test_has_centos_network_curthooks(self):
+        self.assertIn('CENTOS_NETWORK_CURTHOOKS', curtin.FEATURES)

=== modified file 'tests/unittests/test_net.py'
--- tests/unittests/test_net.py	2017-02-09 16:58:23 +0000
+++ tests/unittests/test_net.py	2017-07-27 13:56:24 +0000
@@ -1,10 +1,11 @@
 from unittest import TestCase
+import mock
 import os
 import shutil
 import tempfile
 import yaml
 
-from curtin import net
+from curtin import config, net, util
 import curtin.net.network_state as network_state
 from textwrap import dedent
 
@@ -503,24 +504,19 @@
             auto interface1
             iface interface1 inet manual
                 bond-mode active-backup
-                bond-master bond0
+                bond-master bond1
 
             auto interface2
             iface interface2 inet manual
                 bond-mode active-backup
-                bond-master bond0
+                bond-master bond1
 
-            auto bond0
-            iface bond0 inet static
+            auto bond1
+            iface bond1 inet static
                 address 10.23.23.2/24
                 bond-mode active-backup
-                hwaddress ether 52:54:00:12:34:06
                 bond-slaves none
 
-            # control-alias bond0
-            iface bond0 inet static
-                address 10.23.24.2/24
-
             source /etc/network/interfaces.d/*.cfg
             """)
         net_ifaces = net.render_interfaces(ns.network_state)
@@ -654,6 +650,91 @@
         self.assertEqual(sorted(ifaces.split('\n')),
                          sorted(net_ifaces.split('\n')))
 
+    @mock.patch('curtin.util.subp')
+    @mock.patch('curtin.util.which')
+    @mock.patch.object(util.ChrootableTarget, "__enter__", new=lambda a: a)
+    def test_netconfig_passthrough_available(self, mock_which, mock_subp):
+        cloud_init = '/usr/bin/cloud-init'
+        mock_which.return_value = cloud_init
+        mock_subp.return_value = ("NETWORK_CONFIG_V1\nNETWORK_CONFIG_V2\n", '')
+
+        available = net.netconfig_passthrough_available(self.target)
+
+        self.assertEqual(True, available,
+                         "netconfig passthrough was NOT available")
+        mock_which.assert_called_with('cloud-init', target=self.target)
+        mock_subp.assert_called_with([cloud_init, 'features'],
+                                     capture=True, target=self.target)
+
+    @mock.patch('curtin.net.LOG')
+    @mock.patch('curtin.util.subp')
+    @mock.patch('curtin.util.which')
+    @mock.patch.object(util.ChrootableTarget, "__enter__", new=lambda a: a)
+    def test_netconfig_passthrough_available_no_cloudinit(self, mock_which,
+                                                          mock_subp, mock_log):
+        mock_which.return_value = None
+
+        available = net.netconfig_passthrough_available(self.target)
+
+        self.assertEqual(False, available,
+                         "netconfig passthrough was available")
+        self.assertTrue(mock_log.warning.called)
+        self.assertFalse(mock_subp.called)
+
+    @mock.patch('curtin.util.subp')
+    @mock.patch('curtin.util.which')
+    @mock.patch.object(util.ChrootableTarget, "__enter__", new=lambda a: a)
+    def test_netconfig_passthrough_available_feature_not_found(self,
+                                                               mock_which,
+                                                               mock_subp):
+        cloud_init = '/usr/bin/cloud-init'
+        mock_which.return_value = cloud_init
+        mock_subp.return_value = ('NETWORK_CONFIG_V1\n', '')
+
+        available = net.netconfig_passthrough_available(self.target)
+
+        self.assertEqual(False, available,
+                         "netconfig passthrough was available")
+        mock_which.assert_called_with('cloud-init', target=self.target)
+        mock_subp.assert_called_with([cloud_init, 'features'],
+                                     capture=True, target=self.target)
+
+    @mock.patch('curtin.net.LOG')
+    @mock.patch('curtin.util.subp')
+    @mock.patch('curtin.util.which')
+    @mock.patch.object(util.ChrootableTarget, "__enter__", new=lambda a: a)
+    def test_netconfig_passthrough_available_exc(self, mock_which, mock_subp,
+                                                 mock_log):
+        cloud_init = '/usr/bin/cloud-init'
+        mock_which.return_value = cloud_init
+        mock_subp.side_effect = util.ProcessExecutionError
+
+        available = net.netconfig_passthrough_available(self.target)
+
+        self.assertEqual(False, available,
+                         "netconfig passthrough was available")
+        mock_which.assert_called_with('cloud-init', target=self.target)
+        mock_subp.assert_called_with([cloud_init, 'features'],
+                                     capture=True, target=self.target)
+        self.assertTrue(mock_log.warning.called)
+
+    @mock.patch('curtin.util.write_file')
+    def test_render_netconfig_passthrough(self, mock_writefile):
+        netcfg = yaml.safe_load(self.config)
+        pt_config = 'etc/cloud/cloud.cfg.d/50-curtin-networking.cfg'
+        target_config = os.path.sep.join((self.target, pt_config),)
+
+        net.render_netconfig_passthrough(self.target, netconfig=netcfg)
+
+        content = config.dump_config(netcfg)
+        mock_writefile.assert_called_with(target_config, content=content)
+
+    def test_render_netconfig_passthrough_nonetcfg(self):
+        netcfg = None
+        self.assertRaises(ValueError,
+                          net.render_netconfig_passthrough,
+                          self.target, netconfig=netcfg)
+
     def test_routes_rendered(self):
         # as reported in bug 1649652
         conf = [

=== modified file 'tests/vmtests/__init__.py'
--- tests/vmtests/__init__.py	2017-05-19 21:40:48 +0000
+++ tests/vmtests/__init__.py	2017-07-27 13:56:24 +0000
@@ -593,7 +593,7 @@
             logger.debug("Interface name: {}".format(ifname))
             iface = interfaces.get(ifname)
             hwaddr = iface.get('mac_address')
-            if hwaddr:
+            if iface['type'] == 'physical' and hwaddr:
                 macs.append(hwaddr)
         netdevs = []
         if len(macs) > 0:
@@ -685,6 +685,12 @@
             configs.append(excfg)
             logger.debug('Added extra config {}'.format(excfg))
 
+        if cls.target_distro == "centos":
+            centos_default = 'examples/tests/centos_defaults.yaml'
+            configs.append(centos_default)
+            logger.info('Detected centos, adding default config %s',
+                        centos_default)
+
         if cls.multipath:
             disks = disks * cls.multipath_num_paths
 

=== modified file 'tests/vmtests/test_centos_basic.py'
--- tests/vmtests/test_centos_basic.py	2016-10-04 23:20:44 +0000
+++ tests/vmtests/test_centos_basic.py	2017-07-27 13:56:24 +0000
@@ -1,5 +1,6 @@
 from . import VMBaseClass
 from .releases import centos_base_vm_classes as relbase
+from .test_network import TestNetworkBaseTestsAbs
 
 import textwrap
 
@@ -9,10 +10,20 @@
     __test__ = False
     conf_file = "examples/tests/centos_basic.yaml"
     extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
+    # XXX: command | tee output is required for Centos under SELinux
+    # http://danwalsh.livejournal.com/22860.html
     collect_scripts = [textwrap.dedent(
         """
         cd OUTPUT_COLLECT_D
         cat /etc/fstab > fstab
+        rpm -qa | cat >rpm_qa
+        ifconfig -a | cat >ifconfig_a
+        ip a | cat >ip_a
+        cp -a /etc/sysconfig/network-scripts .
+        cp -a /var/log/messages .
+        cp -a /var/log/cloud-init* .
+        cp -a /var/lib/cloud ./var_lib_cloud
+        cp -a /run/cloud-init ./run_cloud-init
         """)]
     fstab_expected = {
         'LABEL=cloudimg-rootfs': '/',
@@ -40,3 +51,27 @@
     # FIXME: test is disabled because the grub config script in target
     #        specifies drive using hd(1,0) syntax, which breaks when the
     #        installation medium is removed. other than this, the install works
+
+
+class CentosTestBasicNetworkAbs(TestNetworkBaseTestsAbs):
+    conf_file = "examples/tests/centos_basic.yaml"
+    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
+    collect_scripts = TestNetworkBaseTestsAbs.collect_scripts + [
+        textwrap.dedent("""
+            cd OUTPUT_COLLECT_D
+            cp -a /etc/sysconfig/network-scripts .
+            cp -a /var/log/cloud-init* .
+            cp -a /var/lib/cloud ./var_lib_cloud
+            cp -a /run/cloud-init ./run_cloud-init
+        """)]
+
+    def test_etc_network_interfaces(self):
+        pass
+
+    def test_etc_resolvconf(self):
+        pass
+
+
+class Centos70BasicNetworkFromXenialTestBasic(relbase.centos70fromxenial,
+                                              CentosTestBasicNetworkAbs):
+    __test__ = True

=== modified file 'tests/vmtests/test_network.py'
--- tests/vmtests/test_network.py	2017-07-26 14:35:50 +0000
+++ tests/vmtests/test_network.py	2017-07-27 13:56:24 +0000
@@ -1,7 +1,13 @@
 from . import VMBaseClass, logger, helpers
 from .releases import base_vm_classes as relbase
-
+from .releases import centos_base_vm_classes as centos_relbase
+
+from unittest import SkipTest
+from curtin import config
+
+import glob
 import ipaddress
+import os
 import re
 import textwrap
 import yaml
@@ -11,50 +17,167 @@
     interactive = False
     extra_disks = []
     extra_nics = []
+    # XXX: command | tee output is required for Centos under SELinux
+    # http://danwalsh.livejournal.com/22860.html
     collect_scripts = [textwrap.dedent("""
         cd OUTPUT_COLLECT_D
         echo "waiting for ipv6 to settle" && sleep 5
-        ifconfig -a > ifconfig_a
-        ip link show > ip_link_show
-        ip a > ip_a
+        route -n | tee first_route_n
+        ifconfig -a | tee ifconfig_a
+        ip link show | tee ip_link_show
+        ip a | tee  ip_a
         find /etc/network/interfaces.d > find_interfacesd
         cp -av /etc/network/interfaces .
         cp -av /etc/network/interfaces.d .
         cp /etc/resolv.conf .
-        cp -av /etc/udev/rules.d/70-persistent-net.rules .
-        ip -o route show > ip_route_show
-        ip -6 -o route show > ip_6_route_show
-        route -n > route_n
-        route -6 -n > route_6_n
+        cp -av /etc/udev/rules.d/70-persistent-net.rules . ||:
+        ip -o route show | tee ip_route_show
+        ip -6 -o route show | tee ip_6_route_show
+        route -n |tee route_n
+        route -n -A inet6 |tee route_6_n
         cp -av /run/network ./run_network
         cp -av /var/log/upstart ./upstart ||:
-        sleep 10 && ip a > ip_a
+        cp -av /etc/cloud ./etc_cloud
+        cp -av /var/log/cloud*.log ./
+        dpkg-query -W -f '${Version}' cloud-init |tee dpkg_cloud-init_version
+        dpkg-query -W -f '${Version}' nplan |tee dpkg_nplan_version
+        dpkg-query -W -f '${Version}' systemd |tee dpkg_systemd_version
+        rpm -q --queryformat '%{VERSION}\n' cloud-init |tee rpm_ci_version
+        V=/usr/lib/python*/*-packages/cloudinit/version.py;
+        grep -c NETWORK_CONFIG_V2 $V |tee cloudinit_passthrough_available
+        mkdir -p etc_netplan
+        cp -av /etc/netplan/* ./etc_netplan/ ||:
+        networkctl |tee networkctl
+        mkdir -p run_systemd_network
+        cp -a /run/systemd/network/* ./run_systemd_network/ ||:
+        cp -a /run/systemd/netif ./run_systemd_netif ||:
+        cp -a /run/systemd/resolve ./run_systemd_resolve ||:
+        cp -a /etc/systemd ./etc_systemd ||:
+        journalctl --no-pager -b -x | tee journalctl_out
+        sleep 10 && ip a | tee  ip_a
         """)]
 
     def test_output_files_exist(self):
         self.output_files_exist([
-            "70-persistent-net.rules",
             "find_interfacesd",
             "ifconfig_a",
-            "interfaces",
             "ip_a",
             "ip_route_show",
-            "resolv.conf",
             "route_6_n",
             "route_n",
         ])
 
-    def test_etc_network_interfaces(self):
+    def read_eni(self):
+        eni = ""
+        eni_cfg = ""
+
         eni = self.load_collect_file("interfaces")
         logger.debug('etc/network/interfaces:\n{}'.format(eni))
 
+        # we don't use collect_path as we're building a glob
+        eni_dir = os.path.join(self.td.collect, "interfaces.d", "*.cfg")
+        eni_cfg = '\n'.join([self.load_collect_file(cfg)
+                             for cfg in glob.glob(eni_dir)])
+
+        return (eni, eni_cfg)
+
+    def _network_renderer(self):
+        """ Determine if target uses eni/ifupdown or netplan/networkd """
+
+        etc_netplan = self.collect_path('etc_netplan')
+        networkd = self.collect_path('run_systemd_network')
+
+        if len(os.listdir(etc_netplan)) > 0 and len(os.listdir(networkd)) > 0:
+            print('Network Renderer: systemd-networkd')
+            return 'systemd-networkd'
+
+        print('Network Renderer: ifupdown')
+        return 'ifupdown'
+
+    def test_etc_network_interfaces(self):
+        avail_str = self.load_collect_file('cloudinit_passthrough_available')
+        pt_available = int(avail_str) == 1
+        print('avail_str=%s pt_available=%s' % (avail_str, pt_available))
+
+        if self._network_renderer() != "ifupdown" or pt_available:
+            reason = ("{}: using net-passthrough; "
+                      "deferring to cloud-init".format(self.__class__))
+            raise SkipTest(reason)
+
+        if not pt_available:
+            raise SkipTest(
+                'network passthrough not available on %s' % self.__class__)
+
+        eni, eni_cfg = self.read_eni()
+        logger.debug('etc/network/interfaces:\n{}'.format(eni))
         expected_eni = self.get_expected_etc_network_interfaces()
-        eni_lines = eni.split('\n')
-        for line in expected_eni.split('\n'):
-            self.assertTrue(line in eni_lines, msg="missing line: %s" % line)
+
+        eni_lines = eni.split('\n') + eni_cfg.split('\n')
+        print("\n".join(eni_lines))
+        for line in [l for l in expected_eni.split('\n') if len(l) > 0]:
+            if line.startswith("#"):
+                continue
+            if "hwaddress ether" in line:
+                continue
+            print('expected line:\n%s' % line)
+            self.assertTrue(line in eni_lines, "not in eni: %s" % line)
+
+    def test_cloudinit_network_passthrough(self):
+        cc_passthrough = "cloud.cfg.d/50-curtin-networking.cfg"
+
+        avail_str = self.load_collect_file('cloudinit_passthrough_available')
+        available = int(avail_str) == 1
+        print('avail_str=%s available=%s' % (avail_str, available))
+
+        if not available:
+            raise SkipTest('not available on %s' % self.__class__)
+
+        print('passthrough was available')
+        pt_file = os.path.join(self.td.collect, 'etc_cloud',
+                               cc_passthrough)
+        print('checking if passthrough file written: %s' % pt_file)
+        self.assertTrue(os.path.exists(pt_file))
+
+        # compare
+        original = {'network':
+                    config.load_config(self.conf_file).get('network')}
+        intarget = config.load_config(pt_file)
+        self.assertEqual(original, intarget)
+
+    def test_cloudinit_network_disabled(self):
+        cc_disabled = 'cloud.cfg.d/curtin-disable-cloudinit-networking.cfg'
+
+        avail_str = self.load_collect_file('cloudinit_passthrough_available')
+        available = int(avail_str) == 1
+        print('avail_str=%s available=%s' % (avail_str, available))
+
+        if available:
+            raise SkipTest('passthrough available on %s' % self.__class__)
+
+        print('passthrough not available')
+        cc_disable_file = os.path.join(self.td.collect, 'etc_cloud',
+                                       cc_disabled)
+        print('checking if network:disable file written: %s' %
+              cc_disable_file)
+        self.assertTrue(os.path.exists(cc_disable_file))
+
+        # compare
+        original = {'network': {'config': 'disabled'}}
+        intarget = config.load_config(cc_disable_file)
+
+        print('checking cloud-init network-cfg content')
+        self.assertEqual(original, intarget)
 
     def test_etc_resolvconf(self):
-        resolvconf = self.load_collect_file("resolv.conf")
+        render2resolvconf = {
+            'ifupdown': "resolv.conf",
+            'systemd-networkd': "run_systemd_resolve/resolv.conf"
+        }
+        resolvconfpath = render2resolvconf.get(self._network_renderer(), None)
+        self.assertTrue(resolvconfpath is not None)
+        logger.debug('Selected path to resolvconf: %s', resolvconfpath)
+
+        resolvconf = self.load_collect_file(resolvconfpath)
         logger.debug('etc/resolv.conf:\n{}'.format(resolvconf))
 
         resolv_lines = resolvconf.split('\n')
@@ -111,12 +234,21 @@
     def test_static_routes(self):
         '''check routing table'''
         network_state = self.get_network_state()
+
+        # if we're using passthrough then we can't load state
+        cc_passthrough = "cloud.cfg.d/50-curtin-networking.cfg"
+        pt_file = os.path.join(self.td.collect, 'etc_cloud', cc_passthrough)
+        print('checking if passthrough file written: %s' % pt_file)
+        if not network_state and os.path.exists(pt_file):
+            raise SkipTest('passthrough enabled, skipping %s' % self.__class__)
+
         ip_route_show = self.load_collect_file("ip_route_show")
         route_n = self.load_collect_file("route_n")
 
         print("ip route show:\n%s" % ip_route_show)
         print("route -n:\n%s" % route_n)
-        routes = network_state.get('routes')
+        routes = network_state.get('routes', [])
+        print("found routes: [%s]" % routes)
         for route in routes:
             print('Checking static route: %s' % route)
             destnet = (
@@ -144,6 +276,12 @@
         print('parsed ip_a dict:\n{}'.format(
             yaml.dump(ip_dict, default_flow_style=False, indent=4)))
 
+        route_n = self.load_collect_file("route_n")
+        logger.debug("route -n:\n{}".format(route_n))
+
+        route_6_n = self.load_collect_file("route_6_n")
+        logger.debug("route -6 -n:\n{}".format(route_6_n))
+
         ip_route_show = self.load_collect_file("ip_route_show")
         logger.debug("ip route show:\n{}".format(ip_route_show))
         for line in [line for line in ip_route_show.split('\n')
@@ -156,12 +294,6 @@
             route_info = m.groupdict('')
             logger.debug(route_info)
 
-        route_n = self.load_collect_file("route_n")
-        logger.debug("route -n:\n{}".format(route_n))
-
-        route_6_n = self.load_collect_file("route_6_n")
-        logger.debug("route -6 -n:\n{}".format(route_6_n))
-
         routes = {
             '4': route_n,
             '6': route_6_n,
@@ -170,9 +302,10 @@
         for iface in interfaces.values():
             print("\nnetwork_state iface: %s" % (
                 yaml.dump(iface, default_flow_style=False, indent=4)))
+            ipcfg = ip_dict.get(iface['name'], {})
             self.check_interface(iface['name'],
                                  iface,
-                                 ip_dict.get(iface['name']),
+                                 ipcfg,
                                  routes)
 
     def check_interface(self, ifname, iface, ipcfg, routes):
@@ -182,8 +315,9 @@
         # FIXME: remove check?
         # initial check, do we have the correct iface ?
         print('ifname={}'.format(ifname))
+        self.assertTrue(type(ipcfg) == dict, "%s is not dict" % (ipcfg))
+        print("ipcfg['interface']={}".format(ipcfg['interface']))
         self.assertEqual(ifname, ipcfg['interface'])
-        print("ipcfg['interface']={}".format(ipcfg['interface']))
 
         # check physical interface attributes (skip bond members, macs change)
         if iface['type'] in ['physical'] and 'bond-master' not in iface:
@@ -292,6 +426,25 @@
     conf_file = "examples/tests/basic_network.yaml"
 
 
+class CentosTestNetworkBasicAbs(TestNetworkBaseTestsAbs):
+    conf_file = "examples/tests/centos_basic.yaml"
+    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
+    collect_scripts = TestNetworkBaseTestsAbs.collect_scripts + [
+        textwrap.dedent("""
+            cd OUTPUT_COLLECT_D
+            cp -a /etc/sysconfig/network-scripts .
+            cp -a /var/log/cloud-init* .
+            cp -a /var/lib/cloud ./var_lib_cloud
+            cp -a /run/cloud-init ./run_cloud-init
+        """)]
+
+    def test_etc_network_interfaces(self):
+        pass
+
+    def test_etc_resolvconf(self):
+        pass
+
+
 class PreciseHWETTestNetworkBasic(relbase.precise_hwe_t, TestNetworkBasicAbs):
     # FIXME: off due to hang at test: Starting execute cloud user/final scripts
     __test__ = False
@@ -334,3 +487,13 @@
 
 class ArtfulTestNetworkBasic(relbase.artful, TestNetworkBasicAbs):
     __test__ = True
+
+
+class Centos66TestNetworkBasic(centos_relbase.centos66fromxenial,
+                               CentosTestNetworkBasicAbs):
+    __test__ = True
+
+
+class Centos70TestNetworkBasic(centos_relbase.centos70fromxenial,
+                               CentosTestNetworkBasicAbs):
+    __test__ = True

=== modified file 'tests/vmtests/test_network_alias.py'
--- tests/vmtests/test_network_alias.py	2017-07-26 14:35:50 +0000
+++ tests/vmtests/test_network_alias.py	2017-07-27 13:56:24 +0000
@@ -1,5 +1,8 @@
 from .releases import base_vm_classes as relbase
+from .releases import centos_base_vm_classes as centos_relbase
 from .test_network import TestNetworkBaseTestsAbs
+from unittest import SkipTest
+import textwrap
 
 
 class TestNetworkAliasAbs(TestNetworkBaseTestsAbs):
@@ -7,6 +10,36 @@
     """
     conf_file = "examples/tests/network_alias.yaml"
 
+    def test_etc_network_interfaces(self):
+        reason = ("%s: cloud-init and curtin eni rendering"
+                  " differ" % (self.__class__))
+        raise SkipTest(reason)
+
+
+class CentosTestNetworkAliasAbs(TestNetworkAliasAbs):
+    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
+    collect_scripts = TestNetworkAliasAbs.collect_scripts + [
+        textwrap.dedent("""
+            cd OUTPUT_COLLECT_D
+            cp -a /etc/sysconfig/network-scripts .
+            cp -a /var/log/cloud-init* .
+            cp -a /var/lib/cloud ./var_lib_cloud
+            cp -a /run/cloud-init ./run_cloud-init
+        """)]
+
+    def test_etc_resolvconf(self):
+        pass
+
+
+class Centos66TestNetworkAlias(centos_relbase.centos66fromxenial,
+                               CentosTestNetworkAliasAbs):
+    __test__ = True
+
+
+class Centos70TestNetworkAlias(centos_relbase.centos70fromxenial,
+                               CentosTestNetworkAliasAbs):
+    __test__ = True
+
 
 class PreciseHWETTestNetworkAlias(relbase.precise_hwe_t, TestNetworkAliasAbs):
     # FIXME: off due to hang at test: Starting execute cloud user/final scripts

=== modified file 'tests/vmtests/test_network_bonding.py'
--- tests/vmtests/test_network_bonding.py	2017-07-26 14:35:50 +0000
+++ tests/vmtests/test_network_bonding.py	2017-07-27 13:56:24 +0000
@@ -1,6 +1,7 @@
 from . import logger
 from .releases import base_vm_classes as relbase
 from .test_network import TestNetworkBaseTestsAbs
+from .releases import centos_base_vm_classes as centos_relbase
 
 import textwrap
 
@@ -22,6 +23,30 @@
         self.assertEqual('install ok installed', status)
 
 
+class CentosTestNetworkBondingAbs(TestNetworkBondingAbs):
+    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
+    collect_scripts = TestNetworkBondingAbs.collect_scripts + [
+        textwrap.dedent("""
+            cd OUTPUT_COLLECT_D
+            cp -a /etc/sysconfig/network-scripts .
+            cp -a /var/log/cloud-init* .
+            cp -a /var/lib/cloud ./var_lib_cloud
+            cp -a /run/cloud-init ./run_cloud-init
+            rpm -qf `which ifenslave` |tee ifenslave_installed
+        """)]
+
+    def test_ifenslave_installed(self):
+        status = self.load_collect_file("ifenslave_installed")
+        logger.debug('ifenslave installed: {}'.format(status))
+        self.assertTrue('iputils' in status)
+
+    def test_etc_network_interfaces(self):
+        pass
+
+    def test_etc_resolvconf(self):
+        pass
+
+
 class PreciseHWETTestBonding(relbase.precise_hwe_t, TestNetworkBondingAbs):
     __test__ = True
     # package names on precise are different, need to check on ifenslave-2.6
@@ -71,3 +96,13 @@
 
 class ArtfulTestBonding(relbase.artful, TestNetworkBondingAbs):
     __test__ = True
+
+
+class Centos66TestNetworkBonding(centos_relbase.centos66fromxenial,
+                                 CentosTestNetworkBondingAbs):
+    __test__ = True
+
+
+class Centos70TestNetworkBonding(centos_relbase.centos70fromxenial,
+                                 CentosTestNetworkBondingAbs):
+    __test__ = True

=== modified file 'tests/vmtests/test_network_bridging.py'
--- tests/vmtests/test_network_bridging.py	2017-07-26 14:35:50 +0000
+++ tests/vmtests/test_network_bridging.py	2017-07-27 13:56:24 +0000
@@ -1,5 +1,6 @@
 from . import logger
 from .releases import base_vm_classes as relbase
+from .releases import centos_base_vm_classes as centos_relbase
 from .test_network import TestNetworkBaseTestsAbs
 from curtin import util
 
@@ -39,6 +40,10 @@
 
 # attrs we cannot validate
 release_to_bridge_params_uncheckable = {
+    'centos66': ['bridge_fd', 'bridge_hello', 'bridge_hw', 'bridge_maxage',
+                 'bridge_pathcost', 'bridge_portprio'],
+    'centos70': ['bridge_fd', 'bridge_hello', 'bridge_hw', 'bridge_maxage',
+                 'bridge_pathcost', 'bridge_portprio'],
     'xenial': ['bridge_ageing'],
     'yakkety': ['bridge_ageing'],
 }
@@ -73,7 +78,7 @@
     # Some of the kernel parameters are non-human values, in that
     # case convert them back to match values from the input YAML
     if param in bridge_param_divfactor:
-        sys_file_val = (sys_file_val / bridge_param_divfactor[param])
+        sys_file_val = round(sys_file_val / bridge_param_divfactor[param])
 
     return sys_file_val
 
@@ -100,18 +105,17 @@
         """)]
 
     def test_output_files_exist_bridge(self):
-        self.output_files_exist(["bridge-utils_installed",
-                                 "sysfs_br0",
+        self.output_files_exist(["sysfs_br0",
                                  "sysfs_br0_eth1",
                                  "sysfs_br0_eth2"])
 
     def test_bridge_utils_installed(self):
+        self.output_files_exist(["bridge-utils_installed"])
         status = self.load_collect_file("bridge-utils_installed").strip()
         logger.debug('bridge-utils installed: {}'.format(status))
         self.assertEqual('install ok installed', status)
 
     def test_bridge_params(self):
-        """ Test if configure bridge params match values on the device """
 
         def _load_sysfs_bridge_data():
             sysfs_br0 = sysfs_to_dict(self.collect_path("sysfs_br0"))
@@ -130,14 +134,17 @@
             return br0
 
         def _get_bridge_params(br):
+            release = (
+                self.target_release if self.target_release else self.release)
             bridge_params_uncheckable = default_bridge_params_uncheckable
             bridge_params_uncheckable.extend(
-                release_to_bridge_params_uncheckable.get(self.release, []))
+                release_to_bridge_params_uncheckable.get(release, []))
             return [p for p in br.keys()
                     if (p.startswith('bridge_') and
                         p not in bridge_params_uncheckable)]
 
         def _check_bridge_param(sysfs_vals, p, br):
+            print('Checking bridge %s param %s' % (br, p))
             value = br.get(param)
             if param in ['bridge_stp']:
                 if value in ['off', '0']:
@@ -146,37 +153,84 @@
                     value = 1
                 else:
                     print('bridge_stp not in known val list')
+            elif param in ['bridge_portprio']:
+                if self._network_renderer() == "systemd-networkd":
+                    reason = ("%s: skip until lp#1668347"
+                              " is fixed" % self.__class__)
+                    logger.warn('Skipping: %s', reason)
+                    print(reason)
+                    return
 
             print('key=%s value=%s' % (param, value))
             if type(value) == list:
                 for subval in value:
                     (port, pval) = subval.split(" ")
-                    print('key=%s port=%s pval=%s' % (param, port, pval))
+                    print('param=%s port=%s pval=%s' % (param, port, pval))
                     sys_file_val = _get_sysfs_value(sysfs_vals, br0['name'],
                                                     param, port)
 
-                    self.assertEqual(int(pval), int(sys_file_val))
+                    msg = "Source cfg: %s=%s on port %s" % (param, value, port)
+                    self.assertEqual(int(pval), int(sys_file_val), msg)
             else:
                 sys_file_val = _get_sysfs_value(sysfs_vals, br0['name'],
                                                 param, port=None)
-                self.assertEqual(int(value), int(sys_file_val))
+                self.assertEqual(int(value), int(sys_file_val),
+                                 "Source cfg: %s=%s" % (param, value))
 
         sysfs_vals = _load_sysfs_bridge_data()
-        print(sysfs_vals)
+        # print(sysfs_vals)
         br0 = _get_bridge_config()
         for param in _get_bridge_params(br0):
+            print('Checking param %s' % param)
             _check_bridge_param(sysfs_vals, param, br0)
 
 
+class CentosTestBridgeNetworkAbs(TestBridgeNetworkAbs):
+    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
+    collect_scripts = TestBridgeNetworkAbs.collect_scripts + [
+        textwrap.dedent("""
+            cd OUTPUT_COLLECT_D
+            cp -a /etc/sysconfig/network-scripts .
+            cp -a /var/log/cloud-init* .
+            cp -a /var/lib/cloud ./var_lib_cloud
+            cp -a /run/cloud-init ./run_cloud-init
+            rpm -qf `which brctl` |tee bridge-utils_installed
+        """)]
+
+    def test_etc_network_interfaces(self):
+        pass
+
+    def test_etc_resolvconf(self):
+        pass
+
+    def test_bridge_utils_installed(self):
+        self.output_files_exist(["bridge-utils_installed"])
+        status = self.load_collect_file("bridge-utils_installed").strip()
+        logger.debug('bridge-utils installed: {}'.format(status))
+        self.assertTrue('bridge' in status)
+
+
+class Centos66TestBridgeNetwork(centos_relbase.centos66fromxenial,
+                                CentosTestBridgeNetworkAbs):
+    __test__ = True
+
+
+class Centos70TestBridgeNetwork(centos_relbase.centos70fromxenial,
+                                CentosTestBridgeNetworkAbs):
+    __test__ = True
+
+
 # only testing Yakkety or newer as older releases do not yet
 # have updated ifupdown/bridge-utils packages;
-class YakketyTestBridging(relbase.yakkety, TestBridgeNetworkAbs):
-    __test__ = False
-
-
 class ZestyTestBridging(relbase.zesty, TestBridgeNetworkAbs):
     __test__ = True
 
+    @classmethod
+    def setUpClass(cls):
+        cls.skip_by_date(cls.__name__, cls.release, "1706752",
+                         fixby=(2017, 8, 10), removeby=(2017, 8, 31))
+        super().setUpClass()
+
 
 class ArtfulTestBridging(relbase.artful, TestBridgeNetworkAbs):
     __test__ = True

=== modified file 'tests/vmtests/test_network_ipv6.py'
--- tests/vmtests/test_network_ipv6.py	2017-07-26 14:35:50 +0000
+++ tests/vmtests/test_network_ipv6.py	2017-07-27 13:56:24 +0000
@@ -1,4 +1,5 @@
 from .releases import base_vm_classes as relbase
+from .releases import centos_base_vm_classes as centos_relbase
 from .test_network import TestNetworkBaseTestsAbs
 
 import textwrap
@@ -21,6 +22,24 @@
         """)]
 
 
+class CentosTestNetworkIPV6Abs(TestNetworkIPV6Abs):
+    extra_kern_args = "BOOTIF=eth0-bc:76:4e:06:96:b3"
+    collect_scripts = TestNetworkIPV6Abs.collect_scripts + [
+        textwrap.dedent("""
+            cd OUTPUT_COLLECT_D
+            cp -a /etc/sysconfig/network-scripts .
+            cp -a /var/log/cloud-init* .
+            cp -a /var/lib/cloud ./var_lib_cloud
+            cp -a /run/cloud-init ./run_cloud-init
+        """)]
+
+    def test_etc_network_interfaces(self):
+        pass
+
+    def test_etc_resolvconf(self):
+        pass
+
+
 class PreciseHWETTestNetwork(relbase.precise_hwe_t, TestNetworkIPV6Abs):
     # FIXME: off due to hang at test: Starting execute cloud user/final scripts
     __test__ = False
@@ -48,6 +67,11 @@
 class XenialTestNetworkIPV6(relbase.xenial, TestNetworkIPV6Abs):
     __test__ = True
 
+    @classmethod
+    def test_ip_output(cls):
+        cls.skip_by_date(cls.__name__, cls.release, bugnum="1701097",
+                         fixby=(2017, 8, 16), removeby=(2017, 8, 31))
+
 
 class YakketyTestNetworkIPV6(relbase.yakkety, TestNetworkIPV6Abs):
     __test__ = False
@@ -56,6 +80,22 @@
 class ZestyTestNetworkIPV6(relbase.zesty, TestNetworkIPV6Abs):
     __test__ = True
 
+    @classmethod
+    def setUpClass(cls):
+        cls.skip_by_date(cls.__name__, cls.release, "ci-003c6678e",
+                         fixby=(2017, 8, 16), removeby=(2017, 8, 31))
+        super().setUpClass()
+
 
 class ArtfulTestNetworkIPV6(relbase.artful, TestNetworkIPV6Abs):
     __test__ = True
+
+
+class Centos66TestNetworkIPV6(centos_relbase.centos66fromxenial,
+                              CentosTestNetworkIPV6Abs):
+    __test__ = True
+
+
+class Centos70TestNetworkIPV6(centos_relbase.centos70fromxenial,
+                              CentosTestNetworkIPV6Abs):
+    __test__ = True

=== modified file 'tests/vmtests/test_network_ipv6_enisource.py'
--- tests/vmtests/test_network_ipv6_enisource.py	2017-07-26 14:35:50 +0000
+++ tests/vmtests/test_network_ipv6_enisource.py	2017-07-27 13:56:24 +0000
@@ -1,10 +1,16 @@
 from .releases import base_vm_classes as relbase
 from .test_network_enisource import TestNetworkENISource
 
+import unittest
+
 
 class TestNetworkIPV6ENISource(TestNetworkENISource):
     conf_file = "examples/tests/network_source_ipv6.yaml"
 
+    @unittest.skip("FIXME: cloud-init.net needs update")
+    def test_etc_network_interfaces(self):
+        pass
+
 
 class PreciseTestNetworkIPV6ENISource(relbase.precise,
                                       TestNetworkIPV6ENISource):
@@ -25,15 +31,35 @@
 class XenialTestNetworkIPV6ENISource(relbase.xenial, TestNetworkIPV6ENISource):
     __test__ = True
 
+    @classmethod
+    def test_ip_output(cls):
+        cls.skip_by_date(cls.__name__, cls.release, bugnum="1701097",
+                         fixby=(2017, 8, 16), removeby=(2017, 8, 31))
+
 
 class YakketyTestNetworkIPV6ENISource(relbase.yakkety,
                                       TestNetworkIPV6ENISource):
     __test__ = False
 
+    @classmethod
+    def test_ip_output(cls):
+        cls.skip_by_date(cls.__name__, cls.release, bugnum="1701097",
+                         fixby=(2017, 8, 16), removeby=(2017, 8, 31))
+
 
 class ZestyTestNetworkIPV6ENISource(relbase.zesty, TestNetworkIPV6ENISource):
     __test__ = True
 
+    @classmethod
+    def test_ip_output(cls):
+        cls.skip_by_date(cls.__name__, cls.release, bugnum="1701097",
+                         fixby=(2017, 8, 16), removeby=(2017, 8, 31))
+
 
 class ArtfulTestNetworkIPV6ENISource(relbase.artful, TestNetworkIPV6ENISource):
     __test__ = True
+
+    @classmethod
+    def test_ip_output(cls):
+        cls.skip_by_date(cls.__name__, cls.release, bugnum="1701097",
+                         fixby=(2017, 8, 16), removeby=(2017, 8, 31))

=== modified file 'tests/vmtests/test_network_ipv6_static.py'
--- tests/vmtests/test_network_ipv6_static.py	2017-07-26 14:35:50 +0000
+++ tests/vmtests/test_network_ipv6_static.py	2017-07-27 13:56:24 +0000
@@ -1,5 +1,7 @@
 from .releases import base_vm_classes as relbase
-from .test_network_static import TestNetworkStaticAbs
+from .releases import centos_base_vm_classes as centos_relbase
+from .test_network_static import (TestNetworkStaticAbs,
+                                  CentosTestNetworkStaticAbs)
 
 
 # reuse basic network tests but with different config (static, no dhcp)
@@ -7,6 +9,10 @@
     conf_file = "examples/tests/basic_network_static_ipv6.yaml"
 
 
+class CentosTestNetworkIPV6StaticAbs(CentosTestNetworkStaticAbs):
+    conf_file = "examples/tests/basic_network_static_ipv6.yaml"
+
+
 class PreciseHWETTestNetworkIPV6Static(relbase.precise_hwe_t,
                                        TestNetworkIPV6StaticAbs):
     __test__ = True
@@ -53,3 +59,13 @@
 
 class ArtfulTestNetworkIPV6Static(relbase.artful, TestNetworkIPV6StaticAbs):
     __test__ = True
+
+
+class Centos66TestNetworkIPV6Static(centos_relbase.centos66fromxenial,
+                                    CentosTestNetworkIPV6StaticAbs):
+    __test__ = True
+
+
+class Centos70TestNetworkIPV6Static(centos_relbase.centos70fromxenial,
+                                    CentosTestNetworkIPV6StaticAbs):
+    __test__ = True

=== modified file 'tests/vmtests/test_network_ipv6_vlan.py'
--- tests/vmtests/test_network_ipv6_vlan.py	2017-07-26 14:35:50 +0000
+++ tests/vmtests/test_network_ipv6_vlan.py	2017-07-27 13:56:24 +0000
@@ -1,11 +1,17 @@
 from .releases import base_vm_classes as relbase
-from .test_network_vlan import TestNetworkVlanAbs
+from .releases import centos_base_vm_classes as centos_relbase
+from .test_network_vlan import (TestNetworkVlanAbs,
+                                CentosTestNetworkVlanAbs)
 
 
 class TestNetworkIPV6VlanAbs(TestNetworkVlanAbs):
     conf_file = "examples/tests/vlan_network_ipv6.yaml"
 
 
+class CentosTestNetworkIPV6VlanAbs(CentosTestNetworkVlanAbs):
+    conf_file = "examples/tests/vlan_network_ipv6.yaml"
+
+
 class PreciseTestNetworkIPV6Vlan(relbase.precise, TestNetworkIPV6VlanAbs):
     __test__ = True
 
@@ -42,6 +48,22 @@
 class ZestyTestNetworkIPV6Vlan(relbase.zesty, TestNetworkIPV6VlanAbs):
     __test__ = True
 
+    @classmethod
+    def setUpClass(cls):
+        cls.skip_by_date(cls.__name__, cls.release, bugnum="ci-003c6678e",
+                         fixby=(2017, 8, 16), removeby=(2017, 8, 31))
+        super().setUpClass()
+
 
 class ArtfulTestNetworkIPV6Vlan(relbase.artful, TestNetworkIPV6VlanAbs):
     __test__ = True
+
+
+class Centos66TestNetworkIPV6Vlan(centos_relbase.centos66fromxenial,
+                                  CentosTestNetworkIPV6VlanAbs):
+    __test__ = True
+
+
+class Centos70TestNetworkIPV6Vlan(centos_relbase.centos70fromxenial,
+                                  CentosTestNetworkIPV6VlanAbs):
+    __test__ = True

=== modified file 'tests/vmtests/test_network_mtu.py'
--- tests/vmtests/test_network_mtu.py	2017-07-26 14:35:50 +0000
+++ tests/vmtests/test_network_mtu.py	2017-07-27 13:56:24 +0000
@@ -1,4 +1,5 @@
 from .releases import base_vm_classes as relbase
+from .releases import centos_base_vm_classes as centos_relbase
 from .test_network_ipv6 import TestNetworkIPV6Abs
 
 import textwrap
@@ -25,8 +26,8 @@
         cd OUTPUT_COLLECT_D
         proc_v6="/proc/sys/net/ipv6/conf"
         for f in `seq 0 7`; do
-            cat /sys/class/net/interface${f}/mtu > interface${f}_dev_mtu;
-            cat $proc_v6/interface${f}/mtu > interface${f}_ipv6_mtu;
+            cat /sys/class/net/interface${f}/mtu |tee interface${f}_dev_mtu;
+            cat $proc_v6/interface${f}/mtu |tee interface${f}_ipv6_mtu;
         done
         if [ -e /var/log/upstart ]; then
           cp -a /var/log/upstart ./var_log_upstart
@@ -114,6 +115,50 @@
         self._check_iface_subnets('interface7')
 
 
+class CentosTestNetworkMtuAbs(TestNetworkMtuAbs):
+    conf_file = "examples/tests/network_mtu.yaml"
+    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
+    collect_scripts = TestNetworkMtuAbs.collect_scripts + [
+        textwrap.dedent("""
+            cd OUTPUT_COLLECT_D
+            cp -a /etc/sysconfig/network-scripts .
+            cp -a /var/log/cloud-init* .
+            cp -a /var/lib/cloud ./var_lib_cloud
+            cp -a /run/cloud-init ./run_cloud-init
+        """)]
+
+    def test_etc_network_interfaces(self):
+        pass
+
+    def test_etc_resolvconf(self):
+        pass
+
+    @classmethod
+    def test_ip_output(cls):
+        cls.skip_by_date(cls.__name__, cls.release, bugnum="1706973",
+                         fixby=(2017, 8, 16), removeby=(2017, 8, 31))
+
+    @classmethod
+    def test_ipv6_mtu_smaller_than_ipv4_v6_iface_first(cls):
+        cls.skip_by_date(cls.__name__, cls.release, bugnum="1706973",
+                         fixby=(2017, 8, 16), removeby=(2017, 8, 31))
+
+    @classmethod
+    def test_ipv6_mtu_smaller_than_ipv4_non_default(cls):
+        cls.skip_by_date(cls.__name__, cls.release, bugnum="1706973",
+                         fixby=(2017, 8, 16), removeby=(2017, 8, 31))
+
+    @classmethod
+    def test_ipv6_mtu_higher_than_default_no_ipv4_iface_up(cls):
+        cls.skip_by_date(cls.__name__, cls.release, bugnum="1706973",
+                         fixby=(2017, 8, 16), removeby=(2017, 8, 31))
+
+    @classmethod
+    def test_ipv6_mtu_higher_than_default_no_ipv4_iface_v6_iface_first(cls):
+        cls.skip_by_date(cls.__name__, cls.release, bugnum="1706973",
+                         fixby=(2017, 8, 16), removeby=(2017, 8, 31))
+
+
 class PreciseHWETTestNetworkMtu(relbase.precise_hwe_t, TestNetworkMtuAbs):
     # FIXME: Precise mtu / ipv6 is buggy
     __test__ = False
@@ -162,3 +207,13 @@
 
 class ArtfulTestNetworkMtu(relbase.artful, TestNetworkMtuAbs):
     __test__ = True
+
+
+class Centos66TestNetworkMtu(centos_relbase.centos66fromxenial,
+                             CentosTestNetworkMtuAbs):
+    __test__ = True
+
+
+class Centos70TestNetworkMtu(centos_relbase.centos70fromxenial,
+                             CentosTestNetworkMtuAbs):
+    __test__ = True

=== modified file 'tests/vmtests/test_network_static.py'
--- tests/vmtests/test_network_static.py	2017-07-26 14:35:50 +0000
+++ tests/vmtests/test_network_static.py	2017-07-27 13:56:24 +0000
@@ -1,5 +1,7 @@
 from .releases import base_vm_classes as relbase
+from .releases import centos_base_vm_classes as centos_relbase
 from .test_network import TestNetworkBaseTestsAbs
+import textwrap
 
 
 class TestNetworkStaticAbs(TestNetworkBaseTestsAbs):
@@ -8,6 +10,24 @@
     conf_file = "examples/tests/basic_network_static.yaml"
 
 
+class CentosTestNetworkStaticAbs(TestNetworkStaticAbs):
+    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
+    collect_scripts = TestNetworkBaseTestsAbs.collect_scripts + [
+        textwrap.dedent("""
+            cd OUTPUT_COLLECT_D
+            cp -a /etc/sysconfig/network-scripts .
+            cp -a /var/log/cloud-init* .
+            cp -a /var/lib/cloud ./var_lib_cloud
+            cp -a /run/cloud-init ./run_cloud-init
+        """)]
+
+    def test_etc_network_interfaces(self):
+        pass
+
+    def test_etc_resolvconf(self):
+        pass
+
+
 class PreciseHWETTestNetworkStatic(relbase.precise_hwe_t,
                                    TestNetworkStaticAbs):
     # FIXME: off due to hang at test: Starting execute cloud user/final scripts
@@ -55,3 +75,13 @@
 
 class ArtfulTestNetworkStatic(relbase.artful, TestNetworkStaticAbs):
     __test__ = True
+
+
+class Centos66TestNetworkStatic(centos_relbase.centos66fromxenial,
+                                CentosTestNetworkStaticAbs):
+    __test__ = True
+
+
+class Centos70TestNetworkStatic(centos_relbase.centos70fromxenial,
+                                CentosTestNetworkStaticAbs):
+    __test__ = True

=== modified file 'tests/vmtests/test_network_static_routes.py'
--- tests/vmtests/test_network_static_routes.py	2017-07-26 14:35:50 +0000
+++ tests/vmtests/test_network_static_routes.py	2017-07-27 13:56:24 +0000
@@ -1,5 +1,7 @@
 from .releases import base_vm_classes as relbase
-from .test_network import TestNetworkBaseTestsAbs
+from .releases import centos_base_vm_classes as centos_relbase
+from .test_network import (TestNetworkBaseTestsAbs,
+                           CentosTestNetworkBasicAbs)
 
 
 class TestNetworkStaticRoutesAbs(TestNetworkBaseTestsAbs):
@@ -8,6 +10,12 @@
     conf_file = "examples/tests/network_static_routes.yaml"
 
 
+class CentosTestNetworkStaticRoutesAbs(CentosTestNetworkBasicAbs):
+    """ Static network routes testing with ipv4
+    """
+    conf_file = "examples/tests/network_static_routes.yaml"
+
+
 class PreciseHWETTestNetworkStaticRoutes(relbase.precise_hwe_t,
                                          TestNetworkStaticRoutesAbs):
     # FIXME: off due to hang at test: Starting execute cloud user/final scripts
@@ -57,3 +65,13 @@
 class ArtfulTestNetworkStaticRoutes(relbase.artful,
                                     TestNetworkStaticRoutesAbs):
     __test__ = True
+
+
+class Centos66TestNetworkStaticRoutes(centos_relbase.centos66fromxenial,
+                                      CentosTestNetworkStaticRoutesAbs):
+    __test__ = False
+
+
+class Centos70TestNetworkStaticRoutes(centos_relbase.centos70fromxenial,
+                                      CentosTestNetworkStaticRoutesAbs):
+    __test__ = False

=== modified file 'tests/vmtests/test_network_vlan.py'
--- tests/vmtests/test_network_vlan.py	2017-07-26 14:35:50 +0000
+++ tests/vmtests/test_network_vlan.py	2017-07-27 13:56:24 +0000
@@ -1,5 +1,6 @@
 from . import logger
 from .releases import base_vm_classes as relbase
+from .releases import centos_base_vm_classes as centos_relbase
 from .test_network import TestNetworkBaseTestsAbs
 
 import textwrap
@@ -12,10 +13,10 @@
         textwrap.dedent("""
              cd OUTPUT_COLLECT_D
              dpkg-query -W -f '${Status}' vlan > vlan_installed
-             ip -d link show interface1.2667 > ip_link_show_interface1.2667
-             ip -d link show interface1.2668 > ip_link_show_interface1.2668
-             ip -d link show interface1.2669 > ip_link_show_interface1.2669
-             ip -d link show interface1.2670 > ip_link_show_interface1.2670
+             ip -d link show interface1.2667 |tee ip_link_show_interface1.2667
+             ip -d link show interface1.2668 |tee ip_link_show_interface1.2668
+             ip -d link show interface1.2669 |tee ip_link_show_interface1.2669
+             ip -d link show interface1.2670 |tee ip_link_show_interface1.2670
              """)]
 
     def get_vlans(self):
@@ -45,10 +46,32 @@
         # did they get configured?
         for vlan in self.get_vlans():
             link_file = "ip_link_show_" + vlan['name']
-            vlan_msg = "vlan protocol 802.1Q id " + str(vlan['vlan_id'])
+            vlan_msg = "vlan.*id " + str(vlan['vlan_id'])
             self.check_file_regex(link_file, vlan_msg)
 
 
+class CentosTestNetworkVlanAbs(TestNetworkVlanAbs):
+    extra_kern_args = "BOOTIF=eth0-d4:be:d9:a8:49:13"
+    collect_scripts = TestNetworkVlanAbs.collect_scripts + [
+        textwrap.dedent("""
+            cd OUTPUT_COLLECT_D
+            cp -a /etc/sysconfig/network-scripts .
+            cp -a /var/log/cloud-init* .
+            cp -a /var/lib/cloud ./var_lib_cloud
+            cp -a /run/cloud-init ./run_cloud-init
+        """)]
+
+    def test_etc_network_interfaces(self):
+        pass
+
+    def test_etc_resolvconf(self):
+        pass
+
+    def test_vlan_installed(self):
+        """centos has vlan support built-in, no extra packages needed"""
+        pass
+
+
 class PreciseTestNetworkVlan(relbase.precise, TestNetworkVlanAbs):
     __test__ = True
 
@@ -84,6 +107,22 @@
 class ZestyTestNetworkVlan(relbase.zesty, TestNetworkVlanAbs):
     __test__ = True
 
+    @classmethod
+    def setUpClass(cls):
+        cls.skip_by_date(cls.__name__, cls.release, "ci-003c6678e",
+                         fixby=(2017, 8, 16), removeby=(2017, 8, 31))
+        super().setUpClass()
+
 
 class ArtfulTestNetworkVlan(relbase.artful, TestNetworkVlanAbs):
     __test__ = True
+
+
+class Centos66TestNetworkVlan(centos_relbase.centos66fromxenial,
+                              CentosTestNetworkVlanAbs):
+    __test__ = True
+
+
+class Centos70TestNetworkVlan(centos_relbase.centos70fromxenial,
+                              CentosTestNetworkVlanAbs):
+    __test__ = True

=== modified file 'tools/build-deb'
--- tools/build-deb	2013-09-25 21:04:22 +0000
+++ tools/build-deb	2017-07-27 13:56:24 +0000
@@ -5,6 +5,7 @@
 sourcename="curtin"
 TEMP_D=""
 UNCOMMITTED=${UNCOMMITTED:-0}
+RELEASE=${RELEASE:-UNRELEASED}
 
 fail() { echo "$@" 1>&2; exit 1; }
 cleanup() {
@@ -67,7 +68,8 @@
    mv "$f" "${f%.trunk}"
 done
 
-sed -i "1s,${clogver_o},${clogver_new}," debian/changelog ||
+sed -i -e "1s,${clogver_o},${clogver_new}," \
+       -e "1s,UNRELEASED,${RELEASE}," debian/changelog ||
    fail "failed to write debian/changelog"
 debuild "$@" || fail "debuild failed"