def test_shutdown_bcache_stop_sysfs_write_fails(
self, mock_get_bcache, mock_log, mock_os, mock_util,
mock_get_bcache_block, mock_udevadm_settle, mock_wipe, mock_block):
"""Test writes sysfs write failures pass if file not present"""
mock_block.sysfs_to_devpath.return_value = self.test_blockdev
mock_os.path.exists.side_effect = iter([
True, # backing device exists
True, # cset device not present (already removed)
False, # backing device is removed with cset
False, # bcache/stop sysfs is missing (already removed)
])
cset = '/sys/fs/bcache/fake'
mock_get_bcache.return_value = cset
mock_get_bcache_block.return_value = self.test_syspath + '/bcache'
mock_os.path.join.side_effect = os.path.join
# make writes to sysfs fail
mock_util.write_file.side_effect = IOError(errno.ENOENT,
"File not found")
clear_holders.shutdown_bcache(self.test_syspath)
self.assertEqual(4, len(mock_log.info.call_args_list))
self.assertEqual(3, len(mock_os.path.exists.call_args_list))
self.assertEqual(1, len(mock_get_bcache.call_args_list))
self.assertEqual(1, len(mock_get_bcache_block.call_args_list))
self.assertEqual(1, len(mock_util.write_file.call_args_list))
self.assertEqual(1, len(mock_util.wait_for_removal.call_args_list))
mock_get_bcache.assert_called_with(self.test_syspath, strict=False)
mock_util.write_file.assert_has_calls([
mock.call(cset + '/stop', '1', mode=None),
])
mock_util.wait_for_removal.assert_has_calls(
[mock.call(cset, retries=self.remove_retries)])
def test_shutdown_bcache_delete_cset_no_backing(
self, mock_get_bcache, mock_log, mock_os, mock_util,
mock_get_bcache_block, mock_udevadm_settle, mock_block):
mock_block.sysfs_to_devpath.return_value = self.test_blockdev
mock_os.path.exists.side_effect = iter([
True, # backing device exists
True, # cset device not present (already removed)
False, # backing device is removed with cset
])
cset = '/sys/fs/bcache/fake'
mock_get_bcache.return_value = cset
mock_get_bcache_block.return_value = self.test_syspath + '/bcache'
mock_os.path.join.side_effect = os.path.join
clear_holders.shutdown_bcache(self.test_syspath)
self.assertEqual(4, len(mock_log.info.call_args_list))
self.assertEqual(3, len(mock_os.path.exists.call_args_list))
self.assertEqual(1, len(mock_get_bcache.call_args_list))
self.assertEqual(1, len(mock_get_bcache_block.call_args_list))
self.assertEqual(1, len(mock_util.write_file.call_args_list))
self.assertEqual(1, len(mock_util.wait_for_removal.call_args_list))
mock_get_bcache.assert_called_with(self.test_syspath, strict=False)
mock_util.write_file.assert_has_calls([
mock.call(cset + '/stop', '1', mode=None),
])
mock_util.wait_for_removal.assert_has_calls(
[mock.call(cset, retries=self.remove_retries)])
def test_shutdown_bcache_non_sysfs_device(self, mock_get_bcache, mock_log,
mock_os, mock_util,
mock_get_bcache_block):
with self.assertRaises(ValueError):
clear_holders.shutdown_bcache(self.test_blockdev)
self.assertEqual(0, len(mock_get_bcache.call_args_list))
self.assertEqual(0, len(mock_log.call_args_list))
self.assertEqual(0, len(mock_os.call_args_list))
self.assertEqual(0, len(mock_util.call_args_list))
self.assertEqual(0, len(mock_get_bcache_block.call_args_list))
def test_shutdown_bcache_no_device(self, mock_get_bcache, mock_log,
mock_os, mock_util,
mock_get_bcache_block, mock_block):
mock_block.sysfs_to_devpath.return_value = self.test_blockdev
mock_os.path.exists.return_value = False
clear_holders.shutdown_bcache(self.test_syspath)
self.assertEqual(3, len(mock_log.info.call_args_list))
self.assertEqual(1, len(mock_os.path.exists.call_args_list))
self.assertEqual(0, len(mock_get_bcache.call_args_list))
self.assertEqual(0, len(mock_util.call_args_list))
self.assertEqual(0, len(mock_get_bcache_block.call_args_list))
def test_shutdown_bcache(self, m_bcache, m_block, m_udev, m_util, m_os):
"""test clear_holders.shutdown_bcache"""
device = self.test_syspath
backing_dev = 'backing1'
backing_sys = '/sys/class/block/%s' % backing_dev
m_block.sysfs_to_devpath.return_value = self.test_blockdev
cset_uuid = str(uuid.uuid4())
def my_sysblock(p, strict=False):
return '/sys/class/block/%s' % os.path.basename(p)
def my_bsys(p, strict=False):
return my_sysblock(p, strict=strict) + '/bcache'
m_bcache.sysfs_path.side_effect = my_bsys
m_os.path.join.side_effect = os.path.join
m_os.listdir.return_value = [backing_dev]
m_os.path.exists.return_value = True
m_bcache.get_attached_cacheset.return_value = cset_uuid
m_block.path_to_kname.return_value = self.test_blockdev
m_bcache.get_backing_device.return_value = backing_sys + '/bcache'
m_bcache.get_cacheset_members.return_value = []
clear_holders.shutdown_bcache(device)
# 1. wipe the bcache device contents
m_block.wipe_volume.assert_called_with(self.test_blockdev,
mode='superblock',
exclusive=False,
strict=True)
# 2. extract the backing device
m_bcache.get_backing_device.assert_called_with(self.test_blockdev)
m_bcache.sysfs_path.assert_has_calls([
mock.call(self.test_syspath, strict=False),
])
# 3. extract the cacheset uuid
m_bcache.get_attached_cacheset.assert_called_with(device)
# 4. stop the cacheset
m_bcache.stop_cacheset.assert_called_with(cset_uuid)
# 5. stop the bcacheN device
m_bcache.stop_device.assert_any_call(my_bsys(device))
def test_shutdown_bcache(self, mock_get_bcache, mock_log, mock_os,
mock_util, mock_get_bcache_block,
mock_udevadm_settle, mock_block):
"""test clear_holders.shutdown_bcache"""
#
# pass in a sysfs path to a bcache block device,
# determine the bcache cset it is part of (or not)
# 1) stop the cset device (if it's enabled)
# 2) wait on cset to be removed if it was present
# 3) stop the block device (if it's still present after stopping cset)
# 4) wait on bcache block device to be removed
#
device = self.test_syspath
mock_block.sys_block_path.return_value = self.test_blockdev
bcache_cset_uuid = 'c08ae789-a964-46fb-a66e-650f0ae78f94'
mock_os.path.exists.return_value = True
mock_os.path.join.side_effect = os.path.join
# os.path.realpath on symlink of /sys/class/block/null/bcache/cache ->
# to /sys/fs/bcache/cset_UUID
mock_get_bcache.return_value = '/sys/fs/bcache/' + bcache_cset_uuid
mock_get_bcache_block.return_value = device + '/bcache'
clear_holders.shutdown_bcache(device)
mock_get_bcache.assert_called_with(device, strict=False)
mock_get_bcache_block.assert_called_with(device, strict=False)
self.assertTrue(mock_log.info.called)
self.assertFalse(mock_log.warn.called)
mock_util.wait_for_removal.assert_has_calls([
mock.call('/sys/fs/bcache/' + bcache_cset_uuid,
retries=self.remove_retries),
mock.call(device, retries=self.remove_retries)
])
mock_util.write_file.assert_has_calls([
mock.call('/sys/fs/bcache/%s/stop' % bcache_cset_uuid,
'1',
mode=None),
mock.call(device + '/bcache/stop', '1', mode=None)
])
def test_shutdown_bcache_no_device(self, m_block, m_os):
""" shutdown_bcache does nothing if target device is not present."""
m_os.path.exists.return_value = False
clear_holders.shutdown_bcache(self.test_syspath)
m_block.wipe_volume.assert_not_called()
def test_shutdown_bcache_non_sysfs_device(self):
""" raises ValueError if called on non-bcache device."""
with self.assertRaises(ValueError):
clear_holders.shutdown_bcache(self.test_blockdev)
