def __init__(self, *args):
NormalSpoke.__init__(self, *args)
GUISpokeInputCheckHandler.__init__(self)
self._users_module = USERS.get_proxy()
self._services_module = SERVICES.get_proxy()
self._refresh_running = False
self._manually_locked = False
def should_run(cls, environment, data):
"""This method is responsible for beginning Spoke initialization
in the firstboot environment (even before __init__).
It should return True if the spoke is to be shown
and False if it should be skipped.
It might be called multiple times, with or without (None)
the data argument.
"""
if environment == ANACONDA_ENVIRON:
return True
if environment == FIRSTBOOT_ENVIRON:
# cannot decide, stay in the game and let another call with data
# available (will come) decide
if data is None:
return True
# generally run spokes in firstboot only if doing reconfig, spokes
# that should run even if not doing reconfig should override this
# method
services_proxy = SERVICES.get_proxy()
return services_proxy.SetupOnBoot == SETUP_ON_BOOT_RECONFIG
return False
def _set_default_boot_target(self):
"""Set the default systemd target for the system."""
if not os.path.exists(util.getSysroot() + "/etc/systemd/system"):
log.error("systemd is not installed -- can't set default target")
return
# If the target was already set, we don't have to continue.
services_proxy = SERVICES.get_proxy()
if services_proxy.DefaultTarget:
log.debug("The default target is already set.")
return
try:
import rpm
except ImportError:
log.info("failed to import rpm -- not adjusting default runlevel")
else:
ts = rpm.TransactionSet(util.getSysroot())
# XXX one day this might need to account for anaconda's display mode
if ts.dbMatch("provides", 'service(graphical-login)').count() and \
not flags.usevnc:
# We only manipulate the ksdata. The symlink is made later
# during the config write out.
services_proxy.SetDefaultTarget(GRAPHICAL_TARGET)
else:
services_proxy.SetDefaultTarget(TEXT_ONLY_TARGET)
def setup(self, ksdata):
timezone_proxy = TIMEZONE.get_proxy()
services_proxy = SERVICES.get_proxy()
enabled_services = services_proxy.EnabledServices
disabled_services = services_proxy.DisabledServices
# do not install and use NTP package
if not timezone_proxy.NTPEnabled or NTP_PACKAGE in ksdata.packages.excludedList:
if util.service_running(
NTP_SERVICE) and conf.system.can_set_time_synchronization:
ret = util.stop_service(NTP_SERVICE)
if ret != 0:
timezone_log.error("Failed to stop NTP service")
if NTP_SERVICE not in disabled_services:
disabled_services.append(NTP_SERVICE)
services_proxy.SetDisabledServices(disabled_services)
# install and use NTP package
else:
if not util.service_running(
NTP_SERVICE) and conf.system.can_set_time_synchronization:
ret = util.start_service(NTP_SERVICE)
if ret != 0:
timezone_log.error("Failed to start NTP service")
self.packages.append(NTP_PACKAGE)
if not NTP_SERVICE in enabled_services and \
not NTP_SERVICE in disabled_services:
enabled_services.append(NTP_SERVICE)
services_proxy.SetEnabledServices(enabled_services)
def should_run(cls, environment, data):
"""This method is responsible for beginning Spoke initialization
in the firstboot environment (even before __init__).
It should return True if the spoke is to be shown
and False if it should be skipped.
It might be called multiple times, with or without (None)
the data argument.
"""
if environment == ANACONDA_ENVIRON:
return True
if environment == FIRSTBOOT_ENVIRON:
# cannot decide, stay in the game and let another call with data
# available (will come) decide
if data is None:
return True
# generally run spokes in firstboot only if doing reconfig, spokes
# that should run even if not doing reconfig should override this
# method
services_proxy = SERVICES.get_proxy()
return services_proxy.SetupOnBoot == SETUP_ON_BOOT_RECONFIG
return False
def execute(self):
unit_name = "initial-setup.service"
services_proxy = SERVICES.get_proxy()
setup_on_boot = services_proxy.SetupOnBoot
if setup_on_boot == SETUP_ON_BOOT_DISABLED:
log.debug("The %s service will be disabled.", unit_name)
util.disable_service(unit_name)
# Also tell the screen access manager, so that the fact that post installation tools
# should be disabled propagates to the user interaction config file.
screen_access.sam.post_install_tools_disabled = True
return
if not os.path.exists(os.path.join(util.getSysroot(), "lib/systemd/system/", unit_name)):
log.debug("The %s service will not be started on first boot, because "
"it's unit file is not installed.", unit_name)
return
if setup_on_boot == SETUP_ON_BOOT_RECONFIG:
log.debug("The %s service will run in the reconfiguration mode.", unit_name)
# write the reconfig trigger file
f = open(os.path.join(util.getSysroot(), "etc/reconfigSys"), "w+")
f.close()
log.debug("The %s service will be enabled.", unit_name)
util.enable_service(unit_name)
def execute(self):
unit_name = "initial-setup.service"
services_proxy = SERVICES.get_proxy()
setup_on_boot = services_proxy.SetupOnBoot
if setup_on_boot == SETUP_ON_BOOT_DISABLED:
log.debug("The %s service will be disabled.", unit_name)
util.disable_service(unit_name)
# Also tell the screen access manager, so that the fact that post installation tools
# should be disabled propagates to the user interaction config file.
screen_access.sam.post_install_tools_disabled = True
return
if not os.path.exists(
os.path.join(util.getSysroot(), "lib/systemd/system/",
unit_name)):
log.debug(
"The %s service will not be started on first boot, because "
"it's unit file is not installed.", unit_name)
return
if setup_on_boot == SETUP_ON_BOOT_RECONFIG:
log.debug("The %s service will run in the reconfiguration mode.",
unit_name)
# write the reconfig trigger file
f = open(os.path.join(util.getSysroot(), "etc/reconfigSys"), "w+")
f.close()
log.debug("The %s service will be enabled.", unit_name)
util.enable_service(unit_name)
def _set_default_boot_target(self):
"""Set the default systemd target for the system."""
if not os.path.exists(util.getSysroot() + "/etc/systemd/system"):
log.error("systemd is not installed -- can't set default target")
return
# If the target was already set, we don't have to continue.
services_proxy = SERVICES.get_proxy()
if services_proxy.DefaultTarget:
log.debug("The default target is already set.")
return
try:
import rpm
except ImportError:
log.info("failed to import rpm -- not adjusting default runlevel")
else:
ts = rpm.TransactionSet(util.getSysroot())
# XXX one day this might need to account for anaconda's display mode
if ts.dbMatch("provides", 'service(graphical-login)').count() and \
not flags.usevnc:
# We only manipulate the ksdata. The symlink is made later
# during the config write out.
services_proxy.SetDefaultTarget(GRAPHICAL_TARGET)
else:
services_proxy.SetDefaultTarget(TEXT_ONLY_TARGET)
def setup(self, ksdata):
timezone_proxy = TIMEZONE.get_proxy()
services_proxy = SERVICES.get_proxy()
enabled_services = services_proxy.EnabledServices
disabled_services = services_proxy.DisabledServices
# do not install and use NTP package
if not timezone_proxy.NTPEnabled or NTP_PACKAGE in ksdata.packages.excludedList:
if util.service_running(NTP_SERVICE) and conf.system.can_set_time_synchronization:
ret = util.stop_service(NTP_SERVICE)
if ret != 0:
timezone_log.error("Failed to stop NTP service")
if NTP_SERVICE not in disabled_services:
disabled_services.append(NTP_SERVICE)
services_proxy.SetDisabledServices(disabled_services)
# install and use NTP package
else:
if not util.service_running(NTP_SERVICE) and conf.system.can_set_time_synchronization:
ret = util.start_service(NTP_SERVICE)
if ret != 0:
timezone_log.error("Failed to start NTP service")
self.packages.append(NTP_PACKAGE)
if not NTP_SERVICE in enabled_services and \
not NTP_SERVICE in disabled_services:
enabled_services.append(NTP_SERVICE)
services_proxy.SetEnabledServices(enabled_services)
def __init__(self, *args):
NormalSpoke.__init__(self, *args)
GUISpokeInputCheckHandler.__init__(self)
self._users_module = USERS.get_observer()
self._users_module.connect()
self._services_module = SERVICES.get_observer()
self._services_module.connect()
def __init__(self, *args):
NormalSpoke.__init__(self, *args)
GUISpokeInputCheckHandler.__init__(self)
self._users_module = USERS.get_observer()
self._users_module.connect()
self._services_module = SERVICES.get_observer()
self._services_module.connect()
def execute(self):
services_proxy = SERVICES.get_proxy()
for svc in services_proxy.DisabledServices:
log.debug("Disabling the service %s.", svc)
util.disable_service(svc)
for svc in services_proxy.EnabledServices:
log.debug("Enabling the service %s.", svc)
util.enable_service(svc)
def execute(self):
services_proxy = SERVICES.get_proxy()
for svc in services_proxy.DisabledServices:
log.debug("Disabling the service %s.", svc)
util.disable_service(svc)
for svc in services_proxy.EnabledServices:
log.debug("Enabling the service %s.", svc)
util.enable_service(svc)
def is_reconfiguration_mode():
"""Check if we are running in Initial Setup reconfig mode.
:return: True or False
"""
if not is_module_available(SERVICES):
return False
services_module = SERVICES.get_proxy()
return services_module.SetupOnBoot == SETUP_ON_BOOT_RECONFIG
def initialize_first_boot_action():
"""Initialize the setup on boot action."""
if not is_module_available(SERVICES):
return
services_proxy = SERVICES.get_proxy()
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)
def update_config_file_state(self):
"""Synchornize user interaction config file state.
At the moment this means simply checking if post installation setup tools should
be enabled/disabled based on kickstart and state of the Services module.
It is assumed this method will be called at an appropriate time before the config
file is written out to the target system.
"""
services_proxy = SERVICES.get_proxy()
if services_proxy.SetupOnBoot == SETUP_ON_BOOT_DISABLED:
self.post_install_tools_disabled = True
def run(self):
services_proxy = SERVICES.get_proxy()
enabled_services = services_proxy.EnabledServices
disabled_services = services_proxy.DisabledServices
if self._ntp_enabled and not self._ntp_excluded:
if NTP_SERVICE not in enabled_services and NTP_SERVICE not in disabled_services:
enabled_services.append(NTP_SERVICE)
services_proxy.SetEnabledServices(enabled_services)
else:
if NTP_SERVICE not in disabled_services:
disabled_services.append(NTP_SERVICE)
services_proxy.SetDisabledServices(disabled_services)
def __init__(self, data, storage, payload):
NormalTUISpoke.__init__(self, data, storage, payload)
self.initialize_start()
self.title = N_("Root password")
self.input_required = False
self._policy = self.data.anaconda.pwpolicy.get_policy("root", fallback_to_default=True)
self._password = None
self._users_module = USERS.get_proxy()
self._services_module = SERVICES.get_proxy()
self.initialize_done()
def _load_kickstart(self):
"""Load the kickstart"""
from pyanaconda import kickstart
# Construct a commandMap with only the supported Anaconda's commands
commandMap = dict(
(k, kickstart.commandMap[k]) for k in SUPPORTED_KICKSTART_COMMANDS)
# Prepare new data object
self.data = kickstart.AnacondaKSHandler(self._addon_module_paths["ks"],
commandUpdates=commandMap)
kickstart_path = INPUT_KICKSTART_PATH
if os.path.exists(OUTPUT_KICKSTART_PATH):
log.info("using kickstart from previous run for input")
kickstart_path = OUTPUT_KICKSTART_PATH
log.info("parsing input kickstart %s", kickstart_path)
try:
# Read the installed kickstart
parser = kickstart.AnacondaKSParser(self.data)
parser.readKickstart(kickstart_path)
log.info("kickstart parsing done")
except pykickstart.errors.KickstartError as kserr:
log.critical("kickstart parsing failed: %s", kserr)
log.critical(
"Initial Setup startup failed due to invalid kickstart file")
raise InitialSetupError
# if we got this far the kickstart should be valid, so send it to Boss as well
boss = BOSS.get_proxy()
report = KickstartReport.from_structure(
boss.ReadKickstartFile(kickstart_path))
if not report.is_valid():
message = "\n\n".join(map(str, report.error_messages))
raise InitialSetupError(message)
if self.external_reconfig:
# set the reconfig flag in kickstart so that
# relevant spokes show up
services_proxy = SERVICES.get_proxy()
services_proxy.SetSetupOnBoot(SETUP_ON_BOOT_RECONFIG)
# Record if groups, users or root password has been set before Initial Setup
# has been started, so that we don't trample over existing configuration.
users_proxy = USERS.get_proxy()
self._groups_already_configured = bool(users_proxy.Groups)
self._users_already_configured = bool(users_proxy.Users)
self._root_password_already_configured = users_proxy.IsRootPasswordSet
def execute(self):
desktop = Desktop()
services_proxy = SERVICES.get_proxy()
default_target = services_proxy.DefaultTarget
default_desktop = services_proxy.DefaultDesktop
if default_target:
log.debug("Using the default target %s.", default_target)
desktop.default_target = default_target
if default_desktop:
log.debug("Using the default desktop %s.", default_desktop)
desktop.desktop = default_desktop
desktop.write()
def execute(self):
desktop = Desktop()
services_proxy = SERVICES.get_proxy()
default_target = services_proxy.DefaultTarget
default_desktop = services_proxy.DefaultDesktop
if default_target:
log.debug("Using the default target %s.", default_target)
desktop.default_target = default_target
if default_desktop:
log.debug("Using the default desktop %s.", default_desktop)
desktop.desktop = default_desktop
desktop.write()
def __init__(self, data, storage, payload):
NormalTUISpoke.__init__(self, data, storage, payload)
self.initialize_start()
self.title = N_("Root password")
self.input_required = False
self._policy = self.data.anaconda.pwpolicy.get_policy("root", fallback_to_default=True)
self._password = None
self._users_module = USERS.get_observer()
self._users_module.connect()
self._services_module = SERVICES.get_observer()
self._services_module.connect()
self.initialize_done()
def _load_kickstart(self):
"""Load the kickstart"""
from pyanaconda import kickstart
# Construct a commandMap with only the supported Anaconda's commands
commandMap = dict(
(k, kickstart.commandMap[k]) for k in SUPPORTED_KICKSTART_COMMANDS)
# Prepare new data object
self.data = kickstart.AnacondaKSHandler(self._addon_module_paths["ks"],
commandUpdates=commandMap)
kickstart_path = INPUT_KICKSTART_PATH
if os.path.exists(OUTPUT_KICKSTART_PATH):
log.info("using kickstart from previous run for input")
kickstart_path = OUTPUT_KICKSTART_PATH
log.info("parsing input kickstart %s", kickstart_path)
try:
# Read the installed kickstart
parser = kickstart.AnacondaKSParser(self.data)
parser.readKickstart(kickstart_path)
log.info("kickstart parsing done")
except pykickstart.errors.KickstartError as kserr:
log.critical("kickstart parsing failed: %s", kserr)
log.critical(
"Initial Setup startup failed due to invalid kickstart file")
raise InitialSetupError
# if we got this far the kickstart should be valid, so send it to Boss as well
boss = BOSS.get_proxy()
boss.SplitKickstart(kickstart_path)
errors = boss.DistributeKickstart()
if errors:
message = "\n\n".join("{error_message}".format_map(e)
for e in errors)
raise InitialSetupError(message)
if self.external_reconfig:
# set the reconfig flag in kickstart so that
# relevant spokes show up
services_proxy = SERVICES.get_proxy()
services_proxy.SetSetupOnBoot(SETUP_ON_BOOT_RECONFIG)
def initialize_default_systemd_target(text_mode):
"""Initialize the default systemd target.
If we're in text mode, the resulting system should be too
unless the kickstart specified otherwise.
NOTE:
Installation controlled via VNC is considered to be
a text mode installation, as the installation run itself
is effectively headless.
:param text_mode: does the installer run in the text mode?
"""
if not is_module_available(SERVICES):
return
services_proxy = SERVICES.get_proxy()
if not services_proxy.DefaultTarget and (text_mode or flags.usevnc):
log.debug("no default systemd target set & in text/vnc mode - setting multi-user.target.")
services_proxy.SetDefaultTarget(TEXT_ONLY_TARGET)
# we now know in which mode we are going to run so store the information
from pykickstart import constants as pykickstart_constants
display_mode_coversion_table = {
constants.DisplayModes.GUI:
pykickstart_constants.DISPLAY_MODE_GRAPHICAL,
constants.DisplayModes.TUI: pykickstart_constants.DISPLAY_MODE_TEXT
}
ksdata.displaymode.displayMode = display_mode_coversion_table[
anaconda.display_mode]
ksdata.displaymode.nonInteractive = not anaconda.interactive_mode
# if we're in text mode, the resulting system should be too
# ...unless the kickstart specified otherwise
from pyanaconda.modules.common.constants.services import SERVICES
from pyanaconda.core.constants import TEXT_ONLY_TARGET
services_proxy = SERVICES.get_proxy()
if not services_proxy.DefaultTarget and anaconda.tui_mode:
services_proxy.SetDefaultTarget(TEXT_ONLY_TARGET)
# Set flag to prompt for missing ks data
if not anaconda.interactive_mode:
flags.ksprompt = False
# Set minimal ram size to the storage checker.
if anaconda.display_mode == constants.DisplayModes.GUI:
min_ram = isys.MIN_GUI_RAM
else:
min_ram = isys.MIN_RAM
from pyanaconda.storage.checker import storage_checker
def _prepare_configuration(payload, ksdata):
"""Configure the installed system."""
configuration_queue = TaskQueue("Configuration queue")
# connect progress reporting
configuration_queue.queue_started.connect(
lambda x: progress_message(x.status_message))
configuration_queue.task_completed.connect(lambda x: progress_step(x.name))
# schedule the execute methods of ksdata that require an installed system to be present
os_config = TaskQueue("Installed system configuration",
N_("Configuring installed system"))
# add installation tasks for the Security DBus module
security_proxy = SECURITY.get_proxy()
security_dbus_tasks = security_proxy.InstallWithTasks()
os_config.append_dbus_tasks(SECURITY, security_dbus_tasks)
# add installation tasks for the Services DBus module
services_proxy = SERVICES.get_proxy()
services_dbus_tasks = services_proxy.InstallWithTasks()
os_config.append_dbus_tasks(SERVICES, services_dbus_tasks)
# add installation tasks for the Timezone DBus module
timezone_proxy = TIMEZONE.get_proxy()
timezone_dbus_tasks = timezone_proxy.InstallWithTasks()
os_config.append_dbus_tasks(TIMEZONE, timezone_dbus_tasks)
# add installation tasks for the Localization DBus module
localization_proxy = LOCALIZATION.get_proxy()
localization_dbus_tasks = localization_proxy.InstallWithTasks()
os_config.append_dbus_tasks(LOCALIZATION, localization_dbus_tasks)
# add the Firewall configuration task
firewall_proxy = NETWORK.get_proxy(FIREWALL)
firewall_dbus_task = firewall_proxy.InstallWithTask()
os_config.append_dbus_tasks(NETWORK, [firewall_dbus_task])
configuration_queue.append(os_config)
# schedule network configuration (if required)
if conf.system.provides_network_config:
overwrite = isinstance(payload, LiveImagePayload)
network_config = TaskQueue("Network configuration",
N_("Writing network configuration"))
network_config.append(
Task("Network configuration", network.write_configuration,
(overwrite, )))
configuration_queue.append(network_config)
# add installation tasks for the Users DBus module
user_config = TaskQueue("User creation", N_("Creating users"))
users_proxy = USERS.get_proxy()
users_dbus_tasks = users_proxy.InstallWithTasks()
os_config.append_dbus_tasks(USERS, users_dbus_tasks)
configuration_queue.append(user_config)
# Anaconda addon configuration
addon_config = TaskQueue("Anaconda addon configuration",
N_("Configuring addons"))
# there is no longer a User class & addons should no longer need it
# FIXME: drop user class parameter from the API & all known addons
addon_config.append(
Task("Configure Anaconda addons", ksdata.addons.execute,
(None, ksdata, None, payload)))
boss_proxy = BOSS.get_proxy()
addon_config.append_dbus_tasks(BOSS, [boss_proxy.InstallSystemWithTask()])
configuration_queue.append(addon_config)
# Initramfs generation
generate_initramfs = TaskQueue("Initramfs generation",
N_("Generating initramfs"))
generate_initramfs.append(
Task("Generate initramfs", payload.recreate_initrds))
# This works around 2 problems, /boot on BTRFS and BTRFS installations where the initrd is
# recreated after the first writeBootLoader call. This reruns it after the new initrd has
# been created, fixing the kernel root and subvol args and adding the missing initrd entry.
bootloader_proxy = STORAGE.get_proxy(BOOTLOADER)
if isinstance(payload, LiveImagePayload):
btrfs_task = bootloader_proxy.FixBTRFSWithTask(
payload.kernel_version_list)
generate_initramfs.append_dbus_tasks(STORAGE, [btrfs_task])
# Invoking zipl should be the last thing done on a s390x installation (see #1652727).
zipl_task = bootloader_proxy.FixZIPLWithTask()
generate_initramfs.append_dbus_tasks(STORAGE, [zipl_task])
configuration_queue.append(generate_initramfs)
# realm join
# - this can run only after network is configured in the target system chroot
configuration_queue.append_dbus_tasks(SECURITY,
[security_proxy.JoinRealmWithTask()])
post_scripts = TaskQueue("Post installation scripts",
N_("Running post-installation scripts"))
post_scripts.append(
Task("Run post installation scripts", runPostScripts,
(ksdata.scripts, )))
configuration_queue.append(post_scripts)
# setup kexec reboot if requested
if flags.flags.kexec:
kexec_setup = TaskQueue("Kexec setup", N_("Setting up kexec"))
kexec_setup.append(Task("Setup kexec", setup_kexec))
configuration_queue.append(kexec_setup)
# write anaconda related configs & kickstarts
write_configs = TaskQueue("Write configs and kickstarts",
N_("Storing configuration files and kickstarts"))
# Write the kickstart file to the installed system (or, copy the input
# kickstart file over if one exists).
if flags.flags.nosave_output_ks:
# don't write the kickstart file to the installed system if this has
# been disabled by the nosave option
log.warning(
"Writing of the output kickstart to installed system has been disabled"
" by the nosave option.")
else:
# write anaconda related configs & kickstarts
write_configs.append(Task("Store kickstarts", _writeKS, (ksdata, )))
# only add write_configs to the main queue if we actually store some kickstarts/configs
if write_configs.task_count:
configuration_queue.append(write_configs)
return configuration_queue
def _apply(self):
# Do not execute sections that were part of the original
# anaconda kickstart file (== have .seen flag set)
log.info("applying changes")
sections = [self.data.keyboard, self.data.lang, self.data.timezone]
# data.selinux
# data.firewall
localization_proxy = LOCALIZATION.get_proxy()
self.data.keyboard.seen = localization_proxy.KeyboardKickstarted
self.data.lang.seen = localization_proxy.LanguageKickstarted
timezone_proxy = TIMEZONE.get_proxy()
self.data.timezone.seen = timezone_proxy.Kickstarted
log.info("executing kickstart")
for section in sections:
section_msg = "%s on line %d" % (repr(section), section.lineno)
if section.seen:
log.debug("skipping %s", section_msg)
continue
log.debug("executing %s", section_msg)
section.execute(None, self.data, None)
# Prepare the user database tools
u = Users()
sections = [self.data.group, self.data.user, self.data.rootpw]
user_proxy = USER.get_proxy()
self.data.rootpw.seen = user_proxy.IsRootpwKickstarted
for section in sections:
section_msg = "%s on line %d" % (repr(section), section.lineno)
if section.seen:
log.debug("skipping %s", section_msg)
continue
log.debug("executing %s", section_msg)
section.execute(None, self.data, None, u)
# Configure all addons
log.info("executing addons")
self.data.addons.execute(None, self.data, None, u, None)
if self.external_reconfig:
# prevent the reconfig flag from being written out
# to kickstart if neither /etc/reconfigSys or /.unconfigured
# are present
services_proxy = SERVICES.get_proxy()
services_proxy.SetSetupOnBoot(SETUP_ON_BOOT_DEFAULT)
# Write the kickstart data to file
log.info("writing the Initial Setup kickstart file %s", OUTPUT_KICKSTART_PATH)
with open(OUTPUT_KICKSTART_PATH, "w") as f:
f.write(str(self.data))
log.info("finished writing the Initial Setup kickstart file")
# Remove the reconfig files, if any - otherwise the reconfig mode
# would start again next time the Initial Setup service is enabled.
if self.external_reconfig:
for reconfig_file in RECONFIG_FILES:
if os.path.exists(reconfig_file):
log.debug("removing reconfig trigger file: %s" % reconfig_file)
os.remove(reconfig_file)
# and we are done with applying changes
log.info("all changes have been applied")
localization.setup_locale(os.environ["LANG"], localization_proxy, text_mode=anaconda.tui_mode)
# we now know in which mode we are going to run so store the information
from pykickstart import constants as pykickstart_constants
display_mode_coversion_table = {
constants.DisplayModes.GUI: pykickstart_constants.DISPLAY_MODE_GRAPHICAL,
constants.DisplayModes.TUI: pykickstart_constants.DISPLAY_MODE_TEXT
}
ksdata.displaymode.displayMode = display_mode_coversion_table[anaconda.display_mode]
ksdata.displaymode.nonInteractive = not anaconda.interactive_mode
# if we're in text mode, the resulting system should be too
# ...unless the kickstart specified otherwise
from pyanaconda.modules.common.constants.services import SERVICES
from pyanaconda.core.constants import TEXT_ONLY_TARGET
services_proxy = SERVICES.get_proxy()
if not services_proxy.DefaultTarget and anaconda.tui_mode:
services_proxy.SetDefaultTarget(TEXT_ONLY_TARGET)
# Set flag to prompt for missing ks data
if not anaconda.interactive_mode:
flags.ksprompt = False
# Set minimal ram size to the storage checker.
if anaconda.display_mode == constants.DisplayModes.GUI:
min_ram = isys.MIN_GUI_RAM
else:
min_ram = isys.MIN_RAM
from pyanaconda.storage_utils import storage_checker
def doConfiguration(storage, payload, ksdata):
"""Configure the installed system."""
configuration_queue = TaskQueue("Configuration queue")
# connect progress reporting
configuration_queue.queue_started.connect(
lambda x: progress_message(x.status_message))
configuration_queue.task_completed.connect(lambda x: progress_step(x.name))
# schedule the execute methods of ksdata that require an installed system to be present
os_config = TaskQueue("Installed system configuration",
N_("Configuring installed system"))
os_config.append(Task("Configure authselect", ksdata.authselect.execute))
security_proxy = SECURITY.get_proxy()
security_dbus_tasks = security_proxy.InstallWithTasks(util.getSysroot())
# add one Task instance per DBUS task
for dbus_task in security_dbus_tasks:
task_proxy = SECURITY.get_proxy(dbus_task)
os_config.append(Task(task_proxy.Name, sync_run_task, (task_proxy, )))
services_proxy = SERVICES.get_proxy()
services_dbus_tasks = services_proxy.InstallWithTasks(util.getSysroot())
# add one Task instance per DBUS task
for dbus_task in services_dbus_tasks:
task_proxy = SERVICES.get_proxy(dbus_task)
os_config.append(Task(task_proxy.Name, sync_run_task, (task_proxy, )))
os_config.append(Task("Configure keyboard", ksdata.keyboard.execute))
os_config.append(Task("Configure timezone", ksdata.timezone.execute))
localization_proxy = LOCALIZATION.get_proxy()
localization_dbus_tasks = localization_proxy.InstallWithTasks(
util.getSysroot())
# add one Task instance per DBUS task
for dbus_task in localization_dbus_tasks:
task_proxy = LOCALIZATION.get_proxy(dbus_task)
os_config.append(Task(task_proxy.Name, sync_run_task, (task_proxy, )))
firewall_proxy = NETWORK.get_proxy(FIREWALL)
firewall_dbus_task = firewall_proxy.InstallWithTask(util.getSysroot())
task_proxy = NETWORK.get_proxy(firewall_dbus_task)
os_config.append(Task(task_proxy.Name, sync_run_task, (task_proxy, )))
configuration_queue.append(os_config)
# schedule network configuration (if required)
if conf.system.provides_network_config:
network_config = TaskQueue("Network configuration",
N_("Writing network configuration"))
network_config.append(
Task("Network configuration", ksdata.network.execute, (payload, )))
configuration_queue.append(network_config)
# creating users and groups requires some pre-configuration.
user_config = TaskQueue("User creation", N_("Creating users"))
users_proxy = USERS.get_proxy()
users_dbus_tasks = users_proxy.InstallWithTasks(util.getSysroot())
# add one Task instance per DBUS task
for dbus_task in users_dbus_tasks:
task_proxy = USERS.get_proxy(dbus_task)
user_config.append(Task(task_proxy.Name, sync_run_task,
(task_proxy, )))
configuration_queue.append(user_config)
# Anaconda addon configuration
addon_config = TaskQueue("Anaconda addon configuration",
N_("Configuring addons"))
# there is no longer a User class & addons should no longer need it
# FIXME: drop user class parameter from the API & all known addons
addon_config.append(
Task("Configure Anaconda addons", ksdata.addons.execute,
(storage, ksdata, None, payload)))
configuration_queue.append(addon_config)
# Initramfs generation
generate_initramfs = TaskQueue("Initramfs generation",
N_("Generating initramfs"))
generate_initramfs.append(
Task("Generate initramfs", payload.recreate_initrds))
# This works around 2 problems, /boot on BTRFS and BTRFS installations where the initrd is
# recreated after the first writeBootLoader call. This reruns it after the new initrd has
# been created, fixing the kernel root and subvol args and adding the missing initrd entry.
boot_on_btrfs = isinstance(storage.mountpoints.get("/"), BTRFSDevice)
bootloader_proxy = STORAGE.get_proxy(BOOTLOADER)
bootloader_enabled = bootloader_proxy.BootloaderMode != BOOTLOADER_DISABLED
if isinstance(payload,
LiveImagePayload) and boot_on_btrfs and bootloader_enabled:
generate_initramfs.append(
Task("Write BTRFS bootloader fix", write_boot_loader,
(storage, payload)))
# Invoking zipl should be the last thing done on a s390x installation (see #1652727).
if arch.is_s390() and not conf.target.is_directory and bootloader_enabled:
generate_initramfs.append(
Task("Rerun zipl", lambda: util.execInSysroot("zipl", [])))
configuration_queue.append(generate_initramfs)
# join a realm (if required)
if ksdata.realm.discovered:
join_realm = TaskQueue(
"Realm join",
N_("Joining realm: %s") % ksdata.realm.discovered)
join_realm.append(Task("Join a realm", ksdata.realm.execute))
configuration_queue.append(join_realm)
post_scripts = TaskQueue("Post installation scripts",
N_("Running post-installation scripts"))
post_scripts.append(
Task("Run post installation scripts", runPostScripts,
(ksdata.scripts, )))
configuration_queue.append(post_scripts)
# setup kexec reboot if requested
if flags.flags.kexec:
kexec_setup = TaskQueue("Kexec setup", N_("Setting up kexec"))
kexec_setup.append(Task("Setup kexec", setup_kexec))
configuration_queue.append(kexec_setup)
# write anaconda related configs & kickstarts
write_configs = TaskQueue("Write configs and kickstarts",
N_("Storing configuration files and kickstarts"))
# Write the kickstart file to the installed system (or, copy the input
# kickstart file over if one exists).
if flags.flags.nosave_output_ks:
# don't write the kickstart file to the installed system if this has
# been disabled by the nosave option
log.warning(
"Writing of the output kickstart to installed system has been disabled"
" by the nosave option.")
else:
# write anaconda related configs & kickstarts
write_configs.append(Task("Store kickstarts", _writeKS, (ksdata, )))
# only add write_configs to the main queue if we actually store some kickstarts/configs
if write_configs.task_count:
configuration_queue.append(write_configs)
# notify progress tracking about the number of steps
progress_init(configuration_queue.task_count)
# log contents of the main task queue
log.info(configuration_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(configuration_queue.queue_count)
task_started_counter = util.item_counter(configuration_queue.task_count)
task_completed_counter = util.item_counter(configuration_queue.task_count)
configuration_queue.queue_started.connect(lambda x: log.info(
"Queue started: %s (%s)", x.name, next(queue_counter)))
configuration_queue.task_started.connect(lambda x: log.info(
"Task started: %s (%s)", x.name, next(task_started_counter)))
configuration_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
configuration_queue.start()
# done
progress_complete()
def __str__(self):
services_proxy = SERVICES.get_proxy()
return services_proxy.GenerateKickstart()
def _apply(self):
# Do not execute sections that were part of the original
# anaconda kickstart file (== have .seen flag set)
log.info("applying changes")
services_proxy = SERVICES.get_proxy()
reconfig_mode = services_proxy.SetupOnBoot == SETUP_ON_BOOT_RECONFIG
# data.selinux
# data.firewall
# Configure the timezone.
timezone_proxy = TIMEZONE.get_proxy()
for task_path in timezone_proxy.InstallWithTasks():
task_proxy = TIMEZONE.get_proxy(task_path)
sync_run_task(task_proxy)
# Configure the localization.
localization_proxy = LOCALIZATION.get_proxy()
for task_path in localization_proxy.InstallWithTasks():
task_proxy = LOCALIZATION.get_proxy(task_path)
sync_run_task(task_proxy)
# Configure persistent hostname
network_proxy = NETWORK.get_proxy()
network_task = network_proxy.ConfigureHostnameWithTask(True)
task_proxy = NETWORK.get_proxy(network_task)
sync_run_task(task_proxy)
# Set current hostname
network_proxy.SetCurrentHostname(network_proxy.Hostname)
# Configure groups, users & root account
#
# NOTE: We only configure groups, users & root account if the respective
# kickstart commands are *not* seen in the input kickstart.
# This basically means that we will configure only what was
# set in the Initial Setup UI and will not attempt to configure
# anything that looks like it was configured previously in
# the Anaconda UI or installation kickstart.
users_proxy = USERS.get_proxy()
if self._groups_already_configured and not reconfig_mode:
log.debug("skipping user group configuration - already configured")
elif users_proxy.Groups: # only run of there are some groups to create
groups_task = users_proxy.ConfigureGroupsWithTask()
task_proxy = USERS.get_proxy(groups_task)
log.debug("configuring user groups via %s task", task_proxy.Name)
sync_run_task(task_proxy)
if self._users_already_configured and not reconfig_mode:
log.debug("skipping user configuration - already configured")
elif users_proxy.Users: # only run if there are some users to create
users_task = users_proxy.ConfigureUsersWithTask()
task_proxy = USERS.get_proxy(users_task)
log.debug("configuring users via %s task", task_proxy.Name)
sync_run_task(task_proxy)
if self._root_password_already_configured and not reconfig_mode:
log.debug(
"skipping root password configuration - already configured")
else:
root_task = users_proxy.SetRootPasswordWithTask()
task_proxy = USERS.get_proxy(root_task)
log.debug("configuring root password via %s task", task_proxy.Name)
sync_run_task(task_proxy)
# Configure all addons
log.info("executing addons")
self.data.addons.execute(storage=None,
ksdata=self.data,
users=None,
payload=None)
boss_proxy = BOSS.get_proxy()
task_path = boss_proxy.InstallSystemWithTask()
task_proxy = BOSS.get_proxy(task_path)
sync_run_task(task_proxy)
if self.external_reconfig:
# prevent the reconfig flag from being written out
# to kickstart if neither /etc/reconfigSys or /.unconfigured
# are present
services_proxy = SERVICES.get_proxy()
services_proxy.SetSetupOnBoot(SETUP_ON_BOOT_DEFAULT)
# Write the kickstart data to file
log.info("writing the Initial Setup kickstart file %s",
OUTPUT_KICKSTART_PATH)
with open(OUTPUT_KICKSTART_PATH, "w") as f:
f.write(str(self.data))
log.info("finished writing the Initial Setup kickstart file")
# Remove the reconfig files, if any - otherwise the reconfig mode
# would start again next time the Initial Setup service is enabled.
if self.external_reconfig:
for reconfig_file in RECONFIG_FILES:
if os.path.exists(reconfig_file):
log.debug("removing reconfig trigger file: %s" %
reconfig_file)
os.remove(reconfig_file)
# and we are done with applying changes
log.info("all changes have been applied")
def _prepare_configuration(payload, ksdata):
"""Configure the installed system."""
configuration_queue = TaskQueue("Configuration queue")
# connect progress reporting
configuration_queue.queue_started.connect(
lambda x: progress_message(x.status_message))
configuration_queue.task_completed.connect(lambda x: progress_step(x.name))
# add installation tasks for the Subscription DBus module
if is_module_available(SUBSCRIPTION):
# we only run the tasks if the Subscription module is available
subscription_config = TaskQueue("Subscription configuration",
N_("Configuring Red Hat subscription"))
subscription_proxy = SUBSCRIPTION.get_proxy()
subscription_dbus_tasks = subscription_proxy.InstallWithTasks()
subscription_config.append_dbus_tasks(SUBSCRIPTION,
subscription_dbus_tasks)
configuration_queue.append(subscription_config)
# schedule the execute methods of ksdata that require an installed system to be present
os_config = TaskQueue("Installed system configuration",
N_("Configuring installed system"))
# add installation tasks for the Security DBus module
security_proxy = SECURITY.get_proxy()
security_dbus_tasks = security_proxy.InstallWithTasks()
os_config.append_dbus_tasks(SECURITY, security_dbus_tasks)
# add installation tasks for the Timezone DBus module
# run these tasks before tasks of the Services module
if is_module_available(TIMEZONE):
timezone_proxy = TIMEZONE.get_proxy()
timezone_dbus_tasks = timezone_proxy.InstallWithTasks()
os_config.append_dbus_tasks(TIMEZONE, timezone_dbus_tasks)
# add installation tasks for the Services DBus module
services_proxy = SERVICES.get_proxy()
services_dbus_tasks = services_proxy.InstallWithTasks()
os_config.append_dbus_tasks(SERVICES, services_dbus_tasks)
# add installation tasks for the Localization DBus module
if is_module_available(LOCALIZATION):
localization_proxy = LOCALIZATION.get_proxy()
localization_dbus_tasks = localization_proxy.InstallWithTasks()
os_config.append_dbus_tasks(LOCALIZATION, localization_dbus_tasks)
# add the Firewall configuration task
if conf.target.can_configure_network:
firewall_proxy = NETWORK.get_proxy(FIREWALL)
firewall_dbus_task = firewall_proxy.InstallWithTask()
os_config.append_dbus_tasks(NETWORK, [firewall_dbus_task])
configuration_queue.append(os_config)
# schedule network configuration (if required)
if conf.target.can_configure_network and conf.system.provides_network_config:
overwrite = payload.type in PAYLOAD_LIVE_TYPES
network_config = TaskQueue("Network configuration",
N_("Writing network configuration"))
network_config.append(
Task("Network configuration", network.write_configuration,
(overwrite, )))
configuration_queue.append(network_config)
# add installation tasks for the Users DBus module
if is_module_available(USERS):
user_config = TaskQueue("User creation", N_("Creating users"))
users_proxy = USERS.get_proxy()
users_dbus_tasks = users_proxy.InstallWithTasks()
user_config.append_dbus_tasks(USERS, users_dbus_tasks)
configuration_queue.append(user_config)
# Anaconda addon configuration
addon_config = TaskQueue("Anaconda addon configuration",
N_("Configuring addons"))
# there is no longer a User class & addons should no longer need it
# FIXME: drop user class parameter from the API & all known addons
addon_config.append(
Task("Configure Anaconda addons", ksdata.addons.execute,
(None, ksdata, None, payload)))
boss_proxy = BOSS.get_proxy()
addon_config.append_dbus_tasks(BOSS, [boss_proxy.InstallSystemWithTask()])
configuration_queue.append(addon_config)
# Initramfs generation
generate_initramfs = TaskQueue("Initramfs generation",
N_("Generating initramfs"))
bootloader_proxy = STORAGE.get_proxy(BOOTLOADER)
def run_generate_initramfs():
tasks = bootloader_proxy.GenerateInitramfsWithTasks(
payload.type, payload.kernel_version_list)
for task in tasks:
sync_run_task(STORAGE.get_proxy(task))
generate_initramfs.append(
Task("Generate initramfs", run_generate_initramfs))
configuration_queue.append(generate_initramfs)
# Configure FIPS.
configuration_queue.append_dbus_tasks(
SECURITY, [security_proxy.ConfigureFIPSWithTask()])
# realm join
# - this can run only after network is configured in the target system chroot
configuration_queue.append_dbus_tasks(SECURITY,
[security_proxy.JoinRealmWithTask()])
post_scripts = TaskQueue("Post installation scripts",
N_("Running post-installation scripts"))
post_scripts.append(
Task("Run post installation scripts", runPostScripts,
(ksdata.scripts, )))
configuration_queue.append(post_scripts)
# setup kexec reboot if requested
if flags.flags.kexec:
kexec_setup = TaskQueue("Kexec setup", N_("Setting up kexec"))
kexec_setup.append(Task("Setup kexec", setup_kexec))
configuration_queue.append(kexec_setup)
# write anaconda related configs & kickstarts
write_configs = TaskQueue("Write configs and kickstarts",
N_("Storing configuration files and kickstarts"))
# Write the kickstart file to the installed system (or, copy the input
# kickstart file over if one exists).
if flags.flags.nosave_output_ks:
# don't write the kickstart file to the installed system if this has
# been disabled by the nosave option
log.warning(
"Writing of the output kickstart to installed system has been disabled"
" by the nosave option.")
else:
# write anaconda related configs & kickstarts
write_configs.append(Task("Store kickstarts", _writeKS, (ksdata, )))
# only add write_configs to the main queue if we actually store some kickstarts/configs
if write_configs.task_count:
configuration_queue.append(write_configs)
return configuration_queue
def __str__(self):
services_proxy = SERVICES.get_proxy()
return services_proxy.GenerateKickstart()