def get_kernel_package(dnf_base, exclude_list):
"""Get an installable kernel package.
:param dnf_base: a DNF base
:param exclude_list: a list of excluded packages
:return: a package name or None
"""
if "kernel" in exclude_list:
return None
# Get the kernel packages.
kernels = ["kernel"]
# ARM systems use either the standard Multiplatform or LPAE platform.
if is_lpae_available():
kernels.insert(0, "kernel-lpae")
# Find an installable one.
for kernel_package in kernels:
subject = dnf.subject.Subject(kernel_package)
installable = bool(subject.get_best_query(dnf_base.sack))
if installable:
log.info("kernel: selected %s", kernel_package)
return kernel_package
log.info("kernel: no such package %s", kernel_package)
log.error("kernel: failed to select a kernel from %s", kernels)
return None
def is_package_available(self, package_spec):
"""Is the specified package available for the installation?
:param package_spec: a package spec
:return: True if the package can be installed, otherwise False
"""
if not self._base.sack:
log.warning("There is no metadata about packages!")
return False
subject = dnf.subject.Subject(package_spec)
return bool(subject.get_best_query(self._base.sack))
def run(self):
self.cli._populate_update_security_filter(self.opts)
if self.opts.querytags:
print(_('Available query-tags: use --queryformat ".. %{tag} .."'))
print(QUERY_TAGS)
return
q = self.base.sack.query()
if self.opts.key:
pkgs = []
for key in self.opts.key:
q = dnf.subject.Subject(key, ignore_case=True).get_best_query(
self.base.sack, with_provides=False)
pkgs += q.run()
q = self.base.sack.query().filter(pkg=pkgs)
if self.opts.recent:
q.recent(self.base.conf.recent)
if self.opts.available:
if self.opts.list and self.opts.list != "installed":
print(self.parser.format_help())
raise dnf.exceptions.Error(
_("argument {}: not allowed with argument {}".format(
"--available", "--" + self.opts.list)))
elif self.opts.list == "unneeded":
q = q._unneeded(self.base.sack, self.base._yumdb)
elif self.opts.list:
q = getattr(q, self.opts.list)()
if self.opts.pkgfilter == "duplicated":
installonly = self.base._get_installonly_query(q)
q = q.difference(installonly).duplicated()
elif self.opts.pkgfilter == "installonly":
q = self.base._get_installonly_query(q)
elif self.opts.pkgfilter == "unsatisfied":
rpmdb = dnf.sack._rpmdb_sack(self.base)
goal = dnf.goal.Goal(rpmdb)
solved = goal.run(verify=True)
if not solved:
for msg in goal.problems:
print(msg)
return
elif not self.opts.list:
# do not show packages from @System repo
q = q.available()
# filter repo and arch
q = self.filter_repo_arch(self.opts, q)
orquery = q
if self.opts.file:
q = q.filter(file__glob=self.opts.file)
if self.opts.whatprovides:
a = q.filter(provides__glob=[self.opts.whatprovides])
if a:
q = a
else:
q = q.filter(file__glob=self.opts.whatprovides)
if self.opts.alldeps or self.opts.exactdeps:
if not self.opts.whatrequires:
raise dnf.exceptions.Error(
_("argument {} requires --whatrequires option".format(
'--alldeps' if self.opts.alldeps else '--exactdeps')))
if self.opts.alldeps:
q = self.by_all_deps(self.opts.whatrequires, q)
else:
q = q.filter(requires__glob=self.opts.whatrequires)
elif self.opts.whatrequires:
q = self.by_all_deps(self.opts.whatrequires, q)
if self.opts.whatrecommends:
q = q.filter(recommends__glob=self.opts.whatrecommends)
if self.opts.whatenhances:
q = q.filter(enhances__glob=self.opts.whatenhances)
if self.opts.whatsupplements:
q = q.filter(supplements__glob=self.opts.whatsupplements)
if self.opts.whatsuggests:
q = q.filter(suggests__glob=self.opts.whatsuggests)
if self.opts.latest_limit:
q = q.latest(self.opts.latest_limit)
# reduce a query to security upgrades if they are specified
q = self.base._merge_update_filters(q, warning=False)
if self.opts.srpm:
pkg_list = []
for pkg in q:
srcname = pkg.source_name
if srcname is not None:
tmp_query = self.base.sack.query().filter(name=srcname,
evr=pkg.evr,
arch='src')
pkg_list += tmp_query.run()
q = self.base.sack.query().filter(pkg=pkg_list)
if self.opts.tree:
if not self.opts.whatrequires and not self.opts.packageatr:
raise dnf.exceptions.Error(
_("No switch specified\nusage: dnf repoquery [--whatrequires|"
"--requires|--conflicts|--obsoletes|--enhances|--suggest|"
"--provides|--suplements|--recommends] [key] [--tree]\n\n"
"description:\n For the given packages print a tree of the packages."
))
self.tree_seed(q, orquery, self.opts)
return
pkgs = set()
if self.opts.packageatr:
for pkg in q.run():
rels = getattr(pkg, OPTS_MAPPING[self.opts.packageatr])
for rel in rels:
pkgs.add(str(rel))
elif self.opts.deplist:
pkgs = []
for pkg in sorted(set(q.run())):
deplist_output = []
deplist_output.append('package: ' + str(pkg))
for req in sorted([str(req) for req in pkg.requires]):
deplist_output.append(' dependency: ' + req)
subject = dnf.subject.Subject(req)
query = subject.get_best_query(self.base.sack)
query = self.filter_repo_arch(self.opts, query.available())
if not self.opts.verbose:
query = query.latest()
for provider in query.run():
deplist_output.append(' provider: ' + str(provider))
pkgs.append('\n'.join(deplist_output))
print('\n\n'.join(pkgs))
return
else:
for pkg in q.run():
try:
pkgs.add(self.build_format_fn(self.opts, pkg))
except AttributeError as e:
# catch that the user has specified attributes
# there don't exist on the dnf Package object.
raise dnf.exceptions.Error(str(e))
if self.opts.resolve:
# find the providing packages and show them
query = self.filter_repo_arch(self.opts,
self.base.sack.query().available())
providers = query.filter(provides__glob=list(pkgs))
pkgs = set()
for pkg in providers.latest().run():
try:
pkgs.add(self.build_format_fn(self.opts, pkg))
except AttributeError as e:
# catch that the user has specified attributes
# there don't exist on the dnf Package object.
raise dnf.exceptions.Error(str(e))
for pkg in sorted(pkgs):
print(pkg)
def run(self):
if self.opts.querytags:
print(_('Available query-tags: use --queryformat ".. %{tag} .."'))
print(QUERY_TAGS)
return
self.cli._populate_update_security_filter(self.opts,
self.base.sack.query())
q = self.base.sack.query(
flags=hawkey.IGNORE_MODULAR_EXCLUDES if self.opts.
disable_modular_filtering else hawkey.APPLY_EXCLUDES)
if self.opts.key:
remote_packages = self._add_add_remote_packages()
kwark = {}
if self.opts.command in self.nevra_forms:
kwark["forms"] = [self.nevra_forms[self.opts.command]]
pkgs = []
query_results = q.filter(empty=True)
if remote_packages:
query_results = query_results.union(
self.base.sack.query().filterm(pkg=remote_packages))
for key in self.opts.key:
query_results = query_results.union(
dnf.subject.Subject(key, ignore_case=True).get_best_query(
self.base.sack, with_provides=False, query=q, **kwark))
q = query_results
if self.opts.recent:
q = q._recent(self.base.conf.recent)
if self.opts.available:
if self.opts.list and self.opts.list != "installed":
print(self.cli.optparser.print_usage())
raise dnf.exceptions.Error(
_("argument {}: not allowed with argument {}".format(
"--available", "--" + self.opts.list)))
elif self.opts.list == "unneeded":
q = q._unneeded(self.base.history.swdb)
elif self.opts.list and self.opts.list != 'userinstalled':
q = getattr(q, self.opts.list)()
if self.opts.pkgfilter == "duplicated":
installonly = self.base._get_installonly_query(q)
q = q.difference(installonly).duplicated()
elif self.opts.pkgfilter == "installonly":
q = self.base._get_installonly_query(q)
elif self.opts.pkgfilter == "unsatisfied":
rpmdb = dnf.sack.rpmdb_sack(self.base)
rpmdb._configure(self.base.conf.installonlypkgs,
self.base.conf.installonly_limit)
goal = dnf.goal.Goal(rpmdb)
goal.protect_running_kernel = False
solved = goal.run(verify=True)
if not solved:
print(dnf.util._format_resolve_problems(goal.problem_rules()))
return
elif not self.opts.list:
# do not show packages from @System repo
q = q.available()
# filter repo and arch
q = self.filter_repo_arch(self.opts, q)
orquery = q
if self.opts.file:
q.filterm(file__glob=self.opts.file)
if self.opts.whatconflicts:
rels = q.filter(conflicts__glob=self.opts.whatconflicts)
q = rels.union(
q.filter(conflicts=self._resolve_nevras(
self.opts.whatconflicts, q)))
if self.opts.whatobsoletes:
q.filterm(obsoletes=self.opts.whatobsoletes)
if self.opts.whatprovides:
query_for_provide = q.filter(provides__glob=self.opts.whatprovides)
if query_for_provide:
q = query_for_provide
else:
q.filterm(file__glob=self.opts.whatprovides)
if self.opts.whatrequires:
if (self.opts.exactdeps):
q.filterm(requires__glob=self.opts.whatrequires)
else:
q = self.by_all_deps(self.opts.whatrequires, q)
if self.opts.whatdepends:
if (self.opts.exactdeps):
dependsquery = q.filter(requires__glob=self.opts.whatdepends)
dependsquery = dependsquery.union(
q.filter(recommends__glob=self.opts.whatdepends))
dependsquery = dependsquery.union(
q.filter(enhances__glob=self.opts.whatdepends))
dependsquery = dependsquery.union(
q.filter(supplements__glob=self.opts.whatdepends))
q = dependsquery.union(
q.filter(suggests__glob=self.opts.whatdepends))
else:
q = self.by_all_deps(self.opts.whatdepends, q, True)
if self.opts.whatrecommends:
rels = q.filter(recommends__glob=self.opts.whatrecommends)
q = rels.union(
q.filter(recommends=self._resolve_nevras(
self.opts.whatrecommends, q)))
if self.opts.whatenhances:
rels = q.filter(enhances__glob=self.opts.whatenhances)
q = rels.union(
q.filter(
enhances=self._resolve_nevras(self.opts.whatenhances, q)))
if self.opts.whatsupplements:
rels = q.filter(supplements__glob=self.opts.whatsupplements)
q = rels.union(
q.filter(supplements=self._resolve_nevras(
self.opts.whatsupplements, q)))
if self.opts.whatsuggests:
rels = q.filter(suggests__glob=self.opts.whatsuggests)
q = rels.union(
q.filter(
suggests=self._resolve_nevras(self.opts.whatsuggests, q)))
if self.opts.latest_limit:
q = q.latest(self.opts.latest_limit)
# reduce a query to security upgrades if they are specified
q = self.base._merge_update_filters(q, warning=False)
if self.opts.srpm:
pkg_list = []
for pkg in q:
srcname = pkg.source_name
if srcname is not None:
tmp_query = self.base.sack.query().filterm(name=srcname,
evr=pkg.evr,
arch='src')
pkg_list += tmp_query.run()
q = self.base.sack.query().filterm(pkg=pkg_list)
if self.opts.tree:
if not self.opts.whatrequires and self.opts.packageatr not in (
'conflicts', 'enhances', 'obsoletes', 'provides',
'recommends', 'requires', 'suggests', 'supplements'):
raise dnf.exceptions.Error(
_("No valid switch specified\nusage: {prog} repoquery [--conflicts|"
"--enhances|--obsoletes|--provides|--recommends|--requires|"
"--suggest|--supplements|--whatrequires] [key] [--tree]\n\n"
"description:\n For the given packages print a tree of the"
"packages.").format(prog=dnf.util.MAIN_PROG))
self.tree_seed(q, orquery, self.opts)
return
pkgs = set()
if self.opts.packageatr:
rels = set()
for pkg in q.run():
if self.opts.list != 'userinstalled' or self.base.history.user_installed(
pkg):
if self.opts.packageatr == 'depends':
rels.update(pkg.requires + pkg.enhances +
pkg.suggests + pkg.supplements +
pkg.recommends)
else:
rels.update(
getattr(pkg, OPTS_MAPPING[self.opts.packageatr]))
if self.opts.resolve:
# find the providing packages and show them
if self.opts.list == "installed":
query = self.filter_repo_arch(self.opts,
self.base.sack.query())
else:
query = self.filter_repo_arch(
self.opts,
self.base.sack.query().available())
providers = query.filter(provides=rels)
if self.opts.recursive:
providers = providers.union(
self._get_recursive_providers_query(query, providers))
pkgs = set()
for pkg in providers.latest().run():
pkgs.add(self.build_format_fn(self.opts, pkg))
else:
pkgs.update(str(rel) for rel in rels)
elif self.opts.location:
for pkg in q.run():
location = pkg.remote_location()
if location is not None:
pkgs.add(location)
elif self.opts.deplist:
pkgs = []
for pkg in sorted(set(q.run())):
if self.opts.list != 'userinstalled' or self.base.history.user_installed(
pkg):
deplist_output = []
deplist_output.append('package: ' + str(pkg))
for req in sorted([str(req) for req in pkg.requires]):
deplist_output.append(' dependency: ' + req)
subject = dnf.subject.Subject(req)
query = subject.get_best_query(self.base.sack)
query = self.filter_repo_arch(self.opts,
query.available())
if not self.opts.verbose:
query = query.latest()
for provider in query.run():
deplist_output.append(' provider: ' +
str(provider))
pkgs.append('\n'.join(deplist_output))
if pkgs:
print('\n\n'.join(pkgs))
return
elif self.opts.groupmember:
self._group_member_report(q)
return
else:
for pkg in q.run():
if self.opts.list != 'userinstalled' or self.base.history.user_installed(
pkg):
pkgs.add(self.build_format_fn(self.opts, pkg))
if pkgs:
if self.opts.queryinfo:
print("\n\n".join(sorted(pkgs)))
else:
print("\n".join(sorted(pkgs)))
def run(self, args):
if self.opts.help_cmd:
self._parser.print_help()
return
self.check_prerequisites()
build_root = os.path.expanduser(self.opts.build_root) \
if self.opts.build_root else None
package_name = self.opts.package
if not package_name.endswith(".rpm"):
subject = dnf.subject.Subject(package_name)
query = subject.get_best_query(self.base.sack)
try:
installed_package = next(iter(query.installed()))
except StopIteration:
installed_package = None
print('Installed package version: ' + str(installed_package))
try:
packages = list(query.available().latest())
packages_with_src = []
for package in packages:
if package.sourcerpm:
logger.info("Found package: " + str(package))
packages_with_src.append(package)
else:
logger.info("Found package without source:" +
str(package))
package = packages_with_src[0]
except IndexError:
package = None
if not package:
print('Package not found.')
return 1
print('Found package: ' + str(package))
source_rpm_path = os.path.join(os.getcwd(), package.sourcerpm)
try:
self._run_dnf_command('download', [
'--source', '--destdir',
os.getcwd(), package.sourcerpm[:-len(".src.rpm")]
])
except subprocess.CalledProcessError:
raise dnf.exceptions.Error("download command failed")
if not os.path.isfile(source_rpm_path):
fmt = "Source RPM file '{0}' is missing (please report this bug!)"
raise dnf.exceptions.Error(fmt.format(source_rpm_path))
else:
source_rpm_path = package_name
logger.debug("build root: " + build_root)
self.setup_build_root(self.opts.build_root)
patches, base_path = self.process_config_file(self.opts.config_file)
if self.opts.enabled_patches:
patches.filter(self.opts.enabled_patches)
if self.opts.disabled_patches:
patches.filter(self.opts.disabled_patches, invert=True)
if not patches:
raise dnf.exceptions.Error(
"No patches found or selected, nothing to do.")
logger.info("Enabled patch sets: {0}".format(', '.join(
patches.keys())))
patch_list = flatten(patches.values())
for patch in patch_list:
logger.info("Enabled patch: {0}".format(patch.file))
if self.opts.build_deps:
try:
self._run_dnf_command('builddep', [source_rpm_path])
except subprocess.CalledProcessError:
raise dnf.exceptions.Error("builddep command failed")
builder = PackageBuilder(package_file=source_rpm_path,
build_root=build_root,
patches=patch_list,
base_path=base_path,
source_only=self.opts.source_only,
arch=self.opts.arch,
quiet=self.opts.quiet)
#try:
builder.build()
def run(self):
if self.opts.querytags:
print(_('Available query-tags: use --queryformat ".. %{tag} .."'))
print(QUERY_TAGS)
return
self.cli._populate_update_security_filter(self.opts, self.base.sack.query())
q = self.base.sack.query()
if self.opts.key:
kwark = {}
forms = [self.nevra_forms[command] for command in self.opts.command
if command in list(self.nevra_forms.keys())]
if forms:
kwark["forms"] = forms
pkgs = []
query_results = q.filter(empty=True)
for key in self.opts.key:
query_results = query_results.union(
dnf.subject.Subject(key, ignore_case=True).get_best_query(
self.base.sack, with_provides=False, **kwark))
q = query_results
if self.opts.recent:
q = q._recent(self.base.conf.recent)
if self.opts.available:
if self.opts.list and self.opts.list != "installed":
print(self.cli.optparser.print_usage())
raise dnf.exceptions.Error(_("argument {}: not allowed with argument {}".format(
"--available", "--" + self.opts.list)))
elif self.opts.list == "unneeded":
q = q._unneeded(self.base.history.swdb)
elif self.opts.list and self.opts.list != 'userinstalled':
q = getattr(q, self.opts.list)()
if self.opts.pkgfilter == "duplicated":
installonly = self.base._get_installonly_query(q)
q = q.difference(installonly).duplicated()
elif self.opts.pkgfilter == "installonly":
q = self.base._get_installonly_query(q)
elif self.opts.pkgfilter == "unsatisfied":
rpmdb = dnf.sack._rpmdb_sack(self.base)
rpmdb._configure(self.base.conf.installonlypkgs, self.base.conf.installonly_limit)
goal = dnf.goal.Goal(rpmdb)
solved = goal.run(verify=True)
if not solved:
print(dnf.util._format_resolve_problems(goal.problem_rules()))
return
elif not self.opts.list:
# do not show packages from @System repo
q = q.available()
# filter repo and arch
q = self.filter_repo_arch(self.opts, q)
orquery = q
if self.opts.file:
q.filterm(file__glob=self.opts.file)
if self.opts.whatconflicts:
q.filterm(conflicts=self.opts.whatconflicts)
if self.opts.whatobsoletes:
q.filterm(obsoletes=self.opts.whatobsoletes)
if self.opts.whatprovides:
query_for_provide = q.filter(provides__glob=[self.opts.whatprovides])
if query_for_provide:
q = query_for_provide
else:
q.filterm(file__glob=self.opts.whatprovides)
if self.opts.alldeps or self.opts.exactdeps:
if not (self.opts.whatrequires or self.opts.whatdepends):
raise dnf.exceptions.Error(
_("argument {} requires --whatrequires or --whatdepends option".format(
'--alldeps' if self.opts.alldeps else '--exactdeps')))
if self.opts.alldeps:
q = self.by_all_deps(self.opts.whatrequires, self.opts.whatdepends, q)
else:
if self.opts.whatrequires:
q.filterm(requires__glob=self.opts.whatrequires)
else:
dependsquery = q.filter(requires__glob=self.opts.whatdepends)
dependsquery = dependsquery.union(
q.filter(recommends__glob=self.opts.whatdepends))
dependsquery = dependsquery.union(
q.filter(enhances__glob=self.opts.whatdepends))
dependsquery = dependsquery.union(
q.filter(supplements__glob=self.opts.whatdepends))
q = dependsquery.union(q.filter(suggests__glob=self.opts.whatdepends))
elif self.opts.whatrequires or self.opts.whatdepends:
q = self.by_all_deps(self.opts.whatrequires, self.opts.whatdepends, q)
if self.opts.whatrecommends:
q.filterm(recommends__glob=self.opts.whatrecommends)
if self.opts.whatenhances:
q.filterm(enhances__glob=self.opts.whatenhances)
if self.opts.whatsupplements:
q.filterm(supplements__glob=self.opts.whatsupplements)
if self.opts.whatsuggests:
q.filterm(suggests__glob=self.opts.whatsuggests)
if self.opts.latest_limit:
q = q.latest(self.opts.latest_limit)
# reduce a query to security upgrades if they are specified
q = self.base._merge_update_filters(q, warning=False)
if self.opts.srpm:
pkg_list = []
for pkg in q:
srcname = pkg.source_name
if srcname is not None:
tmp_query = self.base.sack.query().filterm(name=srcname, evr=pkg.evr,
arch='src')
pkg_list += tmp_query.run()
q = self.base.sack.query().filterm(pkg=pkg_list)
if self.opts.tree:
if not self.opts.whatrequires and self.opts.packageatr not in (
'conflicts', 'enhances', 'obsoletes', 'provides', 'recommends',
'requires', 'suggests', 'supplements'):
raise dnf.exceptions.Error(
_("No valid switch specified\nusage: dnf repoquery [--conflicts|"
"--enhances|--obsoletes|--provides|--recommends|--requires|"
"--suggest|--supplements|--whatrequires] [key] [--tree]\n\n"
"description:\n For the given packages print a tree of the packages."))
self.tree_seed(q, orquery, self.opts)
return
pkgs = set()
if self.opts.packageatr:
rels = set()
for pkg in q.run():
if self.opts.list != 'userinstalled' or self.base.history.user_installed(pkg):
if self.opts.packageatr == 'depends':
rels.update(pkg.requires + pkg.enhances + pkg.suggests +
pkg.supplements + pkg.recommends)
else:
rels.update(getattr(pkg, OPTS_MAPPING[self.opts.packageatr]))
if self.opts.resolve:
# find the providing packages and show them
if self.opts.list == "installed":
query = self.filter_repo_arch(self.opts, self.base.sack.query())
else:
query = self.filter_repo_arch(self.opts, self.base.sack.query().available())
providers = query.filter(provides=rels)
if self.opts.recursive:
providers = providers.union(
self._get_recursive_providers_query(query, providers))
pkgs = set()
for pkg in providers.latest().run():
pkgs.add(self.build_format_fn(self.opts, pkg))
else:
pkgs.update(str(rel) for rel in rels)
elif self.opts.location:
for pkg in q.run():
location = pkg.remote_location()
if location is not None:
pkgs.add(location)
elif self.opts.deplist:
pkgs = []
for pkg in sorted(set(q.run())):
if self.opts.list != 'userinstalled' or self.base.history.user_installed(pkg):
deplist_output = []
deplist_output.append('package: ' + str(pkg))
for req in sorted([str(req) for req in pkg.requires]):
deplist_output.append(' dependency: ' + req)
subject = dnf.subject.Subject(req)
query = subject.get_best_query(self.base.sack)
query = self.filter_repo_arch(
self.opts, query.available())
if not self.opts.verbose:
query = query.latest()
for provider in query.run():
deplist_output.append(' provider: ' + str(provider))
pkgs.append('\n'.join(deplist_output))
if pkgs:
print('\n\n'.join(pkgs))
return
elif self.opts.groupmember:
self._group_member_report(q)
return
else:
for pkg in q.run():
if self.opts.list != 'userinstalled' or self.base.history.user_installed(pkg):
pkgs.add(self.build_format_fn(self.opts, pkg))
if pkgs:
if self.opts.queryinfo:
print("\n\n".join(sorted(pkgs)))
else:
print("\n".join(sorted(pkgs)))
def run(self):
self.cli._populate_update_security_filter(self.opts)
if self.opts.querytags:
print(_('Available query-tags: use --queryformat ".. %{tag} .."'))
print(QUERY_TAGS)
return
q = self.base.sack.query()
if self.opts.key:
pkgs = []
for key in self.opts.key:
q = dnf.subject.Subject(key, ignore_case=True).get_best_query(
self.base.sack, with_provides=False)
pkgs += q.run()
q = self.base.sack.query().filter(pkg=pkgs)
if self.opts.recent:
q.recent(self.base.conf.recent)
if self.opts.available:
if self.opts.list and self.opts.list != "installed":
print(self.parser.format_help())
raise dnf.exceptions.Error(_("argument {}: not allowed with argument {}".format(
"--available", "--" + self.opts.list)))
elif self.opts.list == "unneeded":
q = q._unneeded(self.base.sack, self.base._yumdb)
elif self.opts.list:
q = getattr(q, self.opts.list)()
if self.opts.pkgfilter == "duplicated":
installonly = self.base._get_installonly_query(q)
q = q.difference(installonly).duplicated()
elif self.opts.pkgfilter == "installonly":
q = self.base._get_installonly_query(q)
elif self.opts.pkgfilter == "unsatisfied":
rpmdb = dnf.sack._rpmdb_sack(self.base)
goal = dnf.goal.Goal(rpmdb)
solved = goal.run(verify=True)
if not solved:
for msg in goal.problems:
print(msg)
return
elif not self.opts.list:
# do not show packages from @System repo
q = q.available()
# filter repo and arch
q = self.filter_repo_arch(self.opts, q)
orquery = q
if self.opts.file:
q = q.filter(file__glob=self.opts.file)
if self.opts.whatprovides:
a = q.filter(provides__glob=[self.opts.whatprovides])
if a:
q = a
else:
q = q.filter(file__glob=self.opts.whatprovides)
if self.opts.alldeps or self.opts.exactdeps:
if not self.opts.whatrequires:
raise dnf.exceptions.Error(
_("argument {} requires --whatrequires option".format(
'--alldeps' if self.opts.alldeps else '--exactdeps')))
if self.opts.alldeps:
q = self.by_all_deps(self.opts.whatrequires, q)
else:
q = q.filter(requires__glob=self.opts.whatrequires)
elif self.opts.whatrequires:
q = self.by_all_deps(self.opts.whatrequires, q)
if self.opts.whatrecommends:
q = q.filter(recommends__glob=self.opts.whatrecommends)
if self.opts.whatenhances:
q = q.filter(enhances__glob=self.opts.whatenhances)
if self.opts.whatsupplements:
q = q.filter(supplements__glob=self.opts.whatsupplements)
if self.opts.whatsuggests:
q = q.filter(suggests__glob=self.opts.whatsuggests)
if self.opts.latest_limit:
q = q.latest(self.opts.latest_limit)
# reduce a query to security upgrades if they are specified
q = self.base._merge_update_filters(q, warning=False)
if self.opts.srpm:
pkg_list = []
for pkg in q:
srcname = pkg.source_name
if srcname is not None:
tmp_query = self.base.sack.query().filter(
name=srcname,
evr=pkg.evr,
arch='src')
pkg_list += tmp_query.run()
q = self.base.sack.query().filter(pkg=pkg_list)
if self.opts.tree:
if not self.opts.whatrequires and not self.opts.packageatr:
raise dnf.exceptions.Error(
_("No switch specified\nusage: dnf repoquery [--whatrequires|"
"--requires|--conflicts|--obsoletes|--enhances|--suggest|"
"--provides|--suplements|--recommends] [key] [--tree]\n\n"
"description:\n For the given packages print a tree of the packages."))
self.tree_seed(q, orquery, self.opts)
return
pkgs = set()
if self.opts.packageatr:
for pkg in q.run():
rels = getattr(pkg, OPTS_MAPPING[self.opts.packageatr])
for rel in rels:
pkgs.add(str(rel))
elif self.opts.deplist:
pkgs = []
for pkg in sorted(set(q.run())):
deplist_output = []
deplist_output.append('package: ' + str(pkg))
for req in sorted([str(req) for req in pkg.requires]):
deplist_output.append(' dependency: ' + req)
subject = dnf.subject.Subject(req)
query = subject.get_best_query(self.base.sack)
query = self.filter_repo_arch(
self.opts, query.available())
if not self.opts.verbose:
query = query.latest()
for provider in query.run():
deplist_output.append(' provider: ' + str(provider))
pkgs.append('\n'.join(deplist_output))
print('\n\n'.join(pkgs))
return
else:
for pkg in q.run():
try:
pkgs.add(self.build_format_fn(self.opts, pkg))
except AttributeError as e:
# catch that the user has specified attributes
# there don't exist on the dnf Package object.
raise dnf.exceptions.Error(str(e))
if self.opts.resolve:
# find the providing packages and show them
query = self.filter_repo_arch(
self.opts, self.base.sack.query().available())
providers = query.filter(provides__glob=list(pkgs))
pkgs = set()
for pkg in providers.latest().run():
try:
pkgs.add(self.build_format_fn(self.opts, pkg))
except AttributeError as e:
# catch that the user has specified attributes
# there don't exist on the dnf Package object.
raise dnf.exceptions.Error(str(e))
for pkg in sorted(pkgs):
print(pkg)
