def creation_test(self, device_getter):
"""Test the creation task."""
SnapshotCreateTask(Mock(), [], SNAPSHOT_WHEN_PRE_INSTALL).run()
device_getter.assert_not_called()
SnapshotCreateTask(Mock(), [Mock()], SNAPSHOT_WHEN_POST_INSTALL).run()
device_getter.assert_called_once()
def create_with_task(self, when):
"""Create ThinLV snapshots.
PRE-INSTALL: Create a snapshot before installation starts.
This must be done before user can change anything.
POST-INSTALL: Create a snapshot after post section stops.
Blivet must be reset before creation of the snapshot. This is
required because the storage could be changed in post section.
:param when: a type of the requests to use
:return: a task
"""
return SnapshotCreateTask(storage=self.storage,
requests=self.get_requests(when),
when=when)
def doInstall(storage, payload, ksdata):
"""Perform an installation. This method takes the ksdata as prepared by
the UI (the first hub, in graphical mode) and applies it to the disk.
The two main tasks for this are putting filesystems onto disks and
installing packages onto those filesystems.
"""
bootloader_proxy = STORAGE.get_proxy(BOOTLOADER)
bootloader_enabled = bootloader_proxy.BootloaderMode != BOOTLOADER_DISABLED
can_install_bootloader = not conf.target.is_directory and bootloader_enabled
installation_queue = TaskQueue("Installation queue")
# connect progress reporting
installation_queue.queue_started.connect(
lambda x: progress_message(x.status_message))
installation_queue.task_completed.connect(lambda x: progress_step(x.name))
# This should be the only thread running, wait for the others to finish if not.
if threadMgr.running > 1:
# it could be that the threads finish execution before the task is executed,
# but that should not cause any issues
def wait_for_all_treads():
for message in ("Thread %s is running" % n
for n in threadMgr.names):
log.debug(message)
threadMgr.wait_all()
# Use a queue with a single task as only TaskQueues have the status_message
# property used for setting the progress status in the UI.
wait_for_threads = TaskQueue(
"Wait for threads to finish",
N_("Waiting for %s threads to finish") % (threadMgr.running - 1))
wait_for_threads.append(
Task("Wait for all threads to finish", wait_for_all_treads))
installation_queue.append(wait_for_threads)
# Save system time to HW clock.
# - this used to be before waiting on threads, but I don't think that's needed
if conf.system.can_set_hardware_clock:
# lets just do this as a top-level task - no
save_hwclock = Task("Save system time to HW clock",
timezone.save_hw_clock)
installation_queue.append(save_hwclock)
# setup the installation environment
setup_environment = TaskQueue(
"Installation environment setup",
N_("Setting up the installation environment"))
setup_environment.append(
Task("Setup addons", ksdata.addons.setup, (storage, ksdata, payload)))
installation_queue.append(setup_environment)
# Do partitioning.
# Depending on current payload the storage might be apparently configured
# either before or after package/payload installation.
# So let's have two task queues - early storage & late storage.
early_storage = TaskQueue("Early storage configuration",
N_("Configuring storage"))
# put custom storage info into ksdata
early_storage.append(
Task("Insert custom storage to ksdata",
task=update_storage_ksdata,
task_args=(storage, ksdata)))
# callbacks for blivet
message_clbk = lambda clbk_data: progress_message(clbk_data.msg)
entropy_wait_clbk = lambda clbk_data: wait_for_entropy(
clbk_data.msg, clbk_data.min_entropy, ksdata)
callbacks_reg = callbacks.create_new_callbacks_register(
create_format_pre=message_clbk,
resize_format_pre=message_clbk,
wait_for_entropy=entropy_wait_clbk)
if not conf.target.is_directory:
early_storage.append(
Task("Activate filesystems",
task=turn_on_filesystems,
task_args=(storage, ),
task_kwargs={"callbacks": callbacks_reg}))
early_storage.append(
Task("Mount filesystems", task=storage.mount_filesystems))
if payload.needs_storage_configuration and not conf.target.is_directory:
early_storage.append(
Task("Write early storage",
task=write_storage_configuration,
task_args=(storage, )))
installation_queue.append(early_storage)
# Run %pre-install scripts with the filesystem mounted and no packages
pre_install_scripts = TaskQueue("Pre-install scripts",
N_("Running pre-installation scripts"))
pre_install_scripts.append(
Task("Run %pre-install scripts", runPreInstallScripts,
(ksdata.scripts, )))
installation_queue.append(pre_install_scripts)
# Do packaging.
# Discover information about realms to join to determine the need for additional packages.
realm_discover = TaskQueue("Realm discover",
N_("Discovering realm to join"))
realm_discover.append(Task("Discover realm to join", ksdata.realm.setup))
installation_queue.append(realm_discover)
# Check for other possibly needed additional packages.
pre_install = TaskQueue("Pre install tasks",
N_("Running pre-installation tasks"))
pre_install.append(Task("Setup authselect", ksdata.authselect.setup))
pre_install.append(Task("Setup firewall", ksdata.firewall.setup))
pre_install.append(Task("Setup network", ksdata.network.setup))
# Setup timezone and add chrony as package if timezone was set in KS
# and "-chrony" wasn't in packages section and/or --nontp wasn't set.
pre_install.append(
Task("Setup timezone", ksdata.timezone.setup, (ksdata, )))
# make name resolution work for rpm scripts in chroot
if conf.system.provides_resolver_config:
# we use a custom Task subclass as the sysroot path has to be resolved
# only when the task is actually started, not at task creation time
pre_install.append(WriteResolvConfTask("Copy resolv.conf to sysroot"))
def run_pre_install():
"""This means to gather what additional packages (if any) are needed & executing payload.pre_install()."""
# anaconda requires storage packages in order to make sure the target
# system is bootable and configurable, and some other packages in order
# to finish setting up the system.
payload.requirements.add_packages(storage.packages, reason="storage")
payload.requirements.add_packages(ksdata.realm.packages,
reason="realm")
payload.requirements.add_packages(ksdata.authselect.packages,
reason="authselect")
payload.requirements.add_packages(ksdata.firewall.packages,
reason="firewall")
payload.requirements.add_packages(ksdata.network.packages,
reason="network")
payload.requirements.add_packages(ksdata.timezone.packages,
reason="ntp",
strong=False)
if can_install_bootloader:
payload.requirements.add_packages(storage.bootloader.packages,
reason="bootloader")
payload.requirements.add_groups(payload.language_groups(),
reason="language groups")
payload.requirements.add_packages(payload.langpacks(),
reason="langpacks",
strong=False)
payload.pre_install()
pre_install.append(
Task("Find additional packages & run pre_install()", run_pre_install))
installation_queue.append(pre_install)
payload_install = TaskQueue("Payload installation", N_("Installing."))
payload_install.append(Task("Install the payload", payload.install))
installation_queue.append(payload_install)
# for some payloads storage is configured after the payload is installed
if not payload.needs_storage_configuration:
late_storage = TaskQueue("Late storage configuration",
N_("Configuring storage"))
late_storage.append(
Task("Prepare mount targets",
task=payload.prepare_mount_targets,
task_args=(storage, )))
if not conf.target.is_directory:
late_storage.append(
Task("Write late storage",
task=write_storage_configuration,
task_args=(storage, )))
installation_queue.append(late_storage)
# Do bootloader.
if can_install_bootloader:
bootloader_install = TaskQueue("Bootloader installation",
N_("Installing boot loader"))
bootloader_install.append(
Task("Install bootloader", write_boot_loader, (storage, payload)))
installation_queue.append(bootloader_install)
post_install = TaskQueue("Post-installation setup tasks",
(N_("Performing post-installation setup tasks")))
post_install.append(
Task("Run post-installation setup tasks", payload.post_install))
installation_queue.append(post_install)
# Create snapshot
snapshot_proxy = STORAGE.get_proxy(SNAPSHOT)
if snapshot_proxy.IsRequested(SNAPSHOT_WHEN_POST_INSTALL):
snapshot_creation = TaskQueue("Creating post installation snapshots",
N_("Creating snapshots"))
snapshot_requests = ksdata.snapshot.get_requests(
SNAPSHOT_WHEN_POST_INSTALL)
snapshot_task = SnapshotCreateTask(storage, snapshot_requests,
SNAPSHOT_WHEN_POST_INSTALL)
snapshot_creation.append(
Task("Create post-install snapshots", snapshot_task.run))
installation_queue.append(snapshot_creation)
# notify progress tracking about the number of steps
progress_init(installation_queue.task_count)
# log contents of the main task queue
log.info(installation_queue.summary)
# log tasks and queues when they are started
# - note that we are using generators to add the counter
queue_counter = util.item_counter(installation_queue.queue_count)
task_started_counter = util.item_counter(installation_queue.task_count)
task_completed_counter = util.item_counter(installation_queue.task_count)
installation_queue.queue_started.connect(lambda x: log.info(
"Queue started: %s (%s)", x.name, next(queue_counter)))
installation_queue.task_started.connect(lambda x: log.info(
"Task started: %s (%s)", x.name, next(task_started_counter)))
installation_queue.task_completed.connect(
lambda x: log.debug("Task completed: %s (%s) (%1.1f s)", x.name,
next(task_completed_counter), x.elapsed_time))
# start the task queue
installation_queue.start()
# done
progress_complete()
if services_proxy.SetupOnBoot == SETUP_ON_BOOT_DEFAULT:
if not flags.automatedInstall:
# Enable by default for interactive installations.
services_proxy.SetSetupOnBoot(SETUP_ON_BOOT_ENABLED)
# Create pre-install snapshots
from pykickstart.constants import SNAPSHOT_WHEN_PRE_INSTALL
from pyanaconda.kickstart import check_kickstart_error
from pyanaconda.modules.common.constants.objects import SNAPSHOT
snapshot_proxy = STORAGE.get_proxy(SNAPSHOT)
if snapshot_proxy.IsRequested(SNAPSHOT_WHEN_PRE_INSTALL):
# What for the storage to load devices.
# FIXME: Don't block the main thread!
threadMgr.wait(constants.THREAD_STORAGE)
# Prepare the requests.
requests = ksdata.snapshot.get_requests(SNAPSHOT_WHEN_PRE_INSTALL)
# Run the tasks.
with check_kickstart_error():
from pyanaconda.modules.storage.snapshot.create import SnapshotCreateTask
SnapshotCreateTask(anaconda.storage, requests,
SNAPSHOT_WHEN_PRE_INSTALL).run()
anaconda.intf.setup(ksdata)
anaconda.intf.run()
# vim:tw=78:ts=4:et:sw=4
def _prepare_installation(storage, payload, ksdata):
"""Perform an installation. This method takes the ksdata as prepared by
the UI (the first hub, in graphical mode) and applies it to the disk.
The two main tasks for this are putting filesystems onto disks and
installing packages onto those filesystems.
"""
bootloader_proxy = STORAGE.get_proxy(BOOTLOADER)
bootloader_enabled = bootloader_proxy.BootloaderMode != BOOTLOADER_DISABLED
can_install_bootloader = not conf.target.is_directory and bootloader_enabled
installation_queue = TaskQueue("Installation queue")
# connect progress reporting
installation_queue.queue_started.connect(
lambda x: progress_message(x.status_message))
installation_queue.task_completed.connect(lambda x: progress_step(x.name))
# This should be the only thread running, wait for the others to finish if not.
if threadMgr.running > 1:
# it could be that the threads finish execution before the task is executed,
# but that should not cause any issues
def wait_for_all_treads():
for message in ("Thread %s is running" % n
for n in threadMgr.names):
log.debug(message)
threadMgr.wait_all()
# Use a queue with a single task as only TaskQueues have the status_message
# property used for setting the progress status in the UI.
wait_for_threads = TaskQueue(
"Wait for threads to finish",
N_("Waiting for %s threads to finish") % (threadMgr.running - 1))
wait_for_threads.append(
Task("Wait for all threads to finish", wait_for_all_treads))
installation_queue.append(wait_for_threads)
# Save system time to HW clock.
# - this used to be before waiting on threads, but I don't think that's needed
if conf.system.can_set_hardware_clock:
# lets just do this as a top-level task - no
save_hwclock = Task("Save system time to HW clock",
timezone.save_hw_clock)
installation_queue.append(save_hwclock)
# setup the installation environment
setup_environment = TaskQueue(
"Installation environment setup",
N_("Setting up the installation environment"))
setup_environment.append(
Task("Setup addons", ksdata.addons.setup, (storage, ksdata, payload)))
boss_proxy = BOSS.get_proxy()
setup_environment.append_dbus_tasks(
BOSS, [boss_proxy.ConfigureRuntimeWithTask()])
installation_queue.append(setup_environment)
# Do partitioning.
# Depending on current payload the storage might be apparently configured
# either before or after package/payload installation.
# So let's have two task queues - early storage & late storage.
early_storage = TaskQueue("Early storage configuration",
N_("Configuring storage"))
# put custom storage info into ksdata
early_storage.append(
Task("Insert custom storage to ksdata",
task=update_storage_ksdata,
task_args=(storage, ksdata)))
# callbacks for blivet
message_clbk = lambda clbk_data: progress_message(clbk_data.msg)
entropy_wait_clbk = lambda clbk_data: wait_for_entropy(
clbk_data.msg, clbk_data.min_entropy, ksdata)
callbacks_reg = callbacks.create_new_callbacks_register(
create_format_pre=message_clbk,
resize_format_pre=message_clbk,
wait_for_entropy=entropy_wait_clbk)
if not conf.target.is_directory:
early_storage.append(
Task("Activate filesystems",
task=turn_on_filesystems,
task_args=(storage, ),
task_kwargs={"callbacks": callbacks_reg}))
early_storage.append(
Task("Mount filesystems", task=storage.mount_filesystems))
if payload.needs_storage_configuration and not conf.target.is_directory:
early_storage.append(
Task("Write early storage",
task=write_storage_configuration,
task_args=(storage, )))
installation_queue.append(early_storage)
# Run %pre-install scripts with the filesystem mounted and no packages
pre_install_scripts = TaskQueue("Pre-install scripts",
N_("Running pre-installation scripts"))
pre_install_scripts.append(
Task("Run %pre-install scripts", runPreInstallScripts,
(ksdata.scripts, )))
installation_queue.append(pre_install_scripts)
# Do various pre-installation tasks
# - try to discover a realm (if any)
# - check for possibly needed additional packages.
pre_install = TaskQueue("Pre install tasks",
N_("Running pre-installation tasks"))
# Setup timezone and add chrony as package if timezone was set in KS
# and "-chrony" wasn't in packages section and/or --nontp wasn't set.
pre_install.append(
Task("Setup timezone", ksdata.timezone.setup, (ksdata, )))
# make name resolution work for rpm scripts in chroot
if conf.system.provides_resolver_config:
# we use a custom Task subclass as the sysroot path has to be resolved
# only when the task is actually started, not at task creation time
pre_install.append(WriteResolvConfTask("Copy resolv.conf to sysroot"))
# realm discovery
security_proxy = SECURITY.get_proxy()
pre_install.append_dbus_tasks(SECURITY,
[security_proxy.DiscoverRealmWithTask()])
def run_pre_install():
"""This means to gather what additional packages (if any) are needed & executing payload.pre_install()."""
# anaconda requires storage packages in order to make sure the target
# system is bootable and configurable, and some other packages in order
# to finish setting up the system.
payload.requirements.add_packages(storage.packages, reason="storage")
payload.requirements.add_packages(ksdata.timezone.packages,
reason="ntp",
strong=False)
if can_install_bootloader:
payload.requirements.add_packages(storage.bootloader.packages,
reason="bootloader")
if kernel_arguments.is_enabled("fips"):
payload.requirements.add_packages(['/usr/bin/fips-mode-setup'],
reason="compliance")
payload.requirements.add_groups(payload.language_groups(),
reason="language groups")
payload.requirements.add_packages(payload.langpacks(),
reason="langpacks",
strong=False)
# add package requirements from modules
# - iterate over all modules we know have valid package requirements
# - add any requirements found to the payload requirement tracking
modules_with_package_requirements = [SECURITY, NETWORK]
for module in modules_with_package_requirements:
module_proxy = module.get_proxy()
module_requirements = Requirement.from_structure_list(
module_proxy.CollectRequirements())
log.debug("Adding requirements for module %s : %s", module,
module_requirements)
payload.requirements.add_requirements(module_requirements)
payload.pre_install()
pre_install.append(
Task("Find additional packages & run pre_install()", run_pre_install))
installation_queue.append(pre_install)
payload_install = TaskQueue("Payload installation", N_("Installing."))
payload_install.append(Task("Install the payload", payload.install))
installation_queue.append(payload_install)
# for some payloads storage is configured after the payload is installed
if not payload.needs_storage_configuration and not conf.target.is_directory:
late_storage = TaskQueue("Late storage configuration",
N_("Configuring storage"))
late_storage.append(
Task("Write late storage",
task=write_storage_configuration,
task_args=(storage, )))
installation_queue.append(late_storage)
# Do bootloader.
if can_install_bootloader:
bootloader_install = TaskQueue("Bootloader installation",
N_("Installing boot loader"))
bootloader_install.append(
Task("Install bootloader", write_boot_loader, (storage, payload)))
installation_queue.append(bootloader_install)
post_install = TaskQueue("Post-installation setup tasks",
(N_("Performing post-installation setup tasks")))
post_install.append(
Task("Run post-installation setup tasks", payload.post_install))
installation_queue.append(post_install)
# Create snapshot
snapshot_proxy = STORAGE.get_proxy(SNAPSHOT)
if snapshot_proxy.IsRequested(SNAPSHOT_WHEN_POST_INSTALL):
snapshot_creation = TaskQueue("Creating post installation snapshots",
N_("Creating snapshots"))
snapshot_requests = ksdata.snapshot.get_requests(
SNAPSHOT_WHEN_POST_INSTALL)
snapshot_task = SnapshotCreateTask(storage, snapshot_requests,
SNAPSHOT_WHEN_POST_INSTALL)
snapshot_creation.append(
Task("Create post-install snapshots", snapshot_task.run))
installation_queue.append(snapshot_creation)
return installation_queue