def time_initialize(timezone, storage, bootloader):
"""
Try to guess if RTC uses UTC time or not, set timezone.isUtc properly and
set system time from RTC using the UTC guess.
Guess is done by searching for bootable ntfs devices.
:param timezone: ksdata.timezone object
:param storage: blivet.Blivet instance
:param bootloader: bootloader.Bootloader instance
"""
if arch.isS390():
# nothing to do on s390 where hwclock doesn't exist
return
if not timezone.isUtc and not flags.automatedInstall:
# if set in the kickstart, no magic needed here
threadMgr.wait(THREAD_STORAGE)
ntfs_devs = filter(lambda dev: dev.format.name == "ntfs",
storage.devices)
timezone.isUtc = not bootloader.has_windows(ntfs_devs)
cmd = "hwclock"
args = ["--hctosys"]
if timezone.isUtc:
args.append("--utc")
else:
args.append("--localtime")
iutil.execWithRedirect(cmd, args)
def __init__(self, *args, **kwargs):
StorageChecker.__init__(self)
NormalSpoke.__init__(self, *args, **kwargs)
self.applyOnSkip = True
self._ready = False
self.autoPartType = None
self.encrypted = False
self.passphrase = ""
self.selected_disks = self.data.ignoredisk.onlyuse[:]
# This list contains all possible disks that can be included in the install.
# All types of advanced disks should be set up for us ahead of time, so
# there should be no need to modify this list.
self.disks = []
if not flags.automatedInstall:
# default to using autopart for interactive installs
self.data.autopart.autopart = True
self.autopart = self.data.autopart.autopart
self.autoPartType = None
self.clearPartType = CLEARPART_TYPE_NONE
if self.data.zerombr.zerombr and arch.isS390():
# run dasdfmt on any unformatted DASDs automatically
threadMgr.add(AnacondaThread(name=constants.THREAD_DASDFMT,
target=self.run_dasdfmt))
self._previous_autopart = False
self._last_clicked_overview = None
self._cur_clicked_overview = None
self._grabObjects()
def input(self, args, key):
"""Grab the disk choice and update things"""
try:
keyid = int(key) - 1
self.selection = keyid
if len(self.disks) > 1 and keyid == len(self.disks):
self._select_all_disks()
else:
self._update_disk_list(self.disks[keyid])
return INPUT_PROCESSED
except (ValueError, IndexError):
if key.lower() == "c":
if self.selected_disks:
# check selected disks to see if we have any unformatted DASDs
# if we're on s390x, since they need to be formatted before we
# can use them.
if arch.isS390():
to_format = make_unformatted_dasd_list(self.selected_disks)
if to_format:
self.run_dasdfmt(to_format)
return None
newspoke = AutoPartSpoke(self.app, self.data, self.storage,
self.payload, self.instclass)
self.app.switch_screen_modal(newspoke)
self.apply()
self.execute()
self.close()
return INPUT_PROCESSED
else:
return key
def __init__(self, app, data, storage, payload, instclass):
NormalTUISpoke.__init__(self, app, data, storage, payload, instclass)
self._ready = False
self.selected_disks = self.data.ignoredisk.onlyuse[:]
self.selection = None
self.autopart = None
self.clearPartType = None
# This list gets set up once in initialize and should not be modified
# except perhaps to add advanced devices. It will remain the full list
# of disks that can be included in the install.
self.disks = []
self.errors = []
self.warnings = []
if self.data.zerombr.zerombr and arch.isS390():
# if zerombr is specified in a ks file and there are unformatted
# dasds, automatically format them. pass in storage.devicetree here
# instead of storage.disks since mediaPresent is checked on disks;
# a dasd needing dasdfmt will fail this media check though
to_format = storage.devicetree.make_unformatted_dasd_list(getDisks(self.storage.devicetree))
if to_format:
self.run_dasdfmt(to_format)
if not flags.automatedInstall:
# default to using autopart for interactive installs
self.data.autopart.autopart = True
def write_dasd_conf(disks, ROOT_PATH):
""" Write /etc/dasd.conf to target system for all DASD devices
configured during installation.
"""
if not (arch.isS390() or disks):
return
with open(os.path.realpath(ROOT_PATH + "/etc/dasd.conf"), "w") as f:
for dasd in sorted(disks, key=lambda d: d.name):
fields = [dasd.busid] + dasd.getOpts()
f.write("%s\n" % " ".join(fields),)
def __init__(self, storage, builder):
FilterPage.__init__(self, storage, builder)
self.model = self.builder.get_object("zModel")
self.model.set_visible_func(self.visible_func)
self._ccwEntry = self.builder.get_object("zCCWEntry")
self._wwpnEntry = self.builder.get_object("zWWPNEntry")
self._lunEntry = self.builder.get_object("zLUNEntry")
self._combo = self.builder.get_object("zTypeCombo")
self._isS390 = arch.isS390()
def make_dasd_list(dasds, disks):
""" Create a list of DASDs recognized by the system. """
if not arch.isS390():
return
log.info("Generating DASD list...")
for dev in (d for d in disks if d.type == "dasd"):
if dev not in dasds:
dasds.append(dev)
return dasds
def write_timezone_config(timezone, root):
"""
Write timezone configuration for the system specified by root.
:param timezone: ksdata.timezone object
:param root: path to the root
:raise: TimezoneConfigError
"""
# we want to create a relative symlink
tz_file = "/usr/share/zoneinfo/" + timezone.timezone
rooted_tz_file = os.path.normpath(root + tz_file)
relative_path = os.path.normpath("../" + tz_file)
link_path = os.path.normpath(root + "/etc/localtime")
if not os.access(rooted_tz_file, os.R_OK):
log.error("Timezone to be linked (%s) doesn't exist", rooted_tz_file)
else:
try:
# os.symlink fails if link_path exists, so try to remove it first
os.remove(link_path)
except OSError:
pass
try:
os.symlink(relative_path, link_path)
except OSError as oserr:
log.error("Error when symlinking timezone (from %s): %s",
rooted_tz_file, oserr.strerror)
if arch.isS390():
# there is no HW clock on s390(x)
return
try:
fobj = open(os.path.normpath(root + "/etc/adjtime"), "r")
lines = fobj.readlines()
fobj.close()
except IOError:
lines = ["0.0 0 0.0\n", "0\n"]
try:
with open(os.path.normpath(root + "/etc/adjtime"), "w") as fobj:
fobj.write(lines[0])
fobj.write(lines[1])
if timezone.isUtc:
fobj.write("UTC\n")
else:
fobj.write("LOCAL\n")
except IOError as ioerr:
msg = "Error while writing /etc/adjtime file: %s" % ioerr.strerror
raise TimezoneConfigError(msg)
def input(self, args, key):
"""Grab the disk choice and update things"""
self.errors = []
try:
keyid = int(key) - 1
if keyid < 0:
return key
self.selection = keyid
if len(self.disks) > 1 and keyid == len(self.disks):
self._select_all_disks()
else:
self._update_disk_list(self.disks[keyid])
return INPUT_PROCESSED
except (ValueError, IndexError):
if key.lower() == "c":
if self.selected_disks:
# check selected disks to see if we have any unformatted DASDs
# if we're on s390x, since they need to be formatted before we
# can use them.
if arch.isS390():
_disks = [d for d in self.disks if d.name in self.selected_disks]
to_format = self.storage.devicetree.make_unformatted_dasd_list(_disks)
if to_format:
self.run_dasdfmt(to_format)
return None
# make sure no containers were split up by the user's disk
# selection
self.errors.extend(checkDiskSelection(self.storage,
self.selected_disks))
if self.errors:
# The disk selection has to make sense before we can
# proceed.
return None
newspoke = AutoPartSpoke(self.app, self.data, self.storage,
self.payload, self.instclass)
self.app.switch_screen_modal(newspoke)
self.apply()
self.execute()
self.close()
return INPUT_PROCESSED
else:
return key
def save_hw_clock(timezone):
"""
Save system time to HW clock.
:param timezone: ksdata.timezone object
"""
if arch.isS390():
return
cmd = "hwclock"
args = ["--systohc"]
if timezone.isUtc:
args.append("--utc")
else:
args.append("--local")
iutil.execWithRedirect(cmd, args)
def initialize(self):
NormalSpoke.initialize(self)
self.pages = [SearchPage(self.storage, self.builder),
MultipathPage(self.storage, self.builder),
OtherPage(self.storage, self.builder),
RaidPage(self.storage, self.builder),
ZPage(self.storage, self.builder)]
self._notebook = self.builder.get_object("advancedNotebook")
if not arch.isS390():
self._notebook.remove_page(-1)
self.builder.get_object("addZFCPButton").destroy()
if not has_fcoe():
self.builder.get_object("addFCOEButton").destroy()
self._store = self.builder.get_object("diskStore")
self._addDisksButton = self.builder.get_object("addDisksButton")
def initialize(self):
NormalSpoke.initialize(self)
self.pages = [SearchPage(self.storage, self.builder),
MultipathPage(self.storage, self.builder),
OtherPage(self.storage, self.builder),
ZPage(self.storage, self.builder)]
self._notebook = self.builder.get_object("advancedNotebook")
if not arch.isS390():
self._notebook.remove_page(-1)
self.builder.get_object("addZFCPButton").destroy()
self.builder.get_object("addDASDButton").destroy()
if not has_fcoe():
self.builder.get_object("addFCOEButton").destroy()
self._store = self.builder.get_object("diskStore")
self._addDisksButton = self.builder.get_object("addDisksButton")
# Connect focus events in scrolled viewport children to scrolling on the viewport
searchScrolledViewport = self.builder.get_object("searchScrolledViewport")
searchGrid = self.builder.get_object("searchGrid")
searchGrid.set_focus_hadjustment(searchScrolledViewport.get_hadjustment())
searchGrid.set_focus_vadjustment(searchScrolledViewport.get_vadjustment())
multipathViewport = self.builder.get_object("multipathViewport")
multipathGrid = self.builder.get_object("multipathGrid")
multipathGrid.set_focus_hadjustment(multipathViewport.get_hadjustment())
multipathGrid.set_focus_vadjustment(multipathViewport.get_vadjustment())
otherViewport = self.builder.get_object("otherViewport")
otherGrid = self.builder.get_object("otherGrid")
otherGrid.set_focus_hadjustment(otherViewport.get_hadjustment())
otherGrid.set_focus_vadjustment(otherViewport.get_vadjustment())
zViewport = self.builder.get_object("zViewport")
zGrid = self.builder.get_object("zGrid")
zGrid.set_focus_hadjustment(zViewport.get_hadjustment())
zGrid.set_focus_vadjustment(zViewport.get_vadjustment())
def __init__(self, *args, **kwargs):
StorageChecker.__init__(self, min_ram=isys.MIN_GUI_RAM)
NormalSpoke.__init__(self, *args, **kwargs)
self.applyOnSkip = True
self._ready = False
self.autoPartType = None
self.encrypted = False
self.passphrase = ""
self.selected_disks = self.data.ignoredisk.onlyuse[:]
self._last_selected_disks = None
self._back_clicked = False
self.autopart_missing_passphrase = False
self.disks_errors = []
# This list contains all possible disks that can be included in the install.
# All types of advanced disks should be set up for us ahead of time, so
# there should be no need to modify this list.
self.disks = []
if not flags.automatedInstall:
# default to using autopart for interactive installs
self.data.autopart.autopart = True
self.autopart = self.data.autopart.autopart
self.autoPartType = None
self.clearPartType = CLEARPART_TYPE_NONE
if self.data.zerombr.zerombr and arch.isS390():
# run dasdfmt on any unformatted DASDs automatically
threadMgr.add(
AnacondaThread(name=constants.THREAD_DASDFMT,
target=self.run_dasdfmt))
self._previous_autopart = False
self._last_clicked_overview = None
self._cur_clicked_overview = None
self._grabObjects()
def initialize(self):
NormalSpoke.initialize(self)
self.pages = [
SearchPage(self.storage, self.builder),
MultipathPage(self.storage, self.builder),
OtherPage(self.storage, self.builder),
RaidPage(self.storage, self.builder),
ZPage(self.storage, self.builder)
]
self._notebook = self.builder.get_object("advancedNotebook")
if not arch.isS390():
self._notebook.remove_page(-1)
self.builder.get_object("addZFCPButton").destroy()
if not has_fcoe():
self.builder.get_object("addFCOEButton").destroy()
self._store = self.builder.get_object("diskStore")
self._addDisksButton = self.builder.get_object("addDisksButton")
def __init__(self, app, data, storage, payload, instclass):
NormalTUISpoke.__init__(self, app, data, storage, payload, instclass)
self._ready = False
self.selected_disks = self.data.ignoredisk.onlyuse[:]
# This list gets set up once in initialize and should not be modified
# except perhaps to add advanced devices. It will remain the full list
# of disks that can be included in the install.
self.disks = []
self.errors = []
self.warnings = []
if self.data.zerombr.zerombr and arch.isS390():
# if zerombr is specified in a ks file and there are unformatted
# dasds, automatically format them
to_format = make_unformatted_dasd_list(self.selected_disks)
if to_format:
self.run_dasdfmt(to_format)
if not flags.automatedInstall:
# default to using autopart for interactive installs
self.data.autopart.autopart = True
def write_dasd_conf(disks, root):
""" Write /etc/dasd.conf to target system for all DASD devices
configured during installation.
"""
if not (arch.isS390() and disks):
return
with open(os.path.realpath(root + "/etc/dasd.conf"), "w") as f:
for dasd in sorted(disks, key=lambda d: d.name):
fields = [dasd.busid] + dasd.getOpts()
f.write("%s\n" % " ".join(fields),)
# check for hyper PAV aliases; they need to get added to dasd.conf as well
sysfs = "/sys/bus/ccw/drivers/dasd-eckd"
# in the case that someone is installing with *only* FBA DASDs,the above
# sysfs path will not exist; so check for it and just bail out of here if
# that's the case
if not os.path.exists(sysfs):
return
# this does catch every DASD, even non-aliases, but we're only going to be
# checking for a very specific flag, so there won't be any duplicate entries
# in dasd.conf
devs = [d for d in os.listdir(sysfs) if d.startswith("0.0")]
with open(os.path.realpath(root + "/etc/dasd.conf"), "a") as f:
for d in devs:
aliasfile = "%s/%s/alias" % (sysfs, d)
with open(aliasfile, "r") as falias:
alias = falias.read().strip()
# if alias == 1, then the device is an alias; otherwise it is a
# normal dasd (alias == 0) and we can skip it, since it will have
# been added to dasd.conf in the above block of code
if alias == "1":
f.write("%s\n" % d)
if product.isFinal:
print("anaconda %s started." % verdesc)
else:
print("anaconda %s (pre-release) started." % verdesc)
# we are past the --version and --help shortcut so we can import Blivet
# now without slowing down anything critical
# pylint: disable=import-error
from blivet import arch
if not opts.images and not opts.dirinstall:
print(logs_note)
# no fancy stuff like TTYs on a s390...
if not arch.isS390():
if "TMUX" in os.environ and os.environ.get("TERM") == "screen":
print(shell_and_tmux_note)
else:
print(shell_only_note) # TMUX is not running
# ...but there is apparently TMUX during the manual installation on s390!
elif not opts.ksfile:
print(tmux_only_note) # but not during kickstart installation
# no need to tell users how to switch to text mode
# if already in text mode
if opts.display_mode == 'g':
print(text_mode_note)
print(separate_attachements_note)
from pyanaconda.anaconda import Anaconda
anaconda = Anaconda()
def get_help_path(help_file, instclass):
"""Return the full path for the given help file name,
if the help file path does not exist a fallback path is returned.
There are actually two possible fallback paths that might be returned:
* first we try to return path to the main page of the installation guide
(if it exists)
* if we can't find the main page of the installation page, path to a
"no help found" placeholder bundled with Anaconda is returned
Regarding help l10n, we try to respect the current locale as defined by the
"LANG" environmental variable, but fallback to English if localized content
is not available.
:param help_file: help file name
:type help_file: str or NoneType
:param instclass: current install class instance
:return str: full path to the help file requested or to a placeholder
"""
# help l10n handling
if help_file:
# Some of the RHEL7 installation guide pages might be marked as "common",
# meaning that their content is common for all architectures, while
# other pages might be architecture specific. These two categories
# are mutually exclusive - if there is a common variant, there will be
# no arch specific variant and if there are arch specific variants,
# there will be no common variant.
# check for the common variant
file_head, file_tail = os.path.splitext(help_file)
help_file = "%s-%s%s" % (file_head, COMMON_HELP_FILE_VARIANT_SUFFIX,
file_tail)
help_path = _get_best_help_file(instclass.help_folder, help_file)
if help_path:
log.debug("found a common help file variant at %s", help_path)
return help_path
# check for the arch specific variant
# the documentation files don't differentiate between 32bit and 64bit x86
# and just use a "x86" suffix for both
if arch.isX86():
architecture = "x86"
# the arm docks are the same as the x86 docs
elif arch.isARM() or arch.isAARCH64():
architecture = "x86"
# same thing for s390 (31 bit) and s390x (64 bit), they are just "s390"
elif arch.isS390():
architecture = "s390"
# 32 bit PPC is no longer supported in RHEL and both 64 bit PPC variants (BE and LE)
# are covered with the "ppc64" suffix
elif arch.isPPC():
architecture = "ppc64"
else:
architecture = arch.getArch()
help_file = "%s-%s%s" % (file_head, architecture, file_tail)
help_path = _get_best_help_file(instclass.help_folder, help_file)
if help_path:
log.debug("found arch specific help file variant at %s", help_path)
return help_path
# the screen did not have a helpFile defined or the defined help file
# does not exist, so next try to check if we can find the main page
# of the installation guide and use it instead
help_path = _get_best_help_file(instclass.help_folder,
instclass.help_main_page)
if help_path is not None:
return help_path
# looks like the installation guide is not available, so just return
# a placeholder page, which should be always present
if flags.livecdInstall:
return _get_best_help_file(instclass.help_folder,
instclass.help_placeholder_with_links)
else:
return _get_best_help_file(instclass.help_folder,
instclass.help_placeholder)
def on_back_clicked(self, button):
# We can't exit early if it looks like nothing has changed because the
# user might want to change settings presented in the dialogs shown from
# within this method.
# Do not enter this method multiple times if user clicking multiple times
# on back button
if self._back_clicked:
return
else:
self._back_clicked = True
# make sure the snapshot of unmodified on-disk-storage model is created
if not on_disk_storage.created:
on_disk_storage.create_snapshot(self.storage)
if self.autopart_missing_passphrase:
self._setup_passphrase()
NormalSpoke.on_back_clicked(self, button)
return
# No disks selected? The user wants to back out of the storage spoke.
if not self.selected_disks:
NormalSpoke.on_back_clicked(self, button)
return
disk_selection_changed = False
if self._last_selected_disks:
disk_selection_changed = (self._last_selected_disks != set(self.selected_disks))
# remember the disk selection for future decisions
self._last_selected_disks = set(self.selected_disks)
if disk_selection_changed:
# Changing disk selection is really, really complicated and has
# always been causing numerous hard bugs. Let's not play the hero
# game and just revert everything and start over again.
on_disk_storage.reset_to_snapshot(self.storage)
self.disks = getDisks(self.storage.devicetree)
else:
# Remove all non-existing devices if autopart was active when we last
# refreshed.
if self._previous_autopart:
self._previous_autopart = False
self._remove_nonexistant_partitions()
# hide disks as requested
self._hide_disks()
# make sure no containers were split up by the user's disk selection
self.clear_info()
# if there are some disk selection errors we don't let user to leave the
# spoke, so these errors don't have to go to self.errors
self.disks_errors = checkDiskSelection(self.storage, self.selected_disks)
if self.disks_errors:
# The disk selection has to make sense before we can proceed.
self.set_error(_("There was a problem with your disk selection. "
"Click here for details."))
self._back_clicked = False
return
if arch.isS390():
# check for unformatted DASDs and launch dasdfmt if any discovered
rc = self._check_dasd_formats()
if rc == DASD_FORMAT_NO_CHANGE:
pass
elif rc == DASD_FORMAT_REFRESH:
# User hit OK on the dialog
self.refresh()
elif rc == DASD_FORMAT_RETURN_TO_HUB:
# User clicked uri to return to hub.
NormalSpoke.on_back_clicked(self, button)
return
else:
# User either hit cancel on the dialog or closed it via escape,
# there was no formatting done.
self._back_clicked = False
return
# even if they're not doing autopart, setting autopart.encrypted
# establishes a default of encrypting new devices
self.encrypted = self._encrypted.get_active()
# We might first need to ask about an encryption passphrase.
if self.encrypted and not self._setup_passphrase():
self._back_clicked = False
return
# At this point there are three possible states:
# 1) user chose custom part => just send them to the CustomPart spoke
# 2) user wants to reclaim some more space => run the ResizeDialog
# 3) we are just asked to do autopart => check free space and see if we need
# user to do anything more
self.autopart = not self._customPart.get_active()
disks = [d for d in self.disks if d.name in self.selected_disks]
dialog = None
if not self.autopart:
self.skipTo = "CustomPartitioningSpoke"
elif self._reclaim.get_active():
# HINT: change the logic of this 'if' statement if we are asked to
# support "reclaim before custom partitioning"
# respect disk selection and other choices in the ReclaimDialog
self.apply()
dialog = ResizeDialog(self.data, self.storage, self.payload)
dialog.refresh(disks)
else:
dialog = self._check_space_and_get_dialog(disks)
if dialog:
# more dialogs may need to be run based on user choices, but we are
# only interested in the final result
rc = self._run_dialogs(disks, start_with=dialog)
if rc == RESPONSE_OK:
# nothing special needed
pass
elif rc == RESPONSE_CANCEL:
# A cancel button was clicked on one of the dialogs. Stay on this
# spoke. Generally, this is because the user wants to add more disks.
self._back_clicked = False
return
elif rc == RESPONSE_MODIFY_SW:
# The "Fedora software selection" link was clicked on one of the
# dialogs. Send the user to the software spoke.
self.skipTo = "SoftwareSelectionSpoke"
elif rc == RESPONSE_QUIT:
# Not enough space, and the user can't do anything about it so
# they chose to quit.
raise SystemExit("user-selected exit")
else:
# I don't know how we'd get here, but might as well have a
# catch-all. Just stay on this spoke.
self._back_clicked = False
return
if self.autopart:
refreshAutoSwapSize(self.storage)
self.applyOnSkip = True
NormalSpoke.on_back_clicked(self, button)
def __init__(self, storage, builder):
FilterPage.__init__(self, storage, builder)
self.model = self.builder.get_object("zModel")
self.model.set_visible_func(self.visible_func)
self._isS390 = arch.isS390()
def sanity_check(storage, min_ram=isys.MIN_RAM):
"""
Run a series of tests to verify the storage configuration.
This function is called at the end of partitioning so that
we can make sure you don't have anything silly (like no /,
a really small /, etc).
:param storage: an instance of the :class:`blivet.Blivet` class to check
:param min_ram: minimum RAM (in MiB) needed for the installation with swap
space available
:rtype: a list of SanityExceptions
:return: a list of accumulated errors and warnings
"""
exns = []
checkSizes = [('/usr', Size("250 MiB")), ('/tmp', Size("50 MiB")), ('/var', Size("384 MiB")),
('/home', Size("100 MiB")), ('/boot', Size("200 MiB"))]
mustbeonlinuxfs = ['/', '/var', '/tmp', '/usr', '/home', '/usr/share', '/usr/lib']
mustbeonroot = ['/bin', '/dev', '/sbin', '/etc', '/lib', '/root', '/mnt', 'lost+found', '/proc']
filesystems = storage.mountpoints
root = storage.fsset.rootDevice
swaps = storage.fsset.swapDevices
if root:
if root.size < Size("250 MiB"):
exns.append(
SanityWarning(_("Your root partition is less than 250 "
"megabytes which is usually too small to "
"install %s.") % (productName,)))
else:
exns.append(
SanityError(_("You have not defined a root partition (/), "
"which is required for installation of %s "
"to continue.") % (productName,)))
# Prevent users from installing on s390x with (a) no /boot volume, (b) the
# root volume on LVM, and (c) the root volume not restricted to a single
# PV
# NOTE: There is not really a way for users to create a / volume
# restricted to a single PV. The backend support is there, but there are
# no UI hook-ups to drive that functionality, but I do not personally
# care. --dcantrell
if arch.isS390() and '/boot' not in storage.mountpoints and root:
if root.type == 'lvmlv' and not root.singlePV:
exns.append(
SanityError(_("This platform requires /boot on a dedicated "
"partition or logical volume. If you do not "
"want a /boot volume, you must place / on a "
"dedicated non-LVM partition.")))
# FIXME: put a check here for enough space on the filesystems. maybe?
for (mount, size) in checkSizes:
if mount in filesystems and filesystems[mount].size < size:
exns.append(
SanityWarning(_("Your %(mount)s partition is less than "
"%(size)s which is lower than recommended "
"for a normal %(productName)s install.")
% {'mount': mount, 'size': size,
'productName': productName}))
for (mount, device) in filesystems.items():
problem = filesystems[mount].checkSize()
if problem < 0:
exns.append(
SanityError(_("Your %(mount)s partition is too small for %(format)s formatting "
"(allowable size is %(minSize)s to %(maxSize)s)")
% {"mount": mount, "format": device.format.name,
"minSize": device.minSize, "maxSize": device.maxSize}))
elif problem > 0:
exns.append(
SanityError(_("Your %(mount)s partition is too large for %(format)s formatting "
"(allowable size is %(minSize)s to %(maxSize)s)")
% {"mount":mount, "format": device.format.name,
"minSize": device.minSize, "maxSize": device.maxSize}))
if storage.bootloader and not storage.bootloader.skip_bootloader:
stage1 = storage.bootloader.stage1_device
if not stage1:
exns.append(
SanityError(_("No valid boot loader target device found. "
"See below for details.")))
pe = _platform.stage1MissingError
if pe:
exns.append(SanityError(_(pe)))
else:
storage.bootloader.is_valid_stage1_device(stage1)
exns.extend(SanityError(msg) for msg in storage.bootloader.errors)
exns.extend(SanityWarning(msg) for msg in storage.bootloader.warnings)
stage2 = storage.bootloader.stage2_device
if stage1 and not stage2:
exns.append(SanityError(_("You have not created a bootable partition.")))
else:
storage.bootloader.is_valid_stage2_device(stage2)
exns.extend(SanityError(msg) for msg in storage.bootloader.errors)
exns.extend(SanityWarning(msg) for msg in storage.bootloader.warnings)
if not storage.bootloader.check():
exns.extend(SanityError(msg) for msg in storage.bootloader.errors)
#
# check that GPT boot disk on BIOS system has a BIOS boot partition
#
if _platform.weight(fstype="biosboot") and \
stage1 and stage1.isDisk and \
getattr(stage1.format, "labelType", None) == "gpt":
missing = True
for part in [p for p in storage.partitions if p.disk == stage1]:
if part.format.type == "biosboot":
missing = False
break
if missing:
exns.append(
SanityError(_("Your BIOS-based system needs a special "
"partition to boot from a GPT disk label. "
"To continue, please create a 1MiB "
"'biosboot' type partition.")))
if not swaps:
installed = util.total_memory()
required = Size("%s MiB" % (min_ram + isys.NO_SWAP_EXTRA_RAM))
if installed < required:
exns.append(
SanityError(_("You have not specified a swap partition. "
"%(requiredMem)s of memory is required to continue installation "
"without a swap partition, but you only have %(installedMem)s.")
% {"requiredMem": required,
"installedMem": installed}))
else:
exns.append(
SanityWarning(_("You have not specified a swap partition. "
"Although not strictly required in all cases, "
"it will significantly improve performance "
"for most installations.")))
no_uuid = [s for s in swaps if s.format.exists and not s.format.uuid]
if no_uuid:
exns.append(
SanityWarning(_("At least one of your swap devices does not have "
"a UUID, which is common in swap space created "
"using older versions of mkswap. These devices "
"will be referred to by device path in "
"/etc/fstab, which is not ideal since device "
"paths can change under a variety of "
"circumstances. ")))
for (mountpoint, dev) in filesystems.items():
if mountpoint in mustbeonroot:
exns.append(
SanityError(_("This mount point is invalid. The %s directory must "
"be on the / file system.") % mountpoint))
if mountpoint in mustbeonlinuxfs and (not dev.format.mountable or not dev.format.linuxNative):
exns.append(
SanityError(_("The mount point %s must be on a linux file system.") % mountpoint))
if storage.rootDevice and storage.rootDevice.format.exists:
e = storage.mustFormat(storage.rootDevice)
if e:
exns.append(SanityError(e))
exns += verify_LUKS_devices_have_key(storage)
return exns
def should_run(cls, environment, data):
# run only in the installer on s390(x) machines
return environment == ANACONDA_ENVIRON and arch.isS390()
def should_run(cls, environment, data):
# run only in the installer on s390(x) machines
return environment == ANACONDA_ENVIRON and arch.isS390()
def on_back_clicked(self, button):
# We can't exit early if it looks like nothing has changed because the
# user might want to change settings presented in the dialogs shown from
# within this method.
# Do not enter this method multiple times if user clicking multiple times
# on back button
if self._back_clicked:
return
else:
self._back_clicked = True
# make sure the snapshot of unmodified on-disk-storage model is created
if not on_disk_storage.created:
on_disk_storage.create_snapshot(self.storage)
if self.autopart_missing_passphrase:
self._setup_passphrase()
NormalSpoke.on_back_clicked(self, button)
return
# No disks selected? The user wants to back out of the storage spoke.
if not self.selected_disks:
NormalSpoke.on_back_clicked(self, button)
return
disk_selection_changed = False
if self._last_selected_disks:
disk_selection_changed = (self._last_selected_disks != set(
self.selected_disks))
# remember the disk selection for future decisions
self._last_selected_disks = set(self.selected_disks)
if disk_selection_changed:
# Changing disk selection is really, really complicated and has
# always been causing numerous hard bugs. Let's not play the hero
# game and just revert everything and start over again.
on_disk_storage.reset_to_snapshot(self.storage)
self.disks = getDisks(self.storage.devicetree)
else:
# Remove all non-existing devices if autopart was active when we last
# refreshed.
if self._previous_autopart:
self._previous_autopart = False
self._remove_nonexistant_partitions()
# hide disks as requested
self._hide_disks()
# make sure no containers were split up by the user's disk selection
self.clear_info()
# if there are some disk selection errors we don't let user to leave the
# spoke, so these errors don't have to go to self.errors
self.disks_errors = checkDiskSelection(self.storage,
self.selected_disks)
if self.disks_errors:
# The disk selection has to make sense before we can proceed.
self.set_error(
_("There was a problem with your disk selection. "
"Click here for details."))
self._back_clicked = False
return
if arch.isS390():
# check for unformatted DASDs and launch dasdfmt if any discovered
rc = self._check_dasd_formats()
if rc == DASD_FORMAT_NO_CHANGE:
pass
elif rc == DASD_FORMAT_REFRESH:
# User hit OK on the dialog
self.refresh()
elif rc == DASD_FORMAT_RETURN_TO_HUB:
# User clicked uri to return to hub.
NormalSpoke.on_back_clicked(self, button)
return
else:
# User either hit cancel on the dialog or closed it via escape,
# there was no formatting done.
self._back_clicked = False
return
# even if they're not doing autopart, setting autopart.encrypted
# establishes a default of encrypting new devices
self.encrypted = self._encrypted.get_active()
# We might first need to ask about an encryption passphrase.
if self.encrypted and not self._setup_passphrase():
self._back_clicked = False
return
# At this point there are three possible states:
# 1) user chose custom part => just send them to the CustomPart spoke
# 2) user wants to reclaim some more space => run the ResizeDialog
# 3) we are just asked to do autopart => check free space and see if we need
# user to do anything more
self.autopart = not self._customPart.get_active()
disks = [d for d in self.disks if d.name in self.selected_disks]
dialog = None
if not self.autopart:
self.skipTo = "CustomPartitioningSpoke"
elif self._reclaim.get_active():
# HINT: change the logic of this 'if' statement if we are asked to
# support "reclaim before custom partitioning"
# respect disk selection and other choices in the ReclaimDialog
self.apply()
dialog = ResizeDialog(self.data, self.storage, self.payload)
dialog.refresh(disks)
else:
dialog = self._check_space_and_get_dialog(disks)
if dialog:
# more dialogs may need to be run based on user choices, but we are
# only interested in the final result
rc = self._run_dialogs(disks, start_with=dialog)
if rc == RESPONSE_OK:
# nothing special needed
pass
elif rc == RESPONSE_CANCEL:
# A cancel button was clicked on one of the dialogs. Stay on this
# spoke. Generally, this is because the user wants to add more disks.
self._back_clicked = False
return
elif rc == RESPONSE_MODIFY_SW:
# The "Fedora software selection" link was clicked on one of the
# dialogs. Send the user to the software spoke.
self.skipTo = "SoftwareSelectionSpoke"
elif rc == RESPONSE_QUIT:
# Not enough space, and the user can't do anything about it so
# they chose to quit.
raise SystemExit("user-selected exit")
else:
# I don't know how we'd get here, but might as well have a
# catch-all. Just stay on this spoke.
self._back_clicked = False
return
if self.autopart:
refreshAutoSwapSize(self.storage)
self.applyOnSkip = True
NormalSpoke.on_back_clicked(self, button)
def on_back_clicked(self, button):
# We can't exit early if it looks like nothing has changed because the
# user might want to change settings presented in the dialogs shown from
# within this method.
# Remove all non-existing devices if autopart was active when we last
# refreshed.
if self._previous_autopart:
self._previous_autopart = False
for partition in self.storage.partitions[:]:
# check if it's been removed in a previous iteration
if not partition.exists and \
partition in self.storage.partitions:
self.storage.recursiveRemove(partition)
# hide/unhide disks as requested
for disk in self.disks:
if disk.name not in self.selected_disks and \
disk in self.storage.devices:
self.storage.devicetree.hide(disk)
elif disk.name in self.selected_disks and \
disk not in self.storage.devices:
self.storage.devicetree.unhide(disk)
# show the installation options dialog
disks = [d for d in self.disks if d.name in self.selected_disks]
disks_size = sum(Size(spec="%f MB" % d.size) for d in disks)
# No disks selected? The user wants to back out of the storage spoke.
if not disks:
NormalSpoke.on_back_clicked(self, button)
return
if arch.isS390():
# check for unformatted DASDs and launch dasdfmt if any discovered
dasds = make_unformatted_dasd_list(self.selected_disks)
if len(dasds) > 0:
dialog = DasdFormatDialog(self.data, self.storage, dasds)
ignoreEscape(dialog.window)
rc = self.run_lightbox_dialog(dialog)
if rc == 1:
# User hit OK on the dialog, indicating they stayed on the
# dialog until formatting completed; make sure we stay on
# the storage spoke and don't return to the summary hub
self.skipTo = "StorageSpoke"
# we have to manaually call refresh so changes are picked up
self.refresh()
elif rc == 2:
# User clicked uri to return to hub.
NormalSpoke.on_back_clicked(self, button)
return
elif rc != 2:
# User either hit cancel on the dialog or closed it via escape, so
# there was no formatting done.
# NOTE: rc == 2 means the user clicked on the link that takes them
# back to the hub.
return
# Figure out if the existing disk labels will work on this platform
# you need to have at least one of the platform's labels in order for
# any of the free space to be useful.
disk_labels = set(disk.format.labelType for disk in disks
if hasattr(disk.format, "labelType"))
platform_labels = set(platform.diskLabelTypes)
if disk_labels and platform_labels.isdisjoint(disk_labels):
disk_free = 0
fs_free = 0
log.debug("Need disklabel: %s have: %s" %
(", ".join(platform_labels), ", ".join(disk_labels)))
else:
free_space = self.storage.getFreeSpace(
disks=disks, clearPartType=CLEARPART_TYPE_NONE)
disk_free = sum(f[0] for f in free_space.itervalues())
fs_free = sum(f[1] for f in free_space.itervalues())
required_space = self.payload.spaceRequired
auto_swap = Size(bytes=0)
for autoreq in self.storage.autoPartitionRequests:
if autoreq.fstype == "swap":
auto_swap += Size(spec="%d MB" % autoreq.size)
log.debug("disk free: %s fs free: %s sw needs: %s auto swap: %s" %
(disk_free, fs_free, required_space, auto_swap))
if disk_free >= required_space + auto_swap:
dialog = None
elif disks_size >= required_space:
if self._customPart.get_active() or self._reclaim.get_active():
dialog = None
else:
dialog = InstallOptions1Dialog(self.data, payload=self.payload)
dialog.refresh(required_space, auto_swap, disk_free, fs_free)
rc = self.run_lightbox_dialog(dialog)
else:
dialog = InstallOptions2Dialog(self.data, payload=self.payload)
dialog.refresh(required_space, auto_swap, disk_free, fs_free)
rc = self.run_lightbox_dialog(dialog)
if not dialog:
# Plenty of room - there's no need to pop up a dialog, so just send
# the user to wherever they asked to go. That's either the custom
# spoke or the hub.
# - OR -
# Not enough room, but the user checked the reclaim button.
self.encrypted = self._encrypted.get_active()
if self._customPart.get_active():
self.autopart = False
self.skipTo = "CustomPartitioningSpoke"
else:
self.autopart = True
# We might first need to ask about an encryption passphrase.
if not self._check_encrypted():
return
# Oh and then we might also want to go to the reclaim dialog.
if self._reclaim.get_active():
self.apply()
if not self._show_resize_dialog(disks):
# User pressed cancel on the reclaim dialog, so don't leave
# the storage spoke.
return
elif rc == RESPONSE_CANCEL:
# A cancel button was clicked on one of the dialogs. Stay on this
# spoke. Generally, this is because the user wants to add more disks.
return
elif rc == RESPONSE_MODIFY_SW:
# The "Fedora software selection" link was clicked on one of the
# dialogs. Send the user to the software spoke.
self.skipTo = "SoftwareSelectionSpoke"
elif rc == RESPONSE_RECLAIM:
# Not enough space, but the user can make enough if they do some
# work and free up space.
self.encrypted = self._encrypted.get_active()
if not self._check_encrypted():
return
self.apply()
if not self._show_resize_dialog(disks):
# User pressed cancel on the reclaim dialog, so don't leave
# the storage spoke.
return
# And then go to the custom partitioning spoke if they chose to
# do so.
if self._customPart.get_active():
self.autopart = False
self.skipTo = "CustomPartitioningSpoke"
else:
self.autopart = True
elif rc == RESPONSE_QUIT:
# Not enough space, and the user can't do anything about it so
# they chose to quit.
raise SystemExit("user-selected exit")
else:
# I don't know how we'd get here, but might as well have a
# catch-all. Just stay on this spoke.
return
self.applyOnSkip = True
NormalSpoke.on_back_clicked(self, button)
if product.isFinal:
print("anaconda %s started." % verdesc)
else:
print("anaconda %s (pre-release) started." % verdesc)
# we are past the --version and --help shortcut so we can import Blivet
# now without slowing down anything critical
# pylint: disable=import-error
from blivet import arch
if not opts.images and not opts.dirinstall:
print(logs_note)
# no fancy stuff like TTYs on a s390...
if not arch.isS390():
if "TMUX" in os.environ and os.environ.get("TERM") == "screen":
print(shell_and_tmux_note)
else:
print(shell_only_note) # TMUX is not running
# ...but there is apparently TMUX during the manual installation on s390!
elif not opts.ksfile:
print(tmux_only_note) # but not during kickstart installation
# no need to tell users how to switch to text mode
# if already in text mode
if opts.display_mode == 'g':
print(text_mode_note)
print(separate_attachements_note)
from pyanaconda.anaconda import Anaconda
anaconda = Anaconda()
def sanity_check(storage, min_ram=isys.MIN_RAM):
"""
Run a series of tests to verify the storage configuration.
This function is called at the end of partitioning so that
we can make sure you don't have anything silly (like no /,
a really small /, etc).
:param storage: an instance of the :class:`blivet.Blivet` class to check
:param min_ram: minimum RAM (in MiB) needed for the installation with swap
space available
:rtype: a list of SanityExceptions
:return: a list of accumulated errors and warnings
"""
exns = []
checkSizes = [('/usr', Size("250 MiB")), ('/tmp', Size("50 MiB")),
('/var', Size("384 MiB")), ('/home', Size("100 MiB")),
('/boot', Size("200 MiB"))]
mustbeonlinuxfs = [
'/', '/var', '/tmp', '/usr', '/home', '/usr/share', '/usr/lib'
]
mustbeonroot = [
'/bin', '/dev', '/sbin', '/etc', '/lib', '/root', '/mnt', 'lost+found',
'/proc'
]
filesystems = storage.mountpoints
root = storage.fsset.rootDevice
swaps = storage.fsset.swapDevices
if root:
if root.size < Size("250 MiB"):
exns.append(
SanityWarning(
_("Your root partition is less than 250 "
"megabytes which is usually too small to "
"install %s.") % (productName, )))
else:
exns.append(
SanityError(
_("You have not defined a root partition (/), "
"which is required for installation of %s "
"to continue.") % (productName, )))
# Prevent users from installing on s390x with (a) no /boot volume, (b) the
# root volume on LVM, and (c) the root volume not restricted to a single
# PV
# NOTE: There is not really a way for users to create a / volume
# restricted to a single PV. The backend support is there, but there are
# no UI hook-ups to drive that functionality, but I do not personally
# care. --dcantrell
if arch.isS390() and '/boot' not in storage.mountpoints and root:
if root.type == 'lvmlv' and not root.singlePV:
exns.append(
SanityError(
_("This platform requires /boot on a dedicated "
"partition or logical volume. If you do not "
"want a /boot volume, you must place / on a "
"dedicated non-LVM partition.")))
# FIXME: put a check here for enough space on the filesystems. maybe?
for (mount, size) in checkSizes:
if mount in filesystems and filesystems[mount].size < size:
exns.append(
SanityWarning(
_("Your %(mount)s partition is less than "
"%(size)s which is lower than recommended "
"for a normal %(productName)s install.") % {
'mount': mount,
'size': size,
'productName': productName
}))
# storage.mountpoints is a property that returns a new dict each time, so
# iterating over it is thread-safe.
for (mount, device) in filesystems.items():
problem = filesystems[mount].checkSize()
if problem < 0:
exns.append(
SanityError(
_("Your %(mount)s partition is too small for %(format)s formatting "
"(allowable size is %(minSize)s to %(maxSize)s)") % {
"mount": mount,
"format": device.format.name,
"minSize": device.minSize,
"maxSize": device.maxSize
}))
elif problem > 0:
exns.append(
SanityError(
_("Your %(mount)s partition is too large for %(format)s formatting "
"(allowable size is %(minSize)s to %(maxSize)s)") % {
"mount": mount,
"format": device.format.name,
"minSize": device.minSize,
"maxSize": device.maxSize
}))
if storage.bootloader and not storage.bootloader.skip_bootloader:
stage1 = storage.bootloader.stage1_device
if not stage1:
exns.append(
SanityError(
_("No valid boot loader target device found. "
"See below for details.")))
pe = _platform.stage1MissingError
if pe:
exns.append(SanityError(_(pe)))
else:
storage.bootloader.is_valid_stage1_device(stage1)
exns.extend(SanityError(msg) for msg in storage.bootloader.errors)
exns.extend(
SanityWarning(msg) for msg in storage.bootloader.warnings)
stage2 = storage.bootloader.stage2_device
if stage1 and not stage2:
exns.append(
SanityError(_("You have not created a bootable partition.")))
else:
storage.bootloader.is_valid_stage2_device(stage2)
exns.extend(SanityError(msg) for msg in storage.bootloader.errors)
exns.extend(
SanityWarning(msg) for msg in storage.bootloader.warnings)
if not storage.bootloader.check():
exns.extend(
SanityError(msg) for msg in storage.bootloader.errors)
#
# check that GPT boot disk on BIOS system has a BIOS boot partition
#
if _platform.weight(fstype="biosboot") and \
stage1 and stage1.isDisk and \
getattr(stage1.format, "labelType", None) == "gpt":
missing = True
for part in [p for p in storage.partitions if p.disk == stage1]:
if part.format.type == "biosboot":
missing = False
break
if missing:
exns.append(
SanityError(
_("Your BIOS-based system needs a special "
"partition to boot from a GPT disk label. "
"To continue, please create a 1MiB "
"'biosboot' type partition.")))
if not swaps:
installed = util.total_memory()
required = Size("%s MiB" % (min_ram + isys.NO_SWAP_EXTRA_RAM))
if installed < required:
exns.append(
SanityError(
_("You have not specified a swap partition. "
"%(requiredMem)s of memory is required to continue installation "
"without a swap partition, but you only have %(installedMem)s."
) % {
"requiredMem": required,
"installedMem": installed
}))
else:
exns.append(
SanityWarning(
_("You have not specified a swap partition. "
"Although not strictly required in all cases, "
"it will significantly improve performance "
"for most installations.")))
no_uuid = [s for s in swaps if s.format.exists and not s.format.uuid]
if no_uuid:
exns.append(
SanityWarning(
_("At least one of your swap devices does not have "
"a UUID, which is common in swap space created "
"using older versions of mkswap. These devices "
"will be referred to by device path in "
"/etc/fstab, which is not ideal since device "
"paths can change under a variety of "
"circumstances. ")))
for (mountpoint, dev) in filesystems.items():
if mountpoint in mustbeonroot:
exns.append(
SanityError(
_("This mount point is invalid. The %s directory must "
"be on the / file system.") % mountpoint))
if mountpoint in mustbeonlinuxfs and (not dev.format.mountable
or not dev.format.linuxNative):
exns.append(
SanityError(
_("The mount point %s must be on a linux file system.") %
mountpoint))
if storage.rootDevice and storage.rootDevice.format.exists:
e = storage.mustFormat(storage.rootDevice)
if e:
exns.append(SanityError(e))
exns += verify_LUKS_devices_have_key(storage)
return exns
def on_back_clicked(self, button):
# We can't exit early if it looks like nothing has changed because the
# user might want to change settings presented in the dialogs shown from
# within this method.
# Do not enter this method multiple times if user clicking multiple times
# on back button
if self._back_clicked:
return
else:
self._back_clicked = True
# Remove all non-existing devices if autopart was active when we last
# refreshed.
if self._previous_autopart:
self._previous_autopart = False
for partition in self.storage.partitions[:]:
# check if it's been removed in a previous iteration
if not partition.exists and \
partition in self.storage.partitions:
self.storage.recursiveRemove(partition)
# make sure no containers were split up by the user's disk selection
self.clear_info()
self.errors = checkDiskSelection(self.storage, self.selected_disks)
if self.errors:
# The disk selection has to make sense before we can proceed.
self.set_error(_("There was a problem with your disk selection. "
"Click here for details."))
self._back_clicked = False
return
# hide/unhide disks as requested
for disk in self.disks:
if disk.name not in self.selected_disks and \
disk in self.storage.devices:
self.storage.devicetree.hide(disk)
elif disk.name in self.selected_disks and \
disk not in self.storage.devices:
self.storage.devicetree.unhide(disk)
# show the installation options dialog
disks = [d for d in self.disks if d.name in self.selected_disks]
disks_size = sum((d.size for d in disks), Size(0))
# No disks selected? The user wants to back out of the storage spoke.
if not disks:
NormalSpoke.on_back_clicked(self, button)
return
if arch.isS390():
# check for unformatted DASDs and launch dasdfmt if any discovered
dasds = self.storage.devicetree.make_unformatted_dasd_list(disks)
if len(dasds) > 0:
# We want to apply current selection before running dasdfmt to
# prevent this information from being lost afterward
applyDiskSelection(self.storage, self.data, self.selected_disks)
dialog = DasdFormatDialog(self.data, self.storage, dasds)
ignoreEscape(dialog.window)
rc = self.run_lightbox_dialog(dialog)
if rc == 1:
# User hit OK on the dialog
self.refresh()
elif rc == 2:
# User clicked uri to return to hub.
NormalSpoke.on_back_clicked(self, button)
return
elif rc != 2:
# User either hit cancel on the dialog or closed it via escape,
# there was no formatting done.
# NOTE: rc == 2 means the user clicked on the link that takes t
# back to the hub.
self._back_clicked = False
return
# Figure out if the existing disk labels will work on this platform
# you need to have at least one of the platform's labels in order for
# any of the free space to be useful.
disk_labels = set(disk.format.labelType for disk in disks
if hasattr(disk.format, "labelType"))
platform_labels = set(platform.diskLabelTypes)
if disk_labels and platform_labels.isdisjoint(disk_labels):
disk_free = 0
fs_free = 0
log.debug("Need disklabel: %s have: %s", ", ".join(platform_labels),
", ".join(disk_labels))
else:
free_space = self.storage.getFreeSpace(disks=disks,
clearPartType=CLEARPART_TYPE_NONE)
disk_free = sum(f[0] for f in free_space.values())
fs_free = sum(f[1] for f in free_space.values())
required_space = self.payload.spaceRequired
auto_swap = sum((r.size for r in self.storage.autoPartitionRequests
if r.fstype == "swap"), Size(0))
if self.autopart and auto_swap == Size(0):
# autopartitioning requested, but not applied yet (=> no auto swap
# requests), ask user for enough space to fit in the suggested swap
auto_swap = autopart.swapSuggestion()
log.debug("disk free: %s fs free: %s sw needs: %s auto swap: %s",
disk_free, fs_free, required_space, auto_swap)
if disk_free >= required_space + auto_swap:
dialog = None
elif disks_size >= required_space:
if self._customPart.get_active() or self._reclaim.get_active():
dialog = None
else:
dialog = NeedSpaceDialog(self.data, payload=self.payload)
dialog.refresh(required_space, auto_swap, disk_free, fs_free)
rc = self.run_lightbox_dialog(dialog)
else:
dialog = NoSpaceDialog(self.data, payload=self.payload)
dialog.refresh(required_space, auto_swap, disk_free, fs_free)
rc = self.run_lightbox_dialog(dialog)
if not dialog:
# Plenty of room - there's no need to pop up a dialog, so just send
# the user to wherever they asked to go. That's either the custom
# spoke or the hub.
# - OR -
# Not enough room, but the user checked the reclaim button.
self.encrypted = self._encrypted.get_active()
if self._customPart.get_active():
self.autopart = False
self.skipTo = "CustomPartitioningSpoke"
else:
self.autopart = True
# We might first need to ask about an encryption passphrase.
if not self._check_encrypted():
self._back_clicked = False
return
# Oh and then we might also want to go to the reclaim dialog.
if self._reclaim.get_active():
self.apply()
if not self._show_resize_dialog(disks):
# User pressed cancel on the reclaim dialog, so don't leave
# the storage spoke.
self._back_clicked = False
return
elif rc == RESPONSE_CANCEL:
# A cancel button was clicked on one of the dialogs. Stay on this
# spoke. Generally, this is because the user wants to add more disks.
self._back_clicked = False
return
elif rc == RESPONSE_MODIFY_SW:
# The "Fedora software selection" link was clicked on one of the
# dialogs. Send the user to the software spoke.
self.skipTo = "SoftwareSelectionSpoke"
elif rc == RESPONSE_RECLAIM:
# Not enough space, but the user can make enough if they do some
# work and free up space.
self.encrypted = self._encrypted.get_active()
if not self._check_encrypted():
return
self.apply()
if not self._show_resize_dialog(disks):
# User pressed cancel on the reclaim dialog, so don't leave
# the storage spoke.
self._back_clicked = False
return
# And then go to the custom partitioning spoke if they chose to
# do so.
if self._customPart.get_active():
self.autopart = False
self.skipTo = "CustomPartitioningSpoke"
else:
self.autopart = True
elif rc == RESPONSE_QUIT:
# Not enough space, and the user can't do anything about it so
# they chose to quit.
raise SystemExit("user-selected exit")
else:
# I don't know how we'd get here, but might as well have a
# catch-all. Just stay on this spoke.
self._back_clicked = False
return
if self.autopart:
refreshAutoSwapSize(self.storage)
self.applyOnSkip = True
NormalSpoke.on_back_clicked(self, button)
def on_back_clicked(self, button):
# We can't exit early if it looks like nothing has changed because the
# user might want to change settings presented in the dialogs shown from
# within this method.
# Do not enter this method multiple times if user clicking multiple times
# on back button
if self._back_clicked:
return
else:
self._back_clicked = True
# Remove all non-existing devices if autopart was active when we last
# refreshed.
if self._previous_autopart:
self._previous_autopart = False
for partition in self.storage.partitions[:]:
# check if it's been removed in a previous iteration
if not partition.exists and \
partition in self.storage.partitions:
self.storage.recursiveRemove(partition)
# make sure no containers were split up by the user's disk selection
self.clear_info()
self.errors = checkDiskSelection(self.storage, self.selected_disks)
if self.errors:
# The disk selection has to make sense before we can proceed.
self.set_error(
_("There was a problem with your disk selection. "
"Click here for details."))
self._back_clicked = False
return
# hide/unhide disks as requested
for disk in self.disks:
if disk.name not in self.selected_disks and \
disk in self.storage.devices:
self.storage.devicetree.hide(disk)
elif disk.name in self.selected_disks and \
disk not in self.storage.devices:
self.storage.devicetree.unhide(disk)
# show the installation options dialog
disks = [d for d in self.disks if d.name in self.selected_disks]
disks_size = sum((d.size for d in disks), Size(0))
# No disks selected? The user wants to back out of the storage spoke.
if not disks:
NormalSpoke.on_back_clicked(self, button)
return
if arch.isS390():
# check for unformatted DASDs and launch dasdfmt if any discovered
dasds = self.storage.devicetree.make_unformatted_dasd_list(disks)
if len(dasds) > 0:
# We want to apply current selection before running dasdfmt to
# prevent this information from being lost afterward
applyDiskSelection(self.storage, self.data,
self.selected_disks)
dialog = DasdFormatDialog(self.data, self.storage, dasds)
ignoreEscape(dialog.window)
rc = self.run_lightbox_dialog(dialog)
if rc == 1:
# User hit OK on the dialog
self.refresh()
elif rc == 2:
# User clicked uri to return to hub.
NormalSpoke.on_back_clicked(self, button)
return
elif rc != 2:
# User either hit cancel on the dialog or closed it via escape,
# there was no formatting done.
# NOTE: rc == 2 means the user clicked on the link that takes t
# back to the hub.
self._back_clicked = False
return
# Figure out if the existing disk labels will work on this platform
# you need to have at least one of the platform's labels in order for
# any of the free space to be useful.
disk_labels = set(disk.format.labelType for disk in disks
if hasattr(disk.format, "labelType"))
platform_labels = set(platform.diskLabelTypes)
if disk_labels and platform_labels.isdisjoint(disk_labels):
disk_free = 0
fs_free = 0
log.debug("Need disklabel: %s have: %s",
", ".join(platform_labels), ", ".join(disk_labels))
else:
free_space = self.storage.getFreeSpace(
disks=disks, clearPartType=CLEARPART_TYPE_NONE)
disk_free = sum(f[0] for f in free_space.values())
fs_free = sum(f[1] for f in free_space.values())
required_space = self.payload.spaceRequired
auto_swap = sum((r.size for r in self.storage.autoPartitionRequests
if r.fstype == "swap"), Size(0))
if self.autopart and auto_swap == Size(0):
# autopartitioning requested, but not applied yet (=> no auto swap
# requests), ask user for enough space to fit in the suggested swap
auto_swap = autopart.swapSuggestion()
log.debug("disk free: %s fs free: %s sw needs: %s auto swap: %s",
disk_free, fs_free, required_space, auto_swap)
if disk_free >= required_space + auto_swap:
dialog = None
elif disks_size >= required_space:
if self._customPart.get_active() or self._reclaim.get_active():
dialog = None
else:
dialog = NeedSpaceDialog(self.data, payload=self.payload)
dialog.refresh(required_space, auto_swap, disk_free, fs_free)
rc = self.run_lightbox_dialog(dialog)
else:
dialog = NoSpaceDialog(self.data, payload=self.payload)
dialog.refresh(required_space, auto_swap, disk_free, fs_free)
rc = self.run_lightbox_dialog(dialog)
if not dialog:
# Plenty of room - there's no need to pop up a dialog, so just send
# the user to wherever they asked to go. That's either the custom
# spoke or the hub.
# - OR -
# Not enough room, but the user checked the reclaim button.
self.encrypted = self._encrypted.get_active()
if self._customPart.get_active():
self.autopart = False
self.skipTo = "CustomPartitioningSpoke"
else:
self.autopart = True
# We might first need to ask about an encryption passphrase.
if not self._check_encrypted():
self._back_clicked = False
return
# Oh and then we might also want to go to the reclaim dialog.
if self._reclaim.get_active():
self.apply()
if not self._show_resize_dialog(disks):
# User pressed cancel on the reclaim dialog, so don't leave
# the storage spoke.
self._back_clicked = False
return
elif rc == RESPONSE_CANCEL:
# A cancel button was clicked on one of the dialogs. Stay on this
# spoke. Generally, this is because the user wants to add more disks.
self._back_clicked = False
return
elif rc == RESPONSE_MODIFY_SW:
# The "Fedora software selection" link was clicked on one of the
# dialogs. Send the user to the software spoke.
self.skipTo = "SoftwareSelectionSpoke"
elif rc == RESPONSE_RECLAIM:
# Not enough space, but the user can make enough if they do some
# work and free up space.
self.encrypted = self._encrypted.get_active()
if not self._check_encrypted():
return
self.apply()
if not self._show_resize_dialog(disks):
# User pressed cancel on the reclaim dialog, so don't leave
# the storage spoke.
self._back_clicked = False
return
# And then go to the custom partitioning spoke if they chose to
# do so.
if self._customPart.get_active():
self.autopart = False
self.skipTo = "CustomPartitioningSpoke"
else:
self.autopart = True
elif rc == RESPONSE_QUIT:
# Not enough space, and the user can't do anything about it so
# they chose to quit.
raise SystemExit("user-selected exit")
else:
# I don't know how we'd get here, but might as well have a
# catch-all. Just stay on this spoke.
self._back_clicked = False
return
if self.autopart:
refreshAutoSwapSize(self.storage)
self.applyOnSkip = True
NormalSpoke.on_back_clicked(self, button)
def setupDisplay(anaconda, options, addons=None):
from pyanaconda.ui.tui.simpleline import App
from pyanaconda.ui.tui.spokes.askvnc import AskVNCSpoke
from pykickstart.constants import DISPLAY_MODE_TEXT
from pyanaconda.nm import nm_is_connected, nm_is_connecting
from blivet import arch
graphical_failed = 0
vncS = vnc.VncServer() # The vnc Server object.
vncS.anaconda = anaconda
anaconda.displayMode = options.display_mode
anaconda.isHeadless = arch.isS390()
if options.vnc:
flags.usevnc = True
anaconda.displayMode = 'g'
vncS.password = options.vncpassword
# Only consider vncconnect when vnc is a param
if options.vncconnect:
cargs = options.vncconnect.split(":")
vncS.vncconnecthost = cargs[0]
if len(cargs) > 1 and len(cargs[1]) > 0:
if len(cargs[1]) > 0:
vncS.vncconnectport = cargs[1]
if options.xdriver:
anaconda.xdriver = options.xdriver
anaconda.writeXdriver(root="/")
if flags.rescue_mode:
return
if anaconda.ksdata.vnc.enabled:
flags.usevnc = True
anaconda.displayMode = 'g'
if vncS.password == "":
vncS.password = anaconda.ksdata.vnc.password
if vncS.vncconnecthost == "":
vncS.vncconnecthost = anaconda.ksdata.vnc.host
if vncS.vncconnectport == "":
vncS.vncconnectport = anaconda.ksdata.vnc.port
if anaconda.displayMode == "g":
import pkgutil
import pyanaconda.ui
mods = (tup[1] for tup in pkgutil.iter_modules(pyanaconda.ui.__path__,
"pyanaconda.ui."))
if "pyanaconda.ui.gui" not in mods:
stdoutLog.warning(
"Graphical user interface not available, falling back to text mode"
)
anaconda.displayMode = "t"
flags.usevnc = False
flags.vncquestion = False
# disable VNC over text question when not enough memory is available
if blivet.util.total_memory() < isys.MIN_GUI_RAM:
stdoutLog.warning(
"Not asking for VNC because current memory (%d) < MIN_GUI_RAM (%d)",
blivet.util.total_memory(), isys.MIN_GUI_RAM)
flags.vncquestion = False
# disable VNC question if text mode is requested and this is a ks install
if anaconda.displayMode == 't' and flags.automatedInstall:
stdoutLog.warning("Not asking for VNC because of an automated install")
flags.vncquestion = False
# disable VNC question if we were explicitly asked for text in kickstart
if anaconda.ksdata.displaymode.displayMode == DISPLAY_MODE_TEXT:
stdoutLog.warning(
"Not asking for VNC because text mode was explicitly asked for in kickstart"
)
flags.vncquestion = False
# disable VNC question if we don't have network
if not nm_is_connecting() and not nm_is_connected():
stdoutLog.warning("Not asking for VNC because we don't have a network")
flags.vncquestion = False
# disable VNC question if we don't have Xvnc
if not os.access('/usr/bin/Xvnc', os.X_OK):
stdoutLog.warning("Not asking for VNC because we don't have Xvnc")
flags.vncquestion = False
# Should we try to start Xorg?
want_x = anaconda.displayMode == 'g' and \
not (flags.preexisting_x11 or flags.usevnc)
# X on a headless (e.g. s390) system? Nonsense!
if want_x and anaconda.isHeadless:
stdoutLog.warning(_("DISPLAY variable not set. Starting text mode."))
anaconda.displayMode = 't'
graphical_failed = 1
time.sleep(2)
want_x = False
# Is Xorg is actually available?
if want_x and not os.access("/usr/bin/Xorg", os.X_OK):
stdoutLog.warning(
_("Graphical installation is not available. "
"Starting text mode."))
time.sleep(2)
anaconda.displayMode = 't'
want_x = False
if anaconda.displayMode == 't' and flags.vncquestion:
#we prefer vnc over text mode, so ask about that
message = _("Text mode provides a limited set of installation "
"options. It does not offer custom partitioning for "
"full control over the disk layout. Would you like "
"to use VNC mode instead?")
app = App("VNC Question")
spoke = AskVNCSpoke(app, anaconda.ksdata, message=message)
app.schedule_screen(spoke)
app.run()
if anaconda.ksdata.vnc.enabled:
anaconda.displayMode = 'g'
flags.usevnc = True
vncS.password = anaconda.ksdata.vnc.password
else:
# user has explicitly specified text mode
flags.vncquestion = False
log.info("Display mode = %s", anaconda.displayMode)
check_memory(anaconda, options)
# check_memory may have changed the display mode
want_x = want_x and (anaconda.displayMode == "g")
if want_x:
try:
startX11()
doStartupX11Actions()
except (OSError, RuntimeError) as e:
log.warning("X startup failed: %s", e)
stdoutLog.warning("X startup failed, falling back to text mode")
anaconda.displayMode = 't'
graphical_failed = 1
time.sleep(2)
if not graphical_failed:
doExtraX11Actions(options.runres)
if anaconda.displayMode == 't' and graphical_failed and \
flags.vncquestion and not anaconda.ksdata.vnc.enabled:
app = App("VNC Question")
spoke = AskVNCSpoke(app, anaconda.ksdata)
app.schedule_screen(spoke)
app.run()
if anaconda.ksdata.vnc.enabled:
anaconda.displayMode = 'g'
flags.usevnc = True
vncS.password = anaconda.ksdata.vnc.password
# if they want us to use VNC do that now
if anaconda.displayMode == 'g' and flags.usevnc:
vncS.startServer()
doStartupX11Actions()
# with X running we can initialize the UI interface
anaconda.initInterface(addons)
anaconda.instClass.configure(anaconda)
# report if starting the GUI failed
anaconda.gui_startup_failed = bool(graphical_failed)
def setupDisplay(anaconda, options, addons=None):
from pyanaconda.ui.tui.simpleline import App
from pyanaconda.ui.tui.spokes.askvnc import AskVNCSpoke
from pykickstart.constants import DISPLAY_MODE_TEXT
from pyanaconda.nm import nm_is_connected, nm_is_connecting
from blivet import arch
graphical_failed = 0
vncS = vnc.VncServer() # The vnc Server object.
vncS.anaconda = anaconda
anaconda.displayMode = options.display_mode
anaconda.isHeadless = arch.isS390()
if options.vnc:
flags.usevnc = True
anaconda.displayMode = 'g'
vncS.password = options.vncpassword
# Only consider vncconnect when vnc is a param
if options.vncconnect:
cargs = options.vncconnect.split(":")
vncS.vncconnecthost = cargs[0]
if len(cargs) > 1 and len(cargs[1]) > 0:
if len(cargs[1]) > 0:
vncS.vncconnectport = cargs[1]
if options.xdriver:
anaconda.xdriver = options.xdriver
anaconda.writeXdriver(root="/")
if flags.rescue_mode:
return
if anaconda.ksdata.vnc.enabled:
flags.usevnc = True
anaconda.displayMode = 'g'
if vncS.password == "":
vncS.password = anaconda.ksdata.vnc.password
if vncS.vncconnecthost == "":
vncS.vncconnecthost = anaconda.ksdata.vnc.host
if vncS.vncconnectport == "":
vncS.vncconnectport = anaconda.ksdata.vnc.port
if anaconda.displayMode == "g":
import pkgutil
import pyanaconda.ui
mods = (tup[1] for tup in pkgutil.iter_modules(pyanaconda.ui.__path__, "pyanaconda.ui."))
if "pyanaconda.ui.gui" not in mods:
stdoutLog.warning("Graphical user interface not available, falling back to text mode")
anaconda.displayMode = "t"
flags.usevnc = False
flags.vncquestion = False
# disable VNC over text question when not enough memory is available
if blivet.util.total_memory() < isys.MIN_GUI_RAM:
stdoutLog.warning("Not asking for VNC because current memory (%d) < MIN_GUI_RAM (%d)", blivet.util.total_memory(), isys.MIN_GUI_RAM)
flags.vncquestion = False
# disable VNC question if text mode is requested and this is a ks install
if anaconda.displayMode == 't' and flags.automatedInstall:
stdoutLog.warning("Not asking for VNC because of an automated install")
flags.vncquestion = False
# disable VNC question if we were explicitly asked for text in kickstart
if anaconda.ksdata.displaymode.displayMode == DISPLAY_MODE_TEXT:
stdoutLog.warning("Not asking for VNC because text mode was explicitly asked for in kickstart")
flags.vncquestion = False
# disable VNC question if we don't have network
if not nm_is_connecting() and not nm_is_connected():
stdoutLog.warning("Not asking for VNC because we don't have a network")
flags.vncquestion = False
# disable VNC question if we don't have Xvnc
if not os.access('/usr/bin/Xvnc', os.X_OK):
stdoutLog.warning("Not asking for VNC because we don't have Xvnc")
flags.vncquestion = False
# Should we try to start Xorg?
want_x = anaconda.displayMode == 'g' and \
not (flags.preexisting_x11 or flags.usevnc)
# X on a headless (e.g. s390) system? Nonsense!
if want_x and anaconda.isHeadless:
stdoutLog.warning(_("DISPLAY variable not set. Starting text mode."))
anaconda.displayMode = 't'
graphical_failed = 1
time.sleep(2)
want_x = False
# Is Xorg is actually available?
if want_x and not os.access("/usr/bin/Xorg", os.X_OK):
stdoutLog.warning(_("Graphical installation is not available. "
"Starting text mode."))
time.sleep(2)
anaconda.displayMode = 't'
want_x = False
if anaconda.displayMode == 't' and flags.vncquestion:
#we prefer vnc over text mode, so ask about that
message = _("Text mode provides a limited set of installation "
"options. It does not offer custom partitioning for "
"full control over the disk layout. Would you like "
"to use VNC mode instead?")
app = App("VNC Question")
spoke = AskVNCSpoke(app, anaconda.ksdata, message=message)
app.schedule_screen(spoke)
app.run()
if anaconda.ksdata.vnc.enabled:
anaconda.displayMode = 'g'
flags.usevnc = True
vncS.password = anaconda.ksdata.vnc.password
else:
# user has explicitly specified text mode
flags.vncquestion = False
log.info("Display mode = %s", anaconda.displayMode)
check_memory(anaconda, options)
# check_memory may have changed the display mode
want_x = want_x and (anaconda.displayMode == "g")
if want_x:
try:
startX11()
doStartupX11Actions()
except (OSError, RuntimeError) as e:
log.warning("X startup failed: %s", e)
stdoutLog.warning("X startup failed, falling back to text mode")
anaconda.displayMode = 't'
graphical_failed = 1
time.sleep(2)
if not graphical_failed:
doExtraX11Actions(options.runres)
if anaconda.displayMode == 't' and graphical_failed and \
flags.vncquestion and not anaconda.ksdata.vnc.enabled:
app = App("VNC Question")
spoke = AskVNCSpoke(app, anaconda.ksdata)
app.schedule_screen(spoke)
app.run()
if anaconda.ksdata.vnc.enabled:
anaconda.displayMode = 'g'
flags.usevnc = True
vncS.password = anaconda.ksdata.vnc.password
# if they want us to use VNC do that now
if anaconda.displayMode == 'g' and flags.usevnc:
vncS.startServer()
doStartupX11Actions()
# with X running we can initialize the UI interface
anaconda.initInterface(addons)
anaconda.instClass.configure(anaconda)
# report if starting the GUI failed
anaconda.gui_startup_failed = bool(graphical_failed)
