def test_combined(self): """ Test we get all the possible NEVRA parses. """ subj = hawkey.Subject(INP_FOF) nevras = subj.get_nevra_possibilities() # the epoch in INP_FOF nicely limits the nevra_possibilities: self.assertEqual(next(nevras), NEVRA(name='four-of-fish', epoch=8, version='3.6.9', release='11.fc100', arch='x86_64')) self.assertEqual(next(nevras), NEVRA(name='four-of-fish', epoch=8, version='3.6.9', release='11.fc100.x86_64', arch=None)) self.assertRaises(StopIteration, next, nevras) subj = hawkey.Subject(INP_FOF_NOEPOCH) nevras = subj.get_nevra_possibilities() self.assertEqual(next(nevras), NEVRA(name='four-of-fish', epoch=None, version='3.6.9', release='11.fc100', arch='x86_64')) self.assertEqual(next(nevras), NEVRA(name='four-of-fish-3.6.9-11.fc100', epoch=None, version=None, release=None, arch='x86_64')) self.assertEqual(next(nevras), NEVRA(name='four-of-fish-3.6.9-11.fc100.x86_64', epoch=None, version=None, release=None, arch=None)) self.assertEqual(next(nevras), NEVRA(name='four-of-fish', epoch=None, version='3.6.9', release='11.fc100.x86_64', arch=None)) self.assertEqual(next(nevras), NEVRA(name='four-of-fish-3.6.9', epoch=None, version='11.fc100.x86_64', release=None, arch=None)) self.assertRaises(StopIteration, next, nevras)
def test_reldep_flags(self): subj = hawkey.Subject('fool <= 1-3') self.assertRaises(StopIteration, next, subj.nevra_possibilities_real(self.sack)) reldeps = subj.reldep_possibilities_real(self.sack) reldep = next(reldeps) self.assertEqual(str(reldep), "fool <= 1-3") self.assertRaises(StopIteration, next, reldeps) subj = hawkey.Subject('meanwhile <= 1-3') reldeps = subj.reldep_possibilities_real(self.sack) self.assertRaises(StopIteration, next, reldeps)
def test_combined(self): """ Test we get all the possible NEVRA parses. """ subj = hawkey.Subject(INP_FOF) # the epoch in INP_FOF nicely limits the nevra_possibilities: expect = (NEVRA(name='four-of-fish', epoch=8, version='3.6.9', release='11.fc100', arch='x86_64'), NEVRA(name='four-of-fish', epoch=8, version='3.6.9', release='11.fc100.x86_64', arch=None)) result = subj.get_nevra_possibilities() self.assertEqual(len(result), len(expect)) for idx in range(0, len(expect)): self.assertEqual(expect[idx], result[idx]) subj = hawkey.Subject(INP_FOF_NOEPOCH) expect = (NEVRA(name='four-of-fish', epoch=None, version='3.6.9', release='11.fc100', arch='x86_64'), NEVRA(name='four-of-fish-3.6.9-11.fc100', epoch=None, version=None, release=None, arch='x86_64'), NEVRA(name='four-of-fish-3.6.9-11.fc100.x86_64', epoch=None, version=None, release=None, arch=None), NEVRA(name='four-of-fish', epoch=None, version='3.6.9', release='11.fc100.x86_64', arch=None), NEVRA(name='four-of-fish-3.6.9', epoch=None, version='11.fc100.x86_64', release=None, arch=None)) result = subj.get_nevra_possibilities() self.assertEqual(len(result), len(expect)) for idx in range(0, len(expect)): self.assertEqual(expect[idx], result[idx])
def test_nevra(self): subj = hawkey.Subject(INP_FOF) result = list(subj.get_nevra_possibilities(forms=hawkey.FORM_NEVRA)) self.assertLength(result, 1) self.assertEqual(result[0], NEVRA(name='four-of-fish', epoch=8, version='3.6.9', release='11.fc100', arch='x86_64')) subj = hawkey.Subject(INP_FOF_NOEPOCH) result = list(subj.get_nevra_possibilities(forms=hawkey.FORM_NEVRA)) self.assertEqual(result[0], NEVRA(name='four-of-fish', epoch=None, version='3.6.9', release='11.fc100', arch='x86_64'))
def test_reldep(self): subj = hawkey.Subject("P-lib") self.assertRaises(StopIteration, next, subj.nevra_possibilities_real(self.sack)) reldeps = subj.reldep_possibilities_real(self.sack) reldep = next(reldeps) self.assertEqual(str(reldep), "P-lib") self.assertRaises(StopIteration, next, reldeps)
def test_two_dashes(self): """ Even two dashes can happen, make sure they can still form a name. """ subj = hawkey.Subject("penny-lib-devel") nevra = next(subj.nevra_possibilities_real(self.sack)) self.assertEqual(nevra, NEVRA(name='penny-lib-devel', epoch=None, version=None, release=None, arch=None))
def test_dash_version(self): subj = hawkey.Subject("penny-lib-4") nevra = next(subj.nevra_possibilities_real(self.sack)) self.assertEqual(nevra, NEVRA(name="penny-lib", epoch=None, version='4', release=None, arch=None))
def test_na(self): subj = hawkey.Subject(INP_FOF_NA) nevra_possibilities = list(subj.get_nevra_possibilities(forms=hawkey.FORM_NA)) self.assertLength(nevra_possibilities, 1) self.assertEqual(nevra_possibilities[0], NEVRA(name='four-of-fish-3.6.9', epoch=None, version=None, release=None, arch='i686'))
def test_glob_arches(self): subj = hawkey.Subject("pilchard-1.2.3-1.*6*") nevras = list( subj.nevra_possibilities_real(self.sack, allow_globs=True)) self.assertLength(nevras, 2) self.assertEqual(nevras[0].arch, "*6*") self.assertEqual(nevras[1].arch, None)
def test_dash(self): """ Test that if a dash is present in otherwise simple subject, we take it as a name as the first guess. """ subj = hawkey.Subject("penny-lib") nevra = next(subj.nevra_possibilities_real(self.sack)) self.assertEqual(nevra, NEVRA(name='penny-lib', epoch=None, version=None, release=None, arch=None))
def test_nevr(self): subj = hawkey.Subject(INP_FOF) expect = NEVRA(name='four-of-fish', epoch=8, version='3.6.9', release='11.fc100.x86_64', arch=None) self.assertEqual( subj.get_nevra_possibilities(forms=hawkey.FORM_NEVR)[0], expect)
def test_version_glob(self): subj = hawkey.Subject("pilchard-1.*-1.x86_64") nevras = list(subj.nevra_possibilities_real(self.sack, allow_globs=True)) self.assertEqual( [NEVRA(name='pilchard', epoch=None, version='1.*', release='1', arch='x86_64'), NEVRA(name='pilchard', epoch=None, version='1.*', release='1.x86_64', arch=None)], nevras)
def upgrade(self, module_specs): # :api no_match_specs = [] fail_safe_repo = hawkey.MODULE_FAIL_SAFE_REPO_NAME fail_safe_repo_used = False for spec in module_specs: module_list, nsvcap = self._get_modules(spec) if not module_list: no_match_specs.append(spec) continue update_module_list = [x for x in module_list if self.base._moduleContainer.isModuleActive(x.getId())] if not update_module_list: logger.error(_("Unable to resolve argument {}").format(spec)) continue module_dict = self._create_module_dict_and_enable(update_module_list, False) upgrade_package_set = set() for name, streamdict in module_dict.items(): for stream, module_list_from_dict in streamdict.items(): upgrade_package_set.update(self._get_package_name_set_and_remove_profiles( module_list_from_dict, nsvcap)) latest_module = self._get_latest(module_list_from_dict) if latest_module.getRepoID() == fail_safe_repo: msg = _( "Upgrading module '{0}' from Fail-Safe repository {1} is not allowed") logger.critical(msg.format(latest_module.getNameStream(), fail_safe_repo)) fail_safe_repo_used = True if nsvcap.profile: profiles_set = latest_module.getProfiles(nsvcap.profile) if not profiles_set: continue for profile in profiles_set: upgrade_package_set.update(profile.getContent()) else: for profile in latest_module.getProfiles(): upgrade_package_set.update(profile.getContent()) for artefact in latest_module.getArtifacts(): subj = hawkey.Subject(artefact) for nevra_obj in subj.get_nevra_possibilities( forms=[hawkey.FORM_NEVRA]): upgrade_package_set.add(nevra_obj.name) if not upgrade_package_set: logger.error(_("Unable to match profile in argument {}").format(spec)) query = self.base.sack.query().filterm(name=upgrade_package_set) if query: sltr = dnf.selector.Selector(self.base.sack) sltr.set(pkg=query) self.base._goal.upgrade(select=sltr) if fail_safe_repo_used: raise dnf.exceptions.Error(_( "Upgrading module from Fail-Safe repository is not allowed")) return no_match_specs
def _get_best_selector(sack, dep): # Based on get_best_selector in dnf's subject.py def is_glob_pattern(pattern): return set(pattern) & set("*[?") def first(iterable): it = iter(iterable) try: return next(it) except StopIteration: return None def _nevra_to_selector(sltr, nevra): if nevra.name is not None: if is_glob_pattern(nevra.name): sltr.set(name__glob=nevra.name) else: sltr.set(name=nevra.name) if nevra.version is not None: evr = nevra.version if nevra.epoch is not None and nevra.epoch > 0: evr = "%d:%s" % (nevra.epoch, evr) if nevra.release is None: sltr.set(version=evr) else: evr = "%s-%s" % (evr, nevra.release) sltr.set(evr=evr) if nevra.arch is not None: sltr.set(arch=nevra.arch) return sltr subj = hawkey.Subject(dep) sltr = hawkey.Selector(sack) nevra = first(subj.nevra_possibilities_real(sack, allow_globs=True)) if nevra: s = _nevra_to_selector(sltr, nevra) if len(s.matches()) > 0: return s # pylint: disable=E1101 reldep = first(subj.reldep_possibilities_real(sack)) if reldep: dep = str(reldep) s = sltr.set(provides=dep) if len(s.matches()) > 0: return s if re.search(r'^\*?/', dep): key = "file__glob" if is_glob_pattern(dep) else "file" return sltr.set(**{key: dep}) return sltr
def test_nev(self): subj = hawkey.Subject(INP_FOF_NEV) nevra_possibilities = subj.get_nevra_possibilities( forms=hawkey.FORM_NEV) self.assertLength(nevra_possibilities, 1) self.assertEqual( nevra_possibilities[0], NEVRA(name='four-of-fish', epoch=8, version='3.6.9', release=None, arch=None))
def test_nevra(self): subj = hawkey.Subject("pilchard-1.2.4-1.x86_64") nevra_possibilities = subj.nevra_possibilities_real(self.sack) nevra = next(nevra_possibilities) self.assertEqual(nevra, NEVRA(name='pilchard', epoch=None, version='1.2.4', release='1', arch='x86_64')) nevra = next(nevra_possibilities) self.assertEqual(nevra, NEVRA(name='pilchard', epoch=None, version='1.2.4', release='1.x86_64', arch=None)) self.assertRaises(StopIteration, next, nevra_possibilities)
def upgrade(self, module_specs): no_match_specs = [] for spec in module_specs: module_list, nsvcap = self._get_modules(spec) if not module_list: no_match_specs.append(spec) continue update_module_list = [ x for x in module_list if self.base._moduleContainer.isModuleActive(x.getId()) ] if not update_module_list: logger.error(_("Unable to resolve argument {}").format(spec)) continue module_dict = self._create_module_dict_and_enable( update_module_list, False) upgrade_package_set = set() for name, streamdict in module_dict.items(): for stream, module_list_from_dict in streamdict.items(): upgrade_package_set.update( self._get_package_name_set_and_remove_profiles( module_list_from_dict, nsvcap)) latest_module = self._get_latest(module_list_from_dict) if nsvcap.profile: profiles_set = latest_module.getProfiles( nsvcap.profile) if not profiles_set: continue for profile in profiles_set: upgrade_package_set.update(profile.getContent()) else: for profile in latest_module.getProfiles(): upgrade_package_set.update(profile.getContent()) for artefact in latest_module.getArtifacts(): subj = hawkey.Subject(artefact) for nevra_obj in subj.get_nevra_possibilities( forms=[hawkey.FORM_NEVRA]): upgrade_package_set.add(nevra_obj.name) if not upgrade_package_set: logger.error( _("Unable to match profile in argument {}").format(spec)) query = self.base.sack.query().available().filterm( name=upgrade_package_set) if query: sltr = dnf.selector.Selector(self.base.sack) sltr.set(pkg=query) self.base._goal.upgrade(select=sltr) return no_match_specs
def _get_module_artifact_names(self, use_modules, skip_modules): artifacts = set() pkg_names = set() for module in use_modules: if module not in skip_modules: if self.base._moduleContainer.isModuleActive(module): artifacts.update(module.getArtifacts()) for artifact in artifacts: subj = hawkey.Subject(artifact) for nevra_obj in subj.get_nevra_possibilities( forms=[hawkey.FORM_NEVRA]): if nevra_obj.name: pkg_names.add(nevra_obj.name) return pkg_names, artifacts
def _get_modules(self, module_spec): subj = hawkey.Subject(module_spec) for nsvcap in subj.nsvcap_possibilities(): name = nsvcap.name if nsvcap.name else "" stream = nsvcap.stream if nsvcap.stream else "" version = "" context = nsvcap.context if nsvcap.context else "" arch = nsvcap.arch if nsvcap.arch else "" if nsvcap.version and nsvcap.version != -1: version = str(nsvcap.version) modules = self.base._moduleContainer.query(name, stream, version, context, arch) if modules: return modules, nsvcap return (), None
def test_custom_list(self): subj = hawkey.Subject(INP_FOF) result = subj.get_nevra_possibilities( forms=[hawkey.FORM_NEVRA, hawkey.FORM_NEVR]) self.assertLength(result, 2) self.assertEqual( result[0], NEVRA(name='four-of-fish', epoch=8, version='3.6.9', release='11.fc100', arch='x86_64')) self.assertEqual( result[1], NEVRA(name='four-of-fish', epoch=8, version='3.6.9', release='11.fc100.x86_64', arch=None))
def test_reldep_fail(self): subj = hawkey.Subject("Package not exist") reldeps = subj.reldep_possibilities_real(self.sack) self.assertRaises(StopIteration, next, reldeps)
def __init__(self, pkg_spec, ignore_case=False): self.subj = hawkey.Subject(pkg_spec) # internal subject self.icase = ignore_case
def test_nevr_fail(self): subj = hawkey.Subject("four-of") self.assertLength(subj.get_nevra_possibilities(forms=hawkey.FORM_NEVR), 0)
def _replay_pkg_action(self, pkg_data): try: action = pkg_data["action"] nevra = pkg_data["nevra"] reason = libdnf.transaction.StringToTransactionItemReason( pkg_data["reason"]) except KeyError as e: raise TransactionError( _('Missing object key "{key}" in an rpm.').format( key=e.args[0])) except IndexError as e: raise TransactionError( _('Unexpected value of package reason "{reason}" for rpm nevra "{nevra}".' ).format(reason=pkg_data["reason"], nevra=nevra)) subj = hawkey.Subject(nevra) parsed_nevras = subj.get_nevra_possibilities(forms=[hawkey.FORM_NEVRA]) if len(parsed_nevras) != 1: raise TransactionError( _('Cannot parse NEVRA for package "{nevra}".').format( nevra=nevra)) parsed_nevra = parsed_nevras[0] na = "%s.%s" % (parsed_nevra.name, parsed_nevra.arch) query_na = self._base.sack.query().filter(name=parsed_nevra.name, arch=parsed_nevra.arch) epoch = parsed_nevra.epoch if parsed_nevra.epoch is not None else 0 query = query_na.filter(epoch=epoch, version=parsed_nevra.version, release=parsed_nevra.release) if not query: self._raise_or_warn( self._skip_unavailable, _('Cannot find rpm nevra "{nevra}".').format(nevra=nevra)) return # a cache to check no extra packages were pulled into the transaction if action != "Reason Change": self._nevra_cache.add(nevra) # store reasons for forward actions and "Removed", the rest of the # actions reasons should stay as they were determined by the transaction if action in ("Install", "Upgrade", "Downgrade", "Reinstall", "Removed"): self._nevra_reason_cache[nevra] = reason if action in ("Install", "Upgrade", "Downgrade"): if action == "Install" and query_na.installed( ) and not self._base._get_installonly_query(query_na): self._raise_or_warn( self._ignore_installed, _('Package "{na}" is already installed for action "{action}".' ).format(na=na, action=action)) return sltr = dnf.selector.Selector(self._base.sack).set(pkg=query) self._base.goal.install(select=sltr, optional=not self._base.conf.strict) elif action == "Reinstall": query = query.available() if not query: self._raise_or_warn( self._skip_unavailable, _('Package nevra "{nevra}" not available in repositories for action "{action}".' ).format(nevra=nevra, action=action)) return sltr = dnf.selector.Selector(self._base.sack).set(pkg=query) self._base.goal.install(select=sltr, optional=not self._base.conf.strict) elif action in ("Upgraded", "Downgraded", "Reinstalled", "Removed", "Obsoleted"): query = query.installed() if not query: self._raise_or_warn( self._ignore_installed, _('Package nevra "{nevra}" not installed for action "{action}".' ).format(nevra=nevra, action=action)) return # erasing the original version (the reverse part of an action like # e.g. upgrade) is more robust, but we can't do it if # skip_unavailable is True, because if the forward part of the # action is skipped, we would simply remove the package here if not self._skip_unavailable or action == "Removed": for pkg in query: self._base.goal.erase(pkg, clean_deps=False) elif action == "Reason Change": self._base.history.set_reason(query[0], reason) else: raise TransactionError( _('Unexpected value of package action "{action}" for rpm nevra "{nevra}".' ).format(action=action, nevra=nevra))
def test_none(self): subj = hawkey.Subject(INP_FOF_NOEPOCH) ret = list(subj.nevra_possibilities_real(self.sack)) self.assertLength(ret, 0)
def test_nevra_fail(self): subj = hawkey.Subject("p*4-1*") ret = list(subj.nevra_possibilities_real(self.sack)) self.assertLength(ret, 0)
def test_nonexistent_version(self): subj = hawkey.Subject("penny-5") self.assertLength(list(subj.nevra_possibilities_real(self.sack)), 0)
def test_icase(self): subj = hawkey.Subject("penny-lib-DEVEL") nevra = next(subj.nevra_possibilities_real(self.sack, icase=True)) self.assertEqual(nevra.name, "penny-lib-DEVEL")
def test_nevra_toquery(self): subj = hawkey.Subject("pilchard-1.2.4-1.x86_64") nevra_possibilities = subj.nevra_possibilities_real(self.sack) nevra = next(nevra_possibilities) self.assertEqual(len(nevra.to_query(self.sack)), 1)
def test_wrong_arch(self): subj = hawkey.Subject("pilchard-1.2.4-1.ppc64") ret = list(subj.nevra_possibilities_real(self.sack)) self.assertLength(ret, 1)