8a3385f Convert pkg fetch to the new world order — HardenedBSD-pkg

HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

Convert pkg fetch to the new world order

Baptiste Daroussin committed 13 years ago

commit 8a3385f5a8997003bff9305c91fe783de9b13e86
parent e7c88c5

3 files changed +35 -170

modified libpkg/pkg_jobs.c

@@ -209,7 +209,6 @@ jobs_solve_upgrade(struct pkg_jobs *j)

 	struct pkgdb_it *it;
 	char *origin;
 	bool pkgversiontest = false;
 	unsigned flags = PKG_LOAD_BASIC;
 	if ((j->flags & PKG_FLAG_PKG_VERSION_TEST) != PKG_FLAG_PKG_VERSION_TEST)
 		if (new_pkg_version(j)) {

@@ -223,7 +222,7 @@ jobs_solve_upgrade(struct pkg_jobs *j)

 	if ((it = pkgdb_query(j->db, NULL, MATCH_ALL)) == NULL)
 		return (EPKG_FATAL);
 	while (pkgdb_it_next(it, &pkg, flags) == EPKG_OK) {
 	while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == EPKG_OK) {
 		pkg_get(pkg, PKG_ORIGIN, &origin);
 		/* Do not test we ignore what doesn't exists remotely */
 		get_remote_pkg(j, origin, MATCH_EXACT, false);

@@ -363,7 +362,7 @@ get_remote_pkg(struct pkg_jobs *j, const char *pattern, match_t m, bool root)

 	const char *buf1, *buf2;
 	bool force = false;
 	int rc = EPKG_FATAL;
 	unsigned flags = PKG_LOAD_BASIC|PKG_LOAD_DEPS|PKG_LOAD_OPTIONS|PKG_LOAD_SHLIBS_REQUIRED;
 	unsigned flags = PKG_LOAD_BASIC|PKG_LOAD_OPTIONS|PKG_LOAD_SHLIBS_REQUIRED;
 	if (root && (j->flags & PKG_FLAG_FORCE) == PKG_FLAG_FORCE)
 		force = true;

@@ -371,6 +370,15 @@ get_remote_pkg(struct pkg_jobs *j, const char *pattern, match_t m, bool root)

 	if (j->type == PKG_JOBS_UPGRADE && (j->flags & PKG_FLAG_FORCE) == PKG_FLAG_FORCE)
 		force = true;
 	if (j->type == PKG_JOBS_FETCH) {
 		if ((j->flags & PKG_FLAG_WITH_DEPS) == PKG_FLAG_WITH_DEPS)
 			flags |= PKG_LOAD_DEPS;
 		if ((j->flags & PKG_FLAG_UPGRADES_FOR_INSTALLED) == PKG_FLAG_UPGRADES_FOR_INSTALLED)
 			flags |= PKG_LOAD_DEPS;
 	} else {
 		flags |= PKG_LOAD_DEPS;
 	}
 	if (root && (j->flags & PKG_FLAG_RECURSIVE) == PKG_FLAG_RECURSIVE)
 		flags |= PKG_LOAD_RDEPS;

@@ -390,12 +398,14 @@ get_remote_pkg(struct pkg_jobs *j, const char *pattern, match_t m, bool root)

 			pkg_free(p1);
 		}
 		if (!newer_than_local_pkg(j, p, force)) {
 			if (root)
 				pkg_emit_already_installed(p);
 			rc = EPKG_OK;
 			HASH_ADD_KEYPTR(hh, j->seen, origin, strlen(origin), p);
 			continue;
 		if (j->type != PKG_JOBS_FETCH) {
 			if (!newer_than_local_pkg(j, p, force)) {
 				if (root)
 					pkg_emit_already_installed(p);
 				rc = EPKG_OK;
 				HASH_ADD_KEYPTR(hh, j->seen, origin, strlen(origin), p);
 				continue;
 			}
 		}
 		rc = EPKG_OK;

@@ -622,24 +632,31 @@ jobs_solve_fetch(struct pkg_jobs *j)

 	char *origin;
 	unsigned flag = PKG_LOAD_BASIC;
 	if ((j->flags & PKG_FLAG_UPGRADES_FOR_INSTALLED) != 0)
 		return (jobs_solve_upgrade(j));
 	if ((j->flags & PKG_FLAG_WITH_DEPS) != 0)
 		flag |= PKG_LOAD_DEPS;
 	LL_FOREACH(j->patterns, jp) {
 		if ((it = pkgdb_query_fetch(j->db, jp->match, jp->nb,
 		    jp->pattern, j->reponame, flag)) == NULL)
 	if ((j->flags & PKG_FLAG_UPGRADES_FOR_INSTALLED) == PKG_FLAG_UPGRADES_FOR_INSTALLED) {
 		if ((it = pkgdb_query(j->db, NULL, MATCH_ALL)) == NULL)
 			return (EPKG_FATAL);
 		while (pkgdb_it_next(it, &pkg, flag) == EPKG_OK) {
 		while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == 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);
 	} else {
 		LL_FOREACH(j->patterns, jp) {
 			if (get_remote_pkg(j, jp->pattern[0], jp->match, true) == EPKG_FATAL)
 				pkg_emit_error("No packages matching '%s' has been found in the repositories", jp->pattern[0]);
 		}
 	}
 	HASH_FREE(j->seen, pkg, pkg_free);
 	/* No need to order we are just fetching */
 	j->jobs = j->bulk;
 	j->solved = true;
 	return (EPKG_OK);

modified libpkg/pkgdb.c

@@ -86,7 +86,6 @@ static void pkgdb_pkgle(sqlite3_context *, int, sqlite3_value **);

 static void pkgdb_pkgge(sqlite3_context *, int, sqlite3_value **);
 static int pkgdb_upgrade(struct pkgdb *);
 static void populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg);
 static int create_temporary_pkgjobs(sqlite3 *);
 static void pkgdb_detach_remotes(sqlite3 *);
 static bool is_attached(sqlite3 *, const char *);
 static int sqlcmd_init(sqlite3 *db, __unused const char **err,

@@ -3269,29 +3268,6 @@ pkgdb_compact(struct pkgdb *db)

 	return (sql_exec(db->sqlite, "VACUUM;"));
 }
 static int
 create_temporary_pkgjobs(sqlite3 *s)
 {
 	int	ret;
 	assert(s != NULL);
 	ret = sql_exec(s, "DROP TABLE IF EXISTS pkgjobs;"
 			"CREATE TEMPORARY TABLE IF NOT EXISTS pkgjobs ("
 			"    pkgid INTEGER, origin TEXT UNIQUE NOT NULL,"
 			"    name TEXT, version TEXT, comment TEXT, "
 		        "    desc TEXT, message TEXT, arch TEXT, "
 		        "    maintainer TEXT, www TEXT, prefix TEXT, "
 		        "    locked INTEGER, flatsize INTEGER, "
 			"    newversion TEXT, newflatsize INTEGER, "
 			"    pkgsize INTEGER, cksum TEXT, repopath TEXT, "
 			"    automatic INTEGER, weight INTEGER, dbname TEXT, "
 			"    opts TEXT, deps TEXT, shlibs TEXT"
 			");");
 	return (ret);
 }
 struct pkgdb_it *
 pkgdb_query_delete(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs,
 		   int recursive)

@@ -3918,134 +3894,6 @@ pkgdb_file_set_cksum(struct pkgdb *db, struct pkg_file *file,

 	return (EPKG_OK);
 }
 struct pkgdb_it *
 pkgdb_query_fetch(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs,
     const char *repo, unsigned flags)
 {
 	sqlite3_stmt	*stmt = NULL;
 	int		 i = 0, ret;
 	struct sbuf	*sql = NULL;
 	const char	*how = NULL;
 	const char	*reponame = NULL;
 	const char	 finalsql[] = ""
 		"SELECT pkgid AS id, origin, name, version, "
 		    "flatsize, newversion, newflatsize, pkgsize, "
 		    "cksum, repopath, '%s' AS dbname "
 		"FROM pkgjobs ORDER BY weight DESC;";
 	const char	 main_sql[] = ""
 		"INSERT OR IGNORE INTO pkgjobs (pkgid, origin, name, "
 		        "newversion, newflatsize, pkgsize, cksum, repopath) "
 			"SELECT id, origin, name, version, flatsize, "
 			"pkgsize, cksum, path FROM '%s'.packages ";
 	const char	deps_sql[] = ""
 		"INSERT OR IGNORE INTO pkgjobs (pkgid, origin, name, "
 		        "newversion, newflatsize, pkgsize, cksum, repopath) "
 		"SELECT DISTINCT r.id, r.origin, r.name, r.version, "
 			"r.flatsize, r.pkgsize, r.cksum, r.path "
 		"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 origin FROM main.packages "
 			"WHERE origin = r.origin "
 			"AND version = r.version) IS NULL;";
 	const char	weight_sql[] = ""
 		"UPDATE pkgjobs SET weight=(SELECT COUNT(*) "
 		"FROM '%s'.deps AS d WHERE d.origin = pkgjobs.origin)";
 	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);
 	how = pkgdb_get_match_how(match);
 	create_temporary_pkgjobs(db->sqlite);
 	if (how != NULL) {
 		sbuf_cat(sql, " WHERE ");
 		sbuf_printf(sql, how, "name");
 		sbuf_cat(sql, " OR ");
 		sbuf_printf(sql, how, "origin");
 		sbuf_cat(sql, " OR ");
 		sbuf_printf(sql, how, "name || \"-\" || version");
 		sbuf_finish(sql);
 		for (i = 0; i < nbpkgs; i++) {
 			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);
 			}
 			sqlite3_bind_text(stmt, 1, pkgs[i], -1, SQLITE_STATIC);
 			while (sqlite3_step(stmt) != SQLITE_DONE);
 			/* report if package was not found in the database */
 			if (sqlite3_changes(db->sqlite) == 0)
 				pkg_emit_error("Package '%s' was not found "
 				    "in the repositories", pkgs[i]);
 		}
 	} else {
 		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);
 		}
 		sqlite3_bind_text(stmt, 1, pkgs[i], -1, SQLITE_STATIC);
 		while (sqlite3_step(stmt) != SQLITE_DONE);
 	}
 	sqlite3_finalize(stmt);
 	sbuf_clear(sql);
 	/* Append dependencies */
 	if (flags & PKG_LOAD_DEPS) {
 		sbuf_reset(sql);
 		sbuf_printf(sql, deps_sql, reponame, reponame);
 		sbuf_finish(sql);
 		do {
 			sql_exec(db->sqlite, sbuf_get(sql));
 		} while (sqlite3_changes(db->sqlite) != 0);
 	}
 	sbuf_reset(sql);
 	sbuf_printf(sql, weight_sql, reponame);
 	sbuf_finish(sql);
 	/* Set weight */
 	sql_exec(db->sqlite, sbuf_get(sql));
 	/* Execute 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);
 		sbuf_delete(sql);
 		return (NULL);
 	}
 	sbuf_finish(sql);
 	sbuf_delete(sql);
 	return (pkgdb_it_new(db, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE));
 }
 /*
  * create our custom functions in the sqlite3 connection.
  * Used both in the shell and pkgdb_open

modified pkg/utils.c

@@ -704,7 +704,7 @@ print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)

 			humanize_number(size, sizeof(size), pkgsize, "B", HN_AUTOSCALE, 0);
 			printf("\t%s-%s (%" PRId64 "%% of %s)\n", name, newversion, 100 - (100 * oldsize)/pkgsize, size);
 			printf("\t%s-%s (%" PRId64 "%% of %s)\n", name, newversion == NULL ? version : newversion , 100 - (100 * oldsize)/pkgsize, size);
 			break;
 		}
 	}