461b5e6 Move pkg_lock schema into normal schema upgrade path — HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

Move pkg_lock schema into normal schema upgrade path

Bryan Drewery committed 11 years ago

commit 461b5e6381920cce9e22a942ed421470435696f7
parent 47afc92

2 files changed +25 -51

modified libpkg/pkgdb.c

@@ -73,7 +73,7 @@

 */
 #define DB_SCHEMA_MAJOR	0
 #define DB_SCHEMA_MINOR	23
 #define DB_SCHEMA_MINOR	24
 #define DBVERSION (DB_SCHEMA_MAJOR * 1000 + DB_SCHEMA_MINOR)

@@ -635,6 +635,15 @@ pkgdb_init(sqlite3 *sdb)

 	    "conflict_id INTEGER NOT NULL,"
 	    "UNIQUE(package_id, conflict_id)"
 	");"
 	"CREATE TABLE pkg_lock ("
 	    "exclusive INTEGER(1),"
 	    "advisory INTEGER(1),"
 	    "read INTEGER(8)"
 	");"
 	"CREATE TABLE pkg_lock_pid ("
 	    "pid INTEGER PRIMARY KEY"
 	");"
 	"INSERT INTO pkg_lock VALUES(0,0,0);"
 	"CREATE TABLE provides("
 	"    id INTEGER PRIMARY KEY,"
 	"    provide TEXT NOT NULL"

@@ -4208,31 +4217,6 @@ pkgdb_reset_lock(struct pkgdb *db)

 }
 static int
 pkgdb_sqlite3_exec_while_busy(sqlite3 *sqlite, const char *sql)
 {
 	int ret;
 	struct timespec ts;
 	int64_t num_timeout = 1;
 	unsigned int tries = 0, max_tries = 30;
 	for (;;) {
 		ret = sqlite3_exec(sqlite, sql, NULL, NULL, NULL);
 		if (ret == SQLITE_BUSY && tries++ < max_tries) {
 			ts.tv_sec = (int)num_timeout;
 			ts.tv_nsec = (num_timeout - (int)num_timeout) * 1000000000.;
 			pkg_debug(1, "waiting on database busy for %d times, "
 			    "next try in %.2f seconds", tries, num_timeout);
 			(void)nanosleep(&ts, NULL);
 			continue;
 		}
 		return (ret);
 	}
 	/* NOTREACHED */
 }
 static int
 pkgdb_try_lock(struct pkgdb *db, const char *lock_sql, pkgdb_lock_t type,
 		bool upgrade)
 {

@@ -4251,7 +4235,7 @@ pkgdb_try_lock(struct pkgdb *db, const char *lock_sql, pkgdb_lock_t type,

 		num_maxtries = pkg_object_int(max_tries);
 	while (tries <= num_maxtries) {
 		ret = pkgdb_sqlite3_exec_while_busy(db->sqlite, lock_sql);
 		ret = sqlite3_exec(db->sqlite, lock_sql, NULL, NULL, NULL);
 		if (ret != SQLITE_OK) {
 			if (ret == SQLITE_READONLY && type == PKGDB_LOCK_READONLY) {
 				pkg_debug(1, "want read lock but cannot write to database, "

@@ -4307,14 +4291,6 @@ pkgdb_obtain_lock(struct pkgdb *db, pkgdb_lock_t type)

 {
 	int ret;
 	const char table_sql[] = ""
 			"CREATE TABLE pkg_lock "
 			"(exclusive INTEGER(1), advisory INTEGER(1), read INTEGER(8));";
 	const char pid_sql[] = ""
 			"CREATE TABLE IF NOT EXISTS pkg_lock_pid "
 			"(pid INTEGER PRIMARY KEY);";
 	const char init_sql[] = ""
 			"INSERT INTO pkg_lock VALUES(0,0,0);";
 	const char readonly_lock_sql[] = ""
 			"UPDATE pkg_lock SET read=read+1 WHERE exclusive=0;";
 	const char advisory_lock_sql[] = ""

@@ -4325,22 +4301,6 @@ pkgdb_obtain_lock(struct pkgdb *db, pkgdb_lock_t type)

 	assert(db != NULL);
 	ret = pkgdb_sqlite3_exec_while_busy(db->sqlite, table_sql);
 	if (ret == SQLITE_OK) {
 		/* Need to initialize */
 		ret = sqlite3_exec(db->sqlite, init_sql, NULL, NULL, NULL);
 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(db->sqlite, init_sql);
 			return (EPKG_FATAL);
 		}
 	}
 	ret = pkgdb_sqlite3_exec_while_busy(db->sqlite, pid_sql);
 	if (ret != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite, pid_sql);
 		return (EPKG_FATAL);
 	}
 	switch (type) {
 	case PKGDB_LOCK_READONLY:
 		lock_sql = readonly_lock_sql;

modified libpkg/private/db_upgrades.h

@@ -561,6 +561,20 @@ static struct db_upgrades {

 	"CREATE INDEX packages_origin ON packages(origin COLLATE NOCASE);"
 	"CREATE INDEX packages_name ON packages(name COLLATE NOCASE);"
 	},
 	/* pkg_lock existed during 1.3 dev cycle before moving to schema */
 	{24,
 	"CREATE TABLE IF NOT EXISTS pkg_lock ("
 	    "exclusive INTEGER(1),"
 	    "advisory INTEGER(1),"
 	    "read INTEGER(8)"
 	");"
 	"CREATE TABLE IF NOT EXISTS pkg_lock_pid ("
 	    "pid INTEGER PRIMARY KEY"
 	");"
 	"DELETE FROM pkg_lock;"
 	"DELETE FROM pkg_lock_pid;"
 	"INSERT INTO pkg_lock VALUES(0,0,0);"
 	},
 	/* Mark the end of the array */