def _quit_callback(self, data):
d = YesNoDialog(_(QUIT_MESSAGE))
ScreenHandler.push_screen_modal(d)
self.redraw()
if d.answer:
self._rescue.reboot = True
self._rescue.finish()
def run_dasdfmt_dialog(self, dasd_formatting):
"""Do DASD formatting if user agrees."""
# Prepare text of the dialog.
text = ""
text += _("The following unformatted or LDL DASDs have been "
"detected on your system. You can choose to format them "
"now with dasdfmt or cancel to leave them unformatted. "
"Unformatted DASDs cannot be used during installation.\n\n")
text += dasd_formatting.dasds_summary + "\n\n"
text += _("Warning: All storage changes made using the installer will "
"be lost when you choose to format.\n\nProceed to run dasdfmt?\n")
# Run the dialog.
question_window = YesNoDialog(text)
ScreenHandler.push_screen_modal(question_window)
if not question_window.answer:
return None
print(_("This may take a moment."), flush=True)
# Do the DASD formatting.
dasd_formatting.report.connect(self._show_dasdfmt_report)
dasd_formatting.run(self.storage, self.data)
dasd_formatting.report.disconnect(self._show_dasdfmt_report)
self.update_disks()
def _unlock_devices(self):
"""Attempt to unlock all locked LUKS devices.
Returns true if all devices were unlocked.
"""
try_passphrase = None
passphrase = None
for device_name in self._rescue.get_locked_device_names():
skip = False
unlocked = False
while not (skip or unlocked):
if try_passphrase is None:
p = PasswordDialog(device_name)
ScreenHandler.push_screen_modal(p)
if p.answer:
passphrase = p.answer.strip()
else:
passphrase = try_passphrase
if passphrase is None:
# cancelled
skip = True
else:
unlocked = self._rescue.unlock_device(device_name, passphrase)
try_passphrase = passphrase if unlocked else None
return not self._rescue.get_locked_device_names()
def _set_network_nfs(self, data):
self.set_source_nfs()
new_spoke = SpecifyNFSRepoSpoke(self.data, self.storage,
self.payload, self.instclass, self._error)
ScreenHandler.push_screen_modal(new_spoke)
self.apply()
self.close()
def _set_iso_install_source(self, data):
new_spoke = SelectDeviceSpoke(self.data,
self.storage, self.payload,
self.instclass)
ScreenHandler.push_screen_modal(new_spoke)
self.apply()
self.close()
def _select_mountable_device(self, data):
self._device = data
new_spoke = SelectISOSpoke(self.data,
self.storage, self.payload,
self.instclass, self._device)
ScreenHandler.push_screen_modal(new_spoke)
self.close()
def _quit_callback(self, data):
d = YesNoDialog(_(u"Do you really want to quit?"))
ScreenHandler.push_screen_modal(d)
self.redraw()
if d.answer:
self._rescue.reboot = True
self._rescue.finish()
def _configure_connection(self, iface, connection_uuid):
connection = self.nm_client.get_connection_by_uuid(connection_uuid)
new_spoke = ConfigureDeviceSpoke(self.data, self.storage, self.payload,
self._network_module, iface, connection)
ScreenHandler.push_screen_modal(new_spoke)
if new_spoke.errors:
self.errors.extend(new_spoke.errors)
self.redraw()
return
if new_spoke.apply_configuration:
self._apply = True
device = self.nm_client.get_device_by_iface(iface)
log.debug("activating connection %s with device %s",
connection_uuid, iface)
self.nm_client.activate_connection_async(connection, device, None, None)
self._network_module.proxy.LogConfigurationState(
"Settings of {} updated in TUI.".format(iface)
)
self.redraw()
self.apply()
def input(self, args, key):
"""Handle the input."""
# TRANSLATORS: 'h' to help
if key.lower() == Prompt.HELP:
if self.has_help:
help_path = get_help_path(self.helpFile, True)
ScreenHandler.push_screen_modal(HelpScreen(help_path))
return InputState.PROCESSED_AND_REDRAW
return super().input(args, key)
def _showError(self, message):
"""Internal helper function that MUST BE CALLED FROM THE MAIN THREAD."""
if flags.automatedInstall and not flags.ksprompt:
log.error(message)
# If we're in cmdline mode, just exit.
return
error_window = IpmiErrorDialog(message)
ScreenHandler.push_screen_modal(error_window)
def _mount_root(self):
# decrypt all luks devices
self._unlock_devices()
found_roots = self._rescue.get_found_root_infos()
if len(found_roots) > 1:
# have to prompt user for which root to mount
root_spoke = RootSelectionSpoke(found_roots)
ScreenHandler.push_screen_modal(root_spoke)
self.redraw()
self._rescue.select_root(root_spoke.selection)
self._rescue.mount_root()
def input(self, args, key):
"""Handle the input."""
# TRANSLATORS: 'h' to help
if key.lower() == Prompt.HELP:
if self.has_help:
help_path = ihelp.get_help_path(self.helpFile, self.instclass, True)
ScreenHandler.push_screen_modal(HelpScreen(help_path))
self.redraw()
return InputState.PROCESSED
return super(NormalTUISpoke, self).input(args, key)
def _showYesNoQuestion(self, message):
"""Internal helper function that MUST BE CALLED FROM THE MAIN THREAD."""
if flags.automatedInstall and not flags.ksprompt:
log.error(message)
# If we're in cmdline mode, just say no.
return False
question_window = YesNoDialog(message)
ScreenHandler.push_screen_modal(question_window)
return question_window.answer
def _configure_network_interface(self, data):
devname = data
ndata = network.ksdata_from_ifcfg(devname)
if not ndata:
# There is no ifcfg file for the device.
# Make sure there is just one connection for the device.
try:
nm.nm_device_setting_value(devname, "connection", "uuid")
except nm.SettingsNotFoundError:
log.debug("can't find any connection for %s", devname)
return
except nm.MultipleSettingsFoundError:
log.debug("multiple non-ifcfg connections found for %s", devname)
return
log.debug("dumping ifcfg file for in-memory connection %s", devname)
nm.nm_update_settings_of_device(devname, [['connection', 'id', devname, None]])
ndata = network.ksdata_from_ifcfg(devname)
new_spoke = ConfigureNetworkSpoke(self.data, self.storage,
self.payload, self.instclass, ndata)
ScreenHandler.push_screen_modal(new_spoke)
self.redraw()
if ndata.ip == "dhcp":
ndata.bootProto = "dhcp"
ndata.ip = ""
else:
ndata.bootProto = "static"
if not ndata.netmask:
self.errors.append(_("Configuration not saved: netmask missing in static configuration"))
return
if ndata.ipv6 == "ignore":
ndata.noipv6 = True
ndata.ipv6 = ""
else:
ndata.noipv6 = False
uuid = network.update_settings_with_ksdata(devname, ndata)
network.update_onboot_value(devname, ndata.onboot, ksdata=None, root_path="")
network.logIfcfgFiles("settings of %s updated in tui" % devname)
if ndata._apply:
self._apply = True
try:
nm.nm_activate_device_connection(devname, uuid)
except (nm.UnmanagedDeviceError, nm.UnknownConnectionError):
self.errors.append(_("Can't apply configuration, device activation failed."))
self.apply()
def _validate_password(self, password, confirm):
"""Validate and process user password."""
if password != confirm:
self._report(_(constants.SECRET_CONFIRM_ERROR_TUI[self._secret_type]))
return None
# If an empty password was provided, unset the value
if not password:
return ""
# prepare a password validation request
password_check_request = input_checking.PasswordCheckRequest()
password_check_request.password = password
password_check_request.password_confirmation = ""
password_check_request.policy = self._policy
# validate the password
password_check = input_checking.PasswordValidityCheck()
password_check.run(password_check_request)
# if the score is equal to 0 and we have an error message set
if not password_check.result.password_score and password_check.result.error_message:
self._report(password_check.result.error_message)
return None
if password_check.result.password_quality < self._policy.minquality:
if self._policy.strict:
done_msg = ""
else:
done_msg = _("\nWould you like to use it anyway?")
if password_check.result.error_message:
weak_prefix = _(constants.SECRET_WEAK_WITH_ERROR[self._secret_type])
error = "{} {} {}".format(weak_prefix, password_check.result.error_message, done_msg)
else:
weak_prefix = _(constants.SECRET_WEAK[self._secret_type])
error = "{} {}".format(weak_prefix, done_msg)
if not self._policy.strict:
question_window = YesNoDialog(error)
ScreenHandler.push_screen_modal(question_window)
if not question_window.answer:
return None
else:
self._report(error)
return None
if any(char not in constants.PW_ASCII_CHARS for char in password):
self._report(_(constants.SECRET_ASCII[self._secret_type]))
return self._process_password(password)
def run(self):
"""Get input from user, run the condition functions and call setter callback at the end.
Repeat asking user for input to the time when all the acceptance conditions will be satisfied.
"""
screen = GetInputScreen(self._user_prompt)
if self._conditions:
for c in self._conditions:
screen.add_acceptance_condition(c, self._report_func)
screen.no_separator = self._no_separator
ScreenHandler.push_screen_modal(screen)
return screen.value
def _rescan_devices(self):
"""Rescan devices."""
text = _("Warning: This will revert all changes done so far.\n"
"Do you want to proceed?\n")
question_window = YesNoDialog(text)
ScreenHandler.push_screen_modal(question_window)
if not question_window.answer:
return
print(_("Scanning disks. This may take a moment..."))
reset_storage(self.storage, scan_all=True)
self._manual_part_proxy.SetMountPoints([])
self._mount_info = self._gather_mount_info()
def input(self, args, key):
"""Grab the disk choice and update things"""
self.errors = []
if self._container.process_user_input(key):
return InputState.PROCESSED_AND_REDRAW
else:
# TRANSLATORS: 'c' to continue
if key.lower() == C_('TUI|Spoke Navigation', 'c'):
if self._selected_disks:
# Is DASD formatting supported?
if DasdFormatting.is_supported():
# Wait for storage.
threadMgr.wait(THREAD_STORAGE)
# Get selected disks.
disks = filter_disks_by_names(self._available_disks, self._selected_disks)
# Check if some of the disks should be formatted.
dasd_formatting = DasdFormatting()
dasd_formatting.search_disks(disks)
if dasd_formatting.should_run():
# We want to apply current selection before running dasdfmt to
# prevent this information from being lost afterward
apply_disk_selection(self.storage, self._selected_disks)
# Run the dialog.
self.run_dasdfmt_dialog(dasd_formatting)
return InputState.PROCESSED_AND_REDRAW
# make sure no containers were split up by the user's disk
# selection
self.errors.extend(check_disk_selection(self.storage,
self._selected_disks))
if self.errors:
# The disk selection has to make sense before we can
# proceed.
return InputState.PROCESSED_AND_REDRAW
self.apply()
new_spoke = PartTypeSpoke(self.data, self.storage, self.payload)
ScreenHandler.push_screen_modal(new_spoke)
self.apply()
self.execute()
return InputState.PROCESSED_AND_CLOSE
else:
return super().input(args, key)
def input(self, args, key):
"""Grab the choice and update things"""
if not self._container.process_user_input(key):
# TRANSLATORS: 'c' to continue
if key.lower() == C_('TUI|Spoke Navigation', 'c'):
new_spoke = PartitionSchemeSpoke(self.data, self.storage,
self.payload, self.instclass)
ScreenHandler.push_screen_modal(new_spoke)
self.apply()
self.close()
return InputState.PROCESSED
else:
return super(AutoPartSpoke, self).input(args, key)
self.redraw()
return InputState.PROCESSED
def input(self, args, key):
"""Grab the choice and update things"""
if not self._container.process_user_input(key):
# TRANSLATORS: 'c' to continue
if key.lower() == C_('TUI|Spoke Navigation', 'c'):
self.apply()
self._ensure_init_storage()
if self._do_mount_assign:
new_spoke = MountPointAssignSpoke(self.data, self.storage, self.payload)
else:
new_spoke = PartitionSchemeSpoke(self.data, self.storage, self.payload)
ScreenHandler.push_screen_modal(new_spoke)
return InputState.PROCESSED_AND_CLOSE
else:
return super().input(args, key)
return InputState.PROCESSED_AND_REDRAW
def input(self, args, key):
"""Override input so that we can launch the VNC password spoke"""
if self._container.process_user_input(key):
self.apply()
return InputState.PROCESSED_AND_CLOSE
else:
# TRANSLATORS: 'q' to quit
if key.lower() == C_('TUI|Spoke Navigation', 'q'):
d = YesNoDialog(_(u"Do you really want to quit?"))
ScreenHandler.push_screen_modal(d)
if d.answer:
ipmi_abort(scripts=self.data.scripts)
if conf.system.can_reboot:
execWithRedirect("systemctl", ["--no-wall", "reboot"])
else:
sys.exit(1)
else:
return super().input(args, key)
def _mount_root(self):
# decrypt all luks devices
self._unlock_devices()
roots = self._rescue.find_roots()
if not roots:
return
if len(roots) == 1:
root = roots[0]
else:
# have to prompt user for which root to mount
root_spoke = RootSelectionSpoke(roots)
ScreenHandler.push_screen_modal(root_spoke)
self.redraw()
root = root_spoke.selection
self._rescue.mount_root(root)
def input(self, args, key):
"""Grab the disk choice and update things"""
self.errors = []
if self._container.process_user_input(key):
self.redraw()
return InputState.PROCESSED
else:
# TRANSLATORS: 'c' to continue
if key.lower() == C_('TUI|Spoke Navigation', 'c'):
if self.selected_disks:
# check selected disks to see if we have any unformatted DASDs
# if we're on s390x, since they need to be formatted before we
# can use them.
if arch.is_s390():
_disks = [d for d in self.disks if d.name in self.selected_disks]
to_format = [d for d in _disks if d.type == "dasd" and
blockdev.s390.dasd_needs_format(d.busid)]
if to_format:
self.run_dasdfmt(to_format)
self.redraw()
return InputState.PROCESSED
# make sure no containers were split up by the user's disk
# selection
self.errors.extend(checkDiskSelection(self.storage,
self.selected_disks))
if self.errors:
# The disk selection has to make sense before we can
# proceed.
self.redraw()
return InputState.PROCESSED
new_spoke = AutoPartSpoke(self.data, self.storage,
self.payload, self.instclass)
ScreenHandler.push_screen_modal(new_spoke)
self.apply()
self.execute()
self.close()
return InputState.PROCESSED
else:
return super(StorageSpoke, self).input(args, key)
def input(self, args, key):
try:
idx = int(key) - 1
if idx >= 0 and idx < len(self.visible_fields):
if self.visible_fields[idx].aux == self.CHECK:
setdeepattr(self.args, self.visible_fields[idx].attribute,
not getdeepattr(self.args, self.visible_fields[idx][1]))
self.redraw()
self.apply()
else:
ScreenHandler.push_screen_modal(self.dialog, self.visible_fields[idx])
self.redraw()
if self.dialog.value is not None:
setdeepattr(self.args, self.visible_fields[idx].attribute,
self.dialog.value)
self.apply()
return InputState.PROCESSED
except ValueError:
pass
return NormalTUISpoke.input(self, args, key)
def input(self, args, key):
"""Handle user input. Numbers are used to show a spoke, the rest is passed
to the higher level for processing."""
if self._container.process_user_input(key):
return InputState.PROCESSED
else:
# If we get a continue, check for unfinished spokes. If unfinished
# don't continue
# TRANSLATORS: 'c' to continue
if key == Prompt.CONTINUE:
for spoke in self._spokes.values():
if not spoke.completed and spoke.mandatory:
print(_("Please complete all spokes before continuing"))
return InputState.DISCARDED
# TRANSLATORS: 'h' to help
elif key == Prompt.HELP:
if self.has_help:
help_path = ihelp.get_help_path(self.helpFile, self.instclass, True)
ScreenHandler.push_screen_modal(HelpScreen(help_path))
return InputState.PROCESSED_AND_REDRAW
return key
def run_dasdfmt(self, to_format):
"""
This generates the list of DASDs requiring dasdfmt and runs dasdfmt
against them.
"""
# if the storage thread is running, wait on it to complete before taking
# any further actions on devices; most likely to occur if user has
# zerombr in their ks file
threadMgr.wait(THREAD_STORAGE)
# ask user to verify they want to format if zerombr not in ks file
if not self.data.zerombr.zerombr:
# prepare our msg strings; copied directly from dasdfmt.glade
summary = _("The following unformatted DASDs have been detected on your system. You can choose to format them now with dasdfmt or cancel to leave them unformatted. Unformatted DASDs cannot be used during installation.\n\n")
warntext = _("Warning: All storage changes made using the installer will be lost when you choose to format.\n\nProceed to run dasdfmt?\n")
displaytext = summary + "\n".join("/dev/" + d.name for d in to_format) + "\n" + warntext
# now show actual prompt; note -- in cmdline mode, auto-answer for
# this is 'no', so unformatted DASDs will remain so unless zerombr
# is added to the ks file
question_window = YesNoDialog(displaytext)
ScreenHandler.push_screen_modal(question_window)
if not question_window.answer:
# no? well fine then, back to the storage spoke with you;
return None
for disk in to_format:
try:
print(_("Formatting /dev/%s. This may take a moment.") % disk.name)
blockdev.s390.dasd_format(disk.name)
except blockdev.S390Error as err:
# Log errors if formatting fails, but don't halt the installer
log.error(str(err))
continue
def _add_ntp_server(self, data):
new_spoke = AddNTPServerSpoke(self.data, self.storage, self.payload,
self._servers, self._states)
ScreenHandler.push_screen_modal(new_spoke)
self.redraw()
def _set_hostname_callback(self, data):
# set hostname
entry = Entry(_("Host Name"), "hostname", re.compile(".*$"), True)
ScreenHandler.push_screen_modal(self.hostname_dialog, entry)
self.redraw()
self.apply()
def _timezone_callback(self, data):
ScreenHandler.push_screen_modal(self.timezone_spoke)
self.close()
def _set_network_url(self, data):
new_spoke = SpecifyRepoSpoke(self.data, self.storage,
self.payload, self.instclass, data)
ScreenHandler.push_screen_modal(new_spoke)
self.apply()
self.close()
def _configure_ntp_server_callback(self, data):
new_spoke = NTPServersSpoke(self.data, self.storage, self.payload,
self.instclass, self)
ScreenHandler.push_screen_modal(new_spoke)
self.apply()
self.close()
def _remove_ntp_server(self, data):
new_spoke = RemoveNTPServerSpoke(self.data, self.storage, self.payload,
self.instclass, self._time_spoke)
ScreenHandler.push_screen_modal(new_spoke)
self.redraw()
def _set_iso_install_source(self, data):
new_spoke = SelectDeviceSpoke(self.data, self.storage, self.payload,
self.instclass)
ScreenHandler.push_screen_modal(new_spoke)
self.apply()
self.close()
def _set_network_url(self, data):
new_spoke = SpecifyRepoSpoke(self.data, self.storage, self.payload,
self.instclass, data)
ScreenHandler.push_screen_modal(new_spoke)
self.apply()
self.close()
def _select_mountable_device(self, data):
self._device = data
new_spoke = SelectISOSpoke(self.data, self.storage, self.payload,
self.instclass, self._device)
ScreenHandler.push_screen_modal(new_spoke)
self.close()
def _show_result_and_prompt_for_shell(self):
new_spoke = RescueStatusAndShellSpoke(self._rescue)
ScreenHandler.push_screen_modal(new_spoke)
self.close()
def _ask_pass_modal(self, prompt, no_separator):
pass_screen = GetPasswordInputScreen(prompt)
pass_screen.no_separator = no_separator
ScreenHandler.push_screen_modal(pass_screen)
return pass_screen.value
def _use_vnc_callback(self, data):
self._usevnc = True
new_spoke = VNCPassSpoke(self.data, self.storage, self.payload,
self.instclass)
ScreenHandler.push_screen_modal(new_spoke)
def _use_vnc_callback(self, data):
self._usevnc = True
new_spoke = VNCPassSpoke(self.data, self.storage,
self.payload, self.instclass)
ScreenHandler.push_screen_modal(new_spoke)
def _set_hostname_callback(self, data):
# set hostname
entry = Entry(_("Host Name"), "hostname", re.compile(".*$"), True)
ScreenHandler.push_screen_modal(self.hostname_dialog, entry)
self.redraw()
self.apply()