def _apply(self): if not self.environment: return # NOTE: This block is skipped for kickstart where addons and _origAddons will # both be [], preventing it from wiping out the kickstart's package selection addons = self._get_selected_addons() if set(addons) != set(self._origAddons): for group in addons: if group not in self.selectedGroups: self.selectedGroups.append(group) self._selectFlag = False self.payload.data.packages.packageList = [] self.payload.data.packages.groupList = [] self.payload.selectEnvironment(self.environment) for group in self.selectedGroups: self.payload.selectGroup(group) # And then save these values so we can check next time. self._origAddons = addons self._origEnvironment = self.environment hubQ.send_not_ready(self.__class__.__name__) hubQ.send_not_ready("SourceSpoke") threadMgr.add( AnacondaThread(name=constants.THREAD_CHECK_SOFTWARE, target=self.checkSoftwareSelection))
def _apply(self): env = self._get_selected_environment() # Check if a kickstart install still looks like a kickstart install # If an environment is selected and either the environment or the # addon list does not match the ksdata, the packages were # selected interactively. if env and self._kickstarted: if env != self.data.packages.environment or \ set(self.selectedGroups) != set(self.data.packages.groupList): self._kickstarted = False # Not a kickstart with packages, setup the environment and groups if env and not self._kickstarted: addons = self._get_selected_addons() for group in addons: if group not in self.selectedGroups: self.selectedGroups.append(group) self._selectFlag = False self.payload.data.packages.packageList = [] self.payload.data.packages.groupList = [] self.payload.selectEnvironment(env) self.environment = env for group in self.selectedGroups: self.payload.selectGroup(group) # And then save these values so we can check next time. self._origAddons = addons self._origEnvironment = self.environment hubQ.send_not_ready(self.__class__.__name__) hubQ.send_not_ready("SourceSpoke") threadMgr.add(AnacondaThread(name=constants.THREAD_CHECK_SOFTWARE, target=self.checkSoftwareSelection))
def _apply(self): # Environment needs to be set during a GUI installation, but is not required # for a kickstart install (even partial) if not self.environment: log.debug("Environment is not set, skip user packages settings") return # NOTE: This block is skipped for kickstart where addons and _origAddons will # both be [], preventing it from wiping out the kickstart's package selection addons = self._get_selected_addons() if not self._kickstarted and set(addons) != set(self._origAddons): self._selectFlag = False self.payload.data.packages.packageList = [] self.payload.data.packages.groupList = [] self.payload.selectEnvironment(self.environment) log.debug("Environment selected for installation: %s", self.environment) log.debug("Groups selected for installation: %s", addons) for group in addons: self.payload.selectGroup(group) # And then save these values so we can check next time. self._origAddons = addons self._origEnvironment = self.environment hubQ.send_not_ready(self.__class__.__name__) hubQ.send_not_ready("SourceSpoke") threadMgr.add(AnacondaThread(name=constants.THREAD_CHECK_SOFTWARE, target=self.checkSoftwareSelection))
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 _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 _fetch_data_and_initialize(self): """Fetch data from a specified URL and initialize everything.""" with self._fetch_flag_lock: if self._fetching: # prevent multiple fetches running simultaneously return self._fetching = True thread_name = None if any(self._addon_data.content_url.startswith(net_prefix) for net_prefix in data_fetch.NET_URL_PREFIXES): # need to fetch data over network thread_name = common.wait_and_fetch_net_data( self._addon_data.content_url, self._addon_data.raw_preinst_content_path, self._addon_data.certificates) # pylint: disable-msg=E1101 hubQ.send_message(self.__class__.__name__, _("Fetching content data")) # pylint: disable-msg=E1101 hubQ.send_not_ready(self.__class__.__name__) threadMgr.add(AnacondaThread(name="OSCAPguiWaitForDataFetchThread", target=self._init_after_data_fetch, args=(thread_name,)))
def _apply(self): env = self._get_selected_environment() if not env: return addons = self._get_selected_addons() for group in addons: if group not in self.selectedGroups: self.selectedGroups.append(group) self._selectFlag = False self.payload.data.packages.groupList = [] self.payload.selectEnvironment(env) self.environment = env for group in self.selectedGroups: self.payload.selectGroup(group) # And then save these values so we can check next time. self._origAddons = addons self._origEnvironment = self.environment hubQ.send_not_ready(self.__class__.__name__) hubQ.send_not_ready("SourceSpoke") threadMgr.add(AnacondaThread(name=constants.THREAD_CHECK_SOFTWARE, target=self.checkSoftwareSelection))
def _apply(self): if not self.environment: return # NOTE: This block is skipped for kickstart where addons and _origAddons will # both be [], preventing it from wiping out the kickstart's package selection addons = self._get_selected_addons() if set(addons) != set(self._origAddons): for group in addons: if group not in self.selectedGroups: self.selectedGroups.append(group) self._selectFlag = False self.payload.data.packages.packageList = [] self.payload.data.packages.groupList = [] self.payload.selectEnvironment(self.environment) for group in self.selectedGroups: self.payload.selectGroup(group) # And then save these values so we can check next time. self._origAddons = addons self._origEnvironment = self.environment hubQ.send_not_ready(self.__class__.__name__) hubQ.send_not_ready("SourceSpoke") threadMgr.add(AnacondaThread(name=constants.THREAD_CHECK_SOFTWARE, target=self.checkSoftwareSelection))
def _apply(self): # Environment needs to be set during a GUI installation, but is not required # for a kickstart install (even partial) if not self.environment: log.debug("Environment is not set, skip user packages settings") return # NOTE: This block is skipped for kickstart where addons and _origAddons will # both be [], preventing it from wiping out the kickstart's package selection addons = self._get_selected_addons() if not self._kickstarted and set(addons) != set(self._origAddons): self._selectFlag = False self.payload.data.packages.packageList = [] self.payload.data.packages.groupList = [] self.payload.selectEnvironment(self.environment) log.debug("Environment selected for installation: %s", self.environment) log.debug("Groups selected for installation: %s", addons) for group in addons: self.payload.selectGroup(group) # And then save these values so we can check next time. self._origAddons = addons self._origEnvironment = self.environment hubQ.send_not_ready(self.__class__.__name__) hubQ.send_not_ready("SourceSpoke") threadMgr.add( AnacondaThread(name=constants.THREAD_CHECK_SOFTWARE, target=self.checkSoftwareSelection))
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. e = self.payload.environments g = 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): super().initialize() self.initialize_start() # set X keyboard defaults # - this needs to be done early in spoke initialization so that # the spoke status does not show outdated keyboard selection keyboard.set_x_keyboard_defaults(self._l12_module, self._xkl_wrapper) # make sure the x_layouts list has at least one keyboard layout if not self._l12_module.XLayouts: self._l12_module.SetXLayouts([DEFAULT_KEYBOARD]) self._add_dialog = AddLayoutDialog(self.data) self._add_dialog.initialize() if conf.system.can_configure_keyboard: self.builder.get_object("warningBox").hide() # We want to store layouts' names but show layouts as # 'language (description)'. layoutColumn = self.builder.get_object("layoutColumn") layoutRenderer = self.builder.get_object("layoutRenderer") override_cell_property(layoutColumn, layoutRenderer, "text", _show_layout, self._xkl_wrapper) self._store = self.builder.get_object("addedLayoutStore") self._add_data_layouts() self._selection = self.builder.get_object("layoutSelection") self._switching_dialog = ConfigureSwitchingDialog(self.data, self._l12_module) self._switching_dialog.initialize() self._layoutSwitchLabel = self.builder.get_object("layoutSwitchLabel") if not conf.system.can_configure_keyboard: # Disable area for testing layouts as we cannot make # it work without modifying runtime system widgets = [self.builder.get_object("testingLabel"), self.builder.get_object("testingWindow"), self.builder.get_object("layoutSwitchLabel")] # Use testingLabel's text to explain why this part is not # sensitive. widgets[0].set_text(_("Testing layouts configuration not " "available.")) for widget in widgets: widget.set_sensitive(False) hubQ.send_not_ready(self.__class__.__name__) hubQ.send_message(self.__class__.__name__, _("Getting list of layouts...")) threadMgr.add(AnacondaThread(name=THREAD_KEYBOARD_INIT, target=self._wait_ready))
def initialize(self): NormalSpoke.initialize(self) self.initialize_start() # set X keyboard defaults # - this needs to be done early in spoke initialization so that # the spoke status does not show outdated keyboard selection keyboard.set_x_keyboard_defaults(self.data, self._xkl_wrapper) # make sure the x_layouts list has at least one keyboard layout if not self.data.keyboard.x_layouts: self.data.keyboard.x_layouts.append(DEFAULT_KEYBOARD) self._add_dialog = AddLayoutDialog(self.data) self._add_dialog.initialize() if flags.can_touch_runtime_system("hide runtime keyboard configuration " "warning", touch_live=True): self.builder.get_object("warningBox").hide() # We want to store layouts' names but show layouts as # 'language (description)'. layoutColumn = self.builder.get_object("layoutColumn") layoutRenderer = self.builder.get_object("layoutRenderer") override_cell_property(layoutColumn, layoutRenderer, "text", _show_layout, self._xkl_wrapper) self._store = self.builder.get_object("addedLayoutStore") self._add_data_layouts() self._selection = self.builder.get_object("layoutSelection") self._switching_dialog = ConfigureSwitchingDialog(self.data) self._switching_dialog.initialize() self._layoutSwitchLabel = self.builder.get_object("layoutSwitchLabel") if not flags.can_touch_runtime_system("test X layouts", touch_live=True): # Disable area for testing layouts as we cannot make # it work without modifying runtime system widgets = [self.builder.get_object("testingLabel"), self.builder.get_object("testingWindow"), self.builder.get_object("layoutSwitchLabel")] # Use testingLabel's text to explain why this part is not # sensitive. widgets[0].set_text(_("Testing layouts configuration not " "available.")) for widget in widgets: widget.set_sensitive(False) hubQ.send_not_ready(self.__class__.__name__) hubQ.send_message(self.__class__.__name__, _("Getting list of layouts...")) threadMgr.add(AnacondaThread(name=THREAD_KEYBOARD_INIT, target=self._wait_ready))
def apply(self): """Apply the changes.""" self._kickstarted = False selection = self._selection_cache.get_selection_data() log.debug("Setting new software selection: %s", selection) self.payload.set_packages_selection(selection) hubQ.send_not_ready(self.__class__.__name__) hubQ.send_not_ready("SourceSpoke")
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): NormalSpoke.initialize(self) self._add_dialog = AddLayoutDialog(self.data) self._add_dialog.initialize() if flags.can_touch_runtime_system( "hide runtime keyboard configuration " "warning", touch_live=True): self.builder.get_object("warningBox").hide() # We want to store layouts' names but show layouts as # 'language (description)'. layoutColumn = self.builder.get_object("layoutColumn") layoutRenderer = self.builder.get_object("layoutRenderer") override_cell_property(layoutColumn, layoutRenderer, "text", _show_layout, self._xkl_wrapper) self._store = self.builder.get_object("addedLayoutStore") self._add_data_layouts() self._selection = self.builder.get_object("layoutSelection") self._switching_dialog = ConfigureSwitchingDialog(self.data) self._switching_dialog.initialize() self._layoutSwitchLabel = self.builder.get_object("layoutSwitchLabel") if not flags.can_touch_runtime_system("test X layouts", touch_live=True): # Disable area for testing layouts as we cannot make # it work without modifying runtime system widgets = [ self.builder.get_object("testingLabel"), self.builder.get_object("testingWindow"), self.builder.get_object("layoutSwitchLabel") ] # Use testingLabel's text to explain why this part is not # sensitive. widgets[0].set_text( _("Testing layouts configuration not " "available.")) for widget in widgets: widget.set_sensitive(False) hubQ.send_not_ready(self.__class__.__name__) hubQ.send_message(self.__class__.__name__, _("Getting list of layouts...")) threadMgr.add( AnacondaThread(name=THREAD_KEYBOARD_INIT, target=self._wait_ready))
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 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 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): NormalSpoke.initialize(self) self._add_dialog = AddLayoutDialog(self.data) self._add_dialog.initialize() if flags.can_touch_runtime_system("hide runtime keyboard configuration " "warning", touch_live=True): self.builder.get_object("warningBox").hide() # We want to store layouts' names but show layouts as # 'language (description)'. layoutColumn = self.builder.get_object("layoutColumn") layoutRenderer = self.builder.get_object("layoutRenderer") layoutColumn.set_cell_data_func(layoutRenderer, _show_layout, self._xkl_wrapper) self._store = self.builder.get_object("addedLayoutStore") self._add_data_layouts() self._selection = self.builder.get_object("layoutSelection") self._switching_dialog = ConfigureSwitchingDialog(self.data) self._switching_dialog.initialize() self._layoutSwitchLabel = self.builder.get_object("layoutSwitchLabel") if not flags.can_touch_runtime_system("test X layouts", touch_live=True): # Disable area for testing layouts as we cannot make # it work without modifying runtime system widgets = [self.builder.get_object("testingLabel"), self.builder.get_object("testingWindow"), self.builder.get_object("layoutSwitchLabel")] # Use testingLabel's text to explain why this part is not # sensitive. widgets[0].set_text(_("Testing layouts configuration not " "available.")) for widget in widgets: widget.set_sensitive(False) hubQ.send_not_ready(self.__class__.__name__) hubQ.send_message(self.__class__.__name__, _("Getting list of layouts...")) threadMgr.add(AnacondaThread(name=THREAD_KEYBOARD_INIT, target=self._wait_ready))
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 _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 checkStorage(self): 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: log.error(e) for w in StorageChecker.warnings: log.warning(w)
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 _fetch_data_and_initialize(self): """Fetch data from a specified URL and initialize everything.""" with self._fetch_flag_lock: if self._fetching: # prevent multiple fetches running simultaneously return self._fetching = True thread_name = None if self._policy_data.content_url and self._policy_data.content_type != "scap-security-guide": log.info(f"OSCAP Addon: Actually fetching content from somewhere") thread_name = self.content_bringer.fetch_content( self._handle_error, self._policy_data.certificates) # pylint: disable-msg=E1101 hubQ.send_message(self.__class__.__name__, _("Fetching content data")) # pylint: disable-msg=E1101 hubQ.send_not_ready(self.__class__.__name__) threadMgr.add(AnacondaThread(name="OSCAPguiWaitForDataFetchThread", target=self._init_after_data_fetch, args=(thread_name,)))
def apply(self): """Apply the changes.""" self._kickstarted = False # Clear packages data. self._selection.packages = [] self._selection.excluded_packages = [] # Clear groups data. self._selection.excluded_groups = [] self._selection.groups_package_types = {} # Select new groups. self._selection.groups = [] for group_name in self._get_selected_addons(): self._selection.groups.append(group_name) log.debug("Setting new software selection: %s", self._selection) self.payload.set_packages_data(self._selection) hubQ.send_not_ready(self.__class__.__name__) hubQ.send_not_ready("SourceSpoke")
def _apply(self): env = self._get_selected_environment() # Check if a kickstart install still looks like a kickstart install # If an environment is selected and either the environment or the # addon list does not match the ksdata, the packages were # selected interactively. if env and self._kickstarted: if env != self.data.packages.environment or \ set(self.selectedGroups) != set(self.data.packages.groupList): self._kickstarted = False # Not a kickstart with packages, setup the environment and groups if env and not self._kickstarted: addons = self._get_selected_addons() for group in addons: if group not in self.selectedGroups: self.selectedGroups.append(group) self._selectFlag = False self.payload.data.packages.packageList = [] self.payload.data.packages.groupList = [] self.payload.selectEnvironment(env) self.environment = env for group in self.selectedGroups: self.payload.selectGroup(group) # And then save these values so we can check next time. self._origAddons = addons self._origEnvironment = self.environment hubQ.send_not_ready(self.__class__.__name__) hubQ.send_not_ready("SourceSpoke") threadMgr.add( AnacondaThread(name=constants.THREAD_CHECK_SOFTWARE, target=self.checkSoftwareSelection))