def test_find_raid_partition(self):
""" verify probed raid partitions are found. """
self.probe_data = _get_data('probert_storage_raid1_partitions.json')
extracted = storage_config.extract_storage_config(self.probe_data)
config = extracted['storage']['config']
raids = [cfg for cfg in config if cfg['type'] == 'raid']
raid_partitions = [
cfg for cfg in config
if cfg['type'] == 'partition' and cfg['id'].startswith('raid')
]
self.assertEqual(1, len(raids))
self.assertEqual(1, len(raid_partitions))
self.assertEqual(
{
'id': 'raid-md1',
'type': 'raid',
'raidlevel': 'raid1',
'name': 'md1',
'devices': ['partition-vdb1', 'partition-vdc1'],
'spare_devices': []
}, raids[0])
self.assertEqual(
{
'id': 'raid-md1p1',
'type': 'partition',
'size': 4285530112,
'flag': 'linux',
'number': 1,
'device': 'raid-md1',
'offset': 1048576
}, raid_partitions[0])
def test_probe_handles_missing_keys(self):
""" verify extract handles missing probe_data keys """
for missing_key in self.probe_data.keys():
probe_data = copy.deepcopy(self.probe_data)
del probe_data[missing_key]
extracted = storage_config.extract_storage_config(probe_data)
if missing_key != 'blockdev':
self.assertEqual(
{
'storage': {
'version':
1,
'config': [{
'id': 'disk-sda',
'path': '/dev/sda',
'serial': 'QEMU_HARDDISK_QM00001',
'type': 'disk'
}]
}
}, extracted)
else:
# empty config without blockdev data
self.assertEqual({'storage': {
'config': [],
'version': 1
}}, extracted)
def reset(self):
if self._probe_data is not None:
config = storage_config.extract_storage_config(self._probe_data)
self._actions = self._actions_from_config(
config["storage"]["config"], self._probe_data['blockdev'])
else:
self._actions = []
self.grub_install_device = None
def test_find_extended_partition(self):
""" finds extended partition and set flag in config """
self.probe_data = _get_data('probert_storage_msdos_mbr_extended.json')
extracted = storage_config.extract_storage_config(self.probe_data)
config = extracted['storage']['config']
partitions = [cfg for cfg in config if cfg['type'] == 'partition']
extended = [part for part in partitions if part['flag'] == 'extended']
self.assertEqual(1, len(extended))
def discover():
probe_data = _discover_get_probert_data()
if 'storage' not in probe_data:
raise ValueError('Probing storage failed')
LOG.debug('Extracting storage config from discovered devices')
try:
return storage_config.extract_storage_config(probe_data.get('storage'))
except ImportError as e:
LOG.exception(e)
return {}
def reset(self):
self._all_ids = set()
if self._probe_data is not None:
self._orig_config = storage_config.extract_storage_config(
self._probe_data)["storage"]["config"]
self._actions = self._actions_from_config(
self._orig_config,
self._probe_data['blockdev'],
is_probe_data=True)
else:
self._orig_config = []
self._actions = []
self.swap = None
self.grub = None
def test_find_all_multipath(self):
""" verify probed multipath paths are included in config. """
self.probe_data = _get_data('probert_storage_multipath.json')
extracted = storage_config.extract_storage_config(self.probe_data)
config = extracted['storage']['config']
blockdev = self.probe_data['blockdev']
for mpmap in self.probe_data['multipath']['maps']:
nr_disks = int(mpmap['paths'])
mp_name = blockdev['/dev/%s' % mpmap['sysfs']]['DM_NAME']
matched_disks = [
cfg for cfg in config if cfg['type'] == 'disk'
and cfg.get('multipath', '') == mp_name
]
self.assertEqual(nr_disks, len(matched_disks))
def test_blockdev_detects_nvme_multipath_devices(self):
self.probe_data = _get_data('probert_storage_nvme_multipath.json')
extracted = storage_config.extract_storage_config(self.probe_data)
config = extracted['storage']['config']
disks = [cfg for cfg in config if cfg['type'] == 'disk']
expected_dict = {
'id': 'disk-nvme0n1',
'path': '/dev/nvme0n1',
'ptable': 'gpt',
'serial': 'SAMSUNG MZPLL3T2HAJQ-00005_S4CCNE0M300015',
'type': 'disk',
'wwn': 'eui.344343304d3000150025384500000004',
}
self.assertEqual(1, len(disks))
self.assertEqual(expected_dict, disks[0])
def test_live_iso(self):
""" verify live-iso extracted storage-config finds target disk. """
extracted = storage_config.extract_storage_config(self.probe_data)
self.assertEqual(
{
'storage': {
'version':
1,
'config': [{
'id': 'disk-sda',
'path': '/dev/sda',
'serial': 'QEMU_HARDDISK_QM00001',
'type': 'disk'
}]
}
}, extracted)
def test_blockdev_skips_invalid_wwn(self):
self.probe_data = _get_data('probert_storage_bogus_wwn.json')
extracted = storage_config.extract_storage_config(self.probe_data)
config = extracted['storage']['config']
disks = [
cfg for cfg in config
if cfg['type'] == 'disk' and cfg['path'] == '/dev/sda'
]
expected_dict = {
'id': 'disk-sda',
'path': '/dev/sda',
'ptable': 'gpt',
'serial': 'Corsair_Force_GS_13207907000097410026',
'type': 'disk',
}
self.assertEqual(1, len(disks))
self.assertEqual(expected_dict, disks[0])
def discover():
try:
LOG.debug('Importing probert prober')
from probert import prober
except Exception:
LOG.error('Failed to import probert, discover disabled')
return {}
probe = prober.Prober()
LOG.debug('Probing system for storage devices')
probe.probe_storage()
probe_data = probe.get_results()
if 'storage' not in probe_data:
raise ValueError('Probing storage failed')
LOG.debug('Extracting storage config from discovered devices')
try:
return storage_config.extract_storage_config(probe_data.get('storage'))
except ImportError as e:
LOG.exception(e)
return {}
