class Hub(GUIObject, common.Hub):
"""A Hub is an overview UI screen. A Hub consists of one or more grids of
configuration options that the user may choose from. Each grid is
provided by a SpokeCategory, and each option is provided by a Spoke.
When the user dives down into a Spoke and is finished interacting with
it, they are returned to the Hub.
Some Spokes are required. The user must interact with all required
Spokes before they are allowed to proceed to the next stage of
installation.
From a layout perspective, a Hub is the entirety of the screen, though
the screen itself can be roughly divided into thirds. The top third is
some basic navigation information (where you are, what you're
installing). The middle third is the grid of Spokes. The bottom third
is an action area providing additional buttons (quit, continue) or
progress information (during package installation).
Installation may consist of multiple chained Hubs, or Hubs with
additional standalone screens either before or after them.
.. inheritance-diagram:: Hub
:parts: 3
"""
handles_autostep = True
_hubs_collection = []
def __init__(self, data, storage, payload, instclass):
"""Create a new Hub instance.
The arguments this base class accepts defines the API that Hubs
have to work with. A Hub does not get free reign over everything
in the anaconda class, as that would be a big mess. Instead, a
Hub may count on the following:
ksdata -- An instance of a pykickstart Handler object. The
Hub uses this to populate its UI with defaults
and to pass results back after it has run.
storage -- An instance of storage.Storage. This is useful for
determining what storage devices are present and how
they are configured.
payload -- An instance of a payload.Payload subclass. This
is useful for displaying and selecting packages to
install, and in carrying out the actual installation.
instclass -- An instance of a BaseInstallClass subclass. This
is useful for determining distribution-specific
installation information like default package
selections and default partitioning.
"""
GUIObject.__init__(self, data)
common.Hub.__init__(self, storage, payload, instclass)
# enable the autoContinue feature if we are in kickstart
# mode, but if the user interacts with the hub, it will be
# disabled again
self._autoContinue = flags.automatedInstall
self._hubs_collection.append(self)
self.timeout = None
self._incompleteSpokes = []
self._inSpoke = False
self._notReadySpokes = []
self._spokes = {}
# Used to store the last result of _updateContinue
self._warningMsg = None
self._checker = None
# Flag to indicate the user can continue even if the checker indicates an error.
# The checker itself is left alone so the error message doesn't accidentally get
# cleaered.
self._checker_ignore = False
self._spokesToStepIn = []
self._spokeAutostepIndex = 0
def _createBox(self):
import gi
gi.require_version("Gtk", "3.0")
gi.require_version("AnacondaWidgets", "3.3")
from gi.repository import Gtk, AnacondaWidgets
cats_and_spokes = self._collectCategoriesAndSpokes()
categories = cats_and_spokes.keys()
grid = Gtk.Grid(row_spacing=6, column_spacing=6, column_homogeneous=True,
margin_bottom=12)
row = 0
for c in sorted(categories, key=lambda c: c.title):
obj = c()
selectors = []
for spokeClass in sorted(cats_and_spokes[c], key=lambda s: s.title):
# Check if this spoke is to be shown in the supported environments
if not any(spokeClass.should_run(environ, self.data) for environ in flags.environs):
continue
# Create the new spoke and populate its UI with whatever data.
# From here on, this Spoke will always exist.
spoke = spokeClass(self.data, self.storage, self.payload, self.instclass)
spoke.window.set_beta(self.window.get_beta())
spoke.window.set_property("distribution", distributionText().upper())
# If a spoke is not showable, it is unreachable in the UI. We
# might as well get rid of it.
#
# NOTE: Any kind of spoke can be unshowable.
if not spoke.showable:
del(spoke)
continue
# This allows being able to jump between two spokes without
# having to directly involve the hub.
self._spokes[spokeClass.__name__] = spoke
# If a spoke is indirect, it is reachable but not directly from
# a hub. This is for things like the custom partitioning spoke,
# which you can only get to after going through the initial
# storage configuration spoke.
#
# NOTE: This only makes sense for NormalSpokes. Other kinds
# of spokes do not involve a hub.
if spoke.indirect:
spoke.initialize()
continue
spoke.selector = AnacondaWidgets.SpokeSelector(C_("GUI|Spoke", spoke.title),
spoke.icon)
# Set all selectors to insensitive before initialize runs. The call to
# _updateCompleteness later will take care of setting it straight.
spoke.selector.set_sensitive(False)
spoke.initialize()
if not spoke.ready:
self._notReadySpokes.append(spoke)
# Set some default values on the associated selector that
# affect its display on the hub.
self._updateCompleteness(spoke, update_continue=False)
spoke.selector.connect("button-press-event", self._on_spoke_clicked, spoke)
spoke.selector.connect("key-release-event", self._on_spoke_clicked, spoke)
# If this is a kickstart install, attempt to execute any provided ksdata now.
if flags.automatedInstall and spoke.ready and spoke.changed and \
spoke.visitedSinceApplied:
spoke.execute()
spoke.visitedSinceApplied = False
selectors.append(spoke.selector)
if not selectors:
continue
label = Gtk.Label(label="<span font-desc=\"Sans 14\">%s</span>" % escape_markup(_(obj.title)),
use_markup=True, halign=Gtk.Align.START, margin_top=12, margin_bottom=12)
grid.attach(label, 0, row, 2, 1)
row += 1
col = 0
for selector in selectors:
selector.set_margin_start(12)
grid.attach(selector, col, row, 1, 1)
col = int(not col)
if col == 0:
row += 1
# If this category contains an odd number of selectors, the above
# row += 1 will not have run for the last row, which puts the next
# category's title in the wrong place.
if len(selectors) % 2:
row += 1
# initialization of all expected spokes has been started, so notify the controller
hub_controller = lifecycle.get_controller_by_name(self.__class__.__name__)
if hub_controller:
hub_controller.all_modules_added()
else:
log.error("Initialization controller for hub %s expected but missing.", self.__class__.__name__)
spokeArea = self.window.get_spoke_area()
viewport = Gtk.Viewport()
viewport.add(grid)
spokeArea.add(viewport)
self._updateContinue()
def _updateCompleteness(self, spoke, update_continue=True):
spoke.selector.set_sensitive(spoke.sensitive and spoke.ready)
spoke.selector.set_property("status", spoke.status)
spoke.selector.set_tooltip_markup(escape_markup(spoke.status))
spoke.selector.set_incomplete(not spoke.completed and spoke.mandatory)
self._handleCompleteness(spoke, update_continue)
def _handleCompleteness(self, spoke, update_continue=True):
# Add the spoke to the incomplete list if it's now incomplete, and make
# sure it's not on the list if it's now complete. Then show the box if
# it's needed and hide it if it's not.
if not spoke.mandatory or spoke.completed:
if spoke in self._incompleteSpokes:
self._incompleteSpokes.remove(spoke)
log.debug("incomplete spokes: %s", self._incompleteSpokes)
else:
if spoke not in self._incompleteSpokes:
self._incompleteSpokes.append(spoke)
log.debug("incomplete spokes: %s", self._incompleteSpokes)
if update_continue:
self._updateContinue()
def _updateContinue(self):
warning = None
if len(self._incompleteSpokes) == 0:
if self._checker and not self._checker.check():
warning = self._checker.error_message
log.error(self._checker.error_message)
# If this is a kickstart, consider the user to be warned and
# let them continue anyway, manually
if flags.automatedInstall:
self._autoContinue = False
self._checker_ignore = True
else:
warning = _("Please complete items marked with this icon before continuing to the next step.")
# Check that this warning isn't already set to avoid spamming the
# info bar with incomplete spoke messages when the hub starts
if warning != self._warningMsg:
self.clear_info()
self._warningMsg = warning
if warning:
self.set_warning(warning)
self._updateContinueButton()
@property
def continuePossible(self):
return len(self._incompleteSpokes) == 0 and len(self._notReadySpokes) == 0 and (getattr(self._checker, "success", True) or self._checker_ignore)
def _updateContinueButton(self):
self.window.set_may_continue(self.continuePossible)
def _update_spokes(self):
from pyanaconda.ui.communication import hubQ
import queue
q = hubQ.q
if not self._spokes and self.window.get_may_continue():
# no spokes, move on
log.debug("no spokes available on %s, continuing automatically", self)
gtk_call_once(self.window.emit, "continue-clicked")
click_continue = False
# Grab all messages that may have appeared since last time this method ran.
while True:
try:
(code, args) = q.get(False)
except queue.Empty:
break
# The first argument to all codes is the name of the spoke we are
# acting on. If no such spoke exists, throw the message away.
spoke = self._spokes.get(args[0], None)
if not spoke or spoke.__class__.__name__ not in self._spokes:
q.task_done()
continue
if code == hubQ.HUB_CODE_NOT_READY:
self._updateCompleteness(spoke)
if spoke not in self._notReadySpokes:
self._notReadySpokes.append(spoke)
self._updateContinueButton()
log.debug("spoke is not ready: %s", spoke)
elif code == hubQ.HUB_CODE_READY:
self._updateCompleteness(spoke)
if spoke in self._notReadySpokes:
self._notReadySpokes.remove(spoke)
self._updateContinueButton()
log.debug("spoke is ready: %s", spoke)
# If this is a real kickstart install (the kind with an input ks file)
# and all spokes are now completed, we should skip ahead to the next
# hub automatically. Take into account the possibility the user is
# viewing a spoke right now, though.
if flags.automatedInstall:
spoke_title = spoke.title.replace("_", "")
# Users might find it helpful to know why a kickstart install
# went interactive. Log that here.
if not spoke.completed and spoke.mandatory:
autoinstall_stopped("User interaction required on spoke %s" % spoke_title)
else:
log.debug("kickstart installation, spoke %s is ready", spoke_title)
# Spokes that were not initially ready got the execute call in
# _createBox skipped. Now that it's become ready, do it. Note
# that we also provide a way to skip this processing (see comments
# communication.py) to prevent getting caught in a loop.
if not args[1] and spoke.changed and spoke.visitedSinceApplied:
log.debug("execute spoke from event loop %s", spoke.title.replace("_", ""))
spoke.execute()
spoke.visitedSinceApplied = False
if self.continuePossible:
if self._inSpoke:
self._autoContinue = False
elif self._autoContinue:
click_continue = True
elif code == hubQ.HUB_CODE_MESSAGE:
spoke.selector.set_property("status", args[1])
log.debug("setting %s status to: %s", spoke, args[1])
q.task_done()
# queue is now empty, should continue be clicked?
if self._autoContinue and click_continue and self.window.get_may_continue():
# enqueue the emit to the Gtk message queue
log.debug("_autoContinue clicking continue button")
gtk_call_once(self.window.emit, "continue-clicked")
return True
def refresh(self):
GUIObject.refresh(self)
self._createBox()
for hub in Hub._hubs_collection:
if hub.timeout is not None:
log.debug("Disabling event loop for hub %s", hub.__class__.__name__)
hub.timeout.cancel()
hub.timeout = None
log.debug("Starting event loop for hub %s", self.__class__.__name__)
self.timeout = Timer()
self.timeout.timeout_msec(100, self._update_spokes)
### SIGNAL HANDLERS
def _on_spoke_clicked(self, selector, event, spoke):
import gi
gi.require_version("Gdk", "3.0")
from gi.repository import Gdk
# This handler only runs for these two kinds of events, and only for
# activate-type keys (space, enter) in the latter event's case.
if event and not event.type in [Gdk.EventType.BUTTON_PRESS, Gdk.EventType.KEY_RELEASE]:
return
if event and event.type == Gdk.EventType.KEY_RELEASE and \
event.keyval not in [Gdk.KEY_space, Gdk.KEY_Return, Gdk.KEY_ISO_Enter, Gdk.KEY_KP_Enter, Gdk.KEY_KP_Space]:
return
if selector:
selector.grab_focus()
# On automated kickstart installs, our desired behavior is to display
# the hub while background processes work, then skip to the progress
# hub immediately after everything's done.
# However if the user proves his intent to change the kickstarted
# values by entering any of the spokes, we need to disable the
# autoContinue feature and wait for the user to explicitly state
# that he is done configuring by pressing the continue button.
self._autoContinue = False
# Enter the spoke
self._inSpoke = True
spoke.refresh()
self.main_window.enterSpoke(spoke)
# the new spoke should be now visible, trigger the entered signal
spoke.entered.emit(spoke)
def spoke_done(self, spoke):
# Ignore if not in a spoke
if not self._inSpoke:
return
spoke.visitedSinceApplied = True
# don't apply any actions if the spoke was visited automatically
if spoke.automaticEntry:
spoke.automaticEntry = False
return
# Don't take visitedSinceApplied into account here. It will always be
# True from the line above.
if spoke.changed and (not spoke.skipTo or (spoke.skipTo and spoke.applyOnSkip)):
spoke.apply()
spoke.execute()
spoke.visitedSinceApplied = False
spoke.exited.emit(spoke)
self._inSpoke = False
# Now update the selector with the current status and completeness.
for sp in self._spokes.values():
if not sp.indirect:
self._updateCompleteness(sp, update_continue=False)
self._updateContinue()
# And then if that spoke wants us to jump straight to another one,
# handle that now.
if spoke.skipTo and spoke.skipTo in self._spokes:
dest = spoke.skipTo
# Clear out the skipTo setting so we don't cycle endlessly.
spoke.skipTo = None
self._on_spoke_clicked(self._spokes[dest].selector, None, self._spokes[dest])
# Otherwise, switch back to the hub (that's us!)
else:
self.main_window.returnToHub()
def _doAutostep(self):
"""Autostep through all spokes managed by this hub"""
log.info("autostepping through all spokes on hub %s", self.__class__.__name__)
# create a list of all spokes in reverse alphabetic order, we will pop() from it when
# processing all the spokes so the screenshots will actually be in alphabetic order
self._spokesToStepIn = list(reversed(sorted(self._spokes.values(), key=lambda x: x.__class__.__name__)))
# we can't just loop over all the spokes due to the asynchronous nature of GtkStack, so we start by
# autostepping to the first spoke, this will trigger a callback that steps to the next spoke,
# until we run out of unvisited spokes
self._autostepSpoke()
def _autostepSpoke(self):
"""Process a single spoke, if no more spokes are available report autostep as finished for the hub."""
# do we have some spokes to work on ?
if self._spokesToStepIn:
# take one of them
spoke = self._spokesToStepIn.pop()
# increment the number of processed spokes
self._spokeAutostepIndex += 1
log.debug("stepping to spoke %s (%d/%d)", spoke.__class__.__name__, self._spokeAutostepIndex, len(self._spokes))
# notify the spoke about the upcoming automatic entry and set a callback that will be called
# once the spoke has been successfully processed
spoke.automaticEntry = True
spoke.autostepDoneCallback = lambda x: self._autostepSpoke()
# if this is the last spoke, tell it to return to hub once processed
if self._spokesToStepIn == []:
spoke.lastAutostepSpoke = True
gtk_call_once(self._on_spoke_clicked, None, None, spoke)
else:
log.info("autostep for hub %s finished", self.__class__.__name__)
gtk_call_once(self._doPostAutostep)
def _doPostAutostep(self):
if self._spokesToStepIn:
# there are still spokes that need to be stepped in
return
# we are done, re-emit the continue clicked signal we "consumed" previously
# so that the Anaconda GUI can switch to the next screen (or quit)
self.window.emit("continue-clicked")
class ProgressHub(Hub):
"""
.. inheritance-diagram:: ProgressHub
:parts: 3
"""
builderObjects = ["progressWindow"]
mainWidgetName = "progressWindow"
uiFile = "hubs/progress.glade"
helpFile = "ProgressHub.xml"
def __init__(self, data, storage, payload):
super().__init__(data, storage, payload)
self._totalSteps = 0
self._currentStep = 0
self._configurationDone = False
self._update_progress_timer = Timer()
self._cycle_rnotes_timer = Timer()
def _do_configuration(self, widget=None, reenable_ransom=True):
from pyanaconda.installation import doConfiguration
from pyanaconda.threading 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()
self._update_progress_timer.timeout_msec(250, self._update_progress,
self._configuration_done)
threadMgr.add(AnacondaThread(name=THREAD_CONFIGURATION, target=doConfiguration,
args=(self.storage, self.payload, self.data)))
def _start_ransom_notes(self):
# Adding this as a timeout below means it'll get called after 60
# seconds, so we need to do the first call manually.
self._cycle_rnotes()
self._cycle_rnotes_timer.timeout_sec(60, self._cycle_rnotes)
def _update_progress(self, callback=None):
from pyanaconda.progress import progressQ
import queue
q = progressQ.q
# Grab all messages may have appeared since last time this method ran.
while True:
# Attempt to get a message out of the queue for how we should update
# the progress bar. If there's no message, don't error out.
try:
(code, args) = q.get(False)
except queue.Empty:
break
if code == progressQ.PROGRESS_CODE_INIT:
self._init_progress_bar(args[0])
elif code == progressQ.PROGRESS_CODE_STEP:
self._step_progress_bar()
elif code == progressQ.PROGRESS_CODE_MESSAGE:
self._update_progress_message(args[0])
elif code == progressQ.PROGRESS_CODE_COMPLETE:
q.task_done()
# we are done, stop the progress indication
gtk_call_once(self._progressBar.set_fraction, 1.0)
gtk_call_once(self._progressLabel.set_text, _("Complete!"))
gtk_call_once(self._spinner.stop)
gtk_call_once(self._spinner.hide)
if callback:
callback()
# There shouldn't be any more progress bar updates, so return False
# to indicate this method should be removed from the idle loop.
return False
elif code == progressQ.PROGRESS_CODE_QUIT:
sys.exit(args[0])
q.task_done()
return True
def _configuration_done(self):
# Configuration done, remove ransom notes timer
# and switch to the Reboot page
self._cycle_rnotes_timer.cancel()
self._progressNotebook.set_current_page(1)
self.window.set_may_continue(True)
util.ipmi_report(IPMI_FINISHED)
if conf.license.eula:
self.set_warning(_("Use of this product is subject to the license agreement "
"found at %s") % conf.license.eula)
self.window.show_all()
# kickstart install, continue automatically if reboot or shutdown selected
if flags.automatedInstall and self.data.reboot.action in [KS_REBOOT, KS_SHUTDOWN]:
self.window.emit("continue-clicked")
def _install_done(self):
# package installation done, check personalization spokes
# and start the configuration step if all is ready
if not self._inSpoke and self.continuePossible:
self._do_configuration(reenable_ransom=False)
else:
# some mandatory spokes are not ready
# switch to configure and finish page
self._cycle_rnotes_timer.cancel()
self._progressNotebook.set_current_page(0)
def _do_globs(self, path):
return glob.glob(path + "/*.png") + \
glob.glob(path + "/*.jpg") + \
glob.glob(path + "/*.svg")
def _get_rnotes(self):
# We first look for rnotes in paths containing the language, then in
# directories without the language component. You know, just in case.
paths = ["/tmp/updates/pixmaps/rnotes/",
"/tmp/product/pixmaps/rnotes/",
"/usr/share/anaconda/pixmaps/rnotes/"]
all_lang_pixmaps = []
for path in paths:
all_lang_pixmaps += self._do_globs(path + "/*")
pixmap_langs = [pixmap.split(os.path.sep)[-2] for pixmap in all_lang_pixmaps]
best_lang = find_best_locale_match(os.environ["LANG"], pixmap_langs)
if not best_lang:
# nothing found, try the default language
best_lang = find_best_locale_match(DEFAULT_LANG, pixmap_langs)
if not best_lang:
# nothing found even for the default language, try non-localized rnotes
non_localized = []
for path in paths:
non_localized += self._do_globs(path)
return non_localized
best_lang_pixmaps = []
for path in paths:
best_lang_pixmaps += self._do_globs(path + best_lang)
return best_lang_pixmaps
def _cycle_rnotes(self):
# Change the ransom notes image every minute by grabbing the next
# image's filename. Note that self._rnotesPages is an infinite list,
# so this will cycle through the images indefinitely.
try:
nxt = next(self._rnotesPages)
except StopIteration:
# there are no rnotes
pass
else:
self._progressNotebook.set_current_page(nxt)
return True
def initialize(self):
super().initialize()
if not conf.system.can_reboot and conf.target.is_hardware:
continueText = self.builder.get_object("rebootLabel")
continueText.set_text(_("%s is now successfully installed on your system and ready "
"for you to use! When you are ready, reboot your system to start using it!"))
continueText.set_line_wrap(True)
self.window.get_continue_button().set_label(C_("GUI|Progress", "_Quit"))
self._progressBar = self.builder.get_object("progressBar")
self._progressLabel = self.builder.get_object("progressLabel")
self._progressNotebook = self.builder.get_object("progressNotebook")
self._spinner = self.builder.get_object("progressSpinner")
lbl = self.builder.get_object("configurationLabel")
lbl.set_text(_("%s is now successfully installed, but some configuration still needs to be done.\n"
"Finish it and then click the Finish configuration button please.") %
productName)
lbl = self.builder.get_object("rebootLabel")
lbl.set_text(_("%s is now successfully installed and ready for you to use!\n"
"Go ahead and reboot to start using it!") % productName)
rnotes = self._get_rnotes()
# Get the start of the pages we're about to add to the notebook
rnotes_start = self._progressNotebook.get_n_pages()
if rnotes:
# Add a new page in the notebook for each ransom note image.
for f in rnotes:
img = Gtk.Image.new_from_file(f)
img.show()
self._progressNotebook.append_page(img, None)
# An infinite list of the page numbers containing ransom notes images.
self._rnotesPages = itertools.cycle(range(rnotes_start,
self._progressNotebook.get_n_pages()))
else:
# Add a blank page to the notebook and we'll just cycle to that
# over and over again.
blank = Gtk.Box()
blank.show()
self._progressNotebook.append_page(blank, None)
self._rnotesPages = itertools.cycle([rnotes_start])
def refresh(self):
from pyanaconda.installation import doInstall
from pyanaconda.threading import threadMgr, AnacondaThread
super().refresh()
self._start_ransom_notes()
self._update_progress_timer.timeout_msec(250, self._update_progress, self._install_done)
threadMgr.add(AnacondaThread(name=THREAD_INSTALL, target=doInstall,
args=(self.storage, self.payload, self.data)))
def _updateContinueButton(self):
if self._configurationDone:
self.window.set_may_continue(self.continuePossible)
else:
self.builder.get_object("configureButton").set_sensitive(self.continuePossible)
def _init_progress_bar(self, steps):
self._totalSteps = steps
self._currentStep = 0
gtk_call_once(self._progressBar.set_fraction, 0.0)
def _step_progress_bar(self):
if not self._totalSteps:
return
self._currentStep += 1
gtk_call_once(self._progressBar.set_fraction, self._currentStep/self._totalSteps)
def _update_progress_message(self, message):
if not self._totalSteps:
return
gtk_call_once(self._progressLabel.set_text, message)
@async_action_nowait
def _restart_spinner(self):
self._spinner.show()
self._spinner.start()
class ProgressHub(Hub):
"""
.. inheritance-diagram:: ProgressHub
:parts: 3
"""
builderObjects = ["progressWindow"]
mainWidgetName = "progressWindow"
uiFile = "hubs/progress.glade"
helpFile = "ProgressHub.xml"
def __init__(self, data, storage, payload, instclass):
Hub.__init__(self, data, storage, payload, instclass)
self._totalSteps = 0
self._currentStep = 0
self._configurationDone = False
self._update_progress_timer = Timer()
self._cycle_rnotes_timer = Timer()
def _do_configuration(self, widget=None, reenable_ransom=True):
from pyanaconda.installation import doConfiguration
from pyanaconda.threading 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()
self._update_progress_timer.timeout_msec(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 _start_ransom_notes(self):
# Adding this as a timeout below means it'll get called after 60
# seconds, so we need to do the first call manually.
self._cycle_rnotes()
self._cycle_rnotes_timer.timeout_sec(60, self._cycle_rnotes)
def _update_progress(self, callback=None):
from pyanaconda.progress import progressQ
import queue
q = progressQ.q
# Grab all messages may have appeared since last time this method ran.
while True:
# Attempt to get a message out of the queue for how we should update
# the progress bar. If there's no message, don't error out.
try:
(code, args) = q.get(False)
except queue.Empty:
break
if code == progressQ.PROGRESS_CODE_INIT:
self._init_progress_bar(args[0])
elif code == progressQ.PROGRESS_CODE_STEP:
self._step_progress_bar()
elif code == progressQ.PROGRESS_CODE_MESSAGE:
self._update_progress_message(args[0])
elif code == progressQ.PROGRESS_CODE_COMPLETE:
q.task_done()
# we are done, stop the progress indication
gtk_call_once(self._progressBar.set_fraction, 1.0)
gtk_call_once(self._progressLabel.set_text, _("Complete!"))
gtk_call_once(self._spinner.stop)
gtk_call_once(self._spinner.hide)
if callback:
callback()
# There shouldn't be any more progress bar updates, so return False
# to indicate this method should be removed from the idle loop.
return False
elif code == progressQ.PROGRESS_CODE_QUIT:
sys.exit(args[0])
q.task_done()
return True
def _configuration_done(self):
# Configuration done, remove ransom notes timer
# and switch to the Reboot page
self._cycle_rnotes_timer.cancel()
self._progressNotebook.set_current_page(1)
self.window.set_may_continue(True)
util.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
]:
self.window.emit("continue-clicked")
def _install_done(self):
# package installation done, check personalization spokes
# and start the configuration step if all is ready
if not self._inSpoke and self.continuePossible:
self._do_configuration(reenable_ransom=False)
else:
# some mandatory spokes are not ready
# switch to configure and finish page
self._cycle_rnotes_timer.cancel()
self._progressNotebook.set_current_page(0)
def _do_globs(self, path):
return glob.glob(path + "/*.png") + \
glob.glob(path + "/*.jpg") + \
glob.glob(path + "/*.svg")
def _get_rnotes(self):
# We first look for rnotes in paths containing the language, then in
# directories without the language component. You know, just in case.
paths = [
"/tmp/updates/pixmaps/rnotes/", "/tmp/product/pixmaps/rnotes/",
"/usr/share/anaconda/pixmaps/rnotes/"
]
all_lang_pixmaps = []
for path in paths:
all_lang_pixmaps += self._do_globs(path + "/*")
pixmap_langs = [
pixmap.split(os.path.sep)[-2] for pixmap in all_lang_pixmaps
]
best_lang = find_best_locale_match(os.environ["LANG"], pixmap_langs)
if not best_lang:
# nothing found, try the default language
best_lang = find_best_locale_match(DEFAULT_LANG, pixmap_langs)
if not best_lang:
# nothing found even for the default language, try non-localized rnotes
non_localized = []
for path in paths:
non_localized += self._do_globs(path)
return non_localized
best_lang_pixmaps = []
for path in paths:
best_lang_pixmaps += self._do_globs(path + best_lang)
return best_lang_pixmaps
def _cycle_rnotes(self):
# Change the ransom notes image every minute by grabbing the next
# image's filename. Note that self._rnotesPages is an infinite list,
# so this will cycle through the images indefinitely.
try:
nxt = next(self._rnotesPages)
except StopIteration:
# there are no rnotes
pass
else:
self._progressNotebook.set_current_page(nxt)
return True
def initialize(self):
Hub.initialize(self)
if flags.livecdInstall:
continueText = self.builder.get_object("rebootLabel")
continueText.set_text(
_("%s is now successfully installed on your system and ready "
"for you to use! When you are ready, reboot your system to start using it!"
))
continueText.set_line_wrap(True)
self.window.get_continue_button().set_label(
C_("GUI|Progress", "_Quit"))
self._progressBar = self.builder.get_object("progressBar")
self._progressLabel = self.builder.get_object("progressLabel")
self._progressNotebook = self.builder.get_object("progressNotebook")
self._spinner = self.builder.get_object("progressSpinner")
lbl = self.builder.get_object("configurationLabel")
lbl.set_text(
_("%s is now successfully installed, but some configuration still needs to be done.\n"
"Finish it and then click the Finish configuration button please."
) % productName)
lbl = self.builder.get_object("rebootLabel")
lbl.set_text(
_("%s is now successfully installed and ready for you to use!\n"
"Go ahead and reboot to start using it!") % productName)
rnotes = self._get_rnotes()
# Get the start of the pages we're about to add to the notebook
rnotes_start = self._progressNotebook.get_n_pages()
if rnotes:
# Add a new page in the notebook for each ransom note image.
for f in rnotes:
img = Gtk.Image.new_from_file(f)
img.show()
self._progressNotebook.append_page(img, None)
# An infinite list of the page numbers containing ransom notes images.
self._rnotesPages = itertools.cycle(
range(rnotes_start, self._progressNotebook.get_n_pages()))
else:
# Add a blank page to the notebook and we'll just cycle to that
# over and over again.
blank = Gtk.Box()
blank.show()
self._progressNotebook.append_page(blank, None)
self._rnotesPages = itertools.cycle([rnotes_start])
def refresh(self):
from pyanaconda.installation import doInstall
from pyanaconda.threading import threadMgr, AnacondaThread
Hub.refresh(self)
self._start_ransom_notes()
self._update_progress_timer.timeout_msec(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 _updateContinueButton(self):
if self._configurationDone:
self.window.set_may_continue(self.continuePossible)
else:
self.builder.get_object("configureButton").set_sensitive(
self.continuePossible)
def _init_progress_bar(self, steps):
self._totalSteps = steps
self._currentStep = 0
gtk_call_once(self._progressBar.set_fraction, 0.0)
def _step_progress_bar(self):
if not self._totalSteps:
return
self._currentStep += 1
gtk_call_once(self._progressBar.set_fraction,
self._currentStep / self._totalSteps)
def _update_progress_message(self, message):
if not self._totalSteps:
return
gtk_call_once(self._progressLabel.set_text, message)
@async_action_nowait
def _restart_spinner(self):
self._spinner.show()
self._spinner.start()
class ProgressSpoke(StandaloneSpoke):
"""
.. inheritance-diagram:: ProgressSpoke
:parts: 3
"""
builderObjects = ["progressWindow"]
mainWidgetName = "progressWindow"
uiFile = "spokes/installation_progress.glade"
helpFile = "ProgressHub.xml"
postForHub = SummaryHub
@staticmethod
def get_screen_id():
"""Return a unique id of this UI screen."""
return "installation-progress"
def __init__(self, data, storage, payload):
super().__init__(data, storage, payload)
self._totalSteps = 0
self._currentStep = 0
self._update_progress_timer = Timer()
self._progressBar = self.builder.get_object("progressBar")
self._progressLabel = self.builder.get_object("progressLabel")
self._progressNotebook = self.builder.get_object("progressNotebook")
self._spinner = self.builder.get_object("progressSpinner")
@property
def completed(self):
"""This spoke is never completed, initially."""
return False
def apply(self):
"""There is nothing to apply."""
pass
def _update_progress(self, callback=None):
from pyanaconda.progress import progressQ
import queue
q = progressQ.q
# Grab all messages may have appeared since last time this method ran.
while True:
# Attempt to get a message out of the queue for how we should update
# the progress bar. If there's no message, don't error out.
try:
(code, args) = q.get(False)
except queue.Empty:
break
if code == progressQ.PROGRESS_CODE_INIT:
self._init_progress_bar(args[0])
elif code == progressQ.PROGRESS_CODE_STEP:
self._step_progress_bar()
elif code == progressQ.PROGRESS_CODE_MESSAGE:
self._update_progress_message(args[0])
elif code == progressQ.PROGRESS_CODE_COMPLETE:
q.task_done()
# we are done, stop the progress indication
gtk_call_once(self._progressBar.set_fraction, 1.0)
gtk_call_once(self._progressLabel.set_text, _("Complete!"))
gtk_call_once(self._spinner.stop)
gtk_call_once(self._spinner.hide)
if callback:
callback()
# There shouldn't be any more progress bar updates, so return False
# to indicate this method should be removed from the idle loop.
return False
elif code == progressQ.PROGRESS_CODE_QUIT:
sys.exit(args[0])
q.task_done()
return True
def _installation_done(self):
log.debug("The installation has finished.")
util.ipmi_report(IPMI_FINISHED)
if conf.license.eula:
self.set_warning(_("Use of this product is subject to the license agreement "
"found at %s") % conf.license.eula)
self.window.show_all()
# Show the reboot message.
self._progressNotebook.set_current_page(1)
# Enable the continue button.
self.window.set_may_continue(True)
# Hide the quit button.
quit_button = self.window.get_quit_button()
quit_button.hide()
# kickstart install, continue automatically if reboot or shutdown selected
if flags.automatedInstall and self.data.reboot.action in [KS_REBOOT, KS_SHUTDOWN]:
self.window.emit("continue-clicked")
def initialize(self):
super().initialize()
# Disable the continue button.
self.window.set_may_continue(False)
# Set the label of the continue button.
if conf.target.is_hardware and conf.system.can_reboot:
continue_label = C_("GUI|Progress", "_Reboot System")
else:
continue_label = C_("GUI|Progress", "_Finish Installation")
continue_button = self.window.get_continue_button()
continue_button.set_label(continue_label)
# Set the reboot label.
if conf.target.is_hardware:
continue_text = _(
"%s is now successfully installed and ready for you to use!\n"
"Go ahead and reboot your system to start using it!"
) % productName
else:
continue_text = _(
"%s is now successfully installed and ready for you to use!\n"
"Go ahead and quit the application to start using it!"
) % productName
label = self.builder.get_object("rebootLabel")
label.set_text(continue_text)
# Don't show the reboot message.
self._progressNotebook.set_current_page(0)
def refresh(self):
from pyanaconda.installation import run_installation
from pyanaconda.threading import threadMgr, AnacondaThread
super().refresh()
self._update_progress_timer.timeout_msec(
250,
self._update_progress,
self._installation_done
)
threadMgr.add(AnacondaThread(
name=THREAD_INSTALL,
target=run_installation,
args=(self.payload, self.data))
)
log.debug("The installation has started.")
def _init_progress_bar(self, steps):
self._totalSteps = steps
self._currentStep = 0
gtk_call_once(self._progressBar.set_fraction, 0.0)
def _step_progress_bar(self):
if not self._totalSteps:
return
self._currentStep += 1
gtk_call_once(self._progressBar.set_fraction, self._currentStep/self._totalSteps)
def _update_progress_message(self, message):
if not self._totalSteps:
return
gtk_call_once(self._progressLabel.set_text, message)
class Hub(GUIObject, common.Hub):
"""A Hub is an overview UI screen. A Hub consists of one or more grids of
configuration options that the user may choose from. Each grid is
provided by a SpokeCategory, and each option is provided by a Spoke.
When the user dives down into a Spoke and is finished interacting with
it, they are returned to the Hub.
Some Spokes are required. The user must interact with all required
Spokes before they are allowed to proceed to the next stage of
installation.
From a layout perspective, a Hub is the entirety of the screen, though
the screen itself can be roughly divided into thirds. The top third is
some basic navigation information (where you are, what you're
installing). The middle third is the grid of Spokes. The bottom third
is an action area providing additional buttons (quit, continue) or
progress information (during package installation).
Installation may consist of multiple chained Hubs, or Hubs with
additional standalone screens either before or after them.
.. inheritance-diagram:: Hub
:parts: 3
"""
handles_autostep = True
_hubs_collection = []
# Should we automatically go to next hub if processing is done and there are no
# spokes on the hub ? The default value is False and Initial Setup will likely
# override it to True in it's hub.
continue_if_empty = False
def __init__(self, data, storage, payload):
"""Create a new Hub instance.
The arguments this base class accepts defines the API that Hubs
have to work with. A Hub does not get free reign over everything
in the anaconda class, as that would be a big mess. Instead, a
Hub may count on the following:
ksdata -- An instance of a pykickstart Handler object. The
Hub uses this to populate its UI with defaults
and to pass results back after it has run.
storage -- An instance of storage.Storage. This is useful for
determining what storage devices are present and how
they are configured.
payload -- An instance of a payload.Payload subclass. This
is useful for displaying and selecting packages to
install, and in carrying out the actual installation.
"""
GUIObject.__init__(self, data)
common.Hub.__init__(self, storage, payload)
# enable the autoContinue feature if we are in kickstart
# mode, but if the user interacts with the hub, it will be
# disabled again
self._autoContinue = flags.automatedInstall
self._hubs_collection.append(self)
self.timeout = None
self._incompleteSpokes = []
self._inSpoke = False
self._notReadySpokes = []
self._spokes = {}
# Used to store the last result of _updateContinue
self._warningMsg = None
self._checker = None
# Flag to indicate the user can continue even if the checker indicates an error.
# The checker itself is left alone so the error message doesn't accidentally get
# cleaered.
self._checker_ignore = False
self._spokesToStepIn = []
self._spokeAutostepIndex = 0
self._gridColumns = 3
def _createBox(self):
import gi
gi.require_version("Gtk", "3.0")
gi.require_version("AnacondaWidgets", "3.3")
from gi.repository import Gtk, AnacondaWidgets
cats_and_spokes = self._collectCategoriesAndSpokes()
categories = cats_and_spokes.keys()
grid = Gtk.Grid(row_spacing=18, column_spacing=18, column_homogeneous=True,
margin_bottom=12, margin_left=12, margin_right=12,
halign=Gtk.Align.CENTER, valign=Gtk.Align.CENTER,
row_homogeneous=True)
max_row = category_row = 0
col = 0
for c in sorted(categories, key=lambda c: c.sortOrder):
obj = c()
selectors = []
for spokeClass in sorted(cats_and_spokes[c], key=lambda s: s.title):
# Check if this spoke is to be shown in the supported environments
if not any(spokeClass.should_run(environ, self.data) for environ in flags.environs):
continue
# Create the new spoke and populate its UI with whatever data.
# From here on, this Spoke will always exist.
spoke = spokeClass(self.data, self.storage, self.payload)
spoke.window.set_beta(self.window.get_beta())
spoke.window.set_property("distribution", distributionText().upper())
# If a spoke is not showable, it is unreachable in the UI. We
# might as well get rid of it.
#
# NOTE: Any kind of spoke can be unshowable.
if not spoke.showable:
del(spoke)
continue
# This allows being able to jump between two spokes without
# having to directly involve the hub.
self._spokes[spokeClass.__name__] = spoke
# If a spoke is indirect, it is reachable but not directly from
# a hub. This is for things like the custom partitioning spoke,
# which you can only get to after going through the initial
# storage configuration spoke.
#
# NOTE: This only makes sense for NormalSpokes. Other kinds
# of spokes do not involve a hub.
if spoke.indirect:
spoke.initialize()
continue
spoke.selector = AnacondaWidgets.SpokeSelector(C_("GUI|Spoke", spoke.title),
spoke.icon)
# Set all selectors to insensitive before initialize runs. The call to
# _updateCompleteness later will take care of setting it straight.
spoke.selector.set_sensitive(False)
spoke.initialize()
if not spoke.ready:
self._notReadySpokes.append(spoke)
# Set some default values on the associated selector that
# affect its display on the hub.
self._updateCompleteness(spoke, update_continue=False)
spoke.selector.connect("button-press-event", self._on_spoke_clicked, spoke)
spoke.selector.connect("key-release-event", self._on_spoke_clicked, spoke)
# If this is a kickstart install, attempt to execute any provided ksdata now.
if flags.automatedInstall and spoke.ready and spoke.changed and \
spoke.visitedSinceApplied:
spoke.execute()
spoke.visitedSinceApplied = False
selectors.append(spoke.selector)
if not selectors:
continue
row = category_row
label = Gtk.Label(label="<span size=\"larger\" weight=\"bold\">%s</span>" % escape_markup(_(obj.title)),
use_markup=True, halign=Gtk.Align.START, valign=Gtk.Align.END,
margin_bottom=6, wrap=True, xalign=0.0)
grid.attach(label, col, category_row, 1, 1)
row += 1
for selector in selectors:
grid.attach(selector, col, row, 1, 1)
row += 1
max_row = max(row, max_row)
col = (col + 1) % self._gridColumns
if col == 0:
category_row = max_row
# initialization of all expected spokes has been started, so notify the controller
hub_controller = lifecycle.get_controller_by_name(self.__class__.__name__)
if hub_controller:
hub_controller.all_modules_added()
else:
log.error("Initialization controller for hub %s expected but missing.", self.__class__.__name__)
spokeArea = self.window.get_spoke_area()
viewport = Gtk.Viewport()
viewport.add(grid)
spokeArea.add(viewport)
self._updateContinue()
def _updateCompleteness(self, spoke, update_continue=True):
spoke.selector.set_sensitive(spoke.sensitive and spoke.ready)
spoke.selector.set_property("status", spoke.status)
spoke.selector.set_tooltip_markup(escape_markup(spoke.status))
spoke.selector.set_incomplete(not spoke.completed and spoke.mandatory)
self._handleCompleteness(spoke, update_continue)
def _handleCompleteness(self, spoke, update_continue=True):
# Add the spoke to the incomplete list if it's now incomplete, and make
# sure it's not on the list if it's now complete. Then show the box if
# it's needed and hide it if it's not.
if not spoke.mandatory or spoke.completed:
if spoke in self._incompleteSpokes:
self._incompleteSpokes.remove(spoke)
log.debug("incomplete spokes: %s", self._incompleteSpokes)
else:
if spoke not in self._incompleteSpokes:
self._incompleteSpokes.append(spoke)
log.debug("incomplete spokes: %s", self._incompleteSpokes)
if update_continue:
self._updateContinue()
def _updateContinue(self):
warning = None
if len(self._incompleteSpokes) == 0:
if self._checker and not self._checker.check():
warning = self._checker.error_message
log.error(self._checker.error_message)
# If this is a kickstart, consider the user to be warned and
# let them continue anyway, manually
if flags.automatedInstall:
self._autoContinue = False
self._checker_ignore = True
else:
warning = _("Please complete items marked with this icon before continuing to the next step.")
# Check that this warning isn't already set to avoid spamming the
# info bar with incomplete spoke messages when the hub starts
if warning != self._warningMsg:
self.clear_info()
self._warningMsg = warning
if warning:
self.set_warning(warning)
self._updateContinueButton()
@property
def continuePossible(self):
return len(self._incompleteSpokes) == 0 and len(self._notReadySpokes) == 0 and (getattr(self._checker, "success", True) or self._checker_ignore)
def _updateContinueButton(self):
self.window.set_may_continue(self.continuePossible)
def _update_spokes(self):
from pyanaconda.ui.communication import hubQ
import queue
q = hubQ.q
if not self._spokes and self.window.get_may_continue() and self.continue_if_empty:
# no spokes, move on
log.debug("no spokes available on %s, continuing automatically", self)
gtk_call_once(self.window.emit, "continue-clicked")
click_continue = False
# Grab all messages that may have appeared since last time this method ran.
while True:
try:
(code, args) = q.get(False)
except queue.Empty:
break
# The first argument to all codes is the name of the spoke we are
# acting on. If no such spoke exists, throw the message away.
spoke = self._spokes.get(args[0], None)
if not spoke or spoke.__class__.__name__ not in self._spokes:
q.task_done()
continue
if code == hubQ.HUB_CODE_NOT_READY:
self._updateCompleteness(spoke)
if spoke not in self._notReadySpokes:
self._notReadySpokes.append(spoke)
self._updateContinueButton()
log.debug("spoke is not ready: %s", spoke)
elif code == hubQ.HUB_CODE_READY:
self._updateCompleteness(spoke)
if spoke in self._notReadySpokes:
self._notReadySpokes.remove(spoke)
self._updateContinueButton()
log.debug("spoke is ready: %s", spoke)
# If this is a real kickstart install (the kind with an input ks file)
# and all spokes are now completed, we should skip ahead to the next
# hub automatically. Take into account the possibility the user is
# viewing a spoke right now, though.
if flags.automatedInstall:
spoke_title = spoke.title.replace("_", "")
# Users might find it helpful to know why a kickstart install
# went interactive. Log that here.
if not spoke.completed and spoke.mandatory:
autoinstall_stopped("User interaction required on spoke %s" % spoke_title)
else:
log.debug("kickstart installation, spoke %s is ready", spoke_title)
# Spokes that were not initially ready got the execute call in
# _createBox skipped. Now that it's become ready, do it. Note
# that we also provide a way to skip this processing (see comments
# communication.py) to prevent getting caught in a loop.
if not args[1] and spoke.changed and spoke.visitedSinceApplied:
log.debug("execute spoke from event loop %s", spoke.title.replace("_", ""))
spoke.execute()
spoke.visitedSinceApplied = False
if self.continuePossible:
if self._inSpoke:
self._autoContinue = False
elif self._autoContinue:
click_continue = True
elif code == hubQ.HUB_CODE_MESSAGE:
spoke.selector.set_property("status", args[1])
log.debug("setting %s status to: %s", spoke, args[1])
q.task_done()
# queue is now empty, should continue be clicked?
if self._autoContinue and click_continue and self.window.get_may_continue():
# enqueue the emit to the Gtk message queue
log.debug("_autoContinue clicking continue button")
gtk_call_once(self.window.emit, "continue-clicked")
return True
def refresh(self):
GUIObject.refresh(self)
self._createBox()
for hub in Hub._hubs_collection:
if hub.timeout is not None:
log.debug("Disabling event loop for hub %s", hub.__class__.__name__)
hub.timeout.cancel()
hub.timeout = None
log.debug("Starting event loop for hub %s", self.__class__.__name__)
self.timeout = Timer()
self.timeout.timeout_msec(100, self._update_spokes)
### SIGNAL HANDLERS
def _on_spoke_clicked(self, selector, event, spoke):
import gi
gi.require_version("Gdk", "3.0")
from gi.repository import Gdk
# This handler only runs for these two kinds of events, and only for
# activate-type keys (space, enter) in the latter event's case.
if event and not event.type in [Gdk.EventType.BUTTON_PRESS, Gdk.EventType.KEY_RELEASE]:
return
if event and event.type == Gdk.EventType.KEY_RELEASE and \
event.keyval not in [Gdk.KEY_space, Gdk.KEY_Return, Gdk.KEY_ISO_Enter, Gdk.KEY_KP_Enter, Gdk.KEY_KP_Space]:
return
if selector:
selector.grab_focus()
# On automated kickstart installs, our desired behavior is to display
# the hub while background processes work, then skip to the progress
# hub immediately after everything's done.
# However if the user proves his intent to change the kickstarted
# values by entering any of the spokes, we need to disable the
# autoContinue feature and wait for the user to explicitly state
# that he is done configuring by pressing the continue button.
self._autoContinue = False
# Enter the spoke
self._inSpoke = True
spoke.refresh()
self.main_window.enterSpoke(spoke)
# the new spoke should be now visible, trigger the entered signal
spoke.entered.emit(spoke)
def spoke_done(self, spoke):
# Ignore if not in a spoke
if not self._inSpoke:
return
spoke.visitedSinceApplied = True
# don't apply any actions if the spoke was visited automatically
if spoke.automaticEntry:
spoke.automaticEntry = False
return
# Don't take visitedSinceApplied into account here. It will always be
# True from the line above.
if spoke.changed and (not spoke.skipTo or (spoke.skipTo and spoke.applyOnSkip)):
spoke.apply()
spoke.execute()
spoke.visitedSinceApplied = False
spoke.exited.emit(spoke)
self._inSpoke = False
# Now update the selector with the current status and completeness.
for sp in self._spokes.values():
if not sp.indirect:
self._updateCompleteness(sp, update_continue=False)
self._updateContinue()
# And then if that spoke wants us to jump straight to another one,
# handle that now.
if spoke.skipTo and spoke.skipTo in self._spokes:
dest = spoke.skipTo
# Clear out the skipTo setting so we don't cycle endlessly.
spoke.skipTo = None
self._on_spoke_clicked(self._spokes[dest].selector, None, self._spokes[dest])
# Otherwise, switch back to the hub (that's us!)
else:
self.main_window.returnToHub()
def _doAutostep(self):
"""Autostep through all spokes managed by this hub"""
log.info("autostepping through all spokes on hub %s", self.__class__.__name__)
# create a list of all spokes in reverse alphabetic order, we will pop() from it when
# processing all the spokes so the screenshots will actually be in alphabetic order
self._spokesToStepIn = list(reversed(sorted(self._spokes.values(), key=lambda x: x.__class__.__name__)))
# we can't just loop over all the spokes due to the asynchronous nature of GtkStack, so we start by
# autostepping to the first spoke, this will trigger a callback that steps to the next spoke,
# until we run out of unvisited spokes
self._autostepSpoke()
def _autostepSpoke(self):
"""Process a single spoke, if no more spokes are available report autostep as finished for the hub."""
# do we have some spokes to work on ?
if self._spokesToStepIn:
# take one of them
spoke = self._spokesToStepIn.pop()
# increment the number of processed spokes
self._spokeAutostepIndex += 1
log.debug("stepping to spoke %s (%d/%d)", spoke.__class__.__name__, self._spokeAutostepIndex, len(self._spokes))
# notify the spoke about the upcoming automatic entry and set a callback that will be called
# once the spoke has been successfully processed
spoke.automaticEntry = True
spoke.autostepDoneCallback = lambda x: self._autostepSpoke()
# if this is the last spoke, tell it to return to hub once processed
if self._spokesToStepIn == []:
spoke.lastAutostepSpoke = True
gtk_call_once(self._on_spoke_clicked, None, None, spoke)
else:
log.info("autostep for hub %s finished", self.__class__.__name__)
gtk_call_once(self._doPostAutostep)
def _doPostAutostep(self):
if self._spokesToStepIn:
# there are still spokes that need to be stepped in
return
# we are done, re-emit the continue clicked signal we "consumed" previously
# so that the Anaconda GUI can switch to the next screen (or quit)
self.window.emit("continue-clicked")
