Merge ~chad.smith/curtin:ubuntu/devel into curtin:ubuntu/devel

[Chad Smith]

new upstream snapshot for publish to Cosmic

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

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

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

review: Approve (continuous-integration)

[Scott Moser (smoser)]

review: Approve

diff --git a/curtin/block/__init__.py b/curtin/block/__init__.py
index b49b9d3..b771629 100644
--- a/curtin/block/__init__.py
+++ b/curtin/block/__init__.py
@@ -1074,4 +1074,18 @@ def detect_required_packages_mapping():
     }
     return mapping
 
+
+def get_supported_filesystems():
+    """ Return a list of filesystems that the kernel currently supports
+        as read from /proc/filesystems.
+
+        Raises RuntimeError if /proc/filesystems does not exist.
+    """
+    proc_fs = "/proc/filesystems"
+    if not os.path.exists(proc_fs):
+        raise RuntimeError("Unable to read 'filesystems' from %s" % proc_fs)
+
+    return [l.split('\t')[1].strip()
+            for l in util.load_file(proc_fs).splitlines()]
+
 # vi: ts=4 expandtab syntax=python
diff --git a/curtin/block/clear_holders.py b/curtin/block/clear_holders.py
index 9d73b28..a05c9ca 100644
--- a/curtin/block/clear_holders.py
+++ b/curtin/block/clear_holders.py
@@ -304,11 +304,14 @@ def wipe_superblock(device):
     partitions = block.get_sysfs_partitions(device)
 
     # release zfs member by exporting the pool
-    if block.is_zfs_member(blockdev):
+    if zfs.zfs_supported() and block.is_zfs_member(blockdev):
         poolname = zfs.device_to_poolname(blockdev)
         # only export pools that have been imported
         if poolname in zfs.zpool_list():
-            zfs.zpool_export(poolname)
+            try:
+                zfs.zpool_export(poolname)
+            except util.ProcessExecutionError as e:
+                LOG.warning('Failed to export zpool "%s": %s', poolname, e)
 
     if is_swap_device(blockdev):
         shutdown_swap(blockdev)
@@ -624,19 +627,18 @@ def start_clear_holders_deps():
     # all disks and partitions should be sufficient to remove the mdadm
     # metadata
     mdadm.mdadm_assemble(scan=True, ignore_errors=True)
+    # scan and activate for logical volumes
+    lvm.lvm_scan()
+    lvm.activate_volgroups()
     # the bcache module needs to be present to properly detect bcache devs
     # on some systems (precise without hwe kernel) it may not be possible to
     # lad the bcache module bcause it is not present in the kernel. if this
     # happens then there is no need to halt installation, as the bcache devices
     # will never appear and will never prevent the disk from being reformatted
     util.load_kernel_module('bcache')
-    # the zfs module is needed to find and export devices which may be in-use
-    # and need to be cleared, only on xenial+.
-    try:
-        if zfs.zfs_supported():
-            util.load_kernel_module('zfs')
-    except RuntimeError as e:
-        LOG.warning('Failed to load zfs kernel module: %s', e)
+
+    if not zfs.zfs_supported():
+        LOG.warning('zfs filesystem is not supported in this environment')
 
 
 # anything that is not identified can assumed to be a 'disk' or similar
diff --git a/curtin/block/lvm.py b/curtin/block/lvm.py
index 8643245..eca64f6 100644
--- a/curtin/block/lvm.py
+++ b/curtin/block/lvm.py
@@ -57,14 +57,32 @@ def lvmetad_running():
                                          '/run/lvmetad.pid'))
 
 
-def lvm_scan():
+def activate_volgroups():
+    """
+    Activate available volgroups and logical volumes within.
+
+    # found
+    % vgchange -ay
+      1 logical volume(s) in volume group "vg1sdd" now active
+
+    # none found (no output)
+    % vgchange -ay
+    """
+
+    # vgchange handles syncing with udev by default
+    # see man 8 vgchange and flag --noudevsync
+    out, _ = util.subp(['vgchange', '--activate=y'], capture=True)
+    if out:
+        LOG.info(out)
+
+
+def lvm_scan(activate=True):
     """
     run full scan for volgroups, logical volumes and physical volumes
     """
-    # the lvm tools lvscan, vgscan and pvscan on ubuntu precise do not
-    # support the flag --cache. the flag is present for the tools in ubuntu
-    # trusty and later. since lvmetad is used in current releases of
-    # ubuntu, the --cache flag is needed to ensure that the data cached by
+    # prior to xenial, lvmetad is not packaged, so even if a tool supports
+    # flag --cache it has no effect. In Xenial and newer the --cache flag is
+    # used (if lvmetad is running) to ensure that the data cached by
     # lvmetad is updated.
 
     # before appending the cache flag though, check if lvmetad is running. this
diff --git a/curtin/block/mdadm.py b/curtin/block/mdadm.py
index e0fe0d3..8eff7fb 100644
--- a/curtin/block/mdadm.py
+++ b/curtin/block/mdadm.py
@@ -184,7 +184,7 @@ def mdadm_create(md_devname, raidlevel, devices, spares=None, md_name=""):
             cmd.append(device)
 
     # Create the raid device
-    util.subp(["udevadm", "settle"])
+    udev.udevadm_settle()
     util.subp(["udevadm", "control", "--stop-exec-queue"])
     try:
         util.subp(cmd, capture=True)
@@ -208,8 +208,7 @@ def mdadm_create(md_devname, raidlevel, devices, spares=None, md_name=""):
         raise
 
     util.subp(["udevadm", "control", "--start-exec-queue"])
-    util.subp(["udevadm", "settle",
-               "--exit-if-exists=%s" % md_devname])
+    udev.udevadm_settle(exists=md_devname)
 
 
 def mdadm_examine(devpath, export=MDADM_USE_EXPORT):
diff --git a/curtin/block/zfs.py b/curtin/block/zfs.py
index cfb07a9..e279ab6 100644
--- a/curtin/block/zfs.py
+++ b/curtin/block/zfs.py
@@ -8,7 +8,7 @@ import os
 
 from curtin.config import merge_config
 from curtin import util
-from . import blkid
+from . import blkid, get_supported_filesystems
 
 ZPOOL_DEFAULT_PROPERTIES = {
     'ashift': 12,
@@ -73,6 +73,15 @@ def _join_pool_volume(poolname, volume):
 
 
 def zfs_supported():
+    """Return a boolean indicating if zfs is supported."""
+    try:
+        zfs_assert_supported()
+        return True
+    except RuntimeError:
+        return False
+
+
+def zfs_assert_supported():
     """ Determine if the runtime system supports zfs.
     returns: True if system supports zfs
     raises: RuntimeError: if system does not support zfs
@@ -85,13 +94,15 @@ def zfs_supported():
     if release in ZFS_UNSUPPORTED_RELEASES:
         raise RuntimeError("zfs is not supported on release: %s" % release)
 
-    try:
-        util.subp(['modinfo', 'zfs'], capture=True)
-    except util.ProcessExecutionError as err:
-        if err.stderr.startswith("modinfo: ERROR: Module zfs not found."):
-            raise RuntimeError("zfs kernel module is not available: %s" % err)
+    if 'zfs' not in get_supported_filesystems():
+        try:
+            util.load_kernel_module('zfs')
+        except util.ProcessExecutionError as err:
+            raise RuntimeError("Failed to load 'zfs' kernel module: %s" % err)
 
-    return True
+    missing_progs = [p for p in ('zpool', 'zfs') if not util.which(p)]
+    if missing_progs:
+        raise RuntimeError("Missing zfs utils: %s" % ','.join(missing_progs))
 
 
 def zpool_create(poolname, vdevs, mountpoint=None, altroot=None,
diff --git a/curtin/commands/block_meta.py b/curtin/commands/block_meta.py
index f5b82cf..6bd430d 100644
--- a/curtin/commands/block_meta.py
+++ b/curtin/commands/block_meta.py
@@ -3,7 +3,7 @@
 from collections import OrderedDict, namedtuple
 from curtin import (block, config, util)
 from curtin.block import (bcache, mdadm, mkfs, clear_holders, lvm, iscsi, zfs)
-from curtin.log import LOG
+from curtin.log import LOG, logged_time
 from curtin.reporter import events
 
 from . import populate_one_subcmd
@@ -48,6 +48,7 @@ CMD_ARGUMENTS = (
 )
 
 
+@logged_time("BLOCK_META")
 def block_meta(args):
     # main entry point for the block-meta command.
     state = util.load_command_environment()
@@ -1263,7 +1264,7 @@ def zpool_handler(info, storage_config):
     """
     Create a zpool based in storage_configuration
     """
-    zfs.zfs_supported()
+    zfs.zfs_assert_supported()
 
     state = util.load_command_environment()
 
@@ -1298,7 +1299,8 @@ def zfs_handler(info, storage_config):
     """
     Create a zfs filesystem
     """
-    zfs.zfs_supported()
+    zfs.zfs_assert_supported()
+
     state = util.load_command_environment()
     poolname = get_poolname(info, storage_config)
     volume = info.get('volume')
diff --git a/curtin/commands/install.py b/curtin/commands/install.py
index 9e5406c..4d2a13f 100644
--- a/curtin/commands/install.py
+++ b/curtin/commands/install.py
@@ -15,7 +15,7 @@ from curtin.block import iscsi
 from curtin import config
 from curtin import util
 from curtin import version
-from curtin.log import LOG
+from curtin.log import LOG, logged_time
 from curtin.reporter.legacy import load_reporter
 from curtin.reporter import events
 from . import populate_one_subcmd
@@ -390,6 +390,7 @@ def migrate_proxy_settings(cfg):
     cfg['proxy'] = proxy
 
 
+@logged_time("INSTALL_COMMAND")
 def cmd_install(args):
     from .collect_logs import create_log_tarfile
     cfg = deepcopy(CONFIG_BUILTIN)
diff --git a/curtin/log.py b/curtin/log.py
index 4844460..446ba2c 100644
--- a/curtin/log.py
+++ b/curtin/log.py
@@ -1,6 +1,9 @@
 # This file is part of curtin. See LICENSE file for copyright and license info.
 
 import logging
+import time
+
+from functools import wraps
 
 # Logging items for easy access
 getLogger = logging.getLogger
@@ -56,6 +59,46 @@ def _getLogger(name='curtin'):
 if not logging.getLogger().handlers:
     logging.getLogger().addHandler(NullHandler())
 
+
+def _repr_call(name, *args, **kwargs):
+    return "%s(%s)" % (
+        name,
+        ', '.join([str(repr(a)) for a in args] +
+                  ["%s=%s" % (k, repr(v)) for k, v in kwargs.items()]))
+
+
+def log_call(func, *args, **kwargs):
+    return log_time(
+        "TIMED %s: " % _repr_call(func.__name__, *args, **kwargs),
+        func, *args, **kwargs)
+
+
+def log_time(msg, func, *args, **kwargs):
+    start = time.time()
+    try:
+        return func(*args, **kwargs)
+    finally:
+        LOG.debug(msg + "%.3f", (time.time() - start))
+
+
+def logged_call():
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return log_call(func, *args, **kwargs)
+        return wrapper
+    return decorator
+
+
+def logged_time(msg):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return log_time("TIMED %s: " % msg, func, *args, **kwargs)
+        return wrapper
+    return decorator
+
+
 LOG = _getLogger()
 
 # vi: ts=4 expandtab syntax=python
diff --git a/curtin/udev.py b/curtin/udev.py
index 92e38ff..13d9cc5 100644
--- a/curtin/udev.py
+++ b/curtin/udev.py
@@ -2,6 +2,7 @@
 
 import os
 from curtin import util
+from curtin.log import logged_call
 
 
 def compose_udev_equality(key, value):
@@ -40,6 +41,7 @@ def generate_udev_rule(interface, mac):
     return '%s\n' % rule
 
 
+@logged_call()
 def udevadm_settle(exists=None, timeout=None):
     settle_cmd = ["udevadm", "settle"]
     if exists:
diff --git a/curtin/util.py b/curtin/util.py
index 7d06c09..29bf06e 100644
--- a/curtin/util.py
+++ b/curtin/util.py
@@ -38,7 +38,7 @@ except NameError:
     # python3 does not have a long type.
     numeric_types = (int, float)
 
-from .log import LOG
+from .log import LOG, log_call
 
 _INSTALLED_HELPERS_PATH = 'usr/lib/curtin/helpers'
 _INSTALLED_MAIN = 'usr/bin/curtin'
@@ -661,7 +661,7 @@ class ChrootableTarget(object):
 
         # if /dev is to be unmounted, udevadm settle (LP: #1462139)
         if target_path(self.target, "/dev") in self.umounts:
-            subp(['udevadm', 'settle'])
+            log_call(subp, ['udevadm', 'settle'])
 
         for p in reversed(self.umounts):
             do_umount(p)
@@ -810,13 +810,37 @@ def parse_dpkg_version(raw, name=None, semx=None):
     """Parse a dpkg version string into various parts and calcualate a
        numerical value of the version for use in comparing package versions
 
-       returns a dictionary with the results
+       Native packages (without a '-'), will have the package version treated
+       as the upstream version.
+
+       returns a dictionary with fields:
+          'major' (int), 'minor' (int), 'micro' (int),
+          'semantic_version' (int),
+          'extra' (string), 'raw' (string), 'upstream' (string),
+          'name' (present only if name is not None)
     """
+    if not isinstance(raw, string_types):
+        raise TypeError(
+            "Invalid type %s for parse_dpkg_version" % raw.__class__)
+
     if semx is None:
         semx = (10000, 100, 1)
 
-    upstream = raw.split('-')[0]
-    toks = upstream.split(".", 2)
+    if "-" in raw:
+        upstream = raw.rsplit('-', 1)[0]
+    else:
+        # this is a native package, package version treated as upstream.
+        upstream = raw
+
+    match = re.search(r'[^0-9.]', upstream)
+    if match:
+        extra = upstream[match.start():]
+        upstream_base = upstream[:match.start()]
+    else:
+        upstream_base = upstream
+        extra = None
+
+    toks = upstream_base.split(".", 2)
     if len(toks) == 3:
         major, minor, micro = toks
     elif len(toks) == 2:
@@ -825,9 +849,10 @@ def parse_dpkg_version(raw, name=None, semx=None):
         major, minor, micro = (toks[0], 0, 0)
 
     version = {
-        'major': major,
-        'minor': minor,
-        'micro': micro,
+        'major': int(major),
+        'minor': int(minor),
+        'micro': int(micro),
+        'extra': extra,
         'raw': raw,
         'upstream': upstream,
     }
diff --git a/debian/changelog b/debian/changelog
index 8f013e6..a9e5d53 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,14 @@
+curtin (18.1-49-g72b02c21-0ubuntu1) cosmic; urgency=medium
+
+  * New upstream snapshot.
+    - clear-holders: handle missing zpool/zfs tools when wiping
+    - clear-holders: rescan for lvm devices after assembling raid arrays
+    - vmtest: enable persistent journal and collect at boot time
+    - Add timing and logging functions.
+    - parse_dpkg_version: support non-numeric in version string.
+
+ -- Chad Smith <[e-mail]>  Fri, 17 Aug 2018 17:23:59 -0600
+
 curtin (18.1-44-g2b12b8fc-0ubuntu1) cosmic; urgency=medium
 
   * New upstream snapshot.
diff --git a/examples/tests/dirty_disks_config.yaml b/examples/tests/dirty_disks_config.yaml
index 75d44c3..fb9a0d6 100644
--- a/examples/tests/dirty_disks_config.yaml
+++ b/examples/tests/dirty_disks_config.yaml
@@ -27,6 +27,31 @@ bucket:
       # disable any rpools to trigger disks with zfs_member label but inactive
       # pools
       zpool export rpool ||:
+  - &lvm_stop |
+      #!/bin/sh
+      # This function disables any existing lvm logical volumes that
+      # have been created during the early storage config stage
+      # and simulates the effect of booting into a system with existing
+      # (but inactive) lvm configuration.
+      for vg in `pvdisplay -C --separator = -o vg_name --noheadings`; do
+         vgchange -an $vg ||:
+      done
+      # disable the automatic pvscan, we want to test that curtin
+      # can find/enable logical volumes without this service
+      command -v systemctl && systemctl mask lvm2-pvscan\@.service
+      # remove any existing metadata written from early disk config
+      rm -rf /etc/lvm/archive /etc/lvm/backup
+  - &mdadm_stop  |
+      #!/bin/sh
+      # This function disables any existing raid devices which may
+      # have been created during the early storage config stage
+      # and simulates the effect of booting into a system with existing
+      # but inactive mdadm configuration.
+      for md in /dev/md*; do
+          mdadm --stop $md ||:
+      done
+      # remove any existing metadata written from early disk config
+      rm -f /etc/mdadm/mdadm.conf
 
 early_commands:
   # running block-meta custom from the install environment
@@ -34,9 +59,11 @@ early_commands:
   # the disks exactly as in this config before the rest of the install
   # will just blow it all away.  We have clean out other environment
   # that could unintentionally mess things up.
-  blockmeta: [env, -u, OUTPUT_FSTAB,
+  01-blockmeta: [env, -u, OUTPUT_FSTAB,
               TARGET_MOUNT_POINT=/tmp/my.bdir/target,
               WORKING_DIR=/tmp/my.bdir/work.d, 
               curtin, --showtrace, -v, block-meta, --umount, custom]
-  enable_swaps: [sh, -c, *swapon]
-  disable_rpool: [sh, -c, *zpool_export]
+  02-enable_swaps: [sh, -c, *swapon]
+  03-disable_rpool: [sh, -c, *zpool_export]
+  04-lvm_stop: [sh, -c, *lvm_stop]
+  05-mdadm_stop: [sh, -c, *mdadm_stop]
diff --git a/examples/tests/lvmoverraid.yaml b/examples/tests/lvmoverraid.yaml
new file mode 100644
index 0000000..a1d41e9
--- /dev/null
+++ b/examples/tests/lvmoverraid.yaml
@@ -0,0 +1,98 @@
+storage:
+    config:
+    -   grub_device: true
+        id: disk-0
+        model: QEMU_HARDDISK
+        name: 'main_disk'
+        serial: disk-a
+        preserve: false
+        ptable: gpt
+        type: disk
+        wipe: superblock
+    -   grub_device: false
+        id: disk-2
+        name: 'disk-2'
+        serial: disk-b
+        preserve: false
+        type: disk
+        wipe: superblock
+    -   grub_device: false
+        id: disk-1
+        name: 'disk-1'
+        serial: disk-c
+        preserve: false
+        type: disk
+        wipe: superblock
+    -   grub_device: false
+        id: disk-3
+        name: 'disk-3'
+        serial: disk-d
+        preserve: false
+        type: disk
+        wipe: superblock
+    -   grub_device: false
+        id: disk-4
+        name: 'disk-4'
+        serial: disk-e
+        preserve: false
+        type: disk
+        wipe: superblock
+    -   device: disk-0
+        flag: bios_grub
+        id: part-0
+        preserve: false
+        size: 1048576
+        type: partition
+    -   device: disk-0
+        flag: ''
+        id: part-1
+        preserve: false
+        size: 4G
+        type: partition
+    -   devices:
+        - disk-2
+        - disk-1
+        id: raid-0
+        name: md0
+        raidlevel: 1
+        spare_devices: []
+        type: raid
+    -   devices:
+        - disk-3
+        - disk-4
+        id: raid-1
+        name: md1
+        raidlevel: 1
+        spare_devices: []
+        type: raid
+    -   devices:
+        - raid-0
+        - raid-1
+        id: vg-0
+        name: vg0
+        type: lvm_volgroup
+    -   id: lv-0
+        name: lv-0
+        size: 3G
+        type: lvm_partition
+        volgroup: vg-0
+    -   fstype: ext4
+        id: fs-0
+        preserve: false
+        type: format
+        volume: part-1
+    -   fstype: ext4
+        id: fs-1
+        preserve: false
+        type: format
+        volume: lv-0
+    -   device: fs-0
+        id: mount-0
+        path: /
+        type: mount
+    -   device: fs-1
+        id: mount-1
+        path: /home
+        type: mount
+    version: 1
+
diff --git a/examples/tests/vmtest_pollinate.yaml b/examples/tests/vmtest_defaults.yaml
index e4fac06..b1512a8 100644
--- a/examples/tests/vmtest_pollinate.yaml
+++ b/examples/tests/vmtest_defaults.yaml
@@ -6,5 +6,19 @@ _vmtest_pollinate:
    [ -d "${cfg%/*}" ] || exit 0
    echo curtin/vmtest >> "$cfg"
 
+# this enables a persitent journald if target system has journald
+# and does not have /var/log/journal directory already
+_persist_journal:
+ - &persist_journal |
+   command -v journalctl && {
+       jdir=/var/log/journal
+       [ -e ${jdir} ] || {
+           mkdir -p ${jdir}
+           systemd-tmpfiles --create --prefix ${jdir}
+       }
+    }
+    exit 0
+
 late_commands:
   01_vmtest_pollinate: ['curtin', 'in-target', '--', 'sh', '-c', *pvmtest]
+  02_persist_journal: ['curtin', 'in-target', '--', 'sh', '-c', *persist_journal]
diff --git a/tests/unittests/test_block.py b/tests/unittests/test_block.py
index d9b19a4..9cf8383 100644
--- a/tests/unittests/test_block.py
+++ b/tests/unittests/test_block.py
@@ -647,4 +647,39 @@ class TestSlaveKnames(CiTestCase):
         knames = block.get_device_slave_knames(device)
         self.assertEqual(slaves, knames)
 
+
+class TestGetSupportedFilesystems(CiTestCase):
+
+    supported_filesystems = ['sysfs', 'rootfs', 'ramfs', 'ext4']
+
+    def _proc_filesystems_output(self, supported=None):
+        if not supported:
+            supported = self.supported_filesystems
+
+        def devname(fsname):
+            """ in-use filesystem modules not emit the 'nodev' prefix """
+            return '\t' if fsname.startswith('ext') else 'nodev\t'
+
+        return '\n'.join([devname(fs) + fs for fs in supported]) + '\n'
+
+    @mock.patch('curtin.block.util')
+    @mock.patch('curtin.block.os')
+    def test_get_supported_filesystems(self, mock_os, mock_util):
+        """ test parsing /proc/filesystems contents into a filesystem list"""
+        mock_os.path.exists.return_value = True
+        mock_util.load_file.return_value = self._proc_filesystems_output()
+
+        result = block.get_supported_filesystems()
+        self.assertEqual(sorted(self.supported_filesystems), sorted(result))
+
+    @mock.patch('curtin.block.util')
+    @mock.patch('curtin.block.os')
+    def test_get_supported_filesystems_no_proc_path(self, mock_os, mock_util):
+        """ missing /proc/filesystems raises RuntimeError """
+        mock_os.path.exists.return_value = False
+        with self.assertRaises(RuntimeError):
+            block.get_supported_filesystems()
+        self.assertEqual(0, mock_util.load_file.call_count)
+
+
 # vi: ts=4 expandtab syntax=python
diff --git a/tests/unittests/test_block_lvm.py b/tests/unittests/test_block_lvm.py
index 341f2fa..22fb064 100644
--- a/tests/unittests/test_block_lvm.py
+++ b/tests/unittests/test_block_lvm.py
@@ -75,24 +75,24 @@ class TestBlockLvm(CiTestCase):
     @mock.patch('curtin.block.lvm.util')
     def test_lvm_scan(self, mock_util, mock_lvmetad):
         """check that lvm_scan formats commands correctly for each release"""
+        cmds = [['pvscan'], ['vgscan', '--mknodes']]
         for (count, (codename, lvmetad_status, use_cache)) in enumerate(
-                [('precise', False, False), ('precise', True, False),
-                 ('trusty', False, False), ('trusty', True, True),
-                 ('vivid', False, False), ('vivid', True, True),
-                 ('wily', False, False), ('wily', True, True),
+                [('precise', False, False),
+                 ('trusty', False, False),
                  ('xenial', False, False), ('xenial', True, True),
-                 ('yakkety', True, True), ('UNAVAILABLE', True, True),
                  (None, True, True), (None, False, False)]):
             mock_util.lsb_release.return_value = {'codename': codename}
             mock_lvmetad.return_value = lvmetad_status
             lvm.lvm_scan()
-            self.assertEqual(
-                len(mock_util.subp.call_args_list), 2 * (count + 1))
-            for (expected, actual) in zip(
-                    [['pvscan'], ['vgscan', '--mknodes']],
-                    mock_util.subp.call_args_list[2 * count:2 * count + 2]):
-                if use_cache:
-                    expected.append('--cache')
-                self.assertEqual(mock.call(expected, capture=True), actual)
+            expected = [cmd for cmd in cmds]
+            for cmd in expected:
+                if lvmetad_status:
+                    cmd.append('--cache')
+
+            calls = [mock.call(cmd, capture=True) for cmd in expected]
+            self.assertEqual(len(expected), len(mock_util.subp.call_args_list))
+            mock_util.subp.has_calls(calls)
+            mock_util.subp.reset_mock()
+
 
 # vi: ts=4 expandtab syntax=python
diff --git a/tests/unittests/test_block_mdadm.py b/tests/unittests/test_block_mdadm.py
index e2e109c..341e49d 100644
--- a/tests/unittests/test_block_mdadm.py
+++ b/tests/unittests/test_block_mdadm.py
@@ -90,6 +90,8 @@ class TestBlockMdadmCreate(CiTestCase):
         self.add_patch('curtin.block.mdadm.util', 'mock_util')
         self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
         self.add_patch('curtin.block.mdadm.get_holders', 'mock_holders')
+        self.add_patch('curtin.block.mdadm.udev.udevadm_settle',
+                       'm_udevadm_settle')
 
         # Common mock settings
         self.mock_valid.return_value = True
@@ -115,8 +117,6 @@ class TestBlockMdadmCreate(CiTestCase):
             expected_calls.append(
                 call(["mdadm", "--zero-superblock", d], capture=True))
 
-        side_effects.append(("", ""))  # udevadm settle
-        expected_calls.append(call(["udevadm", "settle"]))
         side_effects.append(("", ""))  # udevadm control --stop-exec-queue
         expected_calls.append(call(["udevadm", "control",
                                     "--stop-exec-queue"]))
@@ -134,9 +134,6 @@ class TestBlockMdadmCreate(CiTestCase):
         side_effects.append(("", ""))  # udevadm control --start-exec-queue
         expected_calls.append(call(["udevadm", "control",
                                     "--start-exec-queue"]))
-        side_effects.append(("", ""))  # udevadm settle
-        expected_calls.append(call(["udevadm", "settle",
-                                    "--exit-if-exists=%s" % md_devname]))
 
         return (side_effects, expected_calls)
 
@@ -154,6 +151,8 @@ class TestBlockMdadmCreate(CiTestCase):
         mdadm.mdadm_create(md_devname=md_devname, raidlevel=raidlevel,
                            devices=devices, spares=spares)
         self.mock_util.subp.assert_has_calls(expected_calls)
+        self.m_udevadm_settle.assert_has_calls(
+            [call(), call(exists=md_devname)])
 
     def test_mdadm_create_raid0_devshort(self):
         md_devname = "md0"
diff --git a/tests/unittests/test_block_zfs.py b/tests/unittests/test_block_zfs.py
index c61a6da..ca8f118 100644
--- a/tests/unittests/test_block_zfs.py
+++ b/tests/unittests/test_block_zfs.py
@@ -378,10 +378,10 @@ class TestBlockZfsDeviceToPoolname(CiTestCase):
         self.mock_blkid.assert_called_with(devs=[devname])
 
 
-class TestBlockZfsZfsSupported(CiTestCase):
+class TestBlockZfsAssertZfsSupported(CiTestCase):
 
     def setUp(self):
-        super(TestBlockZfsZfsSupported, self).setUp()
+        super(TestBlockZfsAssertZfsSupported, self).setUp()
         self.add_patch('curtin.block.zfs.util.subp', 'mock_subp')
         self.add_patch('curtin.block.zfs.util.get_platform_arch', 'mock_arch')
         self.add_patch('curtin.block.zfs.util.lsb_release', 'mock_release')
@@ -394,34 +394,41 @@ class TestBlockZfsZfsSupported(CiTestCase):
     def test_unsupported_arch(self):
         self.mock_arch.return_value = 'i386'
         with self.assertRaises(RuntimeError):
-            zfs.zfs_supported()
+            zfs.zfs_assert_supported()
 
     def test_unsupported_releases(self):
         for rel in ['precise', 'trusty']:
             self.mock_release.return_value = {'codename': rel}
             with self.assertRaises(RuntimeError):
-                zfs.zfs_supported()
+                zfs.zfs_assert_supported()
 
-    def test_missing_module(self):
-        missing = 'modinfo: ERROR: Module zfs not found.\n     '
+    @mock.patch('curtin.block.zfs.util.is_kmod_loaded')
+    @mock.patch('curtin.block.zfs.get_supported_filesystems')
+    def test_missing_module(self, mock_supfs, mock_kmod):
+        missing = 'modprobe: FATAL: Module zfs not found.\n     '
         self.mock_subp.side_effect = ProcessExecutionError(stdout='',
                                                            stderr=missing,
                                                            exit_code='1')
+        mock_supfs.return_value = ['ext4']
+        mock_kmod.return_value = False
         with self.assertRaises(RuntimeError):
-            zfs.zfs_supported()
+            zfs.zfs_assert_supported()
 
 
-class TestZfsSupported(CiTestCase):
+class TestAssertZfsSupported(CiTestCase):
 
     def setUp(self):
-        super(TestZfsSupported, self).setUp()
+        super(TestAssertZfsSupported, self).setUp()
 
+    @mock.patch('curtin.block.zfs.get_supported_filesystems')
     @mock.patch('curtin.block.zfs.util')
-    def test_zfs_supported_returns_true(self, mock_util):
-        """zfs_supported returns True on supported platforms"""
+    def test_zfs_assert_supported_returns_true(self, mock_util, mock_supfs):
+        """zfs_assert_supported returns True on supported platforms"""
         mock_util.get_platform_arch.return_value = 'amd64'
         mock_util.lsb_release.return_value = {'codename': 'bionic'}
         mock_util.subp.return_value = ("", "")
+        mock_supfs.return_value = ['zfs']
+        mock_util.which.side_effect = iter(['/wark/zpool', '/wark/zfs'])
 
         self.assertNotIn(mock_util.get_platform_arch.return_value,
                          zfs.ZFS_UNSUPPORTED_ARCHES)
@@ -430,45 +437,94 @@ class TestZfsSupported(CiTestCase):
         self.assertTrue(zfs.zfs_supported())
 
     @mock.patch('curtin.block.zfs.util')
-    def test_zfs_supported_raises_exception_on_bad_arch(self, mock_util):
-        """zfs_supported raises RuntimeError on unspported arches"""
+    def test_zfs_assert_supported_raises_exception_on_bad_arch(self,
+                                                               mock_util):
+        """zfs_assert_supported raises RuntimeError on unspported arches"""
         mock_util.lsb_release.return_value = {'codename': 'bionic'}
         mock_util.subp.return_value = ("", "")
         for arch in zfs.ZFS_UNSUPPORTED_ARCHES:
             mock_util.get_platform_arch.return_value = arch
             with self.assertRaises(RuntimeError):
-                zfs.zfs_supported()
+                zfs.zfs_assert_supported()
 
     @mock.patch('curtin.block.zfs.util')
-    def test_zfs_supported_raises_execption_on_bad_releases(self, mock_util):
-        """zfs_supported raises RuntimeError on unspported releases"""
+    def test_zfs_assert_supported_raises_exc_on_bad_releases(self, mock_util):
+        """zfs_assert_supported raises RuntimeError on unspported releases"""
         mock_util.get_platform_arch.return_value = 'amd64'
         mock_util.subp.return_value = ("", "")
         for release in zfs.ZFS_UNSUPPORTED_RELEASES:
             mock_util.lsb_release.return_value = {'codename': release}
             with self.assertRaises(RuntimeError):
-                zfs.zfs_supported()
+                zfs.zfs_assert_supported()
 
     @mock.patch('curtin.block.zfs.util.subprocess.Popen')
+    @mock.patch('curtin.block.zfs.util.is_kmod_loaded')
+    @mock.patch('curtin.block.zfs.get_supported_filesystems')
     @mock.patch('curtin.block.zfs.util.lsb_release')
     @mock.patch('curtin.block.zfs.util.get_platform_arch')
-    def test_zfs_supported_raises_exception_on_missing_module(self,
-                                                              m_arch,
-                                                              m_release,
-                                                              m_popen):
-        """zfs_supported raises RuntimeError on missing zfs module"""
+    def test_zfs_assert_supported_raises_exc_on_missing_module(self,
+                                                               m_arch,
+                                                               m_release,
+                                                               m_supfs,
+                                                               m_kmod,
+                                                               m_popen,
+                                                               ):
+        """zfs_assert_supported raises RuntimeError modprobe zfs error"""
 
         m_arch.return_value = 'amd64'
         m_release.return_value = {'codename': 'bionic'}
+        m_supfs.return_value = ['ext4']
+        m_kmod.return_value = False
         process_mock = mock.Mock()
         attrs = {
             'returncode': 1,
             'communicate.return_value':
-                ('output', "modinfo: ERROR: Module zfs not found."),
+                ('output', 'modprobe: FATAL: Module zfs not found ...'),
         }
         process_mock.configure_mock(**attrs)
         m_popen.return_value = process_mock
         with self.assertRaises(RuntimeError):
-            zfs.zfs_supported()
+            zfs.zfs_assert_supported()
+
+    @mock.patch('curtin.block.zfs.get_supported_filesystems')
+    @mock.patch('curtin.block.zfs.util.lsb_release')
+    @mock.patch('curtin.block.zfs.util.get_platform_arch')
+    @mock.patch('curtin.block.zfs.util')
+    def test_zfs_assert_supported_raises_exc_on_missing_binaries(self,
+                                                                 mock_util,
+                                                                 m_arch,
+                                                                 m_release,
+                                                                 m_supfs):
+        """zfs_assert_supported raises RuntimeError if no zpool or zfs tools"""
+        mock_util.get_platform_arch.return_value = 'amd64'
+        mock_util.lsb_release.return_value = {'codename': 'bionic'}
+        mock_util.subp.return_value = ("", "")
+        m_supfs.return_value = ['zfs']
+        mock_util.which.return_value = None
+
+        with self.assertRaises(RuntimeError):
+            zfs.zfs_assert_supported()
+
+
+class TestZfsSupported(CiTestCase):
+
+    @mock.patch('curtin.block.zfs.zfs_assert_supported')
+    def test_zfs_supported(self, m_assert_zfs):
+        zfs_supported = True
+        m_assert_zfs.return_value = zfs_supported
+
+        result = zfs.zfs_supported()
+        self.assertEqual(zfs_supported, result)
+        self.assertEqual(1, m_assert_zfs.call_count)
+
+    @mock.patch('curtin.block.zfs.zfs_assert_supported')
+    def test_zfs_supported_returns_false_on_assert_fail(self, m_assert_zfs):
+        zfs_supported = False
+        m_assert_zfs.side_effect = RuntimeError('No zfs module')
+
+        result = zfs.zfs_supported()
+        self.assertEqual(zfs_supported, result)
+        self.assertEqual(1, m_assert_zfs.call_count)
+
 
 # vi: ts=4 expandtab syntax=python
diff --git a/tests/unittests/test_clear_holders.py b/tests/unittests/test_clear_holders.py
index 6c29171..d3f80a0 100644
--- a/tests/unittests/test_clear_holders.py
+++ b/tests/unittests/test_clear_holders.py
@@ -6,6 +6,7 @@ import os
 import textwrap
 
 from curtin.block import clear_holders
+from curtin.util import ProcessExecutionError
 from .helpers import CiTestCase
 
 
@@ -558,6 +559,7 @@ class TestClearHolders(CiTestCase):
         self.assertFalse(mock_block.wipe_volume.called)
         mock_block.is_extended_partition.return_value = False
         mock_block.is_zfs_member.return_value = True
+        mock_zfs.zfs_supported.return_value = True
         mock_zfs.device_to_poolname.return_value = 'fake_pool'
         mock_zfs.zpool_list.return_value = ['fake_pool']
         clear_holders.wipe_superblock(self.test_syspath)
@@ -567,6 +569,58 @@ class TestClearHolders(CiTestCase):
             self.test_blockdev, exclusive=True, mode='superblock')
 
     @mock.patch('curtin.block.clear_holders.is_swap_device')
+    @mock.patch('curtin.block.clear_holders.zfs')
+    @mock.patch('curtin.block.clear_holders.LOG')
+    @mock.patch('curtin.block.clear_holders.block')
+    def test_clear_holders_wipe_superblock_no_zfs(self, mock_block, mock_log,
+                                                  mock_zfs, mock_swap):
+        """test clear_holders.wipe_superblock checks zfs supported"""
+        mock_swap.return_value = False
+        mock_block.sysfs_to_devpath.return_value = self.test_blockdev
+        mock_block.is_extended_partition.return_value = True
+        clear_holders.wipe_superblock(self.test_syspath)
+        self.assertFalse(mock_block.wipe_volume.called)
+        mock_block.is_extended_partition.return_value = False
+        mock_block.is_zfs_member.return_value = True
+        mock_zfs.zfs_supported.return_value = False
+        clear_holders.wipe_superblock(self.test_syspath)
+        mock_block.sysfs_to_devpath.assert_called_with(self.test_syspath)
+        self.assertEqual(1, mock_zfs.zfs_supported.call_count)
+        self.assertEqual(0, mock_block.is_zfs_member.call_count)
+        self.assertEqual(0, mock_zfs.device_to_poolname.call_count)
+        self.assertEqual(0, mock_zfs.zpool_list.call_count)
+        mock_block.wipe_volume.assert_called_with(
+            self.test_blockdev, exclusive=True, mode='superblock')
+
+    @mock.patch('curtin.block.clear_holders.is_swap_device')
+    @mock.patch('curtin.block.clear_holders.zfs')
+    @mock.patch('curtin.block.clear_holders.LOG')
+    @mock.patch('curtin.block.clear_holders.block')
+    def test_clear_holders_wipe_superblock_zfs_no_utils(self, mock_block,
+                                                        mock_log, mock_zfs,
+                                                        mock_swap):
+        """test clear_holders.wipe_superblock handles missing zpool cmd"""
+        mock_swap.return_value = False
+        mock_block.sysfs_to_devpath.return_value = self.test_blockdev
+        mock_block.is_extended_partition.return_value = True
+        clear_holders.wipe_superblock(self.test_syspath)
+        self.assertFalse(mock_block.wipe_volume.called)
+        mock_block.is_extended_partition.return_value = False
+        mock_block.is_zfs_member.return_value = True
+        mock_zfs.zfs_supported.return_value = True
+        mock_zfs.device_to_poolname.return_value = 'fake_pool'
+        mock_zfs.zpool_list.return_value = ['fake_pool']
+        mock_zfs.zpool_export.side_effect = [
+            ProcessExecutionError(cmd=['zpool', 'export', 'fake_pool'],
+                                  stdout="",
+                                  stderr=("cannot open 'fake_pool': "
+                                          "no such pool"))]
+        clear_holders.wipe_superblock(self.test_syspath)
+        mock_block.sysfs_to_devpath.assert_called_with(self.test_syspath)
+        mock_block.wipe_volume.assert_called_with(
+            self.test_blockdev, exclusive=True, mode='superblock')
+
+    @mock.patch('curtin.block.clear_holders.is_swap_device')
     @mock.patch('curtin.block.clear_holders.time')
     @mock.patch('curtin.block.clear_holders.LOG')
     @mock.patch('curtin.block.clear_holders.block')
@@ -779,22 +833,25 @@ class TestClearHolders(CiTestCase):
         mock_gen_holders_tree.return_value = self.example_holders_trees[1][1]
         clear_holders.assert_clear(device)
 
+    @mock.patch('curtin.block.clear_holders.lvm')
     @mock.patch('curtin.block.clear_holders.zfs')
     @mock.patch('curtin.block.clear_holders.mdadm')
     @mock.patch('curtin.block.clear_holders.util')
-    def test_start_clear_holders_deps(self, mock_util, mock_mdadm, mock_zfs):
+    def test_start_clear_holders_deps(self, mock_util, mock_mdadm, mock_zfs,
+                                      mock_lvm):
         mock_zfs.zfs_supported.return_value = True
         clear_holders.start_clear_holders_deps()
         mock_mdadm.mdadm_assemble.assert_called_with(
             scan=True, ignore_errors=True)
         mock_util.load_kernel_module.assert_has_calls([
-                mock.call('bcache'), mock.call('zfs')])
+                mock.call('bcache')])
 
+    @mock.patch('curtin.block.clear_holders.lvm')
     @mock.patch('curtin.block.clear_holders.zfs')
     @mock.patch('curtin.block.clear_holders.mdadm')
     @mock.patch('curtin.block.clear_holders.util')
     def test_start_clear_holders_deps_nozfs(self, mock_util, mock_mdadm,
-                                            mock_zfs):
+                                            mock_zfs, mock_lvm):
         """test that we skip zfs modprobe on unsupported platforms"""
         mock_zfs.zfs_supported.return_value = False
         clear_holders.start_clear_holders_deps()
diff --git a/tests/unittests/test_util.py b/tests/unittests/test_util.py
index 483cd5d..7fb332d 100644
--- a/tests/unittests/test_util.py
+++ b/tests/unittests/test_util.py
@@ -4,6 +4,7 @@ from unittest import skipIf
 import mock
 import os
 import stat
+import sys
 from textwrap import dedent
 
 from curtin import util
@@ -1035,4 +1036,65 @@ class TestLoadKernelModule(CiTestCase):
         self.assertEqual(0, self.m_subp.call_count)
 
 
+class TestParseDpkgVersion(CiTestCase):
+    """test parse_dpkg_version."""
+
+    def test_none_raises_type_error(self):
+        self.assertRaises(TypeError, util.parse_dpkg_version, None)
+
+    @skipIf(sys.version_info.major < 3, "python 2 bytes are strings.")
+    def test_bytes_raises_type_error(self):
+        self.assertRaises(TypeError, util.parse_dpkg_version, b'1.2.3-0')
+
+    def test_simple_native_package_version(self):
+        """dpkg versions must have a -. If not present expect value error."""
+        self.assertEqual(
+            {'major': 2, 'minor': 28, 'micro': 0, 'extra': None,
+             'raw': '2.28', 'upstream': '2.28', 'name': 'germinate',
+             'semantic_version': 22800},
+            util.parse_dpkg_version('2.28', name='germinate'))
+
+    def test_complex_native_package_version(self):
+        dver = '1.0.106ubuntu2+really1.0.97ubuntu1'
+        self.assertEqual(
+            {'major': 1, 'minor': 0, 'micro': 106,
+             'extra': 'ubuntu2+really1.0.97ubuntu1',
+             'raw': dver, 'upstream': dver, 'name': 'debootstrap',
+             'semantic_version': 100106},
+            util.parse_dpkg_version(dver, name='debootstrap',
+                                    semx=(100000, 1000, 1)))
+
+    def test_simple_valid(self):
+        self.assertEqual(
+            {'major': 1, 'minor': 2, 'micro': 3, 'extra': None,
+             'raw': '1.2.3-0', 'upstream': '1.2.3', 'name': 'foo',
+             'semantic_version': 10203},
+            util.parse_dpkg_version('1.2.3-0', name='foo'))
+
+    def test_simple_valid_with_semx(self):
+        self.assertEqual(
+            {'major': 1, 'minor': 2, 'micro': 3, 'extra': None,
+             'raw': '1.2.3-0', 'upstream': '1.2.3',
+             'semantic_version': 123},
+            util.parse_dpkg_version('1.2.3-0', semx=(100, 10, 1)))
+
+    def test_upstream_with_hyphen(self):
+        """upstream versions may have a hyphen."""
+        cver = '18.2-14-g6d48d265-0ubuntu1'
+        self.assertEqual(
+            {'major': 18, 'minor': 2, 'micro': 0, 'extra': '-14-g6d48d265',
+             'raw': cver, 'upstream': '18.2-14-g6d48d265',
+             'name': 'cloud-init', 'semantic_version': 180200},
+            util.parse_dpkg_version(cver, name='cloud-init'))
+
+    def test_upstream_with_plus(self):
+        """multipath tools has a + in it."""
+        mver = '0.5.0+git1.656f8865-5ubuntu2.5'
+        self.assertEqual(
+            {'major': 0, 'minor': 5, 'micro': 0, 'extra': '+git1.656f8865',
+             'raw': mver, 'upstream': '0.5.0+git1.656f8865',
+             'semantic_version': 500},
+            util.parse_dpkg_version(mver))
+
+
 # vi: ts=4 expandtab syntax=python
diff --git a/tests/vmtests/__init__.py b/tests/vmtests/__init__.py
index 68b7442..0249655 100644
--- a/tests/vmtests/__init__.py
+++ b/tests/vmtests/__init__.py
@@ -916,8 +916,9 @@ class VMBaseClass(TestCase):
         # build iscsi disk args if needed
         disks.extend(cls.build_iscsi_disks())
 
+        # class config file and vmtest defaults
+        configs = [cls.conf_file, 'examples/tests/vmtest_defaults.yaml']
         # proxy config
-        configs = [cls.conf_file, 'examples/tests/vmtest_pollinate.yaml']
         cls.proxy = get_apt_proxy()
         if cls.proxy is not None and not cls.td.restored:
             proxy_config = os.path.join(cls.td.install, 'proxy.cfg')
@@ -1800,6 +1801,19 @@ def generate_user_data(collect_scripts=None, apt_proxy=None,
         exit 0;
         """)
 
+    # add journal collection "last" before collect_post
+    collect_journal = textwrap.dedent("""#!/bin/sh -x
+        cd OUTPUT_COLLECT_D
+        # sync and flush journal before copying (if journald enabled)
+        [ -e /var/log/journal ] && {
+            journalctl --sync --flush --rotate
+            cp -a /var/log/journal ./var-log-journal
+            gzip -9 ./var-log-journal/*/system*.journal
+        }
+        exit 0;
+        """)
+    collect_scripts.append(collect_journal)
+
     scripts = ([collect_prep] + [copy_rootdir] + collect_scripts +
                [collect_post] + [failsafe_poweroff])
 
diff --git a/tests/vmtests/test_lvm_raid.py b/tests/vmtests/test_lvm_raid.py
new file mode 100644
index 0000000..0c50941
--- /dev/null
+++ b/tests/vmtests/test_lvm_raid.py
@@ -0,0 +1,50 @@
+# This file is part of curtin. See LICENSE file for copyright and license info.
+
+from .releases import base_vm_classes as relbase
+from .test_mdadm_bcache import TestMdadmAbs
+from .test_lvm import TestLvmAbs
+
+import textwrap
+
+
+class TestLvmOverRaidAbs(TestMdadmAbs, TestLvmAbs):
+    conf_file = "examples/tests/lvmoverraid.yaml"
+    active_mdadm = "2"
+    nr_cpus = 2
+    dirty_disks = True
+    extra_disks = ['10G'] * 4
+
+    collect_scripts = TestLvmAbs.collect_scripts
+    collect_scripts += TestMdadmAbs.collect_scripts + [textwrap.dedent("""
+        cd OUTPUT_COLLECT_D
+        ls -al /dev/md* > dev_md
+        cp -a /etc/mdadm etc_mdadm
+        cp -a /etc/lvm etc_lvm
+        """)]
+
+    fstab_expected = {
+        '/dev/vg1/lv1': '/srv/data',
+        '/dev/vg1/lv2': '/srv/backup',
+    }
+    disk_to_check = [('main_disk', 1),
+                     ('md0', 0),
+                     ('md1', 0)]
+
+    def test_lvs(self):
+        self.check_file_strippedline("lvs", "lv-0=vg0")
+
+    def test_pvs(self):
+        self.check_file_strippedline("pvs", "vg0=/dev/md0")
+        self.check_file_strippedline("pvs", "vg0=/dev/md1")
+
+
+class CosmicTestLvmOverRaid(relbase.cosmic, TestLvmOverRaidAbs):
+    __test__ = True
+
+
+class BionicTestLvmOverRaid(relbase.bionic, TestLvmOverRaidAbs):
+    __test__ = True
+
+
+class XenialGATestLvmOverRaid(relbase.xenial_ga, TestLvmOverRaidAbs):
+    __test__ = True
diff --git a/tests/vmtests/test_lvm_root.py b/tests/vmtests/test_lvm_root.py
index 8ca69d4..bc8b047 100644
--- a/tests/vmtests/test_lvm_root.py
+++ b/tests/vmtests/test_lvm_root.py
@@ -113,7 +113,7 @@ class XenialTestUefiLvmRootXfs(relbase.xenial, TestUefiLvmRootAbs):
     }
 
 
[e-mail]_by_date("1652822", fixby="2019-06-01")
[e-mail]_by_date("1652822", fixby="2019-06-01", install=False)
 class XenialTestUefiLvmRootXfsBootXfs(relbase.xenial, TestUefiLvmRootAbs):
     """This tests xfs root and xfs boot with uefi.