f0df72b Convering pkg upgrade to new solver — HardenedBSD-pkg

HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

Convering pkg upgrade to new solver

Baptiste Daroussin committed 13 years ago

commit f0df72ba6090431c2f32807b810db563123ef5ba
parent 8c18e6b

3 files changed +23 -305

modified libpkg/pkg_jobs.c

@@ -46,6 +46,8 @@ static int get_remote_pkg(struct pkg_jobs *j, const char *pattern, match_t m, bo

 static struct pkg * get_local_pkg(struct pkg_jobs *j, const char *origin);
 static int pkg_jobs_fetch(struct pkg_jobs *j);
 static bool newer_than_local_pkg(struct pkg_jobs *j, struct pkg *rp, bool force);
 static bool new_pkg_version(struct pkg_jobs *j);
 static int order_pool(struct pkg_jobs *j);
 int
 pkg_jobs_new(struct pkg_jobs **j, pkg_jobs_t t, struct pkgdb *db)

@@ -206,29 +208,38 @@ jobs_solve_upgrade(struct pkg_jobs *j)

 	struct pkg *pkg = NULL;
 	struct pkgdb_it *it;
 	char *origin;
 	bool all = false;
 	bool pkgversiontest = false;
 	unsigned flags = PKG_LOAD_BASIC;
 	if ((j->flags & PKG_FLAG_FORCE) != 0)
 		all = true;
 	if ((j->flags & PKG_FLAG_PKG_VERSION_TEST) != PKG_FLAG_PKG_VERSION_TEST)
 		if (new_pkg_version(j)) {
 			pkg_emit_newpkgversion();
 			goto order;
 		}
 	if ((j->flags & PKG_FLAG_PKG_VERSION_TEST) != 0)
 		pkgversiontest = true;
 	if ((j->flags & PKG_FLAG_WITH_DEPS) != 0)
 		flags |= PKG_LOAD_DEPS;
 	if ((it = pkgdb_query_upgrades(j->db, j->reponame, all,
 	        pkgversiontest)) == NULL)
 	if ((it = pkgdb_query(j->db, NULL, MATCH_ALL)) == NULL)
 		return (EPKG_FATAL);
 	while (pkgdb_it_next(it, &pkg, flags) == EPKG_OK) {
 		pkg_get(pkg, PKG_ORIGIN, &origin);
 		HASH_ADD_KEYPTR(hh, j->jobs, origin, strlen(origin), pkg);
 		/* Do not test we ignore what doesn't exists remotely */
 		get_remote_pkg(j, origin, MATCH_EXACT, false);
 		pkg = NULL;
 	}
 	pkgdb_it_free(it);
 order:
 	HASH_FREE(j->seen, pkg, pkg_free);
 	/* now order the pool */
 	while (HASH_COUNT(j->bulk) > 0) {
 		if (order_pool(j) != EPKG_OK)
 			return (EPKG_FATAL);
 	}
 	j->solved = true;
 	return (EPKG_OK);

@@ -357,6 +368,9 @@ get_remote_pkg(struct pkg_jobs *j, const char *pattern, match_t m, bool root)

 	if (root && (j->flags & PKG_FLAG_FORCE) == PKG_FLAG_FORCE)
 		force = true;
 	if (j->type == PKG_JOBS_UPGRADE && (j->flags & PKG_FLAG_FORCE) == PKG_FLAG_FORCE)
 		force = true;
 	if (root && (j->flags & PKG_FLAG_RECURSIVE) == PKG_FLAG_RECURSIVE)
 		flags |= PKG_LOAD_RDEPS;

modified libpkg/pkgdb.c

@@ -3292,301 +3292,6 @@ create_temporary_pkgjobs(sqlite3 *s)

 	return (ret);
 }
 static struct pkgdb_it *
 pkgdb_query_newpkgversion(struct pkgdb *db, const char *repo)
 {
 	struct sbuf	*sql = NULL;
 	const char	*reponame = NULL;
 	sqlite3_stmt	*stmt = NULL;
 	struct pkgdb_it	*it = NULL;
 	int		 ret;
 	const char	 finalsql[] = ""
 		"SELECT pkgid AS id, origin, name, version, "
 		"comment, desc, message, arch, maintainer, "
 		"www, prefix, flatsize, newversion, newflatsize, pkgsize, "
 		"cksum, repopath, automatic, weight, "
 		"'%s' AS dbname FROM pkgjobs;";
 	const char	 main_sql[] = ""
 	    "INSERT OR IGNORE INTO pkgjobs ("
 	    "  pkgid, origin, name, newversion, comment, desc, arch, "
 	    "  maintainer, www, prefix, newflatsize, pkgsize, "
 	    "  version, flatsize, cksum, repopath, automatic "
 	    ") "
 	    "SELECT p.id, p.origin, p.name, p.version as newversion, "
 	    "	    p.comment, p.desc, p.arch, p.maintainer, p.www, "
 	    "	    p.prefix, p.flatsize as newflatsize, p.pkgsize, "
 	    /* If not installed from a port, insert the running version in */
 	    "COALESCE(l.version, '" PKG_PORTVERSION "') as version, "
 	    "COALESCE(l.flatsize, p.flatsize) as flatsize, "
 	    "p.cksum, p.path, 0 FROM '%s'.packages as p "
 	    "  LEFT JOIN packages as l ON p.origin = l.origin "
 	    "  WHERE p.origin REGEXP '^ports-mgmt/pkg(-devel)?$';";
 	assert(db != NULL);
 	assert(db->type == PKGDB_REMOTE);
 	if ((reponame = pkgdb_get_reponame(db, repo)) == NULL)
 		return (NULL);
 	sql = sbuf_new_auto();
 	sbuf_printf(sql, main_sql, reponame);
 	create_temporary_pkgjobs(db->sqlite);
 	sbuf_finish(sql);
 	sql_exec(db->sqlite, sbuf_get(sql));
 	/* If no rows were INSERTED then pkg is not listed in the remote repo
 	 * so there's nothing to upgrade to.  */
 	if (sqlite3_changes(db->sqlite) == 0) {
 		goto cleanup;
 	}
 	/* Delete where the current version is higher than the remote version */
 	sql_exec(db->sqlite,
 	    "DELETE FROM pkgjobs WHERE "
 	    "  PKGGT(version, newversion) OR version == newversion;");
 	/* Return NULL if pkg was deleted */
 	if (sqlite3_changes(db->sqlite) > 0) {
 		goto cleanup;
 	}
 	/* Final SQL */
 	sbuf_reset(sql);
 	sbuf_printf(sql, finalsql, reponame);
 	sbuf_finish(sql);
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		goto cleanup;
 	}
 	it = pkgdb_it_new(db, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE);
 cleanup:
 	sbuf_delete(sql);
 	return (it);
 }
 struct pkgdb_it *
 pkgdb_query_upgrades(struct pkgdb *db, const char *repo, bool all,
 	bool pkgversiontest)
 {
 	sqlite3_stmt	*stmt = NULL;
 	struct sbuf	*sql = NULL;
 	const char	*reponame = NULL;
 	struct pkgdb_it	*it;
 	int		 ret;
 	if (pkgversiontest &&
 	    (it = pkgdb_query_newpkgversion(db, repo)) != NULL) {
 		pkg_emit_newpkgversion();
 		return (it);
 	}
 	assert(db != NULL);
 	assert(db->type == PKGDB_REMOTE);
 	const char	 finalsql[] = ""
 		"SELECT pkgid AS id, origin, name, version, "
 		    "comment, desc, message, arch, maintainer, "
 		    "www, prefix, locked, flatsize, newversion, "
 		    "newflatsize, pkgsize, cksum, repopath, automatic, "
 		    "weight, '%s' AS dbname "
 		"FROM pkgjobs ORDER BY weight DESC;";
 	/* All the local packages where there is a matching package in
 	 * the repo: all data from the repo except locked and
 	 * automatic flags which are inherited from local */
 	const char	 pkgjobs_sql_1[] = ""
 		"INSERT OR IGNORE INTO pkgjobs (pkgid, origin, name, version, "
 			"comment, desc, arch, maintainer, www, prefix, "
 			"locked, flatsize, newversion, pkgsize, "
 			"cksum, repopath, automatic, opts, deps, shlibs) "
 		"SELECT r.id, r.origin, r.name, r.version, r.comment, "
 			"r.desc, r.arch, r.maintainer, r.www, r.prefix, "
 			"l.locked, r.flatsize, r.version AS newversion, "
 			"r.pkgsize, r.cksum, r.path, l.automatic ,"
 			"(SELECT GROUP_CONCAT(option) FROM (SELECT option "
 			"FROM '%s'.options WHERE package_id = r.id AND "
 			"value = 'on' ORDER BY option)), "
 			"(SELECT GROUP_CONCAT(origin) FROM (SELECT origin "
 			"FROM '%s'.deps WHERE package_id = r.id ORDER BY origin)), "
 			"(SELECT GROUP_CONCAT(shlib) FROM (SELECT name as shlib "
 			"FROM '%s'.pkg_shlibs_required, '%s'.shlibs as s "
 			"WHERE package_id = r.id AND shlib_id = s.id "
 			"ORDER BY name )) "
 			"FROM '%s'.packages r INNER JOIN main.packages l "
 			"ON l.origin = r.origin";
 	/* All dependencies for packages from the repo listed in the
 	 * temporary pkgjobs table and not already installed as local
 	 * packages (locked = 0, automatic = 1) */
 	const char	 pkgjobs_sql_2[] = ""
 		"INSERT OR IGNORE INTO pkgjobs (pkgid, origin, name, version, "
 			"comment, desc, arch, maintainer, www, prefix, "
 			"locked, flatsize, newversion, pkgsize, cksum, "
 			"repopath, automatic, opts, deps, shlibs) "
 		"SELECT DISTINCT r.id, r.origin, r.name, r.version, "
 			"r.comment, r.desc, r.arch, r.maintainer, r.www, "
 			"r.prefix, 0, r.flatsize, NULL AS newversion, "
 			"r.pkgsize, r.cksum, r.path, 1, "
 			"  (SELECT GROUP_CONCAT(option) FROM "
 			"    (SELECT option FROM '%s'.options "
 			"		    WHERE package_id=id"
 			"		    AND value='on' ORDER BY option"
 			"    )"
 			"  ), "
 			"  (SELECT GROUP_CONCAT(origin) FROM "
 			"    (SELECT origin FROM '%s'.deps "
 			"		    WHERE package_id=id"
 			"		    ORDER BY origin"
 			"    )"
 			"  ), "
 			"  (SELECT GROUP_CONCAT(shlib) FROM "
 			"    (SELECT name as shlib FROM '%s'.pkg_shlibs_required, '%s'.shlibs as s "
 			"		WHERE package_id = id AND shlib_id = s.id "
 			"		ORDER BY name"
 			"    )"
 			"  ) "
 		"FROM '%s'.packages AS r WHERE r.origin IN "
 			"(SELECT d.origin FROM '%s'.deps AS d, pkgjobs AS j "
 			"WHERE d.package_id = j.pkgid) AND (SELECT p.origin "
 			"FROM main.packages AS p WHERE p.origin = r.origin "
 			"AND version = r.version) IS NULL;";
 	const char	*pkgjobs_sql_3;
 	if (!all) {
 		pkgjobs_sql_3 = ""
 		"INSERT OR REPLACE INTO pkgjobs (pkgid, origin, name, "
 			"version, comment, desc, message, arch, maintainer, "
 			"www, prefix, locked, flatsize, newversion, "
 			"newflatsize, pkgsize, cksum, repopath, automatic) "
 		"SELECT l.id, l.origin, l.name, l.version, l.comment, "
 			"l.desc, l.message, l.arch, l.maintainer, l.www, "
 			"l.prefix, l.locked, l.flatsize, r.version AS "
 			"newversion, r.flatsize AS newflatsize, r.pkgsize, "
 			"r.cksum, r.repopath, l.automatic "
 		"FROM main.packages AS l, pkgjobs AS r "
 			"WHERE l.origin = r.origin "
 			"AND (PKGLT(l.version, r.version) "
 			"OR (l.name != r.name))";
 	} else {
 		pkgjobs_sql_3 = ""
 		"INSERT OR REPLACE INTO pkgjobs (pkgid, origin, name, "
 			"version, comment, desc, message, arch, "
 			"maintainer, www, prefix, locked, flatsize, "
 			"newversion, newflatsize, pkgsize, "
 			"cksum, repopath, automatic) "
 		"SELECT l.id, l.origin, l.name, l.version, l.comment, "
 			"l.desc, l.message, l.arch, l.maintainer, l.www, "
 			"l.prefix, l.locked, l.flatsize, "
 			"r.version AS newversion, "
 			"r.flatsize AS newflatsize, r.pkgsize, r.cksum, "
 			"r.repopath, l.automatic "
 		"FROM main.packages AS l, pkgjobs AS r "
 			"WHERE l.origin = r.origin";
 	}
 	const char	weight_sql[] = ""
 		"UPDATE pkgjobs SET weight = ("
 		"SELECT COUNT(*) FROM '%s'.deps AS d, "
 			"'%s'.packages AS p, "
 			"pkgjobs AS j "
 		"WHERE d.origin = pkgjobs.origin "
 			"AND d.package_id = p.id "
 			"AND p.origin = j.origin"
 		");";
 	if ((reponame = pkgdb_get_reponame(db, repo)) == NULL)
 		return (NULL);
 	sql = sbuf_new_auto();
 	create_temporary_pkgjobs(db->sqlite);
 	sbuf_printf(sql, pkgjobs_sql_1, reponame, reponame, reponame, reponame, reponame);
 	sbuf_finish(sql);
 	sql_exec(db->sqlite, sbuf_get(sql));
 	if (!all) {
 		/* Remove all the downgrades we asked for upgrade :) */
 		sql_exec(db->sqlite, "DELETE FROM pkgjobs WHERE "
 		    "(SELECT p.origin FROM main.packages AS p WHERE "
 			 "p.origin = pkgjobs.origin "
 			 "AND PKGGT(p.version, pkgjobs.version))"
 			 "IS NOT NULL");
 		/* Remove packages already installed and in the latest
 		 * version */
 		sql_exec(db->sqlite, "DELETE FROM pkgjobs WHERE "
 		    "(SELECT p.origin FROM main.packages AS p WHERE "
 		    "p.origin = pkgjobs.origin "
 			 "AND p.version = pkgjobs.version "
 			 "AND p.name = pkgjobs.name "
 			 "AND (SELECT GROUP_CONCAT(option) "
 		    "FROM (select option FROM main.options "
 			 "WHERE package_id = p.id AND value = 'on' "
 			 "ORDER BY option)) IS pkgjobs.opts "
 			 "AND (SELECT GROUP_CONCAT(origin) "
 		    "FROM (select origin FROM main.deps "
 			 "WHERE package_id = p.id "
 			 "ORDER BY origin)) IS pkgjobs.deps "
 			 "AND (SELECT GROUP_CONCAT(shlib) "
 		    "FROM (SELECT name as shlib from main.pkg_shlibs_required, main.shlibs as s "
 			 "WHERE package_id = p.id AND shlib_id = s.id "
 			 "ORDER BY name)) IS pkgjobs.shlibs "
 			 ") IS NOT NULL;");
 	}
 	sbuf_reset(sql);
 	sbuf_printf(sql, pkgjobs_sql_2, reponame, reponame, reponame, reponame, reponame, reponame);
 	sbuf_finish(sql);
 	do {
 		sql_exec(db->sqlite, sbuf_get(sql));
 	} while (sqlite3_changes(db->sqlite) != 0);
 	if (!all) {
 		/* Remove all the downgrades in dependencies as well
 		 * we asked for upgrade :) */
 		sql_exec(db->sqlite, "DELETE FROM pkgjobs WHERE "
 		    "(SELECT p.origin FROM main.packages AS p "
 			 "WHERE p.origin = pkgjobs.origin "
 			 "AND PKGGT(p.version, pkgjobs.version))"
 			 "IS NOT NULL;");
 	}
 	/* Determine if there is an upgrade needed */
 	sql_exec(db->sqlite, pkgjobs_sql_3);
 	sbuf_reset(sql);
 	sbuf_printf(sql, weight_sql, reponame, reponame);
 	sbuf_finish(sql);
 	sql_exec(db->sqlite, sbuf_get(sql));
 	sql_exec(db->sqlite, "UPDATE pkgjobs SET weight = 100000 "
 		 "WHERE origin REGEXP '^ports-mgmt/pkg(-devel)?$'");
 	sbuf_reset(sql);
 	sbuf_printf(sql, finalsql, reponame);
 	sbuf_finish(sql);
 	ret = sqlite3_prepare_v2(db->sqlite, sbuf_get(sql), -1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);
 		sbuf_delete(sql);
 		return (NULL);
 	}
 	sbuf_delete(sql);
 	return (pkgdb_it_new(db, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE));
 }
 struct pkgdb_it *
 pkgdb_query_delete(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs,
 		   int recursive)

modified libpkg/private/pkgdb.h

@@ -66,7 +66,6 @@ int pkgdb_transaction_rollback(sqlite3 *sqlite, const char *savepoint);

 struct pkgdb_it *pkgdb_it_new(struct pkgdb *db, sqlite3_stmt *s, int type, short flags);
 struct pkgdb_it *pkgdb_query_delete(struct pkgdb *db, match_t type, int nbpkgs, char **pkgs, int recursive);
 struct pkgdb_it *pkgdb_query_upgrades(struct pkgdb *db, const char *reponame, bool all, bool pkgversiontest);
 struct pkgdb_it *pkgdb_query_fetch(struct pkgdb *db, match_t type, int nbpkgs, char **pkgs, const char *reponame, unsigned flags);
 int pkgdb_obtain_lock(struct pkgdb *db);