def _gather_mount_info(self):
"""Gather info about mount points."""
selected_disks = self._disk_select_proxy.SelectedDisks
requests = MountPointRequest.from_structure_list(
self._manual_part_proxy.Requests)
mount_info = []
for device in self.storage.devicetree.leaves:
# Is the device usable?
if device.protected or device.size == Size(0):
continue
# All device's disks have to be in selected disks.
device_disks = {d.name for d in device.disks}
if selected_disks and not set(selected_disks).issuperset(
device_disks):
continue
# Append new info about this device.
request = self._get_mount_point_request(device, requests)
mount_info.append((device, request))
# Use the data only once.
if request in requests:
requests.remove(request)
return mount_info
def SetRequests(self, requests: List[Structure]):
"""Set the mount point requests.
:param requests: a list of requests
"""
self.implementation.set_requests(
MountPointRequest.from_structure_list(requests))
def GatherRequests(self) -> List[Structure]:
"""Gather all mount point requests.
Return mount point requests for all usable devices. If there is
a defined request for the given device, we will use it. Otherwise,
we will generate a new request.
:return: a list of requests
"""
return MountPointRequest.to_structure_list(self.implementation.gather_requests())
def _configure_partitioning(self, storage):
"""Configure the partitioning.
:param storage: an instance of Blivet
"""
log.debug("Setting up the mount points.")
manual_part_proxy = STORAGE.get_proxy(MANUAL_PARTITIONING)
# Set up mount points.
for mount_data in manual_part_proxy.Requests:
self._setup_mount_point(
storage, MountPointRequest.from_structure(mount_data))
def apply(self):
""" Apply our selections. """
mount_points = []
for _device, request in self._mount_info:
if request.reformat or request.mount_point:
if not request.mount_point:
request.mount_point = "none"
mount_points.append(request)
self._manual_part_proxy.SetRequests(MountPointRequest.to_structure_list(mount_points))
def apply(self):
""" Apply our selections. """
mount_points = []
for request in self._requests:
if request.reformat or request.mount_point:
if not request.mount_point:
request.mount_point = "none"
mount_points.append(request)
self._partitioning.SetRequests(
MountPointRequest.to_structure_list(mount_points))
def process_kickstart(self, data):
"""Process the kickstart data."""
requests = []
for mount_data in data.mount.mount_points:
request = MountPointRequest()
request.mount_point = mount_data.mount_point
request.device_spec = mount_data.device
request.reformat = mount_data.reformat
request.format_type = mount_data.format
request.format_options = mount_data.mkfs_opts
request.mount_options = mount_data.mount_opts
requests.append(request)
self.set_requests(requests)
def process_kickstart(self, data):
"""Process the kickstart data."""
if not data.mount.seen:
self.set_requests(list())
self.set_enabled(False)
return
requests = []
for mount_data in data.mount.mount_points:
request = MountPointRequest()
request.mount_point = mount_data.mount_point
request.device_spec = mount_data.device
request.reformat = mount_data.reformat
request.format_type = mount_data.format
request.format_options = mount_data.mkfs_opts
request.mount_options = mount_data.mount_opts
requests.append(request)
self.set_requests(requests)
self.set_enabled(True)
def _create_request_for_device(self, device):
"""Create a mount point request for the given device.
:param device: a Blivet's device object
:return: an instance of MountPointRequest
"""
request = MountPointRequest()
request.device_spec = device.path
request.format_type = device.format.type or ""
request.reformat = False
if device.format.mountable and device.format.mountpoint:
request.mount_point = device.format.mountpoint
return request
def configure_storage(storage, data=None, interactive=False):
"""Setup storage state from the kickstart data.
:param storage: an instance of the Blivet's storage object
:param data: an instance of kickstart data or None
:param interactive: use a task for the interactive partitioning
"""
auto_part_proxy = STORAGE.get_proxy(AUTO_PARTITIONING)
manual_part_proxy = STORAGE.get_proxy(MANUAL_PARTITIONING)
if interactive:
task = InteractivePartitioningTask(storage)
elif auto_part_proxy.Enabled:
request = PartitioningRequest.from_structure(auto_part_proxy.Request)
task = AutomaticPartitioningTask(storage, request)
elif manual_part_proxy.Enabled:
requests = MountPointRequest.from_structure_list(manual_part_proxy.Requests)
task = ManualPartitioningTask(storage, requests)
else:
task = CustomPartitioningTask(storage, data)
task.run()
def _get_mount_point_request(self, device, requests):
"""Get the mount point data for the given device."""
# Try to find existing assignment for this device.
for request in requests:
if device is self.storage.devicetree.resolve_device(request.device_spec):
return request
# Or create a new assignment.
request = MountPointRequest()
request.device_spec = device.path
request.format_type = device.format.type
request.reformat = False
if device.format.mountable and device.format.mountpoint:
request.mount_point = device.format.mountpoint
return request
def test_gather_requests_combination(self):
"""Test GatherRequests with user requests."""
self.module.on_storage_changed(create_storage())
# Add devices dev1 and dev2.
self._add_device(StorageDevice(
"dev1",
size=Size("1 GiB"),
fmt=get_format("ext4", mountpoint="/"))
)
self._add_device(StorageDevice(
"dev2",
size=Size("1 GiB"),
fmt=get_format("swap"))
)
# Add requests for dev1 and dev3.
req1 = MountPointRequest()
req1.device_spec = '/dev/dev1'
req1.format_options = '-L BOOT'
req1.format_type = 'xfs'
req1.mount_options = 'user'
req1.mount_point = '/home'
req1.reformat = True
req3 = MountPointRequest()
req3.device_spec = '/dev/dev3'
req3.mount_point = '/'
self.module.set_requests([req1, req3])
# Get requests for dev1 and dev2.
assert self.interface.GatherRequests() == [
{
'device-spec': get_variant(Str, '/dev/dev1'),
'format-options': get_variant(Str, '-L BOOT'),
'format-type': get_variant(Str, 'xfs'),
'mount-options': get_variant(Str, 'user'),
'mount-point': get_variant(Str, '/home'),
'reformat': get_variant(Bool, True)
},
{
'device-spec': get_variant(Str, '/dev/dev2'),
'format-options': get_variant(Str, ''),
'format-type': get_variant(Str, 'swap'),
'mount-options': get_variant(Str, ''),
'mount-point': get_variant(Str, ''),
'reformat': get_variant(Bool, False)
}
]
def Requests(self) -> List[Structure]:
"""List of mount point requests."""
return MountPointRequest.to_structure_list(self.implementation.requests)
def _gather_requests(self):
"""Gather info about mount points."""
return MountPointRequest.from_structure_list(
self._partitioning.GatherRequests())
