Merge ~mwhudson/curtin:dead-code into curtin:master

[Michael Hudson-Doyle]

remove some unused code

My other ongoing curtin changes seem to be heading off into the weeds sadly, so here's something a little bit simpler, hopefully.

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

FAILED: Continuous integration, rev:c942b260927f7c0770b455a8dc7ea40669e34b82
https://jenkins.ubuntu.com/server/job/curtin-ci/55/
Executed test runs:
    FAILURE: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-amd64/55/
    FAILURE: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-arm64/55/
    FAILURE: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-ppc64el/55/
    FAILURE: https://jenkins.ubuntu.com/server/job/curtin-ci/nodes=metal-s390x/55/

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

review: Needs Fixing (continuous-integration)

3ba0d9e... by Michael Hudson-Doyle on 2021-01-12

fix flakes

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

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

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

review: Approve (continuous-integration)

[Dan Bungert (dbungert)]

Is this still interesting?

[Michael Hudson-Doyle (mwhudson)]

I'm all in favour of deleting unused code, but I guess I should probably be more piecemeal.

Unmerged commits

3ba0d9e... by Michael Hudson-Doyle on 2021-01-12

fix flakes

c942b26... by Michael Hudson-Doyle on 2021-01-12

remove unused code from curtin/net/__init__.py

5ee0119... by Michael Hudson-Doyle on 2021-01-12

remove unused code from curtin/commands/curthooks.py

9dba3c5... by Michael Hudson-Doyle on 2021-01-12

remove unused code from curtin/block/bcache.py

29cf3d7... by Michael Hudson-Doyle on 2021-01-12

remove unused code from curtin/block/multipath.py

a706ed3... by Michael Hudson-Doyle on 2021-01-12

remove unused code from curtin/block/mdadm.py

8f93aec... by Michael Hudson-Doyle on 2021-01-12

remove unused functions from curtin/block/iscsi.py

b9f2b53... by Michael Hudson-Doyle on 2021-01-12

remove unused functions from curtin/block/__init__.py

diff --git a/curtin/block/__init__.py b/curtin/block/__init__.py
index 0cf0866..2c1cc7c 100644
--- a/curtin/block/__init__.py
+++ b/curtin/block/__init__.py
@@ -2,7 +2,6 @@
 import re
 from contextlib import contextmanager
 import errno
-import itertools
 import os
 import stat
 import sys
@@ -692,28 +691,6 @@ def get_scsi_wwid(device, replace_whitespace=False):
         return None
 
 
-def get_multipath_wwids():
-    """
-    Get WWIDs of all multipath devices available in the system.
-    """
-    multipath_devices = set()
-    multipath_wwids = set()
-    devuuids = [(d, i['UUID']) for d, i in blkid().items() if 'UUID' in i]
-    # Looking for two disks which contain filesystems with the same UUID.
-    for (dev1, uuid1), (dev2, uuid2) in itertools.combinations(devuuids, 2):
-        if uuid1 == uuid2:
-            multipath_devices.add(get_blockdev_for_partition(dev1)[0])
-    for device in multipath_devices:
-        wwid = get_scsi_wwid(device)
-        # Function get_scsi_wwid() may return None in case of errors or
-        # WWID field may be empty for some buggy disk. We don't want to
-        # propagate both of these value further to avoid generation of
-        # incorrect /etc/multipath/bindings file.
-        if wwid:
-            multipath_wwids.add(wwid)
-    return multipath_wwids
-
-
 def get_root_device(dev, paths=None):
     """
     Get root partition for specified device, based on presence of any
@@ -812,20 +789,6 @@ def get_volume_uuid(path):
     return ''
 
 
-def get_mountpoints():
-    """
-    Returns a list of all mountpoints where filesystems are currently mounted.
-    """
-    info = _lsblock()
-    proc_mounts = [mp for (dev, mp, vfs, opts, freq, passno) in
-                   get_proc_mounts()]
-    lsblock_mounts = list(i.get("MOUNTPOINT") for name, i in info.items() if
-                          i.get("MOUNTPOINT") is not None and
-                          i.get("MOUNTPOINT") != "")
-
-    return list(set(proc_mounts + lsblock_mounts))
-
-
 def get_proc_mounts():
     """
     Returns a list of tuples for each entry in /proc/mounts
@@ -885,15 +848,6 @@ def disk_to_byid_path(kname):
     return mapping.get(dev_path(kname))
 
 
-def disk_to_bypath_path(kname):
-    """"
-    Return a /dev/disk/by-path path to kname if present.
-    """
-
-    mapping = _get_dev_disk_by_prefix('/dev/disk/by-path')
-    return mapping.get(dev_path(kname))
-
-
 def get_device_mapper_links(devpath, first=False):
     """ Return the best devlink to device at devpath. """
     info = udevadm_info(devpath)
@@ -946,30 +900,6 @@ def lookup_disk(serial):
     return path
 
 
-def lookup_dasd(bus_id):
-    """
-    Search for a dasd by its bus_id.
-
-    :param bus_id: s390x ccw bus_id 0.0.NNNN specifying the dasd
-    :returns: dasd kernel device path (/dev/dasda)
-    """
-
-    LOG.info('Processing ccw bus_id %s', bus_id)
-    sys_ccw_dev = '/sys/bus/ccw/devices/%s/block' % bus_id
-    if not os.path.exists(sys_ccw_dev):
-        raise ValueError('Failed to find a block device at %s' % sys_ccw_dev)
-
-    dasds = os.listdir(sys_ccw_dev)
-    if not dasds or len(dasds) < 1:
-        raise ValueError("no dasd with device_id '%s' found" % bus_id)
-
-    path = '/dev/%s' % dasds[0]
-    if not os.path.exists(path):
-        raise ValueError("path '%s' to block device for dasd with bus_id '%s' \
-            does not exist" % (path, bus_id))
-    return path
-
-
 def sysfs_partition_data(blockdev=None, sysfs_path=None):
     # given block device or sysfs_path, return a list of tuples
     # of (kernel_name, number, offset, size)
diff --git a/curtin/block/bcache.py b/curtin/block/bcache.py
index c1a8d26..581379f 100644
--- a/curtin/block/bcache.py
+++ b/curtin/block/bcache.py
@@ -155,17 +155,6 @@ def get_cacheset_members(cset_uuid):
     return members
 
 
-def get_cacheset_cachedev(cset_uuid):
-    """ Return a sysfs path to a cacheset cache device's bcache dir."""
-
-    # XXX: bcache cachesets only have a single cache0 entry
-    cachedev = '/sys/fs/bcache/%s/cache0' % cset_uuid
-    if os.path.exists(cachedev):
-        return os.path.realpath(cachedev)
-
-    return None
-
-
 def attach_backing_to_cacheset(backing_device, cache_device, cset_uuid):
     LOG.info("Attaching backing device to cacheset: "
              "{} -> {} cset.uuid: {}".format(backing_device, cache_device,
diff --git a/curtin/block/iscsi.py b/curtin/block/iscsi.py
index 3c46500..f251994 100644
--- a/curtin/block/iscsi.py
+++ b/curtin/block/iscsi.py
@@ -9,7 +9,7 @@ import os
 import re
 import shutil
 
-from curtin import (paths, util, udev)
+from curtin import (util, udev)
 from curtin.block import (get_device_slave_knames,
                           path_to_kname)
 
@@ -225,11 +225,6 @@ def ensure_disk_connected(rfc4173, write_config=True):
     return iscsi_disk
 
 
-def connected_disks():
-    global _ISCSI_DISKS
-    return _ISCSI_DISKS
-
-
 def get_iscsi_volumes_from_config(cfg):
     """Parse a curtin storage config and return a list
        of iscsi disk rfc4173 uris for each configuration present.
@@ -267,33 +262,6 @@ def get_iscsi_ports_from_config(cfg):
     return ports
 
 
-def disconnect_target_disks(target_root_path=None):
-    target_nodes_path = paths.target_path(target_root_path, '/etc/iscsi/nodes')
-    fails = []
-    if os.path.isdir(target_nodes_path):
-        for target in os.listdir(target_nodes_path):
-            if target not in iscsiadm_sessions():
-                LOG.debug('iscsi target %s not active, skipping', target)
-                continue
-            # conn is "host,port,lun"
-            for conn in os.listdir(
-                            os.path.sep.join([target_nodes_path, target])):
-                host, port, _ = conn.split(',')
-                try:
-                    util.subp(['sync'])
-                    iscsiadm_logout(target, '%s:%s' % (host, port))
-                except util.ProcessExecutionError as e:
-                    fails.append(target)
-                    LOG.warn("Unable to logout of iSCSI target %s: %s",
-                             target, e)
-    else:
-        LOG.warning('Skipping disconnect: failed to find iscsi nodes path: %s',
-                    target_nodes_path)
-    if fails:
-        raise RuntimeError(
-            "Unable to logout of iSCSI targets: %s" % ', '.join(fails))
-
-
 # Determines if a /dev/disk/by-path symlink matching the udev pattern
 # for iSCSI disks is pointing at @kname
 def kname_is_iscsi(kname):
diff --git a/curtin/block/mdadm.py b/curtin/block/mdadm.py
index a6ac970..fd26752 100644
--- a/curtin/block/mdadm.py
+++ b/curtin/block/mdadm.py
@@ -92,11 +92,6 @@ READWRITE_RAID_STATES = [
     'write-pending',
 ]
 
-VALID_RAID_ARRAY_STATES = (
-    ERROR_RAID_STATES +
-    READONLY_RAID_STATES +
-    READWRITE_RAID_STATES
-)
 
 # need a on-import check of version and set the value for later reference
 ''' mdadm version < 3.3 doesn't include enough info when using --export
@@ -353,15 +348,6 @@ def mdadm_stop(devpath, retries=None):
     raise OSError('Failed to stop mdadm device %s', devpath)
 
 
-def mdadm_remove(devpath):
-    assert_valid_devpath(devpath)
-
-    LOG.info("mdadm removing: %s" % devpath)
-    out, err = util.subp(["mdadm", "--remove", devpath],
-                         rcs=[0], capture=True)
-    LOG.debug("mdadm remove:\n%s\n%s", out, err)
-
-
 def fail_device(mddev, arraydev):
     assert_valid_devpath(mddev)
 
@@ -559,14 +545,6 @@ def md_check_array_state_rw(md_devname):
     return __md_check_array_state(md_devname, mode='READWRITE')
 
 
-def md_check_array_state_ro(md_devname):
-    return __md_check_array_state(md_devname, mode='READONLY')
-
-
-def md_check_array_state_error(md_devname):
-    return __md_check_array_state(md_devname, mode='ERROR')
-
-
 def __mdadm_export_to_dict(output):
     ''' convert Key=Value text output into dictionary '''
     return dict(tok.split('=', 1) for tok in shlex.split(output))
@@ -633,81 +611,6 @@ def __mdadm_detail_to_dict(input):
     return data
 
 
-def md_device_key_role(devname):
-    if not devname:
-        raise ValueError('Missing parameter devname')
-    return 'MD_DEVICE_' + dev_short(devname) + '_ROLE'
-
-
-def md_device_key_dev(devname):
-    if not devname:
-        raise ValueError('Missing parameter devname')
-    return 'MD_DEVICE_' + dev_short(devname) + '_DEV'
-
-
-def __upgrade_detail_dict(detail):
-    ''' This method attempts to convert mdadm --detail output into
-        a KEY=VALUE output the same as mdadm --detail --export from mdadm v3.3
-    '''
-    # if the input already has MD_UUID, it's already been converted
-    if 'MD_UUID' in detail:
-        return detail
-
-    md_detail = {
-        'MD_LEVEL': detail['raid_level'],
-        'MD_DEVICES': detail['raid_devices'],
-        'MD_METADATA': detail['version'],
-        'MD_NAME': detail['name'].split()[0],
-    }
-
-    # exmaine has ARRAY UUID
-    if 'array_uuid' in detail:
-        md_detail.update({'MD_UUID': detail['array_uuid']})
-    # query,detail has UUID
-    elif 'uuid' in detail:
-        md_detail.update({'MD_UUID': detail['uuid']})
-
-    device = detail['device']
-
-    #  MD_DEVICE_vdc1_DEV=/dev/vdc1
-    md_detail.update({md_device_key_dev(device): device})
-
-    if 'device_role' in detail:
-        role = detail['device_role']
-        if role != 'spare':
-            # device_role = Active device 1
-            role = role.split()[-1]
-
-        # MD_DEVICE_vdc1_ROLE=spare
-        md_detail.update({md_device_key_role(device): role})
-
-    return md_detail
-
-
-def md_read_run_mdadm_map():
-    '''
-        md1 1.2 59beb40f:4c202f67:088e702b:efdf577a /dev/md1
-        md0 0.90 077e6a9e:edf92012:e2a6e712:b193f786 /dev/md0
-
-        return
-        # md_shortname = (metaversion, md_uuid, md_devpath)
-        data = {
-            'md1': (1.2, 59beb40f:4c202f67:088e702b:efdf577a, /dev/md1)
-            'md0': (0.90, 077e6a9e:edf92012:e2a6e712:b193f786, /dev/md0)
-    '''
-
-    mdadm_map = {}
-    run_mdadm_map = '/run/mdadm/map'
-    if os.path.exists(run_mdadm_map):
-        with open(run_mdadm_map, 'r') as fp:
-            data = fp.read().strip()
-        for entry in data.split('\n'):
-            (key, meta, md_uuid, dev) = entry.split()
-            mdadm_map.update({key: (meta, md_uuid, dev)})
-
-    return mdadm_map
-
-
 def md_check_array_uuid(md_devname, md_uuid):
     valid_mdname(md_devname)
 
@@ -750,22 +653,6 @@ def md_check_raidlevel(raidlevel):
     return True
 
 
-def md_block_until_in_sync(md_devname):
-    '''
-    sync_completed
-    This shows the number of sectors that have been completed of
-    whatever the current sync_action is, followed by the number of
-    sectors in total that could need to be processed.  The two
-    numbers are separated by a '/'  thus effectively showing one
-    value, a fraction of the process that is complete.
-    A 'select' on this attribute will return when resync completes,
-    when it reaches the current sync_max (below) and possibly at
-    other times.
-    '''
-    # FIXME: use selectors to block on: /sys/class/block/mdX/md/sync_completed
-    pass
-
-
 def md_check_array_state(md_devname):
     # check array state
 
diff --git a/curtin/block/multipath.py b/curtin/block/multipath.py
index 7ad1791..8010f29 100644
--- a/curtin/block/multipath.py
+++ b/curtin/block/multipath.py
@@ -88,15 +88,6 @@ def is_mpath_partition(devpath, info=None):
     return result
 
 
-def mpath_partition_to_mpath_id(devpath):
-    """ Return the mpath id of a multipath partition. """
-    info = udev.udevadm_info(devpath)
-    if 'DM_MPATH' in info:
-        return info['DM_MPATH']
-
-    return None
-
-
 def remove_partition(devpath, retries=10):
     """ Remove a multipath partition mapping. """
     LOG.debug('multipath: removing multipath partition: %s', devpath)
@@ -109,36 +100,6 @@ def remove_partition(devpath, retries=10):
     util.wait_for_removal(devpath)
 
 
-def remove_map(map_id, retries=10):
-    """ Remove a multipath device mapping. """
-    LOG.debug('multipath: removing multipath map: %s', map_id)
-    devpath = '/dev/mapper/%s' % map_id
-    for _ in range(0, retries):
-        util.subp(['multipath', '-v3', '-R3', '-f', map_id], rcs=[0, 1])
-        udev.udevadm_settle()
-        if not os.path.exists(devpath):
-            return
-
-    util.wait_for_removal(devpath)
-
-
-def find_mpath_members(multipath_id, paths=None):
-    """ Return a list of device path for each member of aspecified mpath_id."""
-    if not paths:
-        paths = show_paths()
-        for retry in range(0, 5):
-            orphans = [path for path in paths if 'orphan' in path['multipath']]
-            if len(orphans):
-                udev.udevadm_settle()
-                paths = show_paths()
-            else:
-                break
-
-    members = ['/dev/' + path['device']
-               for path in paths if path['multipath'] == multipath_id]
-    return members
-
-
 def find_mpath_id(devpath, maps=None):
     """ Return the mpath_id associated with a specified device path. """
     if not maps:
@@ -170,17 +131,6 @@ def find_mpath_id_by_path(devpath, paths=None):
     return None
 
 
-def find_mpath_id_by_parent(multipath_id, partnum=None):
-    """ Return the mpath_id associated with a specified device path. """
-    devmap = dmname_to_blkdev_mapping()
-    LOG.debug('multipath: dm_name blk map: %s', devmap)
-    dm_name = multipath_id
-    if partnum:
-        dm_name += "-part%d" % int(partnum)
-
-    return (dm_name, devmap.get(dm_name))
-
-
 def find_mpath_partitions(mpath_id):
     """
     Return a generator of multipath ids which are partitions of 'mpath-id'
diff --git a/curtin/commands/curthooks.py b/curtin/commands/curthooks.py
index 4cf7301..46af022 100644
--- a/curtin/commands/curthooks.py
+++ b/curtin/commands/curthooks.py
@@ -905,16 +905,6 @@ def copy_iscsi_conf(nodes_dir, target, target_nodes_dir='etc/iscsi/nodes'):
             shutil.copytree(source_dir, target_dir)
 
 
-def copy_mdadm_conf(mdadm_conf, target):
-    if not mdadm_conf:
-        LOG.warn("mdadm config must be specified, not copying")
-        return
-
-    LOG.info("copying mdadm.conf into target")
-    shutil.copy(mdadm_conf, os.path.sep.join([target,
-                'etc/mdadm/mdadm.conf']))
-
-
 def copy_zpool_cache(zpool_cache, target):
     if not zpool_cache:
         LOG.warn("zpool_cache path must be specified, not copying")
diff --git a/curtin/net/__init__.py b/curtin/net/__init__.py
index 3b02f9d..2b56f17 100644
--- a/curtin/net/__init__.py
+++ b/curtin/net/__init__.py
@@ -94,10 +94,6 @@ def is_physical(devname):
     return os.path.exists(sys_dev_path(devname, "device"))
 
 
-def is_present(devname):
-    return os.path.exists(sys_dev_path(devname))
-
-
 def get_devicelist():
     return os.listdir(SYS_CLASS_NET)
 
diff --git a/tests/unittests/test_block.py b/tests/unittests/test_block.py
index 78e331d..985700f 100644
--- a/tests/unittests/test_block.py
+++ b/tests/unittests/test_block.py
@@ -29,22 +29,6 @@ class TestBlock(CiTestCase):
         mock_util.subp.assert_called_with(expected_call, capture=True)
         self.assertEqual(uuid, "182e8e23-5322-46c9-a1b8-cf2c6a88f9f7")
 
-    @mock.patch("curtin.block.get_proc_mounts")
-    @mock.patch("curtin.block._lsblock")
-    def test_get_mountpoints(self, mock_lsblk, mock_proc_mounts):
-        mock_lsblk.return_value = {"sda1": {"MOUNTPOINT": None},
-                                   "sda2": {"MOUNTPOINT": ""},
-                                   "sda3": {"MOUNTPOINT": "/mnt"}}
-        mock_proc_mounts.return_value = [
-            ('sysfs', '/sys', 'sysfs', 'sysfs_opts', '0', '0'),
-        ]
-
-        mountpoints = block.get_mountpoints()
-
-        self.assertTrue(mock_lsblk.called)
-        self.assertEqual(sorted(mountpoints),
-                         sorted(["/mnt", "/sys"]))
-
     @mock.patch('curtin.block._lsblock')
     def test_get_blockdev_sector_size(self, mock_lsblk):
         mock_lsblk.return_value = {
diff --git a/tests/unittests/test_block_bcache.py b/tests/unittests/test_block_bcache.py
index 7936522..ecb8046 100644
--- a/tests/unittests/test_block_bcache.py
+++ b/tests/unittests/test_block_bcache.py
@@ -271,19 +271,6 @@ class TestBlockBcache(CiTestCase):
         self.assertEqual([bdev_target], results)
         m_listdir.assert_called_with(cset_path)
 
-    @mock.patch('curtin.block.bcache.os.path.exists')
-    @mock.patch('curtin.block.bcache.os.path.realpath')
-    def test_get_cacheset_cachedev(self, m_real, m_exists):
-        """ get_cacheset_cachedev finds cacheset device path."""
-        cset_uuid = self.random_string()
-        cachedev_target = self.random_string()
-        cset_path = '/sys/fs/bcache/%s/cache0' % cset_uuid
-        m_exists.return_value = True
-        m_real.side_effect = iter([cachedev_target])
-        results = bcache.get_cacheset_cachedev(cset_uuid)
-        self.assertEqual(cachedev_target, results)
-        m_real.assert_called_with(cset_path)
-
     @mock.patch('curtin.block.bcache.is_backing')
     @mock.patch('curtin.block.bcache.sysfs_path')
     @mock.patch('curtin.block.bcache.os.listdir')
diff --git a/tests/unittests/test_block_iscsi.py b/tests/unittests/test_block_iscsi.py
index f8ef5d8..309c28e 100644
--- a/tests/unittests/test_block_iscsi.py
+++ b/tests/unittests/test_block_iscsi.py
@@ -1,10 +1,8 @@
 # This file is part of curtin. See LICENSE file for copyright and license info.
 
 import mock
-import os
 
 from curtin.block import iscsi
-from curtin import util
 from .helpers import CiTestCase
 
 
@@ -647,104 +645,4 @@ class TestBlockIscsiDiskFromConfig(CiTestCase):
         self.assertEqual(expected_iscsi_disks, iscsi_disks)
 
 
-class TestBlockIscsiDisconnect(CiTestCase):
-    # test that when disconnecting iscsi targets we
-    # check that the target has an active session before
-    # issuing a disconnect command
-
-    def setUp(self):
-        super(TestBlockIscsiDisconnect, self).setUp()
-        self.add_patch('curtin.block.iscsi.util.subp', 'mock_subp')
-        self.add_patch('curtin.block.iscsi.iscsiadm_sessions',
-                       'mock_iscsi_sessions')
-        # fake target_root + iscsi nodes dir
-        self.target_path = self.tmp_dir()
-        self.iscsi_nodes = os.path.join(self.target_path, 'etc/iscsi/nodes')
-        util.ensure_dir(self.iscsi_nodes)
-
-    def _fmt_disconnect(self, target, portal):
-        return ['iscsiadm', '--mode=node', '--targetname=%s' % target,
-                '--portal=%s' % portal, '--logout']
-
-    def _setup_nodes(self, sessions, connection):
-        # setup iscsi_nodes dir (<fakeroot>/etc/iscsi/nodes) with content
-        for s in sessions:
-            sdir = os.path.join(self.iscsi_nodes, s)
-            connpath = os.path.join(sdir, connection)
-            util.ensure_dir(sdir)
-            util.write_file(connpath, content="")
-
-    def test_disconnect_target_disk(self):
-        """Test iscsi disconnecting multiple sessions, all present"""
-
-        sessions = [
-            'curtin-53ab23ff-a887-449a-80a8-288151208091',
-            'curtin-94b62de1-c579-42c0-879e-8a28178e64c5',
-            'curtin-556aeecd-a227-41b7-83d7-2bb471c574b4',
-            'curtin-fd0f644b-7858-420f-9997-3ea2aefe87b9'
-        ]
-        connection = '10.245.168.20,16395,1'
-        self._setup_nodes(sessions, connection)
-
-        self.mock_iscsi_sessions.return_value = "\n".join(sessions)
-
-        iscsi.disconnect_target_disks(self.target_path)
-
-        expected_calls = []
-        for session in sessions:
-            (host, port, _) = connection.split(',')
-            disconnect = self._fmt_disconnect(session, "%s:%s" % (host, port))
-            calls = [
-                mock.call(['sync']),
-                mock.call(disconnect, capture=True, log_captured=True),
-                mock.call(['udevadm', 'settle']),
-            ]
-            expected_calls.extend(calls)
-
-        self.mock_subp.assert_has_calls(expected_calls, any_order=True)
-
-    def test_disconnect_target_disk_skip_disconnected(self):
-        """Test iscsi does not attempt to disconnect already closed sessions"""
-        sessions = [
-            'curtin-53ab23ff-a887-449a-80a8-288151208091',
-            'curtin-94b62de1-c579-42c0-879e-8a28178e64c5',
-            'curtin-556aeecd-a227-41b7-83d7-2bb471c574b4',
-            'curtin-fd0f644b-7858-420f-9997-3ea2aefe87b9'
-        ]
-        connection = '10.245.168.20,16395,1'
-        self._setup_nodes(sessions, connection)
-        # Test with all sessions are already disconnected
-        self.mock_iscsi_sessions.return_value = ""
-
-        iscsi.disconnect_target_disks(self.target_path)
-
-        self.mock_subp.assert_has_calls([], any_order=True)
-
-    @mock.patch('curtin.block.iscsi.iscsiadm_logout')
-    def test_disconnect_target_disk_raises_runtime_error(self, mock_logout):
-        """Test iscsi raises RuntimeError if we fail to logout"""
-        sessions = [
-            'curtin-53ab23ff-a887-449a-80a8-288151208091',
-        ]
-        connection = '10.245.168.20,16395,1'
-        self._setup_nodes(sessions, connection)
-        self.mock_iscsi_sessions.return_value = "\n".join(sessions)
-        mock_logout.side_effect = util.ProcessExecutionError()
-
-        with self.assertRaises(RuntimeError):
-            iscsi.disconnect_target_disks(self.target_path)
-
-        expected_calls = []
-        for session in sessions:
-            (host, port, _) = connection.split(',')
-            disconnect = self._fmt_disconnect(session, "%s:%s" % (host, port))
-            calls = [
-                mock.call(['sync']),
-                mock.call(disconnect, capture=True, log_captured=True),
-                mock.call(['udevadm', 'settle']),
-            ]
-            expected_calls.extend(calls)
-
-        self.mock_subp.assert_has_calls([], any_order=True)
-
 # vi: ts=4 expandtab syntax=python
diff --git a/tests/unittests/test_block_mdadm.py b/tests/unittests/test_block_mdadm.py
index b04cf82..a6654ce 100644
--- a/tests/unittests/test_block_mdadm.py
+++ b/tests/unittests/test_block_mdadm.py
@@ -594,33 +594,6 @@ class TestBlockMdadmStop(CiTestCase):
         self.mock_util_write_file.assert_has_calls(expected_writes)
 
 
-class TestBlockMdadmRemove(CiTestCase):
-    def setUp(self):
-        super(TestBlockMdadmRemove, self).setUp()
-        self.add_patch('curtin.block.mdadm.util', 'mock_util')
-        self.add_patch('curtin.block.mdadm.lsb_release', 'mock_lsb_release')
-        self.add_patch('curtin.block.mdadm.is_valid_device', 'mock_valid')
-
-        # Common mock settings
-        self.mock_valid.return_value = True
-        self.mock_lsb_release.return_value = {'codename': 'xenial'}
-        self.mock_util.subp.side_effect = [
-            ("", ""),  # mdadm remove device
-        ]
-
-    def test_mdadm_remove_no_devpath(self):
-        with self.assertRaises(ValueError):
-            mdadm.mdadm_remove(None)
-
-    def test_mdadm_remove(self):
-        device = "/dev/vdc"
-        mdadm.mdadm_remove(device)
-        expected_calls = [
-            call(["mdadm", "--remove", device], rcs=[0], capture=True),
-        ]
-        self.mock_util.subp.assert_has_calls(expected_calls)
-
-
 class TestBlockMdadmQueryDetail(CiTestCase):
     def setUp(self):
         super(TestBlockMdadmQueryDetail, self).setUp()
@@ -716,7 +689,7 @@ class TestBlockMdadmDetailScan(CiTestCase):
             (self.scan_output, ""),  # mdadm --detail --scan
         ]
 
-    def test_mdadm_remove(self):
+    def test_mdadm_detail_scan(self):
         data = mdadm.mdadm_detail_scan()
         expected_calls = [
             call(["mdadm", "--detail", "--scan"], capture=True),
@@ -724,7 +697,7 @@ class TestBlockMdadmDetailScan(CiTestCase):
         self.mock_util.subp.assert_has_calls(expected_calls)
         self.assertEqual(self.scan_output, data)
 
-    def test_mdadm_remove_error(self):
+    def test_mdadm_detail_scan_error(self):
         self.mock_util.subp.side_effect = [
             ("wark", "error"),  # mdadm --detail --scan
         ]
@@ -825,50 +798,6 @@ class TestBlockMdadmMdHelpers(CiTestCase):
         mock_attr.return_value = 'inactive'
         self.assertFalse(mdadm.md_check_array_state_rw(mdname))
 
-    @patch('curtin.block.mdadm.md_sysfs_attr')
-    def test_md_check_array_state_ro(self, mock_attr):
-        mdname = '/dev/md0'
-        mock_attr.return_value = 'readonly'
-        self.assertTrue(mdadm.md_check_array_state_ro(mdname))
-
-    @patch('curtin.block.mdadm.md_sysfs_attr')
-    def test_md_check_array_state_ro_false(self, mock_attr):
-        mdname = '/dev/md0'
-        mock_attr.return_value = 'inactive'
-        self.assertFalse(mdadm.md_check_array_state_ro(mdname))
-
-    @patch('curtin.block.mdadm.md_sysfs_attr')
-    def test_md_check_array_state_error(self, mock_attr):
-        mdname = '/dev/md0'
-        mock_attr.return_value = 'inactive'
-        self.assertTrue(mdadm.md_check_array_state_error(mdname))
-
-    @patch('curtin.block.mdadm.md_sysfs_attr')
-    def test_md_check_array_state_error_false(self, mock_attr):
-        mdname = '/dev/md0'
-        mock_attr.return_value = 'active'
-        self.assertFalse(mdadm.md_check_array_state_error(mdname))
-
-    def test_md_device_key_role(self):
-        devname = '/dev/vda'
-        rolekey = mdadm.md_device_key_role(devname)
-        self.assertEqual('MD_DEVICE_vda_ROLE', rolekey)
-
-    def test_md_device_key_role_no_dev(self):
-        devname = None
-        with self.assertRaises(ValueError):
-            mdadm.md_device_key_role(devname)
-
-    def test_md_device_key_dev(self):
-        devname = '/dev/vda'
-        devkey = mdadm.md_device_key_dev(devname)
-        self.assertEqual('MD_DEVICE_vda_DEV', devkey)
-
-    def test_md_device_key_dev_no_dev(self):
-        devname = None
-        with self.assertRaises(ValueError):
-            mdadm.md_device_key_dev(devname)
-
     @patch('curtin.block.util.load_file')
     @patch('curtin.block.get_blockdev_for_partition')
     @patch('curtin.block.mdadm.os.path.exists')
diff --git a/tests/unittests/test_block_multipath.py b/tests/unittests/test_block_multipath.py
index 96cbcba..a729936 100644
--- a/tests/unittests/test_block_multipath.py
+++ b/tests/unittests/test_block_multipath.py
@@ -82,20 +82,6 @@ class TestMultipath(CiTestCase):
         """is_mpath_member returns false if DM_PART is not present for dev."""
         self.assertFalse(multipath.is_mpath_partition(self.random_string()))
 
-    def test_mpath_partition_to_mpath_id(self):
-        """mpath_part_to_mpath_id extracts MD_MPATH value from mp partition."""
-        dev = self.random_string()
-        mpath_id = self.random_string()
-        self.m_udev.udevadm_info.return_value = {'DM_MPATH': mpath_id}
-        self.assertEqual(mpath_id,
-                         multipath.mpath_partition_to_mpath_id(dev))
-
-    def test_mpath_partition_to_mpath_id_none(self):
-        """mpath_part_to_mpath_id returns none if DM_MPATH missing."""
-        dev = self.random_string()
-        self.m_udev.udevadm_info.return_value = {}
-        self.assertIsNone(multipath.mpath_partition_to_mpath_id(dev))
-
     @mock.patch('curtin.block.multipath.os.path.exists')
     @mock.patch('curtin.block.multipath.util.wait_for_removal')
     def test_remove_partition(self, m_wait, m_exists):
@@ -122,52 +108,6 @@ class TestMultipath(CiTestCase):
         self.assertEqual(3, self.m_udev.udevadm_settle.call_count)
         self.assertEqual(1, m_wait.call_count)
 
-    @mock.patch('curtin.block.multipath.os.path.exists')
-    @mock.patch('curtin.block.multipath.util.wait_for_removal')
-    def test_remove_map(self, m_wait, m_exists):
-        """multipath.remove_map runs multipath -f skips wait if map gone."""
-        map_id = self.random_string()
-        devpath = '/dev/mapper/%s' % map_id
-        m_exists.side_effect = iter([True, True, False])
-        multipath.remove_map(devpath)
-        expected = mock.call(
-            ['multipath', '-v3', '-R3', '-f', devpath], rcs=[0, 1])
-        self.m_subp.assert_has_calls([expected] * 3)
-        m_wait.assert_not_called()
-        self.assertEqual(3, self.m_udev.udevadm_settle.call_count)
-
-    @mock.patch('curtin.block.multipath.os.path.exists')
-    @mock.patch('curtin.block.multipath.util.wait_for_removal')
-    def test_remove_map_wait(self, m_wait, m_exists):
-        """multipath.remove_map runs multipath -f  wait if map remains."""
-        map_id = self.random_string()
-        devpath = '/dev/mapper/%s' % map_id
-        m_exists.side_effect = iter([True, True, True])
-        multipath.remove_map(devpath, retries=3)
-        expected = mock.call(
-            ['multipath', '-v3', '-R3', '-f', devpath], rcs=[0, 1])
-        self.m_subp.assert_has_calls([expected] * 3)
-        self.assertEqual(3, self.m_udev.udevadm_settle.call_count)
-        self.assertEqual(1, m_wait.call_count)
-
-    def test_find_mpath_members(self):
-        """find_mpath_members enumerates kernel block devs of a mpath_id."""
-        mp_id = 'mpatha'
-        paths = ['device=bar multipath=mpatha',
-                 'device=wark multipath=mpatha']
-        self.m_subp.return_value = ("\n".join(paths), "")
-        self.assertEqual(sorted(['/dev/bar', '/dev/wark']),
-                         sorted(multipath.find_mpath_members(mp_id)))
-
-    def test_find_mpath_members_empty(self):
-        """find_mpath_members returns empty list if mpath_id not found."""
-        mp_id = self.random_string()
-        paths = ['device=bar multipath=mpatha',
-                 'device=wark multipath=mpatha']
-        self.m_subp.return_value = ("\n".join(paths), "")
-
-        self.assertEqual([], multipath.find_mpath_members(mp_id))
-
     def test_find_mpath_id(self):
         """find_mpath_id returns mpath_id if device is part of mpath group."""
         mp_id = 'mpatha'
@@ -209,18 +149,6 @@ class TestMultipath(CiTestCase):
         self.assertEqual(expected_mapping,
                          multipath.dmname_to_blkdev_mapping())
 
-    @mock.patch('curtin.block.multipath.dmname_to_blkdev_mapping')
-    def test_find_mpath_id_by_parent(self, m_dmmap):
-        """find_mpath_id_by_parent returns device mapper blk for given DM_NAME.
-        """
-        m_dmmap.return_value = {
-            'mpatha': '/dev/dm-0', 'mpatha-part1': '/dev/dm-1'}
-        mpath_id = 'mpatha'
-        expected_result = ('mpatha-part1', '/dev/dm-1')
-        self.assertEqual(
-            expected_result,
-            multipath.find_mpath_id_by_parent(mpath_id, partnum=1))
-
     def test_find_mpath_id_by_path(self):
         """find_mpath_id_by_path returns the mp_id if specified device is
            member.