- support SOLVER_SOLVABLE_ALL for dup/update/verify

diff --git a/src/problems.c b/src/problems.c
index 70ffde497ef3bfacbfcdc8661d2c87b1e8ba2e20..6dcca8a3bb84ec006f8bf426a34f0b388ca84e2f 100644 (file)
--- a/src/problems.c
+++ b/src/problems.c
@@ -437,7 +437,7 @@ convertsolution(Solver *solv, Id why, Queue *solutionq)
       rr = solv->rules + solv->featurerules + (why - solv->updaterules);
       if (!rr->p)
        rr = solv->rules + why;
-      if (solv->distupgrade && solv->rules[why].p != p && solv->decisionmap[p] > 0)
+      if (solv->dupmap_all && solv->rules[why].p != p && solv->decisionmap[p] > 0)
        {
          /* distupgrade case, allow to keep old package */
          queue_push(solutionq, SOLVER_SOLUTION_DISTUPGRADE);

diff --git a/src/rules.c b/src/rules.c
index 7e17af41caf014cc1370e1ab3730395798d3180c..ca5f758fe1f4a529e442c20960ac90c862ab23e6 100644 (file)
--- a/src/rules.c
+++ b/src/rules.c
@@ -500,9 +500,9 @@ solver_addrpmrulesforsolvable(Solver *solv, Solvable *s, Map *m)
 
       dontfix = 0;
       if (installed                    /* Installed system available */
-         && !solv->fixsystem           /* NOT repair errors in rpm dependency graph */
          && s->repo == installed       /* solvable is installed */
-         && (!solv->fixmap.size || !MAPTST(&solv->fixmap, n - installed->start)))
+         && !solv->fixmap_all          /* NOT repair errors in rpm dependency graph */
+         && !(solv->fixmap.size && MAPTST(&solv->fixmap, n - installed->start)))
         {
          dontfix = 1;                  /* dont care about broken rpm deps */
         }
@@ -926,11 +926,11 @@ solver_addupdaterule(Solver *solv, Solvable *s, int allow_all)
   queue_init_buffer(&qs, qsbuf, sizeof(qsbuf)/sizeof(*qsbuf));
   p = s - pool->solvables;
   /* find update candidates for 's' */
-  if (solv->distupgrade)
+  if (solv->dupmap_all)
     p = finddistupgradepackages(solv, s, &qs, allow_all);
   else
     policy_findupdatepackages(solv, s, &qs, allow_all);
-  if (!allow_all && !solv->distupgrade && solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))
+  if (!allow_all && !solv->dupmap_all && solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))
     addduppackages(solv, s, &qs);
 
   if (!allow_all && qs.count && solv->noobsoletes.size)
@@ -952,13 +952,14 @@ solver_addupdaterule(Solver *solv, Solvable *s, int allow_all)
        }
       if (j < qs.count)
        {
-         if (d && solv->updatesystem && solv->installed && s->repo == solv->installed)
+         if (d && solv->installed && s->repo == solv->installed &&
+              (solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, s - pool->solvables - solv->installed->start))))
            {
              if (!solv->multiversionupdaters)
                solv->multiversionupdaters = sat_calloc(solv->installed->end - solv->installed->start, sizeof(Id));
              solv->multiversionupdaters[s - pool->solvables - solv->installed->start] = d;
            }
-         if (j == 0 && p == -SYSTEMSOLVABLE && solv->distupgrade)
+         if (j == 0 && p == -SYSTEMSOLVABLE && solv->dupmap_all)
            {
              queue_push(&solv->orphaned, s - pool->solvables); /* treat as orphaned */
              j = qs.count;
@@ -1064,7 +1065,7 @@ solver_addinfarchrules(Solver *solv, Map *addedmap)
          a = (a <= pool->lastarch) ? pool->id2arch[a] : 0;
          if (a != 1 && pool->installed && ps->repo == pool->installed)
            {
-             if (!solv->distupgrade)
+             if (!solv->dupmap_all && !(solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
                queue_pushunique(&allowedarchs, ps->arch);      /* also ok to keep this architecture */
              continue;         /* ignore installed solvables when calculating the best arch */
            }
@@ -1375,7 +1376,7 @@ jobtodisablelist(Solver *solv, Id how, Id what, Queue *q)
       if (solv->noobsoletes.size && MAPTST(&solv->noobsoletes, what))
        {
          /* XXX: remove if we always do distupgrade with DUP rules */
-         if (solv->distupgrade && s->repo == installed)
+         if (solv->dupmap_all && s->repo == installed)
            queue_push2(q, DISABLE_UPDATE, what);
          return;
        }

diff --git a/src/solver.c b/src/solver.c
index d6c6938855f2613c40c5f31c505fd4cbea79aaff..fc058f0a8c02ab7ffb63a6f662285d7a84a974b0 100644 (file)
--- a/src/solver.c
+++ b/src/solver.c
@@ -1412,14 +1412,21 @@ solver_run_sat(Solver *solv, int disablerules, int doweak)
              if (l || !dq.count)
                continue;
              /* prune to installed if not updating */
-             if (!solv->updatesystem && solv->installed && dq.count > 1)
+             if (dq.count > 1 && solv->installed && !solv->updatemap_all)
                {
                  int j, k;
                  for (j = k = 0; j < dq.count; j++)
                    {
                      Solvable *s = pool->solvables + dq.elements[j];
                      if (s->repo == solv->installed)
-                       dq.elements[k++] = dq.elements[j];
+                       {
+                         dq.elements[k++] = dq.elements[j];
+                         if (solv->updatemap.size && MAPTST(&solv->updatemap, dq.elements[j] - solv->installed->start))
+                           {
+                             k = 0;    /* package wants to be updated, do not prune */
+                             break;
+                           }
+                       }
                    }
                  if (k)
                    dq.count = k;
@@ -1485,7 +1492,7 @@ solver_run_sat(Solver *solv, int disablerules, int doweak)
                  /* Actually we currently still need it because of erase jobs */
                  /* if noupdate is set we do not look at update candidates */
                  queue_empty(&dq);
-                 if (!MAPTST(&solv->noupdate, i - installed->start) && (solv->decisionmap[i] < 0 || solv->updatesystem || (solv->updatemap.size && MAPTST(&solv->updatemap, i - installed->start)) || rr->p != i))
+                 if (!MAPTST(&solv->noupdate, i - installed->start) && (solv->decisionmap[i] < 0 || solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, i - installed->start)) || rr->p != i))
                    {
                      if (solv->noobsoletes.size && solv->multiversionupdaters
                             && (d = solv->multiversionupdaters[i - installed->start]) != 0)
@@ -1933,7 +1940,7 @@ solver_run_sat(Solver *solv, int disablerules, int doweak)
            }
        }
 
-     if (solv->distupgrade && solv->installed)
+     if (solv->dupmap_all && solv->installed)
        {
          int installedone = 0;
 
@@ -1945,7 +1952,7 @@ solver_run_sat(Solver *solv, int disablerules, int doweak)
              if (solv->decisionmap[p])
                continue;       /* already decided */
              olevel = level;
-             if (solv->distupgrade_removeunsupported)
+             if (solv->droporphanedmap_all)
                continue;
              if (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, p - solv->installed->start))
                continue;
@@ -2484,6 +2491,12 @@ solver_solve(Solver *solv, Queue *job)
   queue_free(&solv->job);
   queue_init_clone(&solv->job, job);
 
+  /* initialize with legacy values */
+  solv->fixmap_all = solv->fixsystem;
+  solv->updatemap_all = solv->updatesystem;
+  solv->droporphanedmap_all = solv->distupgrade_removeunsupported;
+  solv->dupmap_all = solv->distupgrade;
+
   /*
    * create basic rule set of all involved packages
    * use addedmap bitmap to make sure we don't create rules twice
@@ -2506,7 +2519,7 @@ solver_solve(Solver *solv, Queue *job)
    */
   if (installed)
     {
-      /* check for verify jobs */
+      /* check for update/verify jobs as they need to be known early */
       for (i = 0; i < job->count; i += 2)
        {
          how = job->elements[i];
@@ -2515,6 +2528,8 @@ solver_solve(Solver *solv, Queue *job)
          switch (how & SOLVER_JOBMASK)
            {
            case SOLVER_VERIFY:
+             if (select == SOLVER_SOLVABLE_ALL)
+               solv->fixmap_all = 1;
              FOR_JOB_SELECT(p, pp, select, what)
                {
                  s = pool->solvables + p;
@@ -2525,6 +2540,19 @@ solver_solve(Solver *solv, Queue *job)
                  MAPSET(&solv->fixmap, p - solv->installed->start);
                }
              break;
+           case SOLVER_UPDATE:
+             if (select == SOLVER_SOLVABLE_ALL)
+               solv->updatemap_all = 1;
+             FOR_JOB_SELECT(p, pp, select, what)
+               {
+                 s = pool->solvables + p;
+                 if (!solv->installed || s->repo != solv->installed)
+                   continue;
+                 if (!solv->updatemap.size)
+                   map_grow(&solv->updatemap, solv->installed->end - solv->installed->start);
+                 MAPSET(&solv->updatemap, p - solv->installed->start);
+               }
+             break;
            default:
              break;
            }
@@ -2565,7 +2593,9 @@ solver_solve(Solver *solv, Queue *job)
            }
          break;
        case SOLVER_DISTUPGRADE:
-         if (!solv->distupgrade)
+         if (select == SOLVER_SOLVABLE_ALL)
+           solv->dupmap_all = 1;
+         if (!solv->dupmap_all)
            hasdupjob = 1;
          break;
        default:
@@ -2680,7 +2710,7 @@ solver_solve(Solver *solv, Queue *job)
            queue_push(&solv->orphaned, i);
           if (!r->p)
            {
-             assert(solv->distupgrade && !sr->p);
+             assert(solv->dupmap_all && !sr->p);
              continue;
            }
          if (!solver_samerule(solv, r, sr))
@@ -2785,15 +2815,6 @@ solver_solve(Solver *solv, Queue *job)
 
        case SOLVER_UPDATE:
          POOL_DEBUG(SAT_DEBUG_JOB, "job: %supdate %s\n", weak ? "weak " : "", solver_select2str(solv, select, what));
-         FOR_JOB_SELECT(p, pp, select, what)
-           {
-             s = pool->solvables + p;
-             if (!solv->installed || s->repo != solv->installed)
-               continue;
-             if (!solv->updatemap.size)
-               map_grow(&solv->updatemap, solv->installed->end - solv->installed->start);
-             MAPSET(&solv->updatemap, p - solv->installed->start);
-           }
          break;
        case SOLVER_VERIFY:
          POOL_DEBUG(SAT_DEBUG_JOB, "job: %sverify %s\n", weak ? "weak " : "", solver_select2str(solv, select, what));
@@ -2821,6 +2842,8 @@ solver_solve(Solver *solv, Queue *job)
          break;
        case SOLVER_DROP_ORPHANED:
          POOL_DEBUG(SAT_DEBUG_JOB, "job: drop orphaned %s\n", solver_select2str(solv, select, what));
+         if (select == SOLVER_SOLVABLE_ALL)
+           solv->droporphanedmap_all = 1;
          FOR_JOB_SELECT(p, pp, select, what)
            {
              s = pool->solvables + p;

diff --git a/src/solver.h b/src/solver.h
index 7e2d4d4ee01c21f234744267b28cd98ee08482d4..c4de09ba048f3b61fce49a149b96c68e3e051c5b 100644 (file)
--- a/src/solver.h
+++ b/src/solver.h
@@ -82,11 +82,13 @@ typedef struct _Solver {
 
   Map noupdate;                                /* don't try to update these
                                            installed solvables */
-  Map noobsoletes;                     /* ignore obsoletes for these
-                                          (multiinstall) */
+  Map noobsoletes;                     /* ignore obsoletes for these (multiinstall) */
 
-  Map updatemap;                       /* bring those installed packages to the newest version */
-  Map fixmap;                          /* fix those packages */
+  Map updatemap;                       /* bring these installed packages to the newest version */
+  int updatemap_all;                   /* bring all packages to the newest version */
+
+  Map fixmap;                          /* fix these packages */
+  int fixmap_all;                      /* fix all packages */
 
   Queue weakruleq;                     /* index into 'rules' for weak ones */
   Map weakrulemap;                     /* map rule# to '1' for weak rules, 1..learntrules */
@@ -202,10 +204,14 @@ typedef struct _Solver {
   Queue covenantq;                      /* Covenants honored by this solver (generic locks) */
 
   
-  Map dupmap;                          /* packages from dup repos */
+  Map dupmap;                          /* dup these packages*/
+  int dupmap_all;                      /* dup all packages */
   Map dupinvolvedmap;                  /* packages involved in dup process */
+
   Map droporphanedmap;                 /* packages to drop in dup mode */
-  Map cleandepsmap;                    /* try to drop those packages as of cleandeps erases */
+  int droporphanedmap_all;
+
+  Map cleandepsmap;                    /* try to drop these packages as of cleandeps erases */
 
   Queue *ruleinfoq;                    /* tmp space for solver_ruleinfo() */
 } Solver;
@@ -219,6 +225,7 @@ typedef struct _Solver {
 #define SOLVER_SOLVABLE_PROVIDES       0x03
 #define SOLVER_SOLVABLE_ONE_OF         0x04
 #define SOLVER_SOLVABLE_REPO           0x05
+#define SOLVER_SOLVABLE_ALL            0x06
 
 #define SOLVER_SELECTMASK              0xff
 
@@ -365,12 +372,12 @@ solver_create_state_maps(Solver *solv, Map *installedmap, Map *conflictsmap)
          l = r->p; l; l = (dp != &r->w2 + 1 ? *dp++ : 0))
 
 /* iterate over all packages selected by a job */
-#define FOR_JOB_SELECT(p, pp, select, what)                    \
-    if (select == SOLVER_SOLVABLE_REPO)                                \
-       p = pp = 0;                                             \
-    else for (pp = (select == SOLVER_SOLVABLE ? 0 :            \
-               select == SOLVER_SOLVABLE_ONE_OF ? what :       \
-               pool_whatprovides(pool, what)),                         \
+#define FOR_JOB_SELECT(p, pp, select, what)                                    \
+    if (select == SOLVER_SOLVABLE_REPO || select == SOLVER_SOLVABLE_ALL)       \
+       p = pp = 0;                                                             \
+    else for (pp = (select == SOLVER_SOLVABLE ? 0 :                            \
+               select == SOLVER_SOLVABLE_ONE_OF ? what :                       \
+               pool_whatprovides(pool, what)),                                 \
          p = (select == SOLVER_SOLVABLE ? what : pool->whatprovidesdata[pp++]) ; p ; p = pool->whatprovidesdata[pp++]) \
       if (select != SOLVER_SOLVABLE_NAME || pool_match_nevr(pool, pool->solvables + p, what))
 

diff --git a/src/solverdebug.c b/src/solverdebug.c
index dec87d636ce7cd9f449efc040e4bdcacf2c835f6..6884111851da9e638b089b899c4c25680a6aca52 100644 (file)
--- a/src/solverdebug.c
+++ b/src/solverdebug.c
@@ -705,7 +705,7 @@ solver_printsolution(Solver *solv, Id problem, Id solution)
          /* policy, replace p with rp */
          s = pool->solvables + p;
          sd = rp ? pool->solvables + rp : 0;
-         if (s == sd && solv->distupgrade)
+         if (s == sd && solv->dupmap_all)
            {
              POOL_DEBUG(SAT_DEBUG_RESULT, "  - keep obsolete %s\n", solvable2str(pool, s));
            }
@@ -842,5 +842,7 @@ solver_select2str(Solver *solv, Id select, Id what)
       sprintf(b, "repo #%d", what);
       return b;
     }
+  if (select == SOLVER_SOLVABLE_ALL)
+    return "all packages";
   return "unknown job select";
 }