[master 3/4] Fix PEP8 indentation issues.
dwlehman
installerbot-noreply at redhat.com
Wed Oct 28 20:05:37 UTC 2015
From: David Lehman <dlehman at redhat.com>
This is the exact result of running the following command:
python3-autopep8 --select E1 --in-place $(find . -name \*.py)
---
blivet/actionlist.py | 2 +-
blivet/autopart.py | 46 +-
blivet/blivet.py | 70 +--
blivet/callbacks.py | 2 +-
blivet/deviceaction.py | 14 +-
blivet/devicefactory.py | 80 +--
blivet/devicelibs/edd.py | 18 +-
blivet/devicelibs/lvm.py | 2 +-
blivet/devicelibs/mdraid.py | 8 +-
blivet/devicelibs/raid.py | 10 +-
blivet/devices/btrfs.py | 18 +-
blivet/devices/container.py | 4 +-
blivet/devices/device.py | 6 +-
blivet/devices/disk.py | 16 +-
blivet/devices/dm.py | 8 +-
blivet/devices/lvm.py | 16 +-
blivet/devices/md.py | 10 +-
blivet/devices/partition.py | 38 +-
blivet/devices/raid.py | 6 +-
blivet/devices/storage.py | 6 +-
blivet/devicetree.py | 38 +-
blivet/fcoe.py | 8 +-
blivet/formats/__init__.py | 10 +-
blivet/formats/biosboot.py | 1 -
blivet/formats/disklabel.py | 10 +-
blivet/formats/dmraid.py | 11 +-
blivet/formats/fs.py | 16 +-
blivet/formats/luks.py | 1 -
blivet/formats/lvmpv.py | 1 -
blivet/formats/mdraid.py | 1 -
blivet/formats/multipath.py | 1 -
blivet/formats/prepboot.py | 1 -
blivet/formats/swap.py | 2 +-
blivet/iscsi.py | 26 +-
blivet/osinstall.py | 56 +-
blivet/partitioning.py | 210 +++----
blivet/platform.py | 2 +-
blivet/populator.py | 66 +--
blivet/size.py | 2 +-
blivet/tasks/fsck.py | 22 +-
blivet/tasks/fsinfo.py | 2 +-
blivet/tasks/fslabeling.py | 2 +-
blivet/tasks/fsmkfs.py | 2 +-
blivet/tasks/fsmount.py | 4 +-
blivet/tasks/fsresize.py | 6 +-
blivet/tasks/task.py | 4 +-
blivet/udev.py | 2 +-
blivet/util.py | 4 +-
blivet/zfcp.py | 56 +-
doc/conf.py | 22 +-
examples/factory.py | 12 +-
examples/lvm.py | 4 +-
examples/partitioning.py | 4 +-
tests/__init__.py | 1 -
tests/action_test.py | 250 ++++----
tests/clearpart_test.py | 26 +-
tests/devicefactory_test.py | 28 +-
tests/devicelibs_test/edd_test.py | 72 +--
tests/devicelibs_test/raid_test.py | 10 +-
tests/devices_test/device_properties_test.py | 840 +++++++++++++--------------
tests/devices_test/lvm_test.py | 20 +-
tests/devices_test/partition_test.py | 10 +-
tests/devicetree_test.py | 118 ++--
tests/formats_test/disklabel_test.py | 10 +-
tests/formats_test/fslabeling.py | 4 +-
tests/formats_test/fstesting.py | 2 +-
tests/formats_test/init_test.py | 18 +-
tests/imagebackedtestcase.py | 2 +-
tests/partitioning_test.py | 50 +-
tests/pylint/runpylint.py | 38 +-
tests/tsort_test.py | 2 +-
71 files changed, 1241 insertions(+), 1249 deletions(-)
diff --git a/blivet/actionlist.py b/blivet/actionlist.py
index 915466d..cf42028 100644
--- a/blivet/actionlist.py
+++ b/blivet/actionlist.py
@@ -189,7 +189,7 @@ def _pre_process(self, devices=None):
# Call pre_commit_fixup on all devices, including those we're going to
# destroy (these are already removed from the tree)
fixup_devices = devices + [a.device for a in self._actions
- if a.is_destroy and a.is_device]
+ if a.is_destroy and a.is_device]
for device in fixup_devices:
device.pre_commit_fixup()
diff --git a/blivet/autopart.py b/blivet/autopart.py
index 4532858..1a54739 100644
--- a/blivet/autopart.py
+++ b/blivet/autopart.py
@@ -174,9 +174,9 @@ def _schedule_implicit_partitions(storage, disks, min_luks_entropy=0):
fmt_type = "btrfs"
fmt_args = {}
part = storage.new_partition(fmt_type=fmt_type,
- fmt_args=fmt_args,
- grow=True,
- parents=[disk])
+ fmt_args=fmt_args,
+ grow=True,
+ parents=[disk])
storage.create_device(part)
devs.append(part)
@@ -235,15 +235,15 @@ def _schedule_partitions(storage, disks, implicit_devices, min_luks_entropy=0, r
for request in requests:
if ((request.lv and storage.do_autopart and
storage.autopart_type in (AUTOPART_TYPE_LVM,
- AUTOPART_TYPE_LVM_THINP)) or
- (request.btr and storage.autopart_type == AUTOPART_TYPE_BTRFS)):
+ AUTOPART_TYPE_LVM_THINP)) or
+ (request.btr and storage.autopart_type == AUTOPART_TYPE_BTRFS)):
continue
if request.required_space and request.required_space > free:
continue
elif request.fstype in ("prepboot", "efi", "macefi", "hfs+") and \
- (storage.bootloader.skip_bootloader or stage1_device):
+ (storage.bootloader.skip_bootloader or stage1_device):
# there should never be a need for more than one of these
# partitions, so skip them.
log.info("skipping unneeded stage1 %s request", request.fstype)
@@ -260,11 +260,11 @@ def _schedule_partitions(storage, disks, implicit_devices, min_luks_entropy=0, r
getattr(stage1_device.format, "labelType", None) == "gpt")
has_bios_boot = (stage1_device and
any([p.format.type == "biosboot"
- for p in storage.partitions
- if p.disk == stage1_device]))
+ for p in storage.partitions
+ if p.disk == stage1_device]))
if (storage.bootloader.skip_bootloader or
not (stage1_device and stage1_device.is_disk and
- is_gpt and not has_bios_boot)):
+ is_gpt and not has_bios_boot)):
# there should never be a need for more than one of these
# partitions, so skip them.
log.info("skipping unneeded stage1 %s request", request.fstype)
@@ -289,21 +289,21 @@ def _schedule_partitions(storage, disks, implicit_devices, min_luks_entropy=0, r
fmt_args = {}
dev = storage.new_partition(fmt_type=fmt_type,
- fmt_args=fmt_args,
- size=request.size,
- grow=request.grow,
- maxsize=request.max_size,
- mountpoint=request.mountpoint,
- parents=disks,
- weight=request.weight)
+ fmt_args=fmt_args,
+ size=request.size,
+ grow=request.grow,
+ maxsize=request.max_size,
+ mountpoint=request.mountpoint,
+ parents=disks,
+ weight=request.weight)
# schedule the device for creation
storage.create_device(dev)
if request.encrypted and storage.encrypted_autopart:
luks_fmt = get_format(request.fstype,
- device=dev.path,
- mountpoint=request.mountpoint)
+ device=dev.path,
+ mountpoint=request.mountpoint)
luks_dev = LUKSDevice("luks-%s" % dev.name,
fmt=luks_fmt,
size=dev.size,
@@ -312,7 +312,7 @@ def _schedule_partitions(storage, disks, implicit_devices, min_luks_entropy=0, r
if storage.do_autopart and \
storage.autopart_type in (AUTOPART_TYPE_LVM, AUTOPART_TYPE_LVM_THINP,
- AUTOPART_TYPE_BTRFS):
+ AUTOPART_TYPE_BTRFS):
# doing LVM/BTRFS -- make sure the newly created partition fits in some
# free space together with one of the implicitly requested partitions
smallest_implicit = sorted(implicit_devices, key=lambda d: d.size)[0]
@@ -381,8 +381,8 @@ def _schedule_volumes(storage, devs):
for request in storage.autopart_requests:
btr = storage.autopart_type == AUTOPART_TYPE_BTRFS and request.btr
lv = (storage.autopart_type in (AUTOPART_TYPE_LVM,
- AUTOPART_TYPE_LVM_THINP) and request.lv)
- thinlv = (storage.autopart_type == AUTOPART_TYPE_LVM_THINP and
+ AUTOPART_TYPE_LVM_THINP) and request.lv)
+ thinlv = (storage.auto_part_type == AUTOPART_TYPE_LVM_THINP and
request.lv and request.thin)
if thinlv and pool is None:
# create a single thin pool in the vg
@@ -444,7 +444,7 @@ def do_reqpart(storage, requests):
if disks == []:
raise NotEnoughFreeSpaceError(_("Not enough free space on disks for "
- "automatic partitioning"))
+ "automatic partitioning"))
_schedule_partitions(storage, disks, [], requests=requests)
@@ -498,7 +498,7 @@ def do_autopart(storage, data, min_luks_entropy=0):
if disks == []:
raise NotEnoughFreeSpaceError(_("Not enough free space on disks for "
- "automatic partitioning"))
+ "automatic partitioning"))
devs = _schedule_partitions(storage, disks, devs, min_luks_entropy=min_luks_entropy)
diff --git a/blivet/blivet.py b/blivet/blivet.py
index 3d57cec..aa1a98e 100644
--- a/blivet/blivet.py
+++ b/blivet/blivet.py
@@ -527,9 +527,9 @@ def should_clear(self, device, **kwargs):
"""
clear_part_type = kwargs.get("clear_part_type", self.config.clear_part_type)
clear_part_disks = kwargs.get("clear_part_disks",
- self.config.clear_part_disks)
+ self.config.clear_part_disks)
clear_part_devices = kwargs.get("clear_part_devices",
- self.config.clear_part_devices)
+ self.config.clear_part_devices)
for disk in device.disks:
# this will not include disks with hidden formats like multipath
@@ -689,7 +689,7 @@ def initialize_disk(self, disk):
# create a new disklabel on the disk
new_label = get_format("disklabel", device=disk.path,
- label_type=label_type)
+ label_type=label_type)
create_action = ActionCreateFormat(disk, fmt=new_label)
self.devicetree.register_action(create_action)
@@ -737,7 +737,7 @@ def get_free_space(self, disks=None, clear_part_type=None):
free = {}
for disk in disks:
should_clear = self.should_clear(disk, clear_part_type=clear_part_type,
- clear_part_disks=[disk.name])
+ clear_part_disks=[disk.name])
if should_clear:
free[disk.name] = (disk.size, Size(0))
continue
@@ -751,8 +751,8 @@ def get_free_space(self, disks=None, clear_part_type=None):
# operations to translate free filesystem space into free disk
# space
should_clear = self.should_clear(partition,
- clear_part_type=clear_part_type,
- clear_part_disks=[disk.name])
+ clear_part_type=clear_part_type,
+ clear_part_disks=[disk.name])
if should_clear:
disk_free += partition.size
elif hasattr(partition.format, "free"):
@@ -796,9 +796,9 @@ def new_partition(self, *args, **kwargs):
"""
if 'fmt_type' in kwargs:
kwargs["fmt"] = get_format(kwargs.pop("fmt_type"),
- mountpoint=kwargs.pop("mountpoint",
- None),
- **kwargs.pop("fmt_args", {}))
+ mountpoint=kwargs.pop("mountpoint",
+ None),
+ **kwargs.pop("fmt_args", {}))
if 'name' in kwargs:
name = kwargs.pop("name")
@@ -811,7 +811,7 @@ def new_partition(self, *args, **kwargs):
mountpoint = getattr(fmt, "mountpoint", None)
kwargs["weight"] = _platform.weight(mountpoint=mountpoint,
- fstype=fmt.type)
+ fstype=fmt.type)
return PartitionDevice(name, *args, **kwargs)
@@ -835,23 +835,23 @@ def new_mdarray(self, *args, **kwargs):
"""
if 'fmt_type' in kwargs:
kwargs["fmt"] = get_format(kwargs.pop("fmt_type"),
- mountpoint=kwargs.pop("mountpoint",
- None),
- **kwargs.pop("fmt_args", {}))
+ mountpoint=kwargs.pop("mountpoint",
+ None),
+ **kwargs.pop("fmt_args", {}))
name = kwargs.pop("name", None)
if name:
safe_name = self.safe_device_name(name)
if safe_name != name:
log.warning("using '%s' instead of specified name '%s'",
- safe_name, name)
+ safe_name, name)
name = safe_name
else:
swap = getattr(kwargs.get("fmt"), "type", None) == "swap"
mountpoint = getattr(kwargs.get("fmt"), "mountpoint", None)
name = self.suggest_device_name(prefix=short_product_name,
- swap=swap,
- mountpoint=mountpoint)
+ swap=swap,
+ mountpoint=mountpoint)
return MDRaidArrayDevice(name, *args, **kwargs)
@@ -877,7 +877,7 @@ def new_vg(self, *args, **kwargs):
safe_name = self.safe_device_name(name)
if safe_name != name:
log.warning("using '%s' instead of specified name '%s'",
- safe_name, name)
+ safe_name, name)
name = safe_name
else:
hostname = ""
@@ -930,8 +930,8 @@ def new_lv(self, *args, **kwargs):
mountpoint = kwargs.pop("mountpoint", None)
if 'fmt_type' in kwargs:
kwargs["fmt"] = get_format(kwargs.pop("fmt_type"),
- mountpoint=mountpoint,
- **kwargs.pop("fmt_args", {}))
+ mountpoint=mountpoint,
+ **kwargs.pop("fmt_args", {}))
name = kwargs.pop("name", None)
if name:
@@ -942,7 +942,7 @@ def new_lv(self, *args, **kwargs):
if safe_name != full_name:
new_name = safe_name[len(safe_vg_name) + 1:]
log.warning("using '%s' instead of specified name '%s'",
- new_name, name)
+ new_name, name)
name = new_name
else:
if kwargs.get("fmt") and kwargs["fmt"].type == "swap":
@@ -955,9 +955,9 @@ def new_lv(self, *args, **kwargs):
prefix = "pool"
name = self.suggest_device_name(parent=vg,
- swap=swap,
- mountpoint=mountpoint,
- prefix=prefix)
+ swap=swap,
+ mountpoint=mountpoint,
+ prefix=prefix)
if "%s-%s" % (vg.name, name) in self.names:
raise ValueError("name already in use")
@@ -1268,7 +1268,7 @@ def suggest_container_name(self, hostname=None, prefix=""):
return name
def suggest_device_name(self, parent=None, swap=None,
- mountpoint=None, prefix=""):
+ mountpoint=None, prefix=""):
""" Return a suitable, unused name for a new device.
:keyword parent: the parent device
@@ -1411,7 +1411,7 @@ def turn_on_swap(self):
def mount_filesystems(self, read_only=None, skip_root=False):
self.fsset.mount_filesystems(root_path=get_sysroot(),
- read_only=read_only, skip_root=skip_root)
+ read_only=read_only, skip_root=skip_root)
def umount_filesystems(self, swapoff=True):
self.fsset.umount_filesystems(swapoff=swapoff)
@@ -1514,7 +1514,7 @@ def _check_valid_fstype(self, newtype):
raise ValueError("unrecognized value %s for new default fs type" % newtype)
if (not fmt.mountable or not fmt.formattable or not fmt.supported or
- not fmt.linux_native):
+ not fmt.linux_native):
log.debug("invalid default fstype: %r", fmt)
raise ValueError("new value %s is not valid as a default fs type" % fmt)
@@ -1694,7 +1694,7 @@ def copy(self):
# go through and re-get parted_partitions from the disks since they
# don't get deep-copied
hidden_partitions = [d for d in new.devicetree._hidden
- if isinstance(d, PartitionDevice)]
+ if isinstance(d, PartitionDevice)]
for partition in new.partitions + hidden_partitions:
if not partition._parted_partition:
continue
@@ -1774,10 +1774,10 @@ def update_ksdata(self):
self.ksdata.clearpart.devices = []
self.ksdata.clearpart.drives = []
fresh_disks = [d.name for d in self.disks if d.partitioned and
- not d.format.exists]
+ not d.format.exists]
destroy_actions = self.devicetree.find_actions(action_type="destroy",
- object_type="device")
+ object_type="device")
cleared_partitions = []
partial = False
@@ -1809,15 +1809,15 @@ def _update_custom_storage_ksdata(self):
# custom storage
ks_map = {PartitionDevice: ("PartData", "partition"),
- TmpFSDevice: ("PartData", "partition"),
- LVMLogicalVolumeDevice: ("LogVolData", "logvol"),
- LVMVolumeGroupDevice: ("VolGroupData", "volgroup"),
- MDRaidArrayDevice: ("RaidData", "raid"),
- BTRFSDevice: ("BTRFSData", "btrfs")}
+ TmpFSDevice: ("PartData", "partition"),
+ LVMLogicalVolumeDevice: ("LogVolData", "logvol"),
+ LVMVolumeGroupDevice: ("VolGroupData", "volgroup"),
+ MDRaidArrayDevice: ("RaidData", "raid"),
+ BTRFSDevice: ("BTRFSData", "btrfs")}
# make a list of ancestors of all used devices
devices = list(set(a for d in list(self.mountpoints.values()) + self.swaps
- for a in d.ancestors))
+ for a in d.ancestors))
# devices which share information with their distinct raw device
complementary_devices = [d for d in devices if d.raw_device is not d]
diff --git a/blivet/callbacks.py b/blivet/callbacks.py
index 52f59ab..8947f13 100644
--- a/blivet/callbacks.py
+++ b/blivet/callbacks.py
@@ -78,4 +78,4 @@ def create_new_callbacks_register(create_format_pre=None,
WaitForEntropyData = namedtuple("WaitForEntropyData",
["msg", "min_entropy"])
ReportProgressData = namedtuple("ReportProgressData",
- ["msg"])
+ ["msg"])
diff --git a/blivet/deviceaction.py b/blivet/deviceaction.py
index ffb6c5f..6c42fe9 100644
--- a/blivet/deviceaction.py
+++ b/blivet/deviceaction.py
@@ -418,8 +418,8 @@ def obsoletes(self, action):
if self.id >= action.id and not self.device.exists:
rc = True
elif self.id > action.id and \
- self.device.exists and \
- not (action.is_destroy and action.is_format):
+ self.device.exists and \
+ not (action.is_destroy and action.is_format):
rc = True
elif action.is_add and (action.device == self.device):
rc = True
@@ -893,8 +893,8 @@ def obsoletes(self, action):
"""
retval = False
if (action.is_remove and
- action.device == self.device and
- action.container == self.container):
+ action.device == self.device and
+ action.container == self.container):
retval = True
elif (action.is_add and
action.device == self.device and
@@ -945,7 +945,7 @@ def requires(self, action):
"""
retval = False
if ((action.is_shrink or action.is_destroy) and
- action.device.container == self.container):
+ action.device.container == self.container):
retval = True
elif action.is_add and action.container == self.container:
retval = True
@@ -963,8 +963,8 @@ def obsoletes(self, action):
"""
retval = False
if (action.is_add and
- action.device == self.device and
- action.container == self.container):
+ action.device == self.device and
+ action.container == self.container):
retval = True
elif (action.is_remove and
action.device == self.device and
diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py
index f76496a..54f5d9d 100644
--- a/blivet/devicefactory.py
+++ b/blivet/devicefactory.py
@@ -137,7 +137,7 @@ def get_device_factory(blivet, device_type, size, **kwargs):
factory_class = class_table[device_type]
log.debug("instantiating %s: %s, %s, %s, %s", factory_class,
- blivet, size, [d.name for d in disks], kwargs)
+ blivet, size, [d.name for d in disks], kwargs)
return factory_class(blivet, size, disks, **kwargs)
@@ -520,7 +520,7 @@ def get_container(self, device=None, name=None, allow_existing=False):
break
else:
containers = [c for c in self.container_list
- if allow_existing or not c.exists]
+ if allow_existing or not c.exists]
if containers:
# XXX All containers should have a "free" attribute
containers.sort(key=lambda c: getattr(c, "freeSpace", c.size),
@@ -662,9 +662,9 @@ def _create_device(self):
fmt_args["label"] = self.label
fmt = get_format(self.fstype,
- mountpoint=self.mountpoint,
- min_luks_entropy=self.min_luks_entropy,
- **fmt_args)
+ mountpoint=self.mountpoint,
+ min_luks_entropy=self.min_luks_entropy,
+ **fmt_args)
luks_device = LUKSDevice("luks-" + device.name,
parents=[device], fmt=fmt)
self.storage.create_device(luks_device)
@@ -718,17 +718,17 @@ def _set_format(self):
current_format = self.device.format
if current_format.type != self.fstype:
new_format = get_format(self.fstype,
- mountpoint=self.mountpoint,
- label=self.label,
- exists=False)
+ mountpoint=self.mountpoint,
+ label=self.label,
+ exists=False)
self.storage.format_device(self.device, new_format)
else:
if (hasattr(current_format, "mountpoint") and
- current_format.mountpoint != self.mountpoint):
+ current_format.mountpoint != self.mountpoint):
current_format.mountpoint = self.mountpoint
if (hasattr(current_format, "label") and
- current_format.label != self.label):
+ current_format.label != self.label):
current_format.label = self.label
def _set_encryption(self):
@@ -749,7 +749,7 @@ def _set_encryption(self):
orig_device = self.device
leaf_format = self.device.format
self.storage.format_device(self.device, get_format("luks",
- min_luks_entropy=self.min_luks_entropy))
+ min_luks_entropy=self.min_luks_entropy))
luks_device = LUKSDevice("luks-%s" % self.device.name,
fmt=leaf_format,
parents=self.device)
@@ -761,19 +761,19 @@ def _set_encryption(self):
def _set_name(self):
if not self.device_name:
self.device_name = self.storage.suggest_device_name(
- parent=self.container,
- swap=(self.fstype == "swap"),
- mountpoint=self.mountpoint)
+ parent=self.container,
+ swap=(self.fstype == "swap"),
+ mountpoint=self.mountpoint)
safe_new_name = self.storage.safe_device_name(self.device_name)
if self.device.name != safe_new_name:
if safe_new_name in self.storage.names:
log.error("not renaming '%s' to in-use name '%s'",
- self.device.name, safe_new_name)
+ self.device.name, safe_new_name)
return
log.debug("renaming device '%s' to '%s'",
- self.device.name, safe_new_name)
+ self.device.name, safe_new_name)
self.device.name = safe_new_name
def _post_create(self):
@@ -917,7 +917,7 @@ def _set_device_size(self):
""" Set the size of a defined factory device. """
if self.raw_device and self.size != self.raw_device.size:
log.info("adjusting device size from %s to %s",
- self.raw_device.size, self.size)
+ self.raw_device.size, self.size)
base_size = self._get_base_size()
size = self._get_device_size()
@@ -948,8 +948,8 @@ def _get_new_device(self, *args, **kwargs):
kwargs["size"] = self._get_base_size()
device = self.storage.new_partition(*args,
- grow=True, maxsize=max_size,
- **kwargs)
+ grow=True, maxsize=max_size,
+ **kwargs)
return device
def _set_disks(self):
@@ -988,8 +988,8 @@ def __init__(self, storage, size, disks, fstype=None, encrypted=False,
devices an initial set of devices
"""
super(PartitionSetFactory, self).__init__(storage, size, disks,
- fstype=fstype,
- encrypted=encrypted)
+ fstype=fstype,
+ encrypted=encrypted)
self._devices = []
if devices:
self._devices = devices
@@ -1050,7 +1050,7 @@ def configure(self):
# drop any new disks that don't have free space
min_free = min(Size("500MiB"), self.parent_factory.size)
add_disks = [d for d in add_disks if d.partitioned and
- d.format.free >= min_free]
+ d.format.free >= min_free]
log.debug("add_disks: %s", [d.name for d in add_disks])
log.debug("remove_disks: %s", [d.name for d in remove_disks])
@@ -1073,7 +1073,7 @@ def configure(self):
self.storage.destroy_device(member)
members.remove(member)
self.storage.format_device(member.slave,
- get_format(self.fstype))
+ get_format(self.fstype))
members.append(member.slave)
if container:
container.parents.replace(member, member.slave)
@@ -1083,10 +1083,10 @@ def configure(self):
if not member_encrypted and self.encrypted:
members.remove(member)
self.storage.format_device(member, get_format("luks",
- min_luks_entropy=self.min_luks_entropy))
+ min_luks_entropy=self.min_luks_entropy))
luks_member = LUKSDevice("luks-%s" % member.name,
- parents=[member],
- fmt=get_format(self.fstype))
+ parents=[member],
+ fmt=get_format(self.fstype))
self.storage.create_device(luks_member)
members.append(luks_member)
if container:
@@ -1118,8 +1118,8 @@ def configure(self):
try:
member = self.storage.new_partition(parents=[disk], grow=True,
- size=base_size,
- fmt_type=member_format)
+ size=base_size,
+ fmt_type=member_format)
except (StorageError, blockdev.BlockDevError) as e:
log.error("failed to create new member partition: %s", e)
continue
@@ -1229,7 +1229,7 @@ def _set_device_size(self):
size = self._get_device_size()
if self.device and size != self.raw_device.size:
log.info("adjusting device size from %s to %s",
- self.raw_device.size, size)
+ self.raw_device.size, size)
self.raw_device.size = size
self.raw_device.req_grow = False
@@ -1319,16 +1319,16 @@ def _get_new_device(self, *args, **kwargs):
def _set_name(self):
if not self.device_name:
self.device_name = self.storage.suggest_device_name(
- parent=self.container,
- swap=(self.fstype == "swap"),
- mountpoint=self.mountpoint)
+ parent=self.container,
+ swap=(self.fstype == "swap"),
+ mountpoint=self.mountpoint)
lvname = "%s-%s" % (self.container.name, self.device_name)
safe_new_name = self.storage.safe_device_name(lvname)
if self.device.name != safe_new_name:
if safe_new_name in self.storage.names:
log.error("not renaming '%s' to in-use name '%s'",
- self.device.name, safe_new_name)
+ self.device.name, safe_new_name)
return
if not safe_new_name.startswith(self.container.name):
@@ -1338,7 +1338,7 @@ def _set_name(self):
# strip off the vg name before setting
safe_new_name = safe_new_name[len(self.container.name) + 1:]
log.debug("renaming device '%s' to '%s'",
- self.device.name, safe_new_name)
+ self.device.name, safe_new_name)
self.device.name = safe_new_name
def _configure(self):
@@ -1352,7 +1352,7 @@ def _configure(self):
use_dev = member.raw_device
if ((self.container_raid_level and use_dev.type != "mdarray") or
- (not self.container_raid_level and use_dev.type == "mdarray")):
+ (not self.container_raid_level and use_dev.type == "mdarray")):
self.container.parents.remove(member)
self.storage.destroy_device(member)
if member != use_dev:
@@ -1590,8 +1590,8 @@ def _set_container(self):
self.pool = self.get_pool()
if self.pool:
log.debug("pool is %s ; size: %s ; free: %s", self.pool.name,
- self.pool.size,
- self.pool.free_space)
+ self.pool.size,
+ self.pool.free_space)
for lv in self.pool.lvs:
log.debug(" %s size is %s", lv.name, lv.size)
@@ -1632,9 +1632,9 @@ def __init__(self, storage, size, disks, **kwargs):
def _get_device_space(self):
return self.raid_level.get_space(self.size,
- len(self._get_member_devices()),
- None,
- blockdev.md.get_superblock_size)
+ len(self._get_member_devices()),
+ None,
+ blockdev.md.get_superblock_size)
def _get_total_space(self):
return self._get_device_space()
diff --git a/blivet/devicelibs/edd.py b/blivet/devicelibs/edd.py
index 2de52ed..edf2964 100644
--- a/blivet/devicelibs/edd.py
+++ b/blivet/devicelibs/edd.py
@@ -426,7 +426,7 @@ def devname_from_scsi_pci_dev(self):
'chan': self.edd.channel,
'dev': self.edd.scsi_id,
'lun': self.edd.scsi_lun,
- }
+ }
path = tmpl0 % args
pattern = tmpl1 % args
matching_paths = glob.glob(pattern)
@@ -434,8 +434,8 @@ def devname_from_scsi_pci_dev(self):
block_entries = os.listdir(path)
if len(block_entries) == 1:
self.edd.sysfslink = "..%s/%s" % (
- path[len(fsroot) + len("/sys"):],
- block_entries[0])
+ path[len(fsroot) + len("/sys"):],
+ block_entries[0])
name = block_entries[0]
elif len(matching_paths) > 1:
log.error("edd: Too many devices match for pci dev %s channel %s "
@@ -447,8 +447,8 @@ def devname_from_scsi_pci_dev(self):
block_entries = os.listdir(matching_paths[0])
if len(block_entries) == 1:
self.edd.sysfslink = "..%s/%s" % (
- matching_paths[0][len(fsroot) + len("/sys"):],
- block_entries[0])
+ matching_paths[0][len(fsroot) + len("/sys"):],
+ block_entries[0])
name = block_entries[0]
else:
log.warning("edd: Could not find SCSI device for pci dev %s "
@@ -460,7 +460,7 @@ def devname_from_virt_pci_dev(self):
args = {
'fsroot': fsroot,
'pci_dev': self.edd.pci_dev
- }
+ }
pattern = "%(fsroot)s/sys/devices/pci0000:00/0000:%(pci_dev)s/virtio*"
matching_paths = glob.glob(pattern % args)
@@ -472,8 +472,8 @@ def devname_from_virt_pci_dev(self):
block_entries = os.listdir(newpath)
if len(block_entries) == 1:
self.edd.sysfslink = "..%s/%s" % (
- matching_paths[0][len(fsroot) + len("/sys"):],
- block_entries[0])
+ matching_paths[0][len(fsroot) + len("/sys"):],
+ block_entries[0])
return block_entries[0]
else:
# Virtio SCSI looks like scsi but with a virtio%d/ stuck in
@@ -598,7 +598,7 @@ def get_edd_dict(devices):
old_edd_number = edd_dict.get(name)
if old_edd_number:
log.info("edd: both edd entries 0x%x and 0x%x seem to map to %s",
- old_edd_number, edd_number, name)
+ old_edd_number, edd_number, name)
# this means all the other data can be confused and useless
return {}
edd_dict[name] = edd_number
diff --git a/blivet/devicelibs/lvm.py b/blivet/devicelibs/lvm.py
index 539d554..a2b2826 100644
--- a/blivet/devicelibs/lvm.py
+++ b/blivet/devicelibs/lvm.py
@@ -65,7 +65,7 @@
# argument. For every time we call an lvm_cc (lvm compose config) funciton
# we regenerate the config_args with all global info.
config_args_data = {"filterRejects": [], # regular expressions to reject.
- "filterAccepts": []} # regexp to accept
+ "filterAccepts": []} # regexp to accept
def _set_global_config():
diff --git a/blivet/devicelibs/mdraid.py b/blivet/devicelibs/mdraid.py
index 7ace310..fe5af47 100644
--- a/blivet/devicelibs/mdraid.py
+++ b/blivet/devicelibs/mdraid.py
@@ -37,10 +37,10 @@ class MDRaidLevels(raid.RAIDLevels):
@classmethod
def is_raid_level(cls, level):
return super(MDRaidLevels, cls).is_raid_level(level) and \
- hasattr(level, 'get_max_spares') and \
- hasattr(level, 'get_space') and \
- hasattr(level, 'get_recommended_stride') and \
- hasattr(level, 'get_size')
+ hasattr(level, 'get_max_spares') and \
+ hasattr(level, 'get_space') and \
+ hasattr(level, 'get_recommended_stride') and \
+ hasattr(level, 'get_size')
RAID_levels = MDRaidLevels(["raid0", "raid1", "raid4", "raid5", "raid6", "raid10", "linear"])
diff --git a/blivet/devicelibs/raid.py b/blivet/devicelibs/raid.py
index 046a443..54ebce6 100644
--- a/blivet/devicelibs/raid.py
+++ b/blivet/devicelibs/raid.py
@@ -112,17 +112,17 @@ class RAIDn(RAIDLevel):
is_uniform = property(lambda s: True)
number = property(lambda s: int(s.level),
- doc="A numeric code for this level")
+ doc="A numeric code for this level")
name = property(lambda s: "raid" + s.level,
- doc="The canonical name for this level")
+ doc="The canonical name for this level")
alt_synth_names = property(lambda s: ["RAID" + s.level, s.level, s.number],
- doc="names that can be synthesized from level but are not name")
+ doc="names that can be synthesized from level but are not name")
names = property(lambda s:
- [n for n in [s.name] + [s.nick] + s.alt_synth_names if n is not None],
- doc="all valid names for this level")
+ [n for n in [s.name] + [s.nick] + s.alt_synth_names if n is not None],
+ doc="all valid names for this level")
# METHODS
def get_max_spares(self, member_count):
diff --git a/blivet/devices/btrfs.py b/blivet/devices/btrfs.py
index ba0b716..a1d8b26 100644
--- a/blivet/devices/btrfs.py
+++ b/blivet/devices/btrfs.py
@@ -206,13 +206,13 @@ def __init__(self, *args, **kwargs):
if self.parents and not self.format.type:
label = getattr(self.parents[0].format, "label", None)
self.format = get_format("btrfs",
- exists=self.exists,
- label=label,
- vol_uuid=self.uuid,
- device=self.path,
- subvolspec=self.vol_id,
- mountopts="subvolid=%d" % self.vol_id,
- create_options=create_options)
+ exists=self.exists,
+ label=label,
+ vol_uuid=self.uuid,
+ device=self.path,
+ subvolspec=self.vol_id,
+ mountopts="subvolid=%d" % self.vol_id,
+ create_options=create_options)
self.original_format = copy.deepcopy(self.format)
self._default_subvolume_id = None
@@ -309,8 +309,8 @@ def _get_size(self):
# Calculate the size as if it were a RAID with no superblock and a chunk_size of 1
data_level = self.data_level or raid.Single
return data_level.get_size([d.size for d in self.parents],
- chunk_size=Size(1),
- superblock_size_func=lambda x: 0)
+ chunk_size=Size(1),
+ superblock_size_func=lambda x: 0)
def _remove_parent(self, member):
levels = (l for l in (self.data_level, self.metadata_level) if l)
diff --git a/blivet/devices/container.py b/blivet/devices/container.py
index 3897b51..6e5b8c6 100644
--- a/blivet/devices/container.py
+++ b/blivet/devices/container.py
@@ -53,9 +53,9 @@ class ContainerDevice(StorageDevice):
"""
_format_class_name = abc.abstractproperty(lambda s: None,
- doc="The type of member devices' required format")
+ doc="The type of member devices' required format")
_format_uuid_attr = abc.abstractproperty(lambda s: None,
- doc="The container UUID attribute in the member format class")
+ doc="The container UUID attribute in the member format class")
def __init__(self, *args, **kwargs):
self.format_class = get_device_format_class(self._format_class_name)
diff --git a/blivet/devices/device.py b/blivet/devices/device.py
index 7254359..48ea554 100644
--- a/blivet/devices/device.py
+++ b/blivet/devices/device.py
@@ -97,8 +97,8 @@ def __deepcopy__(self, memo):
For these parted objects, we just do a shallow copy.
"""
return util.variable_copy(self, memo,
- omit=('node',),
- shallow=('_parted_partition',))
+ omit=('node',),
+ shallow=('_parted_partition',))
def __repr__(self):
s = ("%(type)s instance (%(id)s) --\n"
@@ -163,7 +163,7 @@ def _get_parent_list(self):
@property
def dict(self):
d = {"type": self.type, "name": self.name,
- "parents": [p.name for p in self.parents]}
+ "parents": [p.name for p in self.parents]}
return d
def remove_child(self):
diff --git a/blivet/devices/disk.py b/blivet/devices/disk.py
index ef2c973..27a8448 100644
--- a/blivet/devices/disk.py
+++ b/blivet/devices/disk.py
@@ -147,9 +147,9 @@ def __init__(self, name, fmt=None,
self._dev_dir = os.path.dirname(name)
super(DiskFile, self).__init__(_name, fmt=fmt, size=size,
- major=major, minor=minor, sysfs_path=sysfs_path,
- parents=parents, serial=serial, vendor=vendor,
- model=model, bus=bus, exists=exists)
+ major=major, minor=minor, sysfs_path=sysfs_path,
+ parents=parents, serial=serial, vendor=vendor,
+ model=model, bus=bus, exists=exists)
#
# Regular files do not have sysfs entries.
@@ -341,7 +341,7 @@ def _setup(self, orig=False):
rc = util.run_program(["multipath", self.name])
if rc:
raise errors.MPathError("multipath activation failed for '%s'" %
- self.name, hardware_fault=True)
+ self.name, hardware_fault=True)
def _post_setup(self):
StorageDevice._post_setup(self)
@@ -400,10 +400,10 @@ def __init__(self, device, **kwargs):
NetworkStorageDevice.__init__(self, host_address=self.node.address,
nic=self.nic)
log.debug("created new iscsi disk %s %s:%d via %s:%s", self.node.name,
- self.node.address,
- self.node.port,
- self.node.iface,
- self.nic)
+ self.node.address,
+ self.node.port,
+ self.node.iface,
+ self.nic)
def dracut_setup_args(self):
if self.ibft:
diff --git a/blivet/devices/dm.py b/blivet/devices/dm.py
index a908ef2..76892f6 100644
--- a/blivet/devices/dm.py
+++ b/blivet/devices/dm.py
@@ -46,8 +46,8 @@ class DMDevice(StorageDevice):
_type = "dm"
_dev_dir = "/dev/mapper"
_external_dependencies = [
- availability.KPARTX_APP,
- availability.BLOCKDEV_DM_PLUGIN
+ availability.KPARTX_APP,
+ availability.BLOCKDEV_DM_PLUGIN
]
def __init__(self, name, fmt=None, size=None, dm_uuid=None, uuid=None,
@@ -78,8 +78,8 @@ def __init__(self, name, fmt=None, size=None, dm_uuid=None, uuid=None,
stored in device metadata on disk.
"""
super(DMDevice, self).__init__(name, fmt=fmt, size=size,
- exists=exists, uuid=uuid,
- parents=parents, sysfs_path=sysfs_path)
+ exists=exists, uuid=uuid,
+ parents=parents, sysfs_path=sysfs_path)
self.target = target
self.dm_uuid = dm_uuid
diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py
index 416f942..d753edd 100644
--- a/blivet/devices/lvm.py
+++ b/blivet/devices/lvm.py
@@ -125,8 +125,8 @@ def __init__(self, name, parents=None, size=None, free=None,
self._complete = True
super(LVMVolumeGroupDevice, self).__init__(name, parents=parents,
- uuid=uuid, size=size,
- exists=exists, sysfs_path=sysfs_path)
+ uuid=uuid, size=size,
+ exists=exists, sysfs_path=sysfs_path)
self.free = util.numeric_type(free)
self.pe_size = util.numeric_type(pe_size)
@@ -315,7 +315,7 @@ def _add_parent(self, member):
super(LVMVolumeGroupDevice, self)._add_parent(member)
if (self.exists and member.format.exists and
- len(self.parents) + 1 == self.pv_count):
+ len(self.parents) + 1 == self.pv_count):
self._complete = True
def _remove_parent(self, member):
@@ -799,7 +799,7 @@ def _pre_create(self):
if self.size > can_use:
msg = ("%s LV's size (%s) exceeds the VG's usable free space (%s),"
- "shrinking the LV") % (self.name, self.size, can_use)
+ "shrinking the LV") % (self.name, self.size, can_use)
log.warning(msg)
self.size = can_use
@@ -865,7 +865,7 @@ def isleaf(self):
# Thin snapshots do not need to be removed prior to removal of the
# origin, but the old snapshots do.
non_thin_snapshots = any(s for s in self.snapshots
- if not isinstance(s, LVMThinSnapShotDevice))
+ if not isinstance(s, LVMThinSnapShotDevice))
return (super(LVMLogicalVolumeDevice, self).isleaf and
not non_thin_snapshots)
@@ -1045,8 +1045,8 @@ def __init__(self, name, vg, parent_lv=None, size=None, uuid=None,
# and some parameters set to values reflecting the fact that this is an
# internal LV
super(LVMInternalLogicalVolumeDevice, self).__init__(name, parents=None,
- size=size, uuid=uuid, seg_type=seg_type, fmt=None, exists=exists,
- sysfs_path=sysfs_path, grow=None, maxsize=None, percent=None)
+ size=size, uuid=uuid, seg_type=seg_type, fmt=None, exists=exists,
+ sysfs_path=sysfs_path, grow=None, maxsize=None, percent=None)
if parent_lv:
self._parent_lv.add_internal_lv(self)
@@ -1200,7 +1200,7 @@ def resizable(self):
# (only) thin pool metadata LVs can be resized directly
def resize(self):
if ((self._parent_lv and not isinstance(self._parent_lv, LVMThinPoolDevice)) or
- re.search(r'_[rc]meta', self.lvname)):
+ re.search(r'_[rc]meta', self.lvname)):
raise errors.DeviceError("RAID and cache pool metadata LVs cannot be resized directly")
# skip the generic LVMInternalLogicalVolumeDevice class and call the
diff --git a/blivet/devices/md.py b/blivet/devices/md.py
index 9e19be3..3822f13 100644
--- a/blivet/devices/md.py
+++ b/blivet/devices/md.py
@@ -229,9 +229,9 @@ def size(self):
if not self.exists or not self.media_present:
try:
size = self.level.get_size([d.size for d in self.members],
- self.member_devices,
- self.chunk_size,
- self.get_superblock_size)
+ self.member_devices,
+ self.chunk_size,
+ self.get_superblock_size)
except (blockdev.MDRaidError, errors.RaidError) as e:
log.info("could not calculate size of device %s for raid level %s: %s", self.name, self.level, e)
size = Size(0)
@@ -305,8 +305,8 @@ def _set_member_devices(self, number):
self._member_devices = number
member_devices = property(lambda d: d._get_member_devices(),
- lambda d, m: d._set_member_devices(m),
- doc="number of member devices")
+ lambda d, m: d._set_member_devices(m),
+ doc="number of member devices")
def _get_spares(self):
spares = 0
diff --git a/blivet/devices/partition.py b/blivet/devices/partition.py
index 6d1c626..ce358e3 100644
--- a/blivet/devices/partition.py
+++ b/blivet/devices/partition.py
@@ -251,7 +251,7 @@ def align_target_size(self, newsize):
return newsize
(_constraint, geometry) = self._compute_resize(self.parted_partition,
- newsize=newsize)
+ newsize=newsize)
return Size(geometry.getLength(unit="B"))
def _set_target_size(self, newsize):
@@ -345,7 +345,7 @@ def _set_parted_partition(self, partition):
self.update_name()
parted_partition = property(lambda d: d._get_parted_partition(),
- lambda d, p: d._set_parted_partition(p))
+ lambda d, p: d._set_parted_partition(p))
def pre_commit_fixup(self):
""" Re-get self.parted_partition from the original disklabel. """
@@ -361,14 +361,14 @@ def pre_commit_fixup(self):
# getPartitionBySector doesn't work on extended partitions
_partition = _disklabel.extended_partition
log.debug("extended lookup found partition %s",
- device_path_to_name(getattr(_partition, "path", None) or "(none)"))
+ device_path_to_name(getattr(_partition, "path", None) or "(none)"))
else:
# lookup the partition by sector to avoid the renumbering
# nonsense entirely
_sector = self.parted_partition.geometry.start
_partition = _disklabel.parted_disk.getPartitionBySector(_sector)
log.debug("sector-based lookup found partition %s",
- device_path_to_name(getattr(_partition, "path", None) or "(none)"))
+ device_path_to_name(getattr(_partition, "path", None) or "(none)"))
self.parted_partition = _partition
@@ -489,7 +489,7 @@ def remove_hook(self, modparent=True):
if self.parted_partition.type == parted.PARTITION_EXTENDED and \
len(self.disk.format.logical_partitions) > 0:
raise ValueError("Cannot remove extended partition %s. "
- "Logical partitions present." % self.name)
+ "Logical partitions present." % self.name)
self.disk.format.remove_partition(self.parted_partition)
@@ -505,8 +505,8 @@ def add_hook(self, new=True):
return
self.disk.format.add_partition(self.parted_partition.geometry.start,
- self.parted_partition.geometry.end,
- self.parted_partition.type)
+ self.parted_partition.geometry.end,
+ self.parted_partition.type)
# Look up the path by start sector to deal with automatic renumbering of
# logical partitions on msdos disklabels.
@@ -575,8 +575,8 @@ def _create(self):
""" Create the device. """
log_method_call(self, self.name, status=self.status)
self.disk.format.add_partition(self.parted_partition.geometry.start,
- self.parted_partition.geometry.end,
- self.parted_partition.type)
+ self.parted_partition.geometry.end,
+ self.parted_partition.type)
self._wipe()
try:
@@ -594,7 +594,7 @@ def _post_create(self):
partition = self.disk.format.parted_disk.getPartitionBySector(start)
log.debug("post-commit partition path is %s", getattr(partition,
- "path", None))
+ "path", None))
self.parted_partition = partition
if not self.is_extended:
# Ensure old metadata which lived in freespace so did not get
@@ -625,8 +625,8 @@ def _compute_resize(self, partition, newsize=None):
current_dev = current_geom.device
new_len = int(newsize // Size(current_dev.sectorSize))
new_geometry = parted.Geometry(device=current_dev,
- start=current_geom.start,
- length=new_len)
+ start=current_geom.start,
+ length=new_len)
# and align the end sector
if new_geometry.length < current_geom.length:
align = self.disk.format.end_alignment.alignUp
@@ -652,9 +652,9 @@ def resize(self):
(constraint, geometry) = self._compute_resize(partition)
parted_disk.setPartitionGeometry(partition=partition,
- constraint=constraint,
- start=geometry.start,
- end=geometry.end)
+ constraint=constraint,
+ start=geometry.start,
+ end=geometry.end)
self.disk.format.commit()
self.update_size()
@@ -690,9 +690,9 @@ def _destroy(self):
self.disk.original_format.commit()
except errors.DiskLabelCommitError:
self.disk.original_format.add_partition(
- self.parted_partition.geometry.start,
- self.parted_partition.geometry.end,
- self.parted_partition.type)
+ self.parted_partition.geometry.start,
+ self.parted_partition.geometry.end,
+ self.parted_partition.type)
self.parted_partition = self.disk.original_format.parted_disk.getPartitionByPath(self.path)
raise
@@ -851,7 +851,7 @@ def max_size(self):
@property
def resizable(self):
return super(PartitionDevice, self).resizable and \
- self.disk.type != 'dasd'
+ self.disk.type != 'dasd'
def check_size(self):
""" Check to make sure the size of the device is allowed by the
diff --git a/blivet/devices/raid.py b/blivet/devices/raid.py
index 85fa3a3..6f999d1 100644
--- a/blivet/devices/raid.py
+++ b/blivet/devices/raid.py
@@ -54,9 +54,9 @@ def _validate_raid_level(self, level, parent_diff=0):
num_members = len(self.members) + parent_diff # pylint: disable=no-member
if not self.exists and num_members < level.min_members:
message = P_(
- "RAID level %(raid_level)s requires that device have at least %(min_members)d member.",
- "RAID level %(raid_level)s requires that device have at least %(min_members)d members.",
- level.min_members
+ "RAID level %(raid_level)s requires that device have at least %(min_members)d member.",
+ "RAID level %(raid_level)s requires that device have at least %(min_members)d members.",
+ level.min_members
)
return message % {"raid_level": level, "min_members": level.min_members}
return None
diff --git a/blivet/devices/storage.py b/blivet/devices/storage.py
index 61df3e9..b394d2b 100644
--- a/blivet/devices/storage.py
+++ b/blivet/devices/storage.py
@@ -232,8 +232,8 @@ def _set_target_size(self, newsize):
self._target_size = newsize
target_size = property(lambda s: s._get_target_size(),
- lambda s, v: s._set_target_size(v),
- doc="Target size of this device")
+ lambda s, v: s._set_target_size(v),
+ doc="Target size of this device")
def __repr__(self):
s = Device.__repr__(self)
@@ -834,7 +834,7 @@ def type_external_dependencies(cls):
device type and of all superclass device types.
"""
return set(
- d for p in cls.__mro__ if issubclass(p, StorageDevice) for d in p._external_dependencies
+ d for p in cls.__mro__ if issubclass(p, StorageDevice) for d in p._external_dependencies
)
@classmethod
diff --git a/blivet/devicetree.py b/blivet/devicetree.py
index d1d022d..b8eb843 100644
--- a/blivet/devicetree.py
+++ b/blivet/devicetree.py
@@ -199,12 +199,12 @@ def _add_device(self, newdev, new=True):
# don't include "req%d" partition names
if ((newdev.type != "partition" or
not newdev.name.startswith("req")) and
- newdev.type != "btrfs volume" and
- newdev.name not in self.names):
+ newdev.type != "btrfs volume" and
+ newdev.name not in self.names):
self.names.append(newdev.name)
log.info("added %s %s (id %d) to device tree", newdev.type,
- newdev.name,
- newdev.id)
+ newdev.name,
+ newdev.id)
def _remove_device(self, dev, force=None, modparent=True):
""" Remove a device from the tree.
@@ -243,8 +243,8 @@ def _remove_device(self, dev, force=None, modparent=True):
if dev.name in self.names and getattr(dev, "complete", True):
self.names.remove(dev.name)
log.info("removed %s %s (id %d) from device tree", dev.type,
- dev.name,
- dev.id)
+ dev.name,
+ dev.id)
def recursive_remove(self, device, actions=True):
""" Remove a device after removing its dependent devices.
@@ -351,7 +351,7 @@ def cancel_action(self, action):
log.info("canceled action %s", action)
def find_actions(self, device=None, action_type=None, object_type=None,
- path=None, devid=None):
+ path=None, devid=None):
""" Find all actions that match all specified parameters.
A value of None for any of the keyword arguments indicates that any
@@ -424,7 +424,7 @@ def get_related_disks(self, disk):
"""
return set(d for dep in self.get_dependent_devices(disk, hidden=True)
- for d in dep.disks)
+ for d in dep.disks)
def hide(self, device):
""" Hide the specified device.
@@ -471,13 +471,13 @@ def hide(self, device):
# aggregate/container device (eg: lvm volume group).
disks = [device]
related_actions = [a for a in self._actions
- if a.device.depends_on(device)]
+ if a.device.depends_on(device)]
for related_device in (a.device for a in related_actions):
disks.extend(related_device.disks)
disks = set(disks)
cancel = [a for a in self._actions
- if set(a.device.disks).intersection(disks)]
+ if set(a.device.disks).intersection(disks)]
for action in reversed(cancel):
self.cancel_action(action)
@@ -519,8 +519,8 @@ def unhide(self, device):
not any(parent in self._hidden for parent in hidden.parents):
log.info("unhiding device %s %s (id %d)", hidden.type,
- hidden.name,
- hidden.id)
+ hidden.name,
+ hidden.id)
self._hidden.remove(hidden)
self._devices.append(hidden)
hidden.add_hook(new=False)
@@ -747,8 +747,8 @@ def get_device_by_name(self, name, incomplete=False, hidden=False):
if name:
devices = self._filter_devices(incomplete=incomplete, hidden=hidden)
result = next((d for d in devices if d.name == name or
- (isinstance(d, _LVM_DEVICE_CLASSES) and d.name == name.replace("--", "-"))),
- None)
+ (isinstance(d, _LVM_DEVICE_CLASSES) and d.name == name.replace("--", "-"))),
+ None)
log_method_return(self, result)
return result
@@ -773,8 +773,8 @@ def get_device_by_path(self, path, incomplete=False, hidden=False):
# the end. So that the search can prefer leaves to interior nodes
# the list that is searched is the reverse of the devices list.
result = next((d for d in reversed(list(devices)) if d.path == path or
- (isinstance(d, _LVM_DEVICE_CLASSES) and d.path == path.replace("--", "-"))),
- None)
+ (isinstance(d, _LVM_DEVICE_CLASSES) and d.path == path.replace("--", "-"))),
+ None)
log_method_return(self, result)
return result
@@ -925,14 +925,14 @@ def resolve_device(self, devspec, blkid_tab=None, crypt_tab=None, options=None):
# device-by-uuid
uuid = devspec.partition("=")[2]
if ((uuid.startswith('"') and uuid.endswith('"')) or
- (uuid.startswith("'") and uuid.endswith("'"))):
+ (uuid.startswith("'") and uuid.endswith("'"))):
uuid = uuid[1:-1]
device = self.uuids.get(uuid)
elif devspec.startswith("LABEL="):
# device-by-label
label = devspec.partition("=")[2]
if ((label.startswith('"') and label.endswith('"')) or
- (label.startswith("'") and label.endswith("'"))):
+ (label.startswith("'") and label.endswith("'"))):
label = label[1:-1]
device = self.labels.get(label)
elif re.match(r'(0x)?[A-Fa-f0-9]{2}(p\d+)?$', devspec):
@@ -1067,7 +1067,7 @@ def handle_nodev_filesystems(self):
continue
log.info("found nodev %s filesystem mounted at %s",
- fstype, mountpoint)
+ fstype, mountpoint)
# nodev filesystems require some special handling.
# For now, a lot of this is based on the idea that it's a losing
# battle to require the presence of an FS class for every type
diff --git a/blivet/fcoe.py b/blivet/fcoe.py
index c50a7b0..ed0b8b1 100644
--- a/blivet/fcoe.py
+++ b/blivet/fcoe.py
@@ -121,15 +121,15 @@ def add_san(self, nic, dcb=False, auto_vlan=True):
self._start_lldpad()
util.run_program(["dcbtool", "sc", nic, "dcb", "on"])
util.run_program(["dcbtool", "sc", nic, "app:fcoe",
- "e:1", "a:1", "w:1"])
+ "e:1", "a:1", "w:1"])
rc, out = util.run_program_and_capture_output(["fipvlan", "-c", "-s", "-f",
- "-fcoe", nic], stderr_to_stdout=True)
+ "-fcoe", nic], stderr_to_stdout=True)
else:
if auto_vlan:
# certain network configrations require the VLAN layer module:
util.run_program(["modprobe", "8021q"])
rc, out = util.run_program_and_capture_output(["fipvlan", '-c', '-s', '-f',
- "-fcoe", nic], stderr_to_stdout=True)
+ "-fcoe", nic], stderr_to_stdout=True)
else:
f = open("/sys/module/libfcoe/parameters/create", "w")
f.write(nic)
@@ -153,7 +153,7 @@ def write(self, root):
for nic, dcb, auto_vlan in self.nics:
fd = util.eintr_retry_call(os.open, root + "/etc/fcoe/cfg-" + nic,
- os.O_RDWR | os.O_CREAT)
+ os.O_RDWR | os.O_CREAT)
config = '# Created by anaconda\n'
config += '# Enable/Disable FCoE service at the Ethernet port\n'
config += 'FCOE_ENABLE="yes"\n'
diff --git a/blivet/formats/__init__.py b/blivet/formats/__init__.py
index 1a5e14b..af6c828 100644
--- a/blivet/formats/__init__.py
+++ b/blivet/formats/__init__.py
@@ -51,7 +51,7 @@ def register_device_format(fmt_class):
device_formats[fmt_class._type] = fmt_class
log.debug("registered device format class %s as %s", fmt_class.__name__,
- fmt_class._type)
+ fmt_class._type)
default_fstypes = ("ext4", "ext3", "ext2")
@@ -97,7 +97,7 @@ def get_format(fmt_type, *args, **kwargs):
fmt._name = fmt_type
log.debug("getFormat('%s') returning %s instance with object id %d",
- fmt_type, fmt.__class__.__name__, fmt.id)
+ fmt_type, fmt.__class__.__name__, fmt.id)
return fmt
@@ -302,9 +302,9 @@ def _get_options(self):
return self._options
options = property(
- lambda s: s._get_options(),
- lambda s, v: s._set_options(v),
- doc="fstab entry option string"
+ lambda s: s._get_options(),
+ lambda s, v: s._set_options(v),
+ doc="fstab entry option string"
)
def _set_create_options(self, options):
diff --git a/blivet/formats/biosboot.py b/blivet/formats/biosboot.py
index 6fa04b1..34001cc 100644
--- a/blivet/formats/biosboot.py
+++ b/blivet/formats/biosboot.py
@@ -62,4 +62,3 @@ def supported(self):
return super(BIOSBoot, self).supported and isinstance(platform.platform, platform.X86)
register_device_format(BIOSBoot)
-
diff --git a/blivet/formats/disklabel.py b/blivet/formats/disklabel.py
index f10edbe..9ea89a3 100644
--- a/blivet/formats/disklabel.py
+++ b/blivet/formats/disklabel.py
@@ -82,8 +82,8 @@ def __deepcopy__(self, memo):
We can't do copy.deepcopy on parted objects, which is okay.
"""
return util.variable_copy(self, memo,
- shallow=('_parted_device', '_optimal_alignment', '_minimal_alignment',),
- duplicate=('_parted_disk', '_orig_parted_disk'))
+ shallow=('_parted_device', '_optimal_alignment', '_minimal_alignment',),
+ duplicate=('_parted_disk', '_orig_parted_disk'))
def __repr__(self):
s = DeviceFormat.__repr__(self)
@@ -299,7 +299,7 @@ def add_partition(self, start, end, ptype=None):
constraint = parted.Constraint(exactGeom=geometry)
self.parted_disk.addPartition(partition=new_partition,
- constraint=constraint)
+ constraint=constraint)
def remove_partition(self, partition):
""" Remove a partition from the disklabel.
@@ -359,7 +359,7 @@ def _get_disk_label_alignment(self):
self._disk_label_alignment = self.parted_disk.partitionAlignment
except _ped.CreateException:
self._disk_label_alignment = parted.Alignment(offset=0,
- grainSize=1)
+ grainSize=1)
return self._disk_label_alignment
@@ -457,7 +457,7 @@ def get_end_alignment(self, size=None, alignment=None):
alignment = self.get_alignment(size=size)
return parted.Alignment(offset=alignment.offset - 1,
- grainSize=alignment.grainSize)
+ grainSize=alignment.grainSize)
@property
def alignment(self):
diff --git a/blivet/formats/dmraid.py b/blivet/formats/dmraid.py
index 13a3084..2ba9dcf 100644
--- a/blivet/formats/dmraid.py
+++ b/blivet/formats/dmraid.py
@@ -44,11 +44,11 @@ class DMRaidMember(DeviceFormat):
# One problem that presents is the possibility of someone passing
# a dmraid member to the MDRaidArrayDevice constructor.
_udev_types = ["adaptec_raid_member", "ddf_raid_member",
- "hpt37x_raid_member", "hpt45x_raid_member",
- "isw_raid_member",
- "jmicron_raid_member", "lsi_mega_raid_member",
- "nvidia_raid_member", "promise_fasttrack_raid_member",
- "silicon_medley_raid_member", "via_raid_member"]
+ "hpt37x_raid_member", "hpt45x_raid_member",
+ "isw_raid_member",
+ "jmicron_raid_member", "lsi_mega_raid_member",
+ "nvidia_raid_member", "promise_fasttrack_raid_member",
+ "silicon_medley_raid_member", "via_raid_member"]
_supported = True # is supported
_packages = ["dmraid"] # required packages
_hidden = True # hide devices with this formatting?
@@ -103,4 +103,3 @@ def destroy(self, **kwargs):
DMRaidMember._udev_types = []
register_device_format(DMRaidMember)
-
diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py
index ce31206..d386a21 100644
--- a/blivet/formats/fs.py
+++ b/blivet/formats/fs.py
@@ -142,7 +142,7 @@ def __init__(self, **kwargs):
self.update_size_info()
except FSError:
log.warning("%s filesystem on %s needs repair", self.type,
- self.device)
+ self.device)
self._target_size = self._size
@@ -214,7 +214,7 @@ def label_format_ok(self, label):
return label is None or (self._labelfs is not None and self._labelfs.label_format_ok(label))
label = property(lambda s: s._get_label(), lambda s, l: s._set_label(l),
- doc="this filesystem's label")
+ doc="this filesystem's label")
def _set_target_size(self, newsize):
""" Set the target size for this filesystem.
@@ -243,14 +243,14 @@ def _get_target_size(self):
return self._target_size
target_size = property(_get_target_size, _set_target_size,
- doc="Target size for this filesystem")
+ doc="Target size for this filesystem")
def _get_size(self):
""" Get this filesystem's size. """
return self.target_size if self.resizable else self._size
size = property(_get_size, doc="This filesystem's size, accounting "
- "for pending changes")
+ "for pending changes")
def update_size_info(self):
""" Update this filesystem's current and minimum size (for resize). """
@@ -431,7 +431,7 @@ def do_resize(self):
# contains it. To round up would risk quietly setting a target size too
# large for the device to hold.
rounded = self.target_size.round_to_nearest(self._resize.unit,
- rounding=ROUND_DOWN)
+ rounding=ROUND_DOWN)
# 1. target size was between the min size and max size values prior to
# rounding (see _set_target_size)
@@ -524,7 +524,7 @@ def system_mountpoint(self):
# It is possible to have multiple mountpoints, return the last one
try:
return mounts_cache.get_mountpoints(self.device,
- getattr(self, "subvolspec", None))[-1]
+ getattr(self, "subvolspec", None))[-1]
except IndexError:
return None
@@ -783,8 +783,8 @@ def sync(self, root='/'):
available under the install root.
"""
if not self.status or not self.system_mountpoint or \
- not self.system_mountpoint.startswith(root) or \
- not self._sync.available:
+ not self.system_mountpoint.startswith(root) or \
+ not self._sync.available:
return
try:
diff --git a/blivet/formats/luks.py b/blivet/formats/luks.py
index 5b9599d..4d9347d 100644
--- a/blivet/formats/luks.py
+++ b/blivet/formats/luks.py
@@ -273,4 +273,3 @@ def escrow(self, directory, backup_passphrase):
register_device_format(LUKS)
-
diff --git a/blivet/formats/lvmpv.py b/blivet/formats/lvmpv.py
index 471e681..65bab91 100644
--- a/blivet/formats/lvmpv.py
+++ b/blivet/formats/lvmpv.py
@@ -144,4 +144,3 @@ def status(self):
os.path.isdir("/dev/%s" % self.vg_name))
register_device_format(LVMPhysicalVolume)
-
diff --git a/blivet/formats/mdraid.py b/blivet/formats/mdraid.py
index 4f499f9..9212c15 100644
--- a/blivet/formats/mdraid.py
+++ b/blivet/formats/mdraid.py
@@ -111,4 +111,3 @@ def hidden(self):
MDRaidMember._udev_types.append("isw_raid_member")
register_device_format(MDRaidMember)
-
diff --git a/blivet/formats/multipath.py b/blivet/formats/multipath.py
index 0b2d2e2..064b171 100644
--- a/blivet/formats/multipath.py
+++ b/blivet/formats/multipath.py
@@ -81,4 +81,3 @@ def destroy(self, **kwargs):
raise MultipathMemberError("destruction of multipath members is non-sense")
register_device_format(MultipathMember)
-
diff --git a/blivet/formats/prepboot.py b/blivet/formats/prepboot.py
index 249c2b2..4d80975 100644
--- a/blivet/formats/prepboot.py
+++ b/blivet/formats/prepboot.py
@@ -100,4 +100,3 @@ def supported(self):
return super(PPCPRePBoot, self).supported and isinstance(platform.platform, platform.IPSeriesPPC)
register_device_format(PPCPRePBoot)
-
diff --git a/blivet/formats/swap.py b/blivet/formats/swap.py
index c378c5e..ef4da08 100644
--- a/blivet/formats/swap.py
+++ b/blivet/formats/swap.py
@@ -108,7 +108,7 @@ def label_format_ok(self, label):
return True
label = property(lambda s: s._get_label(), lambda s, l: s._set_label(l),
- doc="the label for this swap space")
+ doc="the label for this swap space")
def _set_priority(self, priority):
# pylint: disable=attribute-defined-outside-init
diff --git a/blivet/iscsi.py b/blivet/iscsi.py
index 72a2f50..3a14537 100644
--- a/blivet/iscsi.py
+++ b/blivet/iscsi.py
@@ -110,10 +110,10 @@ def _call_discover_targets(con_write, con_recv, ipaddr, port, authinfo):
# TODO: change libiscsi.node to pickable object
for node in found_nodes:
nodes.append({'name': node.name,
- 'tpgt': node.tpgt,
- 'address': node.address,
- 'port': node.port,
- 'iface': node.iface})
+ 'tpgt': node.tpgt,
+ 'address': node.address,
+ 'port': node.port,
+ 'iface': node.iface})
con_write.send((True, nodes))
@@ -222,7 +222,7 @@ def _start_ibft(self):
try:
node.login()
log.info("iscsi IBFT: logged into %s at %s:%s through %s",
- node.name, node.address, node.port, node.iface)
+ node.name, node.address, node.port, node.iface)
self.ibft_nodes.append(node)
except IOError as e:
log.error("Could not log into ibft iscsi target %s: %s",
@@ -285,7 +285,7 @@ def startup(self):
self.initiator_set = True
for fulldir in (os.path.join("/var/lib/iscsi", d) for d in
- ['ifaces', 'isns', 'nodes', 'send_targets', 'slp', 'static']):
+ ['ifaces', 'isns', 'nodes', 'send_targets', 'slp', 'static']):
if not os.path.isdir(fulldir):
os.makedirs(fulldir, 0o755)
@@ -295,7 +295,7 @@ def startup(self):
# not present in iscsi-initiator-utils for Fedora.
try:
iscsiuio = util.find_program_in_path('iscsiuio',
- raise_on_error=True)
+ raise_on_error=True)
except RuntimeError:
log.info("iscsi: iscsiuio not found.")
else:
@@ -388,7 +388,7 @@ def discover(self, ipaddr, port="3260", username=None, password=None,
if not logged_in]
def log_into_node(self, node, username=None, password=None,
- r_username=None, r_password=None):
+ r_username=None, r_password=None):
"""
Raises IOError.
"""
@@ -407,7 +407,7 @@ def log_into_node(self, node, username=None, password=None,
node.login()
rc = True
log.info("iSCSI: logged into %s at %s:%s through %s",
- node.name, node.address, node.port, node.iface)
+ node.name, node.address, node.port, node.iface)
if not self._mark_node_active(node):
log.error("iSCSI: node not found among discovered")
except (IOError, ValueError) as e:
@@ -417,9 +417,9 @@ def log_into_node(self, node, username=None, password=None,
return (rc, msg)
def add_target(self, ipaddr, port="3260", user=None, pw=None,
- user_in=None, pw_in=None, target=None, iface=None,
- discover_user=None, discover_pw=None,
- discover_user_in=None, discover_pw_in=None):
+ user_in=None, pw_in=None, target=None, iface=None,
+ discover_user=None, discover_pw=None,
+ discover_user_in=None, discover_pw_in=None):
"""
Connect to iSCSI server specified by IP address and port
and add all targets found on the server and authenticate if necessary.
@@ -468,7 +468,7 @@ def add_target(self, ipaddr, port="3260", user=None, pw=None,
node_net_iface = self.ifaces.get(node.iface, node.iface)
if iface != node_net_iface:
log.debug("iscsi: skipping logging to iscsi node '%s' via %s",
- node.name, node_net_iface)
+ node.name, node_net_iface)
continue
found = found + 1
diff --git a/blivet/osinstall.py b/blivet/osinstall.py
index a15880a..c57168b 100644
--- a/blivet/osinstall.py
+++ b/blivet/osinstall.py
@@ -187,9 +187,9 @@ def parse_fstab(devicetree, chroot=None):
# find device in the tree
device = devicetree.resolve_device(devspec,
- crypt_tab=crypt_tab,
- blkid_tab=blkid_tab,
- options=options)
+ crypt_tab=crypt_tab,
+ blkid_tab=blkid_tab,
+ options=options)
if device is None:
continue
@@ -264,10 +264,10 @@ def _find_existing_installations(devicetree):
name = _("Unknown Linux")
elif "linux" in product.lower():
name = _("%(product)s %(version)s for %(arch)s") % \
- {"product": product, "version": version, "arch": architecture}
+ {"product": product, "version": version, "arch": architecture}
else:
name = _("%(product)s Linux %(version)s for %(arch)s") % \
- {"product": product, "version": version, "arch": architecture}
+ {"product": product, "version": version, "arch": architecture}
(mounts, swaps) = parse_fstab(devicetree, chroot=get_sysroot())
util.umount(mountpoint=get_sysroot())
@@ -311,8 +311,8 @@ def sysfs(self):
def dev(self):
if not self._dev:
self._dev = DirectoryDevice("/dev",
- fmt=get_format("bind", device="/dev", mountpoint="/dev", exists=True),
- exists=True)
+ fmt=get_format("bind", device="/dev", mountpoint="/dev", exists=True),
+ exists=True)
return self._dev
@@ -356,8 +356,8 @@ def efivars(self):
def run(self):
if not self._run:
self._run = DirectoryDevice("/run",
- fmt=get_format("bind", device="/run", mountpoint="/run", exists=True),
- exists=True)
+ fmt=get_format("bind", device="/run", mountpoint="/run", exists=True),
+ exists=True)
return self._run
@@ -390,9 +390,9 @@ def _parse_one_line(self, devspec, mountpoint, fstype, options, _dump="0", _pass
# find device in the tree
device = self.devicetree.resolve_device(devspec,
- crypt_tab=self.crypt_tab,
- blkid_tab=self.blkid_tab,
- options=options)
+ crypt_tab=self.crypt_tab,
+ blkid_tab=self.blkid_tab,
+ options=options)
if device:
# fall through to the bottom of this block
@@ -404,15 +404,15 @@ def _parse_one_line(self, devspec, mountpoint, fstype, options, _dump="0", _pass
# NFS -- preserve but otherwise ignore
device = NFSDevice(devspec,
fmt=get_format(fstype,
- exists=True,
- device=devspec))
+ 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),
+ device=devspec,
+ exists=True),
exists=True)
elif fstype == "bind" or "bind" in options:
# bind mount... set fstype so later comparison won't
@@ -426,8 +426,8 @@ def _parse_one_line(self, devspec, mountpoint, fstype, options, _dump="0", _pass
parents = get_containing_device(devspec, self.devicetree)
device = DirectoryDevice(devspec, parents=parents, exists=True)
device.format = get_format("bind",
- device=device.path,
- exists=True)
+ 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
@@ -442,7 +442,7 @@ def _parse_one_line(self, devspec, mountpoint, fstype, options, _dump="0", _pass
if device is None:
log.error("failed to resolve %s (%s) from fstab", devspec,
- fstype)
+ fstype)
raise UnrecognizedFSTabEntryError()
device.setup()
@@ -672,7 +672,7 @@ def create_swap_file(self, device, size):
basedir = os.path.normpath("%s/%s" % (get_target_physical_root(),
device.format.mountpoint))
while os.path.exists("%s/%s" % (basedir, filename)) or \
- self.devicetree.get_device_by_name(filename):
+ self.devicetree.get_device_by_name(filename):
count += 1
filename = "/SWAP-%d" % count
@@ -838,8 +838,8 @@ def fstab(self):
options = device.format.options
if not mountpoint:
log.warning("%s filesystem on %s has no mountpoint",
- fstype,
- device.path)
+ fstype,
+ device.path)
continue
options = options or "defaults"
@@ -1022,7 +1022,7 @@ def parse(self, chroot=""):
# resolve devspec to a device in the tree
device = self.devicetree.resolve_device(devspec,
- blkid_tab=self.blkid_tab)
+ blkid_tab=self.blkid_tab)
if device:
self.mappings[name] = {"device": device,
"keyfile": keyfile,
@@ -1045,8 +1045,8 @@ def populate(self):
options = device.format.options or ""
self.mappings[device.format.map_name] = {"device": device,
- "keyfile": key_file,
- "options": options}
+ "keyfile": key_file,
+ "options": options}
def crypttab(self):
""" Write out /etc/crypttab """
@@ -1128,7 +1128,7 @@ def turn_on_filesystems(storage, mount_only=False, callbacks=None):
def write_escrow_packets(storage):
escrow_devices = [d for d in storage.devices if d.format.type == 'luks' and
- d.format.escrow_cert]
+ d.format.escrow_cert]
if not escrow_devices:
return
@@ -1209,8 +1209,8 @@ def mount_existing_system(fsset, root_device, read_only=None):
else:
root_device.setup()
root_device.format.mount(chroot=root_path,
- mountpoint="/",
- options=read_only)
+ mountpoint="/",
+ options=read_only)
fsset.parse_fstab()
fsset.mount_filesystems(root_path=root_path, read_only=read_only, skip_root=True)
diff --git a/blivet/partitioning.py b/blivet/partitioning.py
index f9f5736..1371203 100644
--- a/blivet/partitioning.py
+++ b/blivet/partitioning.py
@@ -172,8 +172,8 @@ def get_next_partition_type(disk, no_primary=None):
def get_best_free_space_region(disk, part_type, req_size, start=None,
- boot=None, best_free=None, grow=None,
- alignment=None):
+ boot=None, best_free=None, grow=None,
+ alignment=None):
""" Return the "best" free region on the specified disk.
For non-boot partitions, we return the largest free region on the
@@ -219,7 +219,7 @@ def get_best_free_space_region(disk, part_type, req_size, start=None,
if start is not None and \
not alignment.isAligned(free_geom, free_geom.start):
log.debug("aligning start sector of region %d-%d", free_geom.start,
- free_geom.end)
+ free_geom.end)
try:
aligned_start = alignment.alignUp(free_geom, free_geom.start)
except ArithmeticError:
@@ -238,7 +238,7 @@ def get_best_free_space_region(disk, part_type, req_size, start=None,
end=free_geom.end)
log.debug("checking %d-%d (%s)", free_geom.start, free_geom.end,
- Size(free_geom.getLength(unit="B")))
+ Size(free_geom.getLength(unit="B")))
if start is not None and not free_geom.containsSector(start):
log.debug("free region does not contain requested start sector")
continue
@@ -246,7 +246,7 @@ def get_best_free_space_region(disk, part_type, req_size, start=None,
if extended:
in_extended = extended.geometry.contains(free_geom)
if ((in_extended and part_type == parted.PARTITION_NORMAL) or
- (not in_extended and part_type == parted.PARTITION_LOGICAL)):
+ (not in_extended and part_type == parted.PARTITION_LOGICAL)):
log.debug("free region not suitable for request")
continue
@@ -260,12 +260,12 @@ def get_best_free_space_region(disk, part_type, req_size, start=None,
req_end = free_start + req_size
if req_end > max_boot:
log.debug("free range position would place boot req above %s",
- max_boot)
+ max_boot)
continue
log.debug("current free range is %d-%d (%s)", free_geom.start,
- free_geom.end,
- Size(free_geom.getLength(unit="B")))
+ free_geom.end,
+ Size(free_geom.getLength(unit="B")))
free_size = Size(free_geom.getLength(unit="B"))
# For boot partitions, we want the first suitable region we find.
@@ -330,8 +330,8 @@ def remove_new_partitions(disks, remove, all_partitions):
:rtype: NoneType
"""
log.debug("removing all non-preexisting partitions %s from disk(s) %s",
- ["%s(id %d)" % (p.name, p.id) for p in remove],
- [d.name for d in disks])
+ ["%s(id %d)" % (p.name, p.id) for p in remove],
+ [d.name for d in disks])
for part in remove:
if part.parted_partition and part.disk in disks:
if part.exists:
@@ -351,7 +351,7 @@ def remove_new_partitions(disks, remove, all_partitions):
extended = disk.format.extended_partition
if extended and not disk.format.logical_partitions and \
(flags.installer_mode or
- extended not in (p.parted_partition for p in all_partitions)):
+ extended not in (p.parted_partition for p in all_partitions)):
log.debug("removing empty extended partition from %s", disk.name)
disk.format.parted_disk.removePartition(extended)
@@ -443,7 +443,7 @@ def add_partition(disklabel, free, part_type, size, start=None, end=None):
geometry=new_geom)
constraint = parted.Constraint(exactGeom=new_geom)
disklabel.parted_disk.addPartition(partition=partition,
- constraint=constraint)
+ constraint=constraint)
return partition
@@ -609,12 +609,12 @@ def do_partitioning(storage):
problem = part.check_size()
if problem < 0:
raise PartitioningError(_("partition is too small for %(format)s formatting "
- "(allowable size is %(min_size)s to %(max_size)s)")
+ "(allowable size is %(min_size)s to %(max_size)s)")
% {"format": part.format.name, "min_size": part.format.min_size,
"max_size": part.format.max_size})
elif problem > 0:
raise PartitioningError(_("partition is too large for %(format)s formatting "
- "(allowable size is %(min_size)s to %(max_size)s)")
+ "(allowable size is %(min_size)s to %(max_size)s)")
% {"format": part.format.name, "min_size": part.format.min_size,
"max_size": part.format.max_size})
@@ -651,8 +651,8 @@ def allocate_partitions(storage, disks, partitions, freespace):
and parents attributes set once they have been allocated.
"""
log.debug("allocatePartitions: disks=%s ; partitions=%s",
- [d.name for d in disks],
- ["%s(id %d)" % (p.name, p.id) for p in partitions])
+ [d.name for d in disks],
+ ["%s(id %d)" % (p.name, p.id) for p in partitions])
new_partitions = [p for p in partitions if not p.exists]
new_partitions.sort(key=_partition_compare_key)
@@ -693,11 +693,11 @@ def allocate_partitions(storage, disks, partitions, freespace):
log.debug("allocating partition: %s ; id: %d ; disks: %s ;\n"
"boot: %s ; primary: %s ; size: %s ; grow: %s ; "
"max_size: %s ; start: %s ; end: %s", _part.name, _part.id,
- [d.name for d in req_disks],
- boot, _part.req_primary,
- _part.req_size, _part.req_grow,
- _part.req_max_size, _part.req_start_sector,
- _part.req_end_sector)
+ [d.name for d in req_disks],
+ boot, _part.req_primary,
+ _part.req_size, _part.req_grow,
+ _part.req_max_size, _part.req_start_sector,
+ _part.req_end_sector)
free = None
use_disk = None
part_type = None
@@ -736,7 +736,7 @@ def allocate_partitions(storage, disks, partitions, freespace):
if _part.req_primary and new_part_type != parted.PARTITION_NORMAL:
if (disklabel.parted_disk.primaryPartitionCount <
- disklabel.parted_disk.maxPrimaryPartitionCount):
+ disklabel.parted_disk.maxPrimaryPartitionCount):
# don't fail to create a primary if there are only three
# primary partitions on the disk (#505269)
new_part_type = parted.PARTITION_NORMAL
@@ -745,33 +745,33 @@ def allocate_partitions(storage, disks, partitions, freespace):
log.debug("no primary slots available on %s", _disk.name)
continue
elif _part.req_part_type is not None and \
- new_part_type != _part.req_part_type:
+ new_part_type != _part.req_part_type:
new_part_type = _part.req_part_type
best = get_best_free_space_region(disklabel.parted_disk,
- new_part_type,
- req_size,
- start=_part.req_start_sector,
- best_free=current_free,
- boot=boot,
- grow=_part.req_grow,
- alignment=alignment)
+ new_part_type,
+ req_size,
+ start=_part.req_start_sector,
+ best_free=current_free,
+ boot=boot,
+ grow=_part.req_grow,
+ alignment=alignment)
if best == free and not _part.req_primary and \
new_part_type == parted.PARTITION_NORMAL:
# see if we can do better with a logical partition
log.debug("not enough free space for primary -- trying logical")
new_part_type = get_next_partition_type(disklabel.parted_disk,
- no_primary=True)
+ no_primary=True)
if new_part_type:
best = get_best_free_space_region(disklabel.parted_disk,
- new_part_type,
- req_size,
- start=_part.req_start_sector,
- best_free=current_free,
- boot=boot,
- grow=_part.req_grow,
- alignment=alignment)
+ new_part_type,
+ req_size,
+ start=_part.req_start_sector,
+ best_free=current_free,
+ boot=boot,
+ grow=_part.req_grow,
+ alignment=alignment)
if best and free != best:
update = True
@@ -798,17 +798,17 @@ def allocate_partitions(storage, disks, partitions, freespace):
if new_part_type == parted.PARTITION_EXTENDED and \
new_part_type != _part.req_part_type:
add_partition(disklabel, best, new_part_type,
- None)
+ None)
_part_type = parted.PARTITION_LOGICAL
_free = get_best_free_space_region(disklabel.parted_disk,
- _part_type,
- req_size,
- start=_part.req_start_sector,
- boot=boot,
- grow=_part.req_grow,
- alignment=alignment)
+ _part_type,
+ req_size,
+ start=_part.req_start_sector,
+ boot=boot,
+ grow=_part.req_grow,
+ alignment=alignment)
if not _free:
log.info("not enough space after adding "
"extended partition for growth test")
@@ -821,14 +821,14 @@ def allocate_partitions(storage, disks, partitions, freespace):
temp_part = None
try:
temp_part = add_partition(disklabel,
- _free,
- _part_type,
- req_size,
- _part.req_start_sector,
- _part.req_end_sector)
+ _free,
+ _part_type,
+ req_size,
+ _part.req_start_sector,
+ _part.req_end_sector)
except ArithmeticError as e:
log.debug("failed to allocate aligned partition "
- "for growth test")
+ "for growth test")
continue
_part.parted_partition = temp_part
@@ -836,7 +836,7 @@ def allocate_partitions(storage, disks, partitions, freespace):
temp_parts.append(_part)
chunks = get_disk_chunks(all_disks[disk_path],
- temp_parts, freespace)
+ temp_parts, freespace)
# grow all growable requests
disk_growth = 0 # in sectors
@@ -853,13 +853,13 @@ def allocate_partitions(storage, disks, partitions, freespace):
req.device.name,
req.growth,
sectors_to_size(req.growth,
- disk_sector_size),
+ disk_sector_size),
sectors_to_size(req.growth + req.base,
- disk_sector_size))
+ disk_sector_size))
log.debug("disk %s growth: %d (%s)",
- disk_path, disk_growth,
- sectors_to_size(disk_growth,
- disk_sector_size))
+ disk_path, disk_growth,
+ sectors_to_size(disk_growth,
+ disk_sector_size))
if temp_part:
disklabel.parted_disk.removePartition(temp_part)
@@ -876,7 +876,7 @@ def allocate_partitions(storage, disks, partitions, freespace):
# choice yielded greater total growth
if free is not None and new_growth <= growth:
log.debug("keeping old free: %d <= %d", new_growth,
- growth)
+ growth)
update = False
else:
growth = new_growth
@@ -885,12 +885,12 @@ def allocate_partitions(storage, disks, partitions, freespace):
# now we know we are choosing a new free space,
# so update the disk and part type
log.debug("updating use_disk to %s, type: %s",
- _disk.name, new_part_type)
+ _disk.name, new_part_type)
part_type = new_part_type
use_disk = _disk
log.debug("new free: %d-%d / %s", best.start,
- best.end,
- Size(best.getLength(unit="B")))
+ best.end,
+ Size(best.getLength(unit="B")))
log.debug("new free allows for %d sectors of growth", growth)
free = best
@@ -924,26 +924,26 @@ def allocate_partitions(storage, disks, partitions, freespace):
# recalculate freespace
log.debug("recalculating free space")
free = get_best_free_space_region(disklabel.parted_disk,
- part_type,
- aligned_size,
- start=_part.req_start_sector,
- boot=boot,
- grow=_part.req_grow,
- alignment=disklabel.alignment)
+ part_type,
+ aligned_size,
+ start=_part.req_start_sector,
+ boot=boot,
+ grow=_part.req_grow,
+ alignment=disklabel.alignment)
if not free:
raise PartitioningError(_("not enough free space after "
- "creating extended partition"))
+ "creating extended partition"))
try:
partition = add_partition(disklabel, free, part_type, aligned_size,
- _part.req_start_sector, _part.req_end_sector)
+ _part.req_start_sector, _part.req_end_sector)
except ArithmeticError:
raise PartitioningError(_("failed to allocate aligned partition"))
log.debug("created partition %s of %s and added it to %s",
- partition.getDeviceNodeName(),
- Size(partition.getLength(unit="B")),
- disklabel.device)
+ partition.getDeviceNodeName(),
+ Size(partition.getLength(unit="B")),
+ disklabel.device)
# this one sets the name
_part.parted_partition = partition
@@ -971,7 +971,7 @@ def __init__(self, device):
self.growth = 0 # growth in sectors
self.max_growth = 0 # max growth in sectors
self.done = not getattr(device, "req_grow", True) # can we grow this
- # request more?
+ # request more?
self.base = 0 # base sectors
@property
@@ -1017,8 +1017,8 @@ def __init__(self, partition):
if partition.req_grow:
limits = [l for l in [size_to_sectors(partition.req_max_size, sector_size),
- size_to_sectors(partition.format.max_size, sector_size),
- partition.parted_partition.disk.maxPartitionLength] if l > 0]
+ size_to_sectors(partition.format.max_size, sector_size),
+ partition.parted_partition.disk.maxPartitionLength] if l > 0]
if limits:
max_sectors = min(limits)
@@ -1043,8 +1043,8 @@ def __init__(self, lv):
if lv.req_grow:
limits = [int(l // lv.vg.pe_size) for l in
- (lv.vg.align(lv.req_max_size),
- lv.vg.align(lv.format.max_size)) if l > Size(0)]
+ (lv.vg.align(lv.req_max_size),
+ lv.vg.align(lv.format.max_size)) if l > Size(0)]
if limits:
max_units = min(limits)
@@ -1079,7 +1079,7 @@ def __init__(self, length, requests=None):
self.length = length
self.pool = length # free unit count
self.base = 0 # sum of growable requests' base
- # sizes
+ # sizes
self.requests = [] # list of Request instances
if isinstance(requests, list):
for req in requests:
@@ -1136,7 +1136,7 @@ def reclaim(self, request, amount):
log.debug("reclaim: %s %d (%s)", request, amount, self.length_to_size(amount))
if request.growth < amount:
log.error("tried to reclaim %d from request with %d of growth",
- amount, request.growth)
+ amount, request.growth)
raise ValueError(_("cannot reclaim more than request has grown"))
request.growth -= amount
@@ -1195,8 +1195,8 @@ def trim_over_grown_request(self, req, base=None):
# we've grown beyond the maximum. put some back.
extra = req.growth - max_growth
log.debug("taking back %d (%s) from %d (%s)",
- extra, self.length_to_size(extra),
- req.device.id, req.device.name)
+ extra, self.length_to_size(extra),
+ req.device.id, req.device.name)
self.pool += extra
req.growth = max_growth
@@ -1244,7 +1244,7 @@ def grow_requests(self, uniform=False):
growth = int(last_pool / self.remaining)
log.debug("%d requests and %s (%s) left in chunk",
- self.remaining, self.pool, self.length_to_size(self.pool))
+ self.remaining, self.pool, self.length_to_size(self.pool))
for p in self.requests:
if p.done or p in self.skip_list:
continue
@@ -1259,14 +1259,14 @@ def grow_requests(self, uniform=False):
p.growth += growth
self.pool -= growth
log.debug("adding %s (%s) to %d (%s)",
- growth, self.length_to_size(growth),
- p.device.id, p.device.name)
+ growth, self.length_to_size(growth),
+ p.device.id, p.device.name)
new_base = self.trim_over_grown_request(p, base=new_base)
log.debug("new grow amount for request %d (%s) is %s "
"units, or %s",
- p.device.id, p.device.name, p.growth,
- self.length_to_size(p.growth))
+ p.device.id, p.device.name, p.growth,
+ self.length_to_size(p.growth))
if self.pool:
# allocate any leftovers in pool to the first partition
@@ -1279,14 +1279,14 @@ def grow_requests(self, uniform=False):
p.growth += growth
self.pool = 0
log.debug("adding %s (%s) to %d (%s)",
- growth, self.length_to_size(growth),
- p.device.id, p.device.name)
+ growth, self.length_to_size(growth),
+ p.device.id, p.device.name)
self.trim_over_grown_request(p)
log.debug("new grow amount for request %d (%s) is %s "
"units, or %s",
- p.device.id, p.device.name, p.growth,
- self.length_to_size(p.growth))
+ p.device.id, p.device.name, p.growth,
+ self.length_to_size(p.growth))
if self.pool == 0:
break
@@ -1352,7 +1352,7 @@ def add_request(self, req):
"""
if not isinstance(req, PartitionRequest):
raise ValueError(_("DiskChunk requests must be of type "
- "PartitionRequest"))
+ "PartitionRequest"))
if not self.requests:
# when adding the first request to the chunk, adjust the pool
@@ -1365,7 +1365,7 @@ def add_request(self, req):
# cannot continue
log.error("chunk start sector is beyond disklabel maximum")
raise PartitioningError(_("partitions allocated outside "
- "disklabel limits"))
+ "disklabel limits"))
new_pool = chunk_end - self.geometry.start + 1
if new_pool != self.pool:
@@ -1450,7 +1450,7 @@ def add_request(self, req):
"""
if not isinstance(req, LVRequest):
raise ValueError(_("VGChunk requests must be of type "
- "LVRequest"))
+ "LVRequest"))
super(VGChunk, self).add_request(req)
@@ -1579,7 +1579,7 @@ def __init__(self, devices, size):
def allocate(self, amount):
log.debug("allocating %d to TotalSizeSet with %d/%d (%d needed)",
- amount, self.allocated, self.size, self.needed)
+ amount, self.allocated, self.size, self.needed)
self.allocated += amount
@property
@@ -1588,7 +1588,7 @@ def needed(self):
def deallocate(self, amount):
log.debug("deallocating %d from TotalSizeSet with %d/%d (%d needed)",
- amount, self.allocated, self.size, self.needed)
+ amount, self.allocated, self.size, self.needed)
self.allocated -= amount
@@ -1640,7 +1640,7 @@ def manage_size_sets(size_sets, chunks):
# TotalSizeSet members are trimmed to achieve the requested
# total size
log.debug("set: %s %d/%d", [d.name for d in ss.devices],
- ss.allocated, ss.size)
+ ss.allocated, ss.size)
for device in ss.devices:
request = requests_by_device[device]
@@ -1730,8 +1730,8 @@ def grow_partitions(disks, partitions, free, size_sets=None):
:returns: :const:`None`
"""
log.debug("growPartitions: disks=%s, partitions=%s",
- [d.name for d in disks],
- ["%s(id %d)" % (p.name, p.id) for p in partitions])
+ [d.name for d in disks],
+ ["%s(id %d)" % (p.name, p.id) for p in partitions])
all_growable = [p for p in partitions if p.req_grow]
if not all_growable:
log.debug("no growable partitions")
@@ -1797,7 +1797,7 @@ def grow_partitions(disks, partitions, free, size_sets=None):
for p in chunk.requests:
ptype = p.device.parted_partition.type
log.debug("partition %s (%d): %s", p.device.name,
- p.device.id, ptype)
+ p.device.id, ptype)
if ptype == parted.PARTITION_EXTENDED:
continue
@@ -1818,7 +1818,7 @@ def grow_partitions(disks, partitions, free, size_sets=None):
start=start,
end=end)
log.debug("new geometry for %s: %s", p.device.name,
- new_geometry)
+ new_geometry)
start = end + 1
new_partition = parted.Partition(disk=disklabel.parted_disk,
type=ptype,
@@ -1827,7 +1827,7 @@ def grow_partitions(disks, partitions, free, size_sets=None):
# remove all new partitions from this chunk
remove_new_partitions([disk], [r.device for r in chunk.requests],
- partitions)
+ partitions)
log.debug("back from remove_new_partitions")
# adjust the extended partition as needed
@@ -1871,10 +1871,10 @@ def grow_partitions(disks, partitions, free, size_sets=None):
name = partition.getDeviceNodeName()
log.debug("setting %s new geometry: %s", name,
- partition.geometry)
+ partition.geometry)
constraint = parted.Constraint(exactGeom=partition.geometry)
disklabel.parted_disk.addPartition(partition=partition,
- constraint=constraint)
+ constraint=constraint)
path = partition.path
if device:
# set the device's name
@@ -1966,7 +1966,7 @@ def grow_lvm(storage):
continue
log.debug("vg %s: %s free ; lvs: %s", vg.name, total_free,
- [l.lvname for l in vg.lvs])
+ [l.lvname for l in vg.lvs])
# don't include thin lvs in the vg's growth calculation
fatlvs = [lv for lv in vg.lvs if lv not in vg.thinlvs]
@@ -1985,7 +1985,7 @@ def grow_lvm(storage):
raise ValueError("sum of percentages within a vg cannot exceed 100")
percent_base = sum(vg.align(lv.req_size, roundup=False) / vg.pe_size
- for lv in percentage_based_lvs)
+ for lv in percentage_based_lvs)
percentage_basis = vg.free_extents + percent_base
for lv in percentage_based_lvs:
new_extents = int(lv.req_percent * Decimal('0.01') * percentage_basis)
diff --git a/blivet/platform.py b/blivet/platform.py
index 6d97138..04716d0 100644
--- a/blivet/platform.py
+++ b/blivet/platform.py
@@ -138,7 +138,7 @@ def best_disklabel_type(self, device):
# that is large enough to address the whole device
label_type = self.default_disklabel_type
log.debug("default disklabel type for %s is %s", device.name,
- label_type)
+ label_type)
for lt in self.disklabel_types:
l = parted.freshDisk(device=parted_device, ty=lt)
if l.maxPartitionStartSector > parted_device.length:
diff --git a/blivet/populator.py b/blivet/populator.py
index f08cdf6..c8bb764 100644
--- a/blivet/populator.py
+++ b/blivet/populator.py
@@ -170,8 +170,8 @@ def is_ignored(self, info):
return False
if udev.device_get_md_container(info) and \
- udev.device_is_md(info) and \
- udev.device_get_md_name(info):
+ udev.device_is_md(info) and \
+ udev.device_get_md_name(info):
md_name = udev.device_get_md_name(info)
# mdadm may have appended _<digit>+ if the current hostname
# does not match the one in the array metadata
@@ -310,7 +310,7 @@ def add_udev_dm_device(self, info):
# if this is a luks device whose map name is not what we expect,
# fix up the map name and see if that sorts us out
handle_luks = (udev.device_is_dm_luks(info) and
- (self._cleanup or not flags.installer_mode))
+ (self._cleanup or not flags.installer_mode))
if device is None and handle_luks and slave_devices:
slave_dev = slave_devices[0]
slave_dev.format.map_name = name
@@ -528,7 +528,7 @@ def add_udev_disk_device(self, info):
container_info = udev.get_device(container_sysfs)
if not container_info:
log.error("failed to find md container %s at %s",
- parent_name, container_sysfs)
+ parent_name, container_sysfs)
return
self.add_udev_device(container_info)
@@ -567,9 +567,9 @@ def add_udev_disk_device(self, info):
log.info("%s is a disk", name)
device = disk_type(name,
- major=udev.device_get_major(info),
- minor=udev.device_get_minor(info),
- sysfs_path=sysfs_path, **kwargs)
+ major=udev.device_get_major(info),
+ minor=udev.device_get_minor(info),
+ sysfs_path=sysfs_path, **kwargs)
if disk_type == DASDDevice:
self.dasd.append(device)
@@ -631,8 +631,8 @@ def add_udev_device(self, info, update_orig_fmt=False):
# make sure this device was not scheduled for removal and also has not
# been hidden
removed = [a.device for a in self.devicetree.actions.find(
- action_type="destroy",
- object_type="device")]
+ action_type="destroy",
+ object_type="device")]
for ignored in removed + self.devicetree._hidden:
if (sysfs_path and ignored.sysfs_path == sysfs_path) or \
(uuid and uuid in (ignored.uuid, ignored.format.uuid)):
@@ -706,7 +706,7 @@ def add_udev_device(self, info, update_orig_fmt=False):
log.info("%s is a loop device", name)
device = self.add_udev_loop_device(info)
elif udev.device_is_dm_mpath(info) and \
- not udev.device_is_dm_partition(info):
+ not udev.device_is_dm_partition(info):
log.info("%s is a multipath device", name)
device = self.add_udev_multipath_device(info)
elif udev.device_is_dm_lvm(info):
@@ -792,9 +792,9 @@ def handle_udev_disk_label_format(self, info, device):
if not device.partitionable:
try:
fmt = formats.get_format("disklabel",
- device=device.path,
- label_type=disklabel_type,
- exists=True)
+ device=device.path,
+ label_type=disklabel_type,
+ exists=True)
except InvalidDiskLabelError:
log.warning("disklabel detected but not usable on %s",
device.name)
@@ -804,8 +804,8 @@ def handle_udev_disk_label_format(self, info, device):
try:
fmt = formats.get_format("disklabel",
- device=device.path,
- exists=True)
+ device=device.path,
+ exists=True)
except InvalidDiskLabelError as e:
log.info("no usable disklabel on %s", device.name)
if disklabel_type == "gpt":
@@ -830,7 +830,7 @@ def handle_udev_luks_format(self, info, device):
device.format.passphrase = passphrase
elif device.format.uuid in self.__luks_devs:
log.info("skipping previously-skipped luks device %s",
- device.name)
+ device.name)
elif self._cleanup or flags.testing:
# if we're only building the devicetree so that we can
# tear down all of the devices we don't need a passphrase
@@ -876,7 +876,7 @@ def handle_vg_lvs(self, vg_device):
""" Handle setup of the LV's in the vg_device. """
vg_name = vg_device.name
lv_info = dict((k, v) for (k, v) in iter(self.devicetree.lv_info.items())
- if v.vg_name == vg_name)
+ if v.vg_name == vg_name)
self.names.extend(n for n in lv_info.keys() if n not in self.names)
@@ -939,7 +939,7 @@ def add_lv(lv):
origin_name = blockdev.lvm.lvorigin(vg_name, lv_name)
if not origin_name:
log.error("lvm snapshot '%s-%s' has unknown origin",
- vg_name, lv_name)
+ vg_name, lv_name)
return
if origin_name.endswith("_vorigin]"):
@@ -948,7 +948,7 @@ def add_lv(lv):
else:
origin_device_name = "%s-%s" % (vg_name, origin_name)
add_required_lv(origin_device_name,
- "failed to locate origin lv")
+ "failed to locate origin lv")
origin = self.get_device_by_name(origin_device_name)
lv_kwargs["origin"] = origin
@@ -1211,12 +1211,12 @@ def handle_udev_md_member_format(self, info, device):
try:
md_array = array_type(
- md_name,
- level=md_level,
- member_devices=md_devices,
- uuid=md_uuid,
- metadata_version=md_metadata,
- exists=True
+ md_name,
+ level=md_level,
+ member_devices=md_devices,
+ uuid=md_uuid,
+ metadata_version=md_metadata,
+ exists=True
)
except (ValueError, DeviceError) as e:
log.error("failed to create md array: %s", e)
@@ -1326,11 +1326,11 @@ def handle_btrfs_format(self, info, device):
raise DeviceTreeError("could not find parent for subvol")
fmt = formats.get_format("btrfs",
- device=btrfs_dev.path,
- exists=True,
- vol_uuid=btrfs_dev.format.vol_uuid,
- subvolspec=vol_path,
- mountopts="subvol=%s" % vol_path)
+ device=btrfs_dev.path,
+ exists=True,
+ vol_uuid=btrfs_dev.format.vol_uuid,
+ subvolspec=vol_path,
+ mountopts="subvol=%s" % vol_path)
if vol_id in snapshot_ids:
device_class = BTRFSSnapShotDevice
else:
@@ -1373,7 +1373,7 @@ def handle_udev_device_format(self, info, device):
self.handle_udev_disk_label_format(info, device)
if device.partitioned or self.is_ignored(info) or \
(not device.partitionable and
- device.format.type == "disklabel"):
+ device.format.type == "disklabel"):
# If the device has a disklabel, or the user chose not to
# create one, we are finished with this device. Otherwise
# it must have some non-disklabel formatting, in which case
@@ -1464,7 +1464,7 @@ def handle_udev_device_format(self, info, device):
log.info("got format: %s", device.format)
except FSError:
log.warning("type '%s' on '%s' invalid, assuming no format",
- format_designator, name)
+ format_designator, name)
device.format = formats.DeviceFormat()
return
@@ -1635,7 +1635,7 @@ def populate(self, cleanup_only=False):
def _populate(self):
log.info("DeviceTree.populate: ignored_disks is %s ; exclusive_disks is %s",
- self.ignored_disks, self.exclusive_disks)
+ self.ignored_disks, self.exclusive_disks)
self.devicetree.drop_lvm_cache()
diff --git a/blivet/size.py b/blivet/size.py
index b90066a..383b61c 100644
--- a/blivet/size.py
+++ b/blivet/size.py
@@ -196,7 +196,7 @@ def parse_spec(spec):
# be detected when an exception is raised during conversion of the numeric
# part to a numeric value.
spec_re = re.compile(
- r"""(?P<numeric> # the numeric part consists of three parts, below
+ r"""(?P<numeric> # the numeric part consists of three parts, below
(-|\+)? # optional sign character
(?P<base>([0-9\.]+)) # the base
(?P<exp>(e|E)(-|\+)[0-9]+)?) # optional exponent
diff --git a/blivet/tasks/fsck.py b/blivet/tasks/fsck.py
index f6ff393..a3ed775 100644
--- a/blivet/tasks/fsck.py
+++ b/blivet/tasks/fsck.py
@@ -42,7 +42,7 @@ class FSCK(task.BasicApplication, fstask.FSTask):
description = "fsck"
options = abc.abstractproperty(
- doc="Options for invoking the application.")
+ doc="Options for invoking the application.")
# IMPLEMENTATION methods
@@ -84,15 +84,15 @@ def do_task(self):
error_msg = self._error_message(rc)
if error_msg is not None:
hdr = "%(type)s filesystem check failure on %(device)s: " % \
- {"type": self.fs.type, "device": self.fs.device}
+ {"type": self.fs.type, "device": self.fs.device}
raise FSError(hdr + error_msg)
class DosFSCK(FSCK):
_fsck_errors = {1: "Recoverable errors have been detected or dosfsck has "
- "discovered an internal inconsistency.",
- 2: "Usage error."}
+ "discovered an internal inconsistency.",
+ 2: "Usage error."}
ext = availability.DOSFSCK_APP
options = ["-n"]
@@ -108,10 +108,10 @@ def _error_message(self, rc):
class Ext2FSCK(FSCK):
_fsck_errors = {4: "File system errors left uncorrected.",
- 8: "Operational error.",
- 16: "Usage or syntax error.",
- 32: "e2fsck cancelled by user request.",
- 128: "Shared library error."}
+ 8: "Operational error.",
+ 16: "Usage or syntax error.",
+ 32: "e2fsck cancelled by user request.",
+ 128: "Shared library error."}
ext = availability.E2FSCK_APP
options = ["-f", "-p", "-C", "0"]
@@ -123,9 +123,9 @@ def _error_message(self, rc):
class HFSPlusFSCK(FSCK):
_fsck_errors = {3: "Quick check found a dirty filesystem; no repairs done.",
- 4: "Root filesystem was dirty. System should be rebooted.",
- 8: "Corrupt filesystem, repairs did not succeed.",
- 47: "Major error found; no repairs attempted."}
+ 4: "Root filesystem was dirty. System should be rebooted.",
+ 8: "Corrupt filesystem, repairs did not succeed.",
+ 47: "Major error found; no repairs attempted."}
ext = availability.FSCK_HFSPLUS_APP
options = []
diff --git a/blivet/tasks/fsinfo.py b/blivet/tasks/fsinfo.py
index 33733dc..af208f5 100644
--- a/blivet/tasks/fsinfo.py
+++ b/blivet/tasks/fsinfo.py
@@ -39,7 +39,7 @@ class FSInfo(task.BasicApplication, fstask.FSTask):
description = "filesystem info"
options = abc.abstractproperty(
- doc="Options for invoking the application.")
+ doc="Options for invoking the application.")
@property
def _info_command(self):
diff --git a/blivet/tasks/fslabeling.py b/blivet/tasks/fslabeling.py
index 7179039..b843af6 100644
--- a/blivet/tasks/fslabeling.py
+++ b/blivet/tasks/fslabeling.py
@@ -31,7 +31,7 @@ class FSLabeling(object):
"""
default_label = abc.abstractproperty(
- doc="Default label set on this filesystem at creation.")
+ doc="Default label set on this filesystem at creation.")
@abc.abstractmethod
def label_format_ok(self, label):
diff --git a/blivet/tasks/fsmkfs.py b/blivet/tasks/fsmkfs.py
index 078c226..d0da5b2 100644
--- a/blivet/tasks/fsmkfs.py
+++ b/blivet/tasks/fsmkfs.py
@@ -45,7 +45,7 @@ class FSMkfs(task.BasicApplication, FSMkfsTask):
description = "mkfs"
label_option = abc.abstractproperty(
- doc="Option for setting a filesystem label.")
+ doc="Option for setting a filesystem label.")
args = abc.abstractproperty(doc="options for creating filesystem")
diff --git a/blivet/tasks/fsmount.py b/blivet/tasks/fsmount.py
index aa175f3..b3ebd6c 100644
--- a/blivet/tasks/fsmount.py
+++ b/blivet/tasks/fsmount.py
@@ -58,8 +58,8 @@ def _has_driver(self):
@property
def _can_mount(self):
return (self.mount_type in fslib.kernel_filesystems) or \
- (os.access("/sbin/mount.%s" % (self.mount_type,), os.X_OK)) or \
- self._has_driver
+ (os.access("/sbin/mount.%s" % (self.mount_type,), os.X_OK)) or \
+ self._has_driver
@property
def _availability_errors(self):
diff --git a/blivet/tasks/fsresize.py b/blivet/tasks/fsresize.py
index a56cf26..343acaf 100644
--- a/blivet/tasks/fsresize.py
+++ b/blivet/tasks/fsresize.py
@@ -110,9 +110,9 @@ def size_spec(self):
@property
def args(self):
return [
- "-ff", # need at least two 'f's to fully suppress interaction
- "-s", self.size_spec(),
- self.fs.device
+ "-ff", # need at least two 'f's to fully suppress interaction
+ "-s", self.size_spec(),
+ self.fs.device
]
diff --git a/blivet/tasks/task.py b/blivet/tasks/task.py
index d5a4192..9ac4301 100644
--- a/blivet/tasks/task.py
+++ b/blivet/tasks/task.py
@@ -40,7 +40,7 @@ class Task(object):
def availability_errors(self):
""" Reasons if this task or the tasks it depends on are unavailable. """
return self._availability_errors + \
- [e for t in self.depends_on for e in t.availability_errors]
+ [e for t in self.depends_on for e in t.availability_errors]
@property
def available(self):
@@ -52,7 +52,7 @@ def available(self):
return self.availability_errors == []
_availability_errors = abc.abstractproperty(
- doc="Reasons if the necessary external tools are unavailable.")
+ doc="Reasons if the necessary external tools are unavailable.")
depends_on = abc.abstractproperty(doc="tasks that this task depends on")
diff --git a/blivet/udev.py b/blivet/udev.py
index c6854ec..7fc6189 100644
--- a/blivet/udev.py
+++ b/blivet/udev.py
@@ -53,7 +53,7 @@ def get_device(sysfs_path):
def get_devices(subsystem="block"):
settle()
return [d for d in global_udev.list_devices(subsystem=subsystem)
- if not __is_blacklisted_blockdev(d.sys_name)]
+ if not __is_blacklisted_blockdev(d.sys_name)]
def settle(quiet=False):
diff --git a/blivet/util.py b/blivet/util.py
index 86e6601..9d1aa20 100644
--- a/blivet/util.py
+++ b/blivet/util.py
@@ -165,7 +165,7 @@ def get_mount_device(mountpoint):
loop_name = os.path.basename(mount_device)
mount_device = blockdev.loop.get_backing_file(loop_name)
log.debug("found backing file %s for loop device %s", mount_device,
- loop_name)
+ loop_name)
if mount_device:
log.debug("%s is mounted on %s", mount_device, mountpoint)
@@ -254,7 +254,7 @@ def get_cow_sysfs_path(dev_path, dev_sysfsPath):
cow_path = dev_path + "-cow"
if not os.path.islink(cow_path):
raise RuntimeError("get_cow_sysfs_path: Could not find cow device for" %
- (dev_path))
+ (dev_path))
# dev path for cow devices is actually a link to a dm device (e.g. /dev/dm-X)
# we need the 'dm-X' name for sysfs_path (e.g. /sys/devices/virtual/block/dm-X)
diff --git a/blivet/zfcp.py b/blivet/zfcp.py
index d43cc65..329cfde 100644
--- a/blivet/zfcp.py
+++ b/blivet/zfcp.py
@@ -84,7 +84,7 @@ def online_device(self):
if not os.path.exists(online):
raise ValueError(_("zFCP device %s not found, not even in device ignore list.") %
- (self.devnum,))
+ (self.devnum,))
try:
f = open(online, "r")
@@ -94,8 +94,8 @@ def online_device(self):
logged_write_line_to_file(online, "1")
except IOError as e:
raise ValueError(_("Could not set zFCP device %(devnum)s "
- "online (%(e)s).")
- % {'devnum': self.devnum, 'e': e})
+ "online (%(e)s).")
+ % {'devnum': self.devnum, 'e': e})
if not os.path.exists(portdir):
if os.path.exists(portadd):
@@ -105,15 +105,15 @@ def online_device(self):
udev.settle()
except IOError as e:
raise ValueError(_("Could not add WWPN %(wwpn)s to zFCP "
- "device %(devnum)s (%(e)s).")
- % {'wwpn': self.wwpn,
+ "device %(devnum)s (%(e)s).")
+ % {'wwpn': self.wwpn,
'devnum': self.devnum,
'e': e})
else:
# newer zfcp sysfs interface with auto port scan
raise ValueError(_("WWPN %(wwpn)s not found at zFCP device "
- "%(devnum)s.") % {'wwpn': self.wwpn,
- 'devnum': self.devnum})
+ "%(devnum)s.") % {'wwpn': self.wwpn,
+ 'devnum': self.devnum})
else:
if os.path.exists(portadd):
# older zfcp sysfs interface
@@ -127,14 +127,14 @@ def online_device(self):
udev.settle()
except IOError as e:
raise ValueError(_("Could not add LUN %(fcplun)s to WWPN "
- "%(wwpn)s on zFCP device %(devnum)s "
- "(%(e)s).")
- % {'fcplun': self.fcplun, 'wwpn': self.wwpn,
+ "%(wwpn)s on zFCP device %(devnum)s "
+ "(%(e)s).")
+ % {'fcplun': self.fcplun, 'wwpn': self.wwpn,
'devnum': self.devnum, 'e': e})
else:
raise ValueError(_("LUN %(fcplun)s at WWPN %(wwpn)s on zFCP "
- "device %(devnum)s already configured.")
- % {'fcplun': self.fcplun,
+ "device %(devnum)s already configured.")
+ % {'fcplun': self.fcplun,
'wwpn': self.wwpn,
'devnum': self.devnum})
@@ -145,17 +145,17 @@ def online_device(self):
f.close()
except IOError as e:
raise ValueError(_("Could not read failed attribute of LUN "
- "%(fcplun)s at WWPN %(wwpn)s on zFCP device "
- "%(devnum)s (%(e)s).")
- % {'fcplun': self.fcplun,
+ "%(fcplun)s at WWPN %(wwpn)s on zFCP device "
+ "%(devnum)s (%(e)s).")
+ % {'fcplun': self.fcplun,
'wwpn': self.wwpn,
'devnum': self.devnum,
'e': e})
if fail != "0":
self.offline_device()
raise ValueError(_("Failed LUN %(fcplun)s at WWPN %(wwpn)s on "
- "zFCP device %(devnum)s removed again.")
- % {'fcplun': self.fcplun,
+ "zFCP device %(devnum)s removed again.")
+ % {'fcplun': self.fcplun,
'wwpn': self.wwpn,
'devnum': self.devnum})
@@ -211,18 +211,18 @@ def offline_device(self):
self.offline_scsi_device()
except IOError as e:
raise ValueError(_("Could not correctly delete SCSI device of "
- "zFCP %(devnum)s %(wwpn)s %(fcplun)s "
- "(%(e)s).")
- % {'devnum': self.devnum, 'wwpn': self.wwpn,
+ "zFCP %(devnum)s %(wwpn)s %(fcplun)s "
+ "(%(e)s).")
+ % {'devnum': self.devnum, 'wwpn': self.wwpn,
'fcplun': self.fcplun, 'e': e})
try:
logged_write_line_to_file(unitremove, self.fcplun)
except IOError as e:
raise ValueError(_("Could not remove LUN %(fcplun)s at WWPN "
- "%(wwpn)s on zFCP device %(devnum)s "
- "(%(e)s).")
- % {'fcplun': self.fcplun, 'wwpn': self.wwpn,
+ "%(wwpn)s on zFCP device %(devnum)s "
+ "(%(e)s).")
+ % {'fcplun': self.fcplun, 'wwpn': self.wwpn,
'devnum': self.devnum, 'e': e})
if os.path.exists(portadd):
@@ -238,8 +238,8 @@ def offline_device(self):
logged_write_line_to_file(portremove, self.wwpn)
except IOError as e:
raise ValueError(_("Could not remove WWPN %(wwpn)s on zFCP "
- "device %(devnum)s (%(e)s).")
- % {'wwpn': self.wwpn,
+ "device %(devnum)s (%(e)s).")
+ % {'wwpn': self.wwpn,
'devnum': self.devnum, 'e': e})
if os.path.exists(portadd):
@@ -254,7 +254,7 @@ def offline_device(self):
# newer zfcp sysfs interface with auto port scan
import glob
luns = glob.glob("%s/0x????????????????/0x????????????????"
- % (devdir,))
+ % (devdir,))
if len(luns) != 0:
log.info("Not setting zFCP device %s offline since it still has other LUNs, e.g. %s.",
self.devnum, luns[0])
@@ -264,8 +264,8 @@ def offline_device(self):
logged_write_line_to_file(offline, "0")
except IOError as e:
raise ValueError(_("Could not set zFCP device %(devnum)s "
- "offline (%(e)s).")
- % {'devnum': self.devnum, 'e': e})
+ "offline (%(e)s).")
+ % {'devnum': self.devnum, 'e': e})
return True
diff --git a/doc/conf.py b/doc/conf.py
index e452490..2b62ffb 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -173,21 +173,21 @@
# -- Options for LaTeX output --------------------------------------------------
latex_elements = {
-# The paper size ('letterpaper' or 'a4paper').
-#'papersize': 'letterpaper',
+ # The paper size ('letterpaper' or 'a4paper').
+ #'papersize': 'letterpaper',
-# The font size ('10pt', '11pt' or '12pt').
-#'pointsize': '10pt',
+ # The font size ('10pt', '11pt' or '12pt').
+ #'pointsize': '10pt',
-# Additional stuff for the LaTeX preamble.
-#'preamble': '',
+ # Additional stuff for the LaTeX preamble.
+ #'preamble': '',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
- ('index', 'Blivet.tex', u'Blivet Documentation',
- u'David Lehman', 'manual'),
+ ('index', 'Blivet.tex', u'Blivet Documentation',
+ u'David Lehman', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
@@ -230,9 +230,9 @@
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
- ('index', 'Blivet', u'Blivet Documentation',
- u'David Lehman', 'Blivet', 'One line description of project.',
- 'Miscellaneous'),
+ ('index', 'Blivet', u'Blivet Documentation',
+ u'David Lehman', 'Blivet', 'One line description of project.',
+ 'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
diff --git a/examples/factory.py b/examples/factory.py
index 1f92fba..a2f1649 100644
--- a/examples/factory.py
+++ b/examples/factory.py
@@ -25,16 +25,16 @@
# create an lv named data in a vg named testvg
device = b.factory_device(blivet.devicefactory.DEVICE_TYPE_LVM,
- Size("50GiB"), disks=[disk1, disk2],
- fstype="xfs", mountpoint="/data")
+ Size("50GiB"), disks=[disk1, disk2],
+ fstype="xfs", mountpoint="/data")
print_devices(b)
# change testvg to have an md RAID1 pv instead of partition pvs
device = b.factory_device(blivet.devicefactory.DEVICE_TYPE_LVM,
- Size("50GiB"), disks=[disk1, disk2],
- fstype="xfs", mountpoint="/data",
- container_raid_level="raid1",
- device=device)
+ Size("50GiB"), disks=[disk1, disk2],
+ fstype="xfs", mountpoint="/data",
+ container_raid_level="raid1",
+ device=device)
print_devices(b)
b.devicetree.process_actions()
diff --git a/examples/lvm.py b/examples/lvm.py
index 7621925..564cf00 100644
--- a/examples/lvm.py
+++ b/examples/lvm.py
@@ -31,12 +31,12 @@
# new lv with base size 5GiB and unbounded growth and an ext4 filesystem
dev = b.new_lv(fmt_type="ext4", size=Size("5GiB"), grow=True,
- parents=[vg], name="unbounded")
+ parents=[vg], name="unbounded")
b.create_device(dev)
# new lv with base size 5GiB and growth up to 15GiB and an ext4 filesystem
dev = b.new_lv(fmt_type="ext4", size=Size("5GiB"), grow=True,
- maxsize=Size("15GiB"), parents=[vg], name="bounded")
+ maxsize=Size("15GiB"), parents=[vg], name="bounded")
b.create_device(dev)
# new lv with a fixed size of 2GiB formatted as swap space
diff --git a/examples/partitioning.py b/examples/partitioning.py
index 7c362f1..875f207 100644
--- a/examples/partitioning.py
+++ b/examples/partitioning.py
@@ -27,13 +27,13 @@
# new partition on either disk1 or disk2 with base size 10GiB and growth
# up to a maximum size of 50GiB
dev = b.new_partition(size=Size("10MiB"), maxsize=Size("50GiB"),
- grow=True, parents=[disk1, disk2])
+ grow=True, parents=[disk1, disk2])
b.create_device(dev)
# new partition on disk1 with base size 5GiB and unbounded growth and an
# ext4 filesystem
dev = b.new_partition(fmt_type="ext4", size=Size("5GiB"), grow=True,
- parents=[disk1])
+ parents=[disk1])
b.create_device(dev)
# new partition on any suitable disk with a fixed size of 2GiB formatted
diff --git a/tests/__init__.py b/tests/__init__.py
index 6f41f47..47c7c52 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -5,4 +5,3 @@
if six.PY2:
TestCase.assertRaisesRegex = TestCase.assertRaisesRegexp
TestCase.assertRegex = TestCase.assertRegexpMatches
-
diff --git a/tests/action_test.py b/tests/action_test.py
index fbab7d3..fe3c759 100644
--- a/tests/action_test.py
+++ b/tests/action_test.py
@@ -24,11 +24,11 @@
from blivet.deviceaction import ActionRemoveMember
DEVICE_CLASSES = [
- DiskDevice,
- PartitionDevice,
- MDRaidArrayDevice,
- LVMVolumeGroupDevice,
- LVMLogicalVolumeDevice
+ DiskDevice,
+ PartitionDevice,
+ MDRaidArrayDevice,
+ LVMVolumeGroupDevice,
+ LVMLogicalVolumeDevice
]
@@ -46,9 +46,9 @@ def setUp(self):
for name in ["sda", "sdb", "sdc", "sdd"]:
disk = self.new_device(device_class=DiskDevice,
- name=name, size=Size("100 GiB"))
+ name=name, size=Size("100 GiB"))
disk.format = self.new_format("disklabel", path=disk.path,
- exists=True)
+ exists=True)
self.storage.devicetree._add_device(disk)
# create a layout similar to autopart as a starting point
@@ -56,44 +56,44 @@ def setUp(self):
sdb = self.storage.devicetree.get_device_by_name("sdb")
sda1 = self.new_device(device_class=PartitionDevice,
- exists=True, name="sda1", parents=[sda],
- size=Size("500 MiB"))
+ exists=True, name="sda1", parents=[sda],
+ size=Size("500 MiB"))
sda1.format = self.new_format("ext4", mountpoint="/boot",
- device_instance=sda1,
- device=sda1.path, exists=True)
+ device_instance=sda1,
+ device=sda1.path, exists=True)
self.storage.devicetree._add_device(sda1)
sda2 = self.new_device(device_class=PartitionDevice,
- size=Size("99.5 GiB"), name="sda2",
- parents=[sda], exists=True)
+ size=Size("99.5 GiB"), name="sda2",
+ parents=[sda], exists=True)
sda2.format = self.new_format("lvmpv", device=sda2.path, exists=True)
self.storage.devicetree._add_device(sda2)
sdb1 = self.new_device(device_class=PartitionDevice,
- size=Size("99.999 GiB"), name="sdb1",
- parents=[sdb], exists=True)
+ size=Size("99.999 GiB"), name="sdb1",
+ parents=[sdb], exists=True)
sdb1.format = self.new_format("lvmpv", device=sdb1.path, exists=True)
self.storage.devicetree._add_device(sdb1)
vg = self.new_device(device_class=LVMVolumeGroupDevice,
- name="VolGroup", parents=[sda2, sdb1],
- exists=True)
+ name="VolGroup", parents=[sda2, sdb1],
+ exists=True)
self.storage.devicetree._add_device(vg)
lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
- name="lv_root", parents=[vg],
- size=Size("160 GiB"), exists=True)
+ name="lv_root", parents=[vg],
+ size=Size("160 GiB"), exists=True)
lv_root.format = self.new_format("ext4", mountpoint="/",
- device_instance=lv_root,
- device=lv_root.path, exists=True)
+ device_instance=lv_root,
+ device=lv_root.path, exists=True)
self.storage.devicetree._add_device(lv_root)
lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
- name="lv_swap", parents=[vg],
- size=Size("4000 MiB"), exists=True)
+ name="lv_swap", parents=[vg],
+ size=Size("4000 MiB"), exists=True)
lv_swap.format = self.new_format("swap", device=lv_swap.path,
- device_instance=lv_swap,
- exists=True)
+ device_instance=lv_swap,
+ exists=True)
self.storage.devicetree._add_device(lv_swap)
def test_actions(self):
@@ -136,38 +136,38 @@ def test_actions(self):
self.assertNotEqual(sda, None, "failed to find disk 'sda'")
sda1 = self.new_device(device_class=PartitionDevice,
- name="sda1", size=Size("500 MiB"),
- parents=[sda])
+ name="sda1", size=Size("500 MiB"),
+ parents=[sda])
self.schedule_create_device(sda1)
sda2 = self.new_device(device_class=PartitionDevice,
- name="sda2", size=Size("100 GiB"),
- parents=[sda])
+ name="sda2", size=Size("100 GiB"),
+ parents=[sda])
self.schedule_create_device(sda2)
fmt = self.new_format("lvmpv", device=sda2.path)
self.schedule_create_format(device=sda2, fmt=fmt)
vg = self.new_device(device_class=LVMVolumeGroupDevice,
- name="vg", parents=[sda2])
+ name="vg", parents=[sda2])
self.schedule_create_device(vg)
lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
- name="lv_root", parents=[vg],
- size=Size("60 GiB"))
+ name="lv_root", parents=[vg],
+ size=Size("60 GiB"))
self.schedule_create_device(lv_root)
fmt = self.new_format("ext4", device=lv_root.path, mountpoint="/")
self.schedule_create_format(device=lv_root, fmt=fmt)
lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
- name="lv_swap", parents=[vg],
- size=Size("4000 MiB"))
+ name="lv_swap", parents=[vg],
+ size=Size("4000 MiB"))
self.schedule_create_device(lv_swap)
fmt = self.new_format("swap", device=lv_swap.path)
self.schedule_create_format(device=lv_swap, fmt=fmt)
sda3 = self.new_device(device_class=PartitionDevice,
- name="sda3", parents=[sda],
- size=Size("40 GiB"))
+ name="sda3", parents=[sda],
+ size=Size("40 GiB"))
self.schedule_create_device(sda3)
fmt = self.new_format("mdmember", device=sda3.path)
self.schedule_create_format(device=sda3, fmt=fmt)
@@ -176,16 +176,16 @@ def test_actions(self):
self.assertNotEqual(sdb, None, "failed to find disk 'sdb'")
sdb1 = self.new_device(device_class=PartitionDevice,
- name="sdb1", parents=[sdb],
- size=Size("40 GiB"))
+ name="sdb1", parents=[sdb],
+ size=Size("40 GiB"))
self.schedule_create_device(sdb1)
fmt = self.new_format("mdmember", device=sdb1.path,)
self.schedule_create_format(device=sdb1, fmt=fmt)
md0 = self.new_device(device_class=MDRaidArrayDevice,
- name="md0", level="raid0", minor=0,
- member_devices=2, total_devices=2,
- parents=[sdb1, sda3])
+ name="md0", level="raid0", minor=0,
+ member_devices=2, total_devices=2,
+ parents=[sdb1, sda3])
self.schedule_create_device(md0)
fmt = self.new_format("ext4", device=md0.path, mountpoint="/home")
@@ -201,7 +201,7 @@ def test_action_creation(self):
# XXX resizable depends on existence, so this is covered implicitly
sdd = self.storage.devicetree.get_device_by_name("sdd")
p = self.new_device(device_class=PartitionDevice,
- name="sdd1", size=Size("32 GiB"), parents=[sdd])
+ name="sdd1", size=Size("32 GiB"), parents=[sdd])
with self.assertRaises(ValueError):
ActionResizeDevice(p, p.size + Size("7232 MiB"))
@@ -274,8 +274,8 @@ def test_action_registration(self):
sdc = self.storage.devicetree.get_device_by_name("sdc")
self.assertNotEqual(sdc, None)
sdc1 = self.new_device(device_class=PartitionDevice,
- name="sdc1", size=Size("100 GiB"),
- parents=[sdc], exists=True)
+ name="sdc1", size=Size("100 GiB"),
+ parents=[sdc], exists=True)
sdc1_format = self.new_format("ext2", device=sdc1.path, mountpoint="/")
create_sdc1_format = ActionCreateFormat(sdc1, sdc1_format)
@@ -324,8 +324,8 @@ def test_action_registration(self):
sdd1 = self.storage.devicetree.get_device_by_name("sdd1")
self.assertEqual(sdd1, None)
sdd1 = self.new_device(device_class=PartitionDevice,
- name="sdd1", size=Size("100 GiB"),
- parents=[sdd])
+ name="sdd1", size=Size("100 GiB"),
+ parents=[sdd])
a = ActionCreateDevice(sdd1)
self.storage.devicetree.register_action(a)
sdd1 = self.storage.devicetree.get_device_by_name("sdd1")
@@ -338,7 +338,7 @@ def test_action_obsoletes(self):
self.assertNotEqual(sdc, None)
sdc1 = self.new_device(device_class=PartitionDevice,
- name="sdc1", parents=[sdc], size=Size("40 GiB"))
+ name="sdc1", parents=[sdc], size=Size("40 GiB"))
# ActionCreateDevice
#
@@ -464,31 +464,31 @@ def test_action_pruning(self):
self.assertNotEqual(sda, None, "failed to find disk 'sda'")
sda1 = self.new_device(device_class=PartitionDevice,
- name="sda1", size=Size("500 MiB"),
- parents=[sda])
+ name="sda1", size=Size("500 MiB"),
+ parents=[sda])
self.schedule_create_device(sda1)
sda2 = self.new_device(device_class=PartitionDevice,
- name="sda2", size=Size("100 GiB"),
- parents=[sda])
+ name="sda2", size=Size("100 GiB"),
+ parents=[sda])
self.schedule_create_device(sda2)
fmt = self.new_format("lvmpv", device=sda2.path)
self.schedule_create_format(device=sda2, fmt=fmt)
vg = self.new_device(device_class=LVMVolumeGroupDevice,
- name="vg", parents=[sda2])
+ name="vg", parents=[sda2])
self.schedule_create_device(vg)
lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
- name="lv_root", parents=[vg],
- size=Size("60 GiB"))
+ name="lv_root", parents=[vg],
+ size=Size("60 GiB"))
self.schedule_create_device(lv_root)
fmt = self.new_format("ext4", device=lv_root.path, mountpoint="/")
self.schedule_create_format(device=lv_root, fmt=fmt)
lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
- name="lv_swap", parents=[vg],
- size=Size("4 GiB"))
+ name="lv_swap", parents=[vg],
+ size=Size("4 GiB"))
self.schedule_create_device(lv_swap)
fmt = self.new_format("swap", device=lv_swap.path)
self.schedule_create_format(device=lv_swap, fmt=fmt)
@@ -496,8 +496,8 @@ def test_action_pruning(self):
# we'll soon schedule destroy actions for these members and the array,
# which will test pruning. the whole mess should reduce to nothing
sda3 = self.new_device(device_class=PartitionDevice,
- name="sda3", parents=[sda],
- size=Size("40 GiB"))
+ name="sda3", parents=[sda],
+ size=Size("40 GiB"))
self.schedule_create_device(sda3)
fmt = self.new_format("mdmember", device=sda3.path)
self.schedule_create_format(device=sda3, fmt=fmt)
@@ -506,16 +506,16 @@ def test_action_pruning(self):
self.assertNotEqual(sdb, None, "failed to find disk 'sdb'")
sdb1 = self.new_device(device_class=PartitionDevice,
- name="sdb1", parents=[sdb],
- size=Size("40 GiB"))
+ name="sdb1", parents=[sdb],
+ size=Size("40 GiB"))
self.schedule_create_device(sdb1)
fmt = self.new_format("mdmember", device=sdb1.path,)
self.schedule_create_format(device=sdb1, fmt=fmt)
md0 = self.new_device(device_class=MDRaidArrayDevice,
- name="md0", level="raid0", minor=0,
- member_devices=2, total_devices=2,
- parents=[sdb1, sda3])
+ name="md0", level="raid0", minor=0,
+ member_devices=2, total_devices=2,
+ parents=[sdb1, sda3])
self.schedule_create_device(md0)
fmt = self.new_format("ext4", device=md0.path, mountpoint="/home")
@@ -591,38 +591,38 @@ def test_action_dependencies(self):
sda = self.storage.devicetree.get_device_by_name("sda")
sdb = self.storage.devicetree.get_device_by_name("sdb")
sda1 = self.new_device(device_class=PartitionDevice, name="sda1",
- size=Size("500 MiB"), parents=[sda])
+ size=Size("500 MiB"), parents=[sda])
sda1_format = self.new_format("ext4", mountpoint="/boot",
- device=sda1.path)
+ device=sda1.path)
self.schedule_create_device(sda1)
self.schedule_create_format(device=sda1, fmt=sda1_format)
sda2 = self.new_device(device_class=PartitionDevice, name="sda2",
- size=Size("99.5 GiB"), parents=[sda])
+ size=Size("99.5 GiB"), parents=[sda])
sda2_format = self.new_format("lvmpv", device=sda2.path)
self.schedule_create_device(sda2)
self.schedule_create_format(device=sda2, fmt=sda2_format)
sdb1 = self.new_device(device_class=PartitionDevice, name="sdb1",
- size=Size("100 GiB"), parents=[sdb])
+ size=Size("100 GiB"), parents=[sdb])
sdb1_format = self.new_format("lvmpv", device=sdb1.path)
self.schedule_create_device(sdb1)
self.schedule_create_format(device=sdb1, fmt=sdb1_format)
vg = self.new_device(device_class=LVMVolumeGroupDevice,
- name="VolGroup", parents=[sda2, sdb1])
+ name="VolGroup", parents=[sda2, sdb1])
self.schedule_create_device(vg)
lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
- name="lv_root", parents=[vg],
- size=Size("160 GiB"))
+ name="lv_root", parents=[vg],
+ size=Size("160 GiB"))
self.schedule_create_device(lv_root)
fmt = self.new_format("ext4", device=lv_root.path, mountpoint="/")
self.schedule_create_format(device=lv_root, fmt=fmt)
lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
- name="lv_swap", parents=[vg],
- size=Size("4 GiB"))
+ name="lv_swap", parents=[vg],
+ size=Size("4 GiB"))
self.schedule_create_device(lv_swap)
fmt = self.new_format("swap", device=lv_swap.path)
self.schedule_create_format(device=lv_swap, fmt=fmt)
@@ -633,8 +633,8 @@ def test_action_dependencies(self):
lv_root = self.storage.devicetree.get_device_by_name("VolGroup-lv_root")
self.assertNotEqual(lv_root, None)
actions = self.storage.devicetree.actions.find(action_type="create",
- object_type="device",
- device=lv_root)
+ object_type="device",
+ device=lv_root)
self.assertEqual(len(actions), 1,
"wrong number of device create actions for lv_root: "
"%d" % len(actions))
@@ -644,8 +644,8 @@ def test_action_dependencies(self):
self.assertNotEqual(vgs, [])
vg = vgs[0]
actions = self.storage.devicetree.actions.find(action_type="create",
- object_type="device",
- device=vg)
+ object_type="device",
+ device=vg)
self.assertEqual(len(actions), 1,
"wrong number of device create actions for VolGroup")
create_vg_action = actions[0]
@@ -658,7 +658,7 @@ def test_action_dependencies(self):
for pv in pvs:
# include device and format create actions for each pv
actions = self.storage.devicetree.actions.find(action_type="create",
- device=pv)
+ device=pv)
self.assertEqual(len(actions), 2,
"wrong number of device create actions for "
"pv %s" % pv.name)
@@ -677,12 +677,12 @@ def test_action_dependencies(self):
self.assertNotEqual(sdc, None)
sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
- parents=[sdc], size=Size("50 GiB"))
+ parents=[sdc], size=Size("50 GiB"))
create_sdc1 = self.schedule_create_device(sdc1)
self.assertEqual(isinstance(create_sdc1, ActionCreateDevice), True)
sdc2 = self.new_device(device_class=PartitionDevice, name="sdc2",
- parents=[sdc], size=Size("50 GiB"))
+ parents=[sdc], size=Size("50 GiB"))
create_sdc2 = self.schedule_create_device(sdc2)
self.assertEqual(isinstance(create_sdc2, ActionCreateDevice), True)
@@ -695,8 +695,8 @@ def test_action_dependencies(self):
sda1 = self.storage.devicetree.get_device_by_name("sda1")
self.assertNotEqual(sda1, None)
actions = self.storage.devicetree.actions.find(action_type="create",
- object_type="device",
- device=sda1)
+ object_type="device",
+ device=sda1)
self.assertEqual(len(actions), 1,
"wrong number of create actions found for sda1")
create_sda1 = actions[0]
@@ -714,21 +714,21 @@ def test_action_dependencies(self):
self.assertNotEqual(sdd, None)
sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
- parents=[sdc], size=Size("40 GiB"))
+ parents=[sdc], size=Size("40 GiB"))
self.schedule_create_device(sdc1)
fmt = self.new_format("mdmember", device=sdc1.path)
self.schedule_create_format(device=sdc1, fmt=fmt)
sdd1 = self.new_device(device_class=PartitionDevice, name="sdd1",
- parents=[sdd], size=Size("40 GiB"))
+ parents=[sdd], size=Size("40 GiB"))
self.schedule_create_device(sdd1)
fmt = self.new_format("mdmember", device=sdd1.path,)
self.schedule_create_format(device=sdd1, fmt=fmt)
md0 = self.new_device(device_class=MDRaidArrayDevice,
- name="md0", level="raid0", minor=0,
- member_devices=2, total_devices=2,
- parents=[sdc1, sdd1])
+ name="md0", level="raid0", minor=0,
+ member_devices=2, total_devices=2,
+ parents=[sdc1, sdd1])
self.schedule_create_device(md0)
fmt = self.new_format("ext4", device=md0.path, mountpoint="/home")
self.schedule_create_format(device=md0, fmt=fmt)
@@ -751,11 +751,11 @@ def test_action_dependencies(self):
# numbered partition, eg: destroy sda2 before destroying sda1
self.destroy_all_devices(disks=["sdc", "sdd"])
sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
- parents=[sdc], size=Size("50 GiB"))
+ parents=[sdc], size=Size("50 GiB"))
self.schedule_create_device(sdc1)
sdc2 = self.new_device(device_class=PartitionDevice, name="sdc2",
- parents=[sdc], size=Size("40 GiB"))
+ parents=[sdc], size=Size("40 GiB"))
self.schedule_create_device(sdc2)
destroy_sdc1 = self.schedule_destroy_device(sdc1)
@@ -770,17 +770,17 @@ def test_action_dependencies(self):
self.assertNotEqual(sdd, None)
sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
- parents=[sdc], size=Size("50 GiB"))
+ parents=[sdc], size=Size("50 GiB"))
create_pv = self.schedule_create_device(sdc1)
fmt = self.new_format("lvmpv", device=sdc1.path)
create_pv_format = self.schedule_create_format(device=sdc1, fmt=fmt)
testvg = self.new_device(device_class=LVMVolumeGroupDevice,
- name="testvg", parents=[sdc1])
+ name="testvg", parents=[sdc1])
create_vg = self.schedule_create_device(testvg)
testlv = self.new_device(device_class=LVMLogicalVolumeDevice,
- name="testlv", parents=[testvg],
- size=Size("30 GiB"))
+ name="testlv", parents=[testvg],
+ size=Size("30 GiB"))
create_lv = self.schedule_create_device(testlv)
fmt = self.new_format("ext4", device=testlv.path)
create_lv_format = self.schedule_create_format(device=testlv, fmt=fmt)
@@ -805,18 +805,18 @@ def test_action_dependencies(self):
# we instantiate and use actions directly
self.destroy_all_devices(disks=["sdc", "sdd"])
sdc1 = self.new_device(device_class=PartitionDevice, exists=True,
- name="sdc1", parents=[sdc],
- size=Size("50 GiB"))
+ name="sdc1", parents=[sdc],
+ size=Size("50 GiB"))
sdc1.format = self.new_format("lvmpv", device=sdc1.path, exists=True,
- device_instance=sdc1)
+ device_instance=sdc1)
testvg = self.new_device(device_class=LVMVolumeGroupDevice, exists=True,
- name="testvg", parents=[sdc1],
- size=Size("50 GiB"))
+ name="testvg", parents=[sdc1],
+ size=Size("50 GiB"))
testlv = self.new_device(device_class=LVMLogicalVolumeDevice,
- exists=True, size=Size("30 GiB"),
- name="testlv", parents=[testvg])
+ exists=True, size=Size("30 GiB"),
+ name="testlv", parents=[testvg])
testlv.format = self.new_format("ext4", device=testlv.path,
- exists=True, device_instance=testlv)
+ exists=True, device_instance=testlv)
# ActionResizeDevice
# an action that resizes a device should require an action that grows
@@ -947,7 +947,7 @@ def test_action_dependencies(self):
self.assertEqual(destroy_lv_format.requires(destroy_pv_format), False)
sdc2 = self.new_device(device_class=PartitionDevice, name="sdc2",
- size=Size("5 GiB"), parents=[sdc])
+ size=Size("5 GiB"), parents=[sdc])
create_sdc2 = self.schedule_create_device(sdc2)
# create actions should always require destroy actions -- even for
@@ -1036,44 +1036,44 @@ def test_container_actions(self):
# create something like an existing lvm autopart layout across two disks
#
sda1 = self.new_device(device_class=PartitionDevice,
- exists=True, name="sda1", parents=[sda],
- size=Size("500 MiB"))
+ exists=True, name="sda1", parents=[sda],
+ size=Size("500 MiB"))
sda1.format = self.new_format("ext4", mountpoint="/boot",
- device_instance=sda1,
- device=sda1.path, exists=True)
+ device_instance=sda1,
+ device=sda1.path, exists=True)
self.storage.devicetree._add_device(sda1)
sda2 = self.new_device(device_class=PartitionDevice,
- size=Size("99.5 GiB"), name="sda2",
- parents=[sda], exists=True)
+ size=Size("99.5 GiB"), name="sda2",
+ parents=[sda], exists=True)
sda2.format = self.new_format("lvmpv", device=sda2.path, exists=True)
self.storage.devicetree._add_device(sda2)
sdb1 = self.new_device(device_class=PartitionDevice,
- size=Size("99.999 GiB"), name="sdb1",
- parents=[sdb], exists=True)
+ size=Size("99.999 GiB"), name="sdb1",
+ parents=[sdb], exists=True)
sdb1.format = self.new_format("lvmpv", device=sdb1.path, exists=True)
self.storage.devicetree._add_device(sdb1)
vg = self.new_device(device_class=LVMVolumeGroupDevice,
- name="VolGroup", parents=[sda2, sdb1],
- exists=True)
+ name="VolGroup", parents=[sda2, sdb1],
+ exists=True)
self.storage.devicetree._add_device(vg)
lv_root = self.new_device(device_class=LVMLogicalVolumeDevice,
- name="lv_root", parents=[vg],
- size=Size("160 GiB"), exists=True)
+ name="lv_root", parents=[vg],
+ size=Size("160 GiB"), exists=True)
lv_root.format = self.new_format("ext4", mountpoint="/",
- device_instance=lv_root,
- device=lv_root.path, exists=True)
+ device_instance=lv_root,
+ device=lv_root.path, exists=True)
self.storage.devicetree._add_device(lv_root)
lv_swap = self.new_device(device_class=LVMLogicalVolumeDevice,
- name="lv_swap", parents=[vg],
- size=Size("4000 MiB"), exists=True)
+ name="lv_swap", parents=[vg],
+ size=Size("4000 MiB"), exists=True)
lv_swap.format = self.new_format("swap", device=lv_swap.path,
- device_instance=lv_swap,
- exists=True)
+ device_instance=lv_swap,
+ exists=True)
self.storage.devicetree._add_device(lv_swap)
#
@@ -1081,11 +1081,11 @@ def test_container_actions(self):
#
sdc = self.storage.devicetree.get_device_by_name("sdc")
sdc1 = self.new_device(device_class=PartitionDevice, name="sdc1",
- size=Size("50 GiB"), parents=[sdc])
+ size=Size("50 GiB"), parents=[sdc])
sdc1_format = self.new_format("lvmpv", device=sdc1.path)
create_sdc1 = self.schedule_create_device(sdc1)
create_sdc1_format = self.schedule_create_format(device=sdc1,
- fmt=sdc1_format)
+ fmt=sdc1_format)
self.assertEqual(len(vg.parents), 2)
@@ -1098,12 +1098,12 @@ def test_container_actions(self):
self.assertEqual(add_sdc1.requires(create_sdc1_format), True)
new_lv = self.new_device(device_class=LVMLogicalVolumeDevice,
- name="newlv", parents=[vg],
- size=Size("20 GiB"))
+ name="newlv", parents=[vg],
+ size=Size("20 GiB"))
create_new_lv = self.schedule_create_device(new_lv)
new_lv_format = self.new_format("xfs", device=new_lv.path)
create_new_lv_format = self.schedule_create_format(device=new_lv,
- fmt=new_lv_format)
+ fmt=new_lv_format)
self.assertEqual(create_new_lv.requires(add_sdc1), True)
self.assertEqual(create_new_lv_format.requires(add_sdc1), False)
@@ -1136,7 +1136,7 @@ def test_container_actions(self):
self.assertEqual(remove_sdb1.obsoletes(add_sdb1), True)
sdc2 = self.new_device(device_class=PartitionDevice, name="sdc2",
- size=Size("5 GiB"), parents=[sdc])
+ size=Size("5 GiB"), parents=[sdc])
create_sdc2 = self.schedule_create_device(sdc2)
# destroy/resize/create sequencing does not apply to container actions
diff --git a/tests/clearpart_test.py b/tests/clearpart_test.py
index f321c08..3ded684 100644
--- a/tests/clearpart_test.py
+++ b/tests/clearpart_test.py
@@ -28,7 +28,7 @@ def test_should_clear(self):
# sda is a disk with an existing disklabel containing two partitions
sda = DiskDevice("sda", size=100000, exists=True)
sda.format = blivet.formats.get_format("disklabel", device=sda.path,
- exists=True)
+ exists=True)
sda.format._parted_disk = mock.Mock()
sda.format._parted_device = mock.Mock()
sda.format._parted_disk.configure_mock(partitions=[])
@@ -38,26 +38,26 @@ def test_should_clear(self):
sda1 = PartitionDevice("sda1", size=500, exists=True,
parents=[sda])
sda1._parted_partition = mock.Mock(**{'type': PARTITION_NORMAL,
- 'getFlag.return_value': 0})
+ 'getFlag.return_value': 0})
sda1.format = blivet.formats.get_format("ext4", mountpoint="/boot",
- device=sda1.path,
- exists=True)
+ device=sda1.path,
+ exists=True)
b.devicetree._add_device(sda1)
# sda2 is a partition containing an existing vfat filesystem
sda2 = PartitionDevice("sda2", size=10000, exists=True,
parents=[sda])
sda2._parted_partition = mock.Mock(**{'type': PARTITION_NORMAL,
- 'getFlag.return_value': 0})
+ 'getFlag.return_value': 0})
sda2.format = blivet.formats.get_format("vfat", mountpoint="/foo",
- device=sda2.path,
- exists=True)
+ device=sda2.path,
+ exists=True)
b.devicetree._add_device(sda2)
# sdb is an unpartitioned disk containing an xfs filesystem
sdb = DiskDevice("sdb", size=100000, exists=True)
sdb.format = blivet.formats.get_format("xfs", device=sdb.path,
- exists=True)
+ exists=True)
b.devicetree._add_device(sdb)
# sdc is an unformatted/uninitialized/empty disk
@@ -67,7 +67,7 @@ def test_should_clear(self):
# sdd is a disk containing an existing disklabel with no partitions
sdd = DiskDevice("sdd", size=100000, exists=True)
sdd.format = blivet.formats.get_format("disklabel", device=sdd.path,
- exists=True)
+ exists=True)
b.devicetree._add_device(sdd)
#
@@ -138,11 +138,11 @@ def test_should_clear(self):
msg="type linux should clear linux-native whole-disk "
"formatting regardless of initlabel setting")
self.assertTrue(b.should_clear(sdc),
- msg="type linux should clear unformatted disks when "
- "initlabel is set")
+ msg="type linux should clear unformatted disks when "
+ "initlabel is set")
self.assertTrue(b.should_clear(sdd),
- msg="type linux should clear disks with empty "
- "partition tables when initlabel is set")
+ msg="type linux should clear disks with empty "
+ "partition tables when initlabel is set")
sda1.protected = True
self.assertFalse(b.should_clear(sda1),
diff --git a/tests/devicefactory_test.py b/tests/devicefactory_test.py
index 9c3a614..1ea3f74 100644
--- a/tests/devicefactory_test.py
+++ b/tests/devicefactory_test.py
@@ -66,7 +66,7 @@ def _clean_up_disk_files(self):
def _factory_device(self, *args, **kwargs):
""" Run the device factory and return the device it produces. """
factory = devicefactory.get_device_factory(self.b,
- *args, **kwargs)
+ *args, **kwargs)
factory.configure()
return factory.device
@@ -230,7 +230,7 @@ def test_normalize_size(self):
# PartitionFactory
size = self.b.disks[0].size - Size("4 MiB")
device = self._factory_device(self.device_type, size,
- disks=self.b.disks, **kwargs)
+ disks=self.b.disks, **kwargs)
self.assertAlmostEqual(device.size, size, delta=self._get_size_delta())
factory.size = None
@@ -418,7 +418,7 @@ class LVMThinPFactoryTestCase(LVMFactoryTestCase):
def _validate_factory_device(self, *args, **kwargs):
super(LVMThinPFactoryTestCase, self)._validate_factory_device(*args,
- **kwargs)
+ **kwargs)
device = args[0]
if kwargs.get("encrypted", False):
@@ -517,20 +517,20 @@ def _get_test_factory_args(self):
def test_mdfactory(self):
factory1 = devicefactory.get_device_factory(self.b,
- devicefactory.DEVICE_TYPE_MD,
- Size("1 GiB"),
- raid_level=raid.RAID1)
+ devicefactory.DEVICE_TYPE_MD,
+ Size("1 GiB"),
+ raid_level=raid.RAID1)
factory2 = devicefactory.get_device_factory(self.b,
- devicefactory.DEVICE_TYPE_MD,
- Size("1 GiB"),
- raid_level=0)
+ devicefactory.DEVICE_TYPE_MD,
+ Size("1 GiB"),
+ raid_level=0)
with self.assertRaisesRegex(devicefactory.DeviceFactoryError, "must have some RAID level"):
devicefactory.get_device_factory(
- self.b,
- devicefactory.DEVICE_TYPE_MD,
- Size("1 GiB"))
+ self.b,
+ devicefactory.DEVICE_TYPE_MD,
+ Size("1 GiB"))
with self.assertRaisesRegex(RaidError, "requires at least"):
factory1._get_device_space()
@@ -543,8 +543,8 @@ def test_mdfactory(self):
self.assertIsNone(factory1.get_container())
parents = [
- DiskDevice("name1", fmt=get_format("mdmember")),
- DiskDevice("name2", fmt=get_format("mdmember"))
+ DiskDevice("name1", fmt=get_format("mdmember")),
+ DiskDevice("name2", fmt=get_format("mdmember"))
]
self.assertIsNotNone(factory1._get_new_device(parents=parents))
diff --git a/tests/devicelibs_test/edd_test.py b/tests/devicelibs_test/edd_test.py
index 743e011..62c7b4d 100644
--- a/tests/devicelibs_test/edd_test.py
+++ b/tests/devicelibs_test/edd_test.py
@@ -59,13 +59,13 @@ def setUp(self):
edd.log.setLevel(logging.DEBUG)
newlog = mock.MagicMock(name='log')
newlog.debug = mock.Mock(name='debug',
- side_effect=self._edd_logger.debug)
+ side_effect=self._edd_logger.debug)
newlog.info = mock.Mock(name='info',
- side_effect=self._edd_logger.info)
+ side_effect=self._edd_logger.info)
newlog.warning = mock.Mock(name='warning',
- side_effect=self._edd_logger.warning)
+ side_effect=self._edd_logger.warning)
newlog.error = mock.Mock(name='error',
- side_effect=self._edd_logger.error)
+ side_effect=self._edd_logger.error)
edd.log = newlog
def tearDown(self):
@@ -110,26 +110,26 @@ def test_collect_edd_data_sata_usb(self):
self._set_fs_root(edd, "sata_usb")
fakeedd = {
0x80: FakeEddEntry(version="0x30", mbr_sig="0x00000000",
- sectors=312581808, host_bus="PCI", type="SATA",
- pci_dev="00:1f.2", channel=255, ata_device=1,
- interface="SATA \tdevice: 1",
- sysfspath="/sys/firmware/edd/int13_dev80"),
+ sectors=312581808, host_bus="PCI", type="SATA",
+ pci_dev="00:1f.2", channel=255, ata_device=1,
+ interface="SATA \tdevice: 1",
+ sysfspath="/sys/firmware/edd/int13_dev80"),
0x81: FakeEddEntry(version="0x21", mbr_sig="0x96a20d28",
- sectors=31293440, host_bus="PCI", type="USB",
- pci_dev="ff:ff.255", channel=255,
- usb_serial=0x30302e31,
- interface="USB \tserial_number: 30302e31",
- sysfspath="/sys/firmware/edd/int13_dev81"),
- }
+ sectors=31293440, host_bus="PCI", type="USB",
+ pci_dev="ff:ff.255", channel=255,
+ usb_serial=0x30302e31,
+ interface="USB \tserial_number: 30302e31",
+ sysfspath="/sys/firmware/edd/int13_dev81"),
+ }
edd_dict = edd.collect_edd_data()
self.debug('edd_dict: %s', edd_dict)
debugs = [
("edd: found device 0x%x at %s", 0x80,
- '/sys/firmware/edd/int13_dev80'),
+ '/sys/firmware/edd/int13_dev80'),
("edd: found device 0x%x at %s", 0x81,
- '/sys/firmware/edd/int13_dev81'),
- ]
+ '/sys/firmware/edd/int13_dev81'),
+ ]
self.assertEqual(len(edd_dict), 2)
self.assertEqual(fakeedd[0x80], edd_dict[0x80])
self.assertEqual(fakeedd[0x81], edd_dict[0x81])
@@ -139,23 +139,23 @@ def test_get_edd_dict_sata_usb(self):
# test with sata sda, usb sdb
self._set_fs_root(edd, "sata_usb")
devices = (FakeDevice("sda"),
- FakeDevice("sdb"),
- )
+ FakeDevice("sdb"),
+ )
fakeedd = {
0x80: FakeEddEntry(version="0x30", mbr_sig="0x00000000",
- sectors=312581808, host_bus="PCI", type="SATA",
- pci_dev="00:1f.2", channel=255, ata_device=1,
- interface="SATA \tdevice: 1",
- sysfspath="/sys/firmware/edd/int13_dev80",
- sysfslink="../devices/pci0000:00/0000:00:1f.2/ata2"
- "/host1/target1:0:0/1:0:0:0/block/sda"),
+ sectors=312581808, host_bus="PCI", type="SATA",
+ pci_dev="00:1f.2", channel=255, ata_device=1,
+ interface="SATA \tdevice: 1",
+ sysfspath="/sys/firmware/edd/int13_dev80",
+ sysfslink="../devices/pci0000:00/0000:00:1f.2/ata2"
+ "/host1/target1:0:0/1:0:0:0/block/sda"),
0x81: FakeEddEntry(version="0x21", mbr_sig="0x96a20d28",
- sectors=31293440, host_bus="PCI", type="USB",
- pci_dev="ff:ff.255", channel=255,
- usb_serial=0x30302e31,
- interface="USB \tserial_number: 30302e31",
- sysfspath="/sys/firmware/edd/int13_dev81"),
- }
+ sectors=31293440, host_bus="PCI", type="USB",
+ pci_dev="ff:ff.255", channel=255,
+ usb_serial=0x30302e31,
+ interface="USB \tserial_number: 30302e31",
+ sysfspath="/sys/firmware/edd/int13_dev81"),
+ }
edd_dict = edd.get_edd_dict(devices)
self.debug('edd_dict: %s', edd_dict)
@@ -166,19 +166,19 @@ def test_get_edd_dict_sata_usb(self):
("edd: data extracted from 0x%x:\n%s", 0x80, fakeedd[0x80]),
("edd: data extracted from 0x%x:\n%s", 0x81, fakeedd[0x81]),
("edd: found device 0x%x at %s", 0x80,
- '/sys/firmware/edd/int13_dev80'),
+ '/sys/firmware/edd/int13_dev80'),
("edd: found device 0x%x at %s", 0x81,
- '/sys/firmware/edd/int13_dev81'),
- ]
+ '/sys/firmware/edd/int13_dev81'),
+ ]
infos = [
("edd: MBR signature on %s is zero. new disk image?", "sda"),
("edd: collected mbr signatures: %s", {'sdb': '0x96a20d28'}),
("edd: matched 0x%x to %s using PCI dev", 0x80, "sda"),
("edd: matched 0x%x to %s using MBR sig", 0x81, "sdb"),
- ]
+ ]
warnings = [
("edd: interface type %s is not implemented (%s)", "USB",
"/sys/firmware/edd/int13_dev81"),
("edd: interface details: %s", "USB \tserial_number: 30302e31"),
- ]
+ ]
self.check_logs(debugs=debugs, infos=infos, warnings=warnings)
diff --git a/tests/devicelibs_test/raid_test.py b/tests/devicelibs_test/raid_test.py
index 0298fc7..5b1a039 100644
--- a/tests/devicelibs_test/raid_test.py
+++ b/tests/devicelibs_test/raid_test.py
@@ -115,15 +115,15 @@ def test_raid(self):
sizes = [Size("32MiB"), Size("128MiB"), Size("128MiB"), Size("64MiB")]
for r in (l for l in raid.ALL_LEVELS if l not in (raid.Container, raid.Dup)):
self.assertEqual(r.get_size(sizes, 4, Size("1MiB"), lambda x: Size(0)),
- r.get_net_array_size(4, Size("32MiB")) if isinstance(r, raid.RAIDn) else sum(sizes, Size(0)))
+ r.get_net_array_size(4, Size("32MiB")) if isinstance(r, raid.RAIDn) else sum(sizes, Size(0)))
for r in (l for l in raid.ALL_LEVELS if l not in (raid.Container, raid.Dup)):
self.assertEqual(r.get_size(sizes, 5, Size("1MiB"), lambda x: Size(0)),
- r.get_net_array_size(5, Size("32MiB")) if isinstance(r, raid.RAIDn) else sum(sizes, Size(0)))
+ r.get_net_array_size(5, Size("32MiB")) if isinstance(r, raid.RAIDn) else sum(sizes, Size(0)))
for r in (l for l in raid.ALL_LEVELS if l not in (raid.Container, raid.Dup)):
self.assertEqual(r.get_size(sizes, 4, Size("1MiB"), lambda x: Size("32MiB")),
- Size(0) if isinstance(r, raid.RAIDn) else (sum(sizes, Size(0)) - 4 * Size("32MiB")))
+ Size(0) if isinstance(r, raid.RAIDn) else (sum(sizes, Size(0)) - 4 * Size("32MiB")))
for r in (l for l in raid.ALL_LEVELS if l not in (raid.Container, raid.Dup)):
if isinstance(r, raid.RAIDn):
@@ -138,9 +138,9 @@ def test_raid(self):
# names
##
self.assertListEqual(raid.RAID0.names,
- ["raid0", "stripe", "RAID0", "0", 0])
+ ["raid0", "stripe", "RAID0", "0", 0])
self.assertListEqual(raid.RAID10.names,
- ["raid10", "RAID10", "10", 10])
+ ["raid10", "RAID10", "10", 10])
##
# __init__
diff --git a/tests/devices_test/device_properties_test.py b/tests/devices_test/device_properties_test.py
index 0887d89..e9ee634 100644
--- a/tests/devices_test/device_properties_test.py
+++ b/tests/devices_test/device_properties_test.py
@@ -60,29 +60,29 @@ class DeviceStateTestCase(unittest.TestCase):
def __init__(self, methodName='run_test'):
self._state_functions = {
- "current_size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
- "direct": xform(self.assertTrue),
- "exists": xform(self.assertFalse),
- "format": xform(self.assertIsNotNone),
- "format_args": xform(lambda x, m: self.assertEqual(x, [], m)),
- "is_disk": xform(self.assertFalse),
- "isleaf": xform(self.assertTrue),
- "major": xform(lambda x, m: self.assertEqual(x, 0, m)),
- "max_size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
- "media_present": xform(self.assertTrue),
- "minor": xform(lambda x, m: self.assertEqual(x, 0, m)),
- "parents": xform(lambda x, m: self.assertEqual(len(x), 0, m) and
- self.assertIsInstance(x, ParentList, m)),
- "partitionable": xform(self.assertFalse),
- "path": xform(lambda x, m: self.assertRegex(x, "^/dev", m)),
- "raw_device": xform(self.assertIsNotNone),
- "resizable": xform(self.assertFalse),
- "size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
- "status": xform(self.assertFalse),
- "sysfs_path": xform(lambda x, m: self.assertEqual(x, "", m)),
- "target_size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
- "type": xform(lambda x, m: self.assertEqual(x, "mdarray", m)),
- "uuid": xform(self.assertIsNone)
+ "current_size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ "direct": xform(self.assertTrue),
+ "exists": xform(self.assertFalse),
+ "format": xform(self.assertIsNotNone),
+ "format_args": xform(lambda x, m: self.assertEqual(x, [], m)),
+ "is_disk": xform(self.assertFalse),
+ "isleaf": xform(self.assertTrue),
+ "major": xform(lambda x, m: self.assertEqual(x, 0, m)),
+ "max_size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ "media_present": xform(self.assertTrue),
+ "minor": xform(lambda x, m: self.assertEqual(x, 0, m)),
+ "parents": xform(lambda x, m: self.assertEqual(len(x), 0, m) and
+ self.assertIsInstance(x, ParentList, m)),
+ "partitionable": xform(self.assertFalse),
+ "path": xform(lambda x, m: self.assertRegex(x, "^/dev", m)),
+ "raw_device": xform(self.assertIsNotNone),
+ "resizable": xform(self.assertFalse),
+ "size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ "status": xform(self.assertFalse),
+ "sysfs_path": xform(lambda x, m: self.assertEqual(x, "", m)),
+ "target_size": xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ "type": xform(lambda x, m: self.assertEqual(x, "mdarray", m)),
+ "uuid": xform(self.assertIsNone)
}
super(DeviceStateTestCase, self).__init__(methodName=methodName)
@@ -122,17 +122,17 @@ class MDRaidArrayDeviceTestCase(DeviceStateTestCase):
def __init__(self, methodName='run_test'):
super(MDRaidArrayDeviceTestCase, self).__init__(methodName=methodName)
state_functions = {
- "create_bitmap": xform(lambda d, a: self.assertFalse),
- "description": xform(self.assertIsNotNone),
- "format_class": xform(self.assertIsNotNone),
- "level": xform(self.assertIsNone),
- "mdadm_format_uuid": xform(self.assertIsNone),
- "member_devices": xform(lambda x, m: self.assertEqual(x, 0, m)),
- "members": xform(lambda x, m: self.assertEqual(len(x), 0, m) and
- self.assertIsInstance(x, list, m)),
- "metadata_version": xform(lambda x, m: self.assertEqual(x, "default", m)),
- "spares": xform(lambda x, m: self.assertEqual(x, 0, m)),
- "total_devices": xform(lambda x, m: self.assertEqual(x, 0, m))
+ "create_bitmap": xform(lambda d, a: self.assertFalse),
+ "description": xform(self.assertIsNotNone),
+ "format_class": xform(self.assertIsNotNone),
+ "level": xform(self.assertIsNone),
+ "mdadm_format_uuid": xform(self.assertIsNone),
+ "member_devices": xform(lambda x, m: self.assertEqual(x, 0, m)),
+ "members": xform(lambda x, m: self.assertEqual(len(x), 0, m) and
+ self.assertIsInstance(x, list, m)),
+ "metadata_version": xform(lambda x, m: self.assertEqual(x, "default", m)),
+ "spares": xform(lambda x, m: self.assertEqual(x, 0, m)),
+ "total_devices": xform(lambda x, m: self.assertEqual(x, 0, m))
}
self._state_functions.update(state_functions)
@@ -143,207 +143,207 @@ def setUp(self):
MDRaidArrayDevice.get_superblock_size = lambda a, s: Size(0)
parents = [
- DiskDevice("name1", fmt=get_format("mdmember"))
+ DiskDevice("name1", fmt=get_format("mdmember"))
]
self.dev1 = MDContainerDevice("dev1", level="container", parents=parents, total_devices=1, member_devices=1)
parents = [
- DiskDevice("name1", fmt=get_format("mdmember"), size=Size("1 GiB")),
- DiskDevice("name2", fmt=get_format("mdmember"), size=Size("1 GiB"))
+ DiskDevice("name1", fmt=get_format("mdmember"), size=Size("1 GiB")),
+ DiskDevice("name2", fmt=get_format("mdmember"), size=Size("1 GiB"))
]
self.dev2 = MDRaidArrayDevice("dev2", level="raid0", parents=parents,
total_devices=2, member_devices=2)
parents = [
- DiskDevice("name1", fmt=get_format("mdmember")),
- DiskDevice("name2", fmt=get_format("mdmember"))
+ DiskDevice("name1", fmt=get_format("mdmember")),
+ DiskDevice("name2", fmt=get_format("mdmember"))
]
self.dev3 = MDRaidArrayDevice("dev3", level="raid1", parents=parents)
parents = [
- DiskDevice("name1", fmt=get_format("mdmember")),
- DiskDevice("name2", fmt=get_format("mdmember")),
- DiskDevice("name3", fmt=get_format("mdmember"))
+ DiskDevice("name1", fmt=get_format("mdmember")),
+ DiskDevice("name2", fmt=get_format("mdmember")),
+ DiskDevice("name3", fmt=get_format("mdmember"))
]
self.dev4 = MDRaidArrayDevice("dev4", level="raid4", parents=parents)
parents = [
- DiskDevice("name1", fmt=get_format("mdmember")),
- DiskDevice("name2", fmt=get_format("mdmember")),
- DiskDevice("name3", fmt=get_format("mdmember"))
+ DiskDevice("name1", fmt=get_format("mdmember")),
+ DiskDevice("name2", fmt=get_format("mdmember")),
+ DiskDevice("name3", fmt=get_format("mdmember"))
]
self.dev5 = MDRaidArrayDevice("dev5", level="raid5", parents=parents)
parents = [
- DiskDevice("name1", fmt=get_format("mdmember")),
- DiskDevice("name2", fmt=get_format("mdmember")),
- DiskDevice("name3", fmt=get_format("mdmember")),
- DiskDevice("name4", fmt=get_format("mdmember"))
+ DiskDevice("name1", fmt=get_format("mdmember")),
+ DiskDevice("name2", fmt=get_format("mdmember")),
+ DiskDevice("name3", fmt=get_format("mdmember")),
+ DiskDevice("name4", fmt=get_format("mdmember"))
]
self.dev6 = MDRaidArrayDevice("dev6", level="raid6", parents=parents)
parents = [
- DiskDevice("name1", fmt=get_format("mdmember")),
- DiskDevice("name2", fmt=get_format("mdmember")),
- DiskDevice("name3", fmt=get_format("mdmember")),
- DiskDevice("name4", fmt=get_format("mdmember"))
+ DiskDevice("name1", fmt=get_format("mdmember")),
+ DiskDevice("name2", fmt=get_format("mdmember")),
+ DiskDevice("name3", fmt=get_format("mdmember")),
+ DiskDevice("name4", fmt=get_format("mdmember"))
]
self.dev7 = MDRaidArrayDevice("dev7", level="raid10", parents=parents)
self.dev8 = MDRaidArrayDevice("dev8", level=1, exists=True)
parents_1 = [
- DiskDevice("name1", fmt=get_format("mdmember")),
- DiskDevice("name2", fmt=get_format("mdmember"))
+ DiskDevice("name1", fmt=get_format("mdmember")),
+ DiskDevice("name2", fmt=get_format("mdmember"))
]
dev_1 = MDContainerDevice(
- "parent",
- level="container",
- parents=parents_1,
- total_devices=2,
- member_devices=2,
- exists=True
+ "parent",
+ level="container",
+ parents=parents_1,
+ total_devices=2,
+ member_devices=2,
+ exists=True
)
self.dev9 = MDBiosRaidArrayDevice(
- "dev9",
- level="raid0",
- member_devices=1,
- parents=[dev_1],
- total_devices=1,
- exists=True
+ "dev9",
+ level="raid0",
+ member_devices=1,
+ parents=[dev_1],
+ total_devices=1,
+ exists=True
)
parents = [
- DiskDevice("name1", fmt=get_format("mdmember")),
- DiskDevice("name2", fmt=get_format("mdmember"))
+ DiskDevice("name1", fmt=get_format("mdmember")),
+ DiskDevice("name2", fmt=get_format("mdmember"))
]
self.dev10 = MDRaidArrayDevice(
- "dev10",
- level="raid0",
- parents=parents,
- size=Size("32 MiB"))
+ "dev10",
+ level="raid0",
+ parents=parents,
+ size=Size("32 MiB"))
parents_1 = [
- DiskDevice("name1", fmt=get_format("mdmember")),
- DiskDevice("name2", fmt=get_format("mdmember"))
+ DiskDevice("name1", fmt=get_format("mdmember")),
+ DiskDevice("name2", fmt=get_format("mdmember"))
]
dev_1 = MDContainerDevice(
- "parent",
- level="container",
- parents=parents,
- total_devices=2,
- member_devices=2
+ "parent",
+ level="container",
+ parents=parents,
+ total_devices=2,
+ member_devices=2
)
self.dev11 = MDBiosRaidArrayDevice(
- "dev11",
- level=1,
- exists=True,
- parents=[dev_1],
- size=Size("32 MiB"))
+ "dev11",
+ level=1,
+ exists=True,
+ parents=[dev_1],
+ size=Size("32 MiB"))
self.dev13 = MDRaidArrayDevice(
- "dev13",
- level=0,
- member_devices=2,
- parents=[
- Mock(**{"size": Size("4 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("2 MiB"),
- "format": get_format("mdmember")})],
- size=Size("32 MiB"),
- total_devices=2)
+ "dev13",
+ level=0,
+ member_devices=2,
+ parents=[
+ Mock(**{"size": Size("4 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("2 MiB"),
+ "format": get_format("mdmember")})],
+ size=Size("32 MiB"),
+ total_devices=2)
self.dev14 = MDRaidArrayDevice(
- "dev14",
- level=4,
- member_devices=3,
- parents=[
- Mock(**{"size": Size("4 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("2 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("2 MiB"),
- "format": get_format("mdmember")})],
- total_devices=3)
+ "dev14",
+ level=4,
+ member_devices=3,
+ parents=[
+ Mock(**{"size": Size("4 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("2 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("2 MiB"),
+ "format": get_format("mdmember")})],
+ total_devices=3)
self.dev15 = MDRaidArrayDevice(
- "dev15",
- level=5,
- member_devices=3,
- parents=[
- Mock(**{"size": Size("4 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("2 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("2 MiB"),
- "format": get_format("mdmember")})],
- total_devices=3)
+ "dev15",
+ level=5,
+ member_devices=3,
+ parents=[
+ Mock(**{"size": Size("4 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("2 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("2 MiB"),
+ "format": get_format("mdmember")})],
+ total_devices=3)
self.dev16 = MDRaidArrayDevice(
- "dev16",
- level=6,
- member_devices=4,
- parents=[
- Mock(**{"size": Size("4 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("4 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("2 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("2 MiB"),
- "format": get_format("mdmember")})],
- total_devices=4)
+ "dev16",
+ level=6,
+ member_devices=4,
+ parents=[
+ Mock(**{"size": Size("4 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("4 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("2 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("2 MiB"),
+ "format": get_format("mdmember")})],
+ total_devices=4)
self.dev17 = MDRaidArrayDevice(
- "dev17",
- level=10,
- member_devices=4,
- parents=[
- Mock(**{"size": Size("4 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("4 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("2 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("2 MiB"),
- "format": get_format("mdmember")})],
- total_devices=4)
+ "dev17",
+ level=10,
+ member_devices=4,
+ parents=[
+ Mock(**{"size": Size("4 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("4 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("2 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("2 MiB"),
+ "format": get_format("mdmember")})],
+ total_devices=4)
self.dev18 = MDRaidArrayDevice(
- "dev18",
- level=10,
- member_devices=4,
- parents=[
- Mock(**{"size": Size("4 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("4 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("2 MiB"),
- "format": get_format("mdmember")}),
- Mock(**{"size": Size("2 MiB"),
- "format": get_format("mdmember")})],
- total_devices=5)
+ "dev18",
+ level=10,
+ member_devices=4,
+ parents=[
+ Mock(**{"size": Size("4 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("4 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("2 MiB"),
+ "format": get_format("mdmember")}),
+ Mock(**{"size": Size("2 MiB"),
+ "format": get_format("mdmember")})],
+ total_devices=5)
parents = [
- DiskDevice("name1", fmt=get_format("mdmember")),
- DiskDevice("name2", fmt=get_format("mdmember"))
+ DiskDevice("name1", fmt=get_format("mdmember")),
+ DiskDevice("name2", fmt=get_format("mdmember"))
]
self.dev19 = MDRaidArrayDevice(
- "dev19",
- level="raid1",
- parents=parents,
- uuid='3386ff85-f501-2621-4a43-5f061eb47236'
+ "dev19",
+ level="raid1",
+ parents=parents,
+ uuid='3386ff85-f501-2621-4a43-5f061eb47236'
)
parents = [
- DiskDevice("name1", fmt=get_format("mdmember")),
- DiskDevice("name2", fmt=get_format("mdmember"))
+ DiskDevice("name1", fmt=get_format("mdmember")),
+ DiskDevice("name2", fmt=get_format("mdmember"))
]
self.dev20 = MDRaidArrayDevice(
- "dev20",
- level="raid1",
- parents=parents,
- uuid='Just-pretending'
+ "dev20",
+ level="raid1",
+ parents=parents,
+ uuid='Just-pretending'
)
def tearDown(self):
@@ -360,180 +360,180 @@ def test_mdraid_array_device_init(self):
# level tests
##
self.state_check(self.dev1,
- level=xform(lambda x, m: self.assertEqual(x.name, "container", m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
- member_devices=xform(lambda x, m: self.assertEqual(x, 1, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
- media_present=xform(self.assertFalse),
- total_devices=xform(lambda x, m: self.assertEqual(x, 1, m)),
- type=xform(lambda x, m: self.assertEqual(x, "mdcontainer", m)))
+ level=xform(lambda x, m: self.assertEqual(x.name, "container", m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+ member_devices=xform(lambda x, m: self.assertEqual(x, 1, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+ media_present=xform(self.assertFalse),
+ total_devices=xform(lambda x, m: self.assertEqual(x, 1, m)),
+ type=xform(lambda x, m: self.assertEqual(x, "mdcontainer", m)))
self.state_check(self.dev2,
- create_bitmap=xform(self.assertFalse),
- level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
- member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- size=xform(lambda x, m: self.assertEqual(x, Size("2 GiB"), m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)))
+ create_bitmap=xform(self.assertFalse),
+ level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
+ member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("2 GiB"), m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)))
self.state_check(self.dev3,
- level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)))
+ level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)))
self.state_check(self.dev4,
- level=xform(lambda x, m: self.assertEqual(x.number, 4, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 3, m)))
+ level=xform(lambda x, m: self.assertEqual(x.number, 4, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 3, m)))
self.state_check(self.dev5,
- level=xform(lambda x, m: self.assertEqual(x.number, 5, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 3, m)))
+ level=xform(lambda x, m: self.assertEqual(x.number, 5, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 3, m)))
self.state_check(self.dev6,
- level=xform(lambda x, m: self.assertEqual(x.number, 6, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 4, m)))
+ level=xform(lambda x, m: self.assertEqual(x.number, 6, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 4, m)))
self.state_check(self.dev7,
- level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 4, m)))
+ level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 4, m)))
##
# existing device tests
##
self.state_check(self.dev8,
- exists=xform(self.assertTrue),
- level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
- metadata_version=xform(self.assertIsNone))
+ exists=xform(self.assertTrue),
+ level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+ metadata_version=xform(self.assertIsNone))
##
# mdbiosraidarray tests
##
self.state_check(self.dev9,
- create_bitmap=xform(self.assertFalse),
- is_disk=xform(self.assertTrue),
- exists=xform(self.assertTrue),
- level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
- member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
- partitionable=xform(self.assertTrue),
- total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
- type=xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)))
+ create_bitmap=xform(self.assertFalse),
+ is_disk=xform(self.assertTrue),
+ exists=xform(self.assertTrue),
+ level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
+ member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+ partitionable=xform(self.assertTrue),
+ total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ type=xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)))
##
# mdcontainer tests
##
dev9_container = self.dev9.parents[0]
self.state_check(dev9_container,
- create_bitmap=xform(self.assertFalse),
- direct=xform(self.assertFalse),
- is_disk=xform(self.assertFalse),
- isleaf=xform(self.assertFalse),
- exists=xform(self.assertTrue),
- level=xform(lambda x, m: self.assertEqual(x.name, "container", m)),
- media_present=xform(self.assertFalse),
- member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- partitionable=xform(self.assertFalse),
- total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
- type=xform(lambda x, m: self.assertEqual(x, "mdcontainer", m)))
+ create_bitmap=xform(self.assertFalse),
+ direct=xform(self.assertFalse),
+ is_disk=xform(self.assertFalse),
+ isleaf=xform(self.assertFalse),
+ exists=xform(self.assertTrue),
+ level=xform(lambda x, m: self.assertEqual(x.name, "container", m)),
+ media_present=xform(self.assertFalse),
+ member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ partitionable=xform(self.assertFalse),
+ total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ type=xform(lambda x, m: self.assertEqual(x, "mdcontainer", m)))
##
# size tests
##
self.state_check(self.dev10,
- create_bitmap=xform(self.assertFalse),
- level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- target_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)))
+ create_bitmap=xform(self.assertFalse),
+ level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ target_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)))
self.state_check(self.dev11,
- is_disk=xform(self.assertTrue),
- exists=xform(lambda x, m: self.assertEqual(x, True, m)),
- level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
- current_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
- max_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
- member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)),
- parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
- partitionable=xform(self.assertTrue),
- size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
- target_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
- total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
- type=xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)))
+ is_disk=xform(self.assertTrue),
+ exists=xform(lambda x, m: self.assertEqual(x, True, m)),
+ level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+ current_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+ max_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+ member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ partitionable=xform(self.assertTrue),
+ size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+ target_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+ total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ type=xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)))
self.state_check(self.dev13,
- create_bitmap=xform(self.assertFalse),
- level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
- member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
- size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
- target_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
- total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)))
+ create_bitmap=xform(self.assertFalse),
+ level=xform(lambda x, m: self.assertEqual(x.number, 0, m)),
+ member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
+ target_size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)),
+ total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)))
self.state_check(self.dev14,
- create_bitmap=xform(self.assertTrue),
- level=xform(lambda x, m: self.assertEqual(x.number, 4, m)),
- member_devices=xform(lambda x, m: self.assertEqual(x, 3, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
- parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
- size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
- total_devices=xform(lambda x, m: self.assertEqual(x, 3, m)))
+ create_bitmap=xform(self.assertTrue),
+ level=xform(lambda x, m: self.assertEqual(x.number, 4, m)),
+ member_devices=xform(lambda x, m: self.assertEqual(x, 3, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
+ total_devices=xform(lambda x, m: self.assertEqual(x, 3, m)))
self.state_check(self.dev15,
- create_bitmap=xform(self.assertTrue),
- level=xform(lambda x, m: self.assertEqual(x.number, 5, m)),
- member_devices=xform(lambda x, m: self.assertEqual(x, 3, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
- parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
- size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
- total_devices=xform(lambda x, m: self.assertEqual(x, 3, m)))
+ create_bitmap=xform(self.assertTrue),
+ level=xform(lambda x, m: self.assertEqual(x.number, 5, m)),
+ member_devices=xform(lambda x, m: self.assertEqual(x, 3, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 3, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
+ total_devices=xform(lambda x, m: self.assertEqual(x, 3, m)))
self.state_check(self.dev16,
- create_bitmap=xform(self.assertTrue),
- level=xform(lambda x, m: self.assertEqual(x.number, 6, m)),
- member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
- parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
- size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
- total_devices=xform(lambda x, m: self.assertEqual(x, 4, m)))
+ create_bitmap=xform(self.assertTrue),
+ level=xform(lambda x, m: self.assertEqual(x.number, 6, m)),
+ member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
+ total_devices=xform(lambda x, m: self.assertEqual(x, 4, m)))
self.state_check(self.dev17,
- create_bitmap=xform(self.assertTrue),
- level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
- member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
- parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
- size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
- total_devices=xform(lambda x, m: self.assertEqual(x, 4, m)))
+ create_bitmap=xform(self.assertTrue),
+ level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
+ member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
+ total_devices=xform(lambda x, m: self.assertEqual(x, 4, m)))
self.state_check(self.dev18,
- create_bitmap=xform(self.assertTrue),
- level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
- member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
- parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
- size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
- spares=xform(lambda x, m: self.assertEqual(x, 1, m)),
- total_devices=xform(lambda x, m: self.assertEqual(x, 5, m)))
+ create_bitmap=xform(self.assertTrue),
+ level=xform(lambda x, m: self.assertEqual(x.number, 10, m)),
+ member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 4, m)),
+ parents=xform(lambda x, m: self.assertNotEqual(x, [], m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)),
+ spares=xform(lambda x, m: self.assertEqual(x, 1, m)),
+ total_devices=xform(lambda x, m: self.assertEqual(x, 5, m)))
self.state_check(self.dev19,
- level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
- mdadm_format_uuid=xform(lambda x, m: self.assertEqual(x, blockdev.md.get_md_uuid(self.dev19.uuid), m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- uuid=xform(lambda x, m: self.assertEqual(x, self.dev19.uuid, m)))
+ level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+ mdadm_format_uuid=xform(lambda x, m: self.assertEqual(x, blockdev.md.get_md_uuid(self.dev19.uuid), m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ uuid=xform(lambda x, m: self.assertEqual(x, self.dev19.uuid, m)))
self.state_check(self.dev20,
- level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
- members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
- uuid=xform(lambda x, m: self.assertEqual(x, self.dev20.uuid, m)))
+ level=xform(lambda x, m: self.assertEqual(x.number, 1, m)),
+ members=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)),
+ uuid=xform(lambda x, m: self.assertEqual(x, self.dev20.uuid, m)))
with self.assertRaisesRegex(DeviceError, "invalid"):
MDRaidArrayDevice("dev")
@@ -543,14 +543,14 @@ def test_mdraid_array_device_init(self):
with self.assertRaisesRegex(DeviceError, "invalid"):
MDRaidArrayDevice(
- "dev",
- parents=[StorageDevice("parent", fmt=get_format("mdmember"))])
+ "dev",
+ parents=[StorageDevice("parent", fmt=get_format("mdmember"))])
with self.assertRaisesRegex(DeviceError, "at least 2 members"):
MDRaidArrayDevice(
- "dev",
- level="raid0",
- parents=[StorageDevice("parent", fmt=get_format("mdmember"))])
+ "dev",
+ level="raid0",
+ parents=[StorageDevice("parent", fmt=get_format("mdmember"))])
with self.assertRaisesRegex(DeviceError, "invalid"):
MDRaidArrayDevice("dev", level="junk")
@@ -578,29 +578,29 @@ class BTRFSDeviceTestCase(DeviceStateTestCase):
def __init__(self, methodName='run_test'):
super(BTRFSDeviceTestCase, self).__init__(methodName=methodName)
state_functions = {
- "data_level": lambda d, a: self.assertFalse(hasattr(d, a)),
- "fstab_spec": xform(self.assertIsNotNone),
- "media_present": xform(self.assertTrue),
- "metadata_level": lambda d, a: self.assertFalse(hasattr(d, a)),
- "type": xform(lambda x, m: self.assertEqual(x, "btrfs", m)),
- "vol_id": xform(lambda x, m: self.assertEqual(x, btrfs.MAIN_VOLUME_ID, m))}
+ "data_level": lambda d, a: self.assertFalse(hasattr(d, a)),
+ "fstab_spec": xform(self.assertIsNotNone),
+ "media_present": xform(self.assertTrue),
+ "metadata_level": lambda d, a: self.assertFalse(hasattr(d, a)),
+ "type": xform(lambda x, m: self.assertEqual(x, "btrfs", m)),
+ "vol_id": xform(lambda x, m: self.assertEqual(x, btrfs.MAIN_VOLUME_ID, m))}
self._state_functions.update(state_functions)
def setUp(self):
self.dev1 = BTRFSVolumeDevice("dev1",
- parents=[StorageDevice("deva",
- fmt=blivet.formats.get_format("btrfs"),
- size=BTRFS_MIN_MEMBER_SIZE)])
+ parents=[StorageDevice("deva",
+ fmt=blivet.formats.get_format("btrfs"),
+ size=BTRFS_MIN_MEMBER_SIZE)])
self.dev2 = BTRFSSubVolumeDevice("dev2",
- parents=[self.dev1],
- fmt=blivet.formats.get_format("btrfs"))
+ parents=[self.dev1],
+ fmt=blivet.formats.get_format("btrfs"))
dev = StorageDevice("deva",
- fmt=blivet.formats.get_format("btrfs"),
- size=Size("500 MiB"))
+ fmt=blivet.formats.get_format("btrfs"),
+ size=Size("500 MiB"))
self.dev3 = BTRFSVolumeDevice("dev3",
- parents=[dev])
+ parents=[dev])
def test_btrfsdevice_init(self):
"""Tests the state of a BTRFSDevice after initialization.
@@ -609,32 +609,32 @@ def test_btrfsdevice_init(self):
"""
self.state_check(self.dev1,
- current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- data_level=xform(self.assertIsNone),
- isleaf=xform(self.assertFalse),
- max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- metadata_level=xform(self.assertIsNone),
- parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
- size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
+ current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ data_level=xform(self.assertIsNone),
+ isleaf=xform(self.assertFalse),
+ max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ metadata_level=xform(self.assertIsNone),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+ size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
self.state_check(self.dev2,
- target_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
- size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- type=xform(lambda x, m: self.assertEqual(x, "btrfs subvolume", m)),
- vol_id=xform(self.assertIsNone))
+ target_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+ size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ type=xform(lambda x, m: self.assertEqual(x, "btrfs subvolume", m)),
+ vol_id=xform(self.assertIsNone))
self.state_check(self.dev3,
- current_size=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
- data_level=xform(self.assertIsNone),
- max_size=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
- metadata_level=xform(self.assertIsNone),
- parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
- size=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
- type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
+ current_size=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
+ data_level=xform(self.assertIsNone),
+ max_size=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
+ metadata_level=xform(self.assertIsNone),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+ size=xform(lambda x, m: self.assertEqual(x, Size("500 MiB"), m)),
+ type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
with self.assertRaisesRegex(ValueError, "BTRFSDevice.*must have at least one parent"):
BTRFSVolumeDevice("dev")
@@ -703,27 +703,27 @@ def test_btrfssnap_shot_device_init(self):
vol.exists = True
snap = BTRFSSnapShotDevice("snap1",
- fmt=blivet.formats.get_format("btrfs"),
- parents=[vol],
- source=vol)
+ fmt=blivet.formats.get_format("btrfs"),
+ parents=[vol],
+ source=vol)
self.state_check(snap,
- current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- target_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
- size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- type=xform(lambda x, m: self.assertEqual(x, "btrfs snapshot", m)),
- vol_id=xform(self.assertIsNone))
+ current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ target_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+ size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ type=xform(lambda x, m: self.assertEqual(x, "btrfs snapshot", m)),
+ vol_id=xform(self.assertIsNone))
self.state_check(vol,
- current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- data_level=xform(self.assertIsNone),
- exists=xform(self.assertTrue),
- isleaf=xform(self.assertFalse),
- max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- metadata_level=xform(self.assertIsNone),
- parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
- size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
- type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
+ current_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ data_level=xform(self.assertIsNone),
+ exists=xform(self.assertTrue),
+ isleaf=xform(self.assertFalse),
+ max_size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ metadata_level=xform(self.assertIsNone),
+ parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)),
+ size=xform(lambda x, m: self.assertEqual(x, BTRFS_MIN_MEMBER_SIZE, m)),
+ type=xform(lambda x, m: self.assertEqual(x, "btrfs volume", m)))
self.assertEqual(snap.isleaf, True)
self.assertEqual(snap.direct, True)
@@ -743,7 +743,7 @@ def __init__(self, methodName="run_test"):
"parents": xform(lambda x, m: self.assertEqual(len(x), 1, m) and
self.assertIsInstance(x, ParentList) and
self.assertIsInstance(x[0], LVMVolumeGroupDevice)),
- }
+ }
self._state_functions.update(state_functions)
@@ -761,71 +761,71 @@ def setUp(self):
vg2 = LVMVolumeGroupDevice("testvg2", parents=[pv2, pv3])
cache_req = LVMCacheRequest(Size("512 MiB"), [pv3], "writethrough")
self.cached_lv = LVMLogicalVolumeDevice("testcachedlv", parents=[vg2],
- fmt=blivet.formats.get_format("xfs"),
- exists=False, cache_request=cache_req)
+ fmt=blivet.formats.get_format("xfs"),
+ exists=False, cache_request=cache_req)
def test_lvmlogical_volume_device_init(self):
self.state_check(self.lv,
- # 1 GiB - one extent
- max_size=xform(lambda x, m: self.assertEqual(x, Size("1020 MiB"), m) and
- self.assertIsInstance(x, Size, m)),
- snapshots=xform(lambda x, m: self.assertEqual(x, [], m)),
- seg_type=xform(lambda x, m: self.assertEqual(x, "linear", m)),
- req_grow=xform(lambda x, m: self.assertEqual(x, None, m)),
- req_max_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
- self.assertIsInstance(x, Size, m)),
- req_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
- self.assertIsInstance(x, Size, m)),
- req_percent=xform(lambda x, m: self.assertEqual(x, Size(0), m)),
- copies=xform(lambda x, m: self.assertEqual(x, 1, m)),
- log_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
- self.assertIsInstance(x, Size, m)),
- metadata_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
- self.assertIsInstance(x, Size, m)),
- mirrored=xform(lambda x, m: self.assertFalse(x, m)),
- vg_space_used=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
- self.assertIsInstance(x, Size, m)),
- vg=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
- container=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
- map_name=xform(lambda x, m: self.assertEqual(x, "testvg-testlv", m)),
- path=xform(lambda x, m: self.assertEqual(x, "/dev/mapper/testvg-testlv", m)),
- lvname=xform(lambda x, m: self.assertEqual(x, "testlv", m)),
- complete=xform(lambda x, m: self.assertTrue(x, m)),
- isleaf=xform(lambda x, m: self.assertTrue(x, m)),
- direct=xform(lambda x, m: self.assertTrue(x, m)),
- cached=xform(lambda x, m: self.assertFalse(x, m)),
- )
+ # 1 GiB - one extent
+ max_size=xform(lambda x, m: self.assertEqual(x, Size("1020 MiB"), m) and
+ self.assertIsInstance(x, Size, m)),
+ snapshots=xform(lambda x, m: self.assertEqual(x, [], m)),
+ seg_type=xform(lambda x, m: self.assertEqual(x, "linear", m)),
+ req_grow=xform(lambda x, m: self.assertEqual(x, None, m)),
+ req_max_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+ self.assertIsInstance(x, Size, m)),
+ req_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+ self.assertIsInstance(x, Size, m)),
+ req_percent=xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ copies=xform(lambda x, m: self.assertEqual(x, 1, m)),
+ log_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+ self.assertIsInstance(x, Size, m)),
+ metadata_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+ self.assertIsInstance(x, Size, m)),
+ mirrored=xform(lambda x, m: self.assertFalse(x, m)),
+ vg_space_used=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+ self.assertIsInstance(x, Size, m)),
+ vg=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
+ container=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
+ map_name=xform(lambda x, m: self.assertEqual(x, "testvg-testlv", m)),
+ path=xform(lambda x, m: self.assertEqual(x, "/dev/mapper/testvg-testlv", m)),
+ lvname=xform(lambda x, m: self.assertEqual(x, "testlv", m)),
+ complete=xform(lambda x, m: self.assertTrue(x, m)),
+ isleaf=xform(lambda x, m: self.assertTrue(x, m)),
+ direct=xform(lambda x, m: self.assertTrue(x, m)),
+ cached=xform(lambda x, m: self.assertFalse(x, m)),
+ )
def test_lvmlogical_volume_device_init_cached(self):
self.state_check(self.cached_lv,
- # 2 * (1 GiB - one extent) - 512 MiB - 8 MiB
- # PVfree cache pmspare
- max_size=xform(lambda x, m: self.assertEqual(x, Size("1520 MiB"), m) and
- self.assertIsInstance(x, Size, m)),
- snapshots=xform(lambda x, m: self.assertEqual(x, [], m)),
- seg_type=xform(lambda x, m: self.assertEqual(x, "linear", m)),
- req_grow=xform(lambda x, m: self.assertEqual(x, None, m)),
- req_max_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
- self.assertIsInstance(x, Size, m)),
- req_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
- self.assertIsInstance(x, Size, m)),
- req_percent=xform(lambda x, m: self.assertEqual(x, Size(0), m)),
- copies=xform(lambda x, m: self.assertEqual(x, 1, m)),
- log_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
- self.assertIsInstance(x, Size, m)),
- metadata_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
- self.assertIsInstance(x, Size, m)),
- mirrored=xform(lambda x, m: self.assertFalse(x, m)),
- vg_space_used=xform(lambda x, m: self.assertEqual(x, Size("512 MiB"), m) and
- self.assertIsInstance(x, Size, m)),
- vg=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
- container=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
- map_name=xform(lambda x, m: self.assertEqual(x, "testvg2-testcachedlv", m)),
- path=xform(lambda x, m: self.assertEqual(x, "/dev/mapper/testvg2-testcachedlv", m)),
- lvname=xform(lambda x, m: self.assertEqual(x, "testcachedlv", m)),
- complete=xform(lambda x, m: self.assertTrue(x, m)),
- isleaf=xform(lambda x, m: self.assertTrue(x, m)),
- direct=xform(lambda x, m: self.assertTrue(x, m)),
- cached=xform(lambda x, m: self.assertTrue(x, m)),
- cache=xform(lambda x, m: self.assertIsInstance(x, LVMCache, m)),
- )
+ # 2 * (1 GiB - one extent) - 512 MiB - 8 MiB
+ # PVfree cache pmspare
+ max_size=xform(lambda x, m: self.assertEqual(x, Size("1520 MiB"), m) and
+ self.assertIsInstance(x, Size, m)),
+ snapshots=xform(lambda x, m: self.assertEqual(x, [], m)),
+ seg_type=xform(lambda x, m: self.assertEqual(x, "linear", m)),
+ req_grow=xform(lambda x, m: self.assertEqual(x, None, m)),
+ req_max_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+ self.assertIsInstance(x, Size, m)),
+ req_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+ self.assertIsInstance(x, Size, m)),
+ req_percent=xform(lambda x, m: self.assertEqual(x, Size(0), m)),
+ copies=xform(lambda x, m: self.assertEqual(x, 1, m)),
+ log_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+ self.assertIsInstance(x, Size, m)),
+ metadata_size=xform(lambda x, m: self.assertEqual(x, Size(0), m) and
+ self.assertIsInstance(x, Size, m)),
+ mirrored=xform(lambda x, m: self.assertFalse(x, m)),
+ vg_space_used=xform(lambda x, m: self.assertEqual(x, Size("512 MiB"), m) and
+ self.assertIsInstance(x, Size, m)),
+ vg=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
+ container=xform(lambda x, m: self.assertIsInstance(x, LVMVolumeGroupDevice)),
+ map_name=xform(lambda x, m: self.assertEqual(x, "testvg2-testcachedlv", m)),
+ path=xform(lambda x, m: self.assertEqual(x, "/dev/mapper/testvg2-testcachedlv", m)),
+ lvname=xform(lambda x, m: self.assertEqual(x, "testcachedlv", m)),
+ complete=xform(lambda x, m: self.assertTrue(x, m)),
+ isleaf=xform(lambda x, m: self.assertTrue(x, m)),
+ direct=xform(lambda x, m: self.assertTrue(x, m)),
+ cached=xform(lambda x, m: self.assertTrue(x, m)),
+ cache=xform(lambda x, m: self.assertIsInstance(x, LVMCache, m)),
+ )
diff --git a/tests/devices_test/lvm_test.py b/tests/devices_test/lvm_test.py
index 2094d6a..d3d761d 100644
--- a/tests/devices_test/lvm_test.py
+++ b/tests/devices_test/lvm_test.py
@@ -15,13 +15,13 @@
from blivet.size import Size
DEVICE_CLASSES = [
- LVMLogicalVolumeDevice,
- LVMSnapShotDevice,
- LVMThinLogicalVolumeDevice,
- LVMThinPoolDevice,
- LVMThinSnapShotDevice,
- LVMVolumeGroupDevice,
- StorageDevice
+ LVMLogicalVolumeDevice,
+ LVMSnapShotDevice,
+ LVMThinLogicalVolumeDevice,
+ LVMThinPoolDevice,
+ LVMThinSnapShotDevice,
+ LVMVolumeGroupDevice,
+ StorageDevice
]
@@ -98,7 +98,7 @@ def test_lvmcached_logical_volume_init(self):
pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"),
size=Size("1 GiB"))
pv2 = StorageDevice("pv2", fmt=blivet.formats.get_format("lvmpv"),
- size=Size("512 MiB"))
+ size=Size("512 MiB"))
vg = LVMVolumeGroupDevice("testvg", parents=[pv, pv2])
cache_req = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
@@ -147,7 +147,7 @@ def test_target_size(self):
# ValueError if size smaller than min_size
with self.assertRaisesRegex(ValueError,
- "size.*smaller than the minimum"):
+ "size.*smaller than the minimum"):
lv.target_size = Size("1 MiB")
# target size should be unchanged
@@ -155,7 +155,7 @@ def test_target_size(self):
# ValueError if size larger than max_size
with self.assertRaisesRegex(ValueError,
- "size.*larger than the maximum"):
+ "size.*larger than the maximum"):
lv.target_size = Size("1 GiB")
# target size should be unchanged
diff --git a/tests/devices_test/partition_test.py b/tests/devices_test/partition_test.py
index ee2227c..724541f 100644
--- a/tests/devices_test/partition_test.py
+++ b/tests/devices_test/partition_test.py
@@ -49,21 +49,21 @@ def test_target_size(self):
# ValueError if not Size
with self.assertRaisesRegex(ValueError,
- "new size must.*type Size"):
+ "new size must.*type Size"):
device.target_size = 22
self.assertEqual(device.target_size, orig_size)
# ValueError if size smaller than min_size
with self.assertRaisesRegex(ValueError,
- "size.*smaller than the minimum"):
+ "size.*smaller than the minimum"):
device.target_size = Size("1 MiB")
self.assertEqual(device.target_size, orig_size)
# ValueError if size larger than max_size
with self.assertRaisesRegex(ValueError,
- "size.*larger than the maximum"):
+ "size.*larger than the maximum"):
device.target_size = Size("11 MiB")
self.assertEqual(device.target_size, orig_size)
@@ -122,7 +122,7 @@ def test_min_max_size_alignment(self):
min_end_sector = partition.geometry.start + min_sectors - 1
self.assertEqual(
disk.format.end_alignment.isAligned(partition.geometry,
- min_end_sector),
+ min_end_sector),
False)
# The end sector based on device min size should be aligned.
@@ -130,7 +130,7 @@ def test_min_max_size_alignment(self):
min_end_sector = partition.geometry.start + min_sectors - 1
self.assertEqual(
disk.format.end_alignment.isAligned(partition.geometry,
- min_end_sector),
+ min_end_sector),
True)
##
diff --git a/tests/devicetree_test.py b/tests/devicetree_test.py
index cd8bd85..84848b6 100644
--- a/tests/devicetree_test.py
+++ b/tests/devicetree_test.py
@@ -42,7 +42,7 @@ def test_resolve_device(self):
dt._add_device(dev3)
dt.edd_dict.update({"dev1": 0x81,
- "dev2": 0x82})
+ "dev2": 0x82})
self.assertEqual(dt.resolve_device(dev1.name), dev1)
self.assertEqual(dt.resolve_device("LABEL=%s" % dev1_label), dev1)
@@ -88,8 +88,8 @@ def collect_expected_data(self):
""" Collect the attribute data we plan to validate later. """
# only look at devices on the disk images -- no loops, &c
for device in (d for d in self.blivet.devices
- if d.disks and
- set(d.disks).issubset(set(self.blivet.disks))):
+ if d.disks and
+ set(d.disks).issubset(set(self.blivet.disks))):
attr_dict = {}
device._parted_device = None # force update from disk for size, &c
for attr in self._validate_attrs:
@@ -161,8 +161,8 @@ def run_test(self):
actual = recursive_getattr(device, attr)
self.assertEqual(actual, expected,
- msg=("attribute mismatch for %s: %s (%s/%s)"
- % (device_id, attr, expected, actual)))
+ msg=("attribute mismatch for %s: %s (%s/%s)"
+ % (device_id, attr, expected, actual)))
class LVMTestCase(BlivetResetTestCase):
@@ -172,23 +172,23 @@ class LVMTestCase(BlivetResetTestCase):
def _set_up_storage(self):
# This isn't exactly autopart, but it should be plenty close to it.
self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
- Size("500 MiB"),
- disks=self.blivet.disks[:],
- fstype="swap")
+ Size("500 MiB"),
+ disks=self.blivet.disks[:],
+ fstype="swap")
self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
- None,
- disks=self.blivet.disks[:])
+ None,
+ disks=self.blivet.disks[:])
class LVMSnapShotTestCase(BlivetResetTestCase):
def _set_up_storage(self):
self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
- Size("1 GiB"),
- label="ROOT",
- disks=self.blivet.disks[:],
- container_name="blivet_test",
- container_size=devicefactory.SIZE_POLICY_MAX)
+ Size("1 GiB"),
+ label="ROOT",
+ disks=self.blivet.disks[:],
+ container_name="blivet_test",
+ container_size=devicefactory.SIZE_POLICY_MAX)
def setUp(self):
super(BlivetResetTestCase, self).setUp() # pylint: disable=bad-super-call
@@ -206,22 +206,22 @@ class LVMThinpTestCase(BlivetResetTestCase):
def _set_up_storage(self):
self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
- Size("500 MiB"),
- fstype="swap",
- disks=self.blivet.disks[:])
+ Size("500 MiB"),
+ fstype="swap",
+ disks=self.blivet.disks[:])
self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM_THINP,
- None,
- label="ROOT",
- disks=self.blivet.disks[:])
+ None,
+ label="ROOT",
+ disks=self.blivet.disks[:])
class LVMThinSnapShotTestCase(LVMThinpTestCase):
def _set_up_storage(self):
self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM_THINP,
- Size("1 GiB"),
- label="ROOT",
- disks=self.blivet.disks[:])
+ Size("1 GiB"),
+ label="ROOT",
+ disks=self.blivet.disks[:])
def setUp(self):
super(BlivetResetTestCase, self).setUp() # pylint: disable=bad-super-call
@@ -241,9 +241,9 @@ class LVMRaidTestCase(BlivetResetTestCase):
def _set_up_storage(self):
# This isn't exactly autopart, but it should be plenty close to it.
self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
- Size("500 MiB"),
- disks=self.blivet.disks[:],
- container_size=devicefactory.SIZE_POLICY_MAX)
+ Size("500 MiB"),
+ disks=self.blivet.disks[:],
+ container_size=devicefactory.SIZE_POLICY_MAX)
def setUp(self):
super(BlivetResetTestCase, self).setUp() # pylint: disable=bad-super-call
@@ -278,43 +278,43 @@ def skip_attr(self, device, attr):
def _set_up_storage(self):
device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
- Size("200 MiB"),
- disks=self.blivet.disks[:],
- raid_level=self.level,
- label="v090",
- name="2")
+ Size("200 MiB"),
+ disks=self.blivet.disks[:],
+ raid_level=self.level,
+ label="v090",
+ name="2")
device.metadata_version = "0.90"
device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
- Size("200 MiB"),
- disks=self.blivet.disks[:],
- raid_level=self.level,
- label="v1",
- name="one")
+ Size("200 MiB"),
+ disks=self.blivet.disks[:],
+ raid_level=self.level,
+ label="v1",
+ name="one")
device.metadata_version = "1.0"
device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
- Size("200 MiB"),
- disks=self.blivet.disks[:],
- raid_level=self.level,
- label="v11",
- name="oneone")
+ Size("200 MiB"),
+ disks=self.blivet.disks[:],
+ raid_level=self.level,
+ label="v11",
+ name="oneone")
device.metadata_version = "1.1"
device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
- Size("200 MiB"),
- disks=self.blivet.disks[:],
- raid_level=self.level,
- label="v12",
- name="onetwo")
+ Size("200 MiB"),
+ disks=self.blivet.disks[:],
+ raid_level=self.level,
+ label="v12",
+ name="onetwo")
device.metadata_version = "1.2"
device = self.blivet.factory_device(devicefactory.DEVICE_TYPE_MD,
- Size("200 MiB"),
- disks=self.blivet.disks[:],
- raid_level=self.level,
- label="vdefault",
- name="default")
+ Size("200 MiB"),
+ disks=self.blivet.disks[:],
+ raid_level=self.level,
+ label="vdefault",
+ name="default")
@unittest.skip("temporarily disabled due to mdadm issues")
@@ -323,11 +323,11 @@ class LVMOnMDTestCase(BlivetResetTestCase):
def _set_up_storage(self):
self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
- Size("200 MiB"),
- disks=self.blivet.disks[:],
- container_raid_level="raid1",
- fstype="swap")
+ Size("200 MiB"),
+ disks=self.blivet.disks[:],
+ container_raid_level="raid1",
+ fstype="swap")
self.blivet.factory_device(devicefactory.DEVICE_TYPE_LVM,
- None,
- disks=self.blivet.disks[:],
- container_raid_level="raid1")
+ None,
+ disks=self.blivet.disks[:],
+ container_raid_level="raid1")
diff --git a/tests/formats_test/disklabel_test.py b/tests/formats_test/disklabel_test.py
index 4c1a317..a4f92cd 100644
--- a/tests/formats_test/disklabel_test.py
+++ b/tests/formats_test/disklabel_test.py
@@ -36,11 +36,11 @@ def test_get_alignment(self):
# expected end alignments
optimal_end_alignment = parted.Alignment(
- grainSize=optimal_alignment.grainSize,
- offset=-1)
+ grainSize=optimal_alignment.grainSize,
+ offset=-1)
minimal_end_alignment = parted.Alignment(
- grainSize=minimal_alignment.grainSize,
- offset=-1)
+ grainSize=minimal_alignment.grainSize,
+ offset=-1)
# make sure the private methods all return the expected values
self.assertEqual(dl._get_disk_label_alignment(), disklabel_alignment)
@@ -49,7 +49,7 @@ def test_get_alignment(self):
# validate result when passing a start alignment to get_end_alignment
self.assertEqual(dl.get_end_alignment(alignment=optimal_alignment),
- optimal_end_alignment)
+ optimal_end_alignment)
self.assertEqual(dl.get_end_alignment(alignment=minimal_alignment),
minimal_end_alignment)
diff --git a/tests/formats_test/fslabeling.py b/tests/formats_test/fslabeling.py
index 47d817a..d835489 100644
--- a/tests/formats_test/fslabeling.py
+++ b/tests/formats_test/fslabeling.py
@@ -16,10 +16,10 @@ class LabelingAsRoot(loopbackedtestcase.LoopBackedTestCase):
"""
_fs_class = abc.abstractproperty(
- doc="The class of the filesystem being tested on.")
+ doc="The class of the filesystem being tested on.")
_invalid_label = abc.abstractproperty(
- doc="A label which is invalid for this filesystem.")
+ doc="A label which is invalid for this filesystem.")
def __init__(self, methodName='run_test'):
super(LabelingAsRoot, self).__init__(methodName=methodName, device_spec=[Size("100 MiB")])
diff --git a/tests/formats_test/fstesting.py b/tests/formats_test/fstesting.py
index 407b051..2c86911 100644
--- a/tests/formats_test/fstesting.py
+++ b/tests/formats_test/fstesting.py
@@ -25,7 +25,7 @@ def can_resize(an_fs):
class FSAsRoot(loopbackedtestcase.LoopBackedTestCase):
_fs_class = abc.abstractproperty(
- doc="The class of the filesystem being tested on.")
+ doc="The class of the filesystem being tested on.")
_DEVICE_SIZE = Size("100 MiB")
diff --git a/tests/formats_test/init_test.py b/tests/formats_test/init_test.py
index cf9a736..6d35920 100644
--- a/tests/formats_test/init_test.py
+++ b/tests/formats_test/init_test.py
@@ -11,23 +11,23 @@ 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
- }
+ 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)
+ [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])
+ 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]
diff --git a/tests/imagebackedtestcase.py b/tests/imagebackedtestcase.py
index c070991..01e2929 100644
--- a/tests/imagebackedtestcase.py
+++ b/tests/imagebackedtestcase.py
@@ -32,7 +32,7 @@ class ImageBackedTestCase(unittest.TestCase):
""" Whether or not to create a disklabel on the disks. """
disks = {"disk1": Size("2 GiB"),
- "disk2": Size("2 GiB")}
+ "disk2": Size("2 GiB")}
""" The names and sizes of the disk images to create/use. """
def set_up_disks(self):
diff --git a/tests/partitioning_test.py b/tests/partitioning_test.py
index 05ed22e..3d836bd 100644
--- a/tests/partitioning_test.py
+++ b/tests/partitioning_test.py
@@ -40,7 +40,7 @@
class PartitioningTestCase(unittest.TestCase):
def get_disk(self, disk_type, primary_count=0,
- has_extended=False, logical_count=0):
+ has_extended=False, logical_count=0):
""" Return a mock representing a parted.Disk. """
disk = Mock()
@@ -86,28 +86,28 @@ def test_next_partition_type(self):
# four primaries and an extended, available logical -> logical
disk = self.get_disk(disk_type="dos", primary_count=4, has_extended=True,
- logical_count=9)
+ logical_count=9)
self.assertEqual(get_next_partition_type(disk), parted.PARTITION_LOGICAL)
# four primaries and an extended, no available logical -> None
disk = self.get_disk(disk_type="dos", primary_count=4, has_extended=True,
- logical_count=11)
+ logical_count=11)
self.assertEqual(get_next_partition_type(disk), None)
# four primaries and no extended -> None
disk = self.get_disk(disk_type="dos", primary_count=4,
- has_extended=False)
+ has_extended=False)
self.assertEqual(get_next_partition_type(disk), None)
# free primary slot, extended, no free logical slot -> primary
disk = self.get_disk(disk_type="dos", primary_count=3, has_extended=True,
- logical_count=11)
+ logical_count=11)
self.assertEqual(get_next_partition_type(disk), parted.PARTITION_NORMAL)
# free primary slot, extended, no free logical slot w/ no_primary
# -> None
disk = self.get_disk(disk_type="dos", primary_count=3, has_extended=True,
- logical_count=11)
+ logical_count=11)
self.assertEqual(get_next_partition_type(disk, no_primary=True), None)
#
@@ -154,7 +154,7 @@ def test_add_partition(self):
#
self.assertEqual(len(disk.format.partitions), 0)
part = add_partition(disk.format, free, parted.PARTITION_NORMAL,
- Size("10 MiB") - Size(37))
+ Size("10 MiB") - Size(37))
self.assertEqual(len(disk.format.partitions), 1)
# an unaligned size still yields an aligned partition
@@ -184,7 +184,7 @@ def test_add_partition(self):
length = 4096 # 2 MiB
size = Size(sector_size * length)
part = add_partition(disk.format, free, parted.PARTITION_NORMAL,
- size)
+ size)
self.assertEqual(part.geometry.length, length)
self.assertEqual(optimal.isAligned(free, part.geometry.start),
False)
@@ -204,7 +204,7 @@ def test_add_partition(self):
start_sector = 5003
end_sector = 15001
part = add_partition(disk.format, free, parted.PARTITION_NORMAL,
- None, start_sector, end_sector)
+ None, start_sector, end_sector)
self.assertEqual(len(disk.format.partitions), 1)
# start and end sectors are exactly as specified
@@ -218,18 +218,18 @@ def test_add_partition(self):
# fail: add a logical partition to a primary free region
#
with self.assertRaisesRegex(parted.PartitionException,
- "no extended partition"):
+ "no extended partition"):
part = add_partition(disk.format, free, parted.PARTITION_LOGICAL,
- Size("10 MiB"))
+ Size("10 MiB"))
# add an extended partition to the disk
placeholder = add_partition(disk.format, free,
- parted.PARTITION_NORMAL, Size("10 MiB"))
+ parted.PARTITION_NORMAL, Size("10 MiB"))
all_free = disk.format.parted_disk.getFreeSpaceRegions()
add_partition(disk.format, all_free[1],
- parted.PARTITION_EXTENDED, Size("30 MiB"),
- alignment.alignUp(all_free[1],
- placeholder.geometry.end))
+ parted.PARTITION_EXTENDED, Size("30 MiB"),
+ alignment.alignUp(all_free[1],
+ placeholder.geometry.end))
disk.format.remove_partition(placeholder)
self.assertEqual(len(disk.format.partitions), 1)
@@ -239,8 +239,8 @@ def test_add_partition(self):
# add a logical partition to an extended free regions
#
part = add_partition(disk.format, all_free[1],
- parted.PARTITION_LOGICAL,
- Size("10 MiB"), all_free[1].start)
+ parted.PARTITION_LOGICAL,
+ Size("10 MiB"), all_free[1].start)
self.assertEqual(part.type, parted.PARTITION_LOGICAL)
disk.format.remove_partition(part)
@@ -251,8 +251,8 @@ def test_add_partition(self):
#
with self.assertRaisesRegex(parted.PartitionException, "overlap"):
part = add_partition(disk.format, all_free[1],
- parted.PARTITION_NORMAL,
- Size("10 MiB"), all_free[1].start)
+ parted.PARTITION_NORMAL,
+ Size("10 MiB"), all_free[1].start)
def test_chunk(self):
dev1 = Mock()
@@ -329,7 +329,7 @@ def test_disk_chunk1(self):
partitions = [p1, p2]
free = get_free_regions([disk])
self.assertEqual(len(free), 1,
- "free region count %d not expected" % len(free))
+ "free region count %d not expected" % len(free))
b = Mock()
allocate_partitions(b, disks, partitions, free)
@@ -392,7 +392,7 @@ def test_disk_chunk2(self):
partitions = [p1, p2, p3, p4, p5]
free = get_free_regions([disk])
self.assertEqual(len(free), 1,
- "free region count %d not expected" % len(free))
+ "free region count %d not expected" % len(free))
b = Mock()
allocate_partitions(b, disks, partitions, free)
@@ -543,7 +543,7 @@ def test_vgchunk_with_cache(self):
# LVMVolumeGroupDevice.extents) -- 1024 MiB for caches, 8 MiB for the
# pmspare LV
pv2 = StorageDevice("pv2", size=Size("1033 MiB"),
- fmt=get_format("lvmpv"))
+ fmt=get_format("lvmpv"))
vg = LVMVolumeGroupDevice("vg", parents=[pv, pv2])
cache_req1 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
@@ -588,7 +588,7 @@ def test_vgchunk_with_cache_pvfree(self):
# need (including the 8MiB pmspare LV) and which should thus be split
# into the LVs
pv2 = StorageDevice("pv2", size=Size("1077 MiB"),
- fmt=get_format("lvmpv"))
+ fmt=get_format("lvmpv"))
vg = LVMVolumeGroupDevice("vg", parents=[pv, pv2])
cache_req1 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough")
@@ -632,7 +632,7 @@ def test_align_free_regions(self):
disk = Mock()
disk.format.alignment.grainSize = 2048
disk.format.parted_disk.getFreeSpaceRegions.return_value = [Mock(start=1, end=2049, length=2049),
- Mock(start=1, end=2048, length=2048)]
+ Mock(start=1, end=2048, length=2048)]
free = get_free_regions([disk])
self.assertEqual(free[0].length, 2049)
@@ -709,7 +709,7 @@ def test_explicit_extended_partitions(self):
""" Verify that explicitly requested extended partitions work. """
disk = self.blivet.disks[0]
p1 = self.blivet.new_partition(size=Size("500 MiB"),
- part_type=parted.PARTITION_EXTENDED)
+ part_type=parted.PARTITION_EXTENDED)
self.blivet.create_device(p1)
do_partitioning(self.blivet)
diff --git a/tests/pylint/runpylint.py b/tests/pylint/runpylint.py
index bc836a6..d7bd01c 100755
--- a/tests/pylint/runpylint.py
+++ b/tests/pylint/runpylint.py
@@ -11,29 +11,29 @@ def __init__(self):
PocketLintConfig.__init__(self)
self.falsePositives = [FalsePositive(r"BTRFSVolumeDevice._create: Instance of 'DeviceFormat' has no 'label' member"),
- FalsePositive(r"Catching an exception which doesn't inherit from BaseException: (BlockDev|DM|Crypto|Swap|LVM|Btrfs|MDRaid|G)Error$"),
- FalsePositive(r"Function 'run_program' has no 'called' member"),
- FalsePositive(r"(PartitioningTestCase|PartitionDeviceTestCase).*: Instance of 'DeviceFormat' has no .* member"),
- FalsePositive(r"Instance of 'int' has no .* member"),
- FalsePositive(r"Instance of 'LUKSDevice' has no .* member"),
- FalsePositive(r"Method 'do_task' is abstract in class 'Task' but is not overridden"),
- FalsePositive(r"Method 'do_task' is abstract in class 'UnimplementedTask' but is not overridden"),
- FalsePositive(r"No value for argument 'member_count' in unbound method call$"),
- FalsePositive(r"No value for argument 'smallest_member_size' in unbound method call$")
- ]
+ FalsePositive(r"Catching an exception which doesn't inherit from BaseException: (BlockDev|DM|Crypto|Swap|LVM|Btrfs|MDRaid|G)Error$"),
+ FalsePositive(r"Function 'run_program' has no 'called' member"),
+ FalsePositive(r"(PartitioningTestCase|PartitionDeviceTestCase).*: Instance of 'DeviceFormat' has no .* member"),
+ FalsePositive(r"Instance of 'int' has no .* member"),
+ FalsePositive(r"Instance of 'LUKSDevice' has no .* member"),
+ FalsePositive(r"Method 'do_task' is abstract in class 'Task' but is not overridden"),
+ FalsePositive(r"Method 'do_task' is abstract in class 'UnimplementedTask' but is not overridden"),
+ FalsePositive(r"No value for argument 'member_count' in unbound method call$"),
+ FalsePositive(r"No value for argument 'smallest_member_size' in unbound method call$")
+ ]
@property
def disabledOptions(self):
return ["W0105", # String statement has no effect
- "W0110", # map/filter on lambda could be replaced by comprehension
- "W0141", # Used builtin function %r
- "W0142", # Used * or ** magic
- "W0212", # Access to a protected member of a client class
- "W0511", # Used when a warning note as FIXME or XXX is detected.
- "W0603", # Using the global statement
- "W0614", # Unused import %s from wildcard import
- "I0011", # Locally disabling %s
- ]
+ "W0110", # map/filter on lambda could be replaced by comprehension
+ "W0141", # Used builtin function %r
+ "W0142", # Used * or ** magic
+ "W0212", # Access to a protected member of a client class
+ "W0511", # Used when a warning note as FIXME or XXX is detected.
+ "W0603", # Using the global statement
+ "W0614", # Unused import %s from wildcard import
+ "I0011", # Locally disabling %s
+ ]
if __name__ == "__main__":
conf = BlivetLintConfig()
diff --git a/tests/tsort_test.py b/tests/tsort_test.py
index 1d34957..16f2a8c 100644
--- a/tests/tsort_test.py
+++ b/tests/tsort_test.py
@@ -46,7 +46,7 @@ def check_order(order, graph):
# verify output list is of the correct length
self.assertFalse(len(order) != len(graph['items']),
- "sorted list length is incorrect")
+ "sorted list length is incorrect")
# verify that all ordering constraints are satisfied
self.assertTrue(check_order(order, graph),
--
To view this commit on github, visit https://github.com/rhinstaller/blivet/commit/52d761defbe5b2c9c9ab38da30fb2bcc5f5d64a3
More information about the anaconda-patches
mailing list