Merge lp:~smoser/ubuntu/xenial/curtin/pkg-sru-r437 into lp:~smoser/ubuntu/xenial/curtin/pkg

[Scott Moser]

[Ryan Harper (raharper)]

+LGTM

review: Approve

=== modified file 'curtin/block/__init__.py'
--- curtin/block/__init__.py	2016-10-03 18:43:46 +0000
+++ curtin/block/__init__.py	2017-01-18 16:16:23 +0000
@@ -120,7 +120,7 @@
     """
     Add number to disk_kname prepending a 'p' if needed
     """
-    for dev_type in ['nvme', 'mmcblk', 'cciss', 'mpath', 'dm']:
+    for dev_type in ['nvme', 'mmcblk', 'cciss', 'mpath', 'dm', 'md']:
         if disk_kname.startswith(dev_type):
             partition_number = "p%s" % partition_number
             break

=== modified file 'curtin/commands/apt_config.py'
--- curtin/commands/apt_config.py	2016-10-03 18:42:29 +0000
+++ curtin/commands/apt_config.py	2017-01-18 16:16:23 +0000
@@ -24,6 +24,7 @@
 import os
 import re
 import sys
+import time
 import yaml
 
 from curtin.log import LOG
@@ -402,13 +403,21 @@
             ent['filename'] += ".list"
 
         if aa_repo_match(source):
-            try:
-                with util.ChrootableTarget(
-                        target, sys_resolvconf=True) as in_chroot:
+            with util.ChrootableTarget(
+                    target, sys_resolvconf=True) as in_chroot:
+                time_entered = time.time()
+                try:
                     in_chroot.subp(["add-apt-repository", source])
-            except util.ProcessExecutionError:
-                LOG.exception("add-apt-repository failed.")
-                raise
+                except util.ProcessExecutionError:
+                    LOG.exception("add-apt-repository failed.")
+                    raise
+                finally:
+                    # workaround to gnupg >=2.x spawning daemons (LP: #1645680)
+                    seconds_since = time.time() - time_entered + 1
+                    in_chroot.subp(['killall', '--wait', '--quiet',
+                                    '--younger-than', '%ds' % seconds_since,
+                                    '--regexp', '(dirmngr|gpg-agent)'],
+                                   rcs=[0, 1])
             continue
 
         sourcefn = util.target_path(target, ent['filename'])
@@ -661,6 +670,7 @@
     """Populate subcommand option parsing for apt-config"""
     populate_one_subcmd(parser, CMD_ARGUMENTS, apt_command)
 
+
 CONFIG_CLEANERS = {
     'cloud-init': clean_cloud_init,
 }

=== modified file 'curtin/commands/block_meta.py'
--- curtin/commands/block_meta.py	2016-10-03 18:43:46 +0000
+++ curtin/commands/block_meta.py	2017-01-18 16:16:23 +0000
@@ -417,8 +417,7 @@
     try:
         lbs_path = os.path.join(disk_sysfs_path, 'queue', 'logical_block_size')
         with open(lbs_path, 'r') as f:
-            l = f.readline()
-            logical_block_size_bytes = int(l)
+            logical_block_size_bytes = int(f.readline())
     except:
         logical_block_size_bytes = 512
     LOG.debug(

=== modified file 'curtin/commands/curthooks.py'
--- curtin/commands/curthooks.py	2016-10-03 18:43:46 +0000
+++ curtin/commands/curthooks.py	2017-01-18 16:16:23 +0000
@@ -159,6 +159,25 @@
         in_chroot.subp(['zipl'])
 
 
+def get_flash_kernel_pkgs(arch=None, uefi=None):
+    if arch is None:
+        arch = util.get_architecture()
+    if uefi is None:
+        uefi = util.is_uefi_bootable()
+    if uefi:
+        return None
+    if not arch.startswith('arm'):
+        return None
+
+    try:
+        fk_packages, _ = util.subp(
+            ['list-flash-kernel-packages'], capture=True)
+        return fk_packages
+    except util.ProcessExecutionError:
+        # Ignore errors
+        return None
+
+
 def install_kernel(cfg, target):
     kernel_cfg = cfg.get('kernel', {'package': None,
                                     'fallback-package': "linux-generic",
@@ -173,6 +192,13 @@
     mapping = copy.deepcopy(KERNEL_MAPPING)
     config.merge_config(mapping, kernel_cfg.get('mapping', {}))
 
+    # Machines using flash-kernel may need additional dependencies installed
+    # before running. Run those checks in the ephemeral environment so the
+    # target only has required packages installed.  See LP:1640519
+    fk_packages = get_flash_kernel_pkgs()
+    if fk_packages:
+        util.install_packages(fk_packages.split(), target=target)
+
     if kernel_package:
         util.install_packages([kernel_package], target=target)
         return
@@ -344,7 +370,8 @@
     cmd = ['update-initramfs', '-u']
     if all_kernels:
         cmd.extend(['-k', 'all'])
-    util.subp(cmd, target=target)
+    with util.ChrootableTarget(target) as in_chroot:
+        in_chroot.subp(cmd)
 
 
 def copy_fstab(fstab, target):

=== modified file 'curtin/deps/__init__.py'
--- curtin/deps/__init__.py	2016-03-18 14:16:45 +0000
+++ curtin/deps/__init__.py	2017-01-18 16:16:23 +0000
@@ -17,8 +17,14 @@
 import os
 import sys
 
-from curtin.util import (which, install_packages, lsb_release,
-                         ProcessExecutionError)
+from curtin.util import (
+    ProcessExecutionError,
+    get_architecture,
+    install_packages,
+    is_uefi_bootable,
+    lsb_release,
+    which,
+)
 
 REQUIRED_IMPORTS = [
     # import string to execute, python2 package, python3 package
@@ -47,6 +53,9 @@
     REQUIRED_IMPORTS.append(
         ('import oauthlib.oauth1', 'python-oauthlib', 'python3-oauthlib'),)
 
+if not is_uefi_bootable() and 'arm' in get_architecture():
+    REQUIRED_EXECUTABLES.append(('flash-kernel', 'flash-kernel'))
+
 
 class MissingDeps(Exception):
     def __init__(self, message, deps):

=== modified file 'curtin/util.py'
--- curtin/util.py	2016-10-03 18:43:46 +0000
+++ curtin/util.py	2017-01-18 16:16:23 +0000
@@ -45,6 +45,12 @@
 except NameError:
     string_types = (str,)
 
+try:
+    numeric_types = (int, float, long)
+except NameError:
+    # python3 does not have a long type.
+    numeric_types = (int, float)
+
 from .log import LOG
 
 _INSTALLED_HELPERS_PATH = '/usr/lib/curtin/helpers'
@@ -871,14 +877,17 @@
 
 def bytes2human(size):
     """convert size in bytes to human readable"""
-    if not (isinstance(size, (int, float)) and
-            int(size) == size and
-            int(size) >= 0):
-        raise ValueError('size must be a integral value')
+    if not isinstance(size, numeric_types):
+        raise ValueError('size must be a numeric value, not %s', type(size))
+    isize = int(size)
+    if isize != size:
+        raise ValueError('size "%s" is not a whole number.' % size)
+    if isize < 0:
+        raise ValueError('size "%d" < 0.' % isize)
     mpliers = {'B': 1, 'K': 2 ** 10, 'M': 2 ** 20, 'G': 2 ** 30, 'T': 2 ** 40}
     unit_order = sorted(mpliers, key=lambda x: -1 * mpliers[x])
-    unit = next((u for u in unit_order if (size / mpliers[u]) >= 1), 'B')
-    return str(int(size / mpliers[unit])) + unit
+    unit = next((u for u in unit_order if (isize / mpliers[u]) >= 1), 'B')
+    return str(int(isize / mpliers[unit])) + unit
 
 
 def import_module(import_str):

=== modified file 'debian/changelog'
--- debian/changelog	2016-10-03 19:12:33 +0000
+++ debian/changelog	2017-01-18 16:16:23 +0000
@@ -1,3 +1,23 @@
+curtin (0.1.0~bzr437-0ubuntu1~16.04.1) UNRELEASED; urgency=medium
+
+  * debian/new-upstream-snapshot: change to not use bzr merge-upstream.
+  * New upstream snapshot.
+    - revert: Test Workaround: skip XenialTestNvme for a short time.
+    - Test Workaround: skip XenialTestNvme for a short time.
+    - pep8: fix pep8 errors found with 'make pep8' on zesty.
+    - Workaround failures caused by gpg2 daemons left running in chroot.
+      (LP: #1645680)
+    - Install u-boot-tools when running on a system with u-boot. (LP: #1640519)
+    - block: fix partition kname for raid devices  (LP: #1641661)
+    - Fix up tox errors that slipped in and new pycodestyle 2.1.0 complaints.
+    - vmtests: adjust vmtest image sync metadata filenames
+    - vmtests: Add centos support
+    - Disable WilyTestRaid5Bcache vmtest
+    - tools/xkvm: fix --netdev=<bridge>
+    - bytes2human: fix for values larger than 32 bit int on 32 bit python2.
+
+ -- Scott Moser <[e-mail]>  Wed, 18 Jan 2017 10:56:59 -0500
+
 curtin (0.1.0~bzr425-0ubuntu1~16.04.1) xenial-proposed; urgency=medium
 
   [ Scott Moser ]

=== modified file 'debian/new-upstream-snapshot'
--- debian/new-upstream-snapshot	2016-10-03 17:23:32 +0000
+++ debian/new-upstream-snapshot	2017-01-18 16:16:23 +0000
@@ -23,7 +23,7 @@
 print_commit() {
     local subject="$1" author="$2" bugs="$3" aname=""
     aname=${author% <*}
-    echo "    - $subject ${aname:+[${aname}]}${bugs:+ (LP: ${bugs})}"
+    echo "    - $subject${aname:+ [${aname}]}${bugs:+ (LP: ${bugs})}"
 }
 
 # unfortunately seems like no easy way to get 'Author' unless
@@ -99,8 +99,52 @@
    bzr export --format=tgz "--revision=${revno}" "$tarball" "${trunk}" ||
      fail "failed exporting bzr in $trunk to $tarball"
 fi
-bzr merge-upstream "$tarball" "--version=${version}" ||
-   fail "failed merge-upstream of $tarball at version=$version"
+#bzr merge-upstream "$tarball" "--version=${version}" ||
+#   fail "failed merge-upstream of $tarball at version=$version"
+tmpd=$(mktemp -d "${TMPDIR:-/tmp}/curtin.${0##*/}.XXXXXX")
+trap 'rm -Rf "$tmpd"' EXIT
+newflist="${tmpd}/new-files"
+oldflist="${tmpd}/old-files"
+
+tar -tf "$tarball" \
+   --strip-components=1 --exclude="*/debian" > "$newflist.full" ||
+   fail "failed tar tf on $tarball"
+sed 's,^[^/]*/,,' "$newflist.full" > "$newflist"
+
+bzr ls --recursive --versioned > "$oldflist.full" ||
+   fail "failed bzr ls --recursive"
+grep -v "^debian/" "$oldflist.full" > "$oldflist"
+
+cat "$oldflist" "$newflist" "$newflist" > "$tmpd/all-old" ||
+   fail "failed getting all old files"
+cat "$newflist" "$oldflist" "$oldflist" > "$tmpd/all-new" ||
+   fail "failed getting all new"
+
+removed="${tmpd}/removed"
+added="$tmpd/added"
+sort "$tmpd/all-old" | uniq --uniq > "$removed"
+sort "$tmpd/all-new" | uniq --uniq > "$added"
+
+while read rmfile; do
+   case "$rmfile" in
+      .pc/*) continue;;
+      */) rflag="-r";;
+      *) rflag="";;
+   esac
+   bzr rm $rflag "$rmfile" || fail "failed bzr rm${rflag:+ ${rflag}} $rmfile"
+done < "$removed"
+
+for f in *; do
+   [ "$f" = "debian" ] && continue
+   rm -rf "$f" || fail "failed removing '$f'"
+done
+
+tar --strip-components=1 --exclude "*/debian/*" -xf "$tarball" ||
+   fail "failed extraction of $tarball"
+
+while read newfile; do
+    bzr add "$newfile" || fail "failed adding '$newfile'"
+done < "$added"
 
 oldrev=$(($prevno+1))
 ( cd "$trunk" && bzr log -r "${oldrev}..${revno}" ) > new-changes.log ||

=== added file 'examples/tests/centos_basic.yaml'
--- examples/tests/centos_basic.yaml	1970-01-01 00:00:00 +0000
+++ examples/tests/centos_basic.yaml	2017-01-18 16:16:23 +0000
@@ -0,0 +1,13 @@
+showtrace: true
+hook_commands:
+    builtin: null
+network:
+    version: 1
+    config:
+        - type: physical
+          name: interface0
+          mac_address: "52:54:00:12:34:00"
+          subnets:
+              - type: static
+                address: 10.0.2.15/24
+                gateway: 10.0.2.2

=== added file 'examples/tests/mirrorboot-msdos-partition.yaml'
--- examples/tests/mirrorboot-msdos-partition.yaml	1970-01-01 00:00:00 +0000
+++ examples/tests/mirrorboot-msdos-partition.yaml	2017-01-18 16:16:23 +0000
@@ -0,0 +1,82 @@
+showtrace: true
+storage:
+  version: 1
+  config:
+     - id: sda
+       type: disk
+       ptable: msdos
+       model: QEMU HARDDISK
+       path: /dev/vdb
+       name: main_disk
+       grub_device: true
+       wipe: superblock
+     - id: sdb
+       type: disk
+       ptable: msdos
+       model: QEMU HARDDISK
+       path: /dev/vdc
+       name: second_disk
+       wipe: superblock
+     - id: sda-part1
+       name: sda-part1
+       type: partition
+       size: 5GB
+       number: 1
+       device: sda
+       uuid: bbfd7fc9-fd0c-4151-99d4-a48c148c46b1
+       wipe: superblock
+     - id: sdb-part1
+       name: sdb-part1
+       type: partition
+       size: 5GB
+       number: 1
+       device: sdb
+       uuid: b37f57af-52b9-4ffc-98cf-08b7f7f4bed1
+       wipe: superblock
+     - id: md0
+       name: md0
+       type: raid
+       ptable: gpt
+       raidlevel: 1
+       devices:
+         - sda-part1
+         - sdb-part1
+       spare_devices: []
+     - device: md0
+       id: md0-part1
+       name: md0-part1
+       number: 1
+       offset: 4194304B
+       size: 2GB
+       type: partition
+       uuid: 4f4fa336-2762-48e4-ae54-9451141665cd
+       wipe: superblock
+     - device: md0
+       id: md0-part2
+       name: md0-part2
+       number: 2
+       size: 2GB
+       type: partition
+       uuid: c2d21fd3-3cde-4432-8eab-f08594bbe76e
+       wipe: superblock
+     - fstype: ext4
+       id: md0-part1_format
+       label: ''
+       type: format
+       uuid: c4024546-ad9d-4d85-adfa-c4b22611baa8
+       volume: md0-part1
+     - fstype: swap
+       id: md0-part2_format
+       label: ''
+       type: format
+       uuid: f68507ce-6d3d-4087-83e8-d8e531d7ec7d
+       volume: md0-part2
+     - device: md0-part1_format
+       id: md0-part1_mount
+       options: ''
+       path: /
+       type: mount
+     - device: md0-part2_format
+       id: md0-part2_mount
+       options: ''
+       type: mount

=== added file 'helpers/list-flash-kernel-packages'
--- helpers/list-flash-kernel-packages	1970-01-01 00:00:00 +0000
+++ helpers/list-flash-kernel-packages	2017-01-18 16:16:23 +0000
@@ -0,0 +1,13 @@
+#!/bin/sh -e
+# Return the list of packages flash-kernel requires for this machine if
+# supported. If not supported return a non-zero return code.
+
+FK_DIR=/usr/share/flash-kernel
+. ${FK_DIR}/functions
+
+machine="$(get_cpuinfo_hardware)"
+check_supported "${machine}"
+# get_machine_field gives a non-zero return code when no additional packages
+# are required. Ignore it so the script succeeds allowing just flash-kernel to
+# be installed in the target.
+get_machine_field "${machine}" "Required-Packages" ||:

=== modified file 'tests/unittests/test_apt_source.py'
--- tests/unittests/test_apt_source.py	2016-10-03 18:42:29 +0000
+++ tests/unittests/test_apt_source.py	2017-01-18 16:16:23 +0000
@@ -58,6 +58,7 @@
     def __exit__(self, exc_type, exc_value, traceback):
         return
 
+
 ChrootableTargetStr = "curtin.commands.apt_config.util.ChrootableTarget"
 
 

=== modified file 'tests/unittests/test_block.py'
--- tests/unittests/test_block.py	2016-10-03 18:42:29 +0000
+++ tests/unittests/test_block.py	2017-01-18 16:16:23 +0000
@@ -302,6 +302,7 @@
                        (('mmcblk0', 1), 'mmcblk0p1'),
                        (('cciss!c0d0', 1), 'cciss!c0d0p1'),
                        (('dm-0', 1), 'dm-0p1'),
+                       (('md0', 1), 'md0p1'),
                        (('mpath1', 2), 'mpath1p2')]
         for ((disk_kname, part_number), part_kname) in part_knames:
             self.assertEqual(block.partition_kname(disk_kname, part_number),
@@ -313,6 +314,7 @@
         path_knames = [('/dev/sda', 'sda'),
                        ('/dev/sda1', 'sda1'),
                        ('/dev////dm-0/', 'dm-0'),
+                       ('/dev/md0p1', 'md0p1'),
                        ('vdb', 'vdb'),
                        ('/dev/mmcblk0p1', 'mmcblk0p1'),
                        ('/dev/nvme0n0p1', 'nvme0n0p1'),

=== 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-01-18 16:16:23 +0000
@@ -0,0 +1,134 @@
+import os
+from unittest import TestCase
+from mock import call, patch
+import shutil
+import tempfile
+
+from curtin.commands import curthooks
+from curtin import util
+
+
+class CurthooksBase(TestCase):
+    def setUp(self):
+        super(CurthooksBase, 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 TestGetFlashKernelPkgs(CurthooksBase):
+    def setUp(self):
+        super(TestGetFlashKernelPkgs, self).setUp()
+        self.add_patch('curtin.util.subp', 'mock_subp')
+        self.add_patch('curtin.util.get_architecture', 'mock_get_architecture')
+        self.add_patch('curtin.util.is_uefi_bootable', 'mock_is_uefi_bootable')
+
+    def test__returns_none_when_uefi(self):
+        self.assertIsNone(curthooks.get_flash_kernel_pkgs(uefi=True))
+        self.assertFalse(self.mock_subp.called)
+
+    def test__returns_none_when_not_arm(self):
+        self.assertIsNone(curthooks.get_flash_kernel_pkgs('amd64', False))
+        self.assertFalse(self.mock_subp.called)
+
+    def test__returns_none_on_error(self):
+        self.mock_subp.side_effect = util.ProcessExecutionError()
+        self.assertIsNone(curthooks.get_flash_kernel_pkgs('arm64', False))
+        self.mock_subp.assert_called_with(
+            ['list-flash-kernel-packages'], capture=True)
+
+    def test__returns_flash_kernel_pkgs(self):
+        self.mock_subp.return_value = 'u-boot-tools', ''
+        self.assertEquals(
+            'u-boot-tools', curthooks.get_flash_kernel_pkgs('arm64', False))
+        self.mock_subp.assert_called_with(
+            ['list-flash-kernel-packages'], capture=True)
+
+    def test__calls_get_arch_and_is_uefi_bootable_when_undef(self):
+        curthooks.get_flash_kernel_pkgs()
+        self.mock_get_architecture.assert_called_once_with()
+        self.mock_is_uefi_bootable.assert_called_once_with()
+
+
+class TestCurthooksInstallKernel(CurthooksBase):
+    def setUp(self):
+        super(TestCurthooksInstallKernel, self).setUp()
+        self.add_patch('curtin.util.has_pkg_available', 'mock_haspkg')
+        self.add_patch('curtin.util.install_packages', 'mock_instpkg')
+        self.add_patch(
+            'curtin.commands.curthooks.get_flash_kernel_pkgs',
+            'mock_get_flash_kernel_pkgs')
+
+        self.kernel_cfg = {'kernel': {'package': 'mock-linux-kernel',
+                                      'fallback-package': 'mock-fallback',
+                                      'mapping': {}}}
+        # Tests don't actually install anything so we just need a name
+        self.target = tempfile.mktemp()
+
+    def test__installs_flash_kernel_packages_when_needed(self):
+        kernel_package = self.kernel_cfg.get('kernel', {}).get('package', {})
+        self.mock_get_flash_kernel_pkgs.return_value = 'u-boot-tools'
+
+        curthooks.install_kernel(self.kernel_cfg, self.target)
+
+        inst_calls = [
+            call(['u-boot-tools'], target=self.target),
+            call([kernel_package], target=self.target)]
+
+        self.mock_instpkg.assert_has_calls(inst_calls)
+
+    def test__installs_kernel_package(self):
+        kernel_package = self.kernel_cfg.get('kernel', {}).get('package', {})
+        self.mock_get_flash_kernel_pkgs.return_value = None
+
+        curthooks.install_kernel(self.kernel_cfg, self.target)
+
+        self.mock_instpkg.assert_called_with(
+            [kernel_package], target=self.target)
+
+
+class TestUpdateInitramfs(CurthooksBase):
+    def setUp(self):
+        super(TestUpdateInitramfs, self).setUp()
+        self.add_patch('curtin.util.subp', 'mock_subp')
+        self.target = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.target)
+
+    def _mnt_call(self, point):
+        target = os.path.join(self.target, point)
+        return call(['mount', '--bind', '/%s' % point, target])
+
+    def test_mounts_and_runs(self):
+        curthooks.update_initramfs(self.target)
+
+        print('subp calls: %s' % self.mock_subp.mock_calls)
+        subp_calls = [
+            self._mnt_call('dev'),
+            self._mnt_call('proc'),
+            self._mnt_call('sys'),
+            call(['update-initramfs', '-u'], target=self.target),
+            call(['udevadm', 'settle']),
+        ]
+        self.mock_subp.assert_has_calls(subp_calls)
+
+    def test_mounts_and_runs_for_all_kernels(self):
+        curthooks.update_initramfs(self.target, True)
+
+        print('subp calls: %s' % self.mock_subp.mock_calls)
+        subp_calls = [
+            self._mnt_call('dev'),
+            self._mnt_call('proc'),
+            self._mnt_call('sys'),
+            call(['update-initramfs', '-u', '-k', 'all'], target=self.target),
+            call(['udevadm', 'settle']),
+        ]
+        self.mock_subp.assert_has_calls(subp_calls)
+
+# vi: ts=4 expandtab syntax=python

=== modified file 'tests/vmtests/__init__.py'
--- tests/vmtests/__init__.py	2016-10-03 18:43:46 +0000
+++ tests/vmtests/__init__.py	2017-01-18 16:16:23 +0000
@@ -4,7 +4,6 @@
 import logging
 import json
 import os
-import pathlib
 import random
 import re
 import shutil
@@ -19,14 +18,10 @@
 
 from .image_sync import query as imagesync_query
 from .image_sync import mirror as imagesync_mirror
+from .image_sync import (IMAGE_SRC_URL, IMAGE_DIR)
 from .helpers import check_call, TimeoutExpired
 from unittest import TestCase, SkipTest
 
-IMAGE_SRC_URL = os.environ.get(
-    'IMAGE_SRC_URL',
-    "http://maas.ubuntu.com/images/ephemeral-v2/daily/streams/v1/index.sjson")
-
-IMAGE_DIR = os.environ.get("IMAGE_DIR", "/srv/images")
 try:
     IMAGES_TO_KEEP = int(os.environ.get("IMAGES_TO_KEEP", 1))
 except ValueError:
@@ -37,6 +32,7 @@
 
 DEVNULL = open(os.devnull, 'w')
 KEEP_DATA = {"pass": "none", "fail": "all"}
+CURTIN_VMTEST_IMAGE_SYNC = os.environ.get("CURTIN_VMTEST_IMAGE_SYNC", False)
 IMAGE_SYNCS = []
 TARGET_IMAGE_FORMAT = "raw"
 
@@ -169,20 +165,25 @@
     return
 
 
-def get_images(src_url, local_d, release, arch, krel=None, sync=True):
+def get_images(src_url, local_d, distro, release, arch, krel=None, sync=True,
+               ftypes=None):
     # ensure that the image items (roottar, kernel, initrd)
     # we need for release and arch are available in base_dir.
     # returns updated ftypes dictionary {ftype: item_url}
-    if krel is None:
-        krel = release
-    ftypes = {
-        'vmtest.root-image': '',
-        'vmtest.root-tgz': '',
-        'boot-kernel': '',
-        'boot-initrd': ''
-    }
-    common_filters = ['release=%s' % release, 'krel=%s' % krel,
-                      'arch=%s' % arch]
+    if not ftypes:
+        ftypes = {
+            'vmtest.root-image': '',
+            'vmtest.root-tgz': '',
+            'boot-kernel': '',
+            'boot-initrd': ''
+        }
+    elif isinstance(ftypes, (list, tuple)):
+        ftypes = dict().fromkeys(ftypes)
+
+    common_filters = ['release=%s' % release,
+                      'arch=%s' % arch, 'os=%s' % distro]
+    if krel:
+        common_filters.append('krel=%s' % krel)
     filters = ['ftype~(%s)' % ("|".join(ftypes.keys()))] + common_filters
 
     if sync:
@@ -208,16 +209,17 @@
         # try to fix this with a sync
         logger.info(fail_msg + "  Attempting to fix with an image sync. (%s)",
                     query_str)
-        return get_images(src_url, local_d, release, arch, krel, sync=True)
+        return get_images(src_url, local_d, distro, release, arch,
+                          krel=krel, sync=True, ftypes=ftypes)
     elif not results:
         raise ValueError("Nothing found in query: %s" % query_str)
 
     missing = []
-    expected = sorted(ftypes.keys())
     found = sorted(f.get('ftype') for f in results)
-    if expected != found:
-        raise ValueError("Query returned unexpected ftypes=%s. "
-                         "Expected=%s" % (found, expected))
+    for ftype in ftypes.keys():
+        if ftype not in found:
+            raise ValueError("Expected ftype '{}' but not in results"
+                             .format(ftype))
     for item in results:
         ftypes[item['ftype']] = item['item_url']
         last_item = item
@@ -235,42 +237,6 @@
     return version_info, ftypes
 
 
-class ImageStore:
-    """Local mirror of MAAS images simplestreams data."""
-
-    # By default sync on demand.
-    sync = True
-
-    # images are expected in dirs named <release>/<arch>/YYYYMMDD[.X]
-    image_dir_re = re.compile(r"^[0-9]{4}[01][0-9][0123][0-9]([.][0-9])*$")
-
-    def __init__(self, source_url, base_dir):
-        """Initialize the ImageStore.
-
-        source_url is the simplestreams source from where the images will be
-        downloaded.
-        base_dir is the target dir in the filesystem to keep the mirror.
-        """
-        self.source_url = source_url
-        self.base_dir = base_dir
-        if not os.path.isdir(self.base_dir):
-            os.makedirs(self.base_dir)
-        self.url = pathlib.Path(self.base_dir).as_uri()
-
-    def get_image(self, release, arch, krel=None):
-        """Return tuple of version info, and paths for root image,
-           kernel, initrd, tarball."""
-        if krel is None:
-            krel = release
-        ver_info, ftypes = get_images(
-            self.source_url, self.base_dir, release, arch, krel, self.sync)
-        root_image_path = ftypes['vmtest.root-image']
-        kernel_path = ftypes['boot-kernel']
-        initrd_path = ftypes['boot-initrd']
-        tarball = ftypes['vmtest.root-tgz']
-        return ver_info, (root_image_path, kernel_path, initrd_path, tarball)
-
-
 class TempDir(object):
     boot = None
     collect = None
@@ -356,7 +322,6 @@
     extra_disks = []
     extra_kern_args = None
     fstab_expected = {}
-    image_store_class = ImageStore
     boot_cloudconf = None
     install_timeout = INSTALL_TIMEOUT
     interactive = False
@@ -372,6 +337,30 @@
     release = None
     arch = None
     krel = None
+    distro = None
+    target_distro = None
+    target_release = None
+    target_krel = None
+
+    @classmethod
+    def get_test_files(cls):
+        img_verstr, ftypes = get_images(
+            IMAGE_SRC_URL, IMAGE_DIR, cls.distro, cls.release, cls.arch,
+            krel=cls.krel if cls.krel else cls.release,
+            ftypes=('boot-initrd', 'boot-kernel', 'vmtest.root-image'))
+        logger.debug("Install Image %s\n, ftypes: %s\n", img_verstr, ftypes)
+        logger.info("Install Image: %s", img_verstr)
+        if not cls.target_krel and cls.krel:
+            cls.target_krel = cls.krel
+        img_verstr, found = get_images(
+            IMAGE_SRC_URL, IMAGE_DIR,
+            cls.target_distro if cls.target_distro else cls.distro,
+            cls.target_release if cls.target_release else cls.release,
+            cls.arch, krel=cls.target_krel, ftypes=('vmtest.root-tgz',))
+        logger.debug("Target Tarball %s\n, ftypes: %s\n", img_verstr, found)
+        logger.info("Target Tarball: %s", img_verstr)
+        ftypes.update(found)
+        return ftypes
 
     @classmethod
     def setUpClass(cls):
@@ -383,27 +372,17 @@
 
         setup_start = time.time()
         logger.info('Starting setup for testclass: {}'.format(cls.__name__))
-        # get boot img
-        image_store = cls.image_store_class(IMAGE_SRC_URL, IMAGE_DIR)
-        # Disable sync if env var is set.
-        image_store.sync = get_env_var_bool('CURTIN_VMTEST_IMAGE_SYNC', False)
-        logger.debug("Image sync = %s", image_store.sync)
-        img_verstr, (boot_img, boot_kernel, boot_initrd, tarball) = (
-            image_store.get_image(cls.release, cls.arch, cls.krel))
-        logger.debug("Image %s\n  boot=%s\n  kernel=%s\n  initrd=%s\n"
-                     "  tarball=%s\n", img_verstr, boot_img, boot_kernel,
-                     boot_initrd, tarball)
         # set up tempdir
         cls.td = TempDir(
             name=cls.__name__,
             user_data=generate_user_data(collect_scripts=cls.collect_scripts,
                                          boot_cloudconf=cls.boot_cloudconf))
-        logger.info('Using tempdir: %s , Image: %s', cls.td.tmpdir,
-                    img_verstr)
+        logger.info('Using tempdir: %s', cls.td.tmpdir)
         cls.install_log = os.path.join(cls.td.logs, 'install-serial.log')
         cls.boot_log = os.path.join(cls.td.logs, 'boot-serial.log')
         logger.debug('Install console log: {}'.format(cls.install_log))
         logger.debug('Boot console log: {}'.format(cls.boot_log))
+        ftypes = cls.get_test_files()
 
         # if interactive, launch qemu without 'background & wait'
         if cls.interactive:
@@ -422,8 +401,8 @@
             cmd.extend(["--append=" + cls.extra_kern_args])
 
         # publish the root tarball
-        install_src = "PUBURL/" + os.path.basename(tarball)
-        cmd.append("--publish=%s" % tarball)
+        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)
@@ -520,8 +499,9 @@
             disks = disks * cls.multipath_num_paths
 
         cmd.extend(uefi_flags + netdevs + disks +
-                   [boot_img, "--kernel=%s" % boot_kernel, "--initrd=%s" %
-                    boot_initrd, "--", "curtin", "-vv", "install"] +
+                   [ftypes['vmtest.root-image'], "--kernel=%s" %
+                       ftypes['boot-kernel'], "--initrd=%s" %
+                    ftypes['boot-initrd'], "--", "curtin", "-vv", "install"] +
                    ["--config=%s" % f for f in configs] +
                    [install_src])
 
@@ -539,8 +519,8 @@
             raise
         finally:
             if os.path.exists(cls.install_log):
-                with open(cls.install_log, 'rb') as l:
-                    content = l.read().decode('utf-8', errors='replace')
+                with open(cls.install_log, 'rb') as lfh:
+                    content = lfh.read().decode('utf-8', errors='replace')
                 logger.debug('install serial console output:\n%s', content)
             else:
                 logger.warn("Boot for install did not produce a console log.")
@@ -548,8 +528,8 @@
         logger.debug('')
         try:
             if os.path.exists(cls.install_log):
-                with open(cls.install_log, 'rb') as l:
-                    install_log = l.read().decode('utf-8', errors='replace')
+                with open(cls.install_log, 'rb') as lfh:
+                    install_log = lfh.read().decode('utf-8', errors='replace')
                 errmsg, errors = check_install_log(install_log)
                 if errmsg:
                     for e in errors:
@@ -650,8 +630,8 @@
             raise e
         finally:
             if os.path.exists(cls.boot_log):
-                with open(cls.boot_log, 'rb') as l:
-                    content = l.read().decode('utf-8', errors='replace')
+                with open(cls.boot_log, 'rb') as lfh:
+                    content = lfh.read().decode('utf-8', errors='replace')
                 logger.debug('boot serial console output:\n%s', content)
             else:
                     logger.warn("Booting after install not produce"
@@ -837,21 +817,6 @@
                                     separators=(',', ': ')) + "\n")
 
 
-class PsuedoImageStore(object):
-    def __init__(self, source_url, base_dir):
-        self.source_url = source_url
-        self.base_dir = base_dir
-
-    def get_image(self, release, arch, krel=None):
-        """Return tuple of version info, and paths for root image,
-           kernel, initrd, tarball."""
-        names = ['psuedo-root-image', 'psuedo-kernel', 'psuedo-initrd',
-                 'psuedo-tarball']
-        return (
-            "psuedo-%s %s/hwe-P 20160101" % (release, arch),
-            [os.path.join(self.base_dir, release, arch, f) for f in names])
-
-
 class PsuedoVMBaseClass(VMBaseClass):
     # This mimics much of the VMBaseClass just with faster setUpClass
     # The tests here will fail only if CURTIN_VMTEST_DEBUG_ALLOW_FAIL
@@ -859,7 +824,6 @@
     # during a 'make vmtest' (keeping it running) but not to break test.
     #
     # boot_timeouts is a dict of {'purpose': 'mesg'}
-    image_store_class = PsuedoImageStore
     # boot_results controls what happens when boot_system is called
     # a dictionary with key of the 'purpose'
     # inside each dictionary:
@@ -883,6 +847,21 @@
                                 "LABEL=root / ext4 defaults 0 1")))
 
     @classmethod
+    def get_test_files(cls):
+        """Return tuple of version info, and paths for root image,
+           kernel, initrd, tarball."""
+
+        def get_psuedo_path(name):
+            return os.path.join(IMAGE_DIR, cls.release, cls.arch, name)
+
+        return {
+            'vmtest.root-image': get_psuedo_path('psuedo-root-image'),
+            'boot-kernel': get_psuedo_path('psuedo-kernel'),
+            'boot-initrd': get_psuedo_path('psuedo-initrd'),
+            'vmtest.root-tgz': get_psuedo_path('psuedo-root-tgz')
+        }
+
+    @classmethod
     def boot_system(cls, cmd, console_log, proc_out, timeout, purpose):
         # this is separated for easy override in Psuedo classes
         data = {'timeout_msg': None, 'timeout': 0,
@@ -1011,15 +990,17 @@
     collect_post = textwrap.dedent(
         'tar -C "%s" -cf "%s" .' % (output_dir, output_device))
 
-    # failsafe poweroff runs on precise only, where power_state does
+    # failsafe poweroff runs on precise and centos only, where power_state does
     # not exist.
-    precise_poweroff = textwrap.dedent("""#!/bin/sh -x
-        [ "$(lsb_release -sc)" = "precise" ] || exit 0;
-        shutdown -P now "Shutting down on precise"
+    failsafe_poweroff = textwrap.dedent("""#!/bin/sh -x
+        [ -e /etc/centos-release -o -e /etc/redhat-release ] &&
+            { shutdown -P now "Shutting down on centos"; }
+        [ "$(lsb_release -sc)" = "precise" ] &&
+            { shutdown -P now "Shutting down on precise"; }
         """)
 
     scripts = ([collect_prep] + collect_scripts + [collect_post] +
-               [precise_poweroff])
+               [failsafe_poweroff])
 
     for part in scripts:
         if not part.startswith("#!"):

=== modified file 'tests/vmtests/helpers.py'
--- tests/vmtests/helpers.py	2016-10-03 18:43:46 +0000
+++ tests/vmtests/helpers.py	2017-01-18 16:16:23 +0000
@@ -67,6 +67,7 @@
 
         return 0
 
+
 try:
     TimeoutExpired = subprocess.TimeoutExpired
 except AttributeError:
@@ -99,10 +100,13 @@
     return Command(cmd, signal).run(**kwargs)
 
 
-def find_releases():
-    """Return a sorted list of releases defined in test cases."""
-    # Use the TestLoader to load all tests cases defined within
-    # tests/vmtests/ and figure out which releases they are testing.
+def find_releases_by_distro():
+    """
+    Returns a dictionary of distros and the distro releases that will be tested
+    """
+    # Use the TestLoder to load all test cases defined within tests/vmtests/
+    # and figure out what distros and releases they are testing. Any tests
+    # which are disabled will be excluded.
     loader = TestLoader()
     # dir with the vmtest modules (i.e. tests/vmtests/)
     tests_dir = os.path.dirname(__file__)
@@ -110,13 +114,21 @@
     root_dir = os.path.split(os.path.split(tests_dir)[0])[0]
     # Find all test modules defined in curtin/tests/vmtests/
     module_test_suites = loader.discover(tests_dir, top_level_dir=root_dir)
-    releases = set()
+    # find all distros and releases tested for each distro
+    distros = {}
     for mts in module_test_suites:
         for class_test_suite in mts:
             for test_case in class_test_suite:
-                if getattr(test_case, 'release', ''):
-                    releases.add(getattr(test_case, 'release'))
-    return sorted(releases)
+                # skip disabled tests
+                if not getattr(test_case, '__test__', False):
+                    continue
+                for (dist, rel) in (
+                        (getattr(test_case, a, None) for a in attrs)
+                        for attrs in (('distro', 'release'),
+                                      ('target_distro', 'target_release'))):
+                    if dist and rel:
+                        distros[dist] = distros.get(dist, set()).union((rel,))
+    return {k: sorted(v) for (k, v) in distros.items()}
 
 
 def _parse_ip_a(ip_a):

=== modified file 'tests/vmtests/image_sync.py'
--- tests/vmtests/image_sync.py	2016-10-03 18:00:41 +0000
+++ tests/vmtests/image_sync.py	2017-01-18 16:16:23 +0000
@@ -22,12 +22,16 @@
 IMAGE_SRC_URL = os.environ.get(
     'IMAGE_SRC_URL',
     "http://maas.ubuntu.com/images/ephemeral-v2/daily/streams/v1/index.sjson")
+IMAGE_DIR = os.environ.get("IMAGE_DIR", "/srv/images")
 
 KEYRING = '/usr/share/keyrings/ubuntu-cloudimage-keyring.gpg'
-ITEM_NAME_FILTERS = ['ftype~(root-image.gz|boot-initrd|boot-kernel)']
+ITEM_NAME_FILTERS = ['ftype~(root-image.gz|boot-initrd|boot-kernel|root-tgz)']
 FORMAT_JSON = 'JSON'
-VMTEST_CONTENT_ID = 'com.ubuntu.maas:daily:v2:download'
-VMTEST_JSON_PATH = "streams/v1/vmtest.json"
+STREAM_BASE = 'com.ubuntu.maas:daily'
+VMTEST_CONTENT_ID_PATH_MAP = {
+    STREAM_BASE + ":v2:download": "streams/v1/vmtest.json",
+    STREAM_BASE + ":centos-bases-download": "streams/v1/vmtest-centos.json",
+}
 
 DEFAULT_OUTPUT_FORMAT = (
     "%(release)-7s %(arch)s/%(subarch)s %(version_name)-10s %(item_name)s")
@@ -222,7 +226,10 @@
         tver_data = products_version_get(target, pedigree)
         titems = tver_data.get('items')
 
-        if ('root-image.gz' in titems and
+        if not titems or 'root-image.gz' not in titems:
+            return
+
+        if (titems['root-image.gz']['ftype'] == 'root-image.gz' and
                 not (ri_name in titems and rtgz_name in titems)):
             # generate the root-image and root-tgz
             derived_items = generate_root_derived(
@@ -231,6 +238,18 @@
             for fname, item in derived_items.items():
                 self.insert_item(item, src, target, pedigree + (fname,),
                                  FakeContentSource(item['path']))
+        elif (titems['root-image.gz']['ftype'] == 'root-tgz' and
+                rtgz_name not in titems):
+            # already have the root tgz, just need to add content as a
+            # vmtest.root-tgz
+            # TODO: may need to generate the vmtest.root-image at some point in
+            #       the future if there is a need to use the centos image as an
+            #       ephemeral environment rather than installing centos from
+            #       an ubuntu ephemeral image
+            self.insert_item(
+                {'ftype': rtgz_name, 'path': titems['root-image.gz']['path']},
+                src, target, pedigree + (rtgz_name,),
+                FakeContentSource(titems['root-image.gz']['path']))
 
     def get_file_info(self, path):
         # check and see if we might know checksum and size
@@ -262,11 +281,11 @@
         self.store.insert_content(path, content)
 
         # for our vmtest content id, we want to write
-        # a vmtest.json in streams/v1/vmtest.json that can be queried
+        # a json file in streams/v1/<distro>.json that can be queried
         # even though it will not appear in index
-        if target['content_id'] == VMTEST_CONTENT_ID:
-            self.store.insert_content(VMTEST_JSON_PATH,
-                                      util.json_dumps(target))
+        vmtest_json = VMTEST_CONTENT_ID_PATH_MAP.get(target['content_id'])
+        if vmtest_json:
+            self.store.insert_content(vmtest_json, util.json_dumps(target))
 
     def insert_index_entry(self, data, src, pedigree, contentsource):
         # this is overridden, because the default implementation
@@ -377,20 +396,15 @@
 def query(mirror, max_items=1, filter_list=None, verbosity=0):
     if filter_list is None:
         filter_list = []
-
     ifilters = filters.get_filters(filter_list)
 
     def fpath(path):
-        # return the full path to a local file in the mirror
         return os.path.join(mirror, path)
 
-    try:
-        stree = sutil.load_content(util.load_file(fpath(VMTEST_JSON_PATH)))
-    except OSError:
-        raise
-    results = query_ptree(stree, max_num=max_items, ifilters=ifilters,
-                          path2url=fpath)
-    return results
+    return next((q for q in (
+        query_ptree(sutil.load_content(util.load_file(fpath(path))),
+                    max_num=max_items, ifilters=ifilters, path2url=fpath)
+        for path in VMTEST_CONTENT_ID_PATH_MAP.values()) if q), None)
 
 
 def main_query(args):

=== modified file 'tests/vmtests/releases.py'
--- tests/vmtests/releases.py	2016-10-03 18:00:41 +0000
+++ tests/vmtests/releases.py	2017-01-18 16:16:23 +0000
@@ -6,47 +6,68 @@
     arch = get_platform_arch()
 
 
-class _PreciseBase(_ReleaseBase):
+class _UbuntuBase(_ReleaseBase):
+    distro = "ubuntu"
+
+
+class _CentosFromUbuntuBase(_UbuntuBase):
+    # base for installing centos tarballs from ubuntu base
+    target_distro = "centos"
+
+
+class _Centos70FromXenialBase(_CentosFromUbuntuBase):
+    # release for boot
+    release = "xenial"
+    # release for target
+    target_release = "centos70"
+
+
+class _Centos66FromXenialBase(_CentosFromUbuntuBase):
+    release = "xenial"
+    target_release = "centos66"
+
+
+class _PreciseBase(_UbuntuBase):
     release = "precise"
 
 
-class _PreciseHWET(_ReleaseBase):
+class _PreciseHWET(_UbuntuBase):
     release = "precise"
     krel = "trusty"
 
 
-class _TrustyBase(_ReleaseBase):
+class _TrustyBase(_UbuntuBase):
     release = "trusty"
 
 
-class _TrustyHWEU(_ReleaseBase):
+class _TrustyHWEU(_UbuntuBase):
     release = "trusty"
     krel = "utopic"
 
 
-class _TrustyHWEV(_ReleaseBase):
+class _TrustyHWEV(_UbuntuBase):
     release = "trusty"
     krel = "vivid"
 
 
-class _TrustyHWEW(_ReleaseBase):
+class _TrustyHWEW(_UbuntuBase):
     release = "trusty"
     krel = "wily"
 
 
-class _VividBase(_ReleaseBase):
+class _VividBase(_UbuntuBase):
     release = "vivid"
 
 
-class _WilyBase(_ReleaseBase):
+class _WilyBase(_UbuntuBase):
     release = "wily"
 
 
-class _XenialBase(_ReleaseBase):
+class _XenialBase(_UbuntuBase):
     release = "xenial"
 
 
-class _YakketyBase(_ReleaseBase):
+class _YakketyBase(_UbuntuBase):
     release = "yakkety"
 
 
@@ -62,6 +83,13 @@
     xenial = _XenialBase
     yakkety = _YakketyBase
 
+
+class _CentosReleases(object):
+    centos70fromxenial = _Centos70FromXenialBase
+    centos66fromxenial = _Centos66FromXenialBase
+
+
 base_vm_classes = _Releases
+centos_base_vm_classes = _CentosReleases
 
 # vi: ts=4 expandtab syntax=python

=== modified file 'tests/vmtests/test_apt_config_cmd.py'
--- tests/vmtests/test_apt_config_cmd.py	2016-10-03 18:42:29 +0000
+++ tests/vmtests/test_apt_config_cmd.py	2017-01-18 16:16:23 +0000
@@ -53,3 +53,7 @@
         apt feature Test for Xenial using the standalone command
     """
     __test__ = True
+
+
+class YakketyTestAptConfigCMDCMD(relbase.yakkety, TestAptConfigCMD):
+    __test__ = True

=== added file 'tests/vmtests/test_centos_basic.py'
--- tests/vmtests/test_centos_basic.py	1970-01-01 00:00:00 +0000
+++ tests/vmtests/test_centos_basic.py	2017-01-18 16:16:23 +0000
@@ -0,0 +1,42 @@
+from . import VMBaseClass
+from .releases import centos_base_vm_classes as relbase
+
+import textwrap
+
+
+# FIXME: should eventually be integrated with the real TestBasic
+class CentosTestBasicAbs(VMBaseClass):
+    __test__ = False
+    conf_file = "examples/tests/centos_basic.yaml"
+    extra_kern_args = "BOOTIF=eth0-52:54:00:12:34:00"
+    collect_scripts = [textwrap.dedent(
+        """
+        cd OUTPUT_COLLECT_D
+        cat /etc/fstab > fstab
+        """)]
+    fstab_expected = {
+        'LABEL=cloudimg-rootfs': '/',
+    }
+
+    def test_dname(self):
+        pass
+
+    def test_interfacesd_eth0_removed(self):
+        pass
+
+    def test_output_files_exist(self):
+        self.output_files_exist(["fstab"])
+
+
+# FIXME: this naming scheme needs to be replaced
+class Centos70FromXenialTestBasic(relbase.centos70fromxenial,
+                                  CentosTestBasicAbs):
+    __test__ = True
+
+
+class Centos66FromXenialTestBasic(relbase.centos66fromxenial,
+                                  CentosTestBasicAbs):
+    __test__ = False
+    # 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

=== modified file 'tests/vmtests/test_mdadm_bcache.py'
--- tests/vmtests/test_mdadm_bcache.py	2016-10-03 18:43:46 +0000
+++ tests/vmtests/test_mdadm_bcache.py	2017-01-18 16:16:23 +0000
@@ -182,6 +182,45 @@
     __test__ = True
 
 
+class TestMirrorbootPartitionsAbs(TestMdadmAbs):
+    # alternative config for more complex setup
+    conf_file = "examples/tests/mirrorboot-msdos-partition.yaml"
+    # initialize secondary disk
+    extra_disks = ['10G']
+    disk_to_check = [('main_disk', 1),
+                     ('second_disk', 1),
+                     ('md0', 2)]
+
+
+class TrustyTestMirrorbootPartitions(relbase.trusty,
+                                     TestMirrorbootPartitionsAbs):
+    __test__ = True
+
+    # FIXME(LP: #1523037): dname does not work on trusty
+    # when dname works on trusty, then we need to re-enable by removing line.
+    def test_dname(self):
+        print("test_dname does not work for Trusty")
+
+    def test_ptable(self):
+        print("test_ptable does not work for Trusty")
+
+
+class TrustyHWEUTestMirrorbootPartitions(relbase.trusty_hwe_u,
+                                         TrustyTestMirrorbootPartitions):
+    # This tests kernel upgrade in target
+    __test__ = True
+
+
+class XenialTestMirrorbootPartitions(relbase.xenial,
+                                     TestMirrorbootPartitionsAbs):
+    __test__ = True
+
+
+class YakketyTestMirrorbootPartitions(relbase.yakkety,
+                                      TestMirrorbootPartitionsAbs):
+    __test__ = True
+
+
 class TestRaid5bootAbs(TestMdadmAbs):
     # alternative config for more complex setup
     conf_file = "examples/tests/raid5boot.yaml"

=== modified file 'tests/vmtests/test_raid5_bcache.py'
--- tests/vmtests/test_raid5_bcache.py	2016-10-03 18:43:46 +0000
+++ tests/vmtests/test_raid5_bcache.py	2017-01-18 16:16:23 +0000
@@ -91,7 +91,8 @@
 
 
 class WilyTestRaid5Bcache(relbase.wily, TestMdadmBcacheAbs):
-    __test__ = True
+    # EOL - 2016-07-28
+    __test__ = False
 
 
 class XenialTestRaid5Bcache(relbase.xenial, TestMdadmBcacheAbs):

=== modified file 'tools/vmtest-sync-images'
--- tools/vmtest-sync-images	2016-10-03 18:00:41 +0000
+++ tools/vmtest-sync-images	2017-01-18 16:16:23 +0000
@@ -12,12 +12,16 @@
 from tests.vmtests import (
     IMAGE_DIR, IMAGE_SRC_URL, sync_images)
 from tests.vmtests.image_sync import ITEM_NAME_FILTERS
-from tests.vmtests.helpers import find_releases
+from tests.vmtests.helpers import find_releases_by_distro
 from curtin.util import get_platform_arch
 
 DEFAULT_ARCH = get_platform_arch()
 
 
+def _fmt_list_filter(filter_name, matches):
+    return '~'.join((filter_name, '|'.join(matches)))
+
+
 if __name__ == '__main__':
     if len(sys.argv) > 1 and sys.argv[1] == "--clean":
         print("cleaning image dir %s" % IMAGE_DIR)
@@ -35,11 +39,16 @@
                         os.unlink(fpath)
 
     arg_releases = [r for r in sys.argv[1:] if r != "--clean"]
+    arch_filters = ['arch={}'.format(DEFAULT_ARCH)]
+    filter_sets = []
     if len(arg_releases):
-        releases = arg_releases
+        filter_sets.append([_fmt_list_filter('release', arg_releases)])
     else:
-        releases = find_releases()
-    release_filter = 'release~{}'.format('|'.join(releases))
-    my_filters = ['arch=' + DEFAULT_ARCH, release_filter] + ITEM_NAME_FILTERS
+        filter_sets.extend(
+            (['os={}'.format(distro), _fmt_list_filter('release', rels)]
+             for (distro, rels) in find_releases_by_distro().items()))
+
     # Sync images.
-    sync_images(IMAGE_SRC_URL, IMAGE_DIR, filters=my_filters, verbosity=1)
+    for filter_set in filter_sets:
+        sync_images(IMAGE_SRC_URL, IMAGE_DIR, verbosity=1,
+                    filters=filter_set + ITEM_NAME_FILTERS + arch_filters)

=== modified file 'tools/xkvm'
--- tools/xkvm	2016-10-03 18:43:46 +0000
+++ tools/xkvm	2017-01-18 16:16:23 +0000
@@ -572,12 +572,12 @@
 
     if [ $need_taps -ne 0 ]; then
         local missing="" missing_pkgs="" reqs="" req="" pkgs="" pkg=""
-        for i in "${connections[*]}"; do
-            [ "$i" = "user" -o -e "/sys/class/net/dev/$i" ] ||
+        for i in "${connections[@]}"; do
+            [ "$i" = "user" -o -e "/sys/class/net/$i" ] ||
                 missing="${missing} $i"
         done
         [ -z "$missing" ] || {
-            error "cannot create connection on ${missing# }."
+            error "cannot create connection on: ${missing# }."
             error "bridges do not exist.";
             return 1;
         }