jaiden
/
apk-tools
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
apk-tools/src/solver.c

1374 lines
36 KiB
C
Raw Normal View History

solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
/* solver.c - Alpine Package Keeper (APK)
* A backtracking, forward checking dependency graph solver.
*
all: update copyright year statement
2011-09-13 08:53:01 +00:00
* Copyright (C) 2008-2011 Timo Teräs <timo.teras@iki.fi>
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
* All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published
* by the Free Software Foundation. See http://www.gnu.org/ for details.
*/
#include <stdlib.h>
#include "apk_defines.h"
#include "apk_database.h"
#include "apk_package.h"
#include "apk_solver.h"
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
#include "apk_print.h"
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
#if 0
#include <stdio.h>
#define dbg_printf(args...) fprintf(stderr, args)
#else
#define dbg_printf(args...)
#endif
#define APK_PKGSTF_NOINSTALL 0
#define APK_PKGSTF_INSTALL 1
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
#define APK_PKGSTF_ALT_BRANCH 2
#define APK_PKGSTF_INSTALLIF 4
#define APK_PKGSTF_DECIDED 8
struct apk_score {
unsigned short unsatisfiable;
unsigned short preference;
};
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
struct apk_package_state {
struct apk_package *backtrack;
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
unsigned int topology_soft;
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
struct apk_score saved_score;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
unsigned short flags;
unsigned short conflicts;
};
struct apk_name_state {
struct list_head unsolved_list;
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
struct apk_name *name;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
struct apk_package *chosen;
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
unsigned int allowed_repos, preferred_repos;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
unsigned short requirers;
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
unsigned short install_ifs;
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
unsigned int solver_flags_local : 4;
unsigned int solver_flags_local_mask : 4;
unsigned int solver_flags_inherited : 4;
unsigned int availability_checked : 1;
unsigned int locked : 1;
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
unsigned int in_changeset : 1;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
};
struct apk_solver_state {
struct apk_database *db;
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
unsigned num_topology_positions;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
struct list_head unsolved_list_head;
struct apk_package *latest_decision;
unsigned int topology_position;
unsigned int assigned_names;
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
struct apk_score score;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
unsigned int solver_flags : 4;
unsigned int refresh_name_states : 1;
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
struct apk_package_array *best_solution;
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
struct apk_score best_score;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
};
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
static void apply_constraint(struct apk_solver_state *ss, struct apk_dependency *dep);
static void undo_constraint(struct apk_solver_state *ss, struct apk_dependency *dep);
static void push_decision(struct apk_solver_state *ss, struct apk_package *pkg,
int flags);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
static struct apk_package_state *pkg_to_ps(struct apk_package *pkg)
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
{
return (struct apk_package_state*) pkg->state_ptr;
}
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
static struct apk_name_state *name_to_ns(struct apk_name *name)
{
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
struct apk_name_state *ns;
if (name->state_ptr == NULL) {
ns = calloc(1, sizeof(struct apk_name_state));
ns->name = name;
name->state_ptr = ns;
} else {
ns = (struct apk_name_state*) name->state_ptr;
}
return ns;
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
}
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
static inline int pkg_available(struct apk_database *db, struct apk_package *pkg)
{
if (pkg->installed_size == 0)
return TRUE;
if (pkg->filename != NULL)
return TRUE;
if (apk_db_select_repo(db, pkg) != NULL)
return TRUE;
return FALSE;
}
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
static void foreach_dependency_pkg(
struct apk_solver_state *ss, struct apk_dependency_array *depends,
void (*cb)(struct apk_solver_state *ss, struct apk_package *dependency))
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
{
int i, j;
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
/* And sort the main dependencies */
for (i = 0; i < depends->num; i++) {
struct apk_dependency *dep = &depends->item[i];
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
struct apk_name *name0 = dep->name;
for (j = 0; j < name0->pkgs->num; j++) {
struct apk_package *pkg0 = name0->pkgs->item[j];
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
/* conflict depends on all to be not installed */
solver, pkg: implement versioned conflicts One can now say in dependency "!foo<2" which means, that if foo is installed, it needs to be >=2, but it's not a required dependency.
2011-10-21 19:24:24 +00:00
if (!apk_dep_is_satisfied(dep, pkg0))
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
continue;
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
cb(ss, pkg0);
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
}
}
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
}
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
static void foreach_rinstall_if_pkg(
struct apk_solver_state *ss, struct apk_package *pkg,
void (*cb)(struct apk_solver_state *ss, struct apk_package *rinstall_if))
{
struct apk_name *name = pkg->name;
int i, j, k;
for (i = 0; i < pkg->name->rinstall_if->num; i++) {
struct apk_name *name0 = pkg->name->rinstall_if->item[i];
dbg_printf(PKG_VER_FMT ": rinstall_if %s\n",
PKG_VER_PRINTF(pkg), name0->name);
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
for (j = 0; j < name0->pkgs->num; j++) {
struct apk_package *pkg0 = name0->pkgs->item[j];
for (k = 0; k < pkg0->install_if->num; k++) {
struct apk_dependency *dep = &pkg0->install_if->item[k];
if (dep->name == name &&
solver, pkg: implement versioned conflicts One can now say in dependency "!foo<2" which means, that if foo is installed, it needs to be >=2, but it's not a required dependency.
2011-10-21 19:24:24 +00:00
apk_dep_is_satisfied(dep, pkg))
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
break;
}
if (k >= pkg0->install_if->num)
continue;
/* pkg depends (via install_if) on pkg0 */
cb(ss, pkg0);
}
}
}
static void sort_hard_dependencies(struct apk_solver_state *ss, struct apk_package *pkg)
{
struct apk_package_state *ps;
if (pkg->state_ptr == NULL)
pkg->state_ptr = calloc(1, sizeof(struct apk_package_state));
ps = pkg_to_ps(pkg);
solver: fix sorting when solver is used multiple times within run namely this fixes apk upgrade without --no-self-upgrade when the solver is called twice.
2011-09-15 06:48:51 +00:00
if (ps->topology_soft)
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
return;
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
pkg->topology_hard = -1;
solver: fix sorting when solver is used multiple times within run namely this fixes apk upgrade without --no-self-upgrade when the solver is called twice.
2011-09-15 06:48:51 +00:00
ps->topology_soft = -1;
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
/* Consider hard dependencies only */
foreach_dependency_pkg(ss, pkg->depends, sort_hard_dependencies);
foreach_dependency_pkg(ss, pkg->install_if, sort_hard_dependencies);
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
ps->topology_soft = pkg->topology_hard = ++ss->num_topology_positions;
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
dbg_printf(PKG_VER_FMT ": topology_hard=%d\n",
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
PKG_VER_PRINTF(pkg), pkg->topology_hard);
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
}
static void sort_soft_dependencies(struct apk_solver_state *ss, struct apk_package *pkg)
{
struct apk_package_state *ps;
sort_hard_dependencies(ss, pkg);
ps = pkg_to_ps(pkg);
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
if (ps->topology_soft != pkg->topology_hard)
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
return;
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
ps->topology_soft = -1;
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
/* Soft reverse dependencies aka. install_if */
foreach_rinstall_if_pkg(ss, pkg, sort_hard_dependencies);
foreach_dependency_pkg(ss, pkg->depends, sort_soft_dependencies);
/* Assign a topology sorting order */
ps->topology_soft = ++ss->num_topology_positions;
dbg_printf(PKG_VER_FMT ": topology_soft=%d\n",
PKG_VER_PRINTF(pkg), ps->topology_soft);
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
}
static void sort_name(struct apk_solver_state *ss, struct apk_name *name)
{
int i;
for (i = 0; i < name->pkgs->num; i++)
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
sort_soft_dependencies(ss, name->pkgs->item[i]);
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
}
solver: don't consider package that we can't have Packages that need (re-)installation but which are not available, are excluded now properly.
2011-07-27 19:10:44 +00:00
static void prepare_name(struct apk_solver_state *ss, struct apk_name *name,
struct apk_name_state *ns)
{
int i;
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
if (ns->availability_checked)
solver: don't consider package that we can't have Packages that need (re-)installation but which are not available, are excluded now properly.
2011-07-27 19:10:44 +00:00
return;
for (i = 0; i < name->pkgs->num; i++) {
struct apk_package *pkg = name->pkgs->item[i];
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
struct apk_package_state *ps = pkg_to_ps(pkg);
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct apk_name_state *ns = name_to_ns(pkg->name);
solver: don't consider package that we can't have Packages that need (re-)installation but which are not available, are excluded now properly.
2011-07-27 19:10:44 +00:00
/* if package is needed for (re-)install */
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
if ((pkg->ipkg == NULL) ||
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
((ns->solver_flags_local | ns->solver_flags_inherited |
ss->solver_flags) & APK_SOLVERF_REINSTALL)) {
solver: don't consider package that we can't have Packages that need (re-)installation but which are not available, are excluded now properly.
2011-07-27 19:10:44 +00:00
/* and it's not available, we can't use it */
if (!pkg_available(ss->db, pkg))
solver: add per-name specific flags, and fix the fix applet
2011-09-13 08:47:34 +00:00
ps->conflicts = 1024;
solver: don't consider package that we can't have Packages that need (re-)installation but which are not available, are excluded now properly.
2011-07-27 19:10:44 +00:00
}
}
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
ns->availability_checked = 1;
}
static void foreach_locked_reverse_dependency(
struct apk_name *name,
void (*cb)(struct apk_package *rdepend, void *ctx), void *ctx)
{
int i, j;
if (name == NULL)
return;
for (i = 0; i < name->rdepends->num; i++) {
struct apk_name *name0 = name->rdepends->item[i];
struct apk_name_state *ns0 = name_to_ns(name0);
struct apk_package *pkg0 = ns0->chosen;
if (!ns0->locked || ns0->chosen == NULL)
continue;
for (j = 0; j < pkg0->depends->num; j++) {
struct apk_dependency *dep = &pkg0->depends->item[j];
if (dep->name == name)
break;
}
if (j >= pkg0->depends->num)
continue;
cb(pkg0, ctx);
}
solver: don't consider package that we can't have Packages that need (re-)installation but which are not available, are excluded now properly.
2011-07-27 19:10:44 +00:00
}
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
static void foreach_dependency(struct apk_solver_state *ss, struct apk_dependency_array *deps,
void (*func)(struct apk_solver_state *ss, struct apk_dependency *dep))
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
{
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
int i;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
for (i = 0; i < deps->num; i++)
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
func(ss, &deps->item[i]);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
static int compare_package_preference(unsigned short solver_flags,
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
unsigned int preferred_repos,
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
struct apk_package *pkgA,
struct apk_package *pkgB)
{
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
/* preferred repository pinning */
solver: misc fixes caused upgrading package X with "apk add path/to/x...apk" where the package file was not in any repository to not work properly.
2011-10-31 14:51:53 +00:00
if ((pkgA->ipkg || pkgA->filename || (pkgA->repos & preferred_repos)) &&
!(pkgB->ipkg || pkgB->filename || (pkgB->repos & preferred_repos)))
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
return 1;
solver: misc fixes caused upgrading package X with "apk add path/to/x...apk" where the package file was not in any repository to not work properly.
2011-10-31 14:51:53 +00:00
if ((pkgB->ipkg || pkgA->filename || (pkgB->repos & preferred_repos)) &&
!(pkgA->ipkg || pkgB->filename || (pkgA->repos & preferred_repos)))
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
return -1;
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
if (solver_flags & APK_SOLVERF_AVAILABLE) {
if (pkgA->repos != 0 && pkgB->repos == 0)
return 1;
if (pkgB->repos != 0 && pkgA->repos == 0)
return -1;
}
if (!(solver_flags & APK_SOLVERF_UPGRADE)) {
/* not upgrading, prefer the installed package */
if (pkgA->ipkg != NULL && pkgB->ipkg == NULL)
return 1;
if (pkgB->ipkg != NULL && pkgA->ipkg == NULL)
return -1;
}
/* upgrading, or neither of the package is installed, so
* we just fall back comparing to versions */
switch (apk_pkg_version_compare(pkgA, pkgB)) {
case APK_VERSION_GREATER:
return 1;
case APK_VERSION_LESS:
return -1;
}
/* prefer the one with lowest available repository */
return ffsl(pkgB->repos) - ffsl(pkgA->repos);
}
static int get_preference(struct apk_solver_state *ss,
struct apk_package *pkg,
int installable_only)
solver: permutate each preferred solution first The first found solution is the most preferred one then.
2011-07-27 17:27:41 +00:00
{
struct apk_name *name = pkg->name;
solver: add per-name specific flags, and fix the fix applet
2011-09-13 08:47:34 +00:00
struct apk_name_state *ns = name_to_ns(name);
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
unsigned short name_flags = ns->solver_flags_local
| ns->solver_flags_inherited
| ss->solver_flags;
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
unsigned int preferred_repos = ns->preferred_repos | ss->db->repo_tags[0].allowed_repos;
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
unsigned short preference = 0;
int i;
solver: permutate each preferred solution first The first found solution is the most preferred one then.
2011-07-27 17:27:41 +00:00
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
for (i = 0; i < name->pkgs->num; i++) {
solver: permutate each preferred solution first The first found solution is the most preferred one then.
2011-07-27 17:27:41 +00:00
struct apk_package *pkg0 = name->pkgs->item[i];
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
struct apk_package_state *ps0 = pkg_to_ps(pkg0);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
if (pkg0 == pkg || ps0 == NULL)
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
continue;
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
if (compare_package_preference(name_flags,
preferred_repos,
pkg, pkg0) < 0) {
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
if (installable_only) {
if (ss->topology_position > pkg0->topology_hard &&
!(ps0->flags & APK_PKGSTF_DECIDED))
preference++;
} else
preference++;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
}
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
return preference;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
static int install_if_missing(struct apk_solver_state *ss, struct apk_package *pkg)
{
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct apk_name_state *ns;
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
int i, missing = 0;
for (i = 0; i < pkg->install_if->num; i++) {
struct apk_dependency *dep = &pkg->install_if->item[i];
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
ns = name_to_ns(dep->name);
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
if (!ns->locked || !apk_dep_is_satisfied(dep, ns->chosen))
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
missing++;
}
return missing;
}
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
static int update_name_state(struct apk_solver_state *ss, struct apk_name *name)
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
{
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
struct apk_name_state *ns = name_to_ns(name);
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
struct apk_package *best_pkg = NULL;
unsigned int best_topology = 0;
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
unsigned int allowed_repos = ns->allowed_repos | ss->db->repo_tags[0].allowed_repos;
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
int i, options = 0, skipped_options = 0;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
for (i = 0; i < name->pkgs->num; i++) {
struct apk_package *pkg0 = name->pkgs->item[i];
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
struct apk_package_state *ps0 = pkg_to_ps(pkg0);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
solver: report 'complete' solutions with errors Allow to select packages that conflict in case we are looking for errors. This allows 'add --force' to install (on boot) the set of packages with minimum conflicts.
2011-09-05 07:51:11 +00:00
if (ps0 == NULL ||
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
pkg0->topology_hard >= ss->topology_position ||
solver: report 'complete' solutions with errors Allow to select packages that conflict in case we are looking for errors. This allows 'add --force' to install (on boot) the set of packages with minimum conflicts.
2011-09-05 07:51:11 +00:00
(ps0->flags & APK_PKGSTF_DECIDED))
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
continue;
solver: misc fixes caused upgrading package X with "apk add path/to/x...apk" where the package file was not in any repository to not work properly.
2011-10-31 14:51:53 +00:00
if ((pkg0->repos != 0) && (pkg0->ipkg == NULL) && (pkg0->filename == NULL) &&
!(pkg0->repos & allowed_repos)) {
skipped_options++;
continue;
}
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
if (ns->requirers == 0 && ns->install_ifs != 0 &&
install_if_missing(ss, pkg0)) {
skipped_options++;
continue;
}
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
options++;
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
if (ps0->topology_soft < ss->topology_position &&
ps0->topology_soft > best_topology)
best_pkg = pkg0, best_topology = ps0->topology_soft;
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
else if (pkg0->topology_hard > best_topology)
best_pkg = pkg0, best_topology = pkg0->topology_hard;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
solver: evaluate penalty of unsatisfiable name early this prunes the search tree considerably and fixes a speed regression introduced in an earlier commit.
2011-09-28 05:39:52 +00:00
if (skipped_options == 0 && options == 0) {
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
if (!ns->locked) {
ss->score.unsatisfiable += ns->requirers;
ss->score.preference += name->pkgs->num;
}
solver: evaluate penalty of unsatisfiable name early this prunes the search tree considerably and fixes a speed regression introduced in an earlier commit.
2011-09-28 05:39:52 +00:00
ns->locked = 1;
ns->chosen = NULL;
} else {
ns->locked = 0;
}
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
if (ns->requirers == 0 && ns->install_ifs == 0) {
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
if (list_hashed(&ns->unsolved_list)) {
list_del(&ns->unsolved_list);
list_init(&ns->unsolved_list);
ns->chosen = NULL;
}
solver: report 'complete' solutions with errors Allow to select packages that conflict in case we are looking for errors. This allows 'add --force' to install (on boot) the set of packages with minimum conflicts.
2011-09-05 07:51:11 +00:00
dbg_printf("%s: deleted from unsolved: %d requirers, %d install_ifs, %d options, %d skipped\n",
name->name, ns->requirers, ns->install_ifs, options, skipped_options);
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
} else {
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
dbg_printf("%s: added to unsolved: %d requirers, %d install_ifs, %d options (next topology %d)\n",
name->name, ns->requirers, ns->install_ifs, options,
best_topology);
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
if (!list_hashed(&ns->unsolved_list))
list_add(&ns->unsolved_list, &ss->unsolved_list_head);
solver: misc fixes caused upgrading package X with "apk add path/to/x...apk" where the package file was not in any repository to not work properly.
2011-10-31 14:51:53 +00:00
if (!ns->locked)
ns->chosen = best_pkg;
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
}
solver: report 'complete' solutions with errors Allow to select packages that conflict in case we are looking for errors. This allows 'add --force' to install (on boot) the set of packages with minimum conflicts.
2011-09-05 07:51:11 +00:00
return options + skipped_options;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
static void trigger_install_if(struct apk_solver_state *ss,
struct apk_package *pkg)
{
if (install_if_missing(ss, pkg) == 0) {
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct apk_name_state *ns = ns = name_to_ns(pkg->name);
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
dbg_printf("trigger_install_if: " PKG_VER_FMT " triggered\n",
PKG_VER_PRINTF(pkg));
ns->install_ifs++;
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
update_name_state(ss, pkg->name);
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
}
}
static void untrigger_install_if(struct apk_solver_state *ss,
struct apk_package *pkg)
{
if (install_if_missing(ss, pkg) != 1) {
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct apk_name_state *ns = name_to_ns(pkg->name);
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
dbg_printf("untrigger_install_if: " PKG_VER_FMT " no longer triggered\n",
PKG_VER_PRINTF(pkg));
ns->install_ifs--;
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
update_name_state(ss, pkg->name);
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
}
}
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
static void apply_decision(struct apk_solver_state *ss,
struct apk_package *pkg,
struct apk_package_state *ps)
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
{
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct apk_name_state *ns = name_to_ns(pkg->name);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
dbg_printf("apply_decision: " PKG_VER_FMT " %s\n", PKG_VER_PRINTF(pkg),
(ps->flags & APK_PKGSTF_INSTALL) ? "INSTALL" : "NO_INSTALL");
if (ps->flags & APK_PKGSTF_INSTALL) {
ss->assigned_names++;
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
ss->score.unsatisfiable += ps->conflicts;
ss->score.preference += get_preference(ss, pkg, FALSE);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
ns->chosen = pkg;
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
ns->locked = 1;
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
list_del(&ns->unsolved_list);
list_init(&ns->unsolved_list);
dbg_printf("%s: deleting from unsolved list\n",
pkg->name->name);
foreach_dependency(ss, pkg->depends, apply_constraint);
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
foreach_rinstall_if_pkg(ss, pkg, trigger_install_if);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
} else {
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
update_name_state(ss, pkg->name);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
}
static void undo_decision(struct apk_solver_state *ss,
struct apk_package *pkg,
struct apk_package_state *ps)
{
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct apk_name_state *ns = name_to_ns(pkg->name);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
dbg_printf("undo_decision: " PKG_VER_FMT " %s\n", PKG_VER_PRINTF(pkg),
(ps->flags & APK_PKGSTF_INSTALL) ? "INSTALL" : "NO_INSTALL");
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
if (ps->flags & APK_PKGSTF_INSTALLIF)
ss->topology_position = ps->topology_soft;
else
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
ss->topology_position = pkg->topology_hard;
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
if (ps->flags & APK_PKGSTF_INSTALL) {
ss->assigned_names--;
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
foreach_rinstall_if_pkg(ss, pkg, untrigger_install_if);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
foreach_dependency(ss, pkg->depends, undo_constraint);
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
ns->locked = 0;
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
ns->chosen = NULL;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
ss->score = ps->saved_score;
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
update_name_state(ss, pkg->name);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
static void push_decision(struct apk_solver_state *ss, struct apk_package *pkg,
int flags)
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
{
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
struct apk_package_state *ps = pkg_to_ps(pkg);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
ps->backtrack = ss->latest_decision;
solver: report 'complete' solutions with errors Allow to select packages that conflict in case we are looking for errors. This allows 'add --force' to install (on boot) the set of packages with minimum conflicts.
2011-09-05 07:51:11 +00:00
ps->flags = flags | APK_PKGSTF_DECIDED;
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
ps->saved_score = ss->score;
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
if (ps->topology_soft < ss->topology_position) {
if (flags & APK_PKGSTF_INSTALL)
ps->flags |= APK_PKGSTF_INSTALLIF;
ss->topology_position = ps->topology_soft;
} else {
ps->flags &= ~APK_PKGSTF_INSTALLIF;
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
ss->topology_position = pkg->topology_hard;
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
}
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
ss->latest_decision = pkg;
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
dbg_printf("push_decision: adding new BRANCH at topology_position %d\n",
ss->topology_position);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
if (ps->flags & APK_PKGSTF_INSTALLIF)
dbg_printf("triggers due to " PKG_VER_FMT "\n",
PKG_VER_PRINTF(pkg));
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
apply_decision(ss, pkg, ps);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
static int next_branch(struct apk_solver_state *ss)
{
struct apk_package *pkg;
struct apk_package_state *ps;
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
while (ss->latest_decision != NULL) {
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
pkg = ss->latest_decision;
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
ps = pkg_to_ps(pkg);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
if (ps->flags & APK_PKGSTF_ALT_BRANCH) {
dbg_printf("next_branch: undo decision at topology_position %d\n",
ss->topology_position);
solver: report 'complete' solutions with errors Allow to select packages that conflict in case we are looking for errors. This allows 'add --force' to install (on boot) the set of packages with minimum conflicts.
2011-09-05 07:51:11 +00:00
ps->flags &= ~(APK_PKGSTF_ALT_BRANCH | APK_PKGSTF_DECIDED);
solver: misc fixes caused upgrading package X with "apk add path/to/x...apk" where the package file was not in any repository to not work properly.
2011-10-31 14:51:53 +00:00
undo_decision(ss, pkg, ps);
solver: report 'complete' solutions with errors Allow to select packages that conflict in case we are looking for errors. This allows 'add --force' to install (on boot) the set of packages with minimum conflicts.
2011-09-05 07:51:11 +00:00
ss->latest_decision = ps->backtrack;
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
ss->refresh_name_states = 1;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
} else {
dbg_printf("next_branch: swapping BRANCH at topology_position %d\n",
ss->topology_position);
solver: misc fixes caused upgrading package X with "apk add path/to/x...apk" where the package file was not in any repository to not work properly.
2011-10-31 14:51:53 +00:00
undo_decision(ss, pkg, ps);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
ps->flags |= APK_PKGSTF_ALT_BRANCH;
ps->flags ^= APK_PKGSTF_INSTALL;
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
apply_decision(ss, pkg, ps);
return 0;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
}
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
dbg_printf("next_branch: no more branches\n");
return 1;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
static void inherit_name_state(struct apk_name *to, struct apk_name *from)
{
struct apk_name_state *tns = name_to_ns(to);
struct apk_name_state *fns = name_to_ns(from);
tns->solver_flags_inherited |=
fns->solver_flags_inherited |
(fns->solver_flags_local & fns->solver_flags_local_mask);
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
tns->allowed_repos |= fns->allowed_repos;
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
}
static void inherit_name_state_wrapper(struct apk_package *rdepend, void *ctx)
{
struct apk_name *name = (struct apk_name *) ctx;
inherit_name_state(name, rdepend->name);
}
static int has_inherited_state(struct apk_name *name)
{
struct apk_name_state *ns = name_to_ns(name);
if (name == NULL)
return 0;
if (ns->solver_flags_inherited || (ns->solver_flags_local & ns->solver_flags_local_mask))
return 1;
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
if (ns->allowed_repos)
return 1;
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
return 0;
}
static void recalculate_inherted_name_state(struct apk_name *name)
{
struct apk_name_state *ns = name_to_ns(name);
ns->solver_flags_inherited = 0;
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
ns->allowed_repos = 0;
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
foreach_locked_reverse_dependency(name, inherit_name_state_wrapper, name);
}
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
static void apply_constraint(struct apk_solver_state *ss, struct apk_dependency *dep)
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
{
struct apk_name *name = dep->name;
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct apk_name_state *ns = name_to_ns(name);
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
int i;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
solver: don't consider package that we can't have Packages that need (re-)installation but which are not available, are excluded now properly.
2011-07-27 19:10:44 +00:00
prepare_name(ss, name, ns);
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
if (ns->locked) {
solver: misc fixes caused upgrading package X with "apk add path/to/x...apk" where the package file was not in any repository to not work properly.
2011-10-31 14:51:53 +00:00
if (ns->chosen)
dbg_printf("%s: locked to " PKG_VER_FMT " already\n",
dep->name->name, PKG_VER_PRINTF(ns->chosen));
else
dbg_printf("%s: locked to empty\n",
dep->name->name);
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
if (!apk_dep_is_satisfied(dep, ns->chosen))
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
ss->score.unsatisfiable++;
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
return;
}
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
if (dep->repository_tag) {
unsigned int allowed_repos;
dbg_printf("%s: enabling repository tag %d\n",
dep->name->name, dep->repository_tag);
allowed_repos = ss->db->repo_tags[dep->repository_tag].allowed_repos;
ns->allowed_repos |= allowed_repos;
ns->preferred_repos |= allowed_repos;
}
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
for (i = 0; i < name->pkgs->num; i++) {
struct apk_package *pkg0 = name->pkgs->item[i];
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
struct apk_package_state *ps0 = pkg_to_ps(pkg0);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
if (ps0 == NULL ||
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
pkg0->topology_hard >= ss->topology_position)
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
continue;
if (!apk_dep_is_satisfied(dep, pkg0)) {
ps0->conflicts++;
dbg_printf(PKG_VER_FMT ": conflicts++ -> %d\n",
PKG_VER_PRINTF(pkg0),
ps0->conflicts);
}
}
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
if (ss->latest_decision != NULL)
inherit_name_state(name, ss->latest_decision->name);
solver, pkg: implement versioned conflicts One can now say in dependency "!foo<2" which means, that if foo is installed, it needs to be >=2, but it's not a required dependency.
2011-10-21 19:24:24 +00:00
if (!dep->optional)
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
ns->requirers++;
update_name_state(ss, name);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
static void undo_constraint(struct apk_solver_state *ss, struct apk_dependency *dep)
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
{
struct apk_name *name = dep->name;
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct apk_name_state *ns = name_to_ns(name);
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
int i;
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
if (ns->locked) {
solver: evaluate penalty of unsatisfiable name early this prunes the search tree considerably and fixes a speed regression introduced in an earlier commit.
2011-09-28 05:39:52 +00:00
if (ns->chosen != NULL) {
dbg_printf(PKG_VER_FMT " selected already for %s\n",
PKG_VER_PRINTF(ns->chosen), dep->name->name);
} else {
dbg_printf("%s selected to not be satisfied\n",
dep->name->name);
}
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
return;
}
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
for (i = 0; i < name->pkgs->num; i++) {
struct apk_package *pkg0 = name->pkgs->item[i];
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
struct apk_package_state *ps0 = pkg_to_ps(pkg0);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
if (pkg0->topology_hard >= ss->topology_position)
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
continue;
if (!apk_dep_is_satisfied(dep, pkg0)) {
ps0->conflicts--;
dbg_printf(PKG_VER_FMT ": conflicts-- -> %d\n",
PKG_VER_PRINTF(pkg0),
ps0->conflicts);
}
}
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
if (ss->latest_decision && has_inherited_state(ss->latest_decision->name))
recalculate_inherted_name_state(name);
solver, pkg: implement versioned conflicts One can now say in dependency "!foo<2" which means, that if foo is installed, it needs to be >=2, but it's not a required dependency.
2011-10-21 19:24:24 +00:00
if (!dep->optional)
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
ns->requirers--;
update_name_state(ss, name);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
static int expand_branch(struct apk_solver_state *ss)
{
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
struct apk_name_state *ns;
struct apk_package *pkg0 = NULL;
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
unsigned int topology0 = 0;
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
int flags;
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
/* FIXME: change unsolved_list to a priority queue */
list_for_each_entry(ns, &ss->unsolved_list_head, unsolved_list) {
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
if (ss->refresh_name_states)
update_name_state(ss, ns->name);
solver: reintroduce install_if support * each package name has two sorting positions, one which causes install_if triggers to be run, and other for bulk dependencies * fix also inverted ordering of package installations
2011-08-17 13:55:35 +00:00
/* ns->chosen can be NULL if the name has only install_if
* requirers that got later conflicted, but it still has
* other options that can get activated later due to more
* complicated install_if rules in some other package. */
if (ns->chosen == NULL)
continue;
if (pkg_to_ps(ns->chosen)->topology_soft < ss->topology_position &&
pkg_to_ps(ns->chosen)->topology_soft > topology0)
pkg0 = ns->chosen, topology0 = pkg_to_ps(pkg0)->topology_soft;
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
else if (ns->chosen->topology_hard > topology0)
pkg0 = ns->chosen, topology0 = pkg0->topology_hard;
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
}
solver: fix backtracking We need to refresh all name states after backtracking as options that were excluding due to topology ordering might have become available.
2011-09-22 10:09:23 +00:00
ss->refresh_name_states = 0;
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
if (pkg0 == NULL) {
dbg_printf("expand_branch: list is empty (%d unsatisfied)\n",
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
ss->score.unsatisfiable);
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
return 1;
}
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
/* someone needs to provide this name -- find next eligible
* provider candidate */
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
ns = name_to_ns(pkg0->name);
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
dbg_printf("expand_branch: %s\n", pkg0->name->name);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
if (get_preference(ss, pkg0, TRUE) == 0)
flags = APK_PKGSTF_INSTALL;
else
flags = APK_PKGSTF_NOINSTALL;
push_decision(ss, pkg0, flags);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
return 0;
}
static void record_solution(struct apk_solver_state *ss)
{
struct apk_package *pkg;
struct apk_package_state *ps;
int i;
apk_package_array_resize(&ss->best_solution, ss->assigned_names);
i = 0;
pkg = ss->latest_decision;
while (pkg != NULL) {
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
ps = pkg_to_ps(pkg);
solver: report 'complete' solutions with errors Allow to select packages that conflict in case we are looking for errors. This allows 'add --force' to install (on boot) the set of packages with minimum conflicts.
2011-09-05 07:51:11 +00:00
if (ps->flags & APK_PKGSTF_INSTALL) {
if (i >= ss->assigned_names)
abort();
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
ss->best_solution->item[i++] = pkg;
solver: report 'complete' solutions with errors Allow to select packages that conflict in case we are looking for errors. This allows 'add --force' to install (on boot) the set of packages with minimum conflicts.
2011-09-05 07:51:11 +00:00
}
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
dbg_printf("record_solution: " PKG_VER_FMT ": %sINSTALL\n",
PKG_VER_PRINTF(pkg),
(ps->flags & APK_PKGSTF_INSTALL) ? "" : "NO_");
pkg = ps->backtrack;
}
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
apk_package_array_resize(&ss->best_solution, i);
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
ss->best_score = ss->score;
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
}
static int compare_package_name(const void *p1, const void *p2)
{
const struct apk_package **c1 = (const struct apk_package **) p1;
const struct apk_package **c2 = (const struct apk_package **) p2;
return strcmp((*c1)->name->name, (*c2)->name->name);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
static int compare_change(const void *p1, const void *p2)
{
const struct apk_change *c1 = (const struct apk_change *) p1;
const struct apk_change *c2 = (const struct apk_change *) p2;
if (c1->newpkg == NULL) {
if (c2->newpkg == NULL)
/* both deleted - reverse topology order */
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
return c2->oldpkg->topology_hard -
c1->oldpkg->topology_hard;
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
/* c1 deleted, c2 installed -> c2 first*/
return -1;
}
if (c2->newpkg == NULL)
/* c1 installed, c2 deleted -> c1 first*/
return 1;
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
return c1->newpkg->topology_hard -
c2->newpkg->topology_hard;
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
}
static int generate_changeset(struct apk_database *db,
struct apk_package_array *solution,
solver: add per-name specific flags, and fix the fix applet
2011-09-13 08:47:34 +00:00
struct apk_changeset *changeset,
unsigned short solver_flags)
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
{
struct apk_name *name;
struct apk_name_state *ns;
struct apk_package *pkg, *pkg0;
struct apk_installed_package *ipkg;
int i, j, num_installs = 0, num_removed = 0, ci = 0;
/* calculate change set size */
for (i = 0; i < solution->num; i++) {
pkg = solution->item[i];
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
ns = name_to_ns(pkg->name);
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
ns->chosen = pkg;
ns->in_changeset = 1;
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
if ((pkg->ipkg == NULL) ||
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
((ns->solver_flags_local | ns->solver_flags_inherited |
solver_flags) & APK_SOLVERF_REINSTALL))
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
num_installs++;
}
list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list) {
name = ipkg->pkg->name;
ns = name_to_ns(name);
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
if ((ns->chosen == NULL) || !ns->in_changeset)
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
num_removed++;
}
/* construct changeset */
apk_change_array_resize(&changeset->changes, num_installs + num_removed);
list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list) {
name = ipkg->pkg->name;
ns = name_to_ns(name);
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
if ((ns->chosen == NULL) || !ns->in_changeset) {
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
changeset->changes->item[ci].oldpkg = ipkg->pkg;
ci++;
}
}
for (i = 0; i < solution->num; i++) {
pkg = solution->item[i];
name = pkg->name;
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
ns = name_to_ns(name);
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
if ((pkg->ipkg == NULL) ||
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
((ns->solver_flags_local | ns->solver_flags_inherited |
solver_flags) & APK_SOLVERF_REINSTALL)) {
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
for (j = 0; j < name->pkgs->num; j++) {
pkg0 = name->pkgs->item[j];
if (pkg0->ipkg == NULL)
continue;
changeset->changes->item[ci].oldpkg = pkg0;
break;
}
changeset->changes->item[ci].newpkg = pkg;
ci++;
}
}
/* sort changeset to topology order */
qsort(changeset->changes->item, changeset->changes->num,
sizeof(struct apk_change), compare_change);
return 0;
}
static int free_state(apk_hash_item item, void *ctx)
{
struct apk_name *name = (struct apk_name *) item;
if (name->state_ptr != NULL) {
free(name->state_ptr);
name->state_ptr = NULL;
}
return 0;
}
upgrade: reimplement self-upgrade (after solver merge)
2011-09-14 07:38:26 +00:00
static int free_package(apk_hash_item item, void *ctx)
{
struct apk_package *pkg = (struct apk_package *) item;
if (pkg->state_ptr != NULL) {
free(pkg->state_ptr);
pkg->state_ptr = NULL;
}
return 0;
}
solver: add per-name specific flags, and fix the fix applet
2011-09-13 08:47:34 +00:00
void apk_solver_set_name_flags(struct apk_name *name,
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
unsigned short solver_flags,
unsigned short solver_flags_inheritable)
solver: add per-name specific flags, and fix the fix applet
2011-09-13 08:47:34 +00:00
{
struct apk_name_state *ns = name_to_ns(name);
solver: inheritable solver flags allow per-name solver flags to be inheritable, and use them in self-upgrade, add -u and the fix applet. this gives more familiar behaviour for the upgrades.
2011-09-16 14:10:50 +00:00
ns->solver_flags_local = solver_flags;
ns->solver_flags_local_mask = solver_flags_inheritable;
solver: add per-name specific flags, and fix the fix applet
2011-09-13 08:47:34 +00:00
}
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
static void apk_solver_free(struct apk_database *db)
{
apk_hash_foreach(&db->available.names, free_state, NULL);
apk_hash_foreach(&db->available.packages, free_package, NULL);
}
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
static int cmpscore(struct apk_score *a, struct apk_score *b)
{
if (a->unsatisfiable < b->unsatisfiable)
return -1;
if (a->unsatisfiable > b->unsatisfiable)
return 1;
if (a->preference < b->preference)
return -1;
if (a->preference > b->preference)
return 1;
return 0;
}
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
int apk_solver_solve(struct apk_database *db,
unsigned short solver_flags,
struct apk_dependency_array *world,
struct apk_package_array **solution,
struct apk_changeset *changeset)
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
{
struct apk_solver_state *ss;
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct apk_installed_package *ipkg;
solver: consider world dependencies to determining exit score
2011-11-01 06:29:24 +00:00
struct apk_score zero_score;
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
int i, r;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
ss = calloc(1, sizeof(struct apk_solver_state));
ss->db = db;
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
ss->solver_flags = solver_flags;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
ss->topology_position = -1;
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
ss->best_score = (struct apk_score){ .unsatisfiable = -1, .preference = -1 };
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
list_init(&ss->unsolved_list_head);
solver: move topology sorting to solver code this allows quite some optimizations to running time and memory requirements.
2011-08-05 08:53:26 +00:00
for (i = 0; i < world->num; i++)
sort_name(ss, world->item[i].name);
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list)
sort_name(ss, ipkg->pkg->name);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
foreach_dependency(ss, world, apply_constraint);
solver: consider world dependencies to determining exit score
2011-11-01 06:29:24 +00:00
zero_score = ss->score;
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
do {
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
if (cmpscore(&ss->score, &ss->best_score) < 0) {
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
r = expand_branch(ss);
if (r) {
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
dbg_printf("solution with: %d unsatisfiable, %d preference\n",
ss->score.unsatisfiable,
ss->score.preference);
if (cmpscore(&ss->score, &ss->best_score) < 0)
record_solution(ss);
solver: fix zero score comparison
2011-11-01 12:44:39 +00:00
if (cmpscore(&zero_score, &ss->score) >= 0) {
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
/* found solution - it is optimal because we permutate
* each preferred local option first, and permutations
* happen in topologally sorted order. */
r = 0;
break;
}
r = next_branch(ss);
}
} else {
r = next_branch(ss);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
} while (r == 0);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
/* collect packages */
solver: return changeset even for partial solutions otherwise --force does might not work during boot.
2011-11-01 06:40:50 +00:00
if (changeset != NULL) {
generate_changeset(db, ss->best_solution, changeset,
ss->solver_flags);
}
if (solution != NULL) {
solver: generate proper error messages * the solver no longer does look-ahead locking of names (could be possibly optimized later); instead names are now always ordered strictly to properly detect the package names which are unsolveable * basic error tests added, so we can see the most likely problem in dependencies easily
2011-07-30 17:59:47 +00:00
qsort(ss->best_solution->item, ss->best_solution->num,
sizeof(struct apk_package *), compare_package_name);
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
*solution = ss->best_solution;
solver: return changeset even for partial solutions otherwise --force does might not work during boot.
2011-11-01 06:40:50 +00:00
} else {
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
apk_package_array_free(&ss->best_solution);
solver: return changeset even for partial solutions otherwise --force does might not work during boot.
2011-11-01 06:40:50 +00:00
}
r = ss->best_score.unsatisfiable;
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
apk_solver_free(db);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
free(ss);
return r;
}
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
static void print_change(struct apk_database *db,
struct apk_change *change,
int cur, int total)
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
{
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct apk_name *name;
struct apk_package *oldpkg = change->oldpkg;
struct apk_package *newpkg = change->newpkg;
const char *msg = NULL;
char status[64];
int r;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
snprintf(status, sizeof(status), "(%i/%i)", cur+1, total);
status[sizeof(status) - 1] = '\0';
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
if (oldpkg != NULL)
name = oldpkg->name;
else
name = newpkg->name;
if (oldpkg == NULL) {
apk_message("%s Installing %s (" BLOB_FMT ")",
status, name->name,
BLOB_PRINTF(*newpkg->version));
} else if (newpkg == NULL) {
apk_message("%s Purging %s (" BLOB_FMT ")",
status, name->name,
BLOB_PRINTF(*oldpkg->version));
} else {
r = apk_pkg_version_compare(newpkg, oldpkg);
switch (r) {
case APK_VERSION_LESS:
msg = "Downgrading";
break;
case APK_VERSION_EQUAL:
if (newpkg == oldpkg)
msg = "Re-installing";
else
msg = "Replacing";
break;
case APK_VERSION_GREATER:
msg = "Upgrading";
break;
}
apk_message("%s %s %s (" BLOB_FMT " -> " BLOB_FMT ")",
status, msg, name->name,
BLOB_PRINTF(*oldpkg->version),
BLOB_PRINTF(*newpkg->version));
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
}
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct apk_stats {
unsigned int bytes;
unsigned int packages;
};
static void count_change(struct apk_change *change, struct apk_stats *stats)
{
if (change->newpkg != NULL) {
stats->bytes += change->newpkg->installed_size;
stats->packages ++;
}
if (change->oldpkg != NULL)
stats->packages ++;
}
static void draw_progress(int percent)
{
const int bar_width = apk_get_screen_width() - 7;
int i;
fprintf(stderr, "\e7%3i%% [", percent);
for (i = 0; i < bar_width * percent / 100; i++)
fputc('#', stderr);
for (; i < bar_width; i++)
fputc(' ', stderr);
fputc(']', stderr);
fflush(stderr);
fputs("\e8\e[0K", stderr);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct progress {
struct apk_stats done;
struct apk_stats total;
struct apk_package *pkg;
size_t count;
};
static void progress_cb(void *ctx, size_t progress)
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
{
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct progress *prog = (struct progress *) ctx;
size_t partial = 0, count;
if (prog->pkg != NULL)
partial = muldiv(progress, prog->pkg->installed_size, APK_PROGRESS_SCALE);
count = muldiv(100, prog->done.bytes + prog->done.packages + partial,
prog->total.bytes + prog->total.packages);
if (prog->count != count)
draw_progress(count);
prog->count = count;
}
static int dump_packages(struct apk_changeset *changeset,
int (*cmp)(struct apk_change *change),
const char *msg)
{
struct apk_change *change;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
struct apk_name *name;
print: minor cleanup to indented writer
2011-09-09 17:06:10 +00:00
struct apk_indent indent = { .indent = 2 };
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
int match = 0, i;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
for (i = 0; i < changeset->changes->num; i++) {
change = &changeset->changes->item[i];
if (!cmp(change))
continue;
if (match == 0)
solver: fix indentation of package lists (in interactive mode) broken in commit bfd53b59d2e62e17 (print: minor cleanup to indented writer).
2011-10-29 20:43:50 +00:00
printf("%s:\n", msg);
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
if (change->newpkg != NULL)
name = change->newpkg->name;
else
name = change->oldpkg->name;
apk_print_indented(&indent, APK_BLOB_STR(name->name));
match++;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
if (match)
printf("\n");
return match;
}
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
static int cmp_remove(struct apk_change *change)
{
return change->newpkg == NULL;
}
static int cmp_new(struct apk_change *change)
{
return change->oldpkg == NULL;
}
static int cmp_downgrade(struct apk_change *change)
{
if (change->newpkg == NULL || change->oldpkg == NULL)
return 0;
if (apk_pkg_version_compare(change->newpkg, change->oldpkg)
& APK_VERSION_LESS)
return 1;
return 0;
}
static int cmp_upgrade(struct apk_change *change)
{
if (change->newpkg == NULL || change->oldpkg == NULL)
return 0;
/* Count swapping package as upgrade too - this can happen if
* same package version is used after it was rebuilt against
* newer libraries. Basically, different (and probably newer)
* package, but equal version number. */
if ((apk_pkg_version_compare(change->newpkg, change->oldpkg) &
(APK_VERSION_GREATER | APK_VERSION_EQUAL)) &&
(change->newpkg != change->oldpkg))
return 1;
return 0;
}
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
static int compare_package_topology(const void *p1, const void *p2)
solver, db: run triggers in dependency order fixes #738
2011-09-14 08:30:02 +00:00
{
struct apk_package *pkg1 = *(struct apk_package **) p1;
struct apk_package *pkg2 = *(struct apk_package **) p2;
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
return pkg1->topology_hard - pkg2->topology_hard;
solver, db: run triggers in dependency order fixes #738
2011-09-14 08:30:02 +00:00
}
static void run_triggers(struct apk_database *db)
{
struct apk_package_array *pkgs;
int i;
pkgs = apk_db_get_pending_triggers(db);
if (pkgs == NULL || pkgs->num == 0)
return;
qsort(pkgs->item, pkgs->num, sizeof(struct apk_package *),
solver: preference scoring Should now choose packages better if the best available version is uninstallable for some reason.
2011-10-14 17:48:20 +00:00
compare_package_topology);
solver, db: run triggers in dependency order fixes #738
2011-09-14 08:30:02 +00:00
for (i = 0; i < pkgs->num; i++) {
struct apk_package *pkg = pkgs->item[i];
struct apk_installed_package *ipkg = pkg->ipkg;
*apk_string_array_add(&ipkg->pending_triggers) = NULL;
apk_ipkg_run_script(ipkg, db, APK_SCRIPT_TRIGGER,
ipkg->pending_triggers->item);
apk_string_array_free(&ipkg->pending_triggers);
}
apk_package_array_free(&pkgs);
}
del: fix recursive deletion and messages (after solver merge) Deduce the world dependencies to remove locally, and same for the additional messages about packages not deleted.
2011-09-09 16:41:19 +00:00
int apk_solver_commit_changeset(struct apk_database *db,
struct apk_changeset *changeset,
struct apk_dependency_array *world)
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
{
struct progress prog;
struct apk_change *change;
int i, r = 0, size_diff = 0;
del: fix recursive deletion and messages (after solver merge) Deduce the world dependencies to remove locally, and same for the additional messages about packages not deleted.
2011-09-09 16:41:19 +00:00
if (changeset->changes == NULL)
goto all_done;
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
/* Count what needs to be done */
memset(&prog, 0, sizeof(prog));
for (i = 0; i < changeset->changes->num; i++) {
change = &changeset->changes->item[i];
count_change(change, &prog.total);
if (change->newpkg)
size_diff += change->newpkg->installed_size;
if (change->oldpkg)
size_diff -= change->oldpkg->installed_size;
}
size_diff /= 1024;
if (apk_verbosity > 1 || (apk_flags & APK_INTERACTIVE)) {
r = dump_packages(changeset, cmp_remove,
"The following packages will be REMOVED");
r += dump_packages(changeset, cmp_downgrade,
"The following packages will be DOWNGRADED");
if (r || (apk_flags & APK_INTERACTIVE) || apk_verbosity > 2) {
dump_packages(changeset, cmp_new,
"The following NEW packages will be installed");
dump_packages(changeset, cmp_upgrade,
"The following packages will be upgraded");
printf("After this operation, %d kB of %s\n", abs(size_diff),
(size_diff < 0) ?
"disk space will be freed." :
"additional disk space will be used.");
}
if (apk_flags & APK_INTERACTIVE) {
printf("Do you want to continue [Y/n]? ");
fflush(stdout);
r = fgetc(stdin);
if (r != 'y' && r != 'Y' && r != '\n')
return -1;
}
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
/* Go through changes */
r = 0;
for (i = 0; i < changeset->changes->num; i++) {
change = &changeset->changes->item[i];
print_change(db, change, i, changeset->changes->num);
if (apk_flags & APK_PROGRESS)
draw_progress(prog.count);
prog.pkg = change->newpkg;
if (!(apk_flags & APK_SIMULATE)) {
r = apk_db_install_pkg(db,
change->oldpkg, change->newpkg,
(apk_flags & APK_PROGRESS) ? progress_cb : NULL,
&prog);
if (r != 0)
break;
}
count_change(change, &prog.done);
}
if (apk_flags & APK_PROGRESS)
draw_progress(100);
solver, db: run triggers in dependency order fixes #738
2011-09-14 08:30:02 +00:00
run_triggers(db);
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
del: fix recursive deletion and messages (after solver merge) Deduce the world dependencies to remove locally, and same for the additional messages about packages not deleted.
2011-09-09 16:41:19 +00:00
all_done:
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
apk_dependency_array_copy(&db->world, world);
apk_db_write_config(db);
upgrade: reimplement self-upgrade (after solver merge)
2011-09-14 07:38:26 +00:00
if (r == 0 && !db->performing_self_update) {
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
apk_message("OK: %d packages, %d dirs, %d files",
db->installed.stats.packages,
db->installed.stats.dirs,
db->installed.stats.files);
}
return r;
}
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
static void print_dep_errors(struct apk_database *db, char *label, struct apk_dependency_array *deps)
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
{
int i, print_label = 1;
char buf[256];
apk_blob_t p;
struct apk_indent indent;
for (i = 0; i < deps->num; i++) {
struct apk_dependency *dep = &deps->item[i];
struct apk_package *pkg = (struct apk_package*) dep->name->state_ptr;
if (pkg != NULL && apk_dep_is_satisfied(dep, pkg))
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
continue;
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
if (print_label) {
print_label = 0;
indent.x = printf(" %s:", label);
indent.indent = indent.x + 1;
}
p = APK_BLOB_BUF(buf);
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
apk_blob_push_dep(&p, db, dep);
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
p = apk_blob_pushed(APK_BLOB_BUF(buf), p);
apk_print_indented(&indent, p);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
if (!print_label)
printf("\n");
}
del: fix recursive deletion and messages (after solver merge) Deduce the world dependencies to remove locally, and same for the additional messages about packages not deleted.
2011-09-09 16:41:19 +00:00
void apk_solver_print_errors(struct apk_database *db,
struct apk_package_array *solution,
struct apk_dependency_array *world,
int unsatisfiable)
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
{
int i;
apk_error("%d unsatisfiable dependencies:", unsatisfiable);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
for (i = 0; i < solution->num; i++) {
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
struct apk_package *pkg = solution->item[i];
pkg->name->state_ptr = pkg;
}
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
print_dep_errors(db, "world", world);
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
for (i = 0; i < solution->num; i++) {
struct apk_package *pkg = solution->item[i];
char pkgtext[256];
snprintf(pkgtext, sizeof(pkgtext), PKG_VER_FMT, PKG_VER_PRINTF(solution->item[i]));
solver, db: implement repository pinning Improves /etc/apk/repositories format so you can say: http://nl.alpinelinux.org/alpine/v2.3/main @edge http://nl.alpinelinux.org/alpine/edge/main @testing http://nl.alpinelinux.org/alpine/edge/testing After which you can pin dependencies to these tags using: apk add stableapp newapp@edge bleedingapp@testing Apk will now by default only use the untagged repositories, but adding a tag to specific dependency: 1. will prefer that tag for the name 2. allowing pulling in dependencies from that tag (though, it prefers untagged packages to satisfy deps if possible) fixes #575
2011-10-29 02:18:21 +00:00
print_dep_errors(db, pkgtext, pkg->depends);
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
}
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
int apk_solver_commit(struct apk_database *db,
unsigned short solver_flags,
struct apk_dependency_array *world)
{
struct apk_changeset changeset = {};
struct apk_package_array *solution = NULL;
int r;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
solver: make state pointers completely internal the only bit of information needed in solver commit is the "hard" topology sorting information for trigger ordering. fixes a bug in "apk del" which uses the state pointers to do intermediate calculations between solution solving and commit.
2011-09-14 13:48:28 +00:00
r = apk_solver_solve(db, solver_flags,
solver, db: run triggers in dependency order fixes #738
2011-09-14 08:30:02 +00:00
world, &solution, &changeset);
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
if (r < 0)
return r;
if (r == 0 || (apk_flags & APK_FORCE)) {
/* Success -- or forced installation of bad graph */
solver: return error code if things fail during package install
2011-09-28 11:04:02 +00:00
r = apk_solver_commit_changeset(db, &changeset, world);
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
} else {
/* Failure -- print errors */
del: fix recursive deletion and messages (after solver merge) Deduce the world dependencies to remove locally, and same for the additional messages about packages not deleted.
2011-09-09 16:41:19 +00:00
apk_solver_print_errors(db, solution, world, r);
applets: start using solver code still todo: - 'fix' is missing - 'del -R' does not work - 'upgrade' does not do self-upgrade first ... and a lot of testing.
2011-09-09 13:31:11 +00:00
}
apk_package_array_free(&solution);
return r;
solver: new package selection logic (which is not yet used) * basic code for a backtracking, forward checking dependency satisfier * works better when there are tricky dependencies to solve (when can't just upgrade everything to most preferred versions) * the new code always evaluates all of 'world' constraints (old code just does incremental updates based on heuristics) * is probably somewhat slower than old code (probably unnoticeable difference in most cases) * makes easier to write support for provides and repository pinning * test applet and a bunch of test cases added which uses the new code * from the old feature set install_if is not yet implemented
2011-07-26 13:56:55 +00:00
}