X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fproblems.c;h=b46d6249013fe0102b587100dee77161c9df5b4b;hb=f1a786b6fe3fc2d53f03b25e303dc45ed7e22ba6;hp=76d6ca01fe2c4199be96316e13769e0b0fe953e3;hpb=2581c2d378058f1a362b3106dbd567e6d23fa232;p=platform%2Fupstream%2Flibsolv.git diff --git a/src/problems.c b/src/problems.c index 76d6ca0..b46d624 100644 --- a/src/problems.c +++ b/src/problems.c @@ -24,7 +24,6 @@ #include "evr.h" #include "solverdebug.h" - /**********************************************************************************/ /* a problem is an item on the solver's problem list. It can either be >0, in that @@ -32,10 +31,9 @@ * consisting of multiple job rules. */ -void +static void solver_disableproblem(Solver *solv, Id v) { - Rule *r; int i; Id *jp; @@ -62,30 +60,30 @@ solver_disableproblem(Solver *solv, Id v) return; } solver_disablerule(solv, solv->rules + v); -#if 0 - /* XXX: doesn't work */ - if (v >= solv->updaterules && v < solv->updaterules_end) - { - /* enable feature rule if we disabled the update rule */ - r = solv->rules + (v - solv->updaterules + solv->featurerules); - if (r->p) - solver_enablerule(solv, r); - } -#endif return; } v = -(v + 1); jp = solv->ruletojob.elements; - for (i = solv->jobrules, r = solv->rules + i; i < solv->jobrules_end; i++, r++, jp++) + if (solv->bestrules_info) + { + int ni = solv->bestrules_up - solv->bestrules; + for (i = 0; i < ni; i++) + { + int j = solv->bestrules_info[i]; + if (j < 0 && jp[-j - solv->jobrules] == v) + solver_disablerule(solv, solv->rules + solv->bestrules + i); + } + } + for (i = solv->jobrules; i < solv->jobrules_end; i++, jp++) if (*jp == v) - solver_disablerule(solv, r); + solver_disablerule(solv, solv->rules + i); } /*------------------------------------------------------------------- * enableproblem */ -void +static void solver_enableproblem(Solver *solv, Id v) { Rule *r; @@ -133,9 +131,189 @@ solver_enableproblem(Solver *solv, Id v) } v = -(v + 1); jp = solv->ruletojob.elements; - for (i = solv->jobrules, r = solv->rules + i; i < solv->jobrules_end; i++, r++, jp++) + if (solv->bestrules_info) + { + int ni = solv->bestrules_up - solv->bestrules; + for (i = 0; i < ni; i++) + { + int j = solv->bestrules_info[i]; + if (j < 0 && jp[-j - solv->jobrules] == v) + solver_enablerule(solv, solv->rules + solv->bestrules + i); + } + } + for (i = solv->jobrules; i < solv->jobrules_end; i++, jp++) if (*jp == v) - solver_enablerule(solv, r); + solver_enablerule(solv, solv->rules + i); +} + + +/*------------------------------------------------------------------- + * turn a problem rule into a problem id by normalizing it + */ +static Id +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_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; + Id name = pool->solvables[-solv->rules[rid].p].name; + while (rid > solv->infarchrules && pool->solvables[-solv->rules[rid - 1].p].name == name) + rid--; + } + else if (rid > solv->duprules && rid < solv->duprules_end) + { + Pool *pool = solv->pool; + Id name = pool->solvables[-solv->rules[rid].p].name; + while (rid > solv->duprules && pool->solvables[-solv->rules[rid - 1].p].name == name) + rid--; + } + return rid; +} + +/*------------------------------------------------------------------- + * when the solver runs into a problem, it needs to disable all + * involved non-pkg rules and record the rules for solution + * generation. + */ +void +solver_recordproblem(Solver *solv, Id rid) +{ + Id v = solver_ruletoproblem(solv, rid); + /* return if problem already countains our rule */ + if (solv->problems.count) + { + int i; + for (i = solv->problems.count - 1; i >= 0; i--) + if (solv->problems.elements[i] == 0) /* end of last problem reached? */ + break; + else if (solv->problems.elements[i] == v) + return; + } + queue_push(&solv->problems, v); +} + +/*------------------------------------------------------------------- + * this is called when a problem is solved by disabling a rule. + * It calls disableproblem and then re-enables policy rules + */ +void +solver_fixproblem(Solver *solv, Id rid) +{ + Id v = solver_ruletoproblem(solv, rid); + solver_disableproblem(solv, v); + if (v < 0) + solver_reenablepolicyrules(solv, -v); +} + +/*------------------------------------------------------------------- + * disable a set of problems + */ +void +solver_disableproblemset(Solver *solv, int start) +{ + int i; + for (i = start + 1; i < solv->problems.count - 1; i++) + solver_disableproblem(solv, solv->problems.elements[i]); +} + +/*------------------------------------------------------------------- + * try to fix a problem by auto-uninstalling packages + */ +Id +solver_autouninstall(Solver *solv, int start) +{ + Pool *pool = solv->pool; + int i; + int lastfeature = 0, lastupdate = 0; + Id v; + Id extraflags = -1; + Map *m = 0; + + if (!solv->allowuninstall && !solv->allowuninstall_all) + { + if (!solv->allowuninstallmap.size) + return 0; /* why did we get called? */ + m = &solv->allowuninstallmap; + } + for (i = start + 1; i < solv->problems.count - 1; i++) + { + v = solv->problems.elements[i]; + if (v < 0) + extraflags &= solv->job.elements[-v - 1]; + 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) + { + /* update rule == feature rule */ + if (v > lastfeature) + lastfeature = v; + /* prefer orphaned packages in dup mode */ + if (solv->keep_orphans) + { + r = solv->rules + v; + if (!r->d && !r->w2 && r->p == p) + { + lastfeature = v; + lastupdate = 0; + break; + } + } + continue; + } + if (v > lastupdate) + lastupdate = v; + } + } + if (!lastupdate && !lastfeature) + return 0; + v = lastupdate ? lastupdate : lastfeature; + POOL_DEBUG(SOLV_DEBUG_UNSOLVABLE, "allowuninstall disabling "); + solver_printruleclass(solv, SOLV_DEBUG_UNSOLVABLE, solv->rules + v); + /* should really be solver_fixproblem, but we know v is an update/feature rule */ + solver_disableproblem(solv, v); + if (extraflags != -1 && (extraflags & SOLVER_CLEANDEPS) != 0 && solv->cleandepsmap.size) + { + /* add the package to the updatepkgs list, this will automatically turn + * on cleandeps mode */ + Id p = solv->rules[v].p; + if (!solv->cleandeps_updatepkgs) + { + solv->cleandeps_updatepkgs = solv_calloc(1, sizeof(Queue)); + queue_init(solv->cleandeps_updatepkgs); + } + if (p > 0) + { + int oldupdatepkgscnt = solv->cleandeps_updatepkgs->count; + queue_pushunique(solv->cleandeps_updatepkgs, p); + if (solv->cleandeps_updatepkgs->count != oldupdatepkgscnt) + solver_disablepolicyrules(solv); + } + } + return v; } @@ -152,6 +330,8 @@ enableweakrules(Solver *solv) int i; Rule *r; + if (!solv->weakrulemap.size) + return; for (i = 1, r = solv->rules + i; i < solv->learntrules; i++, r++) { if (r->d >= 0) /* already enabled? */ @@ -160,6 +340,10 @@ enableweakrules(Solver *solv) continue; solver_enablerule(solv, r); } + /* make sure broken orphan rules stay disabled */ + if (solv->brokenorphanrules) + for (i = 0; i < solv->brokenorphanrules->count; i++) + solver_disablerule(solv, solv->rules + solv->brokenorphanrules->elements[i]); } @@ -196,7 +380,6 @@ refine_suggestion(Solver *solv, Id *problem, Id sug, Queue *refined, int essenti queue_empty(refined); if (!essentialok && sug < 0 && (solv->job.elements[-sug - 1] & SOLVER_ESSENTIAL) != 0) return; - queue_init(&disabled); queue_push(refined, sug); /* re-enable all problem rules with the exception of "sug"(gestion) */ @@ -205,10 +388,14 @@ refine_suggestion(Solver *solv, Id *problem, Id sug, Queue *refined, int essenti for (i = 0; problem[i]; i++) if (problem[i] != sug) solver_enableproblem(solv, problem[i]); - if (sug < 0) solver_reenablepolicyrules(solv, -sug); - else if (sug >= solv->updaterules && sug < solv->updaterules_end) + + /* here is where the feature rules come into play: if we disabled an + * update rule, we enable the corresponding feature rule if there is + * one. We do this to make the solver downgrade packages instead of + * deinstalling them */ + if (sug >= solv->updaterules && sug < solv->updaterules_end) { /* enable feature rule */ Rule *r = solv->rules + solv->featurerules + (sug - solv->updaterules); @@ -218,14 +405,16 @@ refine_suggestion(Solver *solv, Id *problem, Id sug, Queue *refined, int essenti enableweakrules(solv); + /* disabled contains all of the rules we disabled in the refinement process */ + queue_init(&disabled); for (;;) { - int njob, nfeature, nupdate, pass; + int nother, nfeature, nupdate, pass; queue_empty(&solv->problems); solver_reset(solv); - - if (!solv->problems.count) - solver_run_sat(solv, 0, 0); + /* we set disablerules to zero because we are only interested in + * the first problem and we don't want the solver to disable the problems */ + solver_run_sat(solv, 0, 0); if (!solv->problems.count) { @@ -233,16 +422,18 @@ refine_suggestion(Solver *solv, Id *problem, Id sug, Queue *refined, int essenti break; /* great, no more problems */ } disabledcnt = disabled.count; - /* start with 1 to skip over proof index */ - njob = nfeature = nupdate = 0; + nother = nfeature = nupdate = 0; for (pass = 0; pass < 2; pass++) { + /* start with 1 to skip over proof index */ for (i = 1; i < solv->problems.count - 1; i++) { /* ignore solutions in refined */ v = solv->problems.elements[i]; if (v == 0) break; /* end of problem reached */ + if (!essentialok && v < 0 && (solv->job.elements[-v - 1] & SOLVER_ESSENTIAL) != 0) + continue; /* not that one! */ if (sug != v) { /* check if v is in the given problems list @@ -256,14 +447,10 @@ refine_suggestion(Solver *solv, Id *problem, Id sug, Queue *refined, int essenti } if (v >= solv->featurerules && v < solv->featurerules_end) nfeature++; - else if (v > 0) + else if (v > solv->updaterules && v < solv->updaterules_end) nupdate++; else - { - if (!essentialok && (solv->job.elements[-v - 1] & SOLVER_ESSENTIAL) != 0) - continue; /* not that one! */ - njob++; - } + nother++; queue_push(&disabled, v); } if (disabled.count != disabledcnt) @@ -276,7 +463,7 @@ refine_suggestion(Solver *solv, Id *problem, Id sug, Queue *refined, int essenti refined->count = 0; break; } - if (!njob && nupdate && nfeature) + if (!nother && nupdate && nfeature) { /* got only update rules, filter out feature rules */ POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "throwing away feature rules\n"); @@ -296,14 +483,14 @@ refine_suggestion(Solver *solv, Id *problem, Id sug, Queue *refined, int essenti if (!nfeature && v != sug) queue_push(refined, v); /* do not record feature rules */ solver_disableproblem(solv, v); + if (v < 0) + solver_reenablepolicyrules(solv, -v); if (v >= solv->updaterules && v < solv->updaterules_end) { Rule *r = solv->rules + (v - solv->updaterules + solv->featurerules); if (r->p) solver_enablerule(solv, r); /* enable corresponding feature rule */ } - if (v < 0) - solver_reenablepolicyrules(solv, -v); } else { @@ -335,6 +522,7 @@ refine_suggestion(Solver *solv, Id *problem, Id sug, Queue *refined, int essenti for (i = 0; i < disabled.count; i++) solver_enableproblem(solv, disabled.elements[i]); queue_free(&disabled); + /* reset policy rules */ for (i = 0; problem[i]; i++) solver_enableproblem(solv, problem[i]); @@ -450,13 +638,6 @@ convertsolution(Solver *solv, Id why, Queue *solutionq) return; /* false alarm */ p = solv->installed->start + (why - solv->updaterules); - 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); - queue_push(solutionq, p); - return; - } if (solv->decisionmap[p] > 0) return; /* false alarm, turned out we can keep the package */ rr = solv->rules + solv->featurerules + (why - solv->updaterules); @@ -497,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 */ @@ -538,6 +719,12 @@ 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); + } } /* @@ -584,17 +771,12 @@ create_solutions(Solver *solv, int probnr, int solidx) { Pool *pool = solv->pool; Queue redoq; - Queue problem, solution, problems_save; + Queue problem, solution, problems_save, branches_save, decisionq_reason_save; int i, j, nsol; int essentialok; unsigned int now; int oldmistakes = solv->cleandeps_mistakes ? solv->cleandeps_mistakes->count : 0; Id extraflags = -1; - int decisioncnt_update; - int decisioncnt_keep; - int decisioncnt_resolve; - int decisioncnt_weak; - int decisioncnt_orphan; now = solv_timems(0); queue_init(&redoq); @@ -606,16 +788,19 @@ create_solutions(Solver *solv, int probnr, int solidx) queue_push(&redoq, solv->decisionq_why.elements[i]); queue_push(&redoq, solv->decisionmap[p > 0 ? p : -p]); } - decisioncnt_update = solv->decisioncnt_update; - decisioncnt_keep = solv->decisioncnt_keep; - decisioncnt_resolve = solv->decisioncnt_resolve; - decisioncnt_weak = solv->decisioncnt_weak; - decisioncnt_orphan = solv->decisioncnt_orphan; /* save problems queue */ problems_save = solv->problems; memset(&solv->problems, 0, sizeof(solv->problems)); + /* save branches queue */ + branches_save = solv->branches; + memset(&solv->branches, 0, sizeof(solv->branches)); + + /* save decisionq_reason */ + decisionq_reason_save = solv->decisionq_reason; + memset(&solv->decisionq_reason, 0, sizeof(solv->decisionq_reason)); + /* extract problem from queue */ queue_init(&problem); for (i = solidx + 1; i < solv->solutions.count; i++) @@ -703,16 +888,19 @@ create_solutions(Solver *solv, int probnr, int solidx) solv->decisionmap[p > 0 ? p : -p] = redoq.elements[i + 2]; } queue_free(&redoq); - solv->decisioncnt_update = decisioncnt_update; - solv->decisioncnt_keep = decisioncnt_keep; - solv->decisioncnt_resolve = decisioncnt_resolve; - solv->decisioncnt_weak = decisioncnt_weak; - solv->decisioncnt_orphan = decisioncnt_orphan; + + /* restore decision reasons */ + queue_free(&solv->decisionq_reason); + solv->decisionq_reason = decisionq_reason_save; /* restore problems */ queue_free(&solv->problems); solv->problems = problems_save; + /* restore branches */ + queue_free(&solv->branches); + solv->branches = branches_save; + if (solv->cleandeps_mistakes) { if (oldmistakes) @@ -799,6 +987,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 @@ -850,7 +1040,7 @@ solver_take_solutionelement(Solver *solv, Id p, Id rp, Id extrajobflags, Queue * if (rp <= 0 && p <= 0) return; /* just in case */ if (rp > 0) - p = SOLVER_INSTALL|SOLVER_SOLVABLE|extrajobflags; + p = SOLVER_INSTALL|SOLVER_SOLVABLE|SOLVER_NOTBYUSER|extrajobflags; else { rp = p; @@ -885,6 +1075,7 @@ findproblemrule_internal(Solver *solv, Id idx, Id *reqrp, Id *conrp, Id *sysrp, Rule *r; Id jobassert = 0; int i, reqset = 0; /* 0: unset, 1: installed, 2: jobassert, 3: assert */ + int conset = 0; /* 0: unset, 1: installed */ /* find us a jobassert rule */ for (i = idx; (rid = solv->learnt_pool.elements[i]) != 0; i++) @@ -913,7 +1104,7 @@ findproblemrule_internal(Solver *solv, Id idx, Id *reqrp, Id *conrp, Id *sysrp, MAPSET(rseen, rid - solv->learntrules); findproblemrule_internal(solv, solv->learnt_why.elements[rid - solv->learntrules], &lreqr, &lconr, &lsysr, &ljobr, 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)) + 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; @@ -925,11 +1116,21 @@ findproblemrule_internal(Solver *solv, Id idx, Id *reqrp, Id *conrp, Id *sysrp, } else { - assert(rid < solv->rpmrules_end); + assert(rid < solv->pkgrules_end); r = solv->rules + rid; d = r->d < 0 ? -r->d - 1 : r->d; if (!d && r->w2 < 0) { + /* prefer conflicts of installed packages */ + if (solv->installed && !conset) + { + if (r->p < 0 && (solv->pool->solvables[-r->p].repo == solv->installed || + solv->pool->solvables[-r->w2].repo == solv->installed)) + { + *conrp = rid; + conset = 1; + } + } if (!*conrp) *conrp = rid; } @@ -939,8 +1140,11 @@ findproblemrule_internal(Solver *solv, Id idx, Id *reqrp, Id *conrp, Id *sysrp, { if (*reqrp > 0 && r->p < -1) { + Pool *pool = solv->pool; Id op = -solv->rules[*reqrp].p; - if (op > 1 && solv->pool->solvables[op].arch != solv->pool->solvables[-r->p].arch) + 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 */ } /* prefer assertions */ @@ -993,6 +1197,28 @@ solver_findproblemrule(Solver *solv, Id problem) map_init(&rseen, solv->learntrules ? solv->nrules - solv->learntrules : 0); findproblemrule_internal(solv, idx, &reqr, &conr, &sysr, &jobr, &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 */ + if (reqr && conr && solv->installed && solv->rules[reqr].p < 0 && solv->rules[conr].p < 0 && solv->rules[conr].w2 < 0) + { + Pool *pool = solv->pool; + Solvable *s = pool->solvables - solv->rules[reqr].p; + Solvable *s1 = pool->solvables - solv->rules[conr].p; + Solvable *s2 = pool->solvables - solv->rules[conr].w2; + Id cp = 0; + if (s == s1 && s2->repo == solv->installed) + cp = -solv->rules[conr].w2; + else if (s == s2 && s1->repo == solv->installed) + cp = -solv->rules[conr].p; + if (cp && s1->name != s2->name && s->repo != solv->installed) + { + Id p, pp; + Rule *r = solv->rules + reqr; + FOR_RULELITERALS(p, pp, r) + if (p == cp) + return conr; + } + } if (reqr) return reqr; /* some requires */ if (conr) @@ -1048,6 +1274,7 @@ solver_problemruleinfo2str(Solver *solv, SolverRuleinfo type, Id source, Id targ { Pool *pool = solv->pool; char *s; + Solvable *ss; switch (type) { case SOLVER_RULE_DISTUPGRADE: @@ -1066,38 +1293,54 @@ solver_problemruleinfo2str(Solver *solv, SolverRuleinfo type, Id source, Id targ return pool_tmpjoin(pool, "package ", pool_dep2str(pool, dep), " does not exist"); case SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM: return pool_tmpjoin(pool, pool_dep2str(pool, dep), " is provided by the system", 0); - case SOLVER_RULE_RPM: + case SOLVER_RULE_PKG: return "some dependency problem"; - case SOLVER_RULE_RPM_NOT_INSTALLABLE: + case SOLVER_RULE_BEST: + if (source > 0) + return pool_tmpjoin(pool, "cannot install the best update candidate for package ", pool_solvid2str(pool, source), 0); + return "cannot install the best candidate for the job"; + case SOLVER_RULE_PKG_NOT_INSTALLABLE: + ss = pool->solvables + source; + 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 && 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_RPM_NOTHING_PROVIDES_DEP: + case SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP: s = pool_tmpjoin(pool, "nothing provides ", pool_dep2str(pool, dep), 0); return pool_tmpappend(pool, s, " needed by ", pool_solvid2str(pool, source)); - case SOLVER_RULE_RPM_SAME_NAME: + case SOLVER_RULE_PKG_SAME_NAME: s = pool_tmpjoin(pool, "cannot install both ", pool_solvid2str(pool, source), 0); return pool_tmpappend(pool, s, " and ", pool_solvid2str(pool, target)); - case SOLVER_RULE_RPM_PACKAGE_CONFLICT: + case SOLVER_RULE_PKG_CONFLICTS: s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), 0); s = pool_tmpappend(pool, s, " conflicts with ", pool_dep2str(pool, dep)); return pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target)); - case SOLVER_RULE_RPM_PACKAGE_OBSOLETES: + case SOLVER_RULE_PKG_OBSOLETES: s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), 0); s = pool_tmpappend(pool, s, " obsoletes ", pool_dep2str(pool, dep)); return pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target)); - case SOLVER_RULE_RPM_INSTALLEDPKG_OBSOLETES: + case SOLVER_RULE_PKG_INSTALLED_OBSOLETES: s = pool_tmpjoin(pool, "installed package ", pool_solvid2str(pool, source), 0); s = pool_tmpappend(pool, s, " obsoletes ", pool_dep2str(pool, dep)); return pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target)); - case SOLVER_RULE_RPM_IMPLICIT_OBSOLETES: + case SOLVER_RULE_PKG_IMPLICIT_OBSOLETES: s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), 0); s = pool_tmpappend(pool, s, " implicitly obsoletes ", pool_dep2str(pool, dep)); return pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target)); - case SOLVER_RULE_RPM_PACKAGE_REQUIRES: + case SOLVER_RULE_PKG_REQUIRES: s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " requires "); return pool_tmpappend(pool, s, pool_dep2str(pool, dep), ", but none of the providers can be installed"); - case SOLVER_RULE_RPM_SELF_CONFLICT: + case SOLVER_RULE_PKG_SELF_CONFLICT: s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " conflicts with "); return pool_tmpappend(pool, s, pool_dep2str(pool, dep), " provided by itself"); + case SOLVER_RULE_YUMOBS: + 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"); default: return "bad problem rule type"; } @@ -1152,6 +1395,11 @@ 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 > 0 && rp > 0)