Size: 8085 bytes, 1 line

It's become clear that our approach to evaluating packaging dependencies and constraints needs to become a lot more sophisticated as we've been trying to make packaging metadata more accurately reflect the way we build and test packages. A significant part of the difficulty is dealing with externally produced packages; if a variety of versions are available we may need to iteratively test multiple versions, evaluating their dependencies to find one that is compatible w/ the constraints that may be active on the current image. One method of doing this sort of automated decision making is to cast the problem as a series of boolean expressions, and then apply a SAT solver to find a solution. These notes describe the results of my experiments w/ the minisat solver Stephen posted some time ago.... Notes: -------- 1) The presence of a particular package version is a single boolean variable; True if it's present, False if not. The problem set handed to the SAT solver is a series of clauses; each clause are boolean variables (or their negation) or'd together. All clauses must be true for the solution to exist. The clauses need to encode the fact that only one version of a package may be installed at a time, and also encode all different package dependencies and constraints. 2) Each package has some number of versions, inherently ordered. Only one version of a package may be installed at a time pkg a -> a.1, a.2, a.3, a.4 pkg b -> b.1, b.2, b.3, b.4 Thus for "a": !a.1 | !a.2 !a.1 | !a.3 !a.1 | !a.4 !a.2 | !a.3 !a.2 | !a.4 !a.3 | !a.4 where !a represents the negation of a. This means that for N versions, we have N(N-1)/2 clauses; pruning older non-accessible versions will be required to bound memory consumption. 3) Each version of a package may have dependencies on other packages, either w/ or w/o a version. The version specification will likely not be fully specified (eg multiple versions may satisfy this requirement). 4) dependencies may be of the following types: required: fmri specifies minimum acceptable version if a.1 requires b.2, b.3 or b.4: !a.1 | b.2 | b.3 | b.4 optional: if present, fmri must be at this level or greater if a.1 optionally requires b.3: !a.1 | !b.1 !a.1 | !b.2 incorporate: if present, pkg must match fmri if a.1 incorporates b.3: !a.1 | !b.1 !a.1 | !b.2 !a.1 | !b.4 exclude: if present, pkg must be less that version in fmri: if a.1 excludes b.3, !a.1 | !b.3 !a.1 | !b.4 All of these are linear in the number of package versions either meeting or failing to meet the dependency. 5) To express state, the presence of a package is encoded as a clause. We compute the matching fmris and then construct a clause that matches one of those fmris. Specifying a single version requires that version to be present in the solution; we can also specify current version or newer, or any version of a package. 6) The SAT solver will find a particular solution to our packaging problem, but there is no way of "preferring" newer packages, and preventing the introduction of extraneous unneeded packages. As a result, external optimization in the form of repeated solution attempts w/ additional constraints is necessary. The following algorithm has been implemented: The packaging problem to be solved is expressed as a series of boolean constraints, and a solution obtained. Then, for each fmri appearing in the solution vector, all older versions are excluded; in other words, if a.3 is part of the solution, then subsequent solutions will not contain a.1 or a.2. Then a single vector is added that is the negation of the just found vector, and another solution is found. For example: if solution is a.2, b.3, z.10, we add # first negations of older versions !a.1 !b.1 !b.2 !z.1 !z.2 ... !z.9 # now negate just found solution !a.2 | !b.3 | !z.10 The latter vector requires that the new solution not contain a.2 and b.3 and z.10; since we've excluded older versions we will either get a vector that eliminates one of the packages as unneeded (if dependencies allow) or one that has newer versions of one of the needed pkgs. We repeat the above process until a solution cannot be found; the last found solution must therefore be the most optimal one. The above technique may fail to find the overall optimal solution if newer packages have incorporation dependencies on earlier versions of their dependencies. This is expected to be rare. Pruning the solution space to eliminate older packages is necessary due to rapid solution space growth if there are multiple versions that satisfy dependencies. 7) In order to prevent rapid growth of clause count as the number of versions of packages increases, trimming the solution space is essential. I'm currently using the following techniques: 1) install a new package on existing system identify any existing installed constraints, and trim pkg catalog to eliminate versions outside those constraints. trim pkg catalog to exclude all pkg older than those already installed input to solver is trimmed catalog, and vectors selecting any version of already installed pkgs that meet constraints, plus a vector selected any version of desired pkg. 2) upgrade to latest version of all available pkgs identify any existing installed constraints, and trim pkg catalog to eliminate versions OLDER than those constraints. trim pkg catalog to exclude all pkg older than those already installed input to solver is trimmed catalog, and vectors selecting any version of already installed pkgs 3) upgrade to specified version identify any existing installed constraints, and trim pkg catalog to eliminate versions OLDER than those constraints. trim pkg catalog to exclude all pkg older than those already installed input to solver is trimmed catalog, and vectors selecting any version of already installed pkgs, plus vector(s) selecting desired constraint(s). 8) One of the most difficult aspects of using a SAT solver is providing a reasonable error message when no solution can be found. Some techniques that I'm experimenting with include: Explicitly checking for obvious non-starters (pkg version earlier than already installed, pkg version that violates constraints on system) prior to passing to SAT solver. This is needed to permit trimming in any case. Using the pruned catalog to quickly evaluate the effect of constraints. Implementation details ------------------------- combine catalog object w/ list of installed pkgs and proposed changes: class pkg_solver(object): def __init__(self, catalog, existing_fmris): def solve_install(existing_freezes, proposed_fmris): """tries to find solution that adds specified fmris to existing set; any existing packages containing incorporate dependencies which are at most only depended on by name (no version) are frozen.""" def solve_reinstall(existing_freezes, proposed_fmris): """tries to find solution that replaces existing version with specified version; this one allows stuff to go backwards if specified on command line""" def solve_uninstall(existing_freezes, proposed_fmris): """tries to remove specified package""" def solve_update_all(existing_freezes): """find most recent version of all packages""" solve* routines return a list of tuples (old_version, new_version) for each fmri that is changing; new installs have None as old_version, removals have None as new_version. A returned empty list indicates that no action is needed. A failure to find a solution throws an exception, pkg_solver.No_Solution_Found.

Please Confirm