From b36464f01ffadab9ca49eed1a06ab480626b28c2 Mon Sep 17 00:00:00 2001

From: Jaroslav Mracek <jmracek@redhat.com>

Date: Mon, 16 Dec 2019 10:10:51 +0100

Subject: [PATCH 1/2] Add new query filter upgrades_by_priority

It returns upgrades only from repository with the lowest priority.

---

 libdnf/hy-types.h              |  3 +-

 libdnf/sack/query.cpp          | 60 ++++++++++++++++++++++++++++++++++

 python/hawkey/hawkeymodule.cpp |  1 +

 python/hawkey/query-py.cpp     |  5 ++-

 4 files changed, 67 insertions(+), 2 deletions(-)

diff --git a/libdnf/hy-types.h b/libdnf/hy-types.h

index b34988d89..380a0d5cc 100644

--- a/libdnf/hy-types.h

+++ b/libdnf/hy-types.h

@@ -97,7 +97,8 @@ enum _hy_key_name_e {

     * @brief Use for strings of whole NEVRA (missing epoch is handled as epoch 0)

     * Allowed compare types - only HY_EQ or HY_NEQ

     */

-    HY_PKG_NEVRA_STRICT = 36

+    HY_PKG_NEVRA_STRICT = 36,

+    HY_PKG_UPGRADES_BY_PRIORITY = 37,

 };

 enum _hy_comparison_type_e {

diff --git a/libdnf/sack/query.cpp b/libdnf/sack/query.cpp

index eea0ce1b1..ecfd3110f 100644

--- a/libdnf/sack/query.cpp

+++ b/libdnf/sack/query.cpp

@@ -148,6 +148,13 @@ NameArchSolvableComparator(const Solvable * first, const Solvable * second)

     return first->arch < second->arch;

 }

+static bool

+NamePrioritySolvableKey(const Solvable * first, const Solvable * second)

+{

+    if (first->name != second->name)

+        return first->name < second->name;

+    return first->repo->priority > second->repo->priority;

+}

 static bool

 match_type_num(int keyname) {

@@ -158,6 +165,7 @@ match_type_num(int keyname) {

         case HY_PKG_LATEST_PER_ARCH:

         case HY_PKG_UPGRADABLE:

         case HY_PKG_UPGRADES:

+        case HY_PKG_UPGRADES_BY_PRIORITY:

         case HY_PKG_DOWNGRADABLE:

         case HY_PKG_DOWNGRADES:

             return true;

@@ -690,6 +698,7 @@ class Query::Impl {

     void filterAdvisory(const Filter & f, Map *m, int keyname);

     void filterLatest(const Filter & f, Map *m);

     void filterUpdown(const Filter & f, Map *m);

+    void filterUpdownByPriority(const Filter & f, Map *m);

     void filterUpdownAble(const Filter  &f, Map *m);

     void filterDataiterator(const Filter & f, Map *m);

     int filterUnneededOrSafeToRemove(const Swdb &swdb, bool debug_solver, bool safeToRemove);

@@ -1732,6 +1741,54 @@ Query::Impl::filterUpdown(const Filter & f, Map *m)

     }

 }

+void

+Query::Impl::filterUpdownByPriority(const Filter & f, Map *m)

+{

+    Pool *pool = dnf_sack_get_pool(sack);

+    auto resultPset = result.get();

+

+    dnf_sack_make_provides_ready(sack);

+    auto repoInstalled = pool->installed;

+    if (!repoInstalled) {

+        return;

+    }

+

+    for (auto match_in : f.getMatches()) {

+        if (match_in.num == 0)

+            continue;

+        std::vector<Solvable *> upgradeCandidates;

+        upgradeCandidates.reserve(resultPset->size());

+        Id id = -1;

+        while ((id = resultPset->next(id)) != -1) {

+            Solvable *candidate = pool_id2solvable(pool, id);

+            if (candidate->repo == repoInstalled)

+                continue;

+            upgradeCandidates.push_back(candidate);

+        }

+        if (upgradeCandidates.empty()) {

+            continue;

+        }

+        std::sort(upgradeCandidates.begin(), upgradeCandidates.end(), NamePrioritySolvableKey);

+        Id name = 0;

+        int priority = 0;

+        for (auto * candidate: upgradeCandidates) {

+            if (name != candidate->name) {

+                name = candidate->name;

+                priority = candidate->repo->priority;

+                id = pool_solvable2id(pool, candidate);

+                if (what_upgrades(pool, id) > 0) {

+                    MAPSET(m, id);

+                }

+            } else if (priority == candidate->repo->priority) {

+                id = pool_solvable2id(pool, candidate);

+                if (what_upgrades(pool, id) > 0) {

+                    MAPSET(m, id);

+                }

+            }

+        }

+    }

+}

+

 void

 Query::Impl::filterUpdownAble(const Filter  &f, Map *m)

 {

@@ -1949,6 +2006,9 @@ Query::Impl::apply()

             case HY_PKG_UPGRADES:

                 filterUpdown(f, &m);

                 break;

+            case HY_PKG_UPGRADES_BY_PRIORITY:

+                filterUpdownByPriority(f, &m);

+                break;

             default:

                 filterDataiterator(f, &m);

         }

diff --git a/python/hawkey/hawkeymodule.cpp b/python/hawkey/hawkeymodule.cpp

index 0f05f46c2..4351e96e1 100644

--- a/python/hawkey/hawkeymodule.cpp

+++ b/python/hawkey/hawkeymodule.cpp

@@ -281,6 +281,7 @@ PYCOMP_MOD_INIT(_hawkey)

     PyModule_AddIntConstant(m, "PKG_SUPPLEMENTS", HY_PKG_SUPPLEMENTS);

     PyModule_AddIntConstant(m, "PKG_UPGRADABLE", HY_PKG_UPGRADABLE);

     PyModule_AddIntConstant(m, "PKG_UPGRADES", HY_PKG_UPGRADES);

+    PyModule_AddIntConstant(m, "PKG_UPGRADES_BY_PRIORITY", HY_PKG_UPGRADES_BY_PRIORITY);

     PyModule_AddIntConstant(m, "PKG_URL", HY_PKG_URL);

     PyModule_AddIntConstant(m, "PKG_VERSION", HY_PKG_VERSION);

diff --git a/python/hawkey/query-py.cpp b/python/hawkey/query-py.cpp

index 116ffa1b0..286e306d3 100644

--- a/python/hawkey/query-py.cpp

+++ b/python/hawkey/query-py.cpp

@@ -89,6 +89,7 @@ static const int keyname_int_matches[] = {

     HY_PKG_SUPPLEMENTS,

     HY_PKG_UPGRADABLE,

     HY_PKG_UPGRADES,

+    HY_PKG_UPGRADES_BY_PRIORITY,

     HY_PKG_URL,

     HY_PKG_VERSION

 };

@@ -128,6 +129,7 @@ static const char * const keyname_char_matches[] = {

     "supplements",

     "upgradable",

     "upgrades",

+    "upgrades_by_priority",

     "url",

     "version",

     NULL

@@ -273,7 +275,8 @@ filter_add(HyQuery query, key_t keyname, int cmp_type, PyObject *match)

         keyname == HY_PKG_LATEST_PER_ARCH ||

         keyname == HY_PKG_LATEST ||

         keyname == HY_PKG_UPGRADABLE ||

-        keyname == HY_PKG_UPGRADES) {

+        keyname == HY_PKG_UPGRADES ||

+        keyname == HY_PKG_UPGRADES_BY_PRIORITY) {

         int val;

         if (!PyInt_Check(match) || cmp_type != HY_EQ) {

From 4b83ae692f90d0d3cbc377c7f93bdb7e99e477ef Mon Sep 17 00:00:00 2001

From: Jaroslav Mracek <jmracek@redhat.com>

Date: Mon, 16 Dec 2019 18:34:37 +0100

Subject: [PATCH 2/2] Add new query filter obsoletes_by_priority

---

 libdnf/hy-types.h              |  1 +

 libdnf/sack/query.cpp          | 65 ++++++++++++++++++++++++++++++++++

 python/hawkey/hawkeymodule.cpp |  1 +

 python/hawkey/query-py.cpp     |  5 ++-

 4 files changed, 71 insertions(+), 1 deletion(-)

diff --git a/libdnf/hy-types.h b/libdnf/hy-types.h

index 380a0d5cc..e96459c25 100644

--- a/libdnf/hy-types.h

+++ b/libdnf/hy-types.h

@@ -99,6 +99,7 @@ enum _hy_key_name_e {

     */

     HY_PKG_NEVRA_STRICT = 36,

     HY_PKG_UPGRADES_BY_PRIORITY = 37,

+    HY_PKG_OBSOLETES_BY_PRIORITY = 38,

 };

 enum _hy_comparison_type_e {

diff --git a/libdnf/sack/query.cpp b/libdnf/sack/query.cpp

index ecfd3110f..6e9e4715f 100644

--- a/libdnf/sack/query.cpp

+++ b/libdnf/sack/query.cpp

@@ -179,6 +179,7 @@ match_type_pkg(int keyname) {

     switch (keyname) {

         case HY_PKG:

         case HY_PKG_OBSOLETES:

+        case HY_PKG_OBSOLETES_BY_PRIORITY:

             return true;

         default:

             return false;

@@ -692,6 +693,7 @@ class Query::Impl {

     void filterArch(const Filter & f, Map *m);

     void filterSourcerpm(const Filter & f, Map *m);

     void filterObsoletes(const Filter & f, Map *m);

+    void filterObsoletesByPriority(const Filter & f, Map *m);

     void filterProvidesReldep(const Filter & f, Map *m);

     void filterReponame(const Filter & f, Map *m);

     void filterLocation(const Filter & f, Map *m);

@@ -702,6 +704,7 @@ class Query::Impl {

     void filterUpdownAble(const Filter  &f, Map *m);

     void filterDataiterator(const Filter & f, Map *m);

     int filterUnneededOrSafeToRemove(const Swdb &swdb, bool debug_solver, bool safeToRemove);

+    void obsoletesByPriority(Pool * pool, Solvable * candidate, Map * m, const Map * target, int obsprovides);

     bool isGlob(const std::vector<const char *> &matches) const;

 };

@@ -1469,6 +1472,65 @@ Query::Impl::filterObsoletes(const Filter & f, Map *m)

     }

 }

+void

+Query::Impl::obsoletesByPriority(Pool * pool, Solvable * candidate, Map * m, const Map * target, int obsprovides)

+{

+    if (!candidate->repo)

+        return;

+    for (Id *r_id = candidate->repo->idarraydata + candidate->obsoletes; *r_id; ++r_id) {

+        Id r, rr;

+        FOR_PROVIDES(r, rr, *r_id) {

+            if (!MAPTST(target, r))

+                continue;

+            assert(r != SYSTEMSOLVABLE);

+            Solvable *so = pool_id2solvable(pool, r);

+            if (!obsprovides && !pool_match_nevr(pool, so, *r_id))

+                continue; /* only matching pkg names */

+            MAPSET(m, pool_solvable2id(pool, candidate));

+            break;

+        }

+    }

+}

+

+void

+Query::Impl::filterObsoletesByPriority(const Filter & f, Map *m)

+{

+    Pool *pool = dnf_sack_get_pool(sack);

+    int obsprovides = pool_get_flag(pool, POOL_FLAG_OBSOLETEUSESPROVIDES);

+    Map *target;

+    auto resultPset = result.get();

+

+    assert(f.getMatchType() == _HY_PKG);

+    assert(f.getMatches().size() == 1);

+    target = dnf_packageset_get_map(f.getMatches()[0].pset);

+    dnf_sack_make_provides_ready(sack);

+    std::vector<Solvable *> obsoleteCandidates;

+    obsoleteCandidates.reserve(resultPset->size());

+    Id id = -1;

+    while ((id = resultPset->next(id)) != -1) {

+        Solvable *candidate = pool_id2solvable(pool, id);

+        obsoleteCandidates.push_back(candidate);

+    }

+    if (obsoleteCandidates.empty()) {

+        return;

+    }

+    std::sort(obsoleteCandidates.begin(), obsoleteCandidates.end(), NamePrioritySolvableKey);

+    Id name = 0;

+    int priority = 0;

+    for (auto * candidate: obsoleteCandidates) {

+        if (candidate->repo == pool->installed) {

+            obsoletesByPriority(pool, candidate, m, target, obsprovides);

+        }

+        if (name != candidate->name) {

+            name = candidate->name;

+            priority = candidate->repo->priority;

+            obsoletesByPriority(pool, candidate, m, target, obsprovides);

+        } else if (priority == candidate->repo->priority) {

+            obsoletesByPriority(pool, candidate, m, target, obsprovides);

+        }

+    }

+}

+

 void

 Query::Impl::filterProvidesReldep(const Filter & f, Map *m)

 {

@@ -1969,6 +2031,9 @@ Query::Impl::apply()

                     filterObsoletes(f, &m);

                 }

                 break;

+            case HY_PKG_OBSOLETES_BY_PRIORITY:

+                filterObsoletesByPriority(f, &m);

+                break;

             case HY_PKG_PROVIDES:

                 assert(f.getMatchType() == _HY_RELDEP);

                 filterProvidesReldep(f, &m);

diff --git a/python/hawkey/hawkeymodule.cpp b/python/hawkey/hawkeymodule.cpp

index 4351e96e1..82d05e2cb 100644

--- a/python/hawkey/hawkeymodule.cpp

+++ b/python/hawkey/hawkeymodule.cpp

@@ -270,6 +270,7 @@ PYCOMP_MOD_INIT(_hawkey)

     PyModule_AddIntConstant(m, "PKG_NEVRA", HY_PKG_NEVRA);

     PyModule_AddIntConstant(m, "PKG_NEVRA_STRICT", HY_PKG_NEVRA_STRICT);

     PyModule_AddIntConstant(m, "PKG_OBSOLETES", HY_PKG_OBSOLETES);

+    PyModule_AddIntConstant(m, "PKG_OBSOLETES_BY_PRIORITY", HY_PKG_OBSOLETES_BY_PRIORITY);

     PyModule_AddIntConstant(m, "PKG_PROVIDES", HY_PKG_PROVIDES);

     PyModule_AddIntConstant(m, "PKG_RECOMMENDS", HY_PKG_RECOMMENDS);

     PyModule_AddIntConstant(m, "PKG_RELEASE", HY_PKG_RELEASE);

diff --git a/python/hawkey/query-py.cpp b/python/hawkey/query-py.cpp

index 286e306d3..9178a6d0c 100644

--- a/python/hawkey/query-py.cpp

+++ b/python/hawkey/query-py.cpp

@@ -78,6 +78,7 @@ static const int keyname_int_matches[] = {

     HY_PKG_NEVRA,

     HY_PKG_NEVRA_STRICT,

     HY_PKG_OBSOLETES,

+    HY_PKG_OBSOLETES_BY_PRIORITY,

     HY_PKG_PROVIDES,

     HY_PKG_RECOMMENDS,

     HY_PKG_RELEASE,

@@ -118,6 +119,7 @@ static const char * const keyname_char_matches[] = {

     "nevra",

     "nevra_strict",

     "obsoletes",

+    "obsoletes_by_priority",

     "provides",

     "recommends",

     "release",

@@ -342,7 +344,8 @@ filter_add(HyQuery query, key_t keyname, int cmp_type, PyObject *match)

     // match is a sequence now:

     switch (keyname) {

     case HY_PKG:

-    case HY_PKG_OBSOLETES: {

+    case HY_PKG_OBSOLETES:

+    case HY_PKG_OBSOLETES_BY_PRIORITY: {

         // It could be a sequence of packages or reldep/strings. Lets try packages first.

         auto pset = pyseq_to_packageset(match, query->getSack());

         if (!pset) {