[pakfire.git] / src / libpakfire / problem.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2017 Pakfire development team                                 #
#                                                                             #
# This program is free software: you can redistribute it and/or modify        #
# it under the terms of the GNU General Public License as published by        #
# the Free Software Foundation, either version 3 of the License, or           #
# (at your option) any later version.                                         #
#                                                                             #
# This program is distributed in the hope that it will be useful,             #
# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
# GNU General Public License for more details.                                #
#                                                                             #
# You should have received a copy of the GNU General Public License           #
# along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
#############################################################################*/

#include <errno.h>
#include <stdlib.h>

// Enable legacy logging
#define PAKFIRE_LEGACY_LOGGING

#include <pakfire/constants.h>
#include <pakfire/dependencies.h>
#include <pakfire/i18n.h>
#include <pakfire/logging.h>
#include <pakfire/pakfire.h>
#include <pakfire/private.h>
#include <pakfire/problem.h>
#include <pakfire/solution.h>
#include <pakfire/transaction.h>
#include <pakfire/util.h>

struct pakfire_problem {
	struct pakfire* pakfire;
	int nrefs;

	struct pakfire_transaction* transaction;
	Id id;
	char* string;

	Solver* solver;
};

static char* pakfire_problem_make_string(struct pakfire_problem* problem) {
	Solver* solver = pakfire_transaction_get_solver(problem->transaction);
	Pool* pool = solver->pool;

	// Get the problem rule
	Id rule = solver_findproblemrule(solver, problem->id);

	// Extract some information about that rule
	Id dep;
	Id source;
	Id target;

	SolverRuleinfo type = solver_ruleinfo(solver, rule, &source, &target, &dep);

	char* s = NULL;
	int r = 1;

	switch (type) {
		case SOLVER_RULE_DISTUPGRADE:
			r = asprintf(&s, _("%s does not belong to a distupgrade repository"),
				pool_solvid2str(pool, source));
			break;

		case SOLVER_RULE_INFARCH:
			r = asprintf(&s, _("%s has inferior architecture"),
				pool_solvid2str(pool, source));
			break;

		case SOLVER_RULE_UPDATE:
			r = asprintf(&s, _("problem with installed package %s"),
				pool_solvid2str(pool, source));
			break;

		case SOLVER_RULE_JOB:
			r = asprintf(&s, _("conflicting requests"));
			break;

		case SOLVER_RULE_JOB_UNSUPPORTED:
			r = asprintf(&s, _("unsupported request"));
			break;

		case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP:
			r = asprintf(&s, _("nothing provides requested %s"),
				pakfire_dep2str(problem->pakfire, dep));
			break;

		case SOLVER_RULE_JOB_UNKNOWN_PACKAGE:
			r = asprintf(&s, _("package %s does not exist"),
				pakfire_dep2str(problem->pakfire, dep));
			break;

		case SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM:
			r = asprintf(&s, _("%s is provided by the system"),
				pakfire_dep2str(problem->pakfire, dep));
			break;

		case SOLVER_RULE_RPM:
			r = asprintf(&s, _("some dependency problem"));
			break;

		case SOLVER_RULE_BEST:
			if (source > 0)
				r = asprintf(&s, _("cannot install the best update candidate for package %s"),
					pool_solvid2str(pool, source));
			else
				r = asprintf(&s, _("cannot install the best candidate for the job"));
			break;

		case SOLVER_RULE_RPM_NOT_INSTALLABLE:
			r = asprintf(&s, _("package %s is not installable"),
				pool_solvid2str(pool, source));
			break;

		case SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP:
			r = asprintf(&s, _("nothing provides %s needed by %s"),
				pakfire_dep2str(problem->pakfire, dep),  pool_solvid2str(pool, source));
			break;

		case SOLVER_RULE_RPM_SAME_NAME:
			r = asprintf(&s, _("cannot install both %s and %s"),
				pool_solvid2str(pool, source),  pool_solvid2str(pool, target));
			break;

		case SOLVER_RULE_RPM_PACKAGE_CONFLICT:
			r = asprintf(&s, _("package %s conflicts with %s provided by %s"),
				pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep),
				pool_solvid2str(pool, target));
			break;

		case SOLVER_RULE_RPM_PACKAGE_OBSOLETES:
			r = asprintf(&s, _("package %s obsoletes %s provided by %s"),
				pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep),
				pool_solvid2str(pool, target));
			break;

		case SOLVER_RULE_RPM_INSTALLEDPKG_OBSOLETES:
			r = asprintf(&s, _("installed package %s obsoletes %s provided by %s"),
				pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep),
				pool_solvid2str(pool, target));
			break;

		case SOLVER_RULE_RPM_IMPLICIT_OBSOLETES:
			r = asprintf(&s, _("package %s implicitely obsoletes %s provided by %s"),
				pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep),
				pool_solvid2str(pool, target));
			break;

		case SOLVER_RULE_RPM_PACKAGE_REQUIRES:
			r = asprintf(&s, _("package %s requires %s, but none of the providers can be installed"),
				pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep));
			break;

		case SOLVER_RULE_RPM_SELF_CONFLICT:
			r = asprintf(&s, _("package %s conflicts with %s provided by itself"),
				pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep));
			break;

		case SOLVER_RULE_YUMOBS:
			r = asprintf(&s, _("both package %s and %s obsolete %s"),
				pool_solvid2str(pool, source), pool_solvid2str(pool, target),
				pakfire_dep2str(problem->pakfire, dep));
			break;

		case SOLVER_RULE_BLACK:
			r = asprintf(&s, _("package %s can only be installed by direct request"),
				pool_solvid2str(pool, source));
			break;

		case SOLVER_RULE_PKG_CONSTRAINS:
			r = asprintf(&s, _("package %s has constraint %s conflicting with %s"),
				pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep),
				pool_solvid2str(pool, target));
			break;

		default:
			r = asprintf(&s, _("bad rule type"));
			break;
	}

	// Return nothing if asprintf failed
	if (r < 0)
		return NULL;

	return s;
}

int pakfire_problem_create(struct pakfire_problem** problem,
		struct pakfire* pakfire, struct pakfire_transaction* transaction, Id id) {
	struct pakfire_problem* p = calloc(1, sizeof(*p));
	if (!p)
		return 1;

	p->pakfire = pakfire_ref(pakfire);
	p->nrefs = 1;

	p->transaction = pakfire_transaction_ref(transaction);
	p->id = id;

	// Fetch a reference to the solver
	p->solver = pakfire_transaction_get_solver(transaction);

	*problem = p;
	return 0;
}

PAKFIRE_EXPORT struct pakfire_problem* pakfire_problem_ref(struct pakfire_problem* problem) {
	problem->nrefs++;

	return problem;
}

static void pakfire_problem_free(struct pakfire_problem* problem) {
	if (problem->transaction)
		pakfire_transaction_unref(problem->transaction);
	if (problem->string)
		free(problem->string);
	pakfire_unref(problem->pakfire);
	free(problem);
}

PAKFIRE_EXPORT struct pakfire_problem* pakfire_problem_unref(struct pakfire_problem* problem) {
	if (--problem->nrefs > 0)
		return problem;

	pakfire_problem_free(problem);
	return NULL;
}

struct pakfire* pakfire_problem_get_pakfire(struct pakfire_problem* problem) {
	return pakfire_ref(problem->pakfire);
}

PAKFIRE_EXPORT const char* pakfire_problem_to_string(struct pakfire_problem* problem) {
	if (!problem->string)
		problem->string = pakfire_problem_make_string(problem);

	return problem->string;
}

Id pakfire_problem_get_id(struct pakfire_problem* problem) {
	return problem->id;
}

struct pakfire_transaction* pakfire_problem_get_transaction(struct pakfire_problem* problem) {
	return pakfire_transaction_ref(problem->transaction);
}

PAKFIRE_EXPORT struct pakfire_solution** pakfire_problem_get_solutions(
		struct pakfire_problem* problem) {
	struct pakfire_solution** solutions = NULL;
	struct pakfire_solution* solution = NULL;
	unsigned int count = 0;
	Id id = ID_NULL;
	int r;

	// Fetch how many solutions we have
	count = solver_solution_count(problem->solver, problem->id);
	if (!count)
		return NULL;

	// Allocate some space
	solutions = calloc(count + 1, sizeof(*solutions));
	if (!solutions) {
		r = -errno;
		goto ERROR;
	}

	for (unsigned int i = 0; i < count; i++) {
		id = solver_next_solution(problem->solver, problem->id, id);
		if (!id)
			break;

		// Create a new solution
		r = pakfire_solution_create(&solution, problem->pakfire, problem, id);
		if (r)
			goto ERROR;

		// Store the reference
		solutions[i] = solution;
	}

	return solutions;

ERROR:
	ERROR_ERRNO(problem->pakfire, r, "Could not import solutions: %m\n");

	if (solutions) {
		for (struct pakfire_solution** s = solutions; *s; s++)
			pakfire_solution_unref(*s);

		free(solutions);
	}

	return NULL;
}
Commit	Line	Data
d528058e MT	1	/*#############################################################################
	2	# #
	3	# Pakfire - The IPFire package management system #
	4	# Copyright (C) 2017 Pakfire development team #
	5	# #
	6	# This program is free software: you can redistribute it and/or modify #
	7	# it under the terms of the GNU General Public License as published by #
	8	# the Free Software Foundation, either version 3 of the License, or #
	9	# (at your option) any later version. #
	10	# #
	11	# This program is distributed in the hope that it will be useful, #
	12	# but WITHOUT ANY WARRANTY; without even the implied warranty of #
	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
	14	# GNU General Public License for more details. #
	15	# #
	16	# You should have received a copy of the GNU General Public License #
	17	# along with this program. If not, see <http://www.gnu.org/licenses/>. #
	18	# #
	19	#############################################################################*/
	20
aa36f70e	21	#include <errno.h>
f0d6233d MT	22	#include <stdlib.h>
f0d6233d MT	23
517708c8 MT	24	// Enable legacy logging
	25	#define PAKFIRE_LEGACY_LOGGING
	26
d528058e	27	#include <pakfire/constants.h>
2a623cf8	28	#include <pakfire/dependencies.h>
d528058e	29	#include <pakfire/i18n.h>
6f94a65f	30	#include <pakfire/logging.h>
12656820	31	#include <pakfire/pakfire.h>
9f953e68	32	#include <pakfire/private.h>
d528058e	33	#include <pakfire/problem.h>
9c8337dd	34	#include <pakfire/solution.h>
2f269d34	35	#include <pakfire/transaction.h>
d528058e MT	36	#include <pakfire/util.h>
d528058e MT	37
014e8eb6	38	struct pakfire_problem {
ac4c607b	39	struct pakfire* pakfire;
cf75652c MT	40	int nrefs;
cf75652c MT	41
2f269d34	42	struct pakfire_transaction* transaction;
3dc52735 MT	43	Id id;
3dc52735 MT	44	char* string;
bfe8e8fb MT	45
bfe8e8fb MT	46	Solver* solver;
3dc52735 MT	47	};
3dc52735 MT	48
ae23fb16	49	static char* pakfire_problem_make_string(struct pakfire_problem* problem) {
2f269d34	50	Solver* solver = pakfire_transaction_get_solver(problem->transaction);
d528058e MT	51	Pool* pool = solver->pool;
	52
	53	// Get the problem rule
	54	Id rule = solver_findproblemrule(solver, problem->id);
	55
	56	// Extract some information about that rule
	57	Id dep;
	58	Id source;
	59	Id target;
	60
	61	SolverRuleinfo type = solver_ruleinfo(solver, rule, &source, &target, &dep);
	62
ae23fb16 MT	63	char* s = NULL;
	64	int r = 1;
	65
d528058e MT	66	switch (type) {
d528058e MT	67	case SOLVER_RULE_DISTUPGRADE:
ae23fb16 MT	68	r = asprintf(&s, _("%s does not belong to a distupgrade repository"),
ae23fb16 MT	69	pool_solvid2str(pool, source));
d528058e MT	70	break;
	71
	72	case SOLVER_RULE_INFARCH:
ae23fb16 MT	73	r = asprintf(&s, _("%s has inferior architecture"),
ae23fb16 MT	74	pool_solvid2str(pool, source));
d528058e MT	75	break;
	76
	77	case SOLVER_RULE_UPDATE:
ae23fb16 MT	78	r = asprintf(&s, _("problem with installed package %s"),
ae23fb16 MT	79	pool_solvid2str(pool, source));
d528058e MT	80	break;
	81
	82	case SOLVER_RULE_JOB:
ae23fb16	83	r = asprintf(&s, _("conflicting requests"));
d528058e MT	84	break;
	85
	86	case SOLVER_RULE_JOB_UNSUPPORTED:
ae23fb16	87	r = asprintf(&s, _("unsupported request"));
37cb2f41	88	break;
d528058e MT	89
d528058e MT	90	case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP:
b1171f6a MT	91	r = asprintf(&s, _("nothing provides requested %s"),
b1171f6a MT	92	pakfire_dep2str(problem->pakfire, dep));
d528058e MT	93	break;
	94
	95	case SOLVER_RULE_JOB_UNKNOWN_PACKAGE:
b1171f6a MT	96	r = asprintf(&s, _("package %s does not exist"),
b1171f6a MT	97	pakfire_dep2str(problem->pakfire, dep));
d528058e MT	98	break;
	99
	100	case SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM:
b1171f6a MT	101	r = asprintf(&s, _("%s is provided by the system"),
b1171f6a MT	102	pakfire_dep2str(problem->pakfire, dep));
d528058e MT	103	break;
	104
	105	case SOLVER_RULE_RPM:
ae23fb16	106	r = asprintf(&s, _("some dependency problem"));
d528058e MT	107	break;
	108
	109	case SOLVER_RULE_BEST:
	110	if (source > 0)
ae23fb16 MT	111	r = asprintf(&s, _("cannot install the best update candidate for package %s"),
ae23fb16 MT	112	pool_solvid2str(pool, source));
d528058e	113	else
ae23fb16	114	r = asprintf(&s, _("cannot install the best candidate for the job"));
d528058e MT	115	break;
	116
	117	case SOLVER_RULE_RPM_NOT_INSTALLABLE:
ae23fb16 MT	118	r = asprintf(&s, _("package %s is not installable"),
ae23fb16 MT	119	pool_solvid2str(pool, source));
d528058e MT	120	break;
	121
	122	case SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP:
ae23fb16	123	r = asprintf(&s, _("nothing provides %s needed by %s"),
b1171f6a	124	pakfire_dep2str(problem->pakfire, dep), pool_solvid2str(pool, source));
d528058e MT	125	break;
	126
	127	case SOLVER_RULE_RPM_SAME_NAME:
ae23fb16 MT	128	r = asprintf(&s, _("cannot install both %s and %s"),
ae23fb16 MT	129	pool_solvid2str(pool, source), pool_solvid2str(pool, target));
d528058e MT	130	break;
	131
	132	case SOLVER_RULE_RPM_PACKAGE_CONFLICT:
ae23fb16	133	r = asprintf(&s, _("package %s conflicts with %s provided by %s"),
b1171f6a	134	pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep),
ae23fb16	135	pool_solvid2str(pool, target));
d528058e MT	136	break;
	137
	138	case SOLVER_RULE_RPM_PACKAGE_OBSOLETES:
ae23fb16	139	r = asprintf(&s, _("package %s obsoletes %s provided by %s"),
b1171f6a	140	pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep),
ae23fb16	141	pool_solvid2str(pool, target));
d528058e MT	142	break;
	143
	144	case SOLVER_RULE_RPM_INSTALLEDPKG_OBSOLETES:
ae23fb16	145	r = asprintf(&s, _("installed package %s obsoletes %s provided by %s"),
b1171f6a	146	pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep),
ae23fb16	147	pool_solvid2str(pool, target));
d528058e MT	148	break;
	149
	150	case SOLVER_RULE_RPM_IMPLICIT_OBSOLETES:
ae23fb16	151	r = asprintf(&s, _("package %s implicitely obsoletes %s provided by %s"),
b1171f6a	152	pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep),
ae23fb16	153	pool_solvid2str(pool, target));
d528058e MT	154	break;
	155
	156	case SOLVER_RULE_RPM_PACKAGE_REQUIRES:
ae23fb16	157	r = asprintf(&s, _("package %s requires %s, but none of the providers can be installed"),
b1171f6a	158	pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep));
d528058e MT	159	break;
	160
	161	case SOLVER_RULE_RPM_SELF_CONFLICT:
ae23fb16	162	r = asprintf(&s, _("package %s conflicts with %s provided by itself"),
b1171f6a	163	pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep));
d528058e MT	164	break;
	165
	166	case SOLVER_RULE_YUMOBS:
ae23fb16 MT	167	r = asprintf(&s, _("both package %s and %s obsolete %s"),
ae23fb16 MT	168	pool_solvid2str(pool, source), pool_solvid2str(pool, target),
b1171f6a	169	pakfire_dep2str(problem->pakfire, dep));
d528058e MT	170	break;
d528058e MT	171
bd62b874 MT	172	case SOLVER_RULE_BLACK:
	173	r = asprintf(&s, _("package %s can only be installed by direct request"),
	174	pool_solvid2str(pool, source));
	175	break;
	176
	177	case SOLVER_RULE_PKG_CONSTRAINS:
	178	r = asprintf(&s, _("package %s has constraint %s conflicting with %s"),
b1171f6a	179	pool_solvid2str(pool, source), pakfire_dep2str(problem->pakfire, dep),
bd62b874 MT	180	pool_solvid2str(pool, target));
	181	break;
	182
	183	default:
ae23fb16	184	r = asprintf(&s, _("bad rule type"));
d528058e	185	break;
d528058e MT	186	}
d528058e MT	187
ae23fb16 MT	188	// Return nothing if asprintf failed
	189	if (r < 0)
	190	return NULL;
	191
	192	return s;
d528058e MT	193	}
d528058e MT	194
2f269d34 MT	195	int pakfire_problem_create(struct pakfire_problem** problem,
2f269d34 MT	196	struct pakfire* pakfire, struct pakfire_transaction* transaction, Id id) {
e9cca469	197	struct pakfire_problem* p = calloc(1, sizeof(*p));
4896a9a8 MT	198	if (!p)
4896a9a8 MT	199	return 1;
12656820	200
f446d92e	201	p->pakfire = pakfire_ref(pakfire);
4896a9a8	202	p->nrefs = 1;
d528058e	203
2f269d34	204	p->transaction = pakfire_transaction_ref(transaction);
4896a9a8	205	p->id = id;
d528058e	206
bfe8e8fb MT	207	// Fetch a reference to the solver
	208	p->solver = pakfire_transaction_get_solver(transaction);
	209
4896a9a8 MT	210	*problem = p;
4896a9a8 MT	211	return 0;
d528058e MT	212	}
d528058e MT	213
014e8eb6	214	PAKFIRE_EXPORT struct pakfire_problem* pakfire_problem_ref(struct pakfire_problem* problem) {
d528058e MT	215	problem->nrefs++;
	216
	217	return problem;
	218	}
	219
014e8eb6	220	static void pakfire_problem_free(struct pakfire_problem* problem) {
2f269d34 MT	221	if (problem->transaction)
2f269d34 MT	222	pakfire_transaction_unref(problem->transaction);
d528058e	223	if (problem->string)
f0d6233d	224	free(problem->string);
12656820	225	pakfire_unref(problem->pakfire);
f0d6233d	226	free(problem);
6f94a65f MT	227	}
6f94a65f MT	228
014e8eb6	229	PAKFIRE_EXPORT struct pakfire_problem* pakfire_problem_unref(struct pakfire_problem* problem) {
6f94a65f MT	230	if (--problem->nrefs > 0)
	231	return problem;
	232
	233	pakfire_problem_free(problem);
	234	return NULL;
d528058e MT	235	}
d528058e MT	236
ac4c607b	237	struct pakfire* pakfire_problem_get_pakfire(struct pakfire_problem* problem) {
12656820 MT	238	return pakfire_ref(problem->pakfire);
	239	}
	240
014e8eb6	241	PAKFIRE_EXPORT const char* pakfire_problem_to_string(struct pakfire_problem* problem) {
d48f4d8d	242	if (!problem->string)
ae23fb16	243	problem->string = pakfire_problem_make_string(problem);
d48f4d8d	244
d528058e MT	245	return problem->string;
d528058e MT	246	}
9c8337dd	247
014e8eb6	248	Id pakfire_problem_get_id(struct pakfire_problem* problem) {
3dc52735 MT	249	return problem->id;
	250	}
	251
2f269d34 MT	252	struct pakfire_transaction* pakfire_problem_get_transaction(struct pakfire_problem* problem) {
2f269d34 MT	253	return pakfire_transaction_ref(problem->transaction);
3dc52735 MT	254	}
3dc52735 MT	255
bfe8e8fb MT	256	PAKFIRE_EXPORT struct pakfire_solution** pakfire_problem_get_solutions(
	257	struct pakfire_problem* problem) {
	258	struct pakfire_solution** solutions = NULL;
	259	struct pakfire_solution* solution = NULL;
	260	unsigned int count = 0;
	261	Id id = ID_NULL;
	262	int r;
	263
	264	// Fetch how many solutions we have
	265	count = solver_solution_count(problem->solver, problem->id);
	266	if (!count)
	267	return NULL;
aa36f70e	268
bfe8e8fb MT	269	// Allocate some space
	270	solutions = calloc(count + 1, sizeof(*solutions));
	271	if (!solutions) {
	272	r = -errno;
	273	goto ERROR;
aa36f70e MT	274	}
aa36f70e MT	275
bfe8e8fb MT	276	for (unsigned int i = 0; i < count; i++) {
	277	id = solver_next_solution(problem->solver, problem->id, id);
	278	if (!id)
	279	break;
	280
	281	// Create a new solution
	282	r = pakfire_solution_create(&solution, problem->pakfire, problem, id);
	283	if (r)
	284	goto ERROR;
aa36f70e	285
bfe8e8fb MT	286	// Store the reference
bfe8e8fb MT	287	solutions[i] = solution;
aa36f70e MT	288	}
aa36f70e MT	289
bfe8e8fb MT	290	return solutions;
	291
	292	ERROR:
	293	ERROR_ERRNO(problem->pakfire, r, "Could not import solutions: %m\n");
	294
	295	if (solutions) {
	296	for (struct pakfire_solution** s = solutions; *s; s++)
	297	pakfire_solution_unref(*s);
aa36f70e	298
bfe8e8fb MT	299	free(solutions);
	300	}
	301
	302	return NULL;
aa36f70e	303	}