Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

640 lines (582 sloc) 16.908 kB
/* vim: sw=2 et
*/
/*
* Copyright (c) 2009, Novell Inc.
*
* This program is licensed under the BSD license, read LICENSE.BSD
* for further information
*/
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <zlib.h>
#include "pool.h"
#include "evr.h"
#include "poolarch.h"
#include "repo_solv.h"
#ifdef ENABLE_SUSEREPO
#include "repo_susetags.h"
#endif
#ifdef ENABLE_RPMMD
#include "repo_updateinfoxml.h"
#include "repo_rpmmd.h"
#endif
#include "solver.h"
#include "solverdebug.h"
#include "solv_xfopen.h"
void
showproblems(Solver *solv, Solvable *s, Queue *cand, Queue *badguys)
{
Pool *pool = solv->pool;
Queue rids, rinfo;
Id problem = 0;
int jj;
int rerun = 0;
queue_init(&rids);
queue_init(&rinfo);
printf("can't install %s:\n", pool_solvable2str(pool, s));
while ((problem = solver_next_problem(solv, problem)) != 0)
{
solver_findallproblemrules(solv, problem, &rids);
for (jj = 0; jj < rids.count; jj++)
{
Id probr = rids.elements[jj];
int k, l;
queue_empty(&rinfo);
solver_allruleinfos(solv, probr, &rinfo);
for (k = 0; k < rinfo.count; k += 4)
{
Id dep, source, target;
source = rinfo.elements[k + 1];
target = rinfo.elements[k + 2];
dep = rinfo.elements[k + 3];
switch (rinfo.elements[k])
{
case SOLVER_RULE_DISTUPGRADE:
break;
case SOLVER_RULE_INFARCH:
printf(" %s has inferior architecture\n", pool_solvid2str(pool, source));
break;
case SOLVER_RULE_UPDATE:
printf(" update rule for %s\n", pool_solvid2str(pool, source));
if (badguys)
queue_pushunique(badguys, source);
if (!cand)
break;
/* only drop update problem packages from cand so that we see all problems of this patch */
for (l = 0; l < cand->count; l++)
if (cand->elements[l] == source || cand->elements[l] == -source)
break;
if (l == cand->count)
break;
if (!rerun)
{
for (l = 0; l < cand->count; l++)
if (cand->elements[l] < 0)
cand->elements[l] = -cand->elements[l];
rerun = 1;
}
for (l = 0; l < cand->count; l++)
if (cand->elements[l] == source)
{
cand->elements[l] = -source;
}
break;
case SOLVER_RULE_JOB:
break;
case SOLVER_RULE_RPM:
printf(" some dependency problem\n");
break;
case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP:
printf(" nothing provides requested %s\n", pool_dep2str(pool, dep));
break;
case SOLVER_RULE_RPM_NOT_INSTALLABLE:
printf(" package %s is not installable\n", pool_solvid2str(pool, source));
break;
case SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP:
printf(" nothing provides %s needed by %s\n", pool_dep2str(pool, dep), pool_solvid2str(pool, source));
if (ISRELDEP(dep))
{
Reldep *rd = GETRELDEP(pool, dep);
if (!ISRELDEP(rd->name))
{
Id rp, rpp;
FOR_PROVIDES(rp, rpp, rd->name)
printf(" (we have %s)\n", pool_solvid2str(pool, rp));
}
}
break;
case SOLVER_RULE_RPM_SAME_NAME:
printf(" cannot install both %s and %s\n", pool_solvid2str(pool, source), pool_solvid2str(pool, target));
break;
case SOLVER_RULE_RPM_PACKAGE_CONFLICT:
printf(" package %s conflicts with %s provided by %s\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep), pool_solvid2str(pool, target));
break;
case SOLVER_RULE_RPM_PACKAGE_OBSOLETES:
printf(" package %s obsoletes %s provided by %s\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep), pool_solvid2str(pool, target));
break;
case SOLVER_RULE_RPM_PACKAGE_REQUIRES:
printf(" package %s requires %s, but none of the providers can be installed\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep));
break;
case SOLVER_RULE_RPM_SELF_CONFLICT:
printf(" package %s conflicts with %s provided by itself\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep));
break;
}
}
}
}
queue_free(&rids);
queue_free(&rinfo);
}
void
toinst(Solver *solv, Repo *repo, Repo *instrepo)
{
Pool *pool = solv->pool;
Queue q;
int k;
Id p;
queue_init(&q);
solver_get_decisionqueue(solv, &q);
for (k = 0; k < q.count; k++)
{
p = q.elements[k];
if (p < 0 || p == SYSTEMSOLVABLE)
continue;
/* printf(" toinstall %s\n", pool_solvid2str(pool, p));*/
/* oh my! */
pool->solvables[p].repo = instrepo;
}
queue_free(&q);
}
void
dump_instrepo(Repo *instrepo, Pool *pool)
{
Solvable *s;
Id p;
printf("instrepo..\n");
FOR_REPO_SOLVABLES(instrepo, p, s)
printf(" %s\n", pool_solvable2str(pool, s));
printf("done.\n");
}
void
frominst(Solver *solv, Repo *repo, Repo *instrepo)
{
Pool *pool = solv->pool;
int k;
for (k = 1; k < pool->nsolvables; k++)
if (pool->solvables[k].repo == instrepo)
pool->solvables[k].repo = repo;
}
void
usage(char** argv)
{
printf("%s: <arch> <patchnameprefix> [--install-available] [repos] [--updaterepos] [repos]...\n"
"\t --install-available: installation repository is available during update\n"
"\t repos: repository ending in\n"
"\t\tpackages, packages.gz, primary.xml.gz, updateinfo.xml.gz or .solv\n",
argv[0]);
exit(1);
}
typedef struct {
int updatestart;
int shown;
int status;
int install_available;
Repo *repo;
Repo *instrepo;
} context_t;
#define SHOW_PATCH(c) if (!(c)->shown++) printf("%s:\n", pool_solvable2str(pool, s));
#define PERF_DEBUGGING 0
static Pool *pool;
void
test_all_old_patches_included(context_t *c, Id pid)
{
Id p, pp;
Id con, *conp;
Solvable *s = pool->solvables + pid;
/* Test 1: are all old patches included */
FOR_PROVIDES(p, pp, s->name)
{
Solvable *s2 = pool->solvables + p;
Id con2, *conp2;
if (!s2->conflicts)
continue;
if (pool_evrcmp(pool, s->evr, s2->evr, EVRCMP_COMPARE) <= 0)
continue;
conp2 = s2->repo->idarraydata + s2->conflicts;
while ((con2 = *conp2++) != 0)
{
Reldep *rd2, *rd;
if (!ISRELDEP(con2))
continue;
rd2 = GETRELDEP(pool, con2);
conp = s->repo->idarraydata + s->conflicts;
while ((con = *conp++) != 0)
{
if (!ISRELDEP(con))
continue;
rd = GETRELDEP(pool, con);
if (rd->name == rd2->name)
break;
}
if (!con)
{
SHOW_PATCH(c);
printf(" %s contained %s\n", pool_solvable2str(pool, s2), pool_dep2str(pool, rd2->name));
}
else
{
if (pool_evrcmp(pool, rd->evr, rd2->evr, EVRCMP_COMPARE) < 0)
{
SHOW_PATCH(c);
printf(" %s required newer version %s-%s of %s-%s\n",
pool_solvable2str(pool, s2), pool_dep2str(pool, rd2->name), pool_dep2str(pool, rd2->evr),
pool_dep2str(pool, rd->name), pool_dep2str(pool, rd->evr));
}
}
}
}
}
void
test_all_packages_installable(context_t *c, Id pid)
{
Solver *solv;
Queue job;
Id p, pp;
Id con, *conp;
unsigned int now, solver_runs;
int i;
Solvable *s = pool->solvables + pid;
queue_init(&job);
now = solv_timems(0);
solver_runs = 0;
conp = s->repo->idarraydata + s->conflicts;
while ((con = *conp++) != 0)
{
FOR_PROVIDES(p, pp, con)
{
queue_empty(&job);
queue_push(&job, SOLVER_INSTALL|SOLVER_SOLVABLE|SOLVER_WEAK);
queue_push(&job, p);
/* also set up some minimal system */
queue_push(&job, SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES|SOLVER_WEAK);
queue_push(&job, pool_str2id(pool, "rpm", 1));
queue_push(&job, SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES|SOLVER_WEAK);
queue_push(&job, pool_str2id(pool, "aaa_base", 1));
solv = solver_create(pool);
/* solver_set_flag(solv, SOLVER_FLAG_IGNORE_RECOMMENDED, 1); */
++solver_runs;
if (solver_solve(solv, &job))
{
c->status = 1;
printf("error installing original package\n");
showproblems(solv, s, 0, 0);
}
toinst(solv, c->repo, c->instrepo);
solver_free(solv);
#if 0
dump_instrepo(instrepo, pool);
#endif
if (!c->install_available)
{
queue_empty(&job);
for (i = 1; i < c->updatestart; i++)
{
if (pool->solvables[i].repo != c->repo || i == pid)
continue;
queue_push(&job, SOLVER_ERASE|SOLVER_SOLVABLE);
queue_push(&job, i);
}
}
queue_push(&job, SOLVER_INSTALL|SOLVER_SOLVABLE);
queue_push(&job, pid);
solv = solver_create(pool);
/* solver_set_flag(solv, SOLVER_FLAG_IGNORE_RECOMMENDED, 1); */
++solver_runs;
if (solver_solve(solv, &job))
{
c->status = 1;
showproblems(solv, s, 0, 0);
}
frominst(solv, c->repo, c->instrepo);
solver_free(solv);
}
}
if (PERF_DEBUGGING)
printf(" test_all_packages_installable took %d ms in %d runs\n", solv_timems(now), solver_runs);
}
void
test_can_upgrade_all_packages(context_t *c, Id pid)
{
Solver *solv;
Id p;
Id con, *conp;
Queue job;
Queue cand;
Queue badguys;
int i, j;
unsigned int now, solver_runs;
Solvable *s = pool->solvables + pid;
queue_init(&job);
queue_init(&cand);
queue_init(&badguys);
now = solv_timems(0);
solver_runs = 0;
/* Test 3: can we upgrade all packages? */
for (p = 1; p < pool->nsolvables; p++)
{
Solvable *s = pool->solvables + p;
if (!s->repo)
continue;
if (strchr(pool_id2str(pool, s->name), ':'))
continue; /* only packages, please */
if (!pool_installable(pool, s))
continue;
queue_push(&cand, p);
}
while (cand.count)
{
solv = solver_create(pool);
queue_empty(&job);
for (i = 0; i < badguys.count; i++)
{
queue_push(&job, SOLVER_ERASE|SOLVER_SOLVABLE|SOLVER_WEAK);
queue_push(&job, badguys.elements[i]);
}
conp = s->repo->idarraydata + s->conflicts;
while ((con = *conp++) != 0)
{
queue_push(&job, SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES|SOLVER_WEAK);
queue_push(&job, con);
}
for (i = 0; i < cand.count; i++)
{
p = cand.elements[i];
queue_push(&job, SOLVER_INSTALL|SOLVER_SOLVABLE|SOLVER_WEAK);
queue_push(&job, p);
}
++solver_runs;
solver_solve(solv, &job);
#if 0
solver_printdecisions(solv);
#endif
/* put packages into installed repo and prune them from cand */
toinst(solv, c->repo, c->instrepo);
for (i = 0; i < cand.count; i++)
{
p = cand.elements[i];
if (p > 0 && solver_get_decisionlevel(solv, p) > 0)
cand.elements[i] = -p; /* drop candidate */
}
solver_free(solv);
/* now the interesting part: test patch */
queue_empty(&job);
if (!c->install_available)
{
for (i = 1; i < c->updatestart; i++)
{
if (pool->solvables[i].repo != c->repo || i == pid)
continue;
queue_push(&job, SOLVER_ERASE|SOLVER_SOLVABLE);
queue_push(&job, i);
}
}
queue_push(&job, SOLVER_INSTALL|SOLVER_SOLVABLE);
queue_push(&job, pid);
solv = solver_create(pool);
solver_set_flag(solv, SOLVER_FLAG_IGNORE_RECOMMENDED, 1);
++solver_runs;
if (solver_solve(solv, &job))
{
c->status = 1;
showproblems(solv, s, &cand, &badguys);
}
frominst(solv, c->repo, c->instrepo);
solver_free(solv);
/* now drop all negative elements from cand */
for (i = j = 0; i < cand.count; i++)
{
if (cand.elements[i] < 0)
continue;
cand.elements[j++] = cand.elements[i];
}
if (i == j)
break; /* no progress */
cand.count = j;
}
if (PERF_DEBUGGING)
printf(" test_can_upgrade_all_packages took %d ms in %d runs\n", solv_timems(now), solver_runs);
}
void
test_no_ga_package_fulfills_dependency(context_t *c, Id pid)
{
Id con, *conp;
Solvable *s = pool->solvables + pid;
/* Test 4: no GA package fulfills patch dependency */
conp = s->repo->idarraydata + s->conflicts;
while ((con = *conp++) != 0)
{
Reldep *rd;
Id rp, rpp;
if (!ISRELDEP(con))
continue;
rd = GETRELDEP(pool, con);
FOR_PROVIDES(rp, rpp, rd->name)
{
Solvable *s2 = pool_id2solvable(pool, rp);
if (rp < c->updatestart
&& pool_evrcmp(pool, rd->evr, s2->evr, EVRCMP_COMPARE) < 0
&& pool_match_nevr_rel(pool, s2, rd->name)
)
{
SHOW_PATCH(c);
printf(" conflict %s < %s satisfied by non-updated package %s\n",
pool_dep2str(pool, rd->name), pool_dep2str(pool, rd->evr), pool_solvable2str(pool, s2));
break;
}
}
}
}
int
main(int argc, char **argv)
{
char *arch, *mypatch;
const char *pname;
int l, r;
FILE *fp;
int i;
Id pid, p, pp;
int tests = 0;
context_t c;
static const char* langs[] = {"en"};
c.install_available = 0;
c.updatestart = 0;
c.status = 0;
if (argc <= 3)
usage(argv);
arch = argv[1];
pool = pool_create();
pool_setarch(pool, arch);
pool_set_languages(pool, langs, 1);
#if 0
pool_setdebuglevel(pool, 2);
#endif
mypatch = argv[2];
c.repo = repo_create(pool, 0);
c.instrepo = repo_create(pool, 0);
for (i = 3; i < argc; i++)
{
if (!strcmp(argv[i], "--updaterepos"))
{
c.updatestart = pool->nsolvables;
continue;
}
if (!strcmp(argv[i], "--install-available"))
{
c.install_available = 1;
continue;
}
l = strlen(argv[i]);
if (!strcmp(argv[i], "-"))
fp = stdin;
else if ((fp = solv_xfopen(argv[i], 0)) == 0)
{
perror(argv[i]);
exit(1);
}
r = 0;
if (0)
{
}
#ifdef ENABLE_SUSEREPO
else if (l >= 8 && !strcmp(argv[i] + l - 8, "packages"))
{
r = repo_add_susetags(c.repo, fp, 0, 0, 0);
}
else if (l >= 11 && !strcmp(argv[i] + l - 11, "packages.gz"))
{
r = repo_add_susetags(c.repo, fp, 0, 0, 0);
}
#endif
#ifdef ENABLE_RPMMD
else if (l >= 14 && !strcmp(argv[i] + l - 14, "primary.xml.gz"))
{
r = repo_add_rpmmd(c.repo, fp, 0, 0);
}
else if (l >= 17 && !strcmp(argv[i] + l - 17, "updateinfo.xml.gz"))
{
r = repo_add_updateinfoxml(c.repo, fp, 0);
}
#endif
else
r = repo_add_solv(c.repo, fp, 0);
if (r)
{
fprintf(stderr, "could not add repo %s: %s\n", argv[i], pool_errstr(pool));
exit(1);
}
if (fp != stdin)
fclose(fp);
}
pool_addfileprovides(pool);
/* bad hack ahead: clone repo */
c.instrepo->idarraydata = c.repo->idarraydata;
c.instrepo->idarraysize = c.repo->idarraysize;
c.instrepo->start = c.repo->start;
c.instrepo->end = c.repo->end;
c.instrepo->nsolvables = c.repo->nsolvables; /* sic! */
pool_set_installed(pool, c.instrepo);
pool_createwhatprovides(pool);
for (pid = 1; pid < pool->nsolvables; pid++)
{
Solvable *s;
c.shown = 0;
s = pool->solvables + pid;
if (!s->repo)
continue;
if (!pool_installable(pool, s))
continue;
pname = pool_id2str(pool, s->name);
if (strncmp(pname, "patch:", 6) != 0)
continue;
if (*mypatch)
{
if (strncmp(mypatch, pname + 6, strlen(pname + 6)) != 0)
continue;
if (strcmp(mypatch, pname + 6) != 0)
{
l = strlen(pname + 6);
if (mypatch[l] != '-')
continue;
if (strcmp(mypatch + l + 1, pool_id2str(pool, s->evr)) != 0)
continue;
}
}
else
{
FOR_PROVIDES(p, pp, s->name)
{
Solvable *s2 = pool->solvables + p;
if (pool_evrcmp(pool, s->evr, s2->evr, EVRCMP_COMPARE) < 0)
break;
}
if (p) {
/* printf("found a newer one for %s\n", pname+6); */
continue; /* found a newer one */
}
}
tests++;
if (!s->conflicts)
continue;
#if 0
printf("testing patch %s-%s\n", pname + 6, pool_id2str(pool, s->evr));
#endif
test_all_old_patches_included(&c, pid);
test_all_packages_installable(&c, pid);
test_can_upgrade_all_packages(&c, pid);
test_no_ga_package_fulfills_dependency(&c, pid);
}
exit(c.status);
}
Jump to Line
Something went wrong with that request. Please try again.