}
}
+/* check if multiversion solvable s2 has an obsoletes for installed solvable s */
+static int
+is_multiversion_obsoleteed(Pool *pool, Solvable *s, Solvable *s2)
+{
+ Id *wp, obs, *obsp;
+
+ if (pool->obsoleteusescolors && !pool_colormatch(pool, s, s2))
+ return 0;
+ obsp = s2->repo->idarraydata + s2->obsoletes;
+ if (!pool->obsoleteusesprovides)
+ {
+ while ((obs = *obsp++) != 0)
+ if (pool_match_nevr(pool, s, obs))
+ return 1;
+ }
+ else
+ {
+ while ((obs = *obsp++) != 0)
+ for (wp = pool_whatprovides_ptr(pool, obs); *wp; wp++)
+ if (pool->solvables + *wp == s)
+ return 1;
+ }
+ return 0;
+}
+
/*-------------------------------------------------------------------
*
* add rule for update
if (MAPTST(&solv->multiversion, qs.elements[i]))
{
Solvable *ps = pool->solvables + qs.elements[i];
- /* if keepexplicitobsoletes is set and the name is different,
- * we assume that there is an obsoletes. XXX: not 100% correct */
- if (solv->keepexplicitobsoletes && ps->name != s->name)
+ /* check if there is an explicit obsoletes */
+ if (solv->keepexplicitobsoletes && ps->obsoletes && is_multiversion_obsoleteed(pool, s, ps))
{
qs.elements[j++] = qs.elements[i];
continue;
if (pool->solvables[p].repo == installed)
return;
if (solv->multiversion.size && MAPTST(&solv->multiversion, p) && !solv->keepexplicitobsoletes)
- return;
+ return; /* will not obsolete anything, so just return */
}
omap.size = 0;
qstart = q->count;
#endif
}
return;
+
+ case SOLVER_LOCK:
+ if (!installed)
+ break;
+ qstart = q->count;
+ if (select == SOLVER_SOLVABLE_ALL || (select == SOLVER_SOLVABLE_REPO && what == installed->repoid))
+ {
+ FOR_REPO_SOLVABLES(installed, p, s)
+ {
+ for (i = qstart; i < q->count; i += 2)
+ if (q->elements[i] == DISABLE_DUP && q->elements[i + 1] == pool->solvables[p].name)
+ break;
+ if (i == q->count)
+ queue_push2(q, DISABLE_DUP, pool->solvables[p].name);
+ }
+ }
+ FOR_JOB_SELECT(p, pp, select, what)
+ {
+ if (pool->solvables[p].repo != installed)
+ continue;
+ for (i = qstart; i < q->count; i += 2)
+ if (q->elements[i] == DISABLE_DUP && q->elements[i + 1] == pool->solvables[p].name)
+ break;
+ if (i == q->count)
+ queue_push2(q, DISABLE_DUP, pool->solvables[p].name);
+ }
+ break;
+
default:
return;
}
queue_truncate(q, j);
}
+static void
+prune_best_update(Solver *solv, Id p, Queue *q)
+{
+ if (solv->update_targets && solv->update_targets->elements[p - solv->installed->start])
+ prune_to_update_targets(solv, solv->update_targets->elements + solv->update_targets->elements[p - solv->installed->start], q);
+ if (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))
+ prune_to_dup_packages(solv, p, q);
+ /* select best packages, just look at prio and version */
+ policy_filter_unwanted(solv, q, POLICY_MODE_RECOMMEND);
+}
+
void
-solver_addbestrules(Solver *solv, int havebestinstalljobs)
+solver_addbestrules(Solver *solv, int havebestinstalljobs, int haslockjob)
{
Pool *pool = solv->pool;
Id p;
Rule *r;
Queue infoq;
int i, oldcnt;
+ Map *lockedmap = 0;
solv->bestrules = solv->nrules;
queue_init(&q);
queue_init(&q2);
queue_init(&infoq);
+ if (haslockjob)
+ {
+ int i;
+ lockedmap = solv_calloc(1, sizeof(Map));
+ map_init(lockedmap, pool->nsolvables);
+ for (i = 0, r = solv->rules + solv->jobrules; i < solv->ruletojob.count; i++, r++)
+ {
+ if (r->w2 || (solv->job.elements[solv->ruletojob.elements[i]] & SOLVER_JOBMASK) != SOLVER_LOCK)
+ continue;
+ p = r->p > 0 ? r->p : -r->p;
+ MAPSET(lockedmap, p);
+ }
+ }
if (havebestinstalljobs)
{
for (i = 0; i < solv->job.count; i += 2)
Id how = solv->job.elements[i];
if ((how & (SOLVER_JOBMASK | SOLVER_FORCEBEST)) == (SOLVER_INSTALL | SOLVER_FORCEBEST))
{
- int j;
+ int j, k;
Id p2, pp2;
for (j = 0; j < solv->ruletojob.count; j++)
{
policy_filter_unwanted(solv, &q, POLICY_MODE_RECOMMEND);
if (q.count == oldcnt)
continue; /* nothing filtered */
+ if (lockedmap)
+ {
+ FOR_RULELITERALS(p2, pp2, r)
+ {
+ if (p2 <= 0)
+ continue;
+ if (installed && pool->solvables[p2].repo == installed)
+ {
+ if (MAPTST(lockedmap, p2))
+ queue_pushunique(&q, p2); /* we always want that package */
+ }
+ else if (MAPTST(lockedmap, p2))
+ continue;
+ queue_push(&q2, p2);
+ }
+ policy_filter_unwanted(solv, &q2, POLICY_MODE_RECOMMEND);
+ for (k = 0; k < q2.count; k++)
+ queue_pushunique(&q, q2.elements[k]);
+ }
if (q2.count)
queue_insertn(&q, 0, q2.count, q2.elements);
p2 = queue_shift(&q);
if (p2 > 0)
queue_push(&q, p2);
}
- if (solv->update_targets && solv->update_targets->elements[p - installed->start])
- prune_to_update_targets(solv, solv->update_targets->elements + solv->update_targets->elements[p - installed->start], &q);
- if (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))
- prune_to_dup_packages(solv, p, &q);
- /* select best packages, just look at prio and version */
- policy_filter_unwanted(solv, &q, POLICY_MODE_RECOMMEND);
+ if (lockedmap)
+ {
+ queue_empty(&q2);
+ queue_insertn(&q2, 0, q.count, q.elements);
+ }
+ prune_best_update(solv, p, &q);
if (!q.count)
continue; /* orphaned */
+ if (lockedmap)
+ {
+ int j;
+ /* always ok to keep installed locked packages */
+ if (MAPTST(lockedmap, p))
+ queue_pushunique(&q2, p);
+ for (j = 0; j < q2.count; j++)
+ {
+ Id p2 = q2.elements[j];
+ if (pool->solvables[p2].repo == installed && MAPTST(lockedmap, p2))
+ queue_pushunique(&q, p2);
+ }
+ /* filter out locked packages */
+ for (i = j = 0; j < q2.count; j++)
+ {
+ Id p2 = q2.elements[j];
+ if (pool->solvables[p2].repo == installed || !MAPTST(lockedmap, p2))
+ q2.elements[i++] = p2;
+ }
+ queue_truncate(&q2, i);
+ prune_best_update(solv, p, &q2);
+ for (j = 0; j < q2.count; j++)
+ queue_pushunique(&q, q2.elements[j]);
+ }
if (solv->bestobeypolicy)
{
/* also filter the best of the feature rule packages and add them */
FOR_RULELITERALS(p2, pp2, r)
if (p2 > 0)
queue_push(&q2, p2);
- if (solv->update_targets && solv->update_targets->elements[p - installed->start])
- prune_to_update_targets(solv, solv->update_targets->elements + solv->update_targets->elements[p - installed->start], &q2);
- if (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))
- prune_to_dup_packages(solv, p, &q2);
- policy_filter_unwanted(solv, &q2, POLICY_MODE_RECOMMEND);
+ prune_best_update(solv, p, &q2);
for (j = 0; j < q2.count; j++)
queue_pushunique(&q, q2.elements[j]);
+ if (lockedmap)
+ {
+ queue_empty(&q2);
+ FOR_RULELITERALS(p2, pp2, r)
+ if (p2 > 0)
+ if (pool->solvables[p2].repo == installed || !MAPTST(lockedmap, p2))
+ queue_push(&q2, p2);
+ prune_best_update(solv, p, &q2);
+ for (j = 0; j < q2.count; j++)
+ queue_pushunique(&q, q2.elements[j]);
+ }
}
}
if (solv->allowuninstall || solv->allowuninstall_all || (solv->allowuninstallmap.size && MAPTST(&solv->allowuninstallmap, p - installed->start)))
queue_free(&q);
queue_free(&q2);
queue_free(&infoq);
+ if (lockedmap)
+ {
+ map_free(lockedmap);
+ solv_free(lockedmap);
+ }
}