solver.c 27.2 KB
Newer Older
1
/* solver.c - Alpine Package Keeper (APK)
2
 * Up- and down-propagating, forwarding checking, deductive dependency solver.
3
 *
4
 * Copyright (C) 2008-2013 Timo Teräs <timo.teras@iki.fi>
5
6
7
8
9
10
11
 * 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.
 */

12
#include <stdint.h>
13
#include <unistd.h>
14
#include <strings.h>
15
16
17
18
19
#include "apk_defines.h"
#include "apk_database.h"
#include "apk_package.h"
#include "apk_solver.h"

Timo Teräs's avatar
Timo Teräs committed
20
21
#include "apk_print.h"

22
23
24
//#define DEBUG_PRINT

#ifdef DEBUG_PRINT
25
26
27
28
29
30
#include <stdio.h>
#define dbg_printf(args...) fprintf(stderr, args)
#else
#define dbg_printf(args...)
#endif

31
#define ASSERT(cond, fmt...)	if (!(cond)) { apk_error(fmt); *(char*)NULL = 0; }
32

33
34
struct apk_solver_state {
	struct apk_database *db;
35
36
37
38
	struct apk_changeset *changeset;
	struct list_head dirty_head;
	struct list_head unresolved_head;
	unsigned int errors;
39
	unsigned int solver_flags_inherit;
40
41
42
	unsigned int pinning_inherit;
	unsigned int default_repos;
	unsigned prefer_pinning : 1;
43
};
44

45
46
47
static struct apk_provider provider_none = {
	.pkg = NULL,
	.version = &apk_null_blob
48
49
};

50
51
52
void apk_solver_set_name_flags(struct apk_name *name,
			       unsigned short solver_flags,
			       unsigned short solver_flags_inheritable)
53
{
54
	struct apk_provider *p;
55

56
57
	foreach_array_item(p, name->providers) {
		struct apk_package *pkg = p->pkg;
58
59
60
		pkg->ss.solver_flags |= solver_flags;
		pkg->ss.solver_flags_inheritable |= solver_flags_inheritable;
	}
61
62
}

63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
static int get_tag(struct apk_database *db, unsigned int pinning_mask, unsigned int repos)
{
	int i;

	for (i = 0; i < db->num_repo_tags; i++) {
		if (!(BIT(i) & pinning_mask))
			continue;
		if (db->repo_tags[i].allowed_repos & repos)
			return i;
	}
	return APK_DEFAULT_REPOSITORY_TAG;
}

static unsigned int get_pkg_repos(struct apk_database *db, struct apk_package *pkg)
{
	return pkg->repos | (pkg->ipkg ? db->repo_tags[pkg->ipkg->repository_tag].allowed_repos : 0);
}

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_package *parent_pkg))
{
85
86
87
	struct apk_name *name = pkg->name, *name0, **pname0;
	struct apk_dependency *dep;
	struct apk_provider *p0;
88

89
90
	foreach_array_item(pname0, pkg->name->rinstall_if) {
		name0 = *pname0;
91
		dbg_printf(PKG_VER_FMT ": rinstall_if %s\n", PKG_VER_PRINTF(pkg), name0->name);
92
93
94
95
96
		foreach_array_item(p0, name0->providers) {
			foreach_array_item(dep, p0->pkg->install_if) {
				if (dep->name == name && apk_dep_is_provided(dep, p0)) {
					/* pkg depends (via install_if) on pkg0 */
					cb(ss, p0->pkg, pkg);
97
					break;
98
				}
99
100
101
102
103
			}
		}
	}
}

104
105
106
107
108
109
110
111
static void mark_error(struct apk_solver_state *ss, struct apk_package *pkg)
{
	if (pkg == NULL || pkg->ss.error)
		return;
	pkg->ss.error = 1;
	ss->errors++;
}

112
static void queue_dirty(struct apk_solver_state *ss, struct apk_name *name)
113
{
114
115
116
	if (list_hashed(&name->ss.dirty_list) || name->ss.locked ||
	    (name->ss.requirers == 0 && !name->ss.reevaluate_iif))
		return;
117

118
119
	dbg_printf("queue_dirty: %s\n", name->name);
	list_add_tail(&name->ss.dirty_list, &ss->dirty_head);
120
121
}

122
static void queue_unresolved(struct apk_solver_state *ss, struct apk_name *name)
123
{
124
	int want;
125

126
127
	if (name->ss.locked)
		return;
128

129
	want = (name->ss.requirers > 0) || (name->ss.has_iif);
130
	dbg_printf("queue_unresolved: %s, want=%d (requirers=%d, has_iif=%d)\n", name->name, want, name->ss.requirers, name->ss.has_iif);
131
132
133
134
	if (want && !list_hashed(&name->ss.unresolved_list))
		list_add(&name->ss.unresolved_list, &ss->unresolved_head);
	else if (!want && list_hashed(&name->ss.unresolved_list))
		list_del_init(&name->ss.unresolved_list);
135
136
}

137
static void reevaluate_reverse_deps(struct apk_solver_state *ss, struct apk_name *name)
138
{
139
140
141
142
143
144
145
146
147
	struct apk_name **pname0, *name0;

	foreach_array_item(pname0, name->rdepends) {
		name0 = *pname0;
		if (!name0->ss.seen)
			continue;
		name0->ss.reevaluate_deps = 1;
		queue_dirty(ss, name0);
	}
148
}
149

150
static void reevaluate_reverse_installif(struct apk_solver_state *ss, struct apk_name *name)
151
{
152
153
154
155
156
157
	struct apk_name **pname0, *name0;

	foreach_array_item(pname0, name->rinstall_if) {
		name0 = *pname0;
		if (!name0->ss.seen)
			continue;
158
159
		if (name0->ss.no_iif)
			continue;
160
161
162
		name0->ss.reevaluate_iif = 1;
		queue_dirty(ss, name0);
	}
163
164
}

165
static void disqualify_package(struct apk_solver_state *ss, struct apk_package *pkg, const char *reason)
166
{
167
	struct apk_dependency *p;
168

169
	dbg_printf("disqualify_package: " PKG_VER_FMT " (%s)\n", PKG_VER_PRINTF(pkg), reason);
170
	pkg->ss.pkg_selectable = 0;
171
172
173
174
	reevaluate_reverse_deps(ss, pkg->name);
	foreach_array_item(p, pkg->provides)
		reevaluate_reverse_deps(ss, p->name);
	reevaluate_reverse_installif(ss, pkg->name);
175
176
}

177
static int dependency_satisfiable(struct apk_solver_state *ss, struct apk_dependency *dep)
178
{
179
	struct apk_name *name = dep->name;
180
	struct apk_provider *p;
181

182
183
	if (name->ss.locked)
		return apk_dep_is_provided(dep, &name->ss.chosen);
184

185
186
	if (name->ss.requirers == 0 && apk_dep_is_provided(dep, &provider_none))
		return TRUE;
187

188
	foreach_array_item(p, name->providers)
189
		if (p->pkg->ss.pkg_selectable && apk_dep_is_provided(dep, p))
190
			return TRUE;
191

192
	return FALSE;
193
194
}

195
static void discover_name(struct apk_solver_state *ss, struct apk_name *name)
196
{
197
	struct apk_database *db = ss->db;
198
199
200
	struct apk_name **pname0;
	struct apk_provider *p;
	struct apk_dependency *dep;
201
	unsigned int repos;
202

203
204
	if (name->ss.seen)
		return;
205

206
	name->ss.seen = 1;
207
	name->ss.no_iif = 1;
208
209
	foreach_array_item(p, name->providers) {
		struct apk_package *pkg = p->pkg;
210
		if (pkg->ss.seen)
211
			continue;
212

213
		pkg->ss.seen = 1;
214
215
216
		pkg->ss.iif_failed = (pkg->install_if->num == 0);
		name->ss.no_iif &= pkg->ss.iif_failed;

217
218
		pkg->ss.pinning_allowed = APK_DEFAULT_PINNING_MASK;
		pkg->ss.pinning_preferred = APK_DEFAULT_PINNING_MASK;
219
220
221
222
223
		pkg->ss.pkg_available =
			(pkg->filename != NULL) ||
			(pkg->installed_size == 0) ||
			(pkg->repos & db->available_repos);
		pkg->ss.pkg_selectable = pkg->ss.pkg_available || pkg->ipkg;
224
225

		repos = get_pkg_repos(db, pkg);
226
227
228
229
230
		pkg->ss.tag_preferred =
			(pkg->filename != NULL) ||
			(pkg->installed_size == 0) ||
			!!(repos & ss->default_repos);
		pkg->ss.tag_ok = pkg->ss.tag_preferred || pkg->ipkg;
231

232
233
		foreach_array_item(dep, pkg->depends) {
			discover_name(ss, dep->name);
234
			pkg->ss.max_dep_chain = max(pkg->ss.max_dep_chain,
235
236
						    dep->name->ss.max_dep_chain+1);
		}
237
		name->ss.max_dep_chain = max(name->ss.max_dep_chain, pkg->ss.max_dep_chain);
238

239
		dbg_printf("discover " PKG_VER_FMT ": tag_ok=%d, tag_pref=%d max_dep_chain=%d selectable=%d\n",
240
241
242
			PKG_VER_PRINTF(pkg),
			pkg->ss.tag_ok,
			pkg->ss.tag_preferred,
243
			pkg->ss.max_dep_chain,
244
			pkg->ss.pkg_selectable);
245
	}
246
247
	foreach_array_item(pname0, name->rinstall_if)
		discover_name(ss, *pname0);
248
249
}

250
static void name_requirers_changed(struct apk_solver_state *ss, struct apk_name *name)
251
{
252
	queue_unresolved(ss, name);
253
	reevaluate_reverse_installif(ss, name);
254
	queue_dirty(ss, name);
255
256
}

257
258
259
260
261
262
263
264
static void inherit_pinning(struct apk_solver_state *ss, struct apk_package *pkg, unsigned int pinning, int prefer)
{
	unsigned int repo_mask = apk_db_get_pinning_mask_repos(ss->db, pinning);
	unsigned int repos = get_pkg_repos(ss->db, pkg);

	pkg->ss.pinning_allowed |= pinning;
	pkg->ss.tag_ok |= !!(repos & repo_mask);
	if (prefer) {
265
		pkg->ss.pinning_preferred = pinning;
266
267
268
269
		pkg->ss.tag_preferred = !!(repos & apk_db_get_pinning_mask_repos(ss->db, pkg->ss.pinning_preferred));
	}
}

270
static void apply_constraint(struct apk_solver_state *ss, struct apk_package *ppkg, struct apk_dependency *dep)
271
{
272
	struct apk_name *name = dep->name;
273
	struct apk_provider *p0;
274
	unsigned int solver_flags_inherit = ss->solver_flags_inherit;
275
	int is_provided;
276

277
	dbg_printf("    apply_constraint: %s%s%s" BLOB_FMT "\n",
278
279
280
281
282
283
		dep->conflict ? "!" : "",
		name->name,
		apk_version_op_string(dep->result_mask),
		BLOB_PRINTF(*dep->version));

	name->ss.requirers += !dep->conflict;
284
285
	if (name->ss.requirers == 1 && !dep->conflict)
		name_requirers_changed(ss, name);
286

287
	foreach_array_item(p0, name->providers) {
288
		struct apk_package *pkg0 = p0->pkg;
289

290
		is_provided = apk_dep_is_provided(dep, p0);
291
		dbg_printf("    apply_constraint: provider: %s-" BLOB_FMT ": %d\n",
292
			pkg0->name->name, BLOB_PRINTF(*p0->version), is_provided);
293

294
		pkg0->ss.conflicts += !is_provided;
295
		if (unlikely(pkg0->ss.pkg_selectable && pkg0->ss.conflicts))
296
			disqualify_package(ss, pkg0, "conflicting dependency");
297

298
299
300
		if (is_provided) {
			pkg0->ss.solver_flags |= solver_flags_inherit;
			pkg0->ss.solver_flags_inheritable |= solver_flags_inherit;
301
302
303
304
305
306
			inherit_pinning(ss, pkg0, ss->pinning_inherit, ss->prefer_pinning);

			dbg_printf(PKG_VER_FMT ": tag_ok=%d, tag_pref=%d\n",
				PKG_VER_PRINTF(pkg0),
				pkg0->ss.tag_ok,
				pkg0->ss.tag_preferred);
307
		}
308
	}
309
310
}

311
312
313
314
315
static void exclude_non_providers(struct apk_solver_state *ss, struct apk_name *name, struct apk_name *must_provide)
{
	struct apk_provider *p;
	struct apk_dependency *d;

316
317
318
	if (name == must_provide)
		return;

319
320
321
	dbg_printf("%s must provide %s\n", name->name, must_provide->name);

	foreach_array_item(p, name->providers) {
322
		if (p->pkg->name == must_provide || !p->pkg->ss.pkg_selectable)
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
			goto next;
		foreach_array_item(d, p->pkg->provides)
			if (d->name == must_provide)
				goto next;
		disqualify_package(ss, p->pkg, "provides transitivity");
	next: ;
	}
}

static inline void merge_index(unsigned short *index, int num_options)
{
	if (*index == num_options)
		*index = num_options + 1;
}

static inline int merge_index_complete(unsigned short *index, int num_options)
{
	int ret;

	ret = (*index == num_options);
	*index = 0;

	return ret;
}

348
static void reconsider_name(struct apk_solver_state *ss, struct apk_name *name)
349
{
350
	struct apk_name *name0, **pname0;
351
	struct apk_dependency *dep;
352
	struct apk_package *first_candidate = NULL, *pkg;
353
354
	struct apk_provider *p;
	int reevaluate_deps, reevaluate_iif;
355
	int num_options = 0, num_tag_not_ok = 0, has_iif = 0, no_iif = 1;
356

357
	dbg_printf("reconsider_name: %s\n", name->name);
358

359
360
	reevaluate_deps = name->ss.reevaluate_deps;
	reevaluate_iif = name->ss.reevaluate_iif;
361
	name->ss.reevaluate_deps = 0;
362
	name->ss.reevaluate_iif = 0;
363

364
365
	/* propagate down by merging common dependencies and
	 * applying new constraints */
366
	foreach_array_item(p, name->providers) {
367
		/* check if this pkg's dependencies have become unsatisfiable */
368
		pkg = p->pkg;
Timo Teräs's avatar
Timo Teräs committed
369
		pkg->ss.dependencies_merged = 0;
370
		if (reevaluate_deps) {
371
			if (!pkg->ss.pkg_selectable)
372
				continue;
373
			foreach_array_item(dep, pkg->depends) {
374
375
376
377
378
379
				if (!dependency_satisfiable(ss, dep)) {
					disqualify_package(ss, pkg, "dependency no longer satisfiable");
					break;
				}
			}
		}
380
		if (!pkg->ss.pkg_selectable)
381
			continue;
382

383
384
385
		if (reevaluate_iif &&
		    (pkg->ss.iif_triggered == 0 &&
		     pkg->ss.iif_failed == 0)) {
386
			pkg->ss.iif_triggered = 1;
387
			pkg->ss.iif_failed = 0;
388
			foreach_array_item(dep, pkg->install_if) {
389
390
391
392
393
394
				if (!dep->name->ss.locked) {
					pkg->ss.iif_triggered = 0;
					pkg->ss.iif_failed = 0;
					break;
				}
				if (!apk_dep_is_provided(dep, &dep->name->ss.chosen)) {
395
					pkg->ss.iif_triggered = 0;
396
					pkg->ss.iif_failed = 1;
397
					break;
398
				}
399
400
			}
		}
401
		has_iif |= pkg->ss.iif_triggered;
402
		no_iif  &= pkg->ss.iif_failed;
Timo Teräs's avatar
Timo Teräs committed
403

404
		if (name->ss.requirers == 0)
405
			continue;
406

407
		/* merge common dependencies */
Timo Teräs's avatar
Timo Teräs committed
408
		pkg->ss.dependencies_merged = 1;
409
410
		if (first_candidate == NULL)
			first_candidate = pkg;
411
412
413
414
415
416
417
418
419
420

		/* FIXME: can merge also conflicts */
		foreach_array_item(dep, pkg->depends)
			if (!dep->conflict)
				merge_index(&dep->name->ss.merge_depends, num_options);

		merge_index(&pkg->name->ss.merge_provides, num_options);
		foreach_array_item(dep, pkg->provides)
			if (dep->version != &apk_null_blob)
				merge_index(&dep->name->ss.merge_provides, num_options);
421
422
423

		num_tag_not_ok += !pkg->ss.tag_ok;
		num_options++;
424
	}
425
	name->ss.has_options = (num_options > 1 || num_tag_not_ok > 0);
426
	name->ss.has_iif = has_iif;
427
	name->ss.no_iif = no_iif;
428
429
	queue_unresolved(ss, name);

430
	if (first_candidate != NULL) {
431
		pkg = first_candidate;
432
433
434
		foreach_array_item(p, name->providers)
			p->pkg->ss.dependencies_used = p->pkg->ss.dependencies_merged;

435
		/* propagate down common dependencies */
436
437
		if (num_options == 1) {
			/* FIXME: keeps increasing counts, use bit fields instead? */
438
439
440
			foreach_array_item(dep, pkg->depends)
				if (merge_index_complete(&dep->name->ss.merge_depends, num_options))
					apply_constraint(ss, pkg, dep);
441
442
		} else {
			/* FIXME: could merge versioning bits too */
443
			foreach_array_item(dep, pkg->depends) {
444
				name0 = dep->name;
445
446
				if (merge_index_complete(&name0->ss.merge_depends, num_options) &&
				    name0->ss.requirers == 0) {
447
					/* common dependency name with all */
448
449
450
451
					dbg_printf("%s common dependency: %s\n",
						   name->name, name0->name);
					name0->ss.requirers++;
					name_requirers_changed(ss, name0);
452
453
				}
			}
Timo Teräs's avatar
Timo Teräs committed
454
		}
455
456
457
458
459
460
461

		/* provides transitivity */
		if (merge_index_complete(&pkg->name->ss.merge_provides, num_options))
			exclude_non_providers(ss, pkg->name, name);
		foreach_array_item(dep, pkg->provides)
			if (merge_index_complete(&dep->name->ss.merge_provides, num_options))
				exclude_non_providers(ss, dep->name, name);
Timo Teräs's avatar
Timo Teräs committed
462
	}
463

464
465
466
467
468
469
470
471
472
473
474
	name->ss.reverse_deps_done = 1;
	foreach_array_item(pname0, name->rdepends) {
		name0 = *pname0;
		if (name0->ss.seen && !name0->ss.locked) {
			name->ss.reverse_deps_done = 0;
			break;
		}
	}

	dbg_printf("reconsider_name: %s [finished], has_options=%d, reverse_deps_done=%d\n",
		name->name, name->ss.has_options, name->ss.reverse_deps_done);
475
476
}

477
478
static int compare_providers(struct apk_solver_state *ss,
			     struct apk_provider *pA, struct apk_provider *pB)
479
{
480
481
	struct apk_database *db = ss->db;
	struct apk_package *pkgA = pA->pkg, *pkgB = pB->pkg;
482
	unsigned int solver_flags;
483
	int r;
484

485
486
487
	/* Prefer existing package */
	if (pkgA == NULL || pkgB == NULL)
		return (pkgA != NULL) - (pkgB != NULL);
488

489
490
491
492
493
494
495
496
497
	/* Latest version required? */
	solver_flags = pkgA->ss.solver_flags | pkgB->ss.solver_flags;
	if ((solver_flags & APK_SOLVERF_LATEST) &&
	    (pkgA->ss.pinning_allowed == APK_DEFAULT_PINNING_MASK) &&
	    (pkgB->ss.pinning_allowed == APK_DEFAULT_PINNING_MASK)) {
		/* Prefer allowed pinning */
		r = (int)pkgA->ss.tag_ok - (int)pkgB->ss.tag_ok;
		if (r)
			return r;
498

499
500
		/* Prefer available */
		if (solver_flags & (APK_SOLVERF_AVAILABLE | APK_SOLVERF_REINSTALL)) {
501
			r = (int)pkgA->ss.pkg_available - (int)pkgB->ss.pkg_available;
502
503
504
505
506
			if (r)
				return r;
		}
	} else {
		/* Prefer without errors */
507
		r = (int)pkgA->ss.pkg_selectable - (int)pkgB->ss.pkg_selectable;
508
509
		if (r)
			return r;
Timo Teräs's avatar
Timo Teräs committed
510

511
512
513
514
515
		/* Prefer those that were in last dependency merging group */
		r = (int)pkgA->ss.dependencies_used - (int)pkgB->ss.dependencies_used;
		if (r)
			return r;
		r = pkgB->ss.conflicts - pkgA->ss.conflicts;
Timo Teräs's avatar
Timo Teräs committed
516
517
518
		if (r)
			return r;

519
520
521
522
523
524
		/* Prefer installed on self-upgrade */
		if (db->performing_self_update && !(solver_flags & APK_SOLVERF_UPGRADE)) {
			r = (pkgA->ipkg != NULL) - (pkgB->ipkg != NULL);
			if (r)
				return r;
		}
525

526
527
		/* Prefer allowed pinning */
		r = (int)pkgA->ss.tag_ok - (int)pkgB->ss.tag_ok;
528
529
		if (r)
			return r;
530

531
532
		/* Prefer available */
		if (solver_flags & (APK_SOLVERF_AVAILABLE | APK_SOLVERF_REINSTALL)) {
533
			r = (int)pkgA->ss.pkg_available - (int)pkgB->ss.pkg_available;
534
535
536
			if (r)
				return r;
		}
537

538
539
		/* Prefer preferred pinning */
		r = (int)pkgA->ss.tag_preferred - (int)pkgB->ss.tag_preferred;
540
541
		if (r)
			return r;
542
543
544
545
546
547
548

		/* Prefer installed */
		if (!(solver_flags & APK_SOLVERF_UPGRADE)) {
			r = (pkgA->ipkg != NULL) - (pkgB->ipkg != NULL);
			if (r)
				return r;
		}
549
	}
550

551
552
553
554
555
556
557
	/* Select latest by requested name */
	switch (apk_version_compare_blob(*pA->version, *pB->version)) {
	case APK_VERSION_LESS:
		return -1;
	case APK_VERSION_GREATER:
		return 1;
	}
558

559
560
561
562
563
564
565
566
567
	/* Select latest by principal name */
	if (pkgA->name == pkgB->name) {
		switch (apk_version_compare_blob(*pkgA->version, *pkgB->version)) {
		case APK_VERSION_LESS:
			return -1;
		case APK_VERSION_GREATER:
			return 1;
		}
	}
Timo Teräs's avatar
Timo Teräs committed
568

569
570
571
572
	/* Prefer installed (matches here if upgrading) */
	r = (pkgA->ipkg != NULL) - (pkgB->ipkg != NULL);
	if (r)
		return r;
573

574
	/* Prefer lowest available repository */
575
	return ffs(pkgB->repos) - ffs(pkgA->repos);
576
}
577

578
579
580
581
582
583
static void inherit_pinning_from_pkg(struct apk_solver_state *ss, struct apk_package *rinstall_if, struct apk_package *parent_pkg)
{
	inherit_pinning(ss, rinstall_if, parent_pkg->ss.pinning_allowed, 0);
}

static void assign_name(struct apk_solver_state *ss, struct apk_name *name, struct apk_provider p)
584
{
585
	struct apk_provider *p0;
586
587
588
589
590
591

	if (name->ss.locked) {
		/* If both are providing this name without version, it's ok */
		if (p.version == &apk_null_blob &&
		    name->ss.chosen.version == &apk_null_blob)
			return;
592
593
594
		/* Conflict: providing same name */
		mark_error(ss, p.pkg);
		mark_error(ss, name->ss.chosen.pkg);
595
		return;
596
	}
597

598
599
	if (p.pkg)
		dbg_printf("assign %s to "PKG_VER_FMT"\n", name->name, PKG_VER_PRINTF(p.pkg));
600

601
602
603
604
605
606
607
	name->ss.locked = 1;
	name->ss.chosen = p;
	if (list_hashed(&name->ss.unresolved_list))
		list_del(&name->ss.unresolved_list);
	if (list_hashed(&name->ss.dirty_list))
		list_del(&name->ss.dirty_list);

608
609
610
611
	/* propagate pinning to install_if candidates */
	if (p.pkg)
		foreach_rinstall_if_pkg(ss, p.pkg, inherit_pinning_from_pkg);

612
	/* disqualify all conflicting packages */
613
614
	foreach_array_item(p0, name->providers) {
		if (p0->pkg == p.pkg)
615
616
			continue;
		if (p.version == &apk_null_blob &&
617
		    p0->version == &apk_null_blob)
618
			continue;
619
		disqualify_package(ss, p0->pkg, "conflicting provides");
620
	}
621
	reevaluate_reverse_deps(ss, name);
622
	reevaluate_reverse_installif(ss, name);
623
624
}

625
static void select_package(struct apk_solver_state *ss, struct apk_name *name)
626
{
627
	struct apk_provider chosen = { NULL, &apk_null_blob }, *p;
628
	struct apk_package *pkg = NULL;
629
	struct apk_dependency *d;
630

631
	dbg_printf("select_package: %s (requirers=%d, iif=%d)\n", name->name, name->ss.requirers, name->ss.has_iif);
632

633
	if (name->ss.requirers || name->ss.has_iif) {
634
		foreach_array_item(p, name->providers) {
635
			/* Ensure valid pinning and install-if trigger */
636
			if (name->ss.requirers == 0 &&
637
638
			    (!p->pkg->ss.iif_triggered ||
			     !p->pkg->ss.tag_ok))
639
				continue;
640
641
642
			/* Virtual packages cannot be autoselected */
			if (p->version == &apk_null_blob && p->pkg->name->ss.requirers == 0)
				continue;
643
644
			if (compare_providers(ss, p, &chosen) > 0)
				chosen = *p;
645
		}
646
	}
647

648
649
	pkg = chosen.pkg;
	if (pkg) {
650
		if (!pkg->ss.pkg_selectable || !pkg->ss.tag_ok) {
651
652
653
			/* Selecting broken or unallowed package */
			mark_error(ss, pkg);
		}
654
		dbg_printf("selecting: " PKG_VER_FMT ", available: %d\n", PKG_VER_PRINTF(pkg), pkg->ss.pkg_selectable);
655

656
		assign_name(ss, pkg->name, APK_PROVIDER_FROM_PACKAGE(pkg));
657
658
659
		foreach_array_item(d, pkg->provides)
			assign_name(ss, d->name, APK_PROVIDER_FROM_PROVIDES(pkg, d));

660
		ss->solver_flags_inherit = pkg->ss.solver_flags_inheritable;
661
		ss->pinning_inherit = pkg->ss.pinning_allowed;
662
663
		foreach_array_item(d, pkg->depends)
			apply_constraint(ss, pkg, d);
664
		ss->solver_flags_inherit = 0;
665
		ss->pinning_inherit = 0;
666
667
668
	} else {
		dbg_printf("selecting: %s [unassigned]\n", name->name);
		assign_name(ss, name, provider_none);
669
		ss->errors += (name->ss.requirers > 0);
670
	}
671
672
}

673
static void record_change(struct apk_solver_state *ss, struct apk_package *opkg, struct apk_package *npkg)
674
{
675
676
677
	struct apk_changeset *changeset = ss->changeset;
	struct apk_change *change;

678
	change = apk_change_array_add(&changeset->changes);
679
680
681
	*change = (struct apk_change) {
		.old_pkg = opkg,
		.old_repository_tag = opkg ? opkg->ipkg->repository_tag : 0,
682
683
684
		.new_pkg = npkg,
		.new_repository_tag = npkg ? get_tag(ss->db, npkg->ss.pinning_allowed, get_pkg_repos(ss->db, npkg)) : 0,
		.reinstall = npkg ? !!(npkg->ss.solver_flags & APK_SOLVERF_REINSTALL) : 0,
685
	};
686
	if (npkg == NULL)
687
		changeset->num_remove++;
688
	else if (opkg == NULL)
689
		changeset->num_install++;
690
	else if (npkg != opkg || change->reinstall || change->new_repository_tag != change->old_repository_tag)
691
		changeset->num_adjust++;
692
}
693

694
695
696
697
static void cset_gen_name_change(struct apk_solver_state *ss, struct apk_name *name);
static void cset_gen_name_remove(struct apk_solver_state *ss, struct apk_package *pkg);
static void cset_gen_dep(struct apk_solver_state *ss, struct apk_package *ppkg, struct apk_dependency *dep);

698
static void cset_track_deps_added(struct apk_package *pkg)
699
700
701
{
	struct apk_dependency *d;

702
703
704
705
706
	foreach_array_item(d, pkg->depends) {
		if (d->conflict || !d->name->ss.installed_name)
			continue;
		d->name->ss.installed_name->ss.requirers++;
	}
707
708
709
710
711
712
713
714
}

static void cset_track_deps_removed(struct apk_solver_state *ss, struct apk_package *pkg)
{
	struct apk_dependency *d;
	struct apk_package *pkg0;

	foreach_array_item(d, pkg->depends) {
715
		if (d->conflict || !d->name->ss.installed_name)
716
			continue;
717
		if (--d->name->ss.installed_name->ss.requirers > 0)
718
			continue;
719
		pkg0 = d->name->ss.installed_pkg;
720
721
722
723
724
725
726
727
728
		if (pkg0 != NULL)
			cset_gen_name_remove(ss, pkg0);
	}
}

static void cset_check_removal_by_deps(struct apk_solver_state *ss, struct apk_package *pkg)
{
	if (pkg->name->ss.requirers == 0)
		cset_gen_name_remove(ss, pkg);
729
730
}

731
static void cset_check_install_by_iif(struct apk_solver_state *ss, struct apk_name *name)
732
{
733
	struct apk_package *pkg = name->ss.chosen.pkg;
734
	struct apk_dependency *dep0;
735

736
	if (pkg == NULL || !name->ss.seen || name->ss.in_changeset)
737
738
		return;

739
	foreach_array_item(dep0, pkg->install_if) {
740
741
742
743
744
		struct apk_name *name0 = dep0->name;
		if (!name0->ss.in_changeset)
			return;
		if (!apk_dep_is_provided(dep0, &name0->ss.chosen))
			return;
745
	}
746
747
748
749
750
	cset_gen_name_change(ss, name);
}

static void cset_check_removal_by_iif(struct apk_solver_state *ss, struct apk_name *name)
{
751
	struct apk_package *pkg = name->ss.installed_pkg;
752
	struct apk_dependency *dep0;
753

754
	if (pkg == NULL || name->ss.in_changeset || name->ss.chosen.pkg != NULL)
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
		return;

	foreach_array_item(dep0, pkg->install_if) {
		if (dep0->name->ss.in_changeset &&
		    dep0->name->ss.chosen.pkg == NULL) {
			cset_check_removal_by_deps(ss, pkg);
			return;
		}
	}
}

static void cset_gen_name_change(struct apk_solver_state *ss, struct apk_name *name)
{
	struct apk_name **pname;
	struct apk_package *pkg = name->ss.chosen.pkg, *opkg;
	struct apk_dependency *d;

	if (pkg == NULL || pkg->ss.in_changeset)
		return;

	pkg->ss.in_changeset = 1;
	pkg->name->ss.in_changeset = 1;
777
778
	foreach_array_item(d, pkg->provides)
		d->name->ss.in_changeset = 1;
779

780
	opkg = pkg->name->ss.installed_pkg;
781
782
783
784
785
786
787
788
	if (opkg) {
		foreach_array_item(pname, opkg->name->rinstall_if)
			cset_check_removal_by_iif(ss, *pname);
	}

	foreach_array_item(d, pkg->depends)
		cset_gen_dep(ss, pkg, d);

789
	dbg_printf("Selecting: "PKG_VER_FMT"%s\n", PKG_VER_PRINTF(pkg), pkg->ss.pkg_selectable ? "" : " [NOT SELECTABLE]");
790
791
792
793
794
	record_change(ss, opkg, pkg);

	foreach_array_item(pname, pkg->name->rinstall_if)
		cset_check_install_by_iif(ss, *pname);

795
	cset_track_deps_added(pkg);
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
	if (opkg)
		cset_track_deps_removed(ss, opkg);
}

static void cset_gen_name_remove(struct apk_solver_state *ss, struct apk_package *pkg)
{
	struct apk_name *name = pkg->name, **pname;

	if (name->ss.chosen.pkg != NULL || name->ss.in_changeset)
		return;

	name->ss.in_changeset = 1;
	foreach_array_item(pname, pkg->name->rinstall_if)
		cset_check_removal_by_iif(ss, *pname);
	record_change(ss, pkg, NULL);
	cset_track_deps_removed(ss, pkg);
812
813
}

814
static void cset_gen_dep(struct apk_solver_state *ss, struct apk_package *ppkg, struct apk_dependency *dep)
815
{
816
	struct apk_name *name = dep->name;
817
	struct apk_package *pkg = name->ss.chosen.pkg;
818

819
	if (!apk_dep_is_provided(dep, &name->ss.chosen))
820
		mark_error(ss, ppkg);
821

822
	cset_gen_name_change(ss, name);
823
824
825

	if (pkg && pkg->ss.error)
		mark_error(ss, ppkg);
826
}
827

828
829
830
831
832
833
834
835
836
static int cset_reset_name(apk_hash_item item, void *ctx)
{
	struct apk_name *name = (struct apk_name *) item;
	name->ss.installed_pkg = NULL;
	name->ss.installed_name = NULL;
	name->ss.requirers = 0;
	return 0;
}

837
838
839
static void generate_changeset(struct apk_solver_state *ss, struct apk_dependency_array *world)
{
	struct apk_changeset *changeset = ss->changeset;
840
	struct apk_package *pkg;
841
	struct apk_installed_package *ipkg;
842
	struct apk_dependency *d;
843

844
845
	apk_change_array_init(&changeset->changes);

846
847
848
849
850
851
852
853
854
	apk_hash_foreach(&ss->db->available.names, cset_reset_name, NULL);
	list_for_each_entry(ipkg, &ss->db->installed.packages, installed_pkgs_list) {
		pkg = ipkg->pkg;
		pkg->name->ss.installed_pkg = pkg;
		pkg->name->ss.installed_name = pkg->name;
		foreach_array_item(d, pkg->provides)
			if (d->version != &apk_null_blob)
				d->name->ss.installed_name = pkg->name;
	}
855
	list_for_each_entry(ipkg, &ss->db->installed.packages, installed_pkgs_list)
856
		cset_track_deps_added(ipkg->pkg);
857
858
	list_for_each_entry(ipkg, &ss->db->installed.packages, installed_pkgs_list)
		cset_check_removal_by_deps(ss, ipkg->pkg);
Timo Teräs's avatar
Timo Teräs committed
859

860
	foreach_array_item(d, world)
861
		cset_gen_dep(ss, NULL, d);
862

863
864
	list_for_each_entry(ipkg, &ss->db->installed.packages, installed_pkgs_list)
		cset_gen_name_remove(ss, ipkg->pkg);
865

866
867
868
869
	changeset->num_total_changes =
		changeset->num_install +
		changeset->num_remove +
		changeset->num_adjust;
870
871
}

872
static int free_name(apk_hash_item item, void *ctx)
873
874
875
876
877
{
	struct apk_name *name = (struct apk_name *) item;
	memset(&name->ss, 0, sizeof(name->ss));
	return 0;
}
Timo Teräs's avatar
Timo Teräs committed
878

879
880
881
882
883
static int free_package(apk_hash_item item, void *ctx)
{
	struct apk_package *pkg = (struct apk_package *) item;
	memset(&pkg->ss, 0, sizeof(pkg->ss));
	return 0;
884
885
}

886
887
888
889
int apk_solver_solve(struct apk_database *db,
		     unsigned short solver_flags,
		     struct apk_dependency_array *world,
		     struct apk_changeset *changeset)
890
{
891
	struct apk_name *name, *name0;
892
	struct apk_package *pkg;
893
	struct apk_solver_state ss_data, *ss = &ss_data;
894
	struct apk_dependency *d;
895

896
restart:
897
898
899
	memset(ss, 0, sizeof(*ss));
	ss->db = db;
	ss->changeset = changeset;
900
	ss->default_repos = apk_db_get_pinning_mask_repos(db, APK_DEFAULT_PINNING_MASK);
901
902
	list_init(&ss->dirty_head);
	list_init(&ss->unresolved_head);
903

904
	dbg_printf("discovering world\n");
905
	ss->prefer_pinning = 1;
906
	ss->solver_flags_inherit = solver_flags;