def checkSoftwareSelection(self): from pyanaconda.packaging import DependencyError hubQ.send_message(self.__class__.__name__, _("Checking software dependencies...")) try: self.payload.checkSoftwareSelection() except DependencyError as e: self._errorMsgs = "\n".join(sorted(e.message)) hubQ.send_message(self.__class__.__name__, _("Error checking software dependencies")) self._tx_id = None else: self._errorMsgs = None # If we are installing with a kickstart that does not specify packages, # we want the user to enter the Software spoke and confirm the software # selection. We do this be by resetting the transaction id, which # forces the user to visit the spoke and also makes sure any changes # the user does in the spoke are respected. if flags.automatedInstall and not self.data.packages.seen: self._tx_id = None else: self._tx_id = self.payload.txID finally: hubQ.send_ready(self.__class__.__name__, False) hubQ.send_ready("SourceSpoke", False)
def apply(self): # Copy data from the UI back to the kickstart object homedir = self._tHome.get_text() # If the user cleared the home directory, revert back to the # default if not homedir: self._user.homedir = None # If the user modified the home directory input, save that the # home directory has been modified and use the value. elif self._origHome != homedir: if not os.path.isabs(homedir): homedir = "/" + homedir self._user.homedir = homedir # Otherwise leave the home directory alone. If the home # directory is currently the default value, the next call # to refresh() will update the input text to reflect # changes in the username. if self._cUid.get_active(): self._user.uid = int(self._uid.get_value()) else: self._user.uid = None if self._cGid.get_active(): self._user.gid = int(self._gid.get_value()) else: self._user.gid = None # ''.split(',') returns [''] instead of [], which is not what we want self._user.groups = [g.strip() for g in self._tGroups.get_text().split(",") if g] # Send ready signal to main event loop hubQ.send_ready(self.__class__.__name__, False)
def ready(self): """ The ready property that tells whether the spoke is ready (can be visited) or not. The spoke is made (in)sensitive based on the returned value. :rtype: bool """ # Check if the hostname starts with "localhost" # if myHostname = subprocess.check_output(['hostname', '-s']).strip() if myHostname.startswith("localhost"): self.readyState = BADHOSTNAME return False # if the readyState was BADHOSTNAME return to CONFIGURE state # send a message to Hub that we are now ready (only way to # to remove this spoke from _notReady list if self.readyState == BADHOSTNAME: self.readyState = CONFIGURE hubQ.send_ready(self.__class__.__name__, True) if self.readyState == BUILDING: self.log.info("rocks_rolls.py:building db (ready)") return False self.log.info("rocks_rolls.py:ready") return True
def _doExecute(self): self._ready = False hubQ.send_not_ready(self.__class__.__name__) hubQ.send_message(self.__class__.__name__, _("Saving storage configuration...")) try: doKickstartStorage(self.storage, self.data, self.instclass) except (StorageError, KickstartValueError) as e: log.error("storage configuration failed: %s", e) StorageChecker.errors = str(e).split("\n") hubQ.send_message(self.__class__.__name__, _("Failed to save storage configuration...")) self.data.bootloader.bootDrive = "" self.data.ignoredisk.drives = [] self.data.ignoredisk.onlyuse = [] self.storage.config.update(self.data) self.storage.reset() self.disks = getDisks(self.storage.devicetree) # now set ksdata back to the user's specified config self._applyDiskSelection(self.selected_disks) except BootLoaderError as e: log.error("BootLoader setup failed: %s", e) StorageChecker.errors = str(e).split("\n") hubQ.send_message(self.__class__.__name__, _("Failed to save storage configuration...")) self.data.bootloader.bootDrive = "" else: if self.autopart: # this was already run as part of doAutoPartition. dumb. StorageChecker.errors = [] StorageChecker.warnings = [] self.run() finally: self._ready = True hubQ.send_ready(self.__class__.__name__, True)
def apply(self): pw = self.password enabled = self.root_enabled self._users_module.SetRootAccountLocked(not enabled) if enabled: # the checkbox makes it possible to override the default Open SSH # policy of not allowing root to login with password ssh_login_override = self._root_password_ssh_login_override.get_active( ) self._users_module.SetRootPasswordSSHLoginAllowed( ssh_login_override) if not pw: self._users_module.ClearRootPassword() return # we have a password - set it to kickstart data self._users_module.SetCryptedRootPassword(crypt_password(pw)) # clear any placeholders self.remove_placeholder_texts() # Send ready signal to main event loop hubQ.send_ready(self.__class__.__name__)
def ready(self): """ The ready property that tells whether the spoke is ready (can be visited) or not. The spoke is made (in)sensitive based on the returned value. :rtype: bool """ ## Let's see if we have a network default route set try: device = network.default_route_device() if device is None: self.readyState = False return False except: self.readyState = False return False # When we change from not ready to ready, send a HubQ message if self.readyState is False: self.readyState = True hubQ.send_ready(self.__class__.__name__, True) self.log.info("rocks_info.py:ready") return True
def ready(self): """ The ready property that tells whether the spoke is ready (can be visited) or not. The spoke is made (in)sensitive based on the returned value. :rtype: bool """ # Check if the hostname starts with "localhost" # if myHostname = subprocess.check_output(['hostname','-s']).strip() if myHostname.startswith("localhost"): self.readyState=BADHOSTNAME return False # if the readyState was BADHOSTNAME return to CONFIGURE state # send a message to Hub that we are now ready (only way to # to remove this spoke from _notReady list if self.readyState == BADHOSTNAME: self.readyState = CONFIGURE hubQ.send_ready(self.__class__.__name__, True) if self.readyState == BUILDING: self.log.info("rocks_rolls.py:building db (ready)") return False self.log.info("rocks_rolls.py:ready") return True
def _initialize(self): threadMgr.wait(constants.THREAD_PAYLOAD) # Select groups which should be selected by kickstart try: for group in self.payload.selectedGroupsIDs(): if self.environment and self.payload.environmentOptionIsDefault(self.environment, group): self._addonStates[group] = self._ADDON_DEFAULT else: self._addonStates[group] = self._ADDON_SELECTED except PayloadError as e: # Group translation is not supported log.warning(e) # It's better to have all or nothing selected from kickstart self._addonStates = {} if not self._kickstarted: # having done all the slow downloading, we need to do the first refresh # of the UI here so there's an environment selected by default. This # happens inside the main thread by necessity. We can't do anything # that takes any real amount of time, or it'll block the UI from # updating. if not self._first_refresh(): return hubQ.send_ready(self.__class__.__name__, False) # If packages were provided by an input kickstart file (or some other means), # we should do dependency solving here. if not self._error: self._apply() # report that software spoke initialization has been completed self.initialize_done()
def _wait_ready(self): self._add_dialog.wait_initialize() self._ready = True hubQ.send_ready(self.__class__.__name__, False) # report that the keyboard spoke initialization has been completed self.initialize_done()
def _doExecute(self): self._ready = False hubQ.send_not_ready(self.__class__.__name__) # on the off-chance dasdfmt is running, we can't proceed further threadMgr.wait(constants.THREAD_DASDFMT) hubQ.send_message(self.__class__.__name__, _("Saving storage configuration...")) try: doKickstartStorage(self.storage, self.data, self.instclass) except (StorageError, KickstartValueError) as e: log.error("storage configuration failed: %s", e) StorageChecker.errors = str(e).split("\n") hubQ.send_message(self.__class__.__name__, _("Failed to save storage configuration...")) self.data.bootloader.bootDrive = "" self.data.ignoredisk.drives = [] self.data.ignoredisk.onlyuse = [] self.storage.config.update(self.data) self.storage.reset() self.disks = getDisks(self.storage.devicetree) # now set ksdata back to the user's specified config applyDiskSelection(self.storage, self.data, self.selected_disks) except BootLoaderError as e: log.error("BootLoader setup failed: %s", e) StorageChecker.errors = str(e).split("\n") hubQ.send_message(self.__class__.__name__, _("Failed to save storage configuration...")) self.data.bootloader.bootDrive = "" else: if self.autopart: self.run() finally: resetCustomStorageData(self.data) self._ready = True hubQ.send_ready(self.__class__.__name__, True)
def _subscription_progress_callback(self, phase): """Progress handling for subscription thread. Used both for both registration + attaching subscription and for unregistration. NOTE: Using the @async_action_wait decorator as this is called from the subscription thread. We need to do that as GTK does bad things if non main threads interact with it. """ # clear error message from a previous attempt (if any) self.registration_error = "" # set registration phase self.registration_phase = phase # set spoke status according to subscription thread phase if phase == SubscriptionPhase.DONE: log.debug("Subscription GUI: registration & attach done") # we are done, clear the phase self.registration_phase = None # update registration and subscription parts of the spoke self._update_registration_state() self._update_subscription_state() # enable controls self.set_registration_controls_sensitive(True) # notify hub hubQ.send_ready(self.__class__.__name__) else: # processing still ongoing, set the phase self.registration_phase = phase # notify hub hubQ.send_ready(self.__class__.__name__) # update spoke state self._update_registration_state()
def _initialize(self): threadMgr.wait(constants.THREAD_PAYLOAD) # Select groups which should be selected by kickstart try: for group in self.payload.selectedGroupsIDs(): if self.environment and self.payload.environmentOptionIsDefault( self.environment, group): self._addonStates[group] = self._ADDON_DEFAULT else: self._addonStates[group] = self._ADDON_SELECTED except PayloadError as e: # Group translation is not supported log.warning(e) # It's better to have all or nothing selected from kickstart self._addonStates = {} if not self._kickstarted: # having done all the slow downloading, we need to do the first refresh # of the UI here so there's an environment selected by default. This # happens inside the main thread by necessity. We can't do anything # that takes any real amount of time, or it'll block the UI from # updating. if not self._first_refresh(): return hubQ.send_ready(self.__class__.__name__, False) # If packages were provided by an input kickstart file (or some other means), # we should do dependency solving here. if not self._error: self._apply() # report that software spoke initialization has been completed self.initialize_done()
def apply(self): if self.root_enabled and self.password: # Set the root password. self._users_module.SetCryptedRootPassword( crypt_password(self.password)) # Unlock the root account. self._users_module.SetRootAccountLocked(False) else: # Reset the root password. self._users_module.ClearRootPassword() # Lock the root account. self._users_module.SetRootAccountLocked(True) if self.root_enabled: # the checkbox makes it possible to override the default Open SSH # policy of not allowing root to login with password ssh_login_override = self._root_password_ssh_login_override.get_active( ) self._users_module.SetRootPasswordSSHLoginAllowed( ssh_login_override) # clear any placeholders self.remove_placeholder_texts() # Send ready signal to main event loop hubQ.send_ready(self.__class__.__name__)
def _wait_ready(self): self._add_dialog.wait_initialize() self._ready = True hubQ.send_ready(self.__class__.__name__) # report that the keyboard spoke initialization has been completed self.initialize_done()
def _initialize(self): """Finish the initialization. This method is expected to run only once during the initialization. """ # Wait for storage. hubQ.send_message(self.__class__.__name__, _(constants.PAYLOAD_STATUS_PROBING_STORAGE)) threadMgr.wait(constants.THREAD_STORAGE) # Automatically format DASDs if allowed. disks = self._disk_select_module.GetUsableDisks() DasdFormatting.run_automatically(disks, self._show_dasdfmt_report) hubQ.send_message(self.__class__.__name__, _(constants.PAYLOAD_STATUS_PROBING_STORAGE)) # Update the selected disks. select_default_disks() # Automatically apply the preconfigured partitioning. # Do not set ready in the automated installation before # the execute method is run. if flags.automatedInstall and self._is_preconfigured: self._check_required_passphrase() self.execute() else: self._ready = True hubQ.send_ready(self.__class__.__name__) # Report that the storage spoke has been initialized. self.initialize_done()
def initialize(self): GUIObject.initialize(self) self._grabObjects() # Validate the group input box self.add_check(self._tGroups, self._validateGroups) # Send ready signal to main event loop hubQ.send_ready(self.__class__.__name__, False)
def builddb(self): oldReady = self.readyState self.log.info("rocks_rolls.py:building db (builddb)") self.readyState = BUILDING hubQ.send_ready(self.__class__.__name__, False) self.buildit(None) self.readyState = oldReady self.log.info("rocks_rolls.py: database built (builddb)") hubQ.send_ready(self.__class__.__name__, True)
def _initialize(self): hubQ.send_message(self.__class__.__name__, _("Probing storage...")) threadMgr.wait(constants.THREAD_STORAGE) hubQ.send_message(self.__class__.__name__, _(METADATA_DOWNLOAD_MESSAGE)) threadMgr.wait(constants.THREAD_PAYLOAD) added = False # If there's no fallback mirror to use, we should just disable that option # in the UI. if not self.payload.mirrorEnabled: self._protocolComboBox.remove(PROTOCOL_MIRROR) # If we've previously set up to use a CD/DVD method, the media has # already been mounted by payload.setup. We can't try to mount it # again. So just use what we already know to create the selector. # Otherwise, check to see if there's anything available. if self.data.method.method == "cdrom": self._cdrom = self.payload.install_device elif not flags.automatedInstall: self._cdrom = opticalInstallMedia(self.storage.devicetree) if self._cdrom: @gtk_action_wait def gtk_action_1(): self._autodetectDeviceLabel.set_text( _("Device: %s") % self._cdrom.name) self._autodetectLabel.set_text( _("Label: %s") % (getattr(self._cdrom.format, "label", "") or "")) gtk_action_1() added = True if self.data.method.method == "harddrive": self._currentIsoFile = self.payload.ISOImage # These UI elements default to not being showable. If optical install # media were found, mark them to be shown. if added: gtk_call_once(self._autodetectBox.set_no_show_all, False) gtk_call_once(self._autodetectButton.set_no_show_all, False) # Add the mirror manager URL in as the default for HTTP and HTTPS. # We'll override this later in the refresh() method, if they've already # provided a URL. # FIXME self._reset_repoStore() self._ready = True hubQ.send_ready(self.__class__.__name__, False)
def decorated(self, *args, **kwargs): ret = func(self, *args, **kwargs) self._unitialized_status = None self._ready = True # pylint: disable-msg=E1101 hubQ.send_ready(self.__class__.__name__, True) hubQ.send_message(self.__class__.__name__, self.status) return ret
def _do_execute(self): """Apply a non-interactive partitioning.""" self._ready = False hubQ.send_not_ready(self.__class__.__name__) report = apply_partitioning(self._partitioning, self._show_execute_message) StorageCheckHandler.errors = list(report.error_messages) StorageCheckHandler.warnings = list(report.warning_messages) self._ready = True hubQ.send_ready(self.__class__.__name__, True)
def checkStorage(self): threadMgr.wait(constants.THREAD_EXECUTE_STORAGE) hubQ.send_not_ready(self._mainSpokeClass) hubQ.send_message(self._mainSpokeClass, _("Checking storage configuration...")) (StorageChecker.errors, StorageChecker.warnings) = self.storage.sanityCheck() hubQ.send_ready(self._mainSpokeClass, True) for e in StorageChecker.errors: log.error(e) for w in StorageChecker.warnings: log.warn(w)
def checkStorage(self): threadMgr.wait(constants.THREAD_EXECUTE_STORAGE) hubQ.send_not_ready(self._mainSpokeClass) hubQ.send_message(self._mainSpokeClass, _("Checking storage configuration...")) (StorageChecker.errors, StorageChecker.warnings) = self.storage.sanityCheck() hubQ.send_ready(self._mainSpokeClass, True) for e in StorageChecker.errors: self.log.error(e) for w in StorageChecker.warnings: self.log.warn(w)
def _initialize(self): """Initialize the spoke in a separate thread.""" threadMgr.wait(THREAD_PAYLOAD) # Initialize and check the software selection. self._initialize_selection() # Update the status. hubQ.send_ready(self.__class__.__name__) # Report that the software spoke has been initialized. self.initialize_done()
def _initialize(self): hubQ.send_message(self.__class__.__name__, _("Probing storage...")) threadMgr.wait(constants.THREAD_STORAGE) hubQ.send_message(self.__class__.__name__, _(METADATA_DOWNLOAD_MESSAGE)) threadMgr.wait(constants.THREAD_PAYLOAD) added = False # If there's no fallback mirror to use, we should just disable that option # in the UI. if not self.payload.mirrorEnabled: self._protocolComboBox.remove(PROTOCOL_MIRROR) # If we've previously set up to use a CD/DVD method, the media has # already been mounted by payload.setup. We can't try to mount it # again. So just use what we already know to create the selector. # Otherwise, check to see if there's anything available. if self.data.method.method == "cdrom": self._cdrom = self.payload.install_device elif not flags.automatedInstall: self._cdrom = opticalInstallMedia(self.storage.devicetree) if self._cdrom: @gtk_action_wait def gtk_action_1(): self._autodetectDeviceLabel.set_text(_("Device: %s") % self._cdrom.name) self._autodetectLabel.set_text(_("Label: %s") % (getattr(self._cdrom.format, "label", "") or "")) gtk_action_1() added = True if self.data.method.method == "harddrive": self._currentIsoFile = self.payload.ISOImage # These UI elements default to not being showable. If optical install # media were found, mark them to be shown. if added: gtk_call_once(self._autodetectBox.set_no_show_all, False) gtk_call_once(self._autodetectButton.set_no_show_all, False) # Add the mirror manager URL in as the default for HTTP and HTTPS. # We'll override this later in the refresh() method, if they've already # provided a URL. # FIXME self._reset_repoStore() self._ready = True hubQ.send_ready(self.__class__.__name__, False)
def initialize(self): NormalSpoke.initialize(self) self.initialize_start() # place holders for the text boxes self.pw = self.builder.get_object("pw") self.confirm = self.builder.get_object("confirmPW") # Install the password checks: # - Has a password been specified? # - If a password has been specified and there is data in the confirm box, do they match? # - How strong is the password? # - Does the password contain non-ASCII characters? # - Is there any data in the confirm box? self._confirm_check = self.add_check(self.confirm, self.check_password_confirm) # Keep a reference for these checks, since they have to be manually run for the # click Done twice check. self._pwEmptyCheck = self.add_check(self.pw, self.check_password_empty) self._pwStrengthCheck = self.add_check( self.pw, self.check_user_password_strength) self._pwASCIICheck = self.add_check(self.pw, self.check_password_ASCII) self._kickstarted = self.data.rootpw.seen if self._kickstarted: self.pw.set_placeholder_text(_("The password is set.")) self.confirm.set_placeholder_text(_("The password is set.")) self.pw_bar = self.builder.get_object("password_bar") self.pw_label = self.builder.get_object("password_label") # Configure levels for the password bar self.pw_bar.add_offset_value("low", 2) self.pw_bar.add_offset_value("medium", 3) self.pw_bar.add_offset_value("high", 4) self.pw_bar.add_offset_value("full", 4) # Configure the password policy, if available. Otherwise use defaults. self.policy = self.data.anaconda.pwpolicy.get_policy("root") if not self.policy: self.policy = self.data.anaconda.PwPolicyData() # set the visibility of the password entries set_password_visibility(self.pw, False) set_password_visibility(self.confirm, False) # Send ready signal to main event loop hubQ.send_ready(self.__class__.__name__, False) # report that we are done self.initialize_done()
def _initialize(self): for day in xrange(1, 32): self.add_to_store(self._daysStore, day) for i in xrange(1, 13): #a bit hacky way, but should return the translated string #TODO: how to handle language change? Clear and populate again? month = datetime.date(2000, i, 1).strftime('%B') self.add_to_store(self._monthsStore, month) self._months_nums[month] = i for year in xrange(1990, 2051): self.add_to_store(self._yearsStore, year) cities = set() xlated_regions = ((region, get_xlated_timezone(region)) for region in self._regions_zones.iterkeys()) for region, xlated in sorted(xlated_regions, cmp=_compare_regions): self.add_to_store_xlated(self._regionsStore, region, xlated) for city in self._regions_zones[region]: cities.add((city, get_xlated_timezone(city))) for city, xlated in sorted(cities, cmp=_compare_cities): self.add_to_store_xlated(self._citiesStore, city, xlated) if self._radioButton24h.get_active(): self._set_amPm_part_sensitive(False) self._update_datetime_timer_id = None if is_valid_timezone(self.data.timezone.timezone): self._set_timezone(self.data.timezone.timezone) elif not flags.flags.automatedInstall: log.warning( "%s is not a valid timezone, falling back to default (%s)", self.data.timezone.timezone, DEFAULT_TZ) self._set_timezone(DEFAULT_TZ) self.data.timezone.timezone = DEFAULT_TZ if not flags.can_touch_runtime_system("modify system time and date"): self._set_date_time_setting_sensitive(False) self._config_dialog = NTPconfigDialog(self.data) self._config_dialog.initialize() time_init_thread = threadMgr.get(constants.THREAD_TIME_INIT) if time_init_thread is not None: hubQ.send_message(self.__class__.__name__, _("Restoring hardware time...")) threadMgr.wait(constants.THREAD_TIME_INIT) hubQ.send_ready(self.__class__.__name__, False)
def _subscription_error_callback(self, error_message): log.debug("Subscription GUI: registration & attach failed") # store the error message self.registration_error = error_message # even if we fail, we are technically done, # so clear the phase self.registration_phase = None # update registration and subscription parts of the spoke self._update_registration_state() self._update_subscription_state() # re-enable controls, so user can try again self.set_registration_controls_sensitive(True) # notify hub hubQ.send_ready(self.__class__.__name__)
def _initialize(self): for day in xrange(1, 32): self.add_to_store(self._daysStore, day) for i in xrange(1, 13): #a bit hacky way, but should return the translated string #TODO: how to handle language change? Clear and populate again? month = datetime.date(2000, i, 1).strftime('%B') self.add_to_store(self._monthsStore, month) self._months_nums[month] = i for year in xrange(1990, 2051): self.add_to_store(self._yearsStore, year) cities = set() xlated_regions = ((region, get_xlated_timezone(region)) for region in self._regions_zones.iterkeys()) for region, xlated in sorted(xlated_regions, cmp=_compare_regions): self.add_to_store_xlated(self._regionsStore, region, xlated) for city in self._regions_zones[region]: cities.add((city, get_xlated_timezone(city))) for city, xlated in sorted(cities, cmp=_compare_cities): self.add_to_store_xlated(self._citiesStore, city, xlated) if self._radioButton24h.get_active(): self._set_amPm_part_sensitive(False) self._update_datetime_timer_id = None if is_valid_timezone(self.data.timezone.timezone): self._set_timezone(self.data.timezone.timezone) elif not flags.flags.automatedInstall: log.warning("%s is not a valid timezone, falling back to default (%s)", self.data.timezone.timezone, DEFAULT_TZ) self._set_timezone(DEFAULT_TZ) self.data.timezone.timezone = DEFAULT_TZ if not flags.can_touch_runtime_system("modify system time and date"): self._set_date_time_setting_sensitive(False) self._config_dialog = NTPconfigDialog(self.data) self._config_dialog.initialize() time_init_thread = threadMgr.get(constants.THREAD_TIME_INIT) if time_init_thread is not None: hubQ.send_message(self.__class__.__name__, _("Restoring hardware time...")) threadMgr.wait(constants.THREAD_TIME_INIT) hubQ.send_ready(self.__class__.__name__, False)
def _initialize(self): hubQ.send_message(self.__class__.__name__, _("Probing storage...")) threadMgr.wait(constants.THREAD_STORAGE) threadMgr.wait(constants.THREAD_CUSTOM_STORAGE_INIT) self.disks = getDisks(self.storage.devicetree) # if there's only one disk, select it by default if len(self.disks) == 1 and not self.selected_disks: applyDiskSelection(self.storage, self.data, [self.disks[0].name]) self._ready = True hubQ.send_ready(self.__class__.__name__, False)
def _initialize(self): hubQ.send_message(self.__class__.__name__, _(constants.PAYLOAD_STATUS_PROBING_STORAGE)) threadMgr.wait(constants.THREAD_STORAGE) threadMgr.wait(constants.THREAD_CUSTOM_STORAGE_INIT) self.disks = getDisks(self.storage.devicetree) # if there's only one disk, select it by default if len(self.disks) == 1 and not self.selected_disks: applyDiskSelection(self.storage, self.data, [self.disks[0].name]) self._ready = True hubQ.send_ready(self.__class__.__name__, False)
def checkSoftwareSelection(self): hubQ.send_message(self.__class__.__name__, _("Checking software dependencies...")) try: self.payload.check_software_selection() except DependencyError as e: self._error_msgs = str(e) hubQ.send_message(self.__class__.__name__, _("Error checking software dependencies")) self._tx_id = None else: self._error_msgs = None self._tx_id = self.payload.tx_id finally: hubQ.send_ready(self.__class__.__name__, False) hubQ.send_ready("SourceSpoke", False)
def checkSoftwareSelection(self): hubQ.send_message(self.__class__.__name__, _("Checking software dependencies...")) try: self.payload.check_software_selection() except DependencyError as e: self._error_msgs = str(e) hubQ.send_message(self.__class__.__name__, _("Error checking software dependencies")) self._tx_id = None else: self._error_msgs = None self._tx_id = self.payload.tx_id finally: hubQ.send_ready(self.__class__.__name__) hubQ.send_ready("SourceSpoke")
def initialize(self): NormalSpoke.initialize(self) self.initialize_start() # place holders for the text boxes self.pw = self.builder.get_object("pw") self.confirm = self.builder.get_object("confirmPW") # Install the password checks: # - Has a password been specified? # - If a password has been specified and there is data in the confirm box, do they match? # - How strong is the password? # - Does the password contain non-ASCII characters? # - Is there any data in the confirm box? self._confirm_check = self.add_check(self.confirm, self.check_password_confirm) # Keep a reference for these checks, since they have to be manually run for the # click Done twice check. self._pwEmptyCheck = self.add_check(self.pw, self.check_password_empty) self._pwStrengthCheck = self.add_check(self.pw, self.check_user_password_strength) self._pwASCIICheck = self.add_check(self.pw, self.check_password_ASCII) self._kickstarted = self.data.rootpw.seen if self._kickstarted: self.pw.set_placeholder_text(_("The password is set.")) self.confirm.set_placeholder_text(_("The password is set.")) self.pw_bar = self.builder.get_object("password_bar") self.pw_label = self.builder.get_object("password_label") # Configure levels for the password bar self.pw_bar.add_offset_value("low", 2) self.pw_bar.add_offset_value("medium", 3) self.pw_bar.add_offset_value("high", 4) self.pw_bar.add_offset_value("full", 4) # Configure the password policy, if available. Otherwise use defaults. self.policy = self.data.anaconda.pwpolicy.get_policy("root") if not self.policy: self.policy = self.data.anaconda.PwPolicyData() # set the visibility of the password entries set_password_visibility(self.pw, False) set_password_visibility(self.confirm, False) # Send ready signal to main event loop hubQ.send_ready(self.__class__.__name__, False) # report that we are done self.initialize_done()
def checkStorage(self): from pyanaconda.storage_utils import storage_checker threadMgr.wait(constants.THREAD_EXECUTE_STORAGE) hubQ.send_not_ready(self._mainSpokeClass) hubQ.send_message(self._mainSpokeClass, _("Checking storage configuration...")) report = storage_checker.check(self.storage) self.errors = report.errors self.warnings = report.warnings hubQ.send_ready(self._mainSpokeClass, True) report.log(self.log)
def checkSoftwareSelection(self): from pyanaconda.packaging import DependencyError hubQ.send_message(self.__class__.__name__, _("Checking software dependencies...")) try: self.payload.checkSoftwareSelection() except DependencyError as e: self._errorMsgs = "\n".join(sorted(e.message)) hubQ.send_message(self.__class__.__name__, _("Error checking software dependencies")) self._tx_id = None else: self._errorMsgs = None self._tx_id = self.payload.txID finally: hubQ.send_ready(self.__class__.__name__, False) hubQ.send_ready("SourceSpoke", False)
def _initialize(self): # a bit hacky way, but should return the translated strings for i in range(1, 32): day = datetime.date(2000, 1, i).strftime(self._day_format) self.add_to_store_idx(self._daysStore, i, day) for i in range(1, 13): month = datetime.date(2000, i, 1).strftime(self._month_format) self.add_to_store_idx(self._monthsStore, i, month) for i in range(1990, 2051): year = datetime.date(i, 1, 1).strftime(self._year_format) self.add_to_store_idx(self._yearsStore, i, year) cities = set() xlated_regions = ((region, get_xlated_timezone(region)) for region in self._regions_zones.keys()) for region, xlated in sorted( xlated_regions, key=functools.cmp_to_key(_compare_regions)): self.add_to_store_xlated(self._regionsStore, region, xlated) for city in self._regions_zones[region]: cities.add((city, get_xlated_timezone(city))) for city, xlated in sorted(cities, key=functools.cmp_to_key(_compare_cities)): self.add_to_store_xlated(self._citiesStore, city, xlated) self._update_datetime_timer = None kickstart_timezone = self._timezone_module.proxy.Timezone if is_valid_timezone(kickstart_timezone): self._set_timezone(kickstart_timezone) elif not flags.flags.automatedInstall: log.warning( "%s is not a valid timezone, falling back to default (%s)", kickstart_timezone, DEFAULT_TZ) self._set_timezone(DEFAULT_TZ) self._timezone_module.proxy.SetTimezone(DEFAULT_TZ) time_init_thread = threadMgr.get(constants.THREAD_TIME_INIT) if time_init_thread is not None: hubQ.send_message(self.__class__.__name__, _("Restoring hardware time...")) threadMgr.wait(constants.THREAD_TIME_INIT) hubQ.send_ready(self.__class__.__name__, False) # report that we are done self.initialize_done()
def checkStorage(self): from pyanaconda.storage_utils import storage_checker threadMgr.wait(constants.THREAD_EXECUTE_STORAGE) hubQ.send_not_ready(self._mainSpokeClass) hubQ.send_message(self._mainSpokeClass, _("Checking storage configuration...")) report = storage_checker.check(self.storage) # Storage spoke and custom spoke communicate errors via StorageCheckHandler, # so we need to set errors and warnings class attributes here. StorageCheckHandler.errors = report.errors StorageCheckHandler.warnings = report.warnings hubQ.send_ready(self._mainSpokeClass, True) report.log(self.log)
def checkStorage(self): from pyanaconda.storage_utils import sanity_check, SanityError, SanityWarning threadMgr.wait(constants.THREAD_EXECUTE_STORAGE) hubQ.send_not_ready(self._mainSpokeClass) hubQ.send_message(self._mainSpokeClass, _("Checking storage configuration...")) exns = sanity_check(self.storage, min_ram=self._min_ram) errors = [str(exn) for exn in exns if isinstance(exn, SanityError)] warnings = [str(exn) for exn in exns if isinstance(exn, SanityWarning)] (StorageChecker.errors, StorageChecker.warnings) = (errors, warnings) hubQ.send_ready(self._mainSpokeClass, True) for e in StorageChecker.errors: self.log.error(e) for w in StorageChecker.warnings: self.log.warning(w)
def _initialize(self): threadMgr.wait(constants.THREAD_PAYLOAD) if not self._kickstarted: # having done all the slow downloading, we need to do the first refresh # of the UI here so there's an environment selected by default. This # happens inside the main thread by necessity. We can't do anything # that takes any real amount of time, or it'll block the UI from # updating. if not self._first_refresh(): return hubQ.send_ready(self.__class__.__name__, False) # If packages were provided by an input kickstart file (or some other means), # we should do dependency solving here. if not self._error: self._apply()
def _initialize(self): # wait for subscription thread to finish (if any) threadMgr.wait(THREAD_SUBSCRIPTION) # also wait for the payload thread, which migh still be processing # a CDROM source, to avoid the Subscription being mandatory by mistake # due to CDN still being default at the time of evaulation threadMgr.wait(THREAD_PAYLOAD) # update overall state self._update_registration_state() self._update_subscription_state() # Send ready signal to main event loop hubQ.send_ready(self.__class__.__name__) # report that we are done self.initialize_done()
def checkStorage(self): from blivet.errors import SanityError from blivet.errors import SanityWarning threadMgr.wait(constants.THREAD_EXECUTE_STORAGE) hubQ.send_not_ready(self._mainSpokeClass) hubQ.send_message(self._mainSpokeClass, _("Checking storage configuration...")) exns = self.storage.sanityCheck() errors = [exn.message for exn in exns if isinstance(exn, SanityError)] warnings = [exn.message for exn in exns if isinstance(exn, SanityWarning)] (StorageChecker.errors, StorageChecker.warnings) = (errors, warnings) hubQ.send_ready(self._mainSpokeClass, True) for e in StorageChecker.errors: self.log.error(e) for w in StorageChecker.warnings: self.log.warning(w)
def _initialize(self): # a bit hacky way, but should return the translated strings for i in range(1, 32): day = datetime.date(2000, 1, i).strftime(self._day_format) self.add_to_store_idx(self._daysStore, i, day) for i in range(1, 13): month = datetime.date(2000, i, 1).strftime(self._month_format) self.add_to_store_idx(self._monthsStore, i, month) for i in range(1990, 2051): year = datetime.date(i, 1, 1).strftime(self._year_format) self.add_to_store_idx(self._yearsStore, i, year) cities = set() xlated_regions = ((region, get_xlated_timezone(region)) for region in self._regions_zones.keys()) for region, xlated in sorted(xlated_regions, key=functools.cmp_to_key(_compare_regions)): self.add_to_store_xlated(self._regionsStore, region, xlated) for city in self._regions_zones[region]: cities.add((city, get_xlated_timezone(city))) for city, xlated in sorted(cities, key=functools.cmp_to_key(_compare_cities)): self.add_to_store_xlated(self._citiesStore, city, xlated) self._update_datetime_timer = None kickstart_timezone = self._timezone_module.proxy.Timezone if is_valid_timezone(kickstart_timezone): self._set_timezone(kickstart_timezone) elif not flags.flags.automatedInstall: log.warning("%s is not a valid timezone, falling back to default (%s)", kickstart_timezone, DEFAULT_TZ) self._set_timezone(DEFAULT_TZ) self._timezone_module.proxy.SetTimezone(DEFAULT_TZ) time_init_thread = threadMgr.get(constants.THREAD_TIME_INIT) if time_init_thread is not None: hubQ.send_message(self.__class__.__name__, _("Restoring hardware time...")) threadMgr.wait(constants.THREAD_TIME_INIT) hubQ.send_ready(self.__class__.__name__, False) # report that we are done self.initialize_done()
def _initialize(self): hubQ.send_message(self.__class__.__name__, _("Downloading package metadata...")) threadMgr.wait(constants.THREAD_PAYLOAD) hubQ.send_message(self.__class__.__name__, _("Downloading group metadata...")) # we have no way to select environments with kickstart right now # so don't try. if flags.automatedInstall and self.data.packages.seen: # We don't want to do a full refresh, just join the metadata thread threadMgr.wait(constants.THREAD_PAYLOAD_MD) else: # Grabbing the list of groups could potentially take a long time # at first (yum does a lot of magic property stuff, some of which # involves side effects like network access. We need to reference # them here, outside of the main thread, to not block the UI. try: # pylint: disable-msg=W0104 self.payload.environments # pylint: disable-msg=W0104 self.payload.groups # Parse the environments and groups into the form we want self._parseEnvironments() except MetadataError: hubQ.send_message(self.__class__.__name__, _("No installation source available")) return # And then having done all that slow downloading, we need to do the first # refresh of the UI here so there's an environment selected by default. # This happens inside the main thread by necessity. We can't do anything # that takes any real amount of time, or it'll block the UI from updating. if not self._first_refresh(): return self.payload.release() hubQ.send_ready(self.__class__.__name__, False) # If packages were provided by an input kickstart file (or some other means), # we should do dependency solving here. self._apply()
def ready(self): """ The ready property that tells whether the spoke is ready (can be visited) or not. The spoke is made (in)sensitive based on the returned value. :rtype: bool """ self.derivedValues() # Check if the hostname starts with "localhost" # if if self.privateHostname.startswith("localhost"): self.readyState=BADHOSTNAME return False # if the readyState was BADHOSTNAME return to CONFIGURE state if self.readyState == BADHOSTNAME: self.readyState = CONFIGURE hubQ.send_ready(self.__class__.__name__, True) self.log.info("rocks_private.py:ready") return True
def _doExecute(self): self._ready = False hubQ.send_not_ready(self.__class__.__name__) # on the off-chance dasdfmt is running, we can't proceed further threadMgr.wait(constants.THREAD_DASDFMT) hubQ.send_message(self.__class__.__name__, _("Saving storage configuration...")) if flags.automatedInstall and self.data.autopart.encrypted and not self.data.autopart.passphrase: self.autopart_missing_passphrase = True StorageChecker.errors = [_("Passphrase for autopart encryption not specified.")] self._ready = True hubQ.send_ready(self.__class__.__name__, True) return try: doKickstartStorage(self.storage, self.data, self.instclass) except (StorageError, KickstartParseError) as e: log.error("storage configuration failed: %s", e) StorageChecker.errors = str(e).split("\n") hubQ.send_message(self.__class__.__name__, _("Failed to save storage configuration...")) self.data.bootloader.bootDrive = "" self.data.ignoredisk.drives = [] self.data.ignoredisk.onlyuse = [] self.storage.config.update(self.data) self.storage.reset() self.disks = getDisks(self.storage.devicetree) # now set ksdata back to the user's specified config applyDiskSelection(self.storage, self.data, self.selected_disks) except BootLoaderError as e: log.error("BootLoader setup failed: %s", e) StorageChecker.errors = str(e).split("\n") hubQ.send_message(self.__class__.__name__, _("Failed to save storage configuration...")) self.data.bootloader.bootDrive = "" else: if self.autopart or (flags.automatedInstall and (self.data.autopart.autopart or self.data.partition.seen)): # run() executes StorageChecker.checkStorage in a seperate threat self.run() finally: resetCustomStorageData(self.data) self._ready = True hubQ.send_ready(self.__class__.__name__, True)
def apply(self): pw = self.pw.get_text() # value from the kickstart changed self.data.rootpw.seen = False self._kickstarted = False self.data.rootpw.lock = False if not pw: self.data.rootpw.password = '' self.data.rootpw.isCrypted = False return self.data.rootpw.password = cryptPassword(pw) self.data.rootpw.isCrypted = True self.pw.set_placeholder_text("") self.confirm.set_placeholder_text("") # Send ready signal to main event loop hubQ.send_ready(self.__class__.__name__, False)
def apply(self): pw = self.password # value from the kickstart changed # NOTE: yet again, this stops to be valid once multiple # commands are supported by a single DBUS module self._users_module.proxy.SetRootpwKickstarted(False) self.password_kickstarted = False self._users_module.proxy.SetRootAccountLocked(False) if not pw: self._users_module.proxy.ClearRootPassword() return # we have a password - set it to kickstart data self._users_module.proxy.SetCryptedRootPassword(cryptPassword(pw)) # clear any placeholders self.remove_placeholder_texts() # Send ready signal to main event loop hubQ.send_ready(self.__class__.__name__, False)
def getRepoMetadata(self): hubQ.send_not_ready("SoftwareSelectionSpoke") hubQ.send_not_ready(self.__class__.__name__) hubQ.send_message(self.__class__.__name__, _(BASEREPO_SETUP_MESSAGE)) # this sleep is lame, but without it the message above doesn't seem # to get processed by the hub in time, and is never shown. # FIXME this should get removed when we figure out how to ensure # that the message takes effect on the hub before we try to mount # a bad NFS server. time.sleep(1) try: self.payload.updateBaseRepo(fallback=False, checkmount=False) except (OSError, PayloadError) as e: log.error("PayloadError: %s", e) self._error = True hubQ.send_message(self.__class__.__name__, _("Failed to set up installation source")) if not (hasattr(self.data.method, "proxy") and self.data.method.proxy): gtk_call_once(self.set_warning, _("Failed to set up installation source; check the repo url")) else: gtk_call_once(self.set_warning, _("Failed to set up installation source; check the repo url and proxy settings")) else: self._error = False hubQ.send_message(self.__class__.__name__, _(METADATA_DOWNLOAD_MESSAGE)) self.payload.gatherRepoMetadata() self.payload.release() if not self.payload.baseRepo: hubQ.send_message(self.__class__.__name__, _(METADATA_ERROR_MESSAGE)) hubQ.send_ready(self.__class__.__name__, False) self._error = True gtk_call_once(self.set_warning, _("Failed to set up installation source; check the repo url")) else: try: # Grabbing the list of groups could potentially take a long time the # first time (yum does a lot of magic property stuff, some of which # involves side effects like network access) so go ahead and grab # them now. These are properties with side-effects, just accessing # them will trigger yum. # pylint: disable-msg=W0104 self.payload.environments # pylint: disable-msg=W0104 self.payload.groups except MetadataError: hubQ.send_message("SoftwareSelectionSpoke", _("No installation source available")) else: hubQ.send_ready("SoftwareSelectionSpoke", False) finally: hubQ.send_ready(self.__class__.__name__, False)
def initialize(self): NormalSpoke.initialize(self) self.initialize_start() # get object references from the builders self._password_entry = self.builder.get_object("password_entry") self._password_confirmation_entry = self.builder.get_object("password_confirmation_entry") self._password_bar = self.builder.get_object("password_bar") self._password_label = self.builder.get_object("password_label") # set state based on kickstart # NOTE: this will stop working once the module supports multiple kickstart commands self.password_kickstarted = self._users_module.proxy.IsRootpwKickstarted # Install the password checks: # - Has a password been specified? # - If a password has been specified and there is data in the confirm box, do they match? # - How strong is the password? # - Does the password contain non-ASCII characters? # Setup the password checker for password checking self._checker = input_checking.PasswordChecker( initial_password_content = self.password, initial_password_confirmation_content = self.password_confirmation, policy = input_checking.get_policy(self.data, "root") ) # configure the checker for password checking self.checker.secret_type = constants.SecretType.PASSWORD # remove any placeholder texts if either password or confirmation field changes content from initial state self.checker.password.changed_from_initial_state.connect(self.remove_placeholder_texts) self.checker.password_confirmation.changed_from_initial_state.connect(self.remove_placeholder_texts) # connect UI updates to check results self.checker.checks_done.connect(self._checks_done) # check that the password is not empty self._empty_check = input_checking.PasswordEmptyCheck() # check that the content of the password field & the conformation field are the same self._confirm_check = input_checking.PasswordConfirmationCheck() # regards both fields empty as success to let the user escape self._confirm_check.success_if_confirmation_empty = True # check password validity, quality and strength self._validity_check = input_checking.PasswordValidityCheck() # connect UI updates to validity check results self._validity_check.result.password_score_changed.connect(self.set_password_score) self._validity_check.result.status_text_changed.connect(self.set_password_status) # check if the password contains non-ascii characters self._ascii_check = input_checking.PasswordASCIICheck() # register the individual checks with the checker in proper order # 1) is the password non-empty ? # 2) are both entered passwords the same ? # 3) is the password valid according to the current password checking policy ? # 4) is the password free of non-ASCII characters ? self.checker.add_check(self._empty_check) self.checker.add_check(self._confirm_check) self.checker.add_check(self._validity_check) self.checker.add_check(self._ascii_check) # set placeholders if the password has been kickstarted as we likely don't know # nothing about it and can't really show it in the UI in any meaningful way password_set_message = _("The password was set by kickstart.") if self.password_kickstarted: self.password_entry.set_placeholder_text(password_set_message) self.password_confirmation_entry.set_placeholder_text(password_set_message) # Configure levels for the password bar self._password_bar.add_offset_value("low", 2) self._password_bar.add_offset_value("medium", 3) self._password_bar.add_offset_value("high", 4) # Send ready signal to main event loop hubQ.send_ready(self.__class__.__name__, False) # report that we are done self.initialize_done()
def initialize(self): """ The initialize method that is called after the instance is created. The difference between __init__ and this method is that this may take a long time and thus could be called in a separated thread. :see: pyanaconda.ui.common.UIObject.initialize """ NormalSpoke.initialize(self) column = self.builder.get_object("messageTypeColumn") renderer = self.builder.get_object("messageTypeRenderer") column.set_cell_data_func(renderer, render_message_type) # the main notebook containing two pages -- for settings parameters and # for entering content URL self._main_notebook = self.builder.get_object("mainNotebook") # the store that holds the messages that come from the rules evaluation self._message_store = self.builder.get_object("changesStore") # stores with data streams, checklists and profiles self._ds_store = self.builder.get_object("dsStore") self._xccdf_store = self.builder.get_object("xccdfStore") self._profiles_store = self.builder.get_object("profilesStore") # comboboxes for data streams and checklists self._ids_box = self.builder.get_object("idsBox") self._ds_combo = self.builder.get_object("dsCombo") self._xccdf_combo = self.builder.get_object("xccdfCombo") # profiles view and selection self._profiles_view = self.builder.get_object("profilesView") self._profiles_selection = self.builder.get_object("profilesSelection") selected_column = self.builder.get_object("selectedColumn") selected_renderer = self.builder.get_object("selectedRenderer") selected_column.set_cell_data_func(selected_renderer, self._render_selected) # button for switching profiles self._choose_button = self.builder.get_object("chooseProfileButton") # toggle switching the dry-run mode self._dry_run_switch = self.builder.get_object("dryRunSwitch") # control buttons self._control_buttons = self.builder.get_object("controlButtons") # content URL entering, content fetching, ... self._no_content_label = self.builder.get_object("noContentLabel") self._content_url_entry = self.builder.get_object("urlEntry") self._fetch_button = self.builder.get_object("fetchButton") self._progress_box = self.builder.get_object("progressBox") self._progress_spinner = self.builder.get_object("progressSpinner") self._progress_label = self.builder.get_object("progressLabel") self._ssg_button = self.builder.get_object("ssgButton") # if no content was specified and SSG is available, use it if not self._addon_data.content_type and common.ssg_available(): self._addon_data.content_type = "scap-security-guide" self._addon_data.content_path = common.SSG_DIR + common.SSG_CONTENT if not self._addon_data.content_defined: # nothing more to be done now, the spoke is ready self._ready = True # no more being unitialized self._unitialized_status = None # user is going to enter the content URL self._content_url_entry.grab_focus() # pylint: disable-msg=E1101 hubQ.send_ready(self.__class__.__name__, True) else: # else fetch data self._fetch_data_and_initialize()
def _wait_ready(self): self._add_dialog.wait_initialize() self._ready = True hubQ.send_ready(self.__class__.__name__, False)