NAME¶

libsolv-pool - Libsolv's pool object

PUBLIC ATTRIBUTES¶

void *appdata

Stringpool ss

Reldep *rels

int nrels

Repo **repos

int nrepos

int urepos

Repo *installed

Solvable *solvables

int nsolvables

int disttype

Id *whatprovidesdata

Map *considered

int debugmask

Datapos pos

Queue pooljobs

CREATION AND DESTRUCTION¶

Pool *pool_create();

Create a new instance of a pool.

void pool_free(Pool *pool);

Free a pool and all of the data it contains, e.g. the solvables, repositories, strings.

DEBUGGING AND ERROR REPORTING¶

void pool_debug(Pool *pool, int type, const char *format, ...);

void pool_setdebuglevel(Pool *pool, int level);

void pool_setdebugmask(Pool *pool, int mask);

int pool_error(Pool *pool, int ret, const char *format, ...);

extern char *pool_errstr(Pool *pool);

void pool_setdebugcallback(Pool *pool, void (*debugcallback)(Pool *, void *data, int type, const char *str), void *debugcallbackdata);

POOL CONFIGURATION¶

int pool_setdisttype(Pool *pool, int disttype);

int pool_set_flag(Pool *pool, int flag, int value);

int pool_get_flag(Pool *pool, int flag);

void pool_set_rootdir(Pool *pool, const char *rootdir);

const char *pool_get_rootdir(Pool *pool);

char *pool_prepend_rootdir(Pool *pool, const char *dir);

char *pool_prepend_rootdir_tmp(Pool *pool, const char *dir);

void pool_set_installed(Pool *pool, Repo *repo);

void pool_set_languages(Pool *pool, const char **languages, int nlanguages);

void pool_setarch(Pool *pool, const char *arch);

void pool_setarchpolicy(Pool *, const char *);

void pool_addvendorclass(Pool *pool, const char **vendorclass);

void pool_setvendorclasses(Pool *pool, const char **vendorclasses);

void pool_set_custom_vendorcheck(Pool *pool, int (*vendorcheck)(Pool *, Solvable *, Solvable *));

void pool_setloadcallback(Pool *pool, int (*cb)(Pool *, Repodata *, void *), void *loadcbdata);

void pool_setnamespacecallback(Pool *pool, Id (*cb)(Pool *, void *, Id, Id), void *nscbdata);

ID POOL MANAGEMENT¶

Id pool_str2id(Pool *pool, const char *str, int create);

Id pool_strn2id(Pool *pool, const char *str, unsigned int len, int create);

Id pool_rel2id(Pool *pool, Id name, Id evr, int flags, int create);

Id pool_id2langid(Pool *pool, Id id, const char *lang, int create);

const char *pool_id2str(const Pool *pool, Id id);

const char *pool_id2rel(const Pool *pool, Id id);

const char *pool_id2evr(const Pool *pool, Id id);

const char *pool_dep2str(Pool *pool, Id id);

void pool_freeidhashes(Pool *pool);

SOLVABLE FUNCTIONS¶

Solvable *pool_id2solvable(const Pool *pool, Id p);

Convert a solvable Id into a pointer to the solvable data. Note that the pointer may become invalid if new solvables are created or old solvables deleted, because the array storing all solvables may get reallocated.

const char *pool_solvid2str(Pool *pool, Id p);

Return a string representing the solvable with the Id p. The string will be some canonical representation of the solvable, usually a combination of the name, the version, and the architecture.

const char *pool_solvable2str(Pool *pool, Solvable *s);

Same as pool_solvid2str, but instead of the Id, a pointer to the solvable is passed.

DEPENDENCY MATCHING¶

int pool_evrcmp(const Pool *pool, Id evr1id, Id evr2id, int mode);

int pool_evrcmp_str(const Pool *pool, const char *evr1, const char *evr2, int mode);

int pool_evrmatch(const Pool *pool, Id evrid, const char *epoch, const char *version, const char *release);

int pool_match_dep(Pool *pool, Id d1, Id d2);

int pool_match_nevr(Pool *pool, Solvable *s, Id d);

WHATPROVIDES INDEX¶

void pool_createwhatprovides(Pool *pool);

Create an index that maps dependency Ids to sets of packages that provide the dependency.

void pool_freewhatprovides(Pool *pool);

Free the whatprovides index to save memory.

Id pool_whatprovides(Pool *pool, Id d);

Return an offset into the Pool’s whatprovidesdata array. The solvables with the Ids stored starting at that offset provide the dependency d. The solvable list is zero terminated.

Id *pool_whatprovides_ptr(Pool *pool, Id d);

Instead of returning the offset, return the pointer to the Ids stored at that offset. Note that this pointer has a very limit validity time, as any call that adds new values to the whatprovidesdata area may reallocate the array.

Id pool_queuetowhatprovides(Pool *pool, Queue *q);

Add the contents of the Queue q to the end of the whatprovidesdata array, returning the offset into the array.

void pool_addfileprovides(Pool *pool);

Some package managers like rpm allow dependencies on files contained in other packages. To allow libsolv to deal with those dependencies in an efficient way, you need to call the addfileprovides method after creating and reading all repositories. This method will scan all dependency for file names and then scan all packages for matching files. If a filename has been matched, it will be added to the provides list of the corresponding package.

void pool_addfileprovides_queue(Pool *pool, Queue *idq, Queue *idqinst);

Same as pool_addfileprovides, but the added Ids are returned in two Queues, idq for all repositories except the one containing the “installed” packages, idqinst for the latter one. This information can be stored in the meta section of the repositories to speed up the next time the repository is loaded and addfileprovides is called

void pool_set_whatprovides(pool, Id id, Id offset);

Manually set an entry in the whatprovides index. You’ll never do this for package dependencies, as those entries are created by calling the pool_createwhatprovides() function. But this function is useful for namespace provides if you do not want to use a namespace callback to lazily set the provides. The offset argument is a offset in the whatprovides array, thus you can use “1” as a false value and “2” as true value.

void pool_flush_namespaceproviders(Pool *pool, Id ns, Id evr);

Clear the cache of the providers for namespace dependencies matching namespace ns. If the evr argument is non-zero, the namespace dependency for exactly that dependency is cleared, otherwise all matching namespace dependencies are cleared. See the section about Namespace dependencies for further information.

void pool_add_fileconflicts_deps(Pool *pool, Queue *conflicts);

Some package managers like rpm report conflicts when a package installation overwrites a file of another installed package with different content. As file content information is not stored in the repository metadata, those conflicts can only be detected after the packages are downloaded. Libsolv provides a function to check for such conflicts, pool_findfileconflicts(). If conflicts are found, they can be added as special REL_FILECONFLICT provides dependencies, so that the solver will know about the conflict when it is re-run.

UTILITY FUNCTIONS¶

char *pool_alloctmpspace(Pool *pool, int len);

Allocate space on the pool’s temporary space area. This space has a limited lifetime, it will be automatically freed after a fixed amount (currently 16) of other pool_alloctmpspace() calls are done.

void pool_freetmpspace(Pool *pool, const char *space);

Give the space allocated with pool_alloctmpspace back to the system. You do not have to use this function, as the space is automatically reclaimed, but it can be useful to extend the lifetime of other pointers to the pool’s temporary space area.

const char *pool_bin2hex(Pool *pool, const unsigned char *buf, int len);

Convert some binary data to hexadecimal, returning a string allocated in the pool’s temporary space area.

char *pool_tmpjoin(Pool *pool, const char *str1, const char *str2, const char *str3);

Join three strings and return the result in the pool’s temporary space area. You can use NULL arguments if you just want to join less strings.

char *pool_tmpappend(Pool *pool, const char *str1, const char *str2, const char *str3);

Like pool_tmpjoin(), but if the first argument is the last allocated space in the pool’s temporary space area, it will be replaced with the result of the join and no new temporary space slot will be used. Thus you can join more than three strings by a combination of one pool_tmpjoin() and multiple pool_tmpappend() calls. Note that the str1 pointer is no longer usable after the call.

DATA LOOKUP¶

const char *pool_lookup_str(Pool *pool, Id solvid, Id keyname);

unsigned long long pool_lookup_num(Pool *pool, Id solvid, Id keyname, unsigned long long notfound);

Id pool_lookup_id(Pool *pool, Id solvid, Id keyname);

int pool_lookup_idarray(Pool *pool, Id solvid, Id keyname, Queue *q);

int pool_lookup_void(Pool *pool, Id solvid, Id keyname);

const char *pool_lookup_checksum(Pool *pool, Id solvid, Id keyname, Id *typep);

const unsigned char *pool_lookup_bin_checksum(Pool *pool, Id solvid, Id keyname, Id *typep);

const char *pool_lookup_deltalocation(Pool *pool, Id solvid, unsigned int *medianrp);

void pool_search(Pool *pool, Id solvid, Id keyname, const char *match, int flags, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv), void *cbdata);

JOB AND SELECTION FUNCTIONS¶

A Job consists of two Ids, how and what. The how part describes the action, the job flags, and the selection method while the what part is in input for the selection. A Selection is a queue consisting of multiple jobs (thus the number of elements in the queue must be a multiple of two). See the Solver manpage for more information about jobs.

const char *pool_job2str(Pool *pool, Id how, Id what, Id flagmask);

Convert a job into a string. Useful for debugging purposes. The flagmask can be used to mask the flags of the job, use “0” if you do not want to see such flags, “-1” to see all flags, or a combination of the flags you want to see.

void pool_job2solvables(Pool *pool, Queue *pkgs, Id how, Id what);

Return a list of solvables that the specified job selects.

int pool_isemptyupdatejob(Pool *pool, Id how, Id what);

Return “1” if the job is an update job that does not work with any installed package, i.e. the job is basically a no-op. You can use this to turn no-op update jobs into install jobs (as done by package managers like “zypper”).

const char *pool_selection2str(Pool *pool, Queue *selection, Id flagmask);

Convert a selection into a string. Useful for debugging purposes. See the pool_job2str() function for the flagmask argument.

ODDS AND ENDS¶

void pool_freeallrepos(Pool *pool, int reuseids);

Free all repos from the pool (including all solvables). If reuseids is true, all Ids of the solvables are free to be reused the next time solvables are created.

void pool_clear_pos(Pool *pool);

Clear the data position stored in the pool.

ARCHITECTURE POLICIES¶

An architecture policy defines a list of architectures that can be installed on the system, and also the relationship between them (i.e. the ordering). Architectures can be delimited with three different characters:

':'

'>'

'='

An example would be 'x86_64:i686=athlon>i586'. This means that x86_64 packages can only be replaced by other x86_64 packages, i686 packages can be replaced by i686 and i586 packages (but i686 packages will be preferred) and athlon is another name for the i686 architecture.

You can turn off the architecture replacement checks with the Solver’s SOLVER_FLAG_ALLOW_ARCHCHANGE flag.

VENDOR POLICIES¶

Different vendors often compile packages with different features, so Libsolv only replace installed packages of one vendor with packages coming from the same vendor. Also, while the version of a package is normally defined by the upstream project, the release part of the version is set by the vendor’s package maintainer, so it’s not meaningful to do version comparisons for packages coming from different vendors.

Vendor in this case means the SOLVABLE_VENDOR string stored in each solvable. Sometimes a vendor changes names, or multiple vendors form a group that coordinate their package building, so libsolv offers a way to define that a group of vendors are compatible. You do that be defining vendor equivalence classes, packages from a vendor from one class may be replaced with packages from all the other vendors in the class.

There can be multiple equivalence classes, the set of allowed vendor changes for an installed package is calculated by building the union of all of the equivalence classes the vendor of the installed package is part of.

You can turn off the architecture replacement checks with the Solver’s SOLVER_FLAG_ALLOW_VENDORCHANGE flag.

BOOLEAN DEPENDENCIES¶

Boolean Dependencies allow to build complex expressions from simple dependencies. Note that depending on the package manager only a subset of those may be useful. For example, debian currently only allows an "OR" expression.

REL_OR

REL_AND

REL_WITH

REL_COND

REL_UNLESS

REL_ELSE

Each sub-dependency of a boolean dependency can in turn be a boolean dependency, so you can chain them to create complex dependencies.

NAMESPACE DEPENDENCIES¶

Namespace dependencies can be used to implement dependencies on attributes external to libsolv. An example would be a dependency on the language set by the user. This types of dependencies are usually only used for “Conflicts” or “Supplements” dependencies, as the underlying package manager does not know how to deal with them.

If the library needs to evaluate a namespace dependency, it calls the namespace callback function set in the pool. The callback function can return a set of packages that “provide” the dependency. If the dependency is provided by the system, the returned set should consist of just the system solvable (Solvable Id 1).

The returned set of packages must be returned as offset into the whatprovidesdata array. You can use the pool_queuetowhatprovides function to convert a queue into such an offset. To ease programming the callback function, the return values “0” and “1” are not interpreted as an offset. “0” means that no package is in the return set, “1” means that just the system solvable is in the set.

The returned set is cached, so that for each namespace dependency the callback is just called once. If you need to flush the cache (maybe because the user has selected a different language), use the pool_flush_namespaceproviders() function.

AUTHOR¶

Michael Schroeder <mls@suse.de>