def test_resolve(self, kernel_getter, req_getter1, req_getter2,
req_getter3, req_getter4):
"""Test the successful ResolvePackagesTask task."""
kernel_getter.return_value = None
req_getter1.return_value = [
Requirement.for_group("r1"),
Requirement.for_group("r2")
]
req_getter2.return_value = [Requirement.for_group("r3")]
req_getter3.return_value = [
Requirement.for_package("r4"),
Requirement.for_package("r5")
]
req_getter4.return_value = [Requirement.for_package("r6")]
selection = PackagesSelectionData()
selection.excluded_groups = ["r3"]
selection.excluded_packages = ["r6"]
dnf_manager = Mock()
dnf_manager.default_environment = None
task = ResolvePackagesTask(dnf_manager, selection)
task.run()
dnf_manager.clear_selection.assert_called_once_with()
dnf_manager.disable_modules.assert_called_once_with([])
dnf_manager.enable_modules.assert_called_once_with([])
dnf_manager.apply_specs.assert_called_once_with(
["@core", "@r1", "@r2", "r4", "r5"], ["@r3", "r6"])
dnf_manager.resolve_selection.assert_called_once_with()
def collect_requirements(self):
"""Return installation requirements for this module.
:return: a list of requirements
"""
requirements = []
# Add realm requirements.
for name in self.realm.required_packages:
requirements.append(
Requirement.for_package(name,
reason="Needed to join a realm."))
# Add authselect / authconfig requirements
if self.authselect or self.fingerprint_auth_enabled:
# we need the authselect package in two cases:
# - autselect command is used in kickstart
# - to configure fingerprint authentication
requirements.append(
Requirement.for_package(
"authselect",
reason="Needed by authselect kickstart command & "
"for fingerprint authentication support."))
if self.authconfig:
requirements.append(
Requirement.for_package(
"authselect-compat",
reason=
"Needed to support legacy authconfig kickstart command."))
return requirements
def collect_requirements(self):
"""Return installation requirements for this module.
:return: a list of requirements
"""
requirements = []
# Add FIPS requirements.
if self.fips_enabled:
requirements.append(Requirement.for_package(
"/usr/bin/fips-mode-setup",
reason="Required for FIPS compliance."
))
# Add realm requirements.
for name in self.realm.required_packages:
requirements.append(Requirement.for_package(
name, reason="Needed to join a realm."
))
# Add authselect requirements
if self.authselect or self.fingerprint_auth_enabled:
# we need the authselect package in two cases:
# - autselect command is used in kickstart
# - to configure fingerprint authentication
requirements.append(Requirement.for_package(
"authselect",
reason="Needed by authselect kickstart command & "
"for fingerprint authentication support."
))
return requirements
def collect_requirements(self):
"""Return installation requirements for this module.
:return: a list of requirements
"""
# first collect requirements from the Firewall sub-module
requirements = self._firewall_module.collect_requirements()
# team device configuration support
if self.get_team_devices():
requirements.append(
Requirement.for_package(
"teamd",
reason="Necessary for network team device configuration."))
# prefixdevname
if self._is_using_persistent_device_names(kernel_arguments):
requirements.append(
Requirement.for_package(
"prefixdevname",
reason=
"Necessary for persistent network device naming feature."))
# biosdevname
if self._is_using_biosdevname(kernel_arguments):
requirements.append(
Requirement.for_package(
"biosdevname",
reason=
"Necessary for biosdevname network device naming feature.")
)
return requirements
def add_requirements_test(self):
"""Check that multiple requirements can be added at once."""
reqs = PayloadRequirements()
self.assertTrue(reqs.empty)
# add a package, group & unknown requirement type
req_list = []
req_list.append(Requirement.for_package("foo-package", reason="foo package needed"))
req_list.append(Requirement.for_group("bar-group", reason="bar group needed"))
unknown_req = Requirement()
unknown_req.name = "baz-unknown"
unknown_req.reson = "unknown reason for installation"
unknown_req.type = "baz-unknown-type"
req_list.append(unknown_req)
# add the requrements list and check it is processed correctly
reqs.add_requirements(req_list)
self.assertFalse(reqs.empty)
# package
self.assertEqual(len(reqs.packages), 1)
self.assertEqual(reqs.packages[0].id, "foo-package")
self.assertEqual(len(reqs.packages[0].reasons), 1)
self.assertEqual(reqs.packages[0].reasons[0], "foo package needed")
self.assertTrue(reqs.packages[0].strong)
# group
self.assertEqual(len(reqs.groups), 1)
self.assertEqual(reqs.groups[0].id, "bar-group")
self.assertEqual(len(reqs.groups[0].reasons), 1)
self.assertEqual(reqs.groups[0].reasons[0], "bar group needed")
self.assertTrue(reqs.groups[0].strong)
def collect_language_requirements(dnf_base):
"""Collect requirements for supported languages.
:param dnf_base: a DNF base
:return: a list of requirements
"""
requirements = []
localization_proxy = LOCALIZATION.get_proxy()
locales = [localization_proxy.Language] + localization_proxy.LanguageSupport
# Find all available langpacks.
packages = dnf_base.sack.query().available().filter(name__glob="langpacks-*")
# Get all valid langcodes.
codes = [p.name.split('-', 1)[1] for p in packages]
codes = list(filter(is_valid_langcode, codes))
# Find the best langpacks to install.
for locale in locales:
best_locale = find_best_locale_match(locale, codes)
if not best_locale:
log.warning("Selected locale '%s' does not match "
"any available langpacks.", locale)
continue
requirements.append(Requirement.for_package(
package_name="langpacks-" + best_locale,
reason="Required to support the locale '{}'.".format(locale)
))
return requirements
def collect_requirements(self):
"""Return installation requirements for this module.
:return: a list of requirements
"""
requirements = []
if self.firewall_seen:
requirements.append(Requirement.for_package("firewalld", reason="Requested by the firewall kickstart command."))
return requirements
def collect_requirements(self):
"""Return installation requirements for this module.
:return: a list of requirements
"""
requirements = []
# Add realm requirements.
for name in self.realm.required_packages:
requirements.append(Requirement.for_package(name, reason="Needed to join a realm."))
return requirements
def _add_module_with_requirement(self, service_name, package_name, available=True):
"""Add a DBus module with a package requirement."""
requirement = Requirement.for_package(
package_name=package_name,
reason="Required by {}.".format(service_name)
)
module_proxy = Mock()
module_proxy.CollectRequirements.return_value = \
Requirement.to_structure_list([requirement])
self._add_module(service_name, available=available, proxy=module_proxy)
def collect_requirements(self):
"""Return installation requirements.
:return: a list of requirements
"""
requirements = []
if self.kdump_enabled:
requirements.append(
Requirement.for_package(package_name="kexec-tools",
reason="Required by kdump add-on."))
return requirements
def collect_requirements(self):
"""Return installation requirements for this module.
:return: a list of requirements
"""
# first collect requirements from the Firewall sub-module
requirements = self._firewall_module.collect_requirements()
# team device configuration support
if self.get_team_devices():
requirements.append(Requirement.for_package("teamd", reason="Necessary for network team device configuration."))
return requirements
def collect_requirements(self):
"""Return installation requirements for this module.
:return: a list of requirements
"""
requirements = []
# Add ntp service requirements.
if self._ntp_enabled:
requirements.append(
Requirement.for_package(NTP_PACKAGE,
reason="Needed to run NTP service."))
return requirements
def collect_requirements(self):
"""Return installation requirements for this module.
:return: a list of requirements
"""
requirements = []
# Add the platform requirements.
for name in platform.packages:
requirements.append(Requirement.for_package(
name, reason="Required for the platform."
))
# Add the storage requirements.
for name in self.storage.packages:
requirements.append(Requirement.for_package(
name, reason="Required to manage storage devices."
))
# Add other requirements, for example for bootloader.
for kickstart_module in self._modules:
requirements.extend(kickstart_module.collect_requirements())
return requirements
def collect_requirements(self):
"""Return installation requirements.
:return: a list of requirements
"""
if not self.installation_enabled:
log.debug(
"OSCAP Addon: The installation is disabled. Skip the requirements."
)
return []
requirements = [
Requirement.for_package(package_name="openscap",
reason="Required by oscap add-on."),
Requirement.for_package(package_name="openscap-scanner",
reason="Required by oscap add-on.")
]
if self.policy_data.content_type == "scap-security-guide":
requirements.append(
Requirement.for_package(package_name="scap-security-guide",
reason="Required by oscap add-on."))
return requirements
def collect_requirements(self):
"""Return installation requirements for this module.
:return: a list of requirements
"""
requirements = []
# Install support for non-ascii keyboard layouts (#1919483).
if self.vc_keymap and not langtable.supports_ascii(self.vc_keymap):
requirements.append(
Requirement.for_package(
package_name="kbd-legacy",
reason="Required to support the '{}' keymap.".format(
self.vc_keymap)))
return requirements
def collect_requirements(self):
"""Return installation requirements for this module.
:return: a list of requirements
"""
requirements = []
# check if we need the insights-client package, which is needed to connect the
# target system to Red Hat Insights
if self.subscription_attached and self.connect_to_insights:
# establishing a connection to Red Hat Insights has been requested
# and we need the insights-client package to be present in the
# target system chroot for that
requirements.append(
Requirement.for_package(
"insights-client",
reason=
"Needed to connect the target system to Red Hat Insights.")
)
return requirements
def collect_requirements(self):
"""Return installation requirements for this module.
:return: a list of requirements
"""
if conf.target.is_directory:
log.debug("The bootloader configuration is disabled for dir installations.")
return []
if self.bootloader_mode == BootloaderMode.DISABLED:
log.debug("The bootloader configuration is disabled.")
return []
requirements = []
for name in self.storage.bootloader.packages:
requirements.append(Requirement.for_package(name, reason="bootloader"))
return requirements
def collect_driver_disk_requirements(path="/run/install/dd_packages"):
"""Collect the requirements from the driver updates disk.
:param path: a path to the file with a package list
:return: a list of requirements
"""
requirements = []
if not os.path.exists(path):
return []
with open(path, "r") as f:
for line in f:
package = line.strip()
requirements.append(
Requirement.for_package(
package_name=package,
reason="Required by the driver updates disk."))
return requirements
def test_package_requirement(self):
requirement = Requirement.for_package("package-name", "reason")
assert requirement.type == "package"
assert requirement.name == "package-name"
assert requirement.reason == "reason"
def test_package_requirement(self):
requirement = Requirement.for_package("package-name", "reason")
self.assertEqual(requirement.type, "package")
self.assertEqual(requirement.name, "package-name")
self.assertEqual(requirement.reason, "reason")