Imported Upstream version 0.7.21

[platform/upstream/libsolv.git] / src / problems.c

diff --git a/src/problems.c b/src/problems.c
index 5bd2bf5..0bd48d4 100644 (file)
--- a/src/problems.c
+++ b/src/problems.c
@@ -64,12 +64,12 @@ solver_disableproblem(Solver *solv, Id v)
     }
   v = -(v + 1);
   jp = solv->ruletojob.elements;
-  if (solv->bestrules_pkg)
+  if (solv->bestrules_info)
     {
       int ni = solv->bestrules_up - solv->bestrules;
       for (i = 0; i < ni; i++)
        {
-         int j = solv->bestrules_pkg[i];
+         int j = solv->bestrules_info[i];
          if (j < 0 && jp[-j - solv->jobrules] == v)
            solver_disablerule(solv, solv->rules + solv->bestrules + i);
        }
@@ -131,12 +131,12 @@ solver_enableproblem(Solver *solv, Id v)
     }
   v = -(v + 1);
   jp = solv->ruletojob.elements;
-  if (solv->bestrules_pkg)
+  if (solv->bestrules_info)
     {
       int ni = solv->bestrules_up - solv->bestrules;
       for (i = 0; i < ni; i++)
        {
-         int j = solv->bestrules_pkg[i];
+         int j = solv->bestrules_info[i];
          if (j < 0 && jp[-j - solv->jobrules] == v)
            solver_enablerule(solv, solv->rules + solv->bestrules + i);
        }
@@ -155,8 +155,8 @@ solver_ruletoproblem(Solver *solv, Id rid)
 {
   if (rid >= solv->jobrules && rid < solv->jobrules_end)
     rid = -(solv->ruletojob.elements[rid - solv->jobrules] + 1);
-  else if (rid >= solv->bestrules && rid < solv->bestrules_up && solv->bestrules_pkg[rid - solv->bestrules] < 0)
-    rid = -(solv->ruletojob.elements[-solv->bestrules_pkg[rid - solv->bestrules] - solv->jobrules] + 1);
+  else if (rid >= solv->bestrules && rid < solv->bestrules_up && solv->bestrules_info[rid - solv->bestrules] < 0)
+    rid = -(solv->ruletojob.elements[-solv->bestrules_info[rid - solv->bestrules] - solv->jobrules] + 1);
   else if (rid > solv->infarchrules && rid < solv->infarchrules_end)
     {
       Pool *pool = solv->pool;
@@ -247,8 +247,23 @@ solver_autouninstall(Solver *solv, int start)
       if (v >= solv->updaterules && v < solv->updaterules_end)
        {
          Rule *r;
+         Id p = solv->installed->start + (v - solv->updaterules);
          if (m && !MAPTST(m, v - solv->updaterules))
            continue;
+         if (pool->considered && !MAPTST(pool->considered, p))
+           continue;   /* do not uninstalled disabled packages */
+         if (solv->bestrules_info && solv->bestrules_end > solv->bestrules)
+           {
+             int j;
+             for (j = start + 1; j < solv->problems.count - 1; j++)
+               {
+                 Id vv = solv->problems.elements[j];
+                 if (vv >= solv->bestrules && vv < solv->bestrules_end && solv->bestrules_info[vv - solv->bestrules] == p)
+                   break;
+               }
+             if (j < solv->problems.count - 1)
+               continue;       /* best rule involved, do not uninstall */
+           }
          /* check if identical to feature rule, we don't like that (except for orphans) */
          r = solv->rules + solv->featurerules + (v - solv->updaterules);
          if (!r->p)
@@ -260,7 +275,7 @@ solver_autouninstall(Solver *solv, int start)
              if (solv->keep_orphans)
                {
                  r = solv->rules + v;
-                 if (!r->d && !r->w2 && r->p == (solv->installed->start + (v - solv->updaterules)))
+                 if (!r->d && !r->w2 && r->p == p)
                    {
                      lastfeature = v;
                      lastupdate = 0;
@@ -663,7 +678,7 @@ convertsolution(Solver *solv, Id why, Queue *solutionq)
        if (p > 0 && solv->decisionmap[p] > 0)
          return;       /* false alarm */
       /* check update/feature rule */
-      p = solv->bestrules_pkg[why - solv->bestrules];
+      p = solv->bestrules_info[why - solv->bestrules];
       if (p < 0)
        {
          /* install job */
@@ -704,6 +719,18 @@ convertsolution(Solver *solv, Id why, Queue *solutionq)
        }
       return;
     }
+  if (why >= solv->blackrules && why < solv->blackrules_end)
+    {
+      queue_push(solutionq, SOLVER_SOLUTION_BLACK);
+      assert(solv->rules[why].p < 0);
+      queue_push(solutionq, -solv->rules[why].p);
+    }
+  if (why >= solv->strictrepopriorules && why < solv->strictrepopriorules_end)
+    {
+      queue_push(solutionq, SOLVER_SOLUTION_STRICTREPOPRIORITY);
+      assert(solv->rules[why].p < 0);
+      queue_push(solutionq, -solv->rules[why].p);
+    }
 }
 
 /*
@@ -966,6 +993,8 @@ solver_solutionelement_extrajobflags(Solver *solv, Id problem, Id solution)
  *    -> add (SOLVER_INSTALL|SOLVER_SOLVABLE, rp) to the job
  *    SOLVER_SOLUTION_BEST          pkgid
  *    -> add (SOLVER_INSTALL|SOLVER_SOLVABLE, rp) to the job
+ *    SOLVER_SOLUTION_BLACK         pkgid
+ *    -> add (SOLVER_INSTALL|SOLVER_SOLVABLE, rp) to the job
  *    SOLVER_SOLUTION_JOB           jobidx
  *    -> remove job (jobidx - 1, jobidx) from job queue
  *    SOLVER_SOLUTION_POOLJOB       jobidx
@@ -1045,10 +1074,10 @@ solver_take_solution(Solver *solv, Id problem, Id solution, Queue *job)
  */
 
 static void
-findproblemrule_internal(Solver *solv, Id idx, Id *reqrp, Id *conrp, Id *sysrp, Id *jobrp, Map *rseen)
+findproblemrule_internal(Solver *solv, Id idx, Id *reqrp, Id *conrp, Id *sysrp, Id *jobrp, Id *blkrp, Id *scprp, Map *rseen)
 {
   Id rid, d;
-  Id lreqr, lconr, lsysr, ljobr;
+  Id lreqr, lconr, lsysr, ljobr, lblkr, lscpr;
   Rule *r;
   Id jobassert = 0;
   int i, reqset = 0;   /* 0: unset, 1: installed, 2: jobassert, 3: assert */
@@ -1070,7 +1099,7 @@ findproblemrule_internal(Solver *solv, Id idx, Id *reqrp, Id *conrp, Id *sysrp,
 
   /* the problem rules are somewhat ordered from "near to the problem" to
    * "near to the job" */
-  lreqr = lconr = lsysr = ljobr = 0;
+  lreqr = lconr = lsysr = ljobr = lblkr = lscpr = 0;
   while ((rid = solv->learnt_pool.elements[idx++]) != 0)
     {
       assert(rid > 0);
@@ -1079,9 +1108,9 @@ findproblemrule_internal(Solver *solv, Id idx, Id *reqrp, Id *conrp, Id *sysrp,
          if (MAPTST(rseen, rid - solv->learntrules))
            continue;
          MAPSET(rseen, rid - solv->learntrules);
-         findproblemrule_internal(solv, solv->learnt_why.elements[rid - solv->learntrules], &lreqr, &lconr, &lsysr, &ljobr, rseen);
+         findproblemrule_internal(solv, solv->learnt_why.elements[rid - solv->learntrules], &lreqr, &lconr, &lsysr, &ljobr, &lblkr, &lscpr, rseen);
        }
-      else if ((rid >= solv->jobrules && rid < solv->jobrules_end) || (rid >= solv->infarchrules && rid < solv->infarchrules_end) || (rid >= solv->duprules && rid < solv->duprules_end) || (rid >= solv->bestrules && rid < solv->bestrules_end) || (rid >= solv->yumobsrules && rid <= solv->yumobsrules_end))
+      else if ((rid >= solv->jobrules && rid < solv->jobrules_end) || (rid >= solv->infarchrules && rid < solv->infarchrules_end) || (rid >= solv->duprules && rid < solv->duprules_end) || (rid >= solv->bestrules && rid < solv->bestrules_end) || (rid >= solv->yumobsrules && rid < solv->yumobsrules_end))
        {
          if (!*jobrp)
            *jobrp = rid;
@@ -1091,6 +1120,16 @@ findproblemrule_internal(Solver *solv, Id idx, Id *reqrp, Id *conrp, Id *sysrp,
          if (!*sysrp)
            *sysrp = rid;
        }
+      else if (rid >= solv->blackrules && rid < solv->blackrules_end)
+       {
+         if (!*blkrp)
+           *blkrp = rid;
+       }
+      else if (rid >= solv->strictrepopriorules && rid < solv->strictrepopriorules_end)
+       {
+         if (!*scprp)
+           *scprp = rid;
+       }
       else
        {
          assert(rid < solv->pkgrules_end);
@@ -1120,7 +1159,6 @@ findproblemrule_internal(Solver *solv, Id idx, Id *reqrp, Id *conrp, Id *sysrp,
                      Pool *pool = solv->pool;
                      Id op = -solv->rules[*reqrp].p;
                      if (op > 1 && pool->solvables[op].arch != pool->solvables[-r->p].arch &&
-                         pool->solvables[op].arch != pool->noarchid &&
                          pool->solvables[-r->p].arch != pool->noarchid)
                        continue;       /* different arch, skip */
                    }
@@ -1153,6 +1191,10 @@ findproblemrule_internal(Solver *solv, Id idx, Id *reqrp, Id *conrp, Id *sysrp,
     *jobrp = ljobr;
   if (!*sysrp && lsysr)
     *sysrp = lsysr;
+  if (!*blkrp && lblkr)
+    *blkrp = lblkr;
+  if (!*scprp && lscpr)
+    *scprp = lscpr;
 }
 
 /*
@@ -1167,12 +1209,12 @@ findproblemrule_internal(Solver *solv, Id idx, Id *reqrp, Id *conrp, Id *sysrp,
 Id
 solver_findproblemrule(Solver *solv, Id problem)
 {
-  Id reqr, conr, sysr, jobr;
+  Id reqr, conr, sysr, jobr, blkr, srpr;
   Id idx = solv->problems.elements[2 * problem - 2];
   Map rseen;
-  reqr = conr = sysr = jobr = 0;
+  reqr = conr = sysr = jobr = blkr = srpr = 0;
   map_init(&rseen, solv->learntrules ? solv->nrules - solv->learntrules : 0);
-  findproblemrule_internal(solv, idx, &reqr, &conr, &sysr, &jobr, &rseen);
+  findproblemrule_internal(solv, idx, &reqr, &conr, &sysr, &jobr, &blkr, &srpr, &rseen);
   map_free(&rseen);
   /* check if the request is about a not-installed package requiring a installed
    * package conflicting with the non-installed package. In that case return the conflict */
@@ -1200,6 +1242,10 @@ solver_findproblemrule(Solver *solv, Id problem)
     return reqr;       /* some requires */
   if (conr)
     return conr;       /* some conflict */
+  if (blkr)
+    return blkr;       /* a blacklisted package */
+  if (srpr)
+    return srpr;       /* a strict repo priority */
   if (sysr)
     return sysr;       /* an update rule */
   if (jobr)
@@ -1281,7 +1327,7 @@ solver_problemruleinfo2str(Solver *solv, SolverRuleinfo type, Id source, Id targ
       if (pool_disabled_solvable(pool, ss))
         return pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " is disabled");
       if (ss->arch && ss->arch != ARCH_SRC && ss->arch != ARCH_NOSRC &&
-          pool->id2arch && (ss->arch > pool->lastarch || !pool->id2arch[ss->arch]))
+          pool->id2arch && pool_arch2score(pool, ss->arch) == 0)
         return pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " does not have a compatible architecture");
       return pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " is not installable");
     case SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP:
@@ -1316,6 +1362,14 @@ solver_problemruleinfo2str(Solver *solv, SolverRuleinfo type, Id source, Id targ
       s = pool_tmpjoin(pool, "both package ", pool_solvid2str(pool, source), " and ");
       s = pool_tmpjoin(pool, s, pool_solvid2str(pool, target), " obsolete ");
       return pool_tmpappend(pool, s, pool_dep2str(pool, dep), 0);
+    case SOLVER_RULE_BLACK:
+      return pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " can only be installed by a direct request");
+    case SOLVER_RULE_STRICT_REPO_PRIORITY:
+      return pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " is excluded by strict repo priority");
+    case SOLVER_RULE_PKG_CONSTRAINS:
+      s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), 0);
+      s = pool_tmpappend(pool, s, " has constraint ", pool_dep2str(pool, dep));
+      return pool_tmpappend(pool, s, " conflicting with ", pool_solvid2str(pool, target));
     default:
       return "bad problem rule type";
     }
@@ -1370,8 +1424,18 @@ solver_solutionelement2str(Solver *solv, Id p, Id rp)
       else
         return pool_tmpjoin(pool, "install ", pool_solvable2str(pool, s), " despite the old version");
     }
+  else if (p == SOLVER_SOLUTION_BLACK)
+    {
+      Solvable *s = pool->solvables + rp;
+      return pool_tmpjoin(pool, "install ", pool_solvable2str(pool, s), 0);
+    }
   else if (p > 0 && rp == 0)
     return pool_tmpjoin(pool, "allow deinstallation of ", pool_solvid2str(pool, p), 0);
+  else if (p == SOLVER_SOLUTION_STRICTREPOPRIORITY)
+    {
+      Solvable *s = pool->solvables + rp;
+      return pool_tmpjoin(pool, "install ", pool_solvable2str(pool, s), " despite the repo priority");
+    }
   else if (p > 0 && rp > 0)
     {
       const char *sp = pool_solvid2str(pool, p);