def required_packages(self):
packages = list()
if not self.ultimately_present:
return packages
if self.__class__.blivet_device_class is not None:
packages.extend(self.__class__.blivet_device_class._packages)
fmt = get_format(self._volume['fs_type'])
packages.extend(fmt.packages)
if self._volume['encryption']:
packages.extend(get_format('luks').packages)
return packages
def _manage_one_encryption(self, device):
ret = device
# Make sure to handle adjusting both existing stacks and future stacks.
if device == device.raw_device and self._spec_dict['encryption']:
# add luks
luks_name = "luks-%s" % device._name
if not device.format.exists:
fmt = device.format
else:
fmt = get_format(None)
self._blivet.format_device(
device,
get_format(
"luks",
name=luks_name,
cipher=self._spec_dict.get('encryption_cipher'),
key_size=self._spec_dict.get('encryption_key_size'),
luks_version=self._spec_dict.get(
'encryption_luks_version'),
passphrase=self._spec_dict.get('encryption_passphrase')
or None,
key_file=self._spec_dict.get('encryption_key_file')
or None))
if not device.format.has_key:
raise BlivetAnsibleError(
"encrypted %s '%s' missing key/passphrase" %
(self._type, self._spec_dict['name']))
luks_device = devices.LUKSDevice(luks_name,
fmt=fmt,
parents=[device])
self._blivet.create_device(luks_device)
ret = luks_device
elif device != device.raw_device and not self._spec_dict['encryption']:
# remove luks
if not device.format.exists:
fmt = device.format
else:
fmt = get_format(None)
ret = self._device.raw_device
self._blivet.destroy_device(device)
if fmt.type is not None:
self._blivet.format_device(ret, fmt)
# XXX: blivet has to store cipher, key_size, luks_version for existing before we
# can support re-encrypting based on changes to those parameters
return ret
def _create_members(self):
""" Schedule actions as needed to ensure pool member devices exist. """
members = list()
for disk in self._disks:
if not disk.isleaf or disk.format.type is not None:
if safe_mode:
raise BlivetAnsibleError("cannot remove existing formatting and/or devices on disk '%s' (pool '%s') in safe mode" % (disk.name, self._pool['name']))
else:
self._blivet.devicetree.recursive_remove(disk)
if use_partitions:
label = get_format("disklabel", device=disk.path)
self._blivet.format_device(disk, label)
member = self._blivet.new_partition(parents=[disk], size=Size("256MiB"), grow=True)
self._blivet.create_device(member)
else:
member = disk
if self._is_raid:
self._blivet.format_device(member, fmt=get_format("mdmember"))
else:
self._blivet.format_device(member, self._get_format())
members.append(member)
if self._is_raid:
raid_name = "%s-1" % self._pool['name']
raid_level = self._pool['raid_level']
try:
raid_array = self._blivet.new_mdarray(name=raid_name, level=raid_level,
member_devices=len(members),
total_devices=(len(members)),
parents=members,
fmt=self._get_format())
except ValueError as e:
raise BlivetAnsibleError("cannot create RAID '%s': %s" % (raid_name, str(e)))
self._blivet.create_device(raid_array)
result = [raid_array]
else:
result = members
if use_partitions:
try:
do_partitioning(self._blivet)
except Exception:
raise BlivetAnsibleError("failed to allocate partitions for pool '%s'" % self._pool['name'])
return result
def _get_format(self):
fmt = get_format("lvmpv")
if not fmt.supported or not fmt.formattable:
raise BlivetAnsibleError(
"required tools for managing LVM are missing")
return fmt
def _create_members(self):
""" Schedule actions as needed to ensure pool member devices exist. """
members = list()
for disk in self._disks:
if not disk.isleaf or disk.format.type is not None:
if safe_mode and not packages_only:
raise BlivetAnsibleError("cannot remove existing formatting and/or devices on disk '%s' (pool '%s') in safe mode" % (disk.name, self._pool['name']))
else:
self._blivet.devicetree.recursive_remove(disk)
if use_partitions:
label = get_format("disklabel", device=disk.path)
self._blivet.format_device(disk, label)
member = self._blivet.new_partition(parents=[disk], size=Size("256MiB"), grow=True)
self._blivet.create_device(member)
else:
member = disk
self._blivet.format_device(member, self._get_format())
members.append(member)
if use_partitions:
try:
do_partitioning(self._blivet)
except Exception:
raise BlivetAnsibleError("failed to allocation partitions for pool '%s'" % self._pool['name'])
return members
def _create(self):
if self._device.format.type != "disklabel" or \
self._device.format.label_type != disklabel_type:
self._blivet.devicetree.recursive_remove(self._device, remove_device=False)
label = get_format("disklabel", device=self._device.path, label_type=disklabel_type)
self._blivet.format_device(self._device, label)
def _create_members(self):
""" Schedule actions as needed to ensure pool member devices exist. """
members = list()
for disk in self._disks:
if not disk.isleaf:
self._blivet.devicetree.recursive_remove(disk)
if use_partitions:
label = get_format("disklabel", device=disk.path)
self._blivet.format_device(disk, label)
member = self._blivet.new_partition(parents=[disk], size=Size("256MiB"), grow=True)
self._blivet.create_device(member)
else:
member = disk
self._blivet.format_device(member, self._get_format())
members.append(member)
if use_partitions:
try:
do_partitioning(self._blivet)
except Exception:
# FAIL: problem allocating partitions for pool backing devices
raise BlivetAnsibleError("failed to allocation partitions for pool '%s'" % self._pool['name'])
return members
def required_packages(self):
packages = list()
if self.ultimately_present and self.__class__.blivet_device_class is not None:
packages.extend(self.__class__.blivet_device_class._packages)
if self._pool['encryption']:
packages.extend(get_format('luks').packages)
return packages
def _get_format(self):
""" Return a blivet.formats.DeviceFormat instance for this volume. """
fmt = get_format(self._volume['fs_type'],
mountpoint=self._volume.get('mount_point'),
label=self._volume['fs_label'],
options=self._volume['fs_create_options'])
if not fmt.supported or not fmt.formattable:
raise BlivetAnsibleError("required tools for file system '%s' are missing" % self._volume['fs_type'])
return fmt
def _create(self):
if self._device.format.type != "disklabel" or \
self._device.format.label_type != disklabel_type:
if safe_mode and not packages_only:
raise BlivetAnsibleError("cannot remove existing formatting and/or devices on disk '%s' "
"(pool '%s') in safe mode" % (self._device.name, self._pool['name']))
else:
self._blivet.devicetree.recursive_remove(self._device, remove_device=False)
label = get_format("disklabel", device=self._device.path, label_type=disklabel_type)
self._blivet.format_device(self._device, label)
def _create_raid_members(self, member_names):
members = list()
for member_name in member_names:
member_disk = self._blivet.devicetree.resolve_device(member_name)
if member_disk is not None:
if use_partitions:
# create partition table
label = get_format("disklabel", device=member_disk.path)
self._blivet.format_device(member_disk, label)
# create new partition
member = self._blivet.new_partition(parents=[member_disk], grow=True)
self._blivet.create_device(member)
self._blivet.format_device(member, fmt=get_format("mdmember"))
members.append(member)
else:
self._blivet.format_device(member_disk, fmt=get_format("mdmember"))
members.append(member_disk)
return members
def _reformat(self):
""" Schedule actions as needed to ensure the volume is formatted as specified. """
fmt = self._get_format()
if self._device.format.type == fmt.type:
return
if safe_mode and (self._device.format.type is not None or
self._device.format.name != get_format(None).name):
raise BlivetAnsibleError(
"cannot remove existing formatting on volume '%s' in safe mode"
% self._volume['name'])
if self._device.format.status and (self._device.format.mountable or
self._device.format.type == "swap"):
self._device.format.teardown()
self._blivet.format_device(self._device, fmt)
def _reformat(self):
""" Schedule actions as needed to ensure the volume is formatted as specified. """
global packages_only
fmt = self._get_format()
if self._device.format.type == fmt.type:
return
if safe_mode and (self._device.format.type is not None or self._device.format.name != get_format(None).name) and \
not packages_only:
raise BlivetAnsibleError("cannot remove existing formatting on volume '%s' in safe mode" % self._volume['name'])
if self._device.format.status and not packages_only:
self._device.format.teardown()
if not self._device.isleaf:
self._blivet.devicetree.recursive_remove(self._device, remove_device=False)
self._blivet.format_device(self._device, fmt)
