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 _stop_and_maybe_start_time_updating(self, interval=2):
"""
This method is called in every date/time-setting button's callback.
It removes the timer for updating displayed date/time (do not want to
change it while user does it manually) and allows us to set new system
date/time only after $interval seconds long idle on time-setting buttons.
This is done by the _start_updating_timer that is reset in this method.
So when there is $interval seconds long idle on date/time-setting
buttons, self._save_system_time method is invoked. Since it returns
False, this timer is then removed and only reactivated in this method
(thus in some date/time-setting button's callback).
"""
#do not start timers if the spoke is not shown
if not self._shown:
self._update_datetime()
self._save_system_time()
return
#stop time updating
if self._update_datetime_timer:
self._update_datetime_timer.cancel()
self._update_datetime_timer = None
#stop previous $interval seconds timer (see below)
if self._start_updating_timer:
self._start_updating_timer.cancel()
#let the user change date/time and after $interval seconds of inactivity
#save it as the system time and start updating the displayed date/time
self._start_updating_timer = Timer()
self._start_updating_timer.timeout_sec(interval, self._save_system_time)
def refresh(self):
self._shown = True
# update the displayed time
self._update_datetime_timer = Timer()
self._update_datetime_timer.timeout_sec(1, self._update_datetime)
self._start_updating_timer = None
kickstart_timezone = self._timezone_module.proxy.Timezone
if is_valid_timezone(kickstart_timezone):
self._tzmap.set_timezone(kickstart_timezone)
time.tzset()
self._update_datetime()
has_active_network = self._network_module.proxy.Connected
if not has_active_network:
self._show_no_network_warning()
else:
self.clear_info()
gtk_call_once(self._config_dialog.refresh_servers_state)
if conf.system.can_set_time_synchronization:
ntp_working = has_active_network and util.service_running(NTP_SERVICE)
else:
ntp_working = self._timezone_module.proxy.NTPEnabled
self._ntpSwitch.set_active(ntp_working)
def __init__(self, data, storage):
super().__init__(data)
self.storage = storage
self._notebook = self.builder.get_object("refreshNotebook")
self._cancel_button = self.builder.get_object("refreshCancelButton")
self._ok_button = self.builder.get_object("refreshOKButton")
self._elapsed = 0
self._rescan_timer = Timer()
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)
def _save_system_time(self):
"""
Returning False from this method removes the timer that would
otherwise call it again and again.
"""
self._start_updating_timer = None
if not conf.system.can_set_system_clock:
return False
month = self._get_combo_selection(self._monthCombo)[0]
if not month:
return False
year = self._get_combo_selection(self._yearCombo)[0]
if not year:
return False
hours = int(self._hoursLabel.get_text())
if not self._radioButton24h.get_active():
hours = self._to_24h(hours, self._amPmLabel.get_text())
minutes = int(self._minutesLabel.get_text())
day = self._get_combo_selection(self._dayCombo)[0]
#day may be None if there is no such in the selected year and month
if day:
isys.set_system_date_time(year, month, day, hours, minutes, tz=self._tz)
#start the timer only when the spoke is shown
if self._shown and not self._update_datetime_timer:
self._update_datetime_timer = Timer()
self._update_datetime_timer.timeout_sec(1, self._update_datetime)
#run only once (after first 2 seconds of inactivity)
return False
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
"""
_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 auto continue feature if we are in kickstart
# mode, but if the user interacts with the hub, it will be
# disabled again
self._auto_continue = flags.automatedInstall
self._click_continue = False
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._gridColumns = 3
def _createBox(self):
"""Create and fill the list of categories and spokes."""
import gi
gi.require_version("Gtk", "3.0")
gi.require_version("AnacondaWidgets", "3.4")
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)
col = 0
row_in_column = [-1] * self._gridColumns
for category in common.sort_categories(categories):
selectors = []
for spokeClass in sorted(cats_and_spokes[category], 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())
# 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)
selectors.append(spoke.selector)
if not selectors:
continue
# category handling
# excape unwanted markup
cat_title = escape_markup(category.get_title())
# generate pango markup
cat_label = '<span size="larger" weight="bold">{}</span>'.format(cat_title)
# setup the category label
label = Gtk.Label(label=cat_label,
use_markup=True, halign=Gtk.Align.START, valign=Gtk.Align.END,
margin_bottom=6, wrap=True, xalign=0.0)
grid.attach(label, col, row_in_column[col], 1, 1)
row_in_column[col] += 1
for selector in selectors:
grid.attach(selector, col, row_in_column[col], 1, 1)
row_in_column[col] += 1
col = (col + 1) % self._gridColumns
# 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 _get_warning(self):
"""Get the warning message for the hub."""
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._auto_continue = False
self._checker_ignore = True
else:
warning = _("Please complete items marked with this icon before continuing to the next step.")
return warning
def _updateContinue(self):
# Check that this warning isn't already set to avoid spamming the
# info bar with incomplete spoke messages when the hub starts
warning = self._get_warning()
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")
# 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)
if self.continuePossible:
if self._inSpoke:
self._auto_continue = False
elif self._auto_continue:
self._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._auto_continue and self._click_continue and self.window.get_may_continue():
# don't update spokes anymore
self.timeout.cancel()
# enqueue the emit to the Gtk message queue
log.debug("automatically 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 event.type not 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()
# The automated kickstart installation already continues. Nothing to do.
if self._click_continue:
return
# 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
# auto continue feature and wait for the user to explicitly state
# that he is done configuring by pressing the continue button.
self._auto_continue = 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
if spoke.changed and (not spoke.skipTo or (spoke.skipTo and spoke.applyOnSkip)):
spoke.apply()
spoke.execute()
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 stop(self):
"""Stop the loop."""
DBus.disconnect()
Timer().timeout_sec(1, self.loop.quit)
class DatetimeSpoke(FirstbootSpokeMixIn, NormalSpoke):
"""
.. inheritance-diagram:: DatetimeSpoke
:parts: 3
"""
builderObjects = [
"datetimeWindow",
"days",
"months",
"years",
"regions",
"cities",
"upImage",
"upImage1",
"upImage2",
"downImage",
"downImage1",
"downImage2",
"downImage3",
"configImage",
"citiesFilter",
"daysFilter",
"cityCompletion",
"regionCompletion",
]
mainWidgetName = "datetimeWindow"
uiFile = "spokes/datetime_spoke.glade"
helpFile = "DateTimeSpoke.xml"
category = LocalizationCategory
icon = "preferences-system-time-symbolic"
title = CN_("GUI|Spoke", "_TIME & DATE")
# Hack to get libtimezonemap loaded for GtkBuilder
# see https://bugzilla.gnome.org/show_bug.cgi?id=712184
_hack = TimezoneMap.TimezoneMap()
del (_hack)
def __init__(self, *args):
NormalSpoke.__init__(self, *args)
# taking values from the kickstart file?
self._kickstarted = flags.flags.automatedInstall
self._update_datetime_timer = None
self._start_updating_timer = None
self._shown = False
self._tz = None
self._timezone_module = TIMEZONE.get_observer()
self._timezone_module.connect()
def initialize(self):
NormalSpoke.initialize(self)
self.initialize_start()
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")
self._dateBox = self.builder.get_object("dateBox")
# 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._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._amPmRevealer = self.builder.get_object("amPmRevealer")
# Set the entry completions.
# The text_column property needs to be set here. If we set
# it in the glade file, the completion doesn't show text.
region_completion = self.builder.get_object("regionCompletion")
region_completion.set_text_column(0)
city_completion = self.builder.get_object("cityCompletion")
city_completion.set_text_column(0)
# create widgets for displaying/configuring date
day_box, self._dayCombo, day_label = _new_date_field_box(
self._daysFilter)
self._dayCombo.connect("changed", self.on_day_changed)
month_box, self._monthCombo, month_label = _new_date_field_box(
self._monthsStore)
self._monthCombo.connect("changed", self.on_month_changed)
year_box, self._yearCombo, year_label = _new_date_field_box(
self._yearsStore)
self._yearCombo.connect("changed", self.on_year_changed)
# get the right order for date widgets and respective formats and put
# widgets in place
widgets, formats = resolve_date_format(year_box, month_box, day_box)
for widget in widgets:
self._dateBox.pack_start(widget, False, False, 0)
self._day_format, suffix = formats[widgets.index(day_box)]
day_label.set_text(suffix)
self._month_format, suffix = formats[widgets.index(month_box)]
month_label.set_text(suffix)
self._year_format, suffix = formats[widgets.index(year_box)]
year_label.set_text(suffix)
self._ntpSwitch = self.builder.get_object("networkTimeSwitch")
self._regions_zones = get_all_regions_and_timezones()
# 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._timezone_module)
self._config_dialog.initialize()
threadMgr.add(
AnacondaThread(name=constants.THREAD_DATE_TIME,
target=self._initialize))
def _initialize(self):
# a bit hacky way, but should return the translated strings
for i in range(1, 32):
day = datetime.date(2000, 1, i).strftime(self._day_format)
self.add_to_store_idx(self._daysStore, i, day)
for i in range(1, 13):
month = datetime.date(2000, i, 1).strftime(self._month_format)
self.add_to_store_idx(self._monthsStore, i, month)
for i in range(1990, 2051):
year = datetime.date(i, 1, 1).strftime(self._year_format)
self.add_to_store_idx(self._yearsStore, i, year)
cities = set()
xlated_regions = ((region, get_xlated_timezone(region))
for region in self._regions_zones.keys())
for region, xlated in sorted(
xlated_regions, key=functools.cmp_to_key(_compare_regions)):
self.add_to_store_xlated(self._regionsStore, region, xlated)
for city in self._regions_zones[region]:
cities.add((city, get_xlated_timezone(city)))
for city, xlated in sorted(cities,
key=functools.cmp_to_key(_compare_cities)):
self.add_to_store_xlated(self._citiesStore, city, xlated)
self._update_datetime_timer = None
kickstart_timezone = self._timezone_module.proxy.Timezone
if is_valid_timezone(kickstart_timezone):
self._set_timezone(kickstart_timezone)
elif not flags.flags.automatedInstall:
log.warning(
"%s is not a valid timezone, falling back to default (%s)",
kickstart_timezone, DEFAULT_TZ)
self._set_timezone(DEFAULT_TZ)
self._timezone_module.proxy.SetTimezone(DEFAULT_TZ)
time_init_thread = threadMgr.get(constants.THREAD_TIME_INIT)
if time_init_thread is not None:
hubQ.send_message(self.__class__.__name__,
_("Restoring hardware time..."))
threadMgr.wait(constants.THREAD_TIME_INIT)
hubQ.send_ready(self.__class__.__name__, False)
# report that we are done
self.initialize_done()
@property
def status(self):
kickstart_timezone = self._timezone_module.proxy.Timezone
if kickstart_timezone:
if is_valid_timezone(kickstart_timezone):
return _("%s timezone") % get_xlated_timezone(
kickstart_timezone)
else:
return _("Invalid timezone")
else:
location = self._tzmap.get_location()
if location and location.get_property("zone"):
return _("%s timezone") % get_xlated_timezone(
location.get_property("zone"))
else:
return _("Nothing selected")
def apply(self):
self._shown = False
# we could use self._tzmap.get_timezone() here, but it returns "" if
# Etc/XXXXXX timezone is selected
region = self._get_active_region()
city = self._get_active_city()
# nothing selected, just leave the spoke and
# return to hub without changing anything
if not region or not city:
return
old_tz = self._timezone_module.proxy.Timezone
new_tz = region + "/" + city
self._timezone_module.proxy.SetTimezone(new_tz)
if old_tz != new_tz:
# new values, not from kickstart
# TODO: seen should be set from the module
self._kickstarted = False
self._timezone_module.proxy.SetNTPEnabled(self._ntpSwitch.get_active())
def execute(self):
if self._update_datetime_timer is not None:
self._update_datetime_timer.cancel()
self._update_datetime_timer = None
@property
def ready(self):
return not threadMgr.get("AnaDateTimeThread")
@property
def completed(self):
if self._kickstarted and not self._timezone_module.proxy.Kickstarted:
# taking values from kickstart, but not specified
return False
else:
return is_valid_timezone(self._timezone_module.proxy.Timezone)
@property
def mandatory(self):
return True
def refresh(self):
self._shown = True
# update the displayed time
self._update_datetime_timer = Timer()
self._update_datetime_timer.timeout_sec(1, self._update_datetime)
self._start_updating_timer = None
kickstart_timezone = self._timezone_module.proxy.Timezone
if is_valid_timezone(kickstart_timezone):
self._tzmap.set_timezone(kickstart_timezone)
time.tzset()
self._update_datetime()
has_active_network = nm.nm_is_connected()
if not has_active_network:
self._show_no_network_warning()
else:
self.clear_info()
gtk_call_once(self._config_dialog.refresh_servers_state)
if flags.can_touch_runtime_system("get NTP service state"):
ntp_working = has_active_network and util.service_running(
NTP_SERVICE)
else:
ntp_working = self._timezone_module.proxy.NTPEnabled
self._ntpSwitch.set_active(ntp_working)
@async_action_wait
def _set_timezone(self, timezone):
"""
Sets timezone to the city/region comboboxes and the timezone map.
:param timezone: timezone to set
:type timezone: str
:return: if successfully set or not
:rtype: bool
"""
parts = timezone.split("/", 1)
if len(parts) != 2:
# invalid timezone cannot be set
return False
region, city = parts
self._set_combo_selection(self._regionCombo, region)
self._set_combo_selection(self._cityCombo, city)
return True
@async_action_nowait
def add_to_store_xlated(self, store, item, xlated):
store.append([item, xlated])
@async_action_nowait
def add_to_store_idx(self, store, idx, item):
store.append([idx, item])
def existing_date(self, days_model, days_iter, user_data=None):
if not days_iter:
return False
day = days_model[days_iter][0]
#days 1-28 are in every month every year
if day < 29:
return True
months_model = self._monthCombo.get_model()
months_iter = self._monthCombo.get_active_iter()
if not months_iter:
return True
years_model = self._yearCombo.get_model()
years_iter = self._yearCombo.get_active_iter()
if not years_iter:
return True
try:
datetime.date(years_model[years_iter][0],
months_model[months_iter][0], day)
return True
except ValueError:
return False
def _get_active_city(self):
cities_model = self._cityCombo.get_model()
cities_iter = self._cityCombo.get_active_iter()
if not cities_iter:
return None
return cities_model[cities_iter][0]
def _get_active_region(self):
regions_model = self._regionCombo.get_model()
regions_iter = self._regionCombo.get_active_iter()
if not regions_iter:
return None
return regions_model[regions_iter][0]
def city_in_region(self, model, itr, user_data=None):
if not itr:
return False
city = model[itr][0]
region = self._get_active_region()
if not region:
return False
return city in self._regions_zones[region]
def _set_amPm_part_sensitive(self, sensitive):
for widget in (self._amPmUp, self._amPmDown, self._amPmLabel):
widget.set_sensitive(sensitive)
def _to_amPm(self, hours):
if hours >= 12:
day_phase = _("PM")
else:
day_phase = _("AM")
new_hours = ((hours - 1) % 12) + 1
return (new_hours, day_phase)
def _to_24h(self, hours, day_phase):
correction = 0
if day_phase == _("AM") and hours == 12:
correction = -12
elif day_phase == _("PM") and hours != 12:
correction = 12
return (hours + correction) % 24
def _update_datetime(self):
now = datetime.datetime.now(self._tz)
if self._radioButton24h.get_active():
self._hoursLabel.set_text("%0.2d" % now.hour)
else:
hours, amPm = self._to_amPm(now.hour)
self._hoursLabel.set_text("%0.2d" % hours)
self._amPmLabel.set_text(amPm)
self._minutesLabel.set_text("%0.2d" % now.minute)
self._set_combo_selection(self._dayCombo, now.day)
self._set_combo_selection(self._monthCombo, now.month)
self._set_combo_selection(self._yearCombo, now.year)
#GLib's timer is driven by the return value of the function.
#It runs the fuction periodically while the returned value
#is True.
return True
def _save_system_time(self):
"""
Returning False from this method removes the timer that would
otherwise call it again and again.
"""
self._start_updating_timer = None
if not flags.can_touch_runtime_system("save system time"):
return False
month = self._get_combo_selection(self._monthCombo)[0]
if not month:
return False
year = self._get_combo_selection(self._yearCombo)[0]
if not year:
return False
hours = int(self._hoursLabel.get_text())
if not self._radioButton24h.get_active():
hours = self._to_24h(hours, self._amPmLabel.get_text())
minutes = int(self._minutesLabel.get_text())
day = self._get_combo_selection(self._dayCombo)[0]
#day may be None if there is no such in the selected year and month
if day:
isys.set_system_date_time(year,
month,
day,
hours,
minutes,
tz=self._tz)
#start the timer only when the spoke is shown
if self._shown and not self._update_datetime_timer:
self._update_datetime_timer = Timer()
self._update_datetime_timer.timeout_sec(1, self._update_datetime)
#run only once (after first 2 seconds of inactivity)
return False
def _stop_and_maybe_start_time_updating(self, interval=2):
"""
This method is called in every date/time-setting button's callback.
It removes the timer for updating displayed date/time (do not want to
change it while user does it manually) and allows us to set new system
date/time only after $interval seconds long idle on time-setting buttons.
This is done by the _start_updating_timer that is reset in this method.
So when there is $interval seconds long idle on date/time-setting
buttons, self._save_system_time method is invoked. Since it returns
False, this timer is then removed and only reactivated in this method
(thus in some date/time-setting button's callback).
"""
#do not start timers if the spoke is not shown
if not self._shown:
self._update_datetime()
self._save_system_time()
return
#stop time updating
if self._update_datetime_timer:
self._update_datetime_timer.cancel()
self._update_datetime_timer = None
#stop previous $interval seconds timer (see below)
if self._start_updating_timer:
self._start_updating_timer.cancel()
#let the user change date/time and after $interval seconds of inactivity
#save it as the system time and start updating the displayed date/time
self._start_updating_timer = Timer()
self._start_updating_timer.timeout_sec(interval,
self._save_system_time)
def _set_combo_selection(self, combo, item):
model = combo.get_model()
if not model:
return False
itr = model.get_iter_first()
while itr:
if model[itr][0] == item:
combo.set_active_iter(itr)
return True
itr = model.iter_next(itr)
return False
def _get_combo_selection(self, combo):
"""
Get the selected item of the combobox.
:return: selected item or None
"""
model = combo.get_model()
itr = combo.get_active_iter()
if not itr or not model:
return None, None
return model[itr][0], model[itr][1]
def _restore_old_city_region(self):
"""Restore stored "old" (or last valid) values."""
# check if there are old values to go back to
if self._old_region and self._old_city:
self._set_timezone(self._old_region + "/" + self._old_city)
def on_up_hours_clicked(self, *args):
self._stop_and_maybe_start_time_updating()
hours = int(self._hoursLabel.get_text())
if self._radioButton24h.get_active():
new_hours = (hours + 1) % 24
else:
amPm = self._amPmLabel.get_text()
#let's not deal with magical AM/PM arithmetics
new_hours = self._to_24h(hours, amPm)
new_hours, new_amPm = self._to_amPm((new_hours + 1) % 24)
self._amPmLabel.set_text(new_amPm)
new_hours_str = "%0.2d" % new_hours
self._hoursLabel.set_text(new_hours_str)
def on_down_hours_clicked(self, *args):
self._stop_and_maybe_start_time_updating()
hours = int(self._hoursLabel.get_text())
if self._radioButton24h.get_active():
new_hours = (hours - 1) % 24
else:
amPm = self._amPmLabel.get_text()
#let's not deal with magical AM/PM arithmetics
new_hours = self._to_24h(hours, amPm)
new_hours, new_amPm = self._to_amPm((new_hours - 1) % 24)
self._amPmLabel.set_text(new_amPm)
new_hours_str = "%0.2d" % new_hours
self._hoursLabel.set_text(new_hours_str)
def on_up_minutes_clicked(self, *args):
self._stop_and_maybe_start_time_updating()
minutes = int(self._minutesLabel.get_text())
minutes_str = "%0.2d" % ((minutes + 1) % 60)
self._minutesLabel.set_text(minutes_str)
def on_down_minutes_clicked(self, *args):
self._stop_and_maybe_start_time_updating()
minutes = int(self._minutesLabel.get_text())
minutes_str = "%0.2d" % ((minutes - 1) % 60)
self._minutesLabel.set_text(minutes_str)
def on_updown_ampm_clicked(self, *args):
self._stop_and_maybe_start_time_updating()
if self._amPmLabel.get_text() == _("AM"):
self._amPmLabel.set_text(_("PM"))
else:
self._amPmLabel.set_text(_("AM"))
def on_region_changed(self, combo, *args):
"""
:see: on_city_changed
"""
region = self._get_active_region()
if not region or region == self._old_region:
# region entry being edited or old_value chosen, no action needed
# @see: on_city_changed
return
self._citiesFilter.refilter()
# Set the city to the first one available in this newly selected region.
zone = self._regions_zones[region]
firstCity = sorted(list(zone))[0]
self._set_combo_selection(self._cityCombo, firstCity)
self._old_region = region
self._old_city = firstCity
def on_city_changed(self, combo, *args):
"""
ComboBox emits ::changed signal not only when something is selected, but
also when its entry's text is changed. We need to distinguish between
those two cases ('London' typed in the entry => no action until ENTER is
hit etc.; 'London' chosen in the expanded combobox => update timezone
map and do all necessary actions). Fortunately when entry is being
edited, self._get_active_city returns None.
"""
timezone = None
region = self._get_active_region()
city = self._get_active_city()
if not region or not city or (region == self._old_region
and city == self._old_city):
# entry being edited or no change, no actions needed
return
if city and region:
timezone = region + "/" + city
else:
# both city and region are needed to form a valid timezone
return
if region == "Etc":
# Etc timezones cannot be displayed on the map, so let's reset the
# location and manually set a highlight with no location pin.
self._tzmap.clear_location()
if city in ("GMT", "UTC"):
offset = 0.0
# The tzdb data uses POSIX-style signs for the GMT zones, which is
# the opposite of whatever everyone else expects. GMT+4 indicates a
# zone four hours west of Greenwich; i.e., four hours before. Reverse
# the sign to match the libtimezone map.
else:
# Take the part after "GMT"
offset = -float(city[3:])
self._tzmap.set_selected_offset(offset)
time.tzset()
else:
# we don't want the timezone-changed signal to be emitted
self._tzmap.set_timezone(timezone)
time.tzset()
# update "old" values
self._old_city = city
def on_entry_left(self, entry, *args):
# user clicked somewhere else or hit TAB => finished editing
entry.emit("activate")
def on_city_region_key_released(self, entry, event, *args):
if event.type == Gdk.EventType.KEY_RELEASE and \
event.keyval == Gdk.KEY_Escape:
# editing canceled
self._restore_old_city_region()
def on_completion_match_selected(self, combo, model, itr):
item = None
if model and itr:
item = model[itr][0]
if item:
self._set_combo_selection(combo, item)
def on_city_region_text_entry_activated(self, entry):
combo = entry.get_parent()
# It's gotta be up there somewhere, right? right???
while not isinstance(combo, Gtk.ComboBox):
combo = combo.get_parent()
model = combo.get_model()
entry_text = entry.get_text().lower()
for row in model:
if entry_text == row[0].lower():
self._set_combo_selection(combo, row[0])
return
# non-matching value entered, reset to old values
self._restore_old_city_region()
def on_month_changed(self, *args):
self._stop_and_maybe_start_time_updating(interval=5)
self._daysFilter.refilter()
def on_day_changed(self, *args):
self._stop_and_maybe_start_time_updating(interval=5)
def on_year_changed(self, *args):
self._stop_and_maybe_start_time_updating(interval=5)
self._daysFilter.refilter()
def on_location_changed(self, tz_map, location):
if not location:
return
timezone = location.get_property('zone')
# Updating the timezone will update the region/city combo boxes to match.
# The on_city_changed handler will attempt to convert the timezone back
# to a location and set it in the map, which we don't want, since we
# already have a location. That's why we're here.
with blockedHandler(self._cityCombo, self.on_city_changed):
if self._set_timezone(timezone):
# timezone successfully set
self._tz = get_timezone(timezone)
self._update_datetime()
def on_timeformat_changed(self, button24h, *args):
hours = int(self._hoursLabel.get_text())
amPm = self._amPmLabel.get_text()
#connected to 24-hour radio button
if button24h.get_active():
self._set_amPm_part_sensitive(False)
new_hours = self._to_24h(hours, amPm)
self._amPmRevealer.set_reveal_child(False)
else:
self._set_amPm_part_sensitive(True)
new_hours, new_amPm = self._to_amPm(hours)
self._amPmLabel.set_text(new_amPm)
self._amPmRevealer.set_reveal_child(True)
self._hoursLabel.set_text("%0.2d" % new_hours)
def _set_date_time_setting_sensitive(self, sensitive):
#contains all date/time setting widgets
footer_alignment = self.builder.get_object("footerAlignment")
footer_alignment.set_sensitive(sensitive)
def _show_no_network_warning(self):
self.set_warning(_("You need to set up networking first if you "\
"want to use NTP"))
def _show_no_ntp_server_warning(self):
self.set_warning(_("You have no working NTP server configured"))
def on_ntp_switched(self, switch, *args):
if switch.get_active():
#turned ON
if not flags.can_touch_runtime_system("start NTP service"):
#cannot touch runtime system, not much to do here
return
if not nm.nm_is_connected():
self._show_no_network_warning()
switch.set_active(False)
return
else:
self.clear_info()
working_server = self._config_dialog.working_server
if working_server is None:
self._show_no_ntp_server_warning()
else:
#we need a one-time sync here, because chronyd would not change
#the time as drastically as we need
ntp.one_time_sync_async(working_server)
ret = util.start_service(NTP_SERVICE)
self._set_date_time_setting_sensitive(False)
#if starting chronyd failed and chronyd is not running,
#set switch back to OFF
if (ret != 0) and not util.service_running(NTP_SERVICE):
switch.set_active(False)
else:
#turned OFF
if not flags.can_touch_runtime_system("stop NTP service"):
#cannot touch runtime system, nothing to do here
return
self._set_date_time_setting_sensitive(True)
ret = util.stop_service(NTP_SERVICE)
#if stopping chronyd failed and chronyd is running,
#set switch back to ON
if (ret != 0) and util.service_running(NTP_SERVICE):
switch.set_active(True)
self.clear_info()
def on_ntp_config_clicked(self, *args):
self._config_dialog.refresh()
with self.main_window.enlightbox(self._config_dialog.window):
response = self._config_dialog.run()
if response == 1:
pools, servers = self._config_dialog.pools_servers
self._timezone_module.proxy.SetNTPServers(
ntp.pools_servers_to_internal(pools, servers))
if self._config_dialog.working_server is None:
self._show_no_ntp_server_warning()
else:
self.clear_info()
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 DatetimeSpoke(FirstbootSpokeMixIn, NormalSpoke):
"""
.. inheritance-diagram:: DatetimeSpoke
:parts: 3
"""
builderObjects = ["datetimeWindow",
"days", "months", "years", "regions", "cities",
"upImage", "upImage1", "upImage2", "downImage",
"downImage1", "downImage2", "downImage3", "configImage",
"citiesFilter", "daysFilter",
"cityCompletion", "regionCompletion",
]
mainWidgetName = "datetimeWindow"
uiFile = "spokes/datetime_spoke.glade"
helpFile = "DateTimeSpoke.xml"
category = LocalizationCategory
icon = "preferences-system-time-symbolic"
title = CN_("GUI|Spoke", "_Time & Date")
# Hack to get libtimezonemap loaded for GtkBuilder
# see https://bugzilla.gnome.org/show_bug.cgi?id=712184
_hack = TimezoneMap.TimezoneMap()
del(_hack)
def __init__(self, *args):
NormalSpoke.__init__(self, *args)
# taking values from the kickstart file?
self._kickstarted = flags.flags.automatedInstall
self._update_datetime_timer = None
self._start_updating_timer = None
self._shown = False
self._tz = None
self._timezone_module = TIMEZONE.get_observer()
self._timezone_module.connect()
self._network_module = NETWORK.get_observer()
self._network_module.connect()
def initialize(self):
NormalSpoke.initialize(self)
self.initialize_start()
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")
self._dateBox = self.builder.get_object("dateBox")
# 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._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._amPmRevealer = self.builder.get_object("amPmRevealer")
# Set the entry completions.
# The text_column property needs to be set here. If we set
# it in the glade file, the completion doesn't show text.
region_completion = self.builder.get_object("regionCompletion")
region_completion.set_text_column(0)
city_completion = self.builder.get_object("cityCompletion")
city_completion.set_text_column(0)
# create widgets for displaying/configuring date
day_box, self._dayCombo, day_label = _new_date_field_box(self._daysFilter)
self._dayCombo.connect("changed", self.on_day_changed)
month_box, self._monthCombo, month_label = _new_date_field_box(self._monthsStore)
self._monthCombo.connect("changed", self.on_month_changed)
year_box, self._yearCombo, year_label = _new_date_field_box(self._yearsStore)
self._yearCombo.connect("changed", self.on_year_changed)
# get the right order for date widgets and respective formats and put
# widgets in place
widgets, formats = resolve_date_format(year_box, month_box, day_box)
for widget in widgets:
self._dateBox.pack_start(widget, False, False, 0)
self._day_format, suffix = formats[widgets.index(day_box)]
day_label.set_text(suffix)
self._month_format, suffix = formats[widgets.index(month_box)]
month_label.set_text(suffix)
self._year_format, suffix = formats[widgets.index(year_box)]
year_label.set_text(suffix)
self._ntpSwitch = self.builder.get_object("networkTimeSwitch")
self._regions_zones = get_all_regions_and_timezones()
# Set the initial sensitivity of the AM/PM toggle based on the time-type selected
self._radioButton24h.emit("toggled")
if not conf.system.can_set_system_clock:
self._set_date_time_setting_sensitive(False)
self._config_dialog = NTPconfigDialog(self.data, self._timezone_module)
self._config_dialog.initialize()
threadMgr.add(AnacondaThread(name=constants.THREAD_DATE_TIME,
target=self._initialize))
def _initialize(self):
# a bit hacky way, but should return the translated strings
for i in range(1, 32):
day = datetime.date(2000, 1, i).strftime(self._day_format)
self.add_to_store_idx(self._daysStore, i, day)
for i in range(1, 13):
month = datetime.date(2000, i, 1).strftime(self._month_format)
self.add_to_store_idx(self._monthsStore, i, month)
for i in range(1990, 2051):
year = datetime.date(i, 1, 1).strftime(self._year_format)
self.add_to_store_idx(self._yearsStore, i, year)
cities = set()
xlated_regions = ((region, get_xlated_timezone(region))
for region in self._regions_zones.keys())
for region, xlated in sorted(xlated_regions, key=functools.cmp_to_key(_compare_regions)):
self.add_to_store_xlated(self._regionsStore, region, xlated)
for city in self._regions_zones[region]:
cities.add((city, get_xlated_timezone(city)))
for city, xlated in sorted(cities, key=functools.cmp_to_key(_compare_cities)):
self.add_to_store_xlated(self._citiesStore, city, xlated)
self._update_datetime_timer = None
kickstart_timezone = self._timezone_module.proxy.Timezone
if is_valid_timezone(kickstart_timezone):
self._set_timezone(kickstart_timezone)
elif not flags.flags.automatedInstall:
log.warning("%s is not a valid timezone, falling back to default (%s)",
kickstart_timezone, DEFAULT_TZ)
self._set_timezone(DEFAULT_TZ)
self._timezone_module.proxy.SetTimezone(DEFAULT_TZ)
time_init_thread = threadMgr.get(constants.THREAD_TIME_INIT)
if time_init_thread is not None:
hubQ.send_message(self.__class__.__name__,
_("Restoring hardware time..."))
threadMgr.wait(constants.THREAD_TIME_INIT)
hubQ.send_ready(self.__class__.__name__, False)
# report that we are done
self.initialize_done()
@property
def status(self):
kickstart_timezone = self._timezone_module.proxy.Timezone
if kickstart_timezone:
if is_valid_timezone(kickstart_timezone):
return _("%s timezone") % get_xlated_timezone(kickstart_timezone)
else:
return _("Invalid timezone")
else:
location = self._tzmap.get_location()
if location and location.get_property("zone"):
return _("%s timezone") % get_xlated_timezone(location.get_property("zone"))
else:
return _("Nothing selected")
def apply(self):
self._shown = False
# we could use self._tzmap.get_timezone() here, but it returns "" if
# Etc/XXXXXX timezone is selected
region = self._get_active_region()
city = self._get_active_city()
# nothing selected, just leave the spoke and
# return to hub without changing anything
if not region or not city:
return
old_tz = self._timezone_module.proxy.Timezone
new_tz = region + "/" + city
self._timezone_module.proxy.SetTimezone(new_tz)
if old_tz != new_tz:
# new values, not from kickstart
# TODO: seen should be set from the module
self._kickstarted = False
self._timezone_module.proxy.SetNTPEnabled(self._ntpSwitch.get_active())
def execute(self):
if self._update_datetime_timer is not None:
self._update_datetime_timer.cancel()
self._update_datetime_timer = None
@property
def ready(self):
return not threadMgr.get("AnaDateTimeThread")
@property
def completed(self):
if self._kickstarted and not self._timezone_module.proxy.Kickstarted:
# taking values from kickstart, but not specified
return False
else:
return is_valid_timezone(self._timezone_module.proxy.Timezone)
@property
def mandatory(self):
return True
def refresh(self):
self._shown = True
# update the displayed time
self._update_datetime_timer = Timer()
self._update_datetime_timer.timeout_sec(1, self._update_datetime)
self._start_updating_timer = None
kickstart_timezone = self._timezone_module.proxy.Timezone
if is_valid_timezone(kickstart_timezone):
self._tzmap.set_timezone(kickstart_timezone)
time.tzset()
self._update_datetime()
has_active_network = self._network_module.proxy.Connected
if not has_active_network:
self._show_no_network_warning()
else:
self.clear_info()
gtk_call_once(self._config_dialog.refresh_servers_state)
if conf.system.can_set_time_synchronization:
ntp_working = has_active_network and util.service_running(NTP_SERVICE)
else:
ntp_working = self._timezone_module.proxy.NTPEnabled
self._ntpSwitch.set_active(ntp_working)
@async_action_wait
def _set_timezone(self, timezone):
"""
Sets timezone to the city/region comboboxes and the timezone map.
:param timezone: timezone to set
:type timezone: str
:return: if successfully set or not
:rtype: bool
"""
parts = timezone.split("/", 1)
if len(parts) != 2:
# invalid timezone cannot be set
return False
region, city = parts
self._set_combo_selection(self._regionCombo, region)
self._set_combo_selection(self._cityCombo, city)
return True
@async_action_nowait
def add_to_store_xlated(self, store, item, xlated):
store.append([item, xlated])
@async_action_nowait
def add_to_store_idx(self, store, idx, item):
store.append([idx, item])
def existing_date(self, days_model, days_iter, user_data=None):
if not days_iter:
return False
day = days_model[days_iter][0]
#days 1-28 are in every month every year
if day < 29:
return True
months_model = self._monthCombo.get_model()
months_iter = self._monthCombo.get_active_iter()
if not months_iter:
return True
years_model = self._yearCombo.get_model()
years_iter = self._yearCombo.get_active_iter()
if not years_iter:
return True
try:
datetime.date(years_model[years_iter][0],
months_model[months_iter][0], day)
return True
except ValueError:
return False
def _get_active_city(self):
cities_model = self._cityCombo.get_model()
cities_iter = self._cityCombo.get_active_iter()
if not cities_iter:
return None
return cities_model[cities_iter][0]
def _get_active_region(self):
regions_model = self._regionCombo.get_model()
regions_iter = self._regionCombo.get_active_iter()
if not regions_iter:
return None
return regions_model[regions_iter][0]
def city_in_region(self, model, itr, user_data=None):
if not itr:
return False
city = model[itr][0]
region = self._get_active_region()
if not region:
return False
return city in self._regions_zones[region]
def _set_amPm_part_sensitive(self, sensitive):
for widget in (self._amPmUp, self._amPmDown, self._amPmLabel):
widget.set_sensitive(sensitive)
def _to_amPm(self, hours):
if hours >= 12:
day_phase = _("PM")
else:
day_phase = _("AM")
new_hours = ((hours - 1) % 12) + 1
return (new_hours, day_phase)
def _to_24h(self, hours, day_phase):
correction = 0
if day_phase == _("AM") and hours == 12:
correction = -12
elif day_phase == _("PM") and hours != 12:
correction = 12
return (hours + correction) % 24
def _update_datetime(self):
now = datetime.datetime.now(self._tz)
if self._radioButton24h.get_active():
self._hoursLabel.set_text("%0.2d" % now.hour)
else:
hours, amPm = self._to_amPm(now.hour)
self._hoursLabel.set_text("%0.2d" % hours)
self._amPmLabel.set_text(amPm)
self._minutesLabel.set_text("%0.2d" % now.minute)
self._set_combo_selection(self._dayCombo, now.day)
self._set_combo_selection(self._monthCombo, now.month)
self._set_combo_selection(self._yearCombo, now.year)
#GLib's timer is driven by the return value of the function.
#It runs the fuction periodically while the returned value
#is True.
return True
def _save_system_time(self):
"""
Returning False from this method removes the timer that would
otherwise call it again and again.
"""
self._start_updating_timer = None
if not conf.system.can_set_system_clock:
return False
month = self._get_combo_selection(self._monthCombo)[0]
if not month:
return False
year = self._get_combo_selection(self._yearCombo)[0]
if not year:
return False
hours = int(self._hoursLabel.get_text())
if not self._radioButton24h.get_active():
hours = self._to_24h(hours, self._amPmLabel.get_text())
minutes = int(self._minutesLabel.get_text())
day = self._get_combo_selection(self._dayCombo)[0]
#day may be None if there is no such in the selected year and month
if day:
isys.set_system_date_time(year, month, day, hours, minutes, tz=self._tz)
#start the timer only when the spoke is shown
if self._shown and not self._update_datetime_timer:
self._update_datetime_timer = Timer()
self._update_datetime_timer.timeout_sec(1, self._update_datetime)
#run only once (after first 2 seconds of inactivity)
return False
def _stop_and_maybe_start_time_updating(self, interval=2):
"""
This method is called in every date/time-setting button's callback.
It removes the timer for updating displayed date/time (do not want to
change it while user does it manually) and allows us to set new system
date/time only after $interval seconds long idle on time-setting buttons.
This is done by the _start_updating_timer that is reset in this method.
So when there is $interval seconds long idle on date/time-setting
buttons, self._save_system_time method is invoked. Since it returns
False, this timer is then removed and only reactivated in this method
(thus in some date/time-setting button's callback).
"""
#do not start timers if the spoke is not shown
if not self._shown:
self._update_datetime()
self._save_system_time()
return
#stop time updating
if self._update_datetime_timer:
self._update_datetime_timer.cancel()
self._update_datetime_timer = None
#stop previous $interval seconds timer (see below)
if self._start_updating_timer:
self._start_updating_timer.cancel()
#let the user change date/time and after $interval seconds of inactivity
#save it as the system time and start updating the displayed date/time
self._start_updating_timer = Timer()
self._start_updating_timer.timeout_sec(interval, self._save_system_time)
def _set_combo_selection(self, combo, item):
model = combo.get_model()
if not model:
return False
itr = model.get_iter_first()
while itr:
if model[itr][0] == item:
combo.set_active_iter(itr)
return True
itr = model.iter_next(itr)
return False
def _get_combo_selection(self, combo):
"""
Get the selected item of the combobox.
:return: selected item or None
"""
model = combo.get_model()
itr = combo.get_active_iter()
if not itr or not model:
return None, None
return model[itr][0], model[itr][1]
def _restore_old_city_region(self):
"""Restore stored "old" (or last valid) values."""
# check if there are old values to go back to
if self._old_region and self._old_city:
self._set_timezone(self._old_region + "/" + self._old_city)
def on_up_hours_clicked(self, *args):
self._stop_and_maybe_start_time_updating()
hours = int(self._hoursLabel.get_text())
if self._radioButton24h.get_active():
new_hours = (hours + 1) % 24
else:
amPm = self._amPmLabel.get_text()
#let's not deal with magical AM/PM arithmetics
new_hours = self._to_24h(hours, amPm)
new_hours, new_amPm = self._to_amPm((new_hours + 1) % 24)
self._amPmLabel.set_text(new_amPm)
new_hours_str = "%0.2d" % new_hours
self._hoursLabel.set_text(new_hours_str)
def on_down_hours_clicked(self, *args):
self._stop_and_maybe_start_time_updating()
hours = int(self._hoursLabel.get_text())
if self._radioButton24h.get_active():
new_hours = (hours - 1) % 24
else:
amPm = self._amPmLabel.get_text()
#let's not deal with magical AM/PM arithmetics
new_hours = self._to_24h(hours, amPm)
new_hours, new_amPm = self._to_amPm((new_hours - 1) % 24)
self._amPmLabel.set_text(new_amPm)
new_hours_str = "%0.2d" % new_hours
self._hoursLabel.set_text(new_hours_str)
def on_up_minutes_clicked(self, *args):
self._stop_and_maybe_start_time_updating()
minutes = int(self._minutesLabel.get_text())
minutes_str = "%0.2d" % ((minutes + 1) % 60)
self._minutesLabel.set_text(minutes_str)
def on_down_minutes_clicked(self, *args):
self._stop_and_maybe_start_time_updating()
minutes = int(self._minutesLabel.get_text())
minutes_str = "%0.2d" % ((minutes - 1) % 60)
self._minutesLabel.set_text(minutes_str)
def on_updown_ampm_clicked(self, *args):
self._stop_and_maybe_start_time_updating()
if self._amPmLabel.get_text() == _("AM"):
self._amPmLabel.set_text(_("PM"))
else:
self._amPmLabel.set_text(_("AM"))
def on_region_changed(self, combo, *args):
"""
:see: on_city_changed
"""
region = self._get_active_region()
if not region or region == self._old_region:
# region entry being edited or old_value chosen, no action needed
# @see: on_city_changed
return
self._citiesFilter.refilter()
# Set the city to the first one available in this newly selected region.
zone = self._regions_zones[region]
firstCity = sorted(list(zone))[0]
self._set_combo_selection(self._cityCombo, firstCity)
self._old_region = region
self._old_city = firstCity
def on_city_changed(self, combo, *args):
"""
ComboBox emits ::changed signal not only when something is selected, but
also when its entry's text is changed. We need to distinguish between
those two cases ('London' typed in the entry => no action until ENTER is
hit etc.; 'London' chosen in the expanded combobox => update timezone
map and do all necessary actions). Fortunately when entry is being
edited, self._get_active_city returns None.
"""
timezone = None
region = self._get_active_region()
city = self._get_active_city()
if not region or not city or (region == self._old_region and
city == self._old_city):
# entry being edited or no change, no actions needed
return
if city and region:
timezone = region + "/" + city
else:
# both city and region are needed to form a valid timezone
return
if region == "Etc":
# Etc timezones cannot be displayed on the map, so let's reset the
# location and manually set a highlight with no location pin.
self._tzmap.clear_location()
if city in ("GMT", "UTC"):
offset = 0.0
# The tzdb data uses POSIX-style signs for the GMT zones, which is
# the opposite of whatever everyone else expects. GMT+4 indicates a
# zone four hours west of Greenwich; i.e., four hours before. Reverse
# the sign to match the libtimezone map.
else:
# Take the part after "GMT"
offset = -float(city[3:])
self._tzmap.set_selected_offset(offset)
time.tzset()
else:
# we don't want the timezone-changed signal to be emitted
self._tzmap.set_timezone(timezone)
time.tzset()
# update "old" values
self._old_city = city
def on_entry_left(self, entry, *args):
# user clicked somewhere else or hit TAB => finished editing
entry.emit("activate")
def on_city_region_key_released(self, entry, event, *args):
if event.type == Gdk.EventType.KEY_RELEASE and \
event.keyval == Gdk.KEY_Escape:
# editing canceled
self._restore_old_city_region()
def on_completion_match_selected(self, combo, model, itr):
item = None
if model and itr:
item = model[itr][0]
if item:
self._set_combo_selection(combo, item)
def on_city_region_text_entry_activated(self, entry):
combo = entry.get_parent()
# It's gotta be up there somewhere, right? right???
while not isinstance(combo, Gtk.ComboBox):
combo = combo.get_parent()
model = combo.get_model()
entry_text = entry.get_text().lower()
for row in model:
if entry_text == row[0].lower():
self._set_combo_selection(combo, row[0])
return
# non-matching value entered, reset to old values
self._restore_old_city_region()
def on_month_changed(self, *args):
self._stop_and_maybe_start_time_updating(interval=5)
self._daysFilter.refilter()
def on_day_changed(self, *args):
self._stop_and_maybe_start_time_updating(interval=5)
def on_year_changed(self, *args):
self._stop_and_maybe_start_time_updating(interval=5)
self._daysFilter.refilter()
def on_location_changed(self, tz_map, location):
if not location:
return
timezone = location.get_property('zone')
# Updating the timezone will update the region/city combo boxes to match.
# The on_city_changed handler will attempt to convert the timezone back
# to a location and set it in the map, which we don't want, since we
# already have a location. That's why we're here.
with blockedHandler(self._cityCombo, self.on_city_changed):
if self._set_timezone(timezone):
# timezone successfully set
self._tz = get_timezone(timezone)
self._update_datetime()
def on_timeformat_changed(self, button24h, *args):
hours = int(self._hoursLabel.get_text())
amPm = self._amPmLabel.get_text()
#connected to 24-hour radio button
if button24h.get_active():
self._set_amPm_part_sensitive(False)
new_hours = self._to_24h(hours, amPm)
self._amPmRevealer.set_reveal_child(False)
else:
self._set_amPm_part_sensitive(True)
new_hours, new_amPm = self._to_amPm(hours)
self._amPmLabel.set_text(new_amPm)
self._amPmRevealer.set_reveal_child(True)
self._hoursLabel.set_text("%0.2d" % new_hours)
def _set_date_time_setting_sensitive(self, sensitive):
#contains all date/time setting widgets
footer_alignment = self.builder.get_object("footerAlignment")
footer_alignment.set_sensitive(sensitive)
def _show_no_network_warning(self):
self.set_warning(_("You need to set up networking first if you "\
"want to use NTP"))
def _show_no_ntp_server_warning(self):
self.set_warning(_("You have no working NTP server configured"))
def on_ntp_switched(self, switch, *args):
if switch.get_active():
#turned ON
if not conf.system.can_set_time_synchronization:
#cannot touch runtime system, not much to do here
return
if not self._network_module.proxy.Connected:
self._show_no_network_warning()
switch.set_active(False)
return
else:
self.clear_info()
working_server = self._config_dialog.working_server
if working_server is None:
self._show_no_ntp_server_warning()
else:
#we need a one-time sync here, because chronyd would not change
#the time as drastically as we need
ntp.one_time_sync_async(working_server)
ret = util.start_service(NTP_SERVICE)
self._set_date_time_setting_sensitive(False)
#if starting chronyd failed and chronyd is not running,
#set switch back to OFF
if (ret != 0) and not util.service_running(NTP_SERVICE):
switch.set_active(False)
else:
#turned OFF
if not conf.system.can_set_time_synchronization:
#cannot touch runtime system, nothing to do here
return
self._set_date_time_setting_sensitive(True)
ret = util.stop_service(NTP_SERVICE)
#if stopping chronyd failed and chronyd is running,
#set switch back to ON
if (ret != 0) and util.service_running(NTP_SERVICE):
switch.set_active(True)
self.clear_info()
def on_ntp_config_clicked(self, *args):
self._config_dialog.refresh()
with self.main_window.enlightbox(self._config_dialog.window):
response = self._config_dialog.run()
if response == 1:
pools, servers = self._config_dialog.pools_servers
self._timezone_module.proxy.SetNTPServers(ntp.pools_servers_to_internal(pools, servers))
if self._config_dialog.working_server is None:
self._show_no_ntp_server_warning()
else:
self.clear_info()
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 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")
def _add_modify_watcher(self, widget):
# If the payload fetching thread is still running, the user can't go to
# modify the software selection screen. Thus, we have to set the button
# insensitive and wait until software selection is ready to go.
if not self._software_is_ready():
Timer().timeout_sec(1, self._check_for_storage_thread, widget)
class NTPConfigDialog(GUIObject):
builderObjects = ["ntpConfigDialog", "serversStore"]
mainWidgetName = "ntpConfigDialog"
uiFile = "spokes/lib/ntp_dialog.glade"
def __init__(self, data, servers, states):
GUIObject.__init__(self, data)
self._servers = servers
self._active_server = None
self._states = states
# self.window.set_size_request(500, 400)
working_column = self.builder.get_object("workingColumn")
working_renderer = self.builder.get_object("workingRenderer")
override_cell_property(working_column, working_renderer, "icon-name",
self._render_working)
self._serversView = self.builder.get_object("serversView")
self._serversStore = self.builder.get_object("serversStore")
self._update_timer = Timer()
def _render_working(self, column, renderer, model, itr, user_data=None):
value = self._serversStore[itr][SERVER_WORKING]
if value == constants.NTP_SERVER_QUERY:
return "dialog-question"
elif value == constants.NTP_SERVER_OK:
return "emblem-default"
else:
return "dialog-error"
def refresh(self):
# Update the store.
self._serversStore.clear()
for server in self._servers:
self._add_row(server)
# Start to update the status.
self._update_timer.timeout_sec(1, self._update_rows)
def run(self):
self.window.show()
rc = self.window.run()
self.window.hide()
# OK clicked
if rc == 1:
# Clean up unedited entries
self._cleanup_unedited_entry()
# Restart the NTP service.
if conf.system.can_set_time_synchronization:
ntp.save_servers_to_config(self._servers)
util.restart_service(NTP_SERVICE)
return rc
def _cleanup_unedited_entry(self):
"""Clean up unedited entry.
There can be only one, at the very end.
"""
if self._servers[-1].hostname == SERVER_STARTING_STRING:
pass
num = len(self._serversStore)
path = Gtk.TreePath(num - 1)
itr = self._serversStore.get_iter(path)
self._serversStore.remove(itr)
del self._servers[-1]
def _add_row(self, server):
"""Add a new row for the given NTP server.
:param server: an NTP server
:type server: an instance of TimeSourceData
"""
itr = self._serversStore.append(
["", False, False, constants.NTP_SERVER_QUERY, server])
self._refresh_row(itr)
def _refresh_row(self, itr):
"""Refresh the given row."""
server = self._serversStore[itr][SERVER_OBJECT]
self._serversStore.set_value(itr, SERVER_HOSTNAME, server.hostname)
self._serversStore.set_value(itr, SERVER_POOL,
server.type == TIME_SOURCE_POOL)
self._serversStore.set_value(itr, SERVER_NTS, "nts" in server.options)
def _update_rows(self):
"""Periodically update the status of all rows.
:return: True to repeat, otherwise False
"""
for row in self._serversStore:
server = row[SERVER_OBJECT]
if server is self._active_server:
continue
status = self._states.get_status(server)
row[SERVER_WORKING] = status
return True
def on_add_button_clicked(self, *args):
"""Handler for Add button.
Tries to add a new server for editing, or reuse an existing server that was not edited
after adding.
"""
# check if there is any unedited server
# exactly zero or one such server can exist, at last position only
if not self._servers[-1].hostname == SERVER_STARTING_STRING:
# no unedited leftover, so make a new server with a reasonable guess about the defaults
server = TimeSourceData()
server.type = TIME_SOURCE_SERVER
server.hostname = SERVER_STARTING_STRING
server.options = ["iburst"]
# add the (still invalid) server
self._servers.append(server)
self._states.check_status(server)
self._add_row(server)
# select the correct row - it is always the last one
num = len(self._serversStore)
path = Gtk.TreePath(num - 1)
itr = self._serversStore.get_iter(path)
selection = self._serversView.get_selection()
selection.select_iter(itr)
self._serversView.grab_focus()
# start editing the newly added server hostname
# it is already selected so just "press" the edit button
self.on_edit_button_clicked(*args)
def on_edit_button_clicked(self, *args):
"""Handler for Edit button"""
selection = self._serversView.get_selection()
store, items = selection.get_selected_rows() # pylint: disable=unused-variable
path = items[-1] # take only the last item
column = self._serversView.get_column(
0) # first column is server/hostname
self._serversView.set_cursor(path, column, True)
def on_remove_button_clicked(self, *args):
"""Handler for Remove button"""
selection = self._serversView.get_selection()
store, items = selection.get_selected_rows()
for path in reversed(items):
itr = store.get_iter(path)
server = store[itr][SERVER_OBJECT]
store.remove(itr)
self._servers.remove(server)
def on_pool_toggled(self, renderer, path, *args):
itr = self._serversStore.get_iter(path)
server = self._serversStore[itr][SERVER_OBJECT]
if server.type == TIME_SOURCE_SERVER:
server.type = TIME_SOURCE_POOL
else:
server.type = TIME_SOURCE_SERVER
self._refresh_row(itr)
def on_nts_toggled(self, renderer, path, *args):
itr = self._serversStore.get_iter(path)
server = self._serversStore[itr][SERVER_OBJECT]
if "nts" in server.options:
server.options.remove("nts")
else:
server.options.append("nts")
self._states.check_status(server)
self._refresh_row(itr)
def on_server_editing_started(self, renderer, editable, path):
itr = self._serversStore.get_iter(path)
self._active_server = self._serversStore[itr][SERVER_OBJECT]
def on_server_editing_canceled(self, renderer):
self._active_server = None
def on_server_edited(self, renderer, path, new_text, *args):
self._active_server = None
if not path:
return
(valid, error) = network.is_valid_hostname(new_text)
if not valid:
log.error("'%s' is not a valid hostname: %s", new_text, error)
return
itr = self._serversStore.get_iter(path)
server = self._serversStore[itr][SERVER_OBJECT]
if server.hostname == new_text:
return
server.hostname = new_text
self._states.check_status(server)
self._refresh_row(itr)
class NTPConfigDialog(GUIObject, GUIDialogInputCheckHandler):
builderObjects = ["ntpConfigDialog", "addImage", "serversStore"]
mainWidgetName = "ntpConfigDialog"
uiFile = "spokes/datetime_spoke.glade"
def __init__(self, data, servers, states):
GUIObject.__init__(self, data)
self._servers = servers
self._active_server = None
self._states = states
# Use GUIDIalogInputCheckHandler to manipulate the sensitivity of the
# add button, and check for valid input in on_entry_activated
add_button = self.builder.get_object("addButton")
GUIDialogInputCheckHandler.__init__(self, add_button)
self.window.set_size_request(500, 400)
working_column = self.builder.get_object("workingColumn")
working_renderer = self.builder.get_object("workingRenderer")
override_cell_property(working_column, working_renderer, "icon-name",
self._render_working)
self._serverEntry = self.builder.get_object("serverEntry")
self._serversStore = self.builder.get_object("serversStore")
self._addButton = self.builder.get_object("addButton")
self._poolCheckButton = self.builder.get_object("poolCheckButton")
self._ntsCheckButton = self.builder.get_object("ntsCheckButton")
self._serverCheck = self.add_check(self._serverEntry,
self._validate_server)
self._serverCheck.update_check_status()
self._update_timer = Timer()
def _render_working(self, column, renderer, model, itr, user_data=None):
value = self._serversStore[itr][SERVER_WORKING]
if value == constants.NTP_SERVER_QUERY:
return "dialog-question"
elif value == constants.NTP_SERVER_OK:
return "emblem-default"
else:
return "dialog-error"
def _validate_server(self, inputcheck):
server = self.get_input(inputcheck.input_obj)
# If not set, fail the check to keep the button insensitive, but don't
# display an error
if not server:
return InputCheck.CHECK_SILENT
(valid, error) = network.is_valid_hostname(server)
if not valid:
return "'%s' is not a valid hostname: %s" % (server, error)
else:
return InputCheck.CHECK_OK
def refresh(self):
# Update the store.
self._serversStore.clear()
for server in self._servers:
self._add_row(server)
# Start to update the status.
self._update_timer.timeout_sec(1, self._update_rows)
# Focus on the server entry.
self._serverEntry.grab_focus()
def run(self):
self.window.show()
rc = self.window.run()
self.window.hide()
# OK clicked
if rc == 1:
# Remove servers.
for row in self._serversStore:
if not row[SERVER_USE]:
server = row[SERVER_OBJECT]
self._servers.remove(server)
# Restart the NTP service.
if conf.system.can_set_time_synchronization:
ntp.save_servers_to_config(self._servers)
util.restart_service(NTP_SERVICE)
return rc
def _add_row(self, server):
"""Add a new row for the given NTP server.
:param server: an NTP server
:type server: an instance of TimeSourceData
"""
itr = self._serversStore.append(
["", False, False, constants.NTP_SERVER_QUERY, True, server])
self._refresh_row(itr)
def _refresh_row(self, itr):
"""Refresh the given row."""
server = self._serversStore[itr][SERVER_OBJECT]
self._serversStore.set_value(itr, SERVER_HOSTNAME, server.hostname)
self._serversStore.set_value(itr, SERVER_POOL,
server.type == TIME_SOURCE_POOL)
self._serversStore.set_value(itr, SERVER_NTS, "nts" in server.options)
def _update_rows(self):
"""Periodically update the status of all rows.
:return: True to repeat, otherwise False
"""
for row in self._serversStore:
server = row[SERVER_OBJECT]
if server is self._active_server:
continue
status = self._states.get_status(server)
row[SERVER_WORKING] = status
return True
def on_entry_activated(self, entry, *args):
# Check that the input check has passed
if self._serverCheck.check_status != InputCheck.CHECK_OK:
return
server = TimeSourceData()
if self._poolCheckButton.get_active():
server.type = TIME_SOURCE_POOL
else:
server.type = TIME_SOURCE_SERVER
server.hostname = entry.get_text()
server.options = ["iburst"]
if self._ntsCheckButton.get_active():
server.options.append("nts")
self._servers.append(server)
self._states.check_status(server)
self._add_row(server)
entry.set_text("")
self._poolCheckButton.set_active(False)
self._ntsCheckButton.set_active(False)
def on_add_clicked(self, *args):
self._serverEntry.emit("activate")
def on_use_server_toggled(self, renderer, path, *args):
itr = self._serversStore.get_iter(path)
old_value = self._serversStore[itr][SERVER_USE]
self._serversStore.set_value(itr, SERVER_USE, not old_value)
def on_pool_toggled(self, renderer, path, *args):
itr = self._serversStore.get_iter(path)
server = self._serversStore[itr][SERVER_OBJECT]
if server.type == TIME_SOURCE_SERVER:
server.type = TIME_SOURCE_POOL
else:
server.type = TIME_SOURCE_SERVER
self._refresh_row(itr)
def on_nts_toggled(self, renderer, path, *args):
itr = self._serversStore.get_iter(path)
server = self._serversStore[itr][SERVER_OBJECT]
if "nts" in server.options:
server.options.remove("nts")
else:
server.options.append("nts")
self._states.check_status(server)
self._refresh_row(itr)
def on_server_editing_started(self, renderer, editable, path):
itr = self._serversStore.get_iter(path)
self._active_server = self._serversStore[itr][SERVER_OBJECT]
def on_server_editing_canceled(self, renderer):
self._active_server = None
def on_server_edited(self, renderer, path, new_text, *args):
self._active_server = None
if not path:
return
(valid, error) = network.is_valid_hostname(new_text)
if not valid:
log.error("'%s' is not a valid hostname: %s", new_text, error)
return
itr = self._serversStore.get_iter(path)
server = self._serversStore[itr][SERVER_OBJECT]
if server.hostname == new_text:
return
server.hostname = new_text
self._states.check_status(server)
self._refresh_row(itr)
class RefreshDialog(GUIObject):
builderObjects = ["refreshDialog"]
mainWidgetName = "refreshDialog"
uiFile = "spokes/lib/refresh.glade"
def __init__(self, data, storage):
super().__init__(data)
self.storage = storage
self._notebook = self.builder.get_object("refreshNotebook")
self._cancel_button = self.builder.get_object("refreshCancelButton")
self._ok_button = self.builder.get_object("refreshOKButton")
self._elapsed = 0
self._rescan_timer = Timer()
def run(self):
rc = self.window.run()
self.window.destroy()
return rc
def _check_rescan(self, *args):
if threadMgr.get(constants.THREAD_STORAGE):
self._elapsed += 1
# If more than five seconds has elapsed since the rescan started,
# give the user the option to return to the hub.
if self._elapsed >= 5:
self._notebook.set_current_page(2)
return True
# Seems a little silly to have this warning text still displayed
# when everything is done.
box = self.builder.get_object("warningBox")
box.set_visible(False)
self._cancel_button.set_sensitive(False)
self._ok_button.set_sensitive(True)
self._notebook.set_current_page(3)
return False
def return_to_hub_link_clicked(self, label, uri):
# The user clicked on the link that takes them back to the hub. We need
# to kill the _check_rescan watcher and then emit a special response ID
# indicating the user did not press OK.
#
# NOTE: There is no button with response_id=2.
self._rescan_timer.cancel()
self.window.response(2)
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=reset_storage,
args=(self.storage, ),
kwargs={"scan_all": True}))
self._elapsed = 0
# This watches for the rescan to be finished and updates the dialog when
# that happens.
self._rescan_timer.timeout_sec(1, self._check_rescan)
def stop(self):
self.unpublish()
Timer().timeout_sec(1, self.loop.quit)
