#include "pool.h"
#include "util.h"
#include "evr.h"
+#include "policy.h"
#include "solverdebug.h"
/**********************************************************************************/
solver_disableproblem(solv, solv->problems.elements[i]);
}
+#ifdef SUSE
+static inline int
+suse_isptf(Pool *pool, Solvable *s)
+{
+ if (!strncmp("ptf-", pool_id2str(pool, s->name), 4))
+ return 1;
+ return 0;
+}
+#endif
+
/*-------------------------------------------------------------------
* try to fix a problem by auto-uninstalling packages
*/
Id p = solv->installed->start + (v - solv->updaterules);
if (m && !MAPTST(m, v - solv->updaterules))
continue;
+#ifdef SUSE
+ if (suse_isptf(pool, pool->solvables + p))
+ continue; /* do not autouninstall ptf packages */
+#endif
if (pool->considered && !MAPTST(pool->considered, p))
continue; /* do not uninstalled disabled packages */
if (solv->bestrules_info && solv->bestrules_end > solv->bestrules)
}
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);
+ }
}
/*
return solv->solutions.elements[solidx + 2 * solv->solutions.elements[solidx] + 3];
}
+/* currently just SOLVER_CLEANDEPS */
Id
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
return element + 1;
}
+static inline void
+queue_push3(Queue *q, Id id1, Id id2, Id id3)
+{
+ queue_push(q, id1);
+ queue_push2(q, id2, id3);
+}
+
+static void
+add_expanded_replace(Solver *solv, Id p, Id rp, Queue *q)
+{
+ int illegal = policy_is_illegal(solv, solv->pool->solvables + p, solv->pool->solvables + rp, 0);
+ if ((illegal & POLICY_ILLEGAL_DOWNGRADE) != 0)
+ queue_push3(q, SOLVER_SOLUTION_REPLACE_DOWNGRADE, p, rp);
+ if ((illegal & POLICY_ILLEGAL_ARCHCHANGE) != 0)
+ queue_push3(q, SOLVER_SOLUTION_REPLACE_ARCHCHANGE, p, rp);
+ if ((illegal & POLICY_ILLEGAL_VENDORCHANGE) != 0)
+ queue_push3(q, SOLVER_SOLUTION_REPLACE_VENDORCHANGE, p, rp);
+ if ((illegal & POLICY_ILLEGAL_NAMECHANGE) != 0)
+ queue_push3(q, SOLVER_SOLUTION_REPLACE_NAMECHANGE, p, rp);
+ if (!illegal || (illegal & ~(POLICY_ILLEGAL_DOWNGRADE | POLICY_ILLEGAL_ARCHCHANGE | POLICY_ILLEGAL_VENDORCHANGE | POLICY_ILLEGAL_NAMECHANGE)))
+ queue_push3(q, SOLVER_SOLUTION_REPLACE, p, rp);
+}
+
+/* solutionelements are (type, p, rp) triplets */
+void
+solver_all_solutionelements(Solver *solv, Id problem, Id solution, int expandreplaces, Queue *q)
+{
+ int i, cnt;
+ Id solidx = solv->problems.elements[problem * 2 - 1];
+ solidx = solv->solutions.elements[solidx + solution];
+ queue_empty(q);
+ if (!solidx)
+ return;
+ cnt = solv->solutions.elements[solidx++];
+ for (i = 0; i < cnt; i++)
+ {
+ Id p = solv->solutions.elements[solidx++];
+ Id rp = solv->solutions.elements[solidx++];
+ if (p > 0)
+ {
+ if (rp && expandreplaces)
+ add_expanded_replace(solv, p, rp, q);
+ else
+ queue_push3(q, rp ? SOLVER_SOLUTION_REPLACE : SOLVER_SOLUTION_ERASE, p, rp);
+ }
+ else
+ queue_push3(q, p, rp, 0);
+ }
+}
+
void
solver_take_solutionelement(Solver *solv, Id p, Id rp, Id extrajobflags, Queue *job)
{
job->elements[rp] = 0;
return;
}
+ if (p == SOLVER_SOLUTION_ERASE)
+ {
+ p = rp;
+ rp = 0;
+ }
if (rp <= 0 && p <= 0)
return; /* just in case */
if (rp > 0)
*/
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 */
/* 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);
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;
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);
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 */
}
*jobrp = ljobr;
if (!*sysrp && lsysr)
*sysrp = lsysr;
+ if (!*blkrp && lblkr)
+ *blkrp = lblkr;
+ if (!*scprp && lscpr)
+ *scprp = lscpr;
}
/*
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 */
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)
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";
}
}
const char *
-solver_solutionelement2str(Solver *solv, Id p, Id rp)
+solver_solutionelementtype2str(Solver *solv, int type, Id p, Id rp)
{
Pool *pool = solv->pool;
- if (p == SOLVER_SOLUTION_JOB || p == SOLVER_SOLUTION_POOLJOB)
- {
- Id how, what;
- if (p == SOLVER_SOLUTION_JOB)
- rp += solv->pooljobcnt;
- how = solv->job.elements[rp - 1];
- what = solv->job.elements[rp];
- return pool_tmpjoin(pool, "do not ask to ", pool_job2str(pool, how, what, 0), 0);
- }
- else if (p == SOLVER_SOLUTION_INFARCH)
+ Solvable *s;
+ const char *str;
+
+ switch (type)
{
- Solvable *s = pool->solvables + rp;
+ case SOLVER_SOLUTION_JOB:
+ case SOLVER_SOLUTION_POOLJOB:
+ if (type == SOLVER_SOLUTION_JOB)
+ p += solv->pooljobcnt;
+ return pool_tmpjoin(pool, "do not ask to ", pool_job2str(pool, solv->job.elements[p - 1], solv->job.elements[p], 0), 0);
+ case SOLVER_SOLUTION_INFARCH:
+ s = pool->solvables + p;
if (solv->installed && s->repo == solv->installed)
return pool_tmpjoin(pool, "keep ", pool_solvable2str(pool, s), " despite the inferior architecture");
else
return pool_tmpjoin(pool, "install ", pool_solvable2str(pool, s), " despite the inferior architecture");
- }
- else if (p == SOLVER_SOLUTION_DISTUPGRADE)
- {
- Solvable *s = pool->solvables + rp;
+ case SOLVER_SOLUTION_DISTUPGRADE:
+ s = pool->solvables + p;
if (solv->installed && s->repo == solv->installed)
return pool_tmpjoin(pool, "keep obsolete ", pool_solvable2str(pool, s), 0);
else
return pool_tmpjoin(pool, "install ", pool_solvable2str(pool, s), " from excluded repository");
- }
- else if (p == SOLVER_SOLUTION_BEST)
- {
- Solvable *s = pool->solvables + rp;
+ case SOLVER_SOLUTION_BEST:
+ s = pool->solvables + p;
if (solv->installed && s->repo == solv->installed)
return pool_tmpjoin(pool, "keep old ", pool_solvable2str(pool, s), 0);
else
return pool_tmpjoin(pool, "install ", pool_solvable2str(pool, s), " despite the old version");
+ case SOLVER_SOLUTION_BLACK:
+ return pool_tmpjoin(pool, "install ", pool_solvid2str(pool, p), 0);
+ case SOLVER_SOLUTION_STRICTREPOPRIORITY:
+ return pool_tmpjoin(pool, "install ", pool_solvid2str(pool, p), " despite the repo priority");
+
+ /* replace types: p -> rp */
+ case SOLVER_SOLUTION_ERASE:
+ return pool_tmpjoin(pool, "allow deinstallation of ", pool_solvid2str(pool, p), 0);
+ case SOLVER_SOLUTION_REPLACE:
+ str = pool_tmpjoin(pool, "allow replacement of ", pool_solvid2str(pool, p), 0);
+ return pool_tmpappend(pool, str, " with ", pool_solvid2str(pool, rp));
+ case SOLVER_SOLUTION_REPLACE_DOWNGRADE:
+ return pool_tmpjoin(pool, "allow ", policy_illegal2str(solv, POLICY_ILLEGAL_DOWNGRADE, pool->solvables + p, pool->solvables + rp), 0);
+ case SOLVER_SOLUTION_REPLACE_ARCHCHANGE:
+ return pool_tmpjoin(pool, "allow ", policy_illegal2str(solv, POLICY_ILLEGAL_ARCHCHANGE, pool->solvables + p, pool->solvables + rp), 0);
+ case SOLVER_SOLUTION_REPLACE_VENDORCHANGE:
+ return pool_tmpjoin(pool, "allow ", policy_illegal2str(solv, POLICY_ILLEGAL_VENDORCHANGE, pool->solvables + p, pool->solvables + rp), 0);
+ case SOLVER_SOLUTION_REPLACE_NAMECHANGE:
+ return pool_tmpjoin(pool, "allow ", policy_illegal2str(solv, POLICY_ILLEGAL_NAMECHANGE, pool->solvables + p, pool->solvables + rp), 0);
+ default:
+ break;
}
- else if (p > 0 && rp == 0)
- return pool_tmpjoin(pool, "allow deinstallation of ", pool_solvid2str(pool, p), 0);
- else if (p > 0 && rp > 0)
- {
- const char *sp = pool_solvid2str(pool, p);
- const char *srp = pool_solvid2str(pool, rp);
- const char *str = pool_tmpjoin(pool, "allow replacement of ", sp, 0);
- return pool_tmpappend(pool, str, " with ", srp);
- }
- else
- return "bad solution element";
+ return "bad solution element";
}
+const char *
+solver_solutionelement2str(Solver *solv, Id p, Id rp)
+{
+ if (p > 0)
+ return solver_solutionelementtype2str(solv, rp ? SOLVER_SOLUTION_REPLACE : SOLVER_SOLUTION_ERASE, p, rp);
+ return solver_solutionelementtype2str(solv, p, rp, 0);
+}
projects / platform / upstream / libsolv.git / blobdiff