class FedoraBaseInstallClass(BaseInstallClass):
name = "Fedora"
sortPriority = 10000
if productName.startswith("Red Hat ") or productName.startswith(
"CentOS") or productName.startswith("EasyStack Cloud Linux"):
hidden = True
_l10n_domain = "anaconda"
efi_dir = "fedora"
help_placeholder = "FedoraPlaceholder.html"
help_placeholder_with_links = "FedoraPlaceholderWithLinks.html"
def configure(self, anaconda):
BaseInstallClass.configure(self, anaconda)
BaseInstallClass.setDefaultPartitioning(self, anaconda.storage)
def setNetworkOnbootDefault(self, ksdata):
if any(nd.onboot for nd in ksdata.network.network if nd.device):
return
# choose first wired device having link
for dev in nm.nm_devices():
if nm.nm_device_type_is_wifi(dev):
continue
try:
link_up = nm.nm_device_carrier(dev)
except (nm.UnknownDeviceError, nm.PropertyNotFoundError):
continue
if link_up:
network.update_onboot_value(dev, True, ksdata=ksdata)
break
def __init__(self):
BaseInstallClass.__init__(self)
class FedoraBaseInstallClass(BaseInstallClass):
name = "Fedora"
sortPriority = 10000
if not productName.startswith("Fedora"): # pylint: disable=no-member
hidden = True
_l10n_domain = "anaconda"
efi_dir = "fedora"
help_placeholder = "FedoraPlaceholder.html"
help_placeholder_plain_text = "FedoraPlaceholder.txt"
help_placeholder_with_links = "FedoraPlaceholderWithLinks.html"
def setNetworkOnbootDefault(self, ksdata):
if any(nd.onboot for nd in ksdata.network.network if nd.device):
return
# choose first wired device having link
for dev in nm.nm_devices():
if nm.nm_device_type_is_wifi(dev):
continue
try:
link_up = nm.nm_device_carrier(dev)
except (nm.UnknownDeviceError, nm.PropertyNotFoundError):
continue
if link_up:
network.update_onboot_value(dev, True, ksdata=ksdata)
break
class InstallClass(BaseInstallClass):
# name has underscore used for mnemonics, strip if you dont need it
id = "rhel"
name = N_("Red Hat Enterprise Linux")
sortPriority = 10000
if not productName.startswith("Red Hat Enterprise"):
hidden = 1
defaultFS = "xfs"
bootloaderTimeoutDefault = 5
bootloaderExtraArgs = []
ignoredPackages = ["ntfsprogs"]
installUpdates = False
_l10n_domain = "comps"
efi_dir = "redhat"
def configure(self, anaconda):
BaseInstallClass.configure(self, anaconda)
BaseInstallClass.setDefaultPartitioning(self, anaconda.storage)
def __init__(self):
BaseInstallClass.__init__(self)
def _on_continue_clicked(self, window, user_data=None):
# Don't display the betanag dialog if this is the final release.
if not isFinal:
dlg = self.builder.get_object("betaWarnDialog")
with self.main_window.enlightbox(dlg):
rc = dlg.run()
dlg.destroy()
if rc != 1:
ipmi_report(IPMI_ABORTED)
sys.exit(0)
if (
productName.startswith("Red Hat ")
and is_unsupported_hw()
and not self.data.unsupportedhardware.unsupported_hardware
):
dlg = self.builder.get_object("unsupportedHardwareDialog")
with self.main_window.enlightbox(dlg):
rc = dlg.run()
dlg.destroy()
if rc != 1:
ipmi_report(IPMI_ABORTED)
sys.exit(0)
StandaloneSpoke._on_continue_clicked(self, window, user_data)
class RHELBaseInstallClass(BaseInstallClass):
name = "Red Hat Enterprise Linux"
sortPriority = 10000
if not productName.startswith("Red Hat "): # pylint: disable=no-member
hidden = True
defaultFS = "xfs"
default_luks_version = "luks2"
ignoredPackages = ["ntfsprogs"]
installUpdates = False
efi_dir = "redhat"
help_placeholder = "rhel_help_placeholder.xml"
help_placeholder_with_links = "rhel_help_placeholder.xml"
help_placeholder_plain_text = "rhel_help_placeholder.txt"
eula_path = "/usr/share/redhat-release/EULA"
mirrors_available = False
blivet_gui_supported = False
detect_unsupported_hardware = True
detect_support_removed = True
network_on_boot = NetworkOnBoot.DEFAULT_ROUTE_DEVICE
class FedoraWorkstationInstallClass(FedoraBaseInstallClass):
name = "Fedora Workstation"
stylesheet = "/usr/share/anaconda/pixmaps/workstation/fedora-workstation.css"
sortPriority = FedoraBaseInstallClass.sortPriority + 1
if not productName.startswith("Fedora Workstation"): # pylint: disable=no-member
hidden = True
defaultPackageEnvironment = "workstation-product-environment"
class RHELBaseInstallClass(BaseInstallClass):
name = "Red Hat Enterprise Linux"
sortPriority = 10000
if not productName.startswith("Red Hat "): # pylint: disable=no-member
hidden = True
defaultFS = "xfs"
bootloaderTimeoutDefault = 5
ignoredPackages = ["ntfsprogs"]
installUpdates = False
_l10n_domain = "comps"
efi_dir = "redhat"
help_placeholder = "RHEL7Placeholder.html"
help_placeholder_with_links = "RHEL7PlaceholderWithLinks.html"
def setNetworkOnbootDefault(self, ksdata):
if any(nd.onboot for nd in ksdata.network.network if nd.device):
return
# choose the device used during installation
# (ie for majority of cases the one having the default route)
dev = network.default_route_device() or network.default_route_device(
family="inet6")
if not dev:
return
# ignore wireless (its ifcfgs would need to be handled differently)
if nm.nm_device_type_is_wifi(dev):
return
network.update_onboot_value(dev, True, ksdata=ksdata)
class CentOSBaseInstallClass(BaseInstallClass):
name = "CentOS Linux"
sortPriority = 10000
if not productName.startswith("CentOS"): # pylint: disable=no-member
hidden = True
defaultFS = "xfs"
ignoredPackages = ["ntfsprogs"]
installUpdates = False
efi_dir = "centos"
help_placeholder = "CentOSPlaceholder.html"
help_placeholder_with_links = "CentOSPlaceholder.html"
blivet_gui_supported = False
def setNetworkOnbootDefault(self, ksdata):
if any(nd.onboot for nd in ksdata.network.network if nd.device):
return
# choose the device used during installation
# (ie for majority of cases the one having the default route)
dev = network.default_route_device() or network.default_route_device(
family="inet6")
if not dev:
return
# ignore wireless (its ifcfgs would need to be handled differently)
if nm.nm_device_type_is_wifi(dev):
return
network.update_onboot_value(dev, True, ksdata=ksdata)
class FedoraBaseInstallClass(BaseInstallClass):
name = "Fedora"
sortPriority = 10000
if productName.startswith("Red Hat "): # pylint: disable=no-member
hidden = True
_l10n_domain = "anaconda"
efi_dir = "fedora"
help_placeholder = "FedoraPlaceholder.html"
help_placeholder_with_links = "FedoraPlaceholderWithLinks.html"
def configure(self, anaconda):
BaseInstallClass.configure(self, anaconda)
BaseInstallClass.setDefaultPartitioning(self, anaconda.storage)
def setNetworkOnbootDefault(self, ksdata):
if network.has_some_wired_autoconnect_device():
return
# choose first wired device having link
for dev in nm.nm_devices():
if nm.nm_device_type_is_wifi(dev):
continue
try:
link_up = nm.nm_device_carrier(dev)
except (nm.UnknownDeviceError, nm.PropertyNotFoundError):
continue
if link_up:
network.update_onboot_value(dev, "yes", ksdata)
break
def __init__(self):
BaseInstallClass.__init__(self)
class InstallClass(BaseInstallClass):
# name has underscore used for mnemonics, strip if you dont need it
id = "fedora"
name = N_("_Fedora")
sortPriority = 10000
if productName.startswith("Red Hat "):
hidden = 1
_l10n_domain = "anaconda"
installUpdates = True
efi_dir = "fedora"
def configure(self, anaconda):
BaseInstallClass.configure(self, anaconda)
BaseInstallClass.setDefaultPartitioning(self, anaconda.storage)
def setNetworkOnbootDefault(self, ksdata):
# if something's already enabled, we can just leave the config alone
for devName in nm.nm_devices():
if nm.nm_device_type_is_wifi(devName):
continue
try:
onboot = nm.nm_device_setting_value(devName, "connection",
"autoconnect")
except nm.SettingsNotFoundError:
continue
if not onboot == False:
return
# the default otherwise: bring up the first wired netdev with link
for devName in nm.nm_devices():
if nm.nm_device_type_is_wifi(devName):
continue
try:
link_up = nm.nm_device_carrier(devName)
except ValueError:
continue
if link_up:
ifcfg_path = network.find_ifcfg_file_of_device(
devName, root_path=ROOT_PATH)
if not ifcfg_path:
continue
ifcfg = network.IfcfgFile(ifcfg_path)
ifcfg.read()
ifcfg.set(('ONBOOT', 'yes'))
ifcfg.write()
for nd in ksdata.network.network:
if nd.device == devName:
nd.onboot = True
break
break
def __init__(self):
BaseInstallClass.__init__(self)
def __init__(self, *args, **kwargs):
StandaloneTUISpoke.__init__(self, *args, **kwargs)
self._message = _("This hardware (or a combination thereof) is not "
"supported by Red Hat. For more information on "
"supported hardware, please refer to "
"http://www.redhat.com/hardware.")
# Does anything need to be displayed?
self._unsupported = productName.startswith("Red Hat ") and \
is_unsupported_hw() and \
not self.data.unsupportedhardware.unsupported_hardware
def __init__(self, *args, **kwargs):
StandaloneTUISpoke.__init__(self, *args, **kwargs)
self._message = _("This hardware (or a combination thereof) is not "
"supported by Red Hat. For more information on "
"supported hardware, please refer to "
"http://www.redhat.com/hardware.")
# Does anything need to be displayed?
self._unsupported = productName.startswith("Red Hat ") and \
is_unsupported_hw() and \
not self.data.unsupportedhardware.unsupported_hardware
class OvirtBaseInstallClass(BaseInstallClass):
name = "oVirt Node Next"
sortPriority = 21000
hidden = not productName.startswith("oVirt")
efi_dir = "centos"
def configure(self, anaconda):
BaseInstallClass.configure(self, anaconda)
def setDefaultPartitioning(self, storage):
autorequests = [
PartSpec(mountpoint="/",
fstype=storage.defaultFSType,
size=Size("6GiB"),
thin=True,
grow=True,
lv=True),
PartSpec(mountpoint="/var",
fstype=storage.defaultFSType,
size=Size("15GiB"),
thin=True,
lv=True)
]
bootreqs = platform.setDefaultPartitioning()
if bootreqs:
autorequests.extend(bootreqs)
disk_space = getAvailableDiskSpace(storage)
swp = swap.swapSuggestion(disk_space=disk_space)
autorequests.append(
PartSpec(fstype="swap",
size=swp,
grow=False,
lv=True,
encrypted=True))
for autoreq in autorequests:
if autoreq.fstype is None:
if autoreq.mountpoint == "/boot":
autoreq.fstype = storage.defaultBootFSType
autoreq.size = Size("1GiB")
else:
autoreq.fstype = storage.defaultFSType
storage.autoPartitionRequests = autorequests
def __init__(self):
BaseInstallClass.__init__(self)
class FedoraBaseInstallClass(BaseInstallClass):
name = "Fedora"
sortPriority = 10000
if not productName.startswith("Fedora"): # pylint: disable=no-member
hidden = True
efi_dir = "fedora"
help_placeholder = "FedoraPlaceholder.html"
help_placeholder_plain_text = "FedoraPlaceholder.txt"
help_placeholder_with_links = "FedoraPlaceholderWithLinks.html"
default_luks_version = "luks1"
network_on_boot = NetworkOnBoot.FIRST_WIRED_WITH_LINK
class ScientificBaseInstallClass(RHELBaseInstallClass):
'''
Scientific Linux is a Free RHEL rebuild.
In general it should install mostly like RHEL.
These few items are different between them.
'''
name = "Scientific Linux"
hidden = not productName.startswith("Scientific") # pylint: disable=no-member
installUpdates = True
help_placeholder = "SLPlaceholder.html"
help_placeholder_with_links = "SLPlaceholder.html"
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.title = N_("Warnings")
self.initialize_start()
self._message = _("This hardware (or a combination thereof) is not "
"supported by Red Hat. For more information on "
"supported hardware, please refer to "
"http://www.redhat.com/hardware.")
# Does anything need to be displayed?
# pylint: disable=no-member
self._unsupported = productName.startswith("Red Hat ") and \
is_unsupported_hw() and \
not self.data.unsupportedhardware.unsupported_hardware
self.initialize_done()
class RHELBaseInstallClass(BaseInstallClass):
name = "Red Hat Enterprise Linux"
sortPriority = 10000
if not productName.startswith("Red Hat "): # pylint: disable=no-member
hidden = True
defaultFS = "xfs"
default_luks_version = "luks2"
bootloaderTimeoutDefault = 5
ignoredPackages = ["ntfsprogs"]
installUpdates = False
_l10n_domain = "comps"
efi_dir = "redhat"
help_placeholder = "rhel_help_placeholder.xml"
help_placeholder_with_links = "rhel_help_placeholder.xml"
help_placeholder_plain_text = "rhel_help_placeholder.txt"
eula_path = "/usr/share/redhat-release/EULA"
mirrors_available = False
blivet_gui_supported = False
detect_unsupported_hardware = True
detect_support_removed = True
def setNetworkOnbootDefault(self, ksdata):
if any(nd.onboot for nd in ksdata.network.network if nd.device):
return
# choose the device used during installation
# (ie for majority of cases the one having the default route)
dev = network.default_route_device() or network.default_route_device(
family="inet6")
if not dev:
return
# ignore wireless (its ifcfgs would need to be handled differently)
if nm.nm_device_type_is_wifi(dev):
return
network.update_onboot_value(dev, True, ksdata=ksdata)
class RHELAtomicInstallClass(RHELBaseInstallClass):
name = "Red Hat Enterprise Linux Atomic Host"
sortPriority = 21000
hidden = not productName.startswith(
("RHEL Atomic Host", "Red Hat Enterprise Linux Atomic"))
def configure(self, anaconda):
RHELBaseInstallClass.configure(self, anaconda)
# Atomic installations are always single language (#1235726)
log.info(
"Automatically enabling single language mode for %s installation.",
self.name)
flags.singlelang = True
def setDefaultPartitioning(self, storage):
autorequests = [
PartSpec(mountpoint="/",
fstype=storage.defaultFSType,
size=Size("1GiB"),
maxSize=Size("3GiB"),
grow=True,
lv=True)
]
bootreqs = platform.setDefaultPartitioning()
if bootreqs:
autorequests.extend(bootreqs)
disk_space = getAvailableDiskSpace(storage)
swp = swap.swapSuggestion(disk_space=disk_space)
autorequests.append(
PartSpec(fstype="swap",
size=swp,
grow=False,
lv=True,
encrypted=True))
for autoreq in autorequests:
if autoreq.fstype is None:
if autoreq.mountpoint == "/boot":
autoreq.fstype = storage.defaultBootFSType
autoreq.size = Size("300MiB")
else:
autoreq.fstype = storage.defaultFSType
storage.autoPartitionRequests = autorequests
class RHELBaseInstallClass(BaseInstallClass):
name = "Rocks CentOS-based Linux"
sortPriority = 20003
if not productName.startswith("Rocks"):
hidden = True
defaultFS = "ext4"
bootloaderTimeoutDefault = 5
ignoredPackages = [
"ntfsprogs", "reiserfs-utils", "hfsplus-tools", "dracut-config-rescue"
]
installUpdates = False
_l10n_domain = "comps"
efi_dir = "centos"
help_placeholder = "CentOSPlaceholder.html"
help_placeholder_with_links = "CentOSPlaceholder.html"
def configure(self, anaconda):
BaseInstallClass.configure(self, anaconda)
self.setDefaultPartitioning(anaconda.storage)
def setNetworkOnbootDefault(self, ksdata):
if any(nd.onboot for nd in ksdata.network.network if nd.device):
return
# choose the device used during installation
# (ie for majority of cases the one having the default route)
dev = network.default_route_device() \
or network.default_route_device(family="inet6")
if not dev:
return
# ignore wireless (its ifcfgs would need to be handled differently)
if nm.nm_device_type_is_wifi(dev):
return
network.update_onboot_value(dev, "yes", ksdata)
def getBackend(self):
"""Use the Rocks-defined version of yumpayload"""
return RocksYumPayload
def __init__(self):
BaseInstallClass.__init__(self)
class CentOSBaseInstallClass(BaseInstallClass):
name = "CentOS Linux"
sortPriority = 10000
if not productName.startswith("CentOS"): # pylint: disable=no-member
hidden = True
defaultFS = "xfs"
ignoredPackages = ["ntfsprogs"]
installUpdates = False
efi_dir = "centos"
help_placeholder = "CentOSPlaceholder.html"
help_placeholder_with_links = "CentOSPlaceholder.html"
blivet_gui_supported = False
network_on_boot = NetworkOnBoot.DEFAULT_ROUTE_DEVICE
class FedoraServerInstallClass(FedoraBaseInstallClass):
name = "Fedora Server"
stylesheet = "/usr/share/anaconda/fedora-server.css"
defaultFS = "xfs"
sortPriority = FedoraBaseInstallClass.sortPriority + 1
if not productName.startswith("Fedora Server"): # pylint: disable=no-member
hidden = True
defaultPackageEnvironment = "server-product-environment"
def setDefaultPartitioning(self, storage):
autorequests = [
PartSpec(mountpoint="/",
fstype=storage.default_fstype,
size=Size("2GiB"),
max_size=Size("15GiB"),
grow=True,
btr=True,
lv=True,
thin=True,
encrypted=True)
]
bootreqs = platform.set_default_partitioning()
if bootreqs:
autorequests.extend(bootreqs)
disk_space = getAvailableDiskSpace(storage)
swp = swap_suggestion(disk_space=disk_space)
autorequests.append(
PartSpec(fstype="swap",
size=swp,
grow=False,
lv=True,
encrypted=True))
for autoreq in autorequests:
if autoreq.fstype is None:
if autoreq.mountpoint == "/boot":
autoreq.fstype = storage.default_boot_fstype
else:
autoreq.fstype = storage.default_fstype
storage.autopart_requests = autorequests
class RHELBaseInstallClass(BaseInstallClass):
name = "Red Hat Enterprise Linux"
sortPriority = 10000
if not productName.startswith("Red Hat "):
hidden = True
defaultFS = "xfs"
bootloaderTimeoutDefault = 5
ignoredPackages = ["ntfsprogs"]
installUpdates = False
_l10n_domain = "comps"
efi_dir = "redhat"
help_placeholder = "RHEL7Placeholder.html"
help_placeholder_with_links = "RHEL7PlaceholderWithLinks.html"
def configure(self, anaconda):
BaseInstallClass.configure(self, anaconda)
BaseInstallClass.setDefaultPartitioning(self, anaconda.storage)
def setNetworkOnbootDefault(self, ksdata):
if ksdata.method.method not in ("url", "nfs"):
return
if network.has_some_wired_autoconnect_device():
return
# choose the device used during installation
# (ie for majority of cases the one having the default route)
dev = network.default_route_device() \
or network.default_route_device(family="inet6")
if not dev:
return
# ignore wireless (its ifcfgs would need to be handled differently)
if nm.nm_device_type_is_wifi(dev):
return
network.update_onboot_value(dev, "yes", ksdata)
def __init__(self):
BaseInstallClass.__init__(self)
def _on_continue_clicked(self, cb):
# Don't display the betanag dialog if this is the final release.
if not isFinal:
dlg = self.builder.get_object("betaWarnDialog")
with enlightbox(self.window, dlg):
rc = dlg.run()
dlg.destroy()
if rc == 0:
sys.exit(0)
if productName.startswith("Red Hat Enterprise Linux") and \
is_unsupported_hw() and not self.data.unsupportedhardware.unsupported_hardware:
dlg = self.builder.get_object("unsupportedHardwareDialog")
with enlightbox(self.window, dlg):
rc = dlg.run()
dlg.destroy()
if rc == 0:
sys.exit(0)
StandaloneSpoke._on_continue_clicked(self, cb)
def _on_continue_clicked(self, cb):
# Don't display the betanag dialog if this is the final release.
if not isFinal:
dlg = self.builder.get_object("betaWarnDialog")
with enlightbox(self.window, dlg):
rc = dlg.run()
dlg.destroy()
if rc == 0:
sys.exit(0)
if productName.startswith("Red Hat Enterprise Linux") and \
is_unsupported_hw() and not self.data.unsupportedhardware.unsupported_hardware:
dlg = self.builder.get_object("unsupportedHardwareDialog")
with enlightbox(self.window, dlg):
rc = dlg.run()
dlg.destroy()
if rc == 0:
sys.exit(0)
StandaloneSpoke._on_continue_clicked(self, cb)
class CentOSBaseInstallClass(BaseInstallClass):
name = "CentOS Linux"
sortPriority = 10000
if not productName.startswith("CentOS"): # pylint: disable=no-member
hidden = True
defaultFS = "xfs"
bootloaderTimeoutDefault = 5
ignoredPackages = ["ntfsprogs"]
installUpdates = False
_l10n_domain = "comps"
efi_dir = "centos"
help_placeholder = "CentOSPlaceholder.html"
help_placeholder_with_links = "CentOSPlaceholder.html"
def configure(self, anaconda):
BaseInstallClass.configure(self, anaconda)
BaseInstallClass.setDefaultPartitioning(self, anaconda.storage)
def setNetworkOnbootDefault(self, ksdata):
if any(nd.onboot for nd in ksdata.network.network if nd.device):
return
# choose the device used during installation
# (ie for majority of cases the one having the default route)
dev = network.default_route_device() \
or network.default_route_device(family="inet6")
if not dev:
return
# ignore wireless (its ifcfgs would need to be handled differently)
if nm.nm_device_type_is_wifi(dev):
return
network.update_onboot_value(dev, True, ksdata=ksdata)
def __init__(self):
BaseInstallClass.__init__(self)
class ESBaseInstallClass(BaseInstallClass):
name = "EasyStack Cloud Linux"
sortPriority = 30001
if not productName.startswith("EasyStack Cloud Linux"):
hidden = True
defaultFS = "xfs"
bootloaderTimeoutDefault = 5
ignoredPackages = ["ntfsprogs", "reiserfs-utils", "hfsplus-tools"]
installUpdates = False
_l10n_domain = "comps"
efi_dir = "escore"
help_placeholder = "ESCorePlaceholder.html"
help_placeholder_with_links = "ESCorePlaceholderWithLinks.html"
def configure(self, anaconda):
BaseInstallClass.configure(self, anaconda)
self.setDefaultPartitioning(anaconda.storage)
def setNetworkOnbootDefault(self, ksdata):
if any(nd.onboot for nd in ksdata.network.network if nd.device):
return
# choose the device used during installation
# (ie for majority of cases the one having the default route)
dev = network.default_route_device() \
or network.default_route_device(family="inet6")
if not dev:
return
# ignore wireless (its ifcfgs would need to be handled differently)
if nm.nm_device_type_is_wifi(dev):
return
network.update_onboot_value(dev, "yes", ksdata)
def __init__(self):
BaseInstallClass.__init__(self)
def _on_continue_clicked(self, window, user_data=None):
# Don't display the betanag dialog if this is the final release.
if not isFinal:
dlg = self.builder.get_object("betaWarnDialog")
with self.main_window.enlightbox(dlg):
rc = dlg.run()
dlg.destroy()
if rc != 1:
ipmi_report(IPMI_ABORTED)
sys.exit(0)
if productName.startswith("Red Hat ") and \
is_unsupported_hw() and not self.data.unsupportedhardware.unsupported_hardware:
dlg = self.builder.get_object("unsupportedHardwareDialog")
with self.main_window.enlightbox(dlg):
rc = dlg.run()
dlg.destroy()
if rc != 1:
ipmi_report(IPMI_ABORTED)
sys.exit(0)
StandaloneSpoke._on_continue_clicked(self, window, user_data)
class ScientificBaseInstallClass(RHELBaseInstallClass):
'''
Scientific Linux is a Free RHEL rebuild.
In general it should install mostly like RHEL.
These few items are different between them.
'''
name = "Scientific Linux"
hidden = not productName.startswith("Scientific") # pylint: disable=no-member
installUpdates = True
help_placeholder = "SLPlaceholder.html"
help_placeholder_with_links = "SLPlaceholder.html"
def configurePayload(self, payload): # pylint: disable=line-too-long
'''
Load SL specific payload repos
'''
if isinstance(payload, PackagePayload):
major_version = productVersion.replace('rolling', '').split('.')[0]
# A number of users like EPEL, seed it disabled
payload.addDisabledRepo(
RepoData(
name='epel',
metalink=
"https://mirrors.fedoraproject.org/metalink?repo=epel-" +
major_version + "&arch=" + productArch))
# ELRepo provides handy hardware drivers, seed it disabled
payload.addDisabledRepo(
RepoData(
name='elrepo',
mirrorlist="http://mirrors.elrepo.org/mirrors-elrepo.el" +
major_version))
super().configurePayload(payload)
class CustomBaseInstallClass(BaseInstallClass):
name = "RockNSM"
sortPriority = 30000
if not productName.startswith("ROCK NSM"):
hidden = True
defaultFS = "xfs"
bootloaderTimeoutDefault = 60
bootloaderExtraArgs = []
ignoredPackages = ["ntfsprogs"]
installUpdates = False
_l10n_domain = "comps"
efi_dir = "centos"
help_placeholder = "CentOSPlaceholder.html"
help_placeholder_with_links = "CentOSPlaceholderWithLinks.html"
def configure(self, anaconda):
BaseInstallClass.configure(self, anaconda)
BaseInstallClass.setDefaultPartitioning(self, anaconda.storage)
def setNetworkOnbootDefault(self, ksdata):
if ksdata.method.method not in ("url", "nfs"):
return
if network.has_some_wired_autoconnect_device():
return
dev = network.default_route_device()
if not dev:
return
if nm.nm_device_type_is_wifi(dev):
return
network.update_onboot_value(dev, "yes", ksdata)
def __init__(self):
BaseInstallClass.__init__(self)
class ESAtomicInstallClass(ESBaseInstallClass):
name = "ESCore Atomic Host"
sortPriority = 21001
hidden = not productName.startswith(
("ESCore Atomic Host", "ESCore Linux Atomic"))
def setDefaultPartitioning(self, storage):
autorequests = [
PartSpec(mountpoint="/",
fstype=storage.defaultFSType,
size=Size("1GiB"),
maxSize=Size("3GiB"),
grow=True,
lv=True)
]
bootreqs = platform.setDefaultPartitioning()
if bootreqs:
autorequests.extend(bootreqs)
disk_space = getAvailableDiskSpace(storage)
swp = swap.swapSuggestion(disk_space=disk_space)
autorequests.append(
PartSpec(fstype="swap",
size=swp,
grow=False,
lv=True,
encrypted=True))
for autoreq in autorequests:
if autoreq.fstype is None:
if autoreq.mountpoint == "/boot":
autoreq.fstype = storage.defaultBootFSType
autoreq.size = Size("300MiB")
else:
autoreq.fstype = storage.defaultFSType
storage.autoPartitionRequests = autorequests
def _on_continue_clicked(self, window, user_data=None):
# Don't display the betanag dialog if this is the final release or
# when autostep has been requested as betanag breaks the autostep logic.
if not isFinal and not self.data.autostep.seen:
dlg = self.builder.get_object("betaWarnDialog")
with self.main_window.enlightbox(dlg):
rc = dlg.run()
dlg.hide()
if rc != 1:
ipmi_abort(scripts=self.data.scripts)
sys.exit(0)
# pylint: disable=no-member
if productName.startswith("Red Hat ") and \
is_unsupported_hw() and not self.data.unsupportedhardware.unsupported_hardware:
dlg = self.builder.get_object("unsupportedHardwareDialog")
with self.main_window.enlightbox(dlg):
rc = dlg.run()
dlg.destroy()
if rc != 1:
ipmi_abort(scripts=self.data.scripts)
sys.exit(0)
StandaloneSpoke._on_continue_clicked(self, window, user_data)
def _on_continue_clicked(self, window, user_data=None):
# Don't display the betanag dialog if this is the final release or
# when autostep has been requested as betanag breaks the autostep logic.
if not isFinal and not self.data.autostep.seen:
dlg = self.builder.get_object("betaWarnDialog")
with self.main_window.enlightbox(dlg):
rc = dlg.run()
dlg.hide()
if rc != 1:
ipmi_abort(scripts=self.data.scripts)
sys.exit(0)
# pylint: disable=no-member
if productName.startswith("Red Hat ") and \
is_unsupported_hw() and not self.data.unsupportedhardware.unsupported_hardware:
dlg = self.builder.get_object("unsupportedHardwareDialog")
with self.main_window.enlightbox(dlg):
rc = dlg.run()
dlg.destroy()
if rc != 1:
ipmi_abort(scripts=self.data.scripts)
sys.exit(0)
StandaloneSpoke._on_continue_clicked(self, window, user_data)
class RHEVInstallClass(OvirtBaseInstallClass):
name = "Red Hat Virtualization"
hidden = not productName.startswith(("RHV", "Red Hat Virtualization"))
efi_dir = "redhat"
def stage2_format_types(self):
if productName.startswith("Red Hat "): # pylint: disable=no-member
return ["xfs", "ext4", "ext3", "ext2"]
else:
return ["ext4", "ext3", "ext2", "xfs"]
def stage2_format_types(self):
if productName.startswith("Red Hat "): # pylint: disable=no-member
return ["xfs", "ext4", "ext3", "ext2"]
else:
return ["ext4", "ext3", "ext2", "btrfs", "xfs"]
