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)
