/*-------------------------------------------------------------------
* enable weak rules
- *
+ *
* Reenable all disabled weak rules (marked in weakrulemap)
- *
+ *
*/
static void
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.
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 */
idx = solv->solutions.count;
queue_push(&solv->solutions, -1); /* unrefined */
}
- solv->problems.count = j;
+ solv->problems.count = j;
return j / 2;
}
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));
}
* 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.
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;
/*-------------------------------------------------------------------
- *
+ *
* find problem rule
*/
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++)
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;
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;
}
*sysrp = lsysr;
}
-/*
+/*
* find problem rule
*
* search for a rule that describes the problem to the
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)
return pool_tmpjoin(pool, pool_dep2str(pool, dep), " is provided by the system", 0);
case SOLVER_RULE_RPM:
return "some dependency problem";
+ 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_RPM_NOT_INSTALLABLE:
return pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " is not installable");
case SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP:
case SOLVER_RULE_RPM_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);
default:
return "bad problem rule type";
}
}
+/* convenience function */
+const char *
+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_solutionelement2str(Solver *solv, Id p, Id rp)
{