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")