def test_match(self):
"""Test boot format populator helper match method"""
if self.helper_class is None:
return
partition = PartitionDevice("testpartitiondev")
storagedev = StorageDevice("teststoragedev")
storagedev.bootable = True
data = dict()
fmt_class = get_device_format_class(self.helper_class._type_specifier)
if fmt_class is None:
self.skipTest("failed to look up format class for %s" %
self.helper_class._type_specifier)
data["ID_FS_TYPE"] = self.helper_class._base_type_specifier
partition._bootable = self.helper_class._bootable
min_size = fmt_class._min_size
max_size = fmt_class._max_size
partition._size = min_size
storagedev._size = min_size
if fmt_class._name:
partition._parted_partition = FakePartedPart(
partition, fmt_class._name)
self.assertTrue(self.helper_class.match(data, partition))
# These are only valid for partitions.
self.assertFalse(self.helper_class.match(data, storagedev))
data["ID_FS_TYPE"] += "x"
self.assertFalse(self.helper_class.match(data, partition))
data["ID_FS_TYPE"] = self.helper_class._base_type_specifier
if self.helper_class._bootable:
partition._bootable = False
self.assertFalse(self.helper_class.match(data, partition))
partition._bootable = True
if max_size:
partition._size = max_size + 1
elif min_size:
partition._size = min_size - 1
self.assertFalse(self.helper_class.match(data, partition))
partition._size = min_size
# we don't always match on the parted partition name, so allow
# subclasses to decide
if not self.name_mismatch_ok:
orig = partition._parted_partition
partition._parted_partition = FakePartedPart(
partition, 'dontmatchanything')
self.assertFalse(self.helper_class.match(data, partition))
# shouldn't crash
partition._parted_partition = None
self.assertFalse(self.helper_class.match(data, partition))
partition._parted_partition = orig
def test_formats_methods(self):
##
# get_device_format_class
##
format_pairs = {
None: formats.DeviceFormat,
"bogus": None,
"biosboot": formats.biosboot.BIOSBoot,
"BIOS Boot": formats.biosboot.BIOSBoot,
"nodev": formats.fs.NoDevFS
}
format_names = format_pairs.keys()
format_values = [format_pairs[k] for k in format_names]
self.assertEqual(
[formats.get_device_format_class(x) for x in format_names],
format_values)
# A DeviceFormat object is returned if lookup by name fails
for name in format_names:
self.assertIs(formats.get_format(name).__class__,
formats.DeviceFormat if format_pairs[name] is None else format_pairs[name])
# Consecutively constructed DeviceFormat objects have consecutive ids
names = [key for key in format_pairs.keys() if format_pairs[key] is not None]
objs = [formats.get_format(name) for name in names]
ids = [obj.id for obj in objs]
self.assertEqual(ids, list(range(ids[0], ids[0] + len(ids))))
# Copy or deepcopy should preserve the id
self.assertEqual(ids, [copy.copy(obj).id for obj in objs])
self.assertEqual(ids, [copy.deepcopy(obj).id for obj in objs])
def testFormatsMethods(self):
##
## get_device_format_class
##
format_pairs = {
None: None,
"bogus": None,
"biosboot": formats.biosboot.BIOSBoot,
"BIOS Boot": formats.biosboot.BIOSBoot,
"nodev": formats.fs.NoDevFS
}
format_names = format_pairs.keys()
format_values = [format_pairs[k] for k in format_names]
self.assertEqual(
[formats.get_device_format_class(x) for x in format_names],
format_values)
## A DeviceFormat object is returned if lookup by name fails
for name in format_names:
self.assertIs(
formats.getFormat(name).__class__, formats.DeviceFormat
if format_pairs[name] is None else format_pairs[name])
## Consecutively constructed DeviceFormat objects have consecutive ids
names = [
key for key in format_pairs.keys() if format_pairs[key] is not None
]
objs = [formats.getFormat(name) for name in names]
ids = [obj.id for obj in objs]
self.assertEqual(ids, range(ids[0], ids[0] + len(ids)))
## Copy or deepcopy should preserve the id
self.assertEqual(ids, [copy.copy(obj).id for obj in objs])
self.assertEqual(ids, [copy.deepcopy(obj).id for obj in objs])
def update_from_flags(self):
if conf.storage.gpt:
disklabel_class = get_device_format_class("disklabel")
disklabel_types = disklabel_class.get_platform_label_types()
if "gpt" not in disklabel_types:
log.warning("GPT is not a supported disklabel on this platform. Using default "
"disklabel %s instead.", disklabel_types[0])
else:
disklabel_class.set_default_label_type("gpt")
def update_from_flags(self):
if flags.gpt:
disklabel_class = get_device_format_class("disklabel")
disklabel_types = disklabel_class.get_platform_label_types()
if "gpt" not in disklabel_types:
log.warning("GPT is not a supported disklabel on this platform. Using default "
"disklabel %s instead.", disklabel_types[0])
else:
disklabel_class.set_default_label_type("gpt")
def test_match(self):
"""Test boot format populator helper match method"""
if self.helper_class is None:
return
partition = PartitionDevice("testpartitiondev")
storagedev = StorageDevice("teststoragedev")
storagedev.bootable = True
data = dict()
fmt_class = get_device_format_class(self.helper_class._type_specifier)
if fmt_class is None:
self.skipTest("failed to look up format class for %s" % self.helper_class._type_specifier)
data["ID_FS_TYPE"] = self.helper_class._base_type_specifier
partition._bootable = self.helper_class._bootable
min_size = fmt_class._min_size
max_size = fmt_class._max_size
partition._size = min_size
storagedev._size = min_size
if fmt_class._name:
partition._parted_partition = FakePartedPart(partition, fmt_class._name)
self.assertTrue(self.helper_class.match(data, partition))
# These are only valid for partitions.
self.assertFalse(self.helper_class.match(data, storagedev))
data["ID_FS_TYPE"] += "x"
self.assertFalse(self.helper_class.match(data, partition))
data["ID_FS_TYPE"] = self.helper_class._base_type_specifier
if self.helper_class._bootable:
partition._bootable = False
self.assertFalse(self.helper_class.match(data, partition))
partition._bootable = True
if max_size:
partition._size = max_size + 1
elif min_size:
partition._size = min_size - 1
self.assertFalse(self.helper_class.match(data, partition))
partition._size = min_size
# we don't always match on the parted partition name, so allow
# subclasses to decide
if not self.name_mismatch_ok:
orig = partition._parted_partition
partition._parted_partition = FakePartedPart(partition, 'dontmatchanything')
self.assertFalse(self.helper_class.match(data, partition))
# shouldn't crash
partition._parted_partition = None
self.assertFalse(self.helper_class.match(data, partition))
partition._parted_partition = orig
def _ctor_kwargs(self):
kwargs = super()._ctor_kwargs()
kwargs["level"] = "raid0"
kwargs["parents"] = [Mock(name="member1", spec=StorageDevice),
Mock(name="member2", spec=StorageDevice)]
mdmember = get_device_format_class("mdmember")
for member in kwargs["parents"]:
member.format = Mock(spec=mdmember, exists=True)
member.protected = False
member.readonly = False
return kwargs
def _ctor_kwargs(self):
kwargs = super(MDRaidArrayDeviceMethodsTestCase, self)._ctor_kwargs()
kwargs["level"] = "raid0"
kwargs["parents"] = [Mock(name="member1", spec=StorageDevice),
Mock(name="member2", spec=StorageDevice)]
mdmember = get_device_format_class("mdmember")
for member in kwargs["parents"]:
member.format = Mock(spec=mdmember, exists=True)
member.protected = False
member.readonly = False
return kwargs
def _set_default_label_type():
"""Set up the default label type."""
if not conf.storage.gpt:
return
disklabel_class = get_device_format_class("disklabel")
disklabel_types = disklabel_class.get_platform_label_types()
if "gpt" not in disklabel_types:
log.warning("GPT is not a supported disklabel on this platform. "
"Using default disklabel %s instead.", disklabel_types[0])
return
disklabel_class.set_default_label_type("gpt")
def test_get_helper(self, *args):
if self.helper_class is None:
return
partition = PartitionDevice("testpartitiondev")
data = dict()
fmt_class = get_device_format_class(self.helper_class._type_specifier)
if fmt_class is None:
self.skipTest("failed to look up format class for %s" % self.helper_class._type_specifier)
data["ID_FS_TYPE"] = self.helper_class._base_type_specifier
data["DEVTYPE"] = "partition"
partition._bootable = self.helper_class._bootable
partition._size = fmt_class._min_size
self.assertEqual(get_format_helper(data, partition), self.helper_class)
def test_get_helper(self, *args):
if self.helper_class is None:
return
partition = PartitionDevice("testpartitiondev")
data = dict()
fmt_class = get_device_format_class(self.helper_class._type_specifier)
if fmt_class is None:
self.skipTest("failed to look up format class for %s" %
self.helper_class._type_specifier)
data["ID_FS_TYPE"] = self.helper_class._base_type_specifier
data["DEVTYPE"] = "partition"
partition._bootable = self.helper_class._bootable
partition._size = fmt_class._min_size
self.assertEqual(get_format_helper(data, partition), self.helper_class)
def test_match(self):
"""Test boot format populator helper match method"""
if self.helper_class is None:
return
partition = PartitionDevice("testpartitiondev")
storagedev = StorageDevice("teststoragedev")
storagedev.bootable = True
data = dict()
fmt_class = get_device_format_class(self.helper_class._type_specifier)
if fmt_class is None:
self.skipTest("failed to look up format class for %s" %
self.helper_class._type_specifier)
data["ID_FS_TYPE"] = self.helper_class._base_type_specifier
partition._bootable = self.helper_class._bootable
min_size = fmt_class._min_size
max_size = fmt_class._max_size
partition._size = min_size
storagedev._size = min_size
self.assertTrue(self.helper_class.match(data, partition))
# These are only valid for partitions.
self.assertFalse(self.helper_class.match(data, storagedev))
data["ID_FS_TYPE"] += "x"
self.assertFalse(self.helper_class.match(data, partition))
data["ID_FS_TYPE"] = self.helper_class._base_type_specifier
if self.helper_class._bootable:
partition._bootable = False
self.assertFalse(self.helper_class.match(data, partition))
partition._bootable = True
if max_size:
partition._size = max_size + 1
elif min_size:
partition._size = min_size - 1
self.assertFalse(self.helper_class.match(data, partition))
partition._size = min_size
def test_match(self):
"""Test boot format populator helper match method"""
if self.helper_class is None:
return
partition = PartitionDevice("testpartitiondev")
storagedev = StorageDevice("teststoragedev")
storagedev.bootable = True
data = dict()
fmt_class = get_device_format_class(self.helper_class._type_specifier)
if fmt_class is None:
self.skipTest("failed to look up format class for %s" % self.helper_class._type_specifier)
data["ID_FS_TYPE"] = self.helper_class._base_type_specifier
partition._bootable = self.helper_class._bootable
min_size = fmt_class._min_size
max_size = fmt_class._max_size
partition._size = min_size
storagedev._size = min_size
self.assertTrue(self.helper_class.match(data, partition))
# These are only valid for partitions.
self.assertFalse(self.helper_class.match(data, storagedev))
data["ID_FS_TYPE"] += "x"
self.assertFalse(self.helper_class.match(data, partition))
data["ID_FS_TYPE"] = self.helper_class._base_type_specifier
if self.helper_class._bootable:
partition._bootable = False
self.assertFalse(self.helper_class.match(data, partition))
partition._bootable = True
if max_size:
partition._size = max_size + 1
elif min_size:
partition._size = min_size - 1
self.assertFalse(self.helper_class.match(data, partition))
partition._size = min_size
def _parse_one_line(self, devspec, mountpoint, fstype, options, _dump="0", _passno="0"):
"""Parse an fstab entry for a device, return the corresponding device.
The parameters correspond to the items in a single entry in the
order in which they occur in the entry.
:return: the device corresponding to the entry
:rtype: :class:`blivet.devices.Device`
"""
# no sense in doing any legwork for a noauto entry
if "noauto" in options.split(","):
log.info("ignoring noauto entry")
raise UnrecognizedFSTabEntryError()
# find device in the tree
device = self.devicetree.resolve_device(devspec,
crypt_tab=self.crypt_tab,
blkid_tab=self.blkid_tab,
options=options)
if device:
# fall through to the bottom of this block
pass
elif devspec.startswith("/dev/loop"):
# FIXME: create devices.LoopDevice
log.warning("completely ignoring your loop mount")
elif ":" in devspec and fstype.startswith("nfs"):
# NFS -- preserve but otherwise ignore
device = NFSDevice(devspec,
fmt=get_format(fstype,
exists=True,
device=devspec))
elif devspec.startswith("/") and fstype == "swap":
# swap file
device = FileDevice(devspec,
parents=get_containing_device(devspec, self.devicetree),
fmt=get_format(fstype,
device=devspec,
exists=True),
exists=True)
elif fstype == "bind" or "bind" in options:
# bind mount... set fstype so later comparison won't
# turn up false positives
fstype = "bind"
# This is probably not going to do anything useful, so we'll
# make sure to try again from FSSet.mount_filesystems. The bind
# mount targets should be accessible by the time we try to do
# the bind mount from there.
parents = get_containing_device(devspec, self.devicetree)
device = DirectoryDevice(devspec, parents=parents, exists=True)
device.format = get_format("bind",
device=device.path,
exists=True)
elif mountpoint in ("/proc", "/sys", "/dev/shm", "/dev/pts",
"/sys/fs/selinux", "/proc/bus/usb", "/sys/firmware/efi/efivars"):
# drop these now -- we'll recreate later
return None
else:
# nodev filesystem -- preserve or drop completely?
fmt = get_format(fstype)
fmt_class = get_device_format_class("nodev")
if devspec == "none" or \
(fmt_class and isinstance(fmt, fmt_class)):
device = NoDevice(fmt=fmt)
if device is None:
log.error("failed to resolve %s (%s) from fstab", devspec,
fstype)
raise UnrecognizedFSTabEntryError()
device.setup()
fmt = get_format(fstype, device=device.path, exists=True)
if fstype != "auto" and None in (device.format.type, fmt.type):
log.info("Unrecognized filesystem type for %s (%s)",
device.name, fstype)
device.teardown()
raise UnrecognizedFSTabEntryError()
# make sure, if we're using a device from the tree, that
# the device's format we found matches what's in the fstab
ftype = getattr(fmt, "mount_type", fmt.type)
dtype = getattr(device.format, "mount_type", device.format.type)
if hasattr(fmt, "test_mount") and fstype != "auto" and ftype != dtype:
log.info("fstab says %s at %s is %s", dtype, mountpoint, ftype)
if fmt.test_mount(): # pylint: disable=no-member
device.format = fmt
else:
device.teardown()
raise FSTabTypeMismatchError(_(
"There is an entry in your /etc/fstab file that contains "
"an invalid or incorrect file system type. The file says that "
"{detected_type} at {mount_point} is {fstab_type}.").format(
detected_type=dtype,
mount_point=mountpoint,
fstab_type=ftype
))
del ftype
del dtype
if hasattr(device.format, "mountpoint"):
device.format.mountpoint = mountpoint
device.format.options = options
return device
def _parse_one_line(self, devspec, mountpoint, fstype, options, _dump="0", _passno="0"):
"""Parse an fstab entry for a device, return the corresponding device.
The parameters correspond to the items in a single entry in the
order in which they occur in the entry.
:return: the device corresponding to the entry
:rtype: :class:`blivet.devices.Device`
"""
# no sense in doing any legwork for a noauto entry
if "noauto" in options.split(","):
log.info("ignoring noauto entry")
raise UnrecognizedFSTabEntryError()
# find device in the tree
device = self.devicetree.resolve_device(devspec,
crypt_tab=self.crypt_tab,
blkid_tab=self.blkid_tab,
options=options)
if device:
# fall through to the bottom of this block
pass
elif devspec.startswith("/dev/loop"):
# FIXME: create devices.LoopDevice
log.warning("completely ignoring your loop mount")
elif ":" in devspec and fstype.startswith("nfs"):
# NFS -- preserve but otherwise ignore
device = NFSDevice(devspec,
fmt=get_format(fstype,
exists=True,
device=devspec))
elif devspec.startswith("/") and fstype == "swap":
# swap file
device = FileDevice(devspec,
parents=get_containing_device(devspec, self.devicetree),
fmt=get_format(fstype,
device=devspec,
exists=True),
exists=True)
elif fstype == "bind" or "bind" in options:
# bind mount... set fstype so later comparison won't
# turn up false positives
fstype = "bind"
# This is probably not going to do anything useful, so we'll
# make sure to try again from FSSet.mount_filesystems. The bind
# mount targets should be accessible by the time we try to do
# the bind mount from there.
parents = get_containing_device(devspec, self.devicetree)
device = DirectoryDevice(devspec, parents=parents, exists=True)
device.format = get_format("bind",
device=device.path,
exists=True)
elif mountpoint in ("/proc", "/sys", "/dev/shm", "/dev/pts",
"/sys/fs/selinux", "/proc/bus/usb", "/sys/firmware/efi/efivars"):
# drop these now -- we'll recreate later
return None
else:
# nodev filesystem -- preserve or drop completely?
fmt = get_format(fstype)
fmt_class = get_device_format_class("nodev")
if devspec == "none" or \
(fmt_class and isinstance(fmt, fmt_class)):
device = NoDevice(fmt=fmt)
if device is None:
log.error("failed to resolve %s (%s) from fstab", devspec,
fstype)
raise UnrecognizedFSTabEntryError()
device.setup()
fmt = get_format(fstype, device=device.path, exists=True)
if fstype != "auto" and None in (device.format.type, fmt.type):
log.info("Unrecognized filesystem type for %s (%s)",
device.name, fstype)
device.teardown()
raise UnrecognizedFSTabEntryError()
# make sure, if we're using a device from the tree, that
# the device's format we found matches what's in the fstab
ftype = getattr(fmt, "mount_type", fmt.type)
dtype = getattr(device.format, "mount_type", device.format.type)
if hasattr(fmt, "test_mount") and fstype != "auto" and ftype != dtype:
log.info("fstab says %s at %s is %s", dtype, mountpoint, ftype)
if fmt.test_mount(): # pylint: disable=no-member
device.format = fmt
else:
device.teardown()
raise FSTabTypeMismatchError("%s: detected as %s, fstab says %s"
% (mountpoint, dtype, ftype))
del ftype
del dtype
if hasattr(device.format, "mountpoint"):
device.format.mountpoint = mountpoint
device.format.options = options
return device
