Merge lp:~wesley-wiedenmeier/curtin/trunk.passthrough-netconfig into lp:~raharper/curtin/trunk.passthrough-netconfig

[Wesley Wiedenmeier]

Update network config passthrough handling to support v2 netconfig:

 - Update passthrough detect behavior:
   - If 'passthrough: true' specified in config, use passthrough
   - If 'passthrough' not in config and v1 netconfig, detect if in-target
     cloud-init supports passthrough, use if available
   - If 'passthrough' not in config and v2 netconfig, detect if in-target
     cloud-init supports passthrough and v2 networking, use if available.
     Even if curtin cannot handle a v2 netconfig, it is better to fail
     installation than to use passthrough to a cloud-init that does not
     support v2 netconfig as that will be a more silent failure.
   - If 'passthrough: false' specified in config, do not use passthrough
 - Add additional unit tests for passthrough behavior
 - Move system_upgrade curthook to before apply_networking (LP: #1665962)
 - Add a basic netconfig v2 passthrough vmtest
 - Temporarily fix (LP: #1666058) using required_net_ifaces attr in vmtests
 - Refactor curthooks.install_missing_packages (LP: #1665954):
   - Move logic for detecting custom config package requirements from
     install_missing_packages to detect_required_packages, as this logic may
     be useful in general
   - Extend requirement detection logic to handle v2 network config
   - Add unittests for curthooks.detect_required_packages

[Wesley Wiedenmeier (wesley-wiedenmeier)]

This should be almost ready to merge. The vmtest for v2 netconfig passthrough currently is using a build of cloud-init with feature flag support in my ppa. Once the cloud-init feature flags are merged in: https://code.launchpad.net/~wesley-wiedenmeier/cloud-init/+git/cloud-init/+merge/317589 we should probably switch it to a build of the netconfig-v2-passthrough devel branch in a ppa under one of the qa accounts.

=== modified file 'curtin/commands/apply_net.py'
--- curtin/commands/apply_net.py	2016-11-22 21:58:52 +0000
+++ curtin/commands/apply_net.py	2017-02-24 02:26:43 +0000
@@ -102,11 +102,16 @@
         # for rendering at runtime, unless:
         #   1) target OS does not support (cloud-init too old)
         #   2) config disables passthrough
+        #   3) we have v2 netconfig and target OS does not support v2
+        #      (cloud-init too old)
         passthrough = netcfg.get('network', {}).get('passthrough', None)
         LOG.debug('netcfg set passthrough to: %s', passthrough)
-        if not passthrough:
+        if passthrough is None:
+            v2_required = netcfg.get('network', {}).get('version', None) == 2
             LOG.debug('testing in-target cloud-init version for support')
-            passthrough = net.netconfig_passthrough_available(target)
+            passthrough = (net.netconfig_passthrough_available(target) and
+                           (not v2_required or
+                            net.netconfig_passthrough_v2_available(target)))
             LOG.debug('passthrough via in-target: %s', passthrough)
 
         if passthrough:

=== modified file 'curtin/commands/curthooks.py'
--- curtin/commands/curthooks.py	2016-08-22 16:20:23 +0000
+++ curtin/commands/curthooks.py	2017-02-24 02:26:43 +0000
@@ -546,53 +546,106 @@
     update_initramfs(target, all_kernels=True)
 
 
-def install_missing_packages(cfg, target):
-    ''' describe which operation types will require specific packages
-
-    'custom_config_key': {
-         '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
-
+def detect_required_packages(cfg):
+    """
+    detect packages that will be required in-target by custom config items
+    """
+    # NOTE: this functionality may be useful in general, and when multi-distro
+    #       curtooks is developed could be moved into its own module with a cli
+
+    def detect_v1_reqs(cust_cfg, pkg_reqs):
+        """
+        detect required packages for v1 config
+        """
+        result = []
+
+        # get reqs by operation type
         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)
+            if set(types).intersection(all_types):
+                result.append(pkg)
 
+        # check deps required by format operations
+        # NOTE: it may make sense to move this into block.mkfs and extended
+        #       it at some point, to keep info about formats in one place
+        v1_storage_format_configs = {
+            'xfsprogs': ['xfs'],
+            'e2fsprogs': ['ext2', 'ext3', 'ext4'],
+            'btrfs-tools': ['btrfs'],
+        }
         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)
+        for pkg, fstypes in v1_storage_format_configs.items():
+            if set(fstypes).intersection(format_types):
+                result.append(pkg)
+
+        return result
+
+    def detect_v2_net_reqs(cust_cfg, pkg_reqs):
+        """
+        detect required packages for v2 net config
+        """
+        return set(pkg_reqs.get(dev_type) for dev_type in cfg[cust_cfg]
+                   if dev_type in pkg_reqs and cfg[cust_cfg][dev_type])
+
+    custom_configs = {
+        'storage': {
+            1: {'handler': detect_v1_reqs,
+                'pkg_reqs': {
+                    'lvm2': ['lvm_volgroup', 'lvm_partition'],
+                    'mdadm': ['raid'],
+                    'bcache-tools': ['bcache']}}},
+        'network': {
+            1: {'handler': detect_v1_reqs,
+                'pkg_reqs': {
+                    'vlan': ['vlan'],
+                    'ifenslave': ['bond'],
+                    'bridge-utils': ['bridge']}},
+            2: {'handler': detect_v2_net_reqs,
+                'pkg_reqs': {
+                    'bridges': 'bridge-utils',
+                    'vlans': 'vlan',
+                    'bonds': 'ifenslave'}}}
+    }
+    needed_packages = []
+
+    for cust_cfg, version_pkg_reqs in custom_configs.items():
+        # skip missing or invalid custom config items
+        if not isinstance(cfg.get(cust_cfg), dict):
+            continue
+
+        # ensure that version is supported
+        version = cfg[cust_cfg].get('version')
+        if not isinstance(version, int) or version not in version_pkg_reqs:
+            LOG.warning('skipping pkg req detection for cfg item: %s '
+                        'because version: %s not supported by '
+                        'detect_required_packages', cust_cfg, version)
+            continue
+
+        # make call to handler
+        req_data = version_pkg_reqs[version]
+        found_reqs = req_data['handler'](cust_cfg, req_data['pkg_reqs'])
+        needed_packages.extend(found_reqs)
+
+    return needed_packages
+
+
+def install_missing_packages(cfg, target):
+    ''' describe which operation types will require specific packages
+
+    'custom_config_key': {
+         'pkg1': ['op_name_1', 'op_name_2', ...]
+     }
+    '''
+
+    installed_packages = util.get_installed_packages(target)
+    needed_packages = [pkg for pkg in detect_required_packages(cfg)
+                       if pkg not in installed_packages]
 
     if needed_packages:
         state = util.load_command_environment()
@@ -679,6 +732,11 @@
 
     with events.ReportEventStack(
             name=stack_prefix, reporting_enabled=True, level="INFO",
+            description="updating packages on target system"):
+        system_upgrade(cfg, target)
+
+    with events.ReportEventStack(
+            name=stack_prefix, reporting_enabled=True, level="INFO",
             description="setting up swap"):
         add_swap(cfg, target, state.get('fstab'))
 
@@ -697,11 +755,6 @@
             description="configuring multipath"):
         detect_and_handle_multipath(cfg, target)
 
-    with events.ReportEventStack(
-            name=stack_prefix, reporting_enabled=True, level="INFO",
-            description="updating packages on target system"):
-        system_upgrade(cfg, target)
-
     # If a crypttab file was created by block_meta than it needs to be copied
     # onto the target system, and update_initramfs() needs to be run, so that
     # the cryptsetup hooks are properly configured on the installed system and

=== modified file 'curtin/net/__init__.py'
--- curtin/net/__init__.py	2016-11-22 21:58:52 +0000
+++ curtin/net/__init__.py	2017-02-24 02:26:43 +0000
@@ -531,6 +531,31 @@
     return True
 
 
+def netconfig_passthrough_v2_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 features')
+    cmd = ("from cloudinit import version;"
+           "print('{}' in getattr(version, 'FEATURES', []))"
+           .format(feature))
+    with util.ChrootableTarget(target) as in_chroot:
+
+        def run_cmd(cmd):
+            (out, _) = in_chroot.subp(cmd, capture=True)
+            return out.strip()
+
+        cloud_init_path = util.which('cloud-init', target=target)
+        if not cloud_init_path:
+            LOG.debug('cloud-init not available in target=%s', target)
+            return False
+
+        script_shebang = run_cmd(['head', '-n1', cloud_init_path])
+        python = script_shebang.split('/')[-1]
+        feature_available = run_cmd([python, '-c', cmd])
+        return config.value_as_boolean(feature_available)
+
+
 def render_netconfig_passthrough(target, netconfig=None):
     """
     Extract original network config and pass it

=== 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-02-24 02:26:43 +0000
@@ -0,0 +1,18 @@
+showtrace: true
+system_upgrade:
+    enabled: true
+apt:
+    preserve_sources_list: false
+    sources:
+        cloud-init-test-repo.list:
+            # FIXME: this should be switched to curtin-dev or cloud-init-dev
+            #        for use on jenkins, and should not be signed with my key
+            source: "deb http://ppa.launchpad.net/wesley-wiedenmeier/test/ubuntu xenial main"
+            keyid: 2B91B36D
+network:
+    version: 2
+    ethernets:
+        interface0:
+            match:
+                mac_address: "52:54:00:12:34:00"
+            dhcp4: true

=== modified file 'tests/unittests/test_commands_apply_net.py'
--- tests/unittests/test_commands_apply_net.py	2016-11-22 21:58:52 +0000
+++ tests/unittests/test_commands_apply_net.py	2017-02-24 02:26:43 +0000
@@ -31,6 +31,8 @@
                        'mock_ipv6_mtu')
         self.add_patch('curtin.net.netconfig_passthrough_available',
                        'mock_netpass_avail')
+        self.add_patch('curtin.net.netconfig_passthrough_v2_available',
+                       'mock_netpass_v2_avail')
         self.add_patch('curtin.net.render_netconfig_passthrough',
                        'mock_netpass_render')
         self.add_patch('curtin.net.parse_net_config_data',
@@ -54,7 +56,7 @@
             'dns': {
                 'nameservers': [],
                 'search': [],
-             }
+            }
         }
 
     # def tearDown(self):
@@ -89,6 +91,7 @@
                             network_config=self.network_config)
 
         self.mock_netpass_avail.assert_called_with(self.target)
+        self.assertFalse(self.mock_netpass_v2_avail.called)
 
         self.mock_net_renderstate.assert_called_with(target=self.target,
                                                      network_state=self.ns)
@@ -107,6 +110,7 @@
         self.assertFalse(self.mock_ns_from_file.called)
         self.mock_load_config.assert_called_with(netcfg)
         self.mock_netpass_avail.assert_called_with(self.target)
+        self.assertFalse(self.mock_netpass_v2_avail.called)
         nc = self.network_config
         self.mock_netpass_render.assert_called_with(self.target, netconfig=nc)
 
@@ -128,6 +132,7 @@
         self.assertFalse(self.mock_ns_from_file.called)
         self.mock_load_config.assert_called_with(netcfg)
         self.assertFalse(self.mock_netpass_avail.called)
+        self.assertFalse(self.mock_netpass_v2_avail.called)
         self.mock_netpass_render.assert_called_with(self.target, netconfig=cfg)
 
         self.assertFalse(self.mock_net_renderstate.called)
@@ -148,9 +153,109 @@
         self.assertFalse(self.mock_ns_from_file.called)
         self.mock_load_config.assert_called_with(netcfg)
         self.mock_netpass_avail.assert_called_with(self.target)
-        self.mock_netpass_render.assert_called_with(self.target, netconfig=nc)
-
-        self.assertFalse(self.mock_net_renderstate.called)
+        self.assertFalse(self.mock_netpass_v2_avail.called)
+        self.mock_netpass_render.assert_called_with(self.target, netconfig=nc)
+
+        self.assertFalse(self.mock_net_renderstate.called)
+        self.mock_legacy.assert_called_with(self.target)
+        self.mock_ipv6_priv.assert_called_with(self.target)
+        self.mock_ipv6_mtu.assert_called_with(self.target)
+
+    def test_apply_net_target_and_config_passthrough_v2(self):
+        nc = copy.deepcopy(self.network_config)
+        nc['network']['version'] = 2
+        self.mock_load_config.return_value = nc
+        self.mock_netpass_avail.return_value = True
+        self.mock_netpass_v2_avail.return_value = True
+
+        netcfg = "network_config.yaml"
+
+        apply_net.apply_net(self.target, network_state=None,
+                            network_config=netcfg)
+
+        self.assertFalse(self.mock_ns_from_file.called)
+        self.mock_load_config.assert_called_with(netcfg)
+        self.mock_netpass_avail.assert_called_with(self.target)
+        self.mock_netpass_v2_avail.assert_called_with(self.target)
+        self.mock_netpass_render.assert_called_with(self.target, netconfig=nc)
+
+        self.assertFalse(self.mock_net_renderstate.called)
+        self.mock_legacy.assert_called_with(self.target)
+        self.mock_ipv6_priv.assert_called_with(self.target)
+        self.mock_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.mock_load_config.return_value = nc
+        self.mock_netpass_avail.return_value = True
+        self.mock_netpass_v2_avail.return_value = False
+        self.mock_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.mock_ns_from_file.called)
+        self.mock_load_config.assert_called_with(netcfg)
+        self.mock_netpass_avail.assert_called_with(self.target)
+        self.mock_netpass_v2_avail.assert_called_with(self.target)
+        self.assertFalse(self.mock_netpass_render.called)
+        self.mock_net_parsedata.assert_called_with(nc['network'])
+
+        self.mock_net_renderstate.assert_called_with(
+            target=self.target, network_state=self.ns)
+        self.mock_legacy.assert_called_with(self.target)
+        self.mock_ipv6_priv.assert_called_with(self.target)
+        self.mock_ipv6_mtu.assert_called_with(self.target)
+
+    def test_apply_net_target_and_config_passthrough_v2_force(self):
+        nc = copy.deepcopy(self.network_config)
+        nc['network']['version'] = 2
+        nc['network']['passthrough'] = True
+        self.mock_load_config.return_value = nc
+        self.mock_netpass_avail.return_value = False
+        self.mock_netpass_v2_avail.return_value = False
+
+        netcfg = "network_config.yaml"
+
+        apply_net.apply_net(self.target, network_state=None,
+                            network_config=netcfg)
+
+        self.assertFalse(self.mock_ns_from_file.called)
+        self.mock_load_config.assert_called_with(netcfg)
+        self.assertFalse(self.mock_netpass_avail.called)
+        self.assertFalse(self.mock_netpass_v2_avail.called)
+        self.mock_netpass_render.assert_called_with(self.target, netconfig=nc)
+
+        self.assertFalse(self.mock_net_renderstate.called)
+        self.mock_legacy.assert_called_with(self.target)
+        self.mock_ipv6_priv.assert_called_with(self.target)
+        self.mock_ipv6_mtu.assert_called_with(self.target)
+
+    def test_apply_net_disable_passthrough(self):
+        nc = copy.deepcopy(self.network_config)
+        nc['network']['passthrough'] = False
+        self.mock_load_config.return_value = nc
+        self.mock_netpass_avail.return_value = False
+        self.mock_netpass_v2_avail.return_value = False
+        self.mock_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.mock_ns_from_file.called)
+        self.mock_load_config.assert_called_with(netcfg)
+        self.assertFalse(self.mock_netpass_avail.called)
+        self.assertFalse(self.mock_netpass_v2_avail.called)
+        self.assertFalse(self.mock_netpass_render.called)
+        self.mock_net_parsedata.assert_called_with(nc['network'])
+
+        self.mock_net_renderstate.assert_called_with(
+            target=self.target, network_state=self.ns)
         self.mock_legacy.assert_called_with(self.target)
         self.mock_ipv6_priv.assert_called_with(self.target)
         self.mock_ipv6_mtu.assert_called_with(self.target)

=== added file 'tests/unittests/test_curthooks.py'
--- tests/unittests/test_curthooks.py	1970-01-01 00:00:00 +0000
+++ tests/unittests/test_curthooks.py	2017-02-24 02:26:43 +0000
@@ -0,0 +1,181 @@
+import unittest
+from curtin.commands import curthooks
+
+
+class TestDetectRequiredPackages(unittest.TestCase):
+    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.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.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:
+            config = self._fmt_config(config_items)
+            actual_reqs = curthooks.detect_required_packages(config)
+            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')),
+        ))

=== modified file 'tests/vmtests/__init__.py'
--- tests/vmtests/__init__.py	2017-01-11 16:04:36 +0000
+++ tests/vmtests/__init__.py	2017-02-24 02:26:43 +0000
@@ -330,6 +330,7 @@
     nvme_disks = []
     recorded_errors = 0
     recorded_failures = 0
+    required_net_ifaces = None
     uefi = False
     proxy = None
 
@@ -404,21 +405,29 @@
         install_src = "PUBURL/" + os.path.basename(ftypes['vmtest.root-tgz'])
         cmd.append("--publish=%s" % ftypes['vmtest.root-tgz'])
 
-        # check for network configuration
-        cls.network_state = curtin_net.parse_net_config(cls.conf_file)
-        logger.debug("Network state: {}".format(cls.network_state))
-
-        # build -n arg list with macaddrs from net_config physical config
-        macs = []
-        interfaces = {}
-        if cls.network_state:
-            interfaces = cls.network_state.get('interfaces')
-        for ifname in interfaces:
-            logger.debug("Interface name: {}".format(ifname))
-            iface = interfaces.get(ifname)
-            hwaddr = iface.get('mac_address')
-            if hwaddr:
-                macs.append(hwaddr)
+        # build network device list, either from required_net_ifaces or from
+        # detection of mac_addresses in storage config
+        if isinstance(cls.required_net_ifaces, (list, tuple)):
+            # get mac addresses from required_net_ifaces
+            macs = cls.required_net_ifaces
+        else:
+            # check for network configuration
+            cls.network_state = curtin_net.parse_net_config(cls.conf_file)
+            logger.debug("Network state: {}".format(cls.network_state))
+
+            # build -n arg list with macaddrs from net_config physical config
+            macs = []
+            interfaces = {}
+            if cls.network_state:
+                interfaces = cls.network_state.get('interfaces')
+            for ifname in interfaces:
+                logger.debug("Interface name: {}".format(ifname))
+                iface = interfaces.get(ifname)
+                hwaddr = iface.get('mac_address')
+                if hwaddr:
+                    macs.append(hwaddr)
+
+        # construct netdev args list
         netdevs = []
         if len(macs) > 0:
             for mac in macs:

=== modified file 'tests/vmtests/test_network_passthrough.py'
--- tests/vmtests/test_network_passthrough.py	2017-01-11 16:04:36 +0000
+++ tests/vmtests/test_network_passthrough.py	2017-02-24 02:26:43 +0000
@@ -12,6 +12,21 @@
         pass
 
 
+class TestNetworkV2PassthroughAbs(TestNetworkPassthroughAbs):
+    """Test network passthrough with v2 netconfig"""
+    conf_file = "examples/tests/network_v2_passthrough.yaml"
+
+    # FIXME: need methods here and in TestNetworkPassthroughAbs to verify
+    #        correctness of cloud-init's network config v2 support
+    # FIXME: need to create a network state object from v2 config in order to
+    #        verify everything properly here
+    def test_etc_resolvconf(self):
+        pass
+
+    def test_ip_output(self):
+        pass
+
+
 class PreciseHWETTestNetworkPassthrough(relbase.precise_hwe_t,
                                         TestNetworkPassthroughAbs):
     # cloud-init too old
@@ -30,3 +45,10 @@
 class YakketyTestNetworkPassthrough(relbase.yakkety,
                                     TestNetworkPassthroughAbs):
     __test__ = True
+
+
+class XenialTestNetworkV2Passthrough(
+        relbase.xenial, TestNetworkV2PassthroughAbs):
+    # test for v2 only available on xenial due to repo add syntax
+    __test__ = True
+    required_net_ifaces = ['52:54:00:12:34:00']