def raw_input(self, prompt, hidden=False): """This method reads one input from user. Its basic form has only one line, but we might need to override it for more complex apps or testing.""" input_thread = AnacondaThread(prefix=constants.THREAD_INPUT_BASENAME, target=self._thread_input, args=(self.queue, prompt, hidden)) input_thread.daemon = True threadMgr.add(input_thread) event = self.process_events(return_at=hubQ.HUB_CODE_INPUT) return event[1][0] # return the user input
def initialize(self): NormalSpoke.initialize(self) self.local_disks_box = self.builder.get_object("local_disks_box") self.specialized_disks_box = self.builder.get_object( "specialized_disks_box") threadMgr.add( AnacondaThread(name=constants.THREAD_STORAGE_WATCHER, target=self._initialize))
def background_XklWrapper_initialize(): """ Create the XklWrapper singleton instance in a separate thread to save time when it's really needed. """ threadMgr.add( AnacondaThread(name=THREAD_XKL_WRAPPER_INIT, target=XklWrapper.get_instance))
def apply(self): """ Apply our selections """ self._apply() # no longer using values from kickstart self._kickstarted = False self.data.packages.seen = True threadMgr.add(AnacondaThread(name=THREAD_CHECK_SOFTWARE, target=self.checkSoftwareSelection))
def on_start_clicked(self, *args): """ Go through the process of validating entry contents and then attempt to add the device. """ # First update widgets self._startButton.hide() self._cancelButton.set_sensitive(False) self._okButton.set_sensitive(False) self._set_configure_sensitive(False) self._conditionNotebook.set_current_page(1) # Initialize. config_error = None device = None wwpn = None lun = None # Get the input. device_name = self._deviceEntry.get_text().strip() wwpn_name = self._wwpnEntry.get_text().strip() lun_name = self._lunEntry.get_text().strip() # Check the input. if not DASD_DEVICE_NUMBER.match(device_name): config_error = "Incorrect format of the given device number." elif not ZFCP_WWPN_NUMBER.match(wwpn_name): config_error = "Incorrect format of the given WWPN number." elif not ZFCP_LUN_NUMBER.match(lun_name): config_error = "Incorrect format of the given LUN number." else: try: # Get the full ids. device = blockdev.s390.sanitize_dev_input(device_name) wwpn = blockdev.s390.zfcp_sanitize_wwpn_input(wwpn_name) lun = blockdev.s390.zfcp_sanitize_lun_input(lun_name) except (blockdev.S390Error, ValueError) as err: config_error = str(err) # Process the configuration error. if config_error: self._errorLabel.set_text(config_error) self._conditionNotebook.set_current_page(2) self._set_configure_sensitive(True) self._cancelButton.set_sensitive(True) # Start the discovery. else: # Discover. self._spinner.start() threadMgr.add(AnacondaThread(name=constants.THREAD_ZFCP_DISCOVER, target=self._discover, args=(device, wwpn, lun))) # Periodically call the check till it is done. GLib.timeout_add(250, self._check_discover)
def install(self): """ Install the payload. """ if self.source_size <= 0: raise PayloadInstallError("Nothing to install") self.pct_lock = Lock() self.pct = 0 threadMgr.add( AnacondaThread(name=THREAD_LIVE_PROGRESS, target=self.progress)) cmd = "rsync" # preserve: permissions, owners, groups, ACL's, xattrs, times, # symlinks, hardlinks # go recursively, include devices and special files, don't cross # file system boundaries args = [ "-pogAXtlHrDx", "--exclude", "/dev/", "--exclude", "/proc/", "--exclude", "/sys/", "--exclude", "/run/", "--exclude", "/boot/*rescue*", "--exclude", "/etc/machine-id", INSTALL_TREE + "/", iutil.getSysroot() ] try: rc = iutil.execWithRedirect(cmd, args) except (OSError, RuntimeError) as e: msg = None err = str(e) log.error(err) else: err = None msg = "%s exited with code %d" % (cmd, rc) log.info(msg) if err or rc == 12: exn = PayloadInstallError(err or msg) if errorHandler.cb(exn) == ERROR_RAISE: raise exn # Wait for progress thread to finish with self.pct_lock: self.pct = 100 threadMgr.wait(THREAD_LIVE_PROGRESS) # Live needs to create the rescue image before bootloader is written if not os.path.exists(iutil.getSysroot() + "/usr/sbin/new-kernel-pkg"): log.error( "new-kernel-pkg does not exist - grubby wasn't installed? skipping" ) return for kernel in self.kernelVersionList: log.info("Generating rescue image for %s", kernel) iutil.execInSysroot("new-kernel-pkg", ["--rpmposttrans", kernel])
def _restartThread(self, storage, ksdata, payload, instClass, fallback, checkmount): # Wait for the old thread to finish threadMgr.wait(THREAD_PAYLOAD) # Start a new payload thread threadMgr.add( AnacondaThread(name=THREAD_PAYLOAD, target=self._runThread, args=(storage, ksdata, payload, instClass, fallback, checkmount)))
def on_format_clicked(self, *args): """ Once the format button is clicked, the option to cancel expires. We also need to display the spinner showing activity. """ self._cancel_button.set_sensitive(False) self._ok_button.set_sensitive(False) self._notebook.set_current_page(1) # Loop through all of our unformatted DASDs and format them threadMgr.add(AnacondaThread(name=constants.THREAD_DASDFMT, target=self.run_dasdfmt, args=(self._epoch,)))
def install(self): """ Install the payload if it is a tar. Otherwise fall back to rsync of INSTALL_TREE """ # If it doesn't look like a tarfile use the super's install() if not self.is_tarfile: super(LiveImageKSPayload, self).install() return # Use 2x the archive's size to estimate the size of the install # This is used to drive the progress display self.source_size = os.stat(self.image_path)[stat.ST_SIZE] * 2 self.pct_lock = Lock() self.pct = 0 threadMgr.add( AnacondaThread(name=THREAD_LIVE_PROGRESS, target=self.progress)) cmd = "tar" # preserve: ACL's, xattrs, and SELinux context args = [ "--selinux", "--acls", "--xattrs", "--xattrs-include", "*", "--exclude", "/dev/", "--exclude", "/proc/", "--exclude", "/sys/", "--exclude", "/run/", "--exclude", "/boot/*rescue*", "--exclude", "/etc/machine-id", "-xaf", self.image_path, "-C", iutil.getSysroot() ] try: rc = iutil.execWithRedirect(cmd, args) except (OSError, RuntimeError) as e: msg = None err = str(e) log.error(err) else: err = None msg = "%s exited with code %d" % (cmd, rc) log.info(msg) if err: exn = PayloadInstallError(err or msg) if errorHandler.cb(exn) == ERROR_RAISE: raise exn # Wait for progress thread to finish with self.pct_lock: self.pct = 100 threadMgr.wait(THREAD_LIVE_PROGRESS) # Live needs to create the rescue image before bootloader is written for kernel in self.kernelVersionList: log.info("Generating rescue image for %s", kernel) iutil.execInSysroot("new-kernel-pkg", ["--rpmposttrans", kernel])
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 on_add_clicked(self, *args): # Set some widgets to visible/not while we work. self._errorBox.hide() self._addSpinner.set_visible(True) self._addSpinner.show() for widget in [self._addButton, self._cancelButton, self._nicCombo, self._dcbCheckbox, self._autoCheckbox]: widget.set_sensitive(False) self._addSpinner.start() threadMgr.add(AnacondaThread(name=constants.THREAD_FCOE, target=self._add))
def refresh(self): from pyanaconda.install import doInstall from pyanaconda.threads import threadMgr, AnacondaThread Hub.refresh(self) self._start_ransom_notes() GLib.timeout_add(250, self._update_progress, self._install_done) threadMgr.add( AnacondaThread(name=THREAD_INSTALL, target=doInstall, args=(self.storage, self.payload, self.data, self.instclass)))
def initialize(self): NormalSpoke.initialize(self) self._daysStore = self.builder.get_object("days") self._monthsStore = self.builder.get_object("months") self._yearsStore = self.builder.get_object("years") self._regionsStore = self.builder.get_object("regions") self._citiesStore = self.builder.get_object("cities") self._tzmap = self.builder.get_object("tzmap") # we need to know it the new value is the same as previous or not self._old_region = None self._old_city = None self._regionCombo = self.builder.get_object("regionCombobox") self._cityCombo = self.builder.get_object("cityCombobox") self._monthCombo = self.builder.get_object("monthCombobox") self._dayCombo = self.builder.get_object("dayCombobox") self._yearCombo = self.builder.get_object("yearCombobox") self._daysFilter = self.builder.get_object("daysFilter") self._daysFilter.set_visible_func(self.existing_date, None) self._citiesFilter = self.builder.get_object("citiesFilter") self._citiesFilter.set_visible_func(self.city_in_region, None) self._hoursLabel = self.builder.get_object("hoursLabel") self._minutesLabel = self.builder.get_object("minutesLabel") self._amPmUp = self.builder.get_object("amPmUpButton") self._amPmDown = self.builder.get_object("amPmDownButton") self._amPmLabel = self.builder.get_object("amPmLabel") self._radioButton24h = self.builder.get_object("timeFormatRB") self._ntpSwitch = self.builder.get_object("networkTimeSwitch") self._regions_zones = get_all_regions_and_timezones() self._months_nums = dict() # Set the initial sensitivity of the AM/PM toggle based on the time-type selected self._radioButton24h.emit("toggled") 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() threadMgr.add(AnacondaThread(name=constants.THREAD_DATE_TIME, target=self._initialize))
def refresh(self, args=None): from pyanaconda.install import doInstall, doConfiguration from pyanaconda.threads import threadMgr, AnacondaThread # We print this here because we don't really use the window object print(_(self.title)) threadMgr.add( AnacondaThread(name=THREAD_INSTALL, target=doInstall, args=(self.storage, self.payload, self.data, self.instclass))) # This will run until we're all done with the install thread. self._update_progress() threadMgr.add( AnacondaThread(name=THREAD_CONFIGURATION, target=doConfiguration, args=(self.storage, self.payload, self.data, self.instclass))) # This will run until we're all done with the configuration thread. self._update_progress() iutil.ipmi_report(IPMI_FINISHED) # kickstart install, continue automatically if reboot or shutdown selected if flags.automatedInstall and self.data.reboot.action in [ KS_REBOOT, KS_SHUTDOWN ]: # Just pretend like we got input, and our input doesn't care # what it gets, it just quits. self.input(None, None) return True
def on_rescan_clicked(self, button): # Once the rescan button is clicked, the option to cancel expires. # We also need to display the spinner showing activity. self._cancel_button.set_sensitive(False) self._ok_button.set_sensitive(False) self._notebook.set_current_page(1) # And now to fire up the storage reinitialization. threadMgr.add(AnacondaThread(name=constants.THREAD_STORAGE, target=storageInitialize, args=(self.storage, self.data, self.storage.devicetree.protectedDevNames))) self._elapsed = 0 # This watches for the rescan to be finished and updates the dialog when # that happens. self._watcher_id = GLib.timeout_add_seconds(1, self._check_rescan)
def __init__(self, *args, **kwargs): NormalSpoke.__init__(self, *args, **kwargs) self.applyOnSkip = True self._ready = False self.selected_disks = self.data.ignoredisk.onlyuse[:] # This list contains all possible disks that can be included in the install. # All types of advanced disks should be set up for us ahead of time, so # there should be no need to modify this list. self.disks = [] self._confirmed = True # if set to False, it means the user needs to confirm the current # storage configuration if flags.automatedInstall: # now we have to check if some form of partitioning is specified # in the current kickstart if not any((self.data.partition.seen, self.data.logvol.seen, self.data.volgroup.seen, self.data.raid.seen, self.data.btrfs.seen, self.data.autopart.seen)): # no partitioning specified, so use autopart # but prompt the user to confirm it self.data.autopart.autopart = True self._confirmed = False else: # default to using autopart for interactive installs self.data.autopart.autopart = True self.autopart = self.data.autopart.autopart self.autoPartType = None self.clearPartType = CLEARPART_TYPE_NONE if self.data.zerombr.zerombr and arch.isS390(): # run dasdfmt on any unformatted DASDs automatically threadMgr.add( AnacondaThread(name=constants.THREAD_DASDFMT, target=self.run_dasdfmt)) self._previous_autopart = False self._last_clicked_overview = None self._cur_clicked_overview = None self._grabObjects()
def refresh(self): """Refresh location info""" # first check if a provider is available if self._provider is None: log.error("Geoloc: can't refresh - no provider") return # then check if a refresh is already in progress if threadMgr.get(constants.THREAD_GEOLOCATION_REFRESH): log.debug("Geoloc: refresh already in progress") else: # wait for Internet connectivity if network.wait_for_connectivity(): threadMgr.add( AnacondaThread(name=constants.THREAD_GEOLOCATION_REFRESH, target=self._provider.refresh)) else: log.error("Geolocation refresh failed" " - no connectivity")
def initialize(self): # We want to store layouts' names but show layouts as # 'language (description)'. self._entry = self.builder.get_object("addLayoutEntry") layoutColumn = self.builder.get_object("newLayoutColumn") layoutRenderer = self.builder.get_object("newLayoutRenderer") override_cell_property(layoutColumn, layoutRenderer, "text", _show_layout, self._xkl_wrapper) self._treeModelFilter = self.builder.get_object("newLayoutStoreFilter") self._treeModelFilter.set_visible_func(self.matches_entry, None) self._treeModelSort = self.builder.get_object("newLayoutStoreSort") self._treeModelSort.set_default_sort_func(self.compare_layouts, None) self._confirmAddButton = self.builder.get_object("confirmAddButton") self._newLayoutSelection = self.builder.get_object("newLayoutSelection") self._store = self.builder.get_object("newLayoutStore") threadMgr.add(AnacondaThread(name=THREAD_ADD_LAYOUTS_INIT, target=self._initialize))
def _do_configuration(self, widget = None, reenable_ransom = True): from pyanaconda.install import doConfiguration from pyanaconda.threads import threadMgr, AnacondaThread assert self._configurationDone == False self._configurationDone = True # Disable all personalization spokes self.builder.get_object("progressWindow-scroll").set_sensitive(False) if reenable_ransom: self._start_ransom_notes() self._restart_spinner() GLib.timeout_add(250, self._update_progress, self._configuration_done) threadMgr.add(AnacondaThread(name=THREAD_CONFIGURATION, target=doConfiguration, args=(self.storage, self.payload, self.data, self.instclass)))
def initialize(self): NormalSpoke.initialize(self) self._daysStore = self.builder.get_object("days") self._monthsStore = self.builder.get_object("months") self._yearsStore = self.builder.get_object("years") self._regionsStore = self.builder.get_object("regions") self._citiesStore = self.builder.get_object("cities") self._tzmap = self.builder.get_object("tzmap") # we need to know it the new value is the same as previous or not self._old_region = None self._old_city = None self._regionCombo = self.builder.get_object("regionCombobox") self._cityCombo = self.builder.get_object("cityCombobox") self._monthCombo = self.builder.get_object("monthCombobox") self._dayCombo = self.builder.get_object("dayCombobox") self._yearCombo = self.builder.get_object("yearCombobox") self._daysFilter = self.builder.get_object("daysFilter") self._daysFilter.set_visible_func(self.existing_date, None) self._citiesFilter = self.builder.get_object("citiesFilter") self._citiesFilter.set_visible_func(self.city_in_region, None) self._citiesSort = self.builder.get_object("citiesSort") self._citiesSort.set_sort_column_id(0, Gtk.SortType.ASCENDING) self._hoursLabel = self.builder.get_object("hoursLabel") self._minutesLabel = self.builder.get_object("minutesLabel") self._amPmUp = self.builder.get_object("amPmUpButton") self._amPmDown = self.builder.get_object("amPmDownButton") self._amPmLabel = self.builder.get_object("amPmLabel") self._radioButton24h = self.builder.get_object("timeFormatRB") self._ntpSwitch = self.builder.get_object("networkTimeSwitch") self._regions_zones = get_all_regions_and_timezones() self._months_nums = dict() threadMgr.add(AnacondaThread(name=constants.THREAD_DATE_TIME, target=self._initialize))
def one_time_sync_async(server, callback=None): """ Asynchronously synchronize the system time with a given NTP server. This function is non-blocking it starts a new thread for synchronization and returns. Use callback argument to specify the function called when the new thread finishes if needed. :param server: NTP server :param callback: callback function to run after sync or failure :type callback: a function taking one boolean argument (success) """ thread_name = "%s_%s" % (THREAD_SYNC_TIME_BASENAME, server) if threadMgr.get(thread_name): #syncing with the same server running return threadMgr.add(AnacondaThread(name=thread_name, target=one_time_sync, args=(server, callback)))
def _apply(self): """ Private apply. """ self.environment = self._get_environment(self._selection) self.addons = self._addons_selection if self.environment is not None else set( ) if not self.environment: return changed = False # Not a kickstart with packages, setup the selected environment and addons if not self._kickstarted: # Changed the environment or addons, clear and setup if not self._origEnv \ or self._origEnv != self.environment \ or set(self._origAddons) != set(self.addons): self.payload.data.packages.packageList = [] self.data.packages.groupList = [] self.payload.selectEnvironment(self.environment) environment_id = self._get_environment_id(self.environment) available_addons = self._get_available_addons(environment_id) for addon_id in available_addons: if addon_id in self.addons: self.payload.selectGroup(addon_id) changed = True self._origEnv = self.environment self._origAddons = set(self.addons) # Check the software selection if changed or self._kickstarted: threadMgr.add( AnacondaThread(name=THREAD_CHECK_SOFTWARE, target=self.checkSoftwareSelection))
def __init__(self, *args, **kwargs): StorageChecker.__init__(self, min_ram=isys.MIN_GUI_RAM) NormalSpoke.__init__(self, *args, **kwargs) self.applyOnSkip = True self._ready = False self.autoPartType = None self.encrypted = False self.passphrase = "" self.selected_disks = self.data.ignoredisk.onlyuse[:] self._last_selected_disks = None self._back_clicked = False self.autopart_missing_passphrase = False self.disks_errors = [] # This list contains all possible disks that can be included in the install. # All types of advanced disks should be set up for us ahead of time, so # there should be no need to modify this list. self.disks = [] if not flags.automatedInstall: # default to using autopart for interactive installs self.data.autopart.autopart = True self.autopart = self.data.autopart.autopart self.autoPartType = None self.clearPartType = CLEARPART_TYPE_NONE if self.data.zerombr.zerombr and arch.isS390(): # run dasdfmt on any unformatted DASDs automatically threadMgr.add( AnacondaThread(name=constants.THREAD_DASDFMT, target=self.run_dasdfmt)) self._previous_autopart = False self._last_clicked_overview = None self._cur_clicked_overview = None self._grabObjects()
def execute(self): # Spawn storage execution as a separate thread so there's no big delay # going back from this spoke to the hub while StorageChecker.run runs. # Yes, this means there's a thread spawning another thread. Sorry. threadMgr.add( AnacondaThread(name=constants.THREAD_EXECUTE_STORAGE, target=self._doExecute)) # Register iSCSI to kickstart data iscsi_devices = [] # Find all selected disks and add all iscsi disks to iscsi_devices list for d in [ d for d in getDisks(self.storage.devicetree) if d.name in self.selected_disks ]: # Get parents of a multipath devices if isinstance(d, MultipathDevice): for parent_dev in d.parents: if isinstance(parent_dev, iScsiDiskDevice) and not parent_dev.ibft: iscsi_devices.append(parent_dev) # Add no-ibft iScsiDiskDevice. IBFT disks are added automatically so there is # no need to have them in KS. elif isinstance(d, iScsiDiskDevice) and not d.ibft: iscsi_devices.append(d) if iscsi_devices: self.data.iscsiname.iscsiname = self.storage.iscsi.initiator # Remove the old iscsi data information and generate new one self.data.iscsi.iscsi = [] for device in iscsi_devices: iscsi_data = self._create_iscsi_data(device) for saved_iscsi in self.data.iscsi.iscsi: if (iscsi_data.ipaddr == saved_iscsi.ipaddr and iscsi_data.target == saved_iscsi.target and iscsi_data.port == saved_iscsi.port): break else: self.data.iscsi.iscsi.append(iscsi_data)
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 try: thread_name = common.wait_and_fetch_net_data( self._addon_data.content_url, self._addon_data.raw_preinst_content_path, self._addon_data.certificates) except common.OSCAPaddonNetworkError: self._network_problem() with self._fetch_flag_lock: self._fetching = False return except KickstartValueError: self._invalid_url() with self._fetch_flag_lock: self._fetching = False return # 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 install(self): """ Install the payload. """ self.pct_lock = Lock() self.pct = 0 threadMgr.add( AnacondaThread(name=THREAD_LIVE_PROGRESS, target=self.progress)) cmd = "rsync" # preserve: permissions, owners, groups, ACL's, xattrs, times, # symlinks, hardlinks # go recursively, include devices and special files, don't cross # file system boundaries args = [ "-pogAXtlHrDx", "--exclude", "/dev/", "--exclude", "/proc/", "--exclude", "/sys/", "--exclude", "/run/", "--exclude", "/boot/*rescue*", "--exclude", "/etc/machine-id", INSTALL_TREE + "/", ROOT_PATH ] try: rc = iutil.execWithRedirect(cmd, args) except (OSError, RuntimeError) as e: msg = None err = str(e) log.error(err) else: err = None msg = "%s exited with code %d" % (cmd, rc) log.info(msg) if err or rc == 12: exn = PayloadInstallError(err or msg) if errorHandler.cb(exn) == ERROR_RAISE: raise exn # Wait for progress thread to finish with self.pct_lock: self.pct = 100 threadMgr.wait(THREAD_LIVE_PROGRESS)
def initialize(self): NormalSpoke.initialize(self) # Wouldn't it be nice if glade knew how to do this? label = self.builder.get_object("summary_button").get_children()[0] markup = "<span foreground='blue'><u>%s</u></span>" % label.get_text() label.set_use_markup(True) label.set_markup(markup) specializedButton = self.builder.get_object("addSpecializedButton") # It's uh... uh... it's down there somewhere, let me take another look. label = specializedButton.get_children()[0].get_children()[0].get_children()[1] markup = "<span size='large'><b>%s</b></span>" % label.get_text() label.set_use_markup(True) label.set_markup(markup) specializedButton.show_all() self.local_disks_box = self.builder.get_object("local_disks_box") self.specialized_disks_box = self.builder.get_object("specialized_disks_box") threadMgr.add(AnacondaThread(name=constants.THREAD_STORAGE_WATCHER, target=self._initialize))
def _apply(self): if self.environment and not (flags.automatedInstall and self.data.packages.seen): 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(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 initialize(self): NormalSpoke.initialize(self) self.local_disks_box = self.builder.get_object("local_disks_box") self.specialized_disks_box = self.builder.get_object( "specialized_disks_box") # Connect the viewport adjustments to the child widgets # See also https://bugzilla.gnome.org/show_bug.cgi?id=744721 localViewport = self.builder.get_object("localViewport") specializedViewport = self.builder.get_object("specializedViewport") self.local_disks_box.set_focus_hadjustment( localViewport.get_hadjustment()) self.specialized_disks_box.set_focus_hadjustment( specializedViewport.get_hadjustment()) mainViewport = self.builder.get_object("storageViewport") mainBox = self.builder.get_object("storageMainBox") mainBox.set_focus_vadjustment(mainViewport.get_vadjustment()) threadMgr.add( AnacondaThread(name=constants.THREAD_STORAGE_WATCHER, target=self._initialize))
def initialize(self): NormalSpoke.initialize(self) self._grabObjects() # I shouldn't have to do this outside GtkBuilder, but it really doesn't # want to let me pass in user data. self._autodetectButton.connect("toggled", self.on_source_toggled, self._autodetectBox) self._isoButton.connect("toggled", self.on_source_toggled, self._isoBox) self._networkButton.connect("toggled", self.on_source_toggled, self._networkBox) # Show or hide the updates option based on the installclass if self.instclass.installUpdates: really_show(self._updatesBox) else: really_hide(self._updatesBox) threadMgr.add( AnacondaThread(name=constants.THREAD_SOURCE_WATCHER, target=self._initialize))
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))