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()