chantra / rpms / dnf

Forked from rpms/dnf 2 years ago
Clone
Blob Blame History Raw
From bfd04883c44ad31407f0b5a48e06fa597c46d727 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Hr=C3=A1zk=C3=BD?= <lhrazky@redhat.com>
Date: Fri, 12 Jul 2019 17:14:00 +0200
Subject: [PATCH 1/6] repoquery: move the alldeps/exactdeps check to
 configure()

Moves the check for alldeps/exactdeps switches to the configure() method
along with the other checks.

Raises dnf.cli.CliError instead of dnf.exceptions.Error.
---
 dnf/cli/commands/repoquery.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/dnf/cli/commands/repoquery.py b/dnf/cli/commands/repoquery.py
index 7334ddcd90..dc09bf4403 100644
--- a/dnf/cli/commands/repoquery.py
+++ b/dnf/cli/commands/repoquery.py
@@ -303,6 +303,12 @@ def configure(self):
                       "(optionally with '--alldeps', but not with '--exactdeps'), or with "
                       "'--requires <REQ> --resolve'"))
 
+        if self.opts.alldeps or self.opts.exactdeps:
+            if not (self.opts.whatrequires or self.opts.whatdepends):
+                raise dnf.cli.CliError(
+                    _("argument {} requires --whatrequires or --whatdepends option".format(
+                        '--alldeps' if self.opts.alldeps else '--exactdeps')))
+
         if self.opts.srpm:
             self.base.repos.enable_source_repos()
 
@@ -496,10 +502,6 @@ def run(self):
             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:

From d9492fef24989085011047dd561fef1dfa1e31d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Hr=C3=A1zk=C3=BD?= <lhrazky@redhat.com>
Date: Fri, 12 Jul 2019 17:22:05 +0200
Subject: [PATCH 2/6] repoquery: fix calling by_all_deps() for --tree

Fixes a bug introduced in bd00c044, where the by_all_deps() arguments
were changed to an array, but in tree_seed() it still passes a single
string.

Untested, I have actually no idea what the code does there, it looks
kind of suspect.
---
 dnf/cli/commands/repoquery.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dnf/cli/commands/repoquery.py b/dnf/cli/commands/repoquery.py
index dc09bf4403..db174b3bba 100644
--- a/dnf/cli/commands/repoquery.py
+++ b/dnf/cli/commands/repoquery.py
@@ -674,7 +674,7 @@ def tree_seed(self, query, aquery, opts, level=-1, usedpkgs=None):
                             ar[querypkg.name + "." + querypkg.arch] = querypkg
                     pkgquery = self.base.sack.query().filterm(pkg=list(ar.values()))
                 else:
-                    pkgquery = self.by_all_deps(pkg.name, None, aquery) if opts.alldeps \
+                    pkgquery = self.by_all_deps((pkg.name, ), None, aquery) if opts.alldeps \
                         else aquery.filter(requires__glob=pkg.name)
                 self.tree_seed(pkgquery, aquery, opts, level + 1, usedpkgs)
 

From f2f31452876b37b54150cba1bf08fc46ecaf72f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Hr=C3=A1zk=C3=BD?= <lhrazky@redhat.com>
Date: Fri, 12 Jul 2019 17:44:38 +0200
Subject: [PATCH 3/6] repoquery: simplify handling of whatrequires and
 whatdepends

Separates whatrequires and whatdepends handling into two separate code
branches, the original was overly complex, confusing and presented
multiple unnecessary corner cases.

The by_all_deps() arguments now also have a much better defined role.
---
 dnf/cli/commands/repoquery.py | 59 +++++++++++++++++------------------
 1 file changed, 29 insertions(+), 30 deletions(-)

diff --git a/dnf/cli/commands/repoquery.py b/dnf/cli/commands/repoquery.py
index db174b3bba..f5e951c9c8 100644
--- a/dnf/cli/commands/repoquery.py
+++ b/dnf/cli/commands/repoquery.py
@@ -350,7 +350,7 @@ def build_format_fn(self, opts, pkg):
             raise dnf.exceptions.Error(str(e))
 
     def _get_recursive_deps_query(self, query_in, query_select, done=None, recursive=False,
-                                  all_deps=False):
+                                  all_dep_types=False):
         done = done if done else self.base.sack.query().filterm(empty=True)
         t = self.base.sack.query().filterm(empty=True)
         set_requires = set()
@@ -360,7 +360,7 @@ def _get_recursive_deps_query(self, query_in, query_select, done=None, recursive
             pkg_provides = pkg.provides
             set_requires.update(pkg_provides)
             set_requires.update(pkg.files)
-            if all_deps:
+            if all_dep_types:
                 set_all_deps.update(pkg_provides)
 
         t = t.union(query_in.filter(requires=set_requires))
@@ -373,29 +373,29 @@ def _get_recursive_deps_query(self, query_in, query_select, done=None, recursive
             query_select = t.difference(done)
             if query_select:
                 done = self._get_recursive_deps_query(query_in, query_select, done=t.union(done),
-                                                      recursive=recursive, all_deps=all_deps)
+                                                      recursive=recursive,
+                                                      all_dep_types=all_dep_types)
         return t.union(done)
 
-    def by_all_deps(self, requires_name, depends_name, query):
-        names = requires_name or depends_name
+    def by_all_deps(self, names, query, all_dep_types=False):
         defaultquery = self.base.sack.query().filterm(empty=True)
         for name in names:
             defaultquery = defaultquery.union(query.intersection(
                 dnf.subject.Subject(name).get_best_query(self.base.sack, with_provides=False,
                                                          with_filenames=False)))
         requiresquery = query.filter(requires__glob=names)
-        if depends_name:
-            requiresquery = requiresquery.union(query.filter(recommends__glob=depends_name))
-            requiresquery = requiresquery.union(query.filter(enhances__glob=depends_name))
-            requiresquery = requiresquery.union(query.filter(supplements__glob=depends_name))
-            requiresquery = requiresquery.union(query.filter(suggests__glob=depends_name))
+        if all_dep_types:
+            requiresquery = requiresquery.union(query.filter(recommends__glob=names))
+            requiresquery = requiresquery.union(query.filter(enhances__glob=names))
+            requiresquery = requiresquery.union(query.filter(supplements__glob=names))
+            requiresquery = requiresquery.union(query.filter(suggests__glob=names))
 
         done = requiresquery.union(self._get_recursive_deps_query(query, defaultquery,
-                                                                  all_deps=depends_name))
+                                                                  all_dep_types=all_dep_types))
         if self.opts.recursive:
             done = done.union(self._get_recursive_deps_query(query, done,
                                                              recursive=self.opts.recursive,
-                                                             all_deps=depends_name))
+                                                             all_dep_types=all_dep_types))
         return done
 
     def _get_recursive_providers_query(self, query_in, providers, done=None):
@@ -501,24 +501,23 @@ def run(self):
                 q = query_for_provide
             else:
                 q.filterm(file__glob=self.opts.whatprovides)
-        if self.opts.alldeps or self.opts.exactdeps:
-            if self.opts.alldeps:
-                q = self.by_all_deps(self.opts.whatrequires, self.opts.whatdepends, q)
+
+        if self.opts.whatrequires:
+            if (self.opts.exactdeps):
+                q.filterm(requires__glob=self.opts.whatrequires)
             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)
+                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:
             q.filterm(recommends__glob=self.opts.whatrecommends)
         if self.opts.whatenhances:
@@ -674,7 +673,7 @@ def tree_seed(self, query, aquery, opts, level=-1, usedpkgs=None):
                             ar[querypkg.name + "." + querypkg.arch] = querypkg
                     pkgquery = self.base.sack.query().filterm(pkg=list(ar.values()))
                 else:
-                    pkgquery = self.by_all_deps((pkg.name, ), None, aquery) if opts.alldeps \
+                    pkgquery = self.by_all_deps((pkg.name, ), aquery) if opts.alldeps \
                         else aquery.filter(requires__glob=pkg.name)
                 self.tree_seed(pkgquery, aquery, opts, level + 1, usedpkgs)
 

From a1bdbfa498438c2710aecd607a82face05a1bdfd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Hr=C3=A1zk=C3=BD?= <lhrazky@redhat.com>
Date: Tue, 9 Jul 2019 17:30:58 +0200
Subject: [PATCH 4/6] repoquery: rework "alldeps" dependency search
 (RhBug:1534123,1698034)

Uses the new feature of filtering by solvables to properly resolve rich
dependencies for packages. The new code now, along with serching for the
arguments as reldeps, also searches for them as NEVRAs and then looks up
the dependencies for the packages it found.

https://bugzilla.redhat.com/show_bug.cgi?id=1534123
https://bugzilla.redhat.com/show_bug.cgi?id=1698034
---
 dnf.spec                      |  2 +-
 dnf/cli/commands/repoquery.py | 93 +++++++++++++++++++----------------
 2 files changed, 51 insertions(+), 44 deletions(-)

diff --git a/dnf.spec b/dnf.spec
index 79e4d27dab..578baccac4 100644
--- a/dnf.spec
+++ b/dnf.spec
@@ -1,5 +1,5 @@
 # default dependencies
-%global hawkey_version 0.41.0
+%global hawkey_version 0.44.0
 %global libcomps_version 0.1.8
 %global libmodulemd_version 1.4.0
 %global rpm_version 4.14.0
diff --git a/dnf/cli/commands/repoquery.py b/dnf/cli/commands/repoquery.py
index f5e951c9c8..d86d32ffcd 100644
--- a/dnf/cli/commands/repoquery.py
+++ b/dnf/cli/commands/repoquery.py
@@ -349,54 +349,61 @@ def build_format_fn(self, opts, pkg):
             # there don't exist on the dnf Package object.
             raise dnf.exceptions.Error(str(e))
 
-    def _get_recursive_deps_query(self, query_in, query_select, done=None, recursive=False,
-                                  all_dep_types=False):
-        done = done if done else self.base.sack.query().filterm(empty=True)
-        t = self.base.sack.query().filterm(empty=True)
-        set_requires = set()
-        set_all_deps = set()
-
-        for pkg in query_select.run():
-            pkg_provides = pkg.provides
-            set_requires.update(pkg_provides)
-            set_requires.update(pkg.files)
-            if all_dep_types:
-                set_all_deps.update(pkg_provides)
-
-        t = t.union(query_in.filter(requires=set_requires))
-        if set_all_deps:
-            t = t.union(query_in.filter(recommends=set_all_deps))
-            t = t.union(query_in.filter(enhances=set_all_deps))
-            t = t.union(query_in.filter(supplements=set_all_deps))
-            t = t.union(query_in.filter(suggests=set_all_deps))
-        if recursive:
-            query_select = t.difference(done)
-            if query_select:
-                done = self._get_recursive_deps_query(query_in, query_select, done=t.union(done),
-                                                      recursive=recursive,
-                                                      all_dep_types=all_dep_types)
-        return t.union(done)
+    def _resolve_nevras(self, nevras, base_query):
+        resolved_nevras_query = self.base.sack.query().filterm(empty=True)
+        for nevra in nevras:
+            resolved_nevras_query = resolved_nevras_query.union(base_query.intersection(
+                dnf.subject.Subject(nevra).get_best_query(
+                    self.base.sack,
+                    with_provides=False,
+                    with_filenames=False
+                )
+            ))
+
+        return resolved_nevras_query
+
+    def _do_recursive_deps(self, query_in, query_select, done=None):
+        done = done if done else query_select
+
+        query_required = query_in.filter(requires=query_select)
+
+        query_select = query_required.difference(done)
+        done = query_required.union(done)
+
+        if query_select:
+            done = self._do_recursive_deps(query_in, query_select, done=done)
+
+        return done
 
     def by_all_deps(self, names, query, all_dep_types=False):
-        defaultquery = self.base.sack.query().filterm(empty=True)
-        for name in names:
-            defaultquery = defaultquery.union(query.intersection(
-                dnf.subject.Subject(name).get_best_query(self.base.sack, with_provides=False,
-                                                         with_filenames=False)))
-        requiresquery = query.filter(requires__glob=names)
+        # in case of arguments being NEVRAs, resolve them to packages
+        resolved_nevras_query = self._resolve_nevras(names, query)
+
+        # filter the arguments directly as reldeps
+        depquery = query.filter(requires__glob=names)
+
+        # filter the resolved NEVRAs as packages
+        depquery = depquery.union(query.filter(requires=resolved_nevras_query))
+
         if all_dep_types:
-            requiresquery = requiresquery.union(query.filter(recommends__glob=names))
-            requiresquery = requiresquery.union(query.filter(enhances__glob=names))
-            requiresquery = requiresquery.union(query.filter(supplements__glob=names))
-            requiresquery = requiresquery.union(query.filter(suggests__glob=names))
+            # TODO this is very inefficient, as it resolves the `names` glob to
+            # reldeps four more times, which in a reasonably wide glob like
+            # `dnf repoquery --whatdepends "libdnf*"` can take roughly 50% of
+            # the total execution time.
+            depquery = depquery.union(query.filter(recommends__glob=names))
+            depquery = depquery.union(query.filter(enhances__glob=names))
+            depquery = depquery.union(query.filter(supplements__glob=names))
+            depquery = depquery.union(query.filter(suggests__glob=names))
+
+            depquery = depquery.union(query.filter(recommends=resolved_nevras_query))
+            depquery = depquery.union(query.filter(enhances=resolved_nevras_query))
+            depquery = depquery.union(query.filter(supplements=resolved_nevras_query))
+            depquery = depquery.union(query.filter(suggests=resolved_nevras_query))
 
-        done = requiresquery.union(self._get_recursive_deps_query(query, defaultquery,
-                                                                  all_dep_types=all_dep_types))
         if self.opts.recursive:
-            done = done.union(self._get_recursive_deps_query(query, done,
-                                                             recursive=self.opts.recursive,
-                                                             all_dep_types=all_dep_types))
-        return done
+            depquery = self._do_recursive_deps(query, depquery)
+
+        return depquery
 
     def _get_recursive_providers_query(self, query_in, providers, done=None):
         done = done if done else self.base.sack.query().filterm(empty=True)

From 60cd14aae7fe3d9ae75d5e5665fc311ef3b04402 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Hr=C3=A1zk=C3=BD?= <lhrazky@redhat.com>
Date: Fri, 1 Nov 2019 18:33:13 +0100
Subject: [PATCH 5/6] repoquery: resolve NEVRAs to packages for most of --what*
 arguments (RhBug:1534123,1698034)

To properly list the conflicts, suggests, recommends, enhances and
supplements dependencies of packages defined through provides or even
rich dependencies, it is required to resolve them to packages and query
for them, because that's where the dependencies are defined.

https://bugzilla.redhat.com/show_bug.cgi?id=1534123
https://bugzilla.redhat.com/show_bug.cgi?id=1698034
---
 dnf/cli/commands/repoquery.py | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/dnf/cli/commands/repoquery.py b/dnf/cli/commands/repoquery.py
index d86d32ffcd..d0521432be 100644
--- a/dnf/cli/commands/repoquery.py
+++ b/dnf/cli/commands/repoquery.py
@@ -499,7 +499,8 @@ def run(self):
         if self.opts.file:
             q.filterm(file__glob=self.opts.file)
         if self.opts.whatconflicts:
-            q.filterm(conflicts=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:
@@ -526,13 +527,18 @@ def run(self):
                 q = self.by_all_deps(self.opts.whatdepends, q, True)
 
         if self.opts.whatrecommends:
-            q.filterm(recommends__glob=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:
-            q.filterm(enhances__glob=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:
-            q.filterm(supplements__glob=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:
-            q.filterm(suggests__glob=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

From 757f9ad4f26c5a0fee9a6a3620eea94dd6004a73 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Hr=C3=A1zk=C3=BD?= <lhrazky@redhat.com>
Date: Tue, 14 Jan 2020 16:44:07 +0100
Subject: [PATCH 6/6] [doc] Update documentation for the query filter API

Add the new types of arguments supported for dependency filtering.
---
 doc/api_queries.rst | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/doc/api_queries.rst b/doc/api_queries.rst
index 5c8804e52a..98907d95a6 100644
--- a/doc/api_queries.rst
+++ b/doc/api_queries.rst
@@ -101,17 +101,20 @@
     release           string         match against packages' releases
     reponame          string         match against packages repositories' names
     version           string         match against packages' versions
-    obsoletes         Query          match packages that obsolete any package from query
     pkg               Query          match against packages in query
     pkg*              list           match against hawkey.Packages in list
     provides          string         match against packages' provides
     provides*         Hawkey.Reldep  match against packages' provides
-    requires          string         match against packages' requirements
-    requires*         Hawkey.Reldep  match against packages' requirements
+    <DEP>             string         match against packages' <DEP>
+    <DEP>*            Hawkey.Reldep  match a reldep against packages' <DEP>
+    <DEP>*            Query          match the result of a query against packages' <DEP>
+    <DEP>*            list(Package)  match the list of hawkey.Packages against packages' <DEP>
     sourcerpm         string         match against packages' source rpm
     upgrades          boolean        see :meth:`upgrades`. Defaults to ``False``.
     ===============   ============== ======================================================
 
+    ``<DEP>`` can be any of: requires, conflicts, obsoletes, enhances, recomments, suggests, supplements
+
     \* The key can also accept a list of values with specified type.
 
     The key name can be supplemented with a relation-specifying suffix, separated by ``__``:
@@ -133,6 +136,8 @@
 
       q = base.sack.query().filter(name__substr="club")
 
+    Note that using packages or queries for dependency filtering performs a more advanced resolution than using a string or a reldep. When a package list or a query is used, rich dependencies are resolved in a more precise way than what is possible when a string or a reldep is used.
+
   .. method:: filterm(\*\*kwargs)
 
     Similar to :meth:`dnf.query.Query.filter` but it modifies the query in place.