def initialize(self):
# Start a thread to wait for the payload and run the first, automatic
# dependency check
self.initialize_start()
super(SoftwareSpoke, self).initialize()
threadMgr.add(AnacondaThread(name=THREAD_SOFTWARE_WATCHER,
target=self._initialize))
def test_exception_handling():
"""
Function that can be used for testing exception handling in anaconda. It
tries to prepare a worst case scenario designed from bugs seen so far.
"""
# XXX: this is a huge hack, but probably the only way, how we can get
# "unique" stack and thus unique hash and new bugreport
def raise_exception(msg, non_ascii):
timestamp = str(time.time()).split(".", 1)[0]
code = """
def f%s(msg, non_ascii):
raise RuntimeError(msg)
f%s(msg, non_ascii)
""" % (timestamp, timestamp)
eval(compile(code, "str_eval", "exec"))
# test non-ascii characters dumping
non_ascii = u'\u0159'
msg = "NOTABUG: testing exception handling"
# raise exception from a separate thread
from pyanaconda.threading import AnacondaThread
threadMgr.add(AnacondaThread(name=THREAD_EXCEPTION_HANDLING_TEST,
target=raise_exception,
args=(msg, non_ascii)))
def _apply(self):
# Environment needs to be set during a GUI installation, but is not required
# for a kickstart install (even partial)
if not self.environment:
log.debug("Environment is not set, skip user packages settings")
return
# NOTE: This block is skipped for kickstart where addons and _origAddons will
# both be [], preventing it from wiping out the kickstart's package selection
addons = self._get_selected_addons()
if not self._kickstarted and set(addons) != set(self._origAddons):
self._selectFlag = False
self.payload.data.packages.packageList = []
self.payload.data.packages.groupList = []
self.payload.selectEnvironment(self.environment)
log.debug("Environment selected for installation: %s", self.environment)
log.debug("Groups selected for installation: %s", addons)
for group in addons:
self.payload.selectGroup(group)
# And then save these values so we can check next time.
self._origAddons = addons
self._origEnvironment = self.environment
hubQ.send_not_ready(self.__class__.__name__)
hubQ.send_not_ready("SourceSpoke")
threadMgr.add(AnacondaThread(name=constants.THREAD_CHECK_SOFTWARE,
target=self.checkSoftwareSelection))
def initialize(self):
NormalTUISpoke.initialize(self)
self.initialize_start()
threadMgr.add(AnacondaThread(name=THREAD_SOURCE_WATCHER,
target=self._initialize))
payloadMgr.addListener(payloadMgr.STATE_ERROR, self._payload_error)
def show_all(self):
super().show_all()
from pyanaconda.installation import doInstall, doConfiguration
from pyanaconda.threading import threadMgr, AnacondaThread
thread_args = (self.storage, self.payload, self.data, self.instclass)
threadMgr.add(AnacondaThread(name=THREAD_INSTALL, target=doInstall, args=thread_args))
# This will run until we're all done with the install thread.
self._update_progress()
threadMgr.add(AnacondaThread(name=THREAD_CONFIGURATION, target=doConfiguration, args=thread_args))
# This will run until we're all done with the configuration thread.
self._update_progress()
util.ipmi_report(IPMI_FINISHED)
if self.instclass.eula_path:
# Notify user about the EULA (if any).
print(_("Installation complete"))
print('')
print(_("Use of this product is subject to the license agreement found at:"))
print(self.instclass.eula_path)
print('')
# kickstart install, continue automatically if reboot or shutdown selected
if flags.automatedInstall and self.data.reboot.action in [KS_REBOOT, KS_SHUTDOWN]:
# Just pretend like we got input, and our input doesn't care
# what it gets, it just quits.
raise ExitMainLoop()
def on_login_clicked(self, *args):
# Make the buttons UI while we work.
self._okButton.set_sensitive(False)
self._cancelButton.set_sensitive(False)
self._loginButton.set_sensitive(False)
self._loginConditionNotebook.set_current_page(0)
self._set_login_sensitive(False)
spinner = self.builder.get_object("loginSpinner")
spinner.start()
spinner.set_visible(True)
spinner.show()
# Are we reusing the credentials from the discovery step? If so, grab them
# out of the UI again here. They should still be there.
page = self._loginAuthNotebook.get_current_page()
if page == 3:
credentials = discoverMap[self._authNotebook.get_current_page()](self.builder)
else:
credentials = loginMap[page](self.builder)
threadMgr.add(AnacondaThread(name=constants.THREAD_ISCSI_LOGIN, target=self._login,
args=(credentials,)))
Timer().timeout_msec(250, self._check_login)
def _refresh_server_working(self, itr):
""" Runs a new thread with _set_server_ok_nok(itr) as a taget. """
self._serversStore.set_value(itr, SERVER_WORKING, constants.NTP_SERVER_QUERY)
threadMgr.add(AnacondaThread(prefix=constants.THREAD_NTP_SERVER_CHECK,
target=self._set_server_ok_nok,
args=(itr, self._epoch)))
def restart_thread(self, storage, ksdata, payload,
fallback=False, checkmount=True, onlyOnChange=False):
"""Start or restart the payload thread.
This method starts a new thread to restart the payload thread, so
this method's return is not blocked by waiting on the previous payload
thread. If there is already a payload thread restart pending, this method
has no effect.
:param pyanaconda.storage.InstallerStorage storage: The blivet storage instance
:param kickstart.AnacondaKSHandler ksdata: The kickstart data instance
:param payload.Payload payload: The payload instance
:param bool fallback: Whether to fall back to the default repo in case of error
:param bool checkmount: Whether to check for valid mounted media
:param bool onlyOnChange: Restart thread only if existing repositories changed.
This won't restart thread even when a new repository was added!!
"""
log.debug("Restarting payload thread")
# If a restart thread is already running, don't start a new one
if threadMgr.get(THREAD_PAYLOAD_RESTART):
return
thread_args = (storage, ksdata, payload, fallback, checkmount, onlyOnChange)
# Launch a new thread so that this method can return immediately
threadMgr.add(AnacondaThread(name=THREAD_PAYLOAD_RESTART, target=self._restart_thread,
args=thread_args))
def on_start_clicked(self, *args):
# First, update some widgets to not be usable while discovery happens.
self._startButton.hide()
self._cancelButton.set_sensitive(False)
self._okButton.set_sensitive(False)
self._conditionNotebook.set_current_page(1)
self._set_configure_sensitive(False)
self._initiatorEntry.set_sensitive(False)
# Now get the node discovery credentials.
credentials = discoverMap[self._authNotebook.get_current_page()](self.builder)
discoveredLabelText = _("The following nodes were discovered using the iSCSI initiator "\
"<b>%(initiatorName)s</b> using the target IP address "\
"<b>%(targetAddress)s</b>. Please select which nodes you "\
"wish to log into:") % \
{"initiatorName": escape_markup(credentials.initiator),
"targetAddress": escape_markup(credentials.targetIP)}
discoveredLabel = self.builder.get_object("discoveredLabel")
discoveredLabel.set_markup(discoveredLabelText)
bind = self._bindCheckbox.get_active()
spinner = self.builder.get_object("waitSpinner")
spinner.start()
threadMgr.add(AnacondaThread(name=constants.THREAD_ISCSI_DISCOVER, target=self._discover,
args=(credentials, bind)))
Timer().timeout_msec(250, self._check_discover)
def wait_and_fetch_net_data(url, out_file, ca_certs=None):
"""
Function that waits for network connection and starts a thread that fetches
data over network.
:see: org_fedora_oscap.data_fetch.fetch_data
:return: the name of the thread running fetch_data
:rtype: str
"""
# get thread that tries to establish a network connection
nm_conn_thread = threadMgr.get(constants.THREAD_WAIT_FOR_CONNECTING_NM)
if nm_conn_thread:
# NM still connecting, wait for it to finish
nm_conn_thread.join()
if not nm.nm_is_connected():
raise OSCAPaddonNetworkError("Network connection needed to fetch data.")
fetch_data_thread = AnacondaThread(name=THREAD_FETCH_DATA,
target=fetch_data,
args=(url, out_file, ca_certs),
fatal=False)
# register and run the thread
threadMgr.add(fetch_data_thread)
return THREAD_FETCH_DATA
def initialize(self):
NormalTUISpoke.initialize(self)
self.initialize_start()
threadMgr.add(AnacondaThread(name=THREAD_STORAGE_WATCHER,
target=self._initialize))
self.selected_disks = self.data.ignoredisk.onlyuse[:]
def _restart_thread(self, storage, ksdata, payload, fallback, checkmount, onlyOnChange):
# Wait for the old thread to finish
threadMgr.wait(THREAD_PAYLOAD)
thread_args = (storage, ksdata, payload, fallback, checkmount, onlyOnChange)
# Start a new payload thread
threadMgr.add(AnacondaThread(name=THREAD_PAYLOAD, target=self._run_thread,
args=thread_args))
def initialize(self):
super().initialize()
self.initialize_start()
# set X keyboard defaults
# - this needs to be done early in spoke initialization so that
# the spoke status does not show outdated keyboard selection
keyboard.set_x_keyboard_defaults(self._l12_module.proxy, self._xkl_wrapper)
# make sure the x_layouts list has at least one keyboard layout
if not self._l12_module.proxy.XLayouts:
self._l12_module.proxy.SetXLayouts([DEFAULT_KEYBOARD])
self._add_dialog = AddLayoutDialog(self.data)
self._add_dialog.initialize()
if conf.system.can_configure_keyboard:
self.builder.get_object("warningBox").hide()
# We want to store layouts' names but show layouts as
# 'language (description)'.
layoutColumn = self.builder.get_object("layoutColumn")
layoutRenderer = self.builder.get_object("layoutRenderer")
override_cell_property(layoutColumn, layoutRenderer, "text", _show_layout,
self._xkl_wrapper)
self._store = self.builder.get_object("addedLayoutStore")
self._add_data_layouts()
self._selection = self.builder.get_object("layoutSelection")
self._switching_dialog = ConfigureSwitchingDialog(self.data, self._l12_module)
self._switching_dialog.initialize()
self._layoutSwitchLabel = self.builder.get_object("layoutSwitchLabel")
if not conf.system.can_configure_keyboard:
# Disable area for testing layouts as we cannot make
# it work without modifying runtime system
widgets = [self.builder.get_object("testingLabel"),
self.builder.get_object("testingWindow"),
self.builder.get_object("layoutSwitchLabel")]
# Use testingLabel's text to explain why this part is not
# sensitive.
widgets[0].set_text(_("Testing layouts configuration not "
"available."))
for widget in widgets:
widget.set_sensitive(False)
hubQ.send_not_ready(self.__class__.__name__)
hubQ.send_message(self.__class__.__name__,
_("Getting list of layouts..."))
threadMgr.add(AnacondaThread(name=THREAD_KEYBOARD_INIT,
target=self._wait_ready))
def _check_ntp_servers_async(self, servers):
"""Asynchronously check if given NTP servers appear to be working.
:param list servers: list of servers to check
"""
for server in servers:
threadMgr.add(AnacondaThread(prefix=constants.THREAD_NTP_SERVER_CHECK,
target=self._check_ntp_server,
args=(server,)))
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 on_format_clicked(self, *args):
"""
Once the format button is clicked, the option to cancel expires.
We also need to display the spinner showing activity.
"""
self._cancel_button.set_sensitive(False)
self._ok_button.set_sensitive(False)
self._notebook.set_current_page(1)
# Format dasds and update the storage.
threadMgr.add(AnacondaThread(name=constants.THREAD_DASDFMT, target=self.run_format, args=()))
def on_start_clicked(self, *args):
self._conditionNotebook.set_current_page(PAGE_ACTION)
for widget in [self._startButton, self._cancelButton, self._sectorSizeSpinButton,
self._okButton]:
widget.set_sensitive(False)
self._reconfigureSpinner.start()
threadMgr.add(AnacondaThread(name=THREAD_NVDIMM_RECONFIGURE, target=self._reconfigure,
args=(self.namespaces, NVDIMM_MODE_SECTOR, self.sector_size)))
def on_start_clicked(self, *args):
""" Go through the process of validating entry contents and then
attempt to add the device.
"""
# First update widgets
self._startButton.hide()
self._cancelButton.set_sensitive(False)
self._okButton.set_sensitive(False)
self._set_configure_sensitive(False)
self._conditionNotebook.set_current_page(1)
# Initialize.
config_error = None
device = None
wwpn = None
lun = None
# Get the input.
device_name = self._deviceEntry.get_text().strip()
wwpn_name = self._wwpnEntry.get_text().strip()
lun_name = self._lunEntry.get_text().strip()
# Check the input.
if not DASD_DEVICE_NUMBER.match(device_name):
config_error = "Incorrect format of the given device number."
elif not ZFCP_WWPN_NUMBER.match(wwpn_name):
config_error = "Incorrect format of the given WWPN number."
elif not ZFCP_LUN_NUMBER.match(lun_name):
config_error = "Incorrect format of the given LUN number."
else:
try:
# Get the full ids.
device = blockdev.s390.sanitize_dev_input(device_name)
wwpn = blockdev.s390.zfcp_sanitize_wwpn_input(wwpn_name)
lun = blockdev.s390.zfcp_sanitize_lun_input(lun_name)
except (blockdev.S390Error, ValueError) as err:
config_error = str(err)
# Process the configuration error.
if config_error:
self._errorLabel.set_text(config_error)
self._conditionNotebook.set_current_page(2)
self._set_configure_sensitive(True)
self._cancelButton.set_sensitive(True)
# Start the discovery.
else:
# Discover.
self._spinner.start()
threadMgr.add(AnacondaThread(name=constants.THREAD_ZFCP_DISCOVER,
target=self._discover,
args=(device, wwpn, lun)))
# Periodically call the check till it is done.
GLib.timeout_add(250, self._check_discover)
def initialize(self):
NormalTUISpoke.initialize(self)
self.initialize_start()
# Ask for a default passphrase.
if flags.automatedInstall and flags.ksprompt:
self.run_passphrase_dialog()
threadMgr.add(AnacondaThread(name=THREAD_STORAGE_WATCHER,
target=self._initialize))
self._selected_disks = self._disk_select_observer.proxy.SelectedDisks
def start(self):
"""Start the task in a new thread."""
threadMgr.add(
AnacondaThread(
name=self._thread_name,
target=self._task_run_callback,
target_started=self._task_started_callback,
target_stopped=self._task_stopped_callback,
target_failed=self._task_failed_with_info_callback,
fatal=False
)
)
def on_format_clicked(self, *args):
"""
Once the format button is clicked, the option to cancel expires.
We also need to display the spinner showing activity.
"""
self._cancel_button.set_sensitive(False)
self._ok_button.set_sensitive(False)
self._notebook.set_current_page(1)
# Loop through all of our unformatted DASDs and format them
threadMgr.add(AnacondaThread(name=constants.THREAD_DASDFMT,
target=self.run_dasdfmt, args=(self._epoch,)))
def on_add_clicked(self, *args):
# Set some widgets to visible/not while we work.
self._errorBox.hide()
self._addSpinner.set_visible(True)
self._addSpinner.show()
for widget in [self._addButton, self._cancelButton, self._nicCombo,
self._dcbCheckbox, self._autoCheckbox]:
widget.set_sensitive(False)
self._addSpinner.start()
threadMgr.add(AnacondaThread(name=constants.THREAD_FCOE, target=self._add))
def refresh(self):
"""Refresh location info."""
# check if a refresh is already in progress
if threadMgr.get(constants.THREAD_GEOLOCATION_REFRESH):
log.debug("Geoloc: refresh already in progress")
else: # wait for Internet connectivity
if network.wait_for_connectivity():
threadMgr.add(AnacondaThread(
name=constants.THREAD_GEOLOCATION_REFRESH,
target=self._provider.refresh))
else:
log.error("Geolocation refresh failed"
" - no connectivity")
def install(self):
""" Install the payload if it is a tar.
Otherwise fall back to rsync of INSTALL_TREE
"""
# If it doesn't look like a tarfile use the super's install()
if not self.is_tarfile:
super().install()
return
# Use 2x the archive's size to estimate the size of the install
# This is used to drive the progress display
self.source_size = os.stat(self.image_path)[stat.ST_SIZE] * 2
self.pct_lock = Lock()
self.pct = 0
threadMgr.add(AnacondaThread(name=THREAD_LIVE_PROGRESS,
target=self.progress))
cmd = "tar"
# preserve: ACL's, xattrs, and SELinux context
args = ["--selinux", "--acls", "--xattrs", "--xattrs-include", "*",
"--exclude", "/dev/", "--exclude", "/proc/",
"--exclude", "/sys/", "--exclude", "/run/", "--exclude", "/boot/*rescue*",
"--exclude", "/etc/machine-id", "-xaf", self.image_path, "-C", util.getSysroot()]
try:
rc = util.execWithRedirect(cmd, args)
except (OSError, RuntimeError) as e:
msg = None
err = str(e)
log.error(err)
else:
err = None
msg = "%s exited with code %d" % (cmd, rc)
log.info(msg)
if err:
exn = PayloadInstallError(err or msg)
if errorHandler.cb(exn) == ERROR_RAISE:
raise exn
# Wait for progress thread to finish
with self.pct_lock:
self.pct = 100
threadMgr.wait(THREAD_LIVE_PROGRESS)
# Live needs to create the rescue image before bootloader is written
for kernel in self.kernel_version_list:
log.info("Generating rescue image for %s", kernel)
util.execInSysroot("new-kernel-pkg",
["--rpmposttrans", kernel])
def install(self):
""" Install the payload. """
if self.source_size <= 0:
raise PayloadInstallError("Nothing to install")
self.pct_lock = Lock()
self.pct = 0
threadMgr.add(AnacondaThread(name=THREAD_LIVE_PROGRESS,
target=self.progress))
cmd = "rsync"
# preserve: permissions, owners, groups, ACL's, xattrs, times,
# symlinks, hardlinks
# go recursively, include devices and special files, don't cross
# file system boundaries
args = ["-pogAXtlHrDx", "--exclude", "/dev/", "--exclude", "/proc/",
"--exclude", "/sys/", "--exclude", "/run/", "--exclude", "/boot/*rescue*",
"--exclude", "/etc/machine-id", INSTALL_TREE + "/", iutil.getSysroot()]
try:
rc = iutil.execWithRedirect(cmd, args)
except (OSError, RuntimeError) as e:
msg = None
err = str(e)
log.error(err)
else:
err = None
msg = "%s exited with code %d" % (cmd, rc)
log.info(msg)
if err or rc == 12:
exn = PayloadInstallError(err or msg)
if errorHandler.cb(exn) == ERROR_RAISE:
raise exn
# Wait for progress thread to finish
with self.pct_lock:
self.pct = 100
threadMgr.wait(THREAD_LIVE_PROGRESS)
# Live needs to create the rescue image before bootloader is written
if not os.path.exists(iutil.getSysroot() + "/usr/sbin/new-kernel-pkg"):
log.error("new-kernel-pkg does not exist - grubby wasn't installed? skipping")
return
for kernel in self.kernelVersionList:
log.info("Generating rescue image for %s", kernel)
iutil.execInSysroot("new-kernel-pkg",
["--rpmposttrans", kernel])
def _after_reconfigure(self):
# When reconfiguration is done, update the UI. We don't need to worry
# about the user escaping from the dialog because all the buttons are
# marked insensitive.
self._reconfigureSpinner.stop()
if self._error:
self.builder.get_object("deviceErrorLabel").set_text(self._error)
self._error = None
self._conditionNotebook.set_current_page(PAGE_RESULT_ERROR)
self._okButton.set_sensitive(True)
else:
self._conditionNotebook.set_current_page(PAGE_RESULT_SUCCESS)
if self._update_devicetree:
self._repopulateSpinner.start()
threadMgr.add(AnacondaThread(name=THREAD_NVDIMM_REPOPULATE, target=self._repopulate))
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=storage_initialize,
args=(self.storage, self.data, self.storage.devicetree.protected_dev_names)))
self._elapsed = 0
# This watches for the rescan to be finished and updates the dialog when
# that happens.
self._watcher_id = GLib.timeout_add_seconds(1, self._check_rescan)
def 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 _apply(self):
""" Private apply. """
self.environment = self._selected_environment
self.addons = self._addons_selection if self.environment is not None else set()
log.debug("Apply called old env %s, new env %s and addons %s",
self._orig_env, self.environment, self.addons)
if self.environment is None:
return
changed = False
# Not a kickstart with packages, setup the selected environment and addons
if not self._kickstarted:
# Changed the environment or addons, clear and setup
if not self._orig_env \
or self._orig_env != self.environment \
or set(self._orig_addons) != set(self.addons):
log.debug("Setting new software selection old env %s, new env %s and addons %s",
self._orig_env, self.environment, self.addons)
self.payload.data.packages.packageList = []
self.data.packages.groupList = []
self.payload.select_environment(self.environment)
environment_id = self._translate_env_name_to_id(self.environment)
available_addons = self._get_available_addons(environment_id)
for addon_id in available_addons:
if addon_id in self.addons:
self.payload.select_group(addon_id)
changed = True
self._orig_env = self.environment
self._orig_addons = set(self.addons)
# Check the software selection
if changed or self._kickstarted:
threadMgr.add(AnacondaThread(name=THREAD_CHECK_SOFTWARE,
target=self.check_software_selection))
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()
GLib.timeout_add(250, self._update_progress, self._configuration_done)
threadMgr.add(AnacondaThread(name=THREAD_CONFIGURATION, target=doConfiguration,
args=(self.storage, self.payload, self.data, self.instclass)))
def initialize(self):
NormalSpoke.initialize(self)
self.initialize_start()
# get object references from the builders
self._main_notebook = self.builder.get_object("main_notebook")
# * the registration tab * #
# container for the main registration controls
self._registration_grid = self.builder.get_object("registration_grid")
# authentication
self._account_radio_button = self.builder.get_object(
"account_radio_button")
self._activation_key_radio_button = self.builder.get_object(
"activation_key_radio_button")
# authentication - account
self._account_revealer = self.builder.get_object("account_revealer")
self._username_entry = self.builder.get_object("username_entry")
self._password_entry = self.builder.get_object("password_entry")
# authentication - activation key
self._activation_key_revealer = self.builder.get_object(
"activation_key_revealer")
self._organization_entry = self.builder.get_object(
"organization_entry")
self._activation_key_entry = self.builder.get_object(
"activation_key_entry")
# system purpose
self._system_purpose_checkbox = self.builder.get_object(
"system_purpose_checkbox")
self._system_purpose_revealer = self.builder.get_object(
"system_purpose_revealer")
self._system_purpose_role_combobox = self.builder.get_object(
"system_purpose_role_combobox")
self._system_purpose_sla_combobox = self.builder.get_object(
"system_purpose_sla_combobox")
self._system_purpose_usage_combobox = self.builder.get_object(
"system_purpose_usage_combobox")
# insights
self._insights_checkbox = self.builder.get_object("insights_checkbox")
# options expander
self._options_expander = self.builder.get_object("options_expander")
# HTTP proxy
self._http_proxy_checkbox = self.builder.get_object(
"http_proxy_checkbox")
self._http_proxy_revealer = self.builder.get_object(
"http_proxy_revealer")
self._http_proxy_location_entry = self.builder.get_object(
"http_proxy_location_entry")
self._http_proxy_username_entry = self.builder.get_object(
"http_proxy_username_entry")
self._http_proxy_password_entry = self.builder.get_object(
"http_proxy_password_entry")
# RHSM baseurl
self._custom_rhsm_baseurl_checkbox = self.builder.get_object(
"custom_rhsm_baseurl_checkbox")
self._custom_rhsm_baseurl_revealer = self.builder.get_object(
"custom_rhsm_baseurl_revealer")
self._custom_rhsm_baseurl_entry = self.builder.get_object(
"custom_rhsm_baseurl_entry")
# server hostname
self._custom_server_hostname_checkbox = self.builder.get_object(
"custom_server_hostname_checkbox")
self._custom_server_hostname_revealer = self.builder.get_object(
"custom_server_hostname_revealer")
self._custom_server_hostname_entry = self.builder.get_object(
"custom_server_hostname_entry")
# status label
self._registration_status_label = self.builder.get_object(
"registration_status_label")
# register button
self._register_button = self.builder.get_object("register_button")
# * the subscription status tab * #
# general status
self._method_status_label = self.builder.get_object(
"method_status_label")
self._role_status_label = self.builder.get_object("role_status_label")
self._sla_status_label = self.builder.get_object("sla_status_label")
self._usage_status_label = self.builder.get_object(
"usage_status_label")
self._insights_status_label = self.builder.get_object(
"insights_status_label")
# attached subscriptions
self._attached_subscriptions_label = self.builder.get_object(
"attached_subscriptions_label")
self._subscriptions_listbox = self.builder.get_object(
"subscriptions_listbox")
# setup spoke state based on data from the Subscription DBus module
self._update_spoke_state()
# start the rest of spoke initialization which might take some time
# (mainly due to waiting for various initialization threads to finish)
# in a separate thread
threadMgr.add(
AnacondaThread(name=THREAD_SUBSCRIPTION_SPOKE_INIT,
target=self._initialize))
text_mode=anaconda.tui_mode)
# Initialize the network now, in case the display needs it
from pyanaconda.network import initialize_network, wait_for_connecting_NM_thread, wait_for_connected_NM
initialize_network()
# If required by user, wait for connection before starting the installation.
if opts.waitfornet:
log.info(
"network: waiting for connectivity requested by inst.waitfornet=%d",
opts.waitfornet)
wait_for_connected_NM(timeout=opts.waitfornet)
# In any case do some actions only after NM finishes its connecting.
threadMgr.add(
AnacondaThread(name=constants.THREAD_WAIT_FOR_CONNECTING_NM,
target=wait_for_connecting_NM_thread))
# now start the interface
display.setup_display(anaconda, opts)
if anaconda.gui_startup_failed:
# we need to reinitialize the locale if GUI startup failed,
# as we might now be in text mode, which might not be able to display
# the characters from our current locale
log.warning(
"reinitializing locale due to failed attempt to start the GUI")
localization.setup_locale(os.environ["LANG"],
localization_proxy,
text_mode=anaconda.tui_mode)
# we now know in which mode we are going to run so store the information
def __enter__(self):
"""Start to monitor the progress."""
# Start the thread.
threadMgr.add(
AnacondaThread(name=self._thread_name,
target=self._monitor_progress))
blivet.enable_installer_mode()
# Initialize the network now, in case the display needs it
from pyanaconda.network import networkInitialize, wait_for_connecting_NM_thread, wait_for_connected_NM
networkInitialize(ksdata)
# If required by user, wait for connection before starting the installation.
if opts.waitfornet:
log.info(
"network: waiting for connectivity requested by inst.waitfornet=%d",
opts.waitfornet)
wait_for_connected_NM(timeout=opts.waitfornet)
# In any case do some actions only after NM finishes its connecting.
threadMgr.add(
AnacondaThread(name=constants.THREAD_WAIT_FOR_CONNECTING_NM,
target=wait_for_connecting_NM_thread,
args=(ksdata, )))
# initialize the screen access manager before launching the UI
from pyanaconda import screen_access
screen_access.initSAM()
# try to open any existing config file
# (might be created by pre-anaconda helper tools, injected during image
# generation, etc.)
screen_access.sam.open_config_file()
# now start the interface
display.setup_display(anaconda, opts, addon_paths=addon_paths)
if anaconda.gui_startup_failed:
# we need to reinitialize the locale if GUI startup failed,
# as we might now be in text mode, which might not be able to display
def gtk_batch_map(action, items, args=(), pre_func=None, batch_size=1):
"""
Function that maps an action on items in a way that makes the action run in
the main thread, but without blocking the main thread for a noticeable
time. If a pre-processing function is given it is mapped on the items first
before the action happens in the main thread.
.. DANGER::
MUST NOT BE CALLED NOR WAITED FOR FROM THE MAIN THREAD.
:param action: any action that has to be done on the items in the main
thread
:type action: (action_item, \\*args) -> None
:param items: an iterable of items that the action should be mapped on
:type items: iterable
:param args: additional arguments passed to the action function
:type args: tuple
:param pre_func: a function that is mapped on the items before they are
passed to the action function
:type pre_func: item -> action_item
:param batch_size: how many items should be processed in one run in the main loop
:raise AssertionError: if called from the main thread
:return: None
"""
assert(not threadMgr.in_main_thread())
def preprocess(queue_instance):
if pre_func:
for item in items:
queue_instance.put(pre_func(item))
else:
for item in items:
queue_instance.put(item)
queue_instance.put(TERMINATOR)
def process_one_batch(arguments):
(queue_instance, action, done_event) = arguments
tstamp_start = time.time()
tstamp = time.time()
# process as many batches as user shouldn't notice
while tstamp - tstamp_start < NOTICEABLE_FREEZE:
for _i in range(batch_size):
try:
action_item = queue_instance.get_nowait()
if action_item is TERMINATOR:
# all items processed, tell we are finished and return
done_event.set()
return False
else:
# run action on the item
action(action_item, *args)
except queue.Empty:
# empty queue_instance, reschedule to run later
return True
tstamp = time.time()
# out of time but something left, reschedule to run again later
return True
item_queue_instance = queue.Queue()
done_event = threading.Event()
# we don't want to log the whole list, type and address is enough
log.debug("Starting applying %s on %s", action, object.__repr__(items))
# start a thread putting preprocessed items into the queue_instance
threadMgr.add(AnacondaThread(prefix="AnaGtkBatchPre",
target=preprocess,
args=(item_queue_instance,)))
run_in_loop(process_one_batch, (item_queue_instance, action, done_event))
done_event.wait()
log.debug("Finished applying %s on %s", action, object.__repr__(items))
enable_installer_mode()
# Initialize the network now, in case the display needs it
from pyanaconda.network import initialize_network, wait_for_connecting_NM_thread, wait_for_connected_NM
initialize_network()
# If required by user, wait for connection before starting the installation.
if opts.waitfornet:
log.info(
"network: waiting for connectivity requested by inst.waitfornet=%d",
opts.waitfornet)
wait_for_connected_NM(timeout=opts.waitfornet)
# In any case do some actions only after NM finishes its connecting.
threadMgr.add(
AnacondaThread(name=constants.THREAD_WAIT_FOR_CONNECTING_NM,
target=wait_for_connecting_NM_thread))
# now start the interface
display.setup_display(anaconda, opts)
if anaconda.gui_startup_failed:
# we need to reinitialize the locale if GUI startup failed,
# as we might now be in text mode, which might not be able to display
# the characters from our current locale
log.warning(
"reinitializing locale due to failed attempt to start the GUI")
localization.setup_locale(os.environ["LANG"],
localization_proxy,
text_mode=anaconda.tui_mode)
# we now know in which mode we are going to run so store the information
def execute(self):
"""Execute the changes."""
threadMgr.add(
AnacondaThread(name=THREAD_CHECK_SOFTWARE,
target=self._check_software_selection))
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._hide_date_time_setting()
threadMgr.add(AnacondaThread(name=constants.THREAD_DATE_TIME,
target=self._initialize))
def install(self):
""" Install the payload. """
if self.source_size <= 0:
raise PayloadInstallError("Nothing to install")
self.pct_lock = Lock()
self.pct = 0
threadMgr.add(
AnacondaThread(name=THREAD_LIVE_PROGRESS, target=self.progress))
cmd = "rsync"
# preserve: permissions, owners, groups, ACL's, xattrs, times,
# symlinks, hardlinks
# go recursively, include devices and special files, don't cross
# file system boundaries
args = [
"-pogAXtlHrDx", "--exclude", "/dev/", "--exclude", "/proc/",
"--exclude", "/sys/", "--exclude", "/run/", "--exclude",
"/boot/*rescue*", "--exclude", "/boot/loader/", "--exclude",
"/boot/efi/loader/", "--exclude", "/etc/machine-id",
INSTALL_TREE + "/",
util.getSysroot()
]
try:
rc = util.execWithRedirect(cmd, args)
except (OSError, RuntimeError) as e:
msg = None
err = str(e)
log.error(err)
else:
err = None
msg = "%s exited with code %d" % (cmd, rc)
log.info(msg)
if err or rc == 11:
exn = PayloadInstallError(err or msg)
if errorHandler.cb(exn) == ERROR_RAISE:
raise exn
# Wait for progress thread to finish
with self.pct_lock:
self.pct = 100
threadMgr.wait(THREAD_LIVE_PROGRESS)
# Live needs to create the rescue image before bootloader is written
if os.path.exists(util.getSysroot() + "/usr/sbin/new-kernel-pkg"):
useNKP = True
else:
log.warning(
"new-kernel-pkg does not exist - grubby wasn't installed?")
useNKP = False
for kernel in self.kernelVersionList:
log.info("Generating rescue image for %s", kernel)
if useNKP:
util.execInSysroot("new-kernel-pkg",
["--rpmposttrans", kernel])
else:
files = glob.glob(util.getSysroot() +
"/etc/kernel/postinst.d/*")
srlen = len(util.getSysroot())
files = sorted(
[f[srlen:] for f in files if os.access(f, os.X_OK)])
for file in files:
util.execInSysroot(
file, [kernel, "/boot/vmlinuz-%s" % kernel])
def run(self):
threadMgr.add(
AnacondaThread(name=constants.THREAD_CHECK_STORAGE,
target=self.checkStorage))
def execute(self):
"""Execute the changes."""
threadMgr.add(AnacondaThread(
name=constants.THREAD_CHECK_SOFTWARE,
target=self.checkSoftwareSelection
))
startup_utils.initialize_locale(opts, text_mode=anaconda.tui_mode)
# Initialize the network now, in case the display needs it
from pyanaconda.network import initialize_network, wait_for_connecting_NM_thread, wait_for_connected_NM
initialize_network()
# If required by user, wait for connection before starting the installation.
if opts.waitfornet:
log.info(
"network: waiting for connectivity requested by inst.waitfornet=%d",
opts.waitfornet)
wait_for_connected_NM(timeout=opts.waitfornet)
# In any case do some actions only after NM finishes its connecting.
threadMgr.add(
AnacondaThread(name=constants.THREAD_WAIT_FOR_CONNECTING_NM,
target=wait_for_connecting_NM_thread))
# now start the interface
display.setup_display(anaconda, opts)
if anaconda.gui_startup_failed:
# we need to reinitialize the locale if GUI startup failed,
# as we might now be in text mode, which might not be able to display
# the characters from our current locale
startup_utils.reinitialize_locale(opts, text_mode=anaconda.tui_mode)
# we now know in which mode we are going to run so store the information
from pykickstart import constants as pykickstart_constants
display_mode_coversion_table = {
constants.DisplayModes.GUI:
pykickstart_constants.DISPLAY_MODE_GRAPHICAL,
def initialize(self):
super().initialize()
self.initialize_start()
threadMgr.add(
AnacondaThread(name=constants.THREAD_SOFTWARE_WATCHER,
target=self._initialize))
def initialize(self):
NormalSpoke.initialize(self)
self.initialize_start()
# set X keyboard defaults
# - this needs to be done early in spoke initialization so that
# the spoke status does not show outdated keyboard selection
keyboard.set_x_keyboard_defaults(self._l12_module.proxy,
self._xkl_wrapper)
# make sure the x_layouts list has at least one keyboard layout
if not self._l12_module.proxy.XLayouts:
self._l12_module.proxy.SetXLayouts([DEFAULT_KEYBOARD])
self._add_dialog = AddLayoutDialog(self.data)
self._add_dialog.initialize()
if flags.can_touch_runtime_system(
"hide runtime keyboard configuration "
"warning", touch_live=True):
self.builder.get_object("warningBox").hide()
# We want to store layouts' names but show layouts as
# 'language (description)'.
layoutColumn = self.builder.get_object("layoutColumn")
layoutRenderer = self.builder.get_object("layoutRenderer")
override_cell_property(layoutColumn, layoutRenderer, "text",
_show_layout, self._xkl_wrapper)
self._store = self.builder.get_object("addedLayoutStore")
self._add_data_layouts()
self._selection = self.builder.get_object("layoutSelection")
self._switching_dialog = ConfigureSwitchingDialog(
self.data, self._l12_module)
self._switching_dialog.initialize()
self._layoutSwitchLabel = self.builder.get_object("layoutSwitchLabel")
if not flags.can_touch_runtime_system("test X layouts",
touch_live=True):
# Disable area for testing layouts as we cannot make
# it work without modifying runtime system
widgets = [
self.builder.get_object("testingLabel"),
self.builder.get_object("testingWindow"),
self.builder.get_object("layoutSwitchLabel")
]
# Use testingLabel's text to explain why this part is not
# sensitive.
widgets[0].set_text(
_("Testing layouts configuration not "
"available."))
for widget in widgets:
widget.set_sensitive(False)
hubQ.send_not_ready(self.__class__.__name__)
hubQ.send_message(self.__class__.__name__,
_("Getting list of layouts..."))
threadMgr.add(
AnacondaThread(name=THREAD_KEYBOARD_INIT, target=self._wait_ready))
