X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fproblems.c;h=b0a421c2392148ee124393319ae805a89435d7d7;hb=d7f392b2f466c04078ccda3c9871b18edc0cdd86;hp=0b77c98105da7cb974e3c3a14b5f4c2fdeeeafb1;hpb=400d90ae66c070919c7cec8dbbd9d47d39f50db4;p=platform%2Fupstream%2Flibsolv.git diff --git a/src/problems.c b/src/problems.c index 0b77c98..b0a421c 100644 --- a/src/problems.c +++ b/src/problems.c @@ -22,9 +22,9 @@ #include "pool.h" #include "util.h" #include "evr.h" +#include "policy.h" #include "solverdebug.h" - /**********************************************************************************/ /* a problem is an item on the solver's problem list. It can either be >0, in that @@ -32,10 +32,9 @@ * consisting of multiple job rules. */ -void +static void solver_disableproblem(Solver *solv, Id v) { - Rule *r; int i; Id *jp; @@ -62,30 +61,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,17 +132,211 @@ 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]); +} + +#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 +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; +#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) + { + 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; } /*------------------------------------------------------------------- * enable weak rules - * + * * Reenable all disabled weak rules (marked in weakrulemap) - * + * */ static void @@ -152,6 +345,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,13 +355,17 @@ 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]); } /*------------------------------------------------------------------- - * + * * refine_suggestion - * + * * at this point, all rules that led to conflicts are disabled. * we re-enable all rules of a problem set but rule "sug", then * continue to disable more rules until there as again a solution. @@ -196,7 +395,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 +403,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 +420,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 +437,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 +462,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 +478,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 +498,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 +537,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 +653,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 +693,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 +734,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); + } } /* @@ -556,14 +764,14 @@ solver_prepare_solutions(Solver *solv) idx = solv->solutions.count; queue_push(&solv->solutions, -1); /* unrefined */ /* proofidx stays in position, thus we start with 1 */ - for (i = 1; i < solv->problems.count; i++) - { + for (i = 1; i < solv->problems.count; i++) + { Id p = solv->problems.elements[i]; - queue_push(&solv->solutions, p); - if (p) + queue_push(&solv->solutions, p); + if (p) continue; /* end of problem reached */ - solv->problems.elements[j++] = idx; + solv->problems.elements[j++] = idx; if (i + 1 >= solv->problems.count) break; /* start another problem */ @@ -571,7 +779,7 @@ solver_prepare_solutions(Solver *solv) idx = solv->solutions.count; queue_push(&solv->solutions, -1); /* unrefined */ } - solv->problems.count = j; + solv->problems.count = j; return j / 2; } @@ -584,7 +792,7 @@ 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; @@ -593,7 +801,7 @@ create_solutions(Solver *solv, int probnr, int solidx) now = solv_timems(0); queue_init(&redoq); - /* save decisionq, decisionq_why, decisionmap */ + /* save decisionq, decisionq_why, decisionmap, and decisioncnt */ for (i = 0; i < solv->decisionq.count; i++) { Id p = solv->decisionq.elements[i]; @@ -601,10 +809,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]); } + /* 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++) @@ -692,10 +909,19 @@ create_solutions(Solver *solv, int probnr, int solidx) solv->decisionmap[p > 0 ? p : -p] = redoq.elements[i + 2]; } queue_free(&redoq); + + /* 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) @@ -706,7 +932,7 @@ create_solutions(Solver *solv, int probnr, int solidx) solv->cleandeps_mistakes = solv_free(solv->cleandeps_mistakes); } } - + POOL_DEBUG(SOLV_DEBUG_STATS, "create_solutions for problem #%d took %d ms\n", probnr, solv_timems(now)); } @@ -761,6 +987,7 @@ solver_solutionelement_internalid(Solver *solv, Id problem, Id solution) 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) { @@ -782,6 +1009,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 @@ -791,7 +1020,7 @@ solver_solutionelement_extrajobflags(Solver *solv, Id problem, Id solution) * pkgid (> 0) pkgid (> 0) * -> add (SOLVER_INSTALL|SOLVER_SOLVABLE, rp) to the job * (this will replace package p) - * + * * Thus, the solver will either ask the application to remove * a specific job from the job queue, or ask to add an install/erase * job to it. @@ -813,6 +1042,56 @@ solver_next_solutionelement(Solver *solv, Id problem, Id solution, Id element, I 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) { @@ -830,10 +1109,15 @@ solver_take_solutionelement(Solver *solv, Id p, Id rp, Id extrajobflags, Queue * 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) - p = SOLVER_INSTALL|SOLVER_SOLVABLE|extrajobflags; + p = SOLVER_INSTALL|SOLVER_SOLVABLE|SOLVER_NOTBYUSER|extrajobflags; else { rp = p; @@ -856,18 +1140,19 @@ solver_take_solution(Solver *solv, Id problem, Id solution, Queue *job) /*------------------------------------------------------------------- - * + * * find problem rule */ 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 */ + int conset = 0; /* 0: unset, 1: installed */ /* find us a jobassert rule */ for (i = idx; (rid = solv->learnt_pool.elements[i]) != 0; i++) @@ -885,7 +1170,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); @@ -894,9 +1179,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)) + 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; @@ -906,13 +1191,33 @@ 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->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; } @@ -922,8 +1227,10 @@ 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[-r->p].arch != pool->noarchid) continue; /* different arch, skip */ } /* prefer assertions */ @@ -955,9 +1262,13 @@ 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; } -/* +/* * find problem rule * * search for a rule that describes the problem to the @@ -969,17 +1280,43 @@ 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 */ + 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) 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) @@ -1031,6 +1368,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: @@ -1049,90 +1387,138 @@ 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"); + 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"; } } +/* convenience function */ const char * -solver_solutionelement2str(Solver *solv, Id p, Id rp) +solver_problem2str(Solver *solv, Id problem) +{ + Id type, source, target, dep; + Id r = solver_findproblemrule(solv, problem); + if (!r) + return "no problem rule?"; + type = solver_ruleinfo(solv, r, &source, &target, &dep); + return solver_problemruleinfo2str(solv, type, source, target, dep); +} + +const char * +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); +}