--- a/toolkit/components/contentprefs/ContentPrefService2.js
+++ b/toolkit/components/contentprefs/ContentPrefService2.js
@@ -1,42 +1,40 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
ChromeUtils.import("resource://gre/modules/Services.jsm");
ChromeUtils.import("resource://gre/modules/ContentPrefUtils.jsm");
ChromeUtils.import("resource://gre/modules/ContentPrefStore.jsm");
+ChromeUtils.defineModuleGetter(this, "OS",
+ "resource://gre/modules/osfile.jsm");
+ChromeUtils.defineModuleGetter(this, "Sqlite",
+ "resource://gre/modules/Sqlite.jsm");
const CACHE_MAX_GROUP_ENTRIES = 100;
const GROUP_CLAUSE = `
SELECT id
FROM groups
WHERE name = :group OR
(:includeSubdomains AND name LIKE :pattern ESCAPE '/')
`;
function ContentPrefService2() {
if (Services.appinfo.processType === Services.appinfo.PROCESS_TYPE_CONTENT) {
return ChromeUtils.import("resource://gre/modules/ContentPrefServiceChild.jsm")
.ContentPrefServiceChild;
}
- // If this throws an exception, it causes the getService call to fail,
- // but the next time a consumer tries to retrieve the service, we'll try
- // to initialize the database again, which might work if the failure
- // was due to a temporary condition (like being out of disk space).
- this._dbInit();
-
Services.obs.addObserver(this, "last-pb-context-exited");
// Observe shutdown so we can shut down the database connection.
- Services.obs.addObserver(this, "xpcom-shutdown");
+ Services.obs.addObserver(this, "profile-before-change");
}
const cache = new ContentPrefStore();
cache.set = function CPS_cache_set(group, name, val) {
Object.getPrototypeOf(this).set.apply(this, arguments);
let groupCount = this._groups.size;
if (groupCount >= CACHE_MAX_GROUP_ENTRIES) {
// Clean half of the entries
@@ -53,41 +51,54 @@ const privModeStorage = new ContentPrefS
ContentPrefService2.prototype = {
// XPCOM Plumbing
classID: Components.ID("{e3f772f3-023f-4b32-b074-36cf0fd5d414}"),
// Destruction
- _destroy: function ContentPrefService__destroy() {
- Services.obs.removeObserver(this, "xpcom-shutdown");
+ _destroy: function CPS2__destroy() {
+ Services.obs.removeObserver(this, "profile-before-change");
Services.obs.removeObserver(this, "last-pb-context-exited");
- this.destroy();
-
- this._dbConnection.asyncClose(() => {
- Services.obs.notifyObservers(null, "content-prefs-db-closed");
- });
-
// Delete references to XPCOM components to make sure we don't leak them
// (although we haven't observed leakage in tests). Also delete references
// in _observers and _genericObservers to avoid cycles with those that
// refer to us and don't remove themselves from those observer pools.
delete this._observers;
delete this._genericObservers;
delete this.__grouper;
},
// in-memory cache and private-browsing stores
_cache: cache,
_pbStore: privModeStorage,
+ _connPromise: null,
+
+ get conn() {
+ if (this._connPromise) {
+ return this._connPromise;
+ }
+
+ return this._connPromise = new Promise(async (resolve, reject) => {
+ let conn;
+ try {
+ conn = await this._getConnection();
+ } catch (e) {
+ this.log("Failed to establish database connection: " + e);
+ reject(e);
+ }
+ resolve(conn);
+ });
+ },
+
// nsIContentPrefService
getByName: function CPS2_getByName(name, context, callback) {
checkNameArg(name);
checkCallbackArg(callback, true);
// Some prefs may be in both the database and the private browsing store.
// Notify the caller of such prefs only once, using the values from private
@@ -114,32 +125,32 @@ ContentPrefService2.prototype = {
SELECT NULL AS grp, prefs.value AS value
FROM prefs
JOIN settings ON settings.id = prefs.settingID
WHERE settings.name = :name AND prefs.groupID ISNULL
`);
stmt2.params.name = name;
this._execStmts([stmt1, stmt2], {
- onRow: function onRow(row) {
+ onRow: row => {
let grp = row.getResultByName("grp");
let val = row.getResultByName("value");
this._cache.set(grp, name, val);
if (!pbPrefs.has(grp, name))
cbHandleResult(callback, new ContentPref(grp, name, val));
},
- onDone: function onDone(reason, ok, gotRow) {
+ onDone: (reason, ok, gotRow) => {
if (ok) {
for (let [pbGroup, pbName, pbVal] of pbPrefs) {
cbHandleResult(callback, new ContentPref(pbGroup, pbName, pbVal));
}
}
cbHandleCompletion(callback, reason);
},
- onError: function onError(nsresult) {
+ onError: nsresult => {
cbHandleError(callback, nsresult);
}
});
},
getByDomainAndName: function CPS2_getByDomainAndName(group, name, context,
callback) {
checkGroupArg(group);
@@ -169,40 +180,42 @@ ContentPrefService2.prototype = {
if (context && context.usePrivateBrowsing) {
for (let [sgroup, val] of
this._pbStore.match(group, name, includeSubdomains)) {
pbPrefs.set(sgroup, name, val);
}
}
this._execStmts([this._commonGetStmt(group, name, includeSubdomains)], {
- onRow: function onRow(row) {
+ onRow: row => {
let grp = row.getResultByName("grp");
let val = row.getResultByName("value");
this._cache.set(grp, name, val);
if (!pbPrefs.has(group, name))
cbHandleResult(callback, new ContentPref(grp, name, val));
},
- onDone: function onDone(reason, ok, gotRow) {
+ onDone: (reason, ok, gotRow) => {
if (ok) {
if (!gotRow)
this._cache.set(group, name, undefined);
for (let [pbGroup, pbName, pbVal] of pbPrefs) {
cbHandleResult(callback, new ContentPref(pbGroup, pbName, pbVal));
}
}
cbHandleCompletion(callback, reason);
},
- onError: function onError(nsresult) {
+ onError: nsresult => {
cbHandleError(callback, nsresult);
}
});
},
- _commonGetStmt: function CPS2__commonGetStmt(group, name, includeSubdomains) {
+ _commonGetStmt: function CPS2__commonGetStmt(group,
+ name,
+ includeSubdomains) {
let stmt = group ?
this._stmtWithGroupClause(group, includeSubdomains, `
SELECT groups.name AS grp, prefs.value AS value
FROM prefs
JOIN settings ON settings.id = prefs.settingID
JOIN groups ON groups.id = prefs.groupID
WHERE settings.name = :name AND prefs.groupID IN (${GROUP_CLAUSE})
`) :
@@ -214,20 +227,21 @@ ContentPrefService2.prototype = {
`);
stmt.params.name = name;
return stmt;
},
_stmtWithGroupClause: function CPS2__stmtWithGroupClause(group,
includeSubdomains,
sql) {
- let stmt = this._stmt(sql);
+ let stmt = this._stmt(sql, false);
stmt.params.group = group;
stmt.params.includeSubdomains = includeSubdomains || false;
- stmt.params.pattern = "%." + stmt.escapeStringForLIKE(group, "/");
+ stmt.params.pattern = "%." + (group == null ? null :
+ group.replace(/\/|%|_/g, "/$&"));
return stmt;
},
getCachedByDomainAndName: function CPS2_getCachedByDomainAndName(group,
name,
context) {
checkGroupArg(group);
let prefs = this._getCached(group, name, false, context);
@@ -354,24 +368,24 @@ ContentPrefService2.prototype = {
`);
}
stmt.params.name = name;
stmt.params.value = value;
stmt.params.now = Date.now() / 1000;
stmts.push(stmt);
this._execStmts(stmts, {
- onDone: function onDone(reason, ok) {
+ onDone: (reason, ok) => {
if (ok)
this._cache.setWithCast(group, name, value);
cbHandleCompletion(callback, reason);
if (ok)
this._notifyPrefSet(group, name, value, context && context.usePrivateBrowsing);
},
- onError: function onError(nsresult) {
+ onError: nsresult => {
cbHandleError(callback, nsresult);
}
});
},
removeByDomainAndName: function CPS2_removeByDomainAndName(group, name,
context,
callback) {
@@ -420,22 +434,22 @@ ContentPrefService2.prototype = {
stmts.push(stmt);
stmts = stmts.concat(this._settingsAndGroupsCleanupStmts());
let prefs = new ContentPrefStore();
let isPrivate = context && context.usePrivateBrowsing;
this._execStmts(stmts, {
- onRow: function onRow(row) {
+ onRow: row => {
let grp = row.getResultByName("grp");
prefs.set(grp, name, undefined);
this._cache.set(grp, name, undefined);
},
- onDone: function onDone(reason, ok) {
+ onDone: (reason, ok) => {
if (ok) {
this._cache.set(group, name, undefined);
if (isPrivate) {
for (let [sgroup, ] of
this._pbStore.match(group, name, includeSubdomains)) {
prefs.set(sgroup, name, undefined);
this._pbStore.remove(sgroup, name);
}
@@ -443,17 +457,17 @@ ContentPrefService2.prototype = {
}
cbHandleCompletion(callback, reason);
if (ok) {
for (let [sgroup, , ] of prefs) {
this._notifyPrefRemoved(sgroup, name, isPrivate);
}
}
},
- onError: function onError(nsresult) {
+ onError: nsresult => {
cbHandleError(callback, nsresult);
}
});
},
// Deletes settings and groups that are no longer used.
_settingsAndGroupsCleanupStmts() {
// The NOTNULL term in the subquery of the second statment is needed because of
@@ -532,23 +546,23 @@ ContentPrefService2.prototype = {
DELETE FROM settings
WHERE id NOT IN (SELECT DISTINCT settingID FROM prefs)
`));
let prefs = new ContentPrefStore();
let isPrivate = context && context.usePrivateBrowsing;
this._execStmts(stmts, {
- onRow: function onRow(row) {
+ onRow: row => {
let grp = row.getResultByName("grp");
let name = row.getResultByName("name");
prefs.set(grp, name, undefined);
this._cache.set(grp, name, undefined);
},
- onDone: function onDone(reason, ok) {
+ onDone: (reason, ok) => {
if (ok && isPrivate) {
for (let [sgroup, sname, ] of this._pbStore) {
if (!group ||
(!includeSubdomains && group == sgroup) ||
(includeSubdomains && sgroup && this._pbStore.groupsMatchIncludingSubdomains(group, sgroup))) {
prefs.set(sgroup, sname, undefined);
this._pbStore.remove(sgroup, sname);
}
@@ -556,17 +570,17 @@ ContentPrefService2.prototype = {
}
cbHandleCompletion(callback, reason);
if (ok) {
for (let [sgroup, sname, ] of prefs) {
this._notifyPrefRemoved(sgroup, sname, isPrivate);
}
}
},
- onError: function onError(nsresult) {
+ onError: nsresult => {
cbHandleError(callback, nsresult);
}
});
},
_removeAllDomainsSince: function CPS2__removeAllDomainsSince(since, context, callback) {
checkCallbackArg(callback, false);
@@ -598,23 +612,23 @@ ContentPrefService2.prototype = {
stmts.push(stmt);
// Cleanup no longer used values.
stmts = stmts.concat(this._settingsAndGroupsCleanupStmts());
let prefs = new ContentPrefStore();
let isPrivate = context && context.usePrivateBrowsing;
this._execStmts(stmts, {
- onRow: function onRow(row) {
+ onRow: row => {
let grp = row.getResultByName("grp");
let name = row.getResultByName("name");
prefs.set(grp, name, undefined);
this._cache.set(grp, name, undefined);
},
- onDone: function onDone(reason, ok) {
+ onDone: (reason, ok) => {
// This nukes all the groups in _pbStore since we don't have their timestamp
// information.
if (ok && isPrivate) {
for (let [sgroup, sname, ] of this._pbStore) {
if (sgroup) {
prefs.set(sgroup, sname, undefined);
}
}
@@ -622,17 +636,17 @@ ContentPrefService2.prototype = {
}
cbHandleCompletion(callback, reason);
if (ok) {
for (let [sgroup, sname, ] of prefs) {
this._notifyPrefRemoved(sgroup, sname, isPrivate);
}
}
},
- onError: function onError(nsresult) {
+ onError: nsresult => {
cbHandleError(callback, nsresult);
}
});
},
removeAllDomainsSince: function CPS2_removeAllDomainsSince(since, context, callback) {
this._removeAllDomainsSince(since, context, callback);
},
@@ -690,65 +704,56 @@ ContentPrefService2.prototype = {
SELECT DISTINCT groupID FROM prefs WHERE groupID NOTNULL
)
`));
let prefs = new ContentPrefStore();
let isPrivate = context && context.usePrivateBrowsing;
this._execStmts(stmts, {
- onRow: function onRow(row) {
+ onRow: row => {
let grp = row.getResultByName("grp");
prefs.set(grp, name, undefined);
this._cache.set(grp, name, undefined);
},
- onDone: function onDone(reason, ok) {
+ onDone: (reason, ok) => {
if (ok && isPrivate) {
for (let [sgroup, sname, ] of this._pbStore) {
if (sname === name) {
prefs.set(sgroup, name, undefined);
this._pbStore.remove(sgroup, name);
}
}
}
cbHandleCompletion(callback, reason);
if (ok) {
for (let [sgroup, , ] of prefs) {
this._notifyPrefRemoved(sgroup, name, isPrivate);
}
}
},
- onError: function onError(nsresult) {
+ onError: nsresult => {
cbHandleError(callback, nsresult);
}
});
},
- destroy: function CPS2_destroy() {
- if (this._statements) {
- for (let sql in this._statements) {
- let stmt = this._statements[sql];
- stmt.finalize();
- }
- }
- },
-
/**
* Returns the cached mozIStorageAsyncStatement for the given SQL. If no such
* statement is cached, one is created and cached.
*
* @param sql The SQL query string.
* @return The cached, possibly new, statement.
*/
- _stmt: function CPS2__stmt(sql) {
- if (!this._statements)
- this._statements = {};
- if (!this._statements[sql])
- this._statements[sql] = this._dbConnection.createAsyncStatement(sql);
- return this._statements[sql];
+ _stmt: function CPS2__stmt(sql, cachable = true) {
+ return {
+ sql,
+ cachable,
+ params: {},
+ };
},
/**
* Executes some async statements.
*
* @param stmts An array of mozIStorageAsyncStatements.
* @param callbacks An object with the following methods:
* onRow(row) (optional)
@@ -758,52 +763,53 @@ ContentPrefService2.prototype = {
* Called when done.
* reason: A nsIContentPrefService2.COMPLETE_* value.
* reasonOK: reason == nsIContentPrefService2.COMPLETE_OK.
* didGetRow: True if onRow was ever called.
* onError(nsresult) (optional)
* Called on error.
* nsresult: The error code.
*/
- _execStmts: function CPS2__execStmts(stmts, callbacks) {
- let self = this;
+ _execStmts: async function CPS2__execStmts(stmts, callbacks) {
+ let conn = await this.conn;
+ let ok = true;
let gotRow = false;
- this._dbConnection.executeAsync(stmts, stmts.length, {
- handleResult: function handleResult(results) {
+ let { onRow, onError } = callbacks;
+ await conn.executeTransaction(async () => {
+ for (let {sql, params, cachable} of stmts) {
try {
- let row = null;
- while ((row = results.getNextRow())) {
+ let execute = cachable ? conn.executeCached : conn.execute;
+ await execute.call(conn, sql, params, row => {
gotRow = true;
- if (callbacks.onRow)
- callbacks.onRow.call(self, row);
+ if (onRow) {
+ try {
+ onRow(row);
+ } catch (e) {
+ Cu.reportError(e);
+ }
+ }
+ });
+ } catch (e) {
+ try {
+ onError(Cr.NS_ERROR_FAILURE);
+ } catch (err) {
+ ok = false;
+ Cu.reportError(e);
}
- } catch (err) {
- Cu.reportError(err);
- }
- },
- handleCompletion: function handleCompletion(reason) {
- try {
- let ok = reason == Ci.mozIStorageStatementCallback.REASON_FINISHED;
- callbacks.onDone.call(self,
- ok ? Ci.nsIContentPrefCallback2.COMPLETE_OK :
- Ci.nsIContentPrefCallback2.COMPLETE_ERROR,
- ok, gotRow);
- } catch (err) {
- Cu.reportError(err);
- }
- },
- handleError: function handleError(error) {
- try {
- if (callbacks.onError)
- callbacks.onError.call(self, Cr.NS_ERROR_FAILURE);
- } catch (err) {
- Cu.reportError(err);
}
}
});
+
+ try {
+ callbacks.onDone(ok ? Ci.nsIContentPrefCallback2.COMPLETE_OK :
+ Ci.nsIContentPrefCallback2.COMPLETE_ERROR,
+ ok, gotRow);
+ } catch (e) {
+ Cu.reportError(e);
+ }
},
__grouper: null,
get _grouper() {
if (!this.__grouper)
this.__grouper = Cc["@mozilla.org/content-pref/hostname-grouper;1"].
getService(Ci.nsIContentURIGrouper);
return this.__grouper;
@@ -916,48 +922,50 @@ ContentPrefService2.prototype = {
* Tests use this as a backchannel by calling it directly.
*
* @param subj This value depends on topic.
* @param topic The backchannel "method" name.
* @param data This value depends on topic.
*/
observe: function CPS2_observe(subj, topic, data) {
switch (topic) {
- case "xpcom-shutdown":
+ case "profile-before-change":
this._destroy();
break;
case "last-pb-context-exited":
this._pbStore.removeAll();
break;
case "test:reset":
let fn = subj.QueryInterface(Ci.xpcIJSWeakReference).get();
this._reset(fn);
break;
case "test:db":
let obj = subj.QueryInterface(Ci.xpcIJSWeakReference).get();
- obj.value = this._dbConnection;
+ obj.value = this.conn;
break;
}
},
/**
* Removes all state from the service. Used by tests.
*
* @param callback A function that will be called when done.
*/
- _reset: function CPS2__reset(callback) {
+ async _reset(callback) {
this._pbStore.removeAll();
this._cache.removeAll();
this._observers = {};
this._genericObservers = [];
let tables = ["prefs", "groups", "settings"];
let stmts = tables.map(t => this._stmt(`DELETE FROM ${t}`));
- this._execStmts(stmts, { onDone: () => callback() });
+ this._execStmts(stmts, { onDone: () => {
+ callback();
+ } });
},
QueryInterface: function CPS2_QueryInterface(iid) {
let supportedIIDs = [
Ci.nsIContentPrefService2,
Ci.nsIObserver,
Ci.nsISupports,
];
@@ -996,196 +1004,189 @@ ContentPrefService2.prototype = {
},
prefs_idx: {
table: "prefs",
columns: ["timestamp", "groupID", "settingID"]
}
}
},
- _dbConnection: null,
+ _debugLog: false,
- // _dbInit and the methods it calls (_dbCreate, _dbMigrate, and version-
- // specific migration methods) must be careful not to call any method
- // of the service that assumes the database connection has already been
- // initialized, since it won't be initialized until at the end of _dbInit.
-
- _dbInit: function ContentPrefService__dbInit() {
- var dbFile = Services.dirsvc.get("ProfD", Ci.nsIFile);
- dbFile.append("content-prefs.sqlite");
+ log: function CPS2_log(aMessage) {
+ if (this._debugLog) {
+ Services.console.logStringMessage("ContentPrefService2: " + aMessage);
+ }
+ },
- var dbConnection;
+ async _getConnection(aAttemptNum = 0) {
+ let path = OS.Path.join(OS.Constants.Path.profileDir, "content-prefs.sqlite");
+ let conn;
+ let resetAndRetry = async e => {
+ if (e.status != Cr.NS_ERROR_FILE_CORRUPTED) {
+ throw e;
+ }
- if (!dbFile.exists())
- dbConnection = this._dbCreate(dbFile);
- else {
- try {
- dbConnection = Services.storage.openDatabase(dbFile);
- } catch (e) {
- // If the connection isn't ready after we open the database, that means
- // the database has been corrupted, so we back it up and then recreate it.
- if (e.result != Cr.NS_ERROR_FILE_CORRUPTED)
- throw e;
- dbConnection = this._dbBackUpAndRecreate(dbFile, dbConnection);
+ if (aAttemptNum >= this.MAX_ATTEMPTS) {
+ if (conn) {
+ await conn.close();
+ }
+ this.log("Establishing connection failed too many times. Giving up.");
+ throw e;
}
- // Get the version of the schema in the file.
- var version = dbConnection.schemaVersion;
+ try {
+ await this._failover(conn, path);
+ } catch (e) {
+ Cu.reportError(e);
+ throw e;
+ }
+ return this._getConnection(++aAttemptNum);
+ };
+ try {
+ conn = await Sqlite.openConnection({ path });
+ Sqlite.shutdown.addBlocker(
+ "Closing ContentPrefService2 connection.",
+ () => conn.close());
+ } catch (e) {
+ Cu.reportError(e);
+ return resetAndRetry(e);
+ }
- // Try to migrate the schema in the database to the current schema used by
- // the service. If migration fails, back up the database and recreate it.
- if (version != this._dbVersion) {
- try {
- this._dbMigrate(dbConnection, version, this._dbVersion);
- } catch (ex) {
- Cu.reportError("error migrating DB: " + ex + "; backing up and recreating");
- dbConnection = this._dbBackUpAndRecreate(dbFile, dbConnection);
- }
- }
+ try {
+ await this._dbMaybeInit(conn);
+ } catch (e) {
+ Cu.reportError(e);
+ return resetAndRetry(e);
}
// Turn off disk synchronization checking to reduce disk churn and speed up
// operations when prefs are changed rapidly (such as when a user repeatedly
// changes the value of the browser zoom setting for a site).
//
// Note: this could cause database corruption if the OS crashes or machine
// loses power before the data gets written to disk, but this is considered
// a reasonable risk for the not-so-critical data stored in this database.
//
// If you really don't want to take this risk, however, just set the
// toolkit.storage.synchronous pref to 1 (NORMAL synchronization) or 2
// (FULL synchronization), in which case mozStorageConnection::Initialize
// will use that value, and we won't override it here.
if (!Services.prefs.prefHasUserValue("toolkit.storage.synchronous"))
- dbConnection.executeSimpleSQL("PRAGMA synchronous = OFF");
+ await conn.execute("PRAGMA synchronous = OFF");
- this._dbConnection = dbConnection;
+ return conn;
},
- _dbCreate: function ContentPrefService__dbCreate(aDBFile) {
- var dbConnection = Services.storage.openDatabase(aDBFile);
-
- try {
- this._dbCreateSchema(dbConnection);
- dbConnection.schemaVersion = this._dbVersion;
- } catch (ex) {
- // If we failed to create the database (perhaps because the disk ran out
- // of space), then remove the database file so we don't leave it in some
- // half-created state from which we won't know how to recover.
- dbConnection.close();
- aDBFile.remove(false);
- throw ex;
+ async _failover(aConn, aPath) {
+ this.log("Cleaning up DB file - close & remove & backup.");
+ if (aConn) {
+ await aConn.close();
}
-
- return dbConnection;
+ let backupFile = aPath + ".corrupt";
+ let { file, path: uniquePath } =
+ await OS.File.openUnique(backupFile, { humanReadable: true });
+ await file.close();
+ await OS.File.copy(aPath, uniquePath);
+ await OS.File.remove(aPath);
+ this.log("Completed DB cleanup.");
},
- _dbCreateSchema: function ContentPrefService__dbCreateSchema(aDBConnection) {
- this._dbCreateTables(aDBConnection);
- this._dbCreateIndices(aDBConnection);
- },
+ _dbMaybeInit: async function CPS2__dbMaybeInit(aConn) {
+ let version = parseInt(await aConn.getSchemaVersion(), 10);
+ this.log("Schema version: " + version);
- _dbCreateTables: function ContentPrefService__dbCreateTables(aDBConnection) {
- for (let name in this._dbSchema.tables)
- aDBConnection.createTable(name, this._dbSchema.tables[name]);
- },
-
- _dbCreateIndices: function ContentPrefService__dbCreateIndices(aDBConnection) {
- for (let name in this._dbSchema.indices) {
- let index = this._dbSchema.indices[name];
- let statement = `
- CREATE INDEX IF NOT EXISTS ${name} ON ${index.table}
- (${index.columns.join(", ")})
- `;
- aDBConnection.executeSimpleSQL(statement);
+ if (version == 0) {
+ await this._dbCreateSchema(aConn);
+ } else if (version != this._dbVersion) {
+ await this._dbMigrate(aConn, version, this._dbVersion);
}
},
- _dbBackUpAndRecreate: function ContentPrefService__dbBackUpAndRecreate(aDBFile,
- aDBConnection) {
- Services.storage.backupDatabaseFile(aDBFile, "content-prefs.sqlite.corrupt");
+ _createTable: async function CPS2__createTable(aConn, aName) {
+ let tSQL = this._dbSchema.tables[aName];
+ this.log("Creating table " + aName + " with " + tSQL);
+ await aConn.execute(`CREATE TABLE ${aName} (${tSQL})`);
+ },
- // Close the database, ignoring the "already closed" exception, if any.
- // It'll be open if we're here because of a migration failure but closed
- // if we're here because of database corruption.
- try { aDBConnection.close(); } catch (ex) {}
-
- aDBFile.remove(false);
-
- let dbConnection = this._dbCreate(aDBFile);
-
- return dbConnection;
+ _createIndex: async function CPS2__createTable(aConn, aName) {
+ let index = this._dbSchema.indices[aName];
+ let statement = "CREATE INDEX IF NOT EXISTS " + aName + " ON " + index.table +
+ "(" + index.columns.join(", ") + ")";
+ await aConn.execute(statement);
},
- _dbMigrate: function ContentPrefService__dbMigrate(aDBConnection, aOldVersion, aNewVersion) {
+ _dbCreateSchema: async function CPS2__dbCreateSchema(aConn) {
+ await aConn.executeTransaction(async () => {
+ this.log("Creating DB -- tables");
+ for (let name in this._dbSchema.tables) {
+ await this._createTable(aConn, name);
+ }
+
+ this.log("Creating DB -- indices");
+ for (let name in this._dbSchema.indices) {
+ await this._createIndex(aConn, name);
+ }
+
+ await aConn.setSchemaVersion(this._dbVersion);
+ });
+ },
+
+ _dbMigrate: async function CPS2__dbMigrate(aConn, aOldVersion, aNewVersion) {
/**
* Migrations should follow the template rules in bug 1074817 comment 3 which are:
* 1. Migration should be incremental and non-breaking.
* 2. It should be idempotent because one can downgrade an upgrade again.
* On downgrade:
* 1. Decrement schema version so that upgrade runs the migrations again.
*/
- aDBConnection.beginTransaction();
-
- try {
- /**
- * If the schema version is 0, that means it was never set, which means
- * the database was somehow created without the schema being applied, perhaps
- * because the system ran out of disk space (although we check for this
- * in _createDB) or because some other code created the database file without
- * applying the schema. In any case, recover by simply reapplying the schema.
- */
- if (aOldVersion == 0) {
- this._dbCreateSchema(aDBConnection);
- } else {
- for (let i = aOldVersion; i < aNewVersion; i++) {
- let migrationName = "_dbMigrate" + i + "To" + (i + 1);
- if (typeof this[migrationName] != "function") {
- throw new Error("no migrator function from version " + aOldVersion + " to version " +
- aNewVersion);
- }
- this[migrationName](aDBConnection);
+ await aConn.executeTransaction(async () => {
+ for (let i = aOldVersion; i < aNewVersion; i++) {
+ let migrationName = "_dbMigrate" + i + "To" + (i + 1);
+ if (typeof this[migrationName] != "function") {
+ throw new Error("no migrator function from version " + aOldVersion + " to version " +
+ aNewVersion);
}
+ await this[migrationName](aConn);
}
- aDBConnection.schemaVersion = aNewVersion;
- aDBConnection.commitTransaction();
- } catch (ex) {
- aDBConnection.rollbackTransaction();
- throw ex;
- }
+ await aConn.setSchemaVersion(aNewVersion);
+ });
},
- _dbMigrate1To2: function ContentPrefService___dbMigrate1To2(aDBConnection) {
- aDBConnection.executeSimpleSQL("ALTER TABLE groups RENAME TO groupsOld");
- aDBConnection.createTable("groups", this._dbSchema.tables.groups);
- aDBConnection.executeSimpleSQL(`
+ _dbMigrate1To2: async function CPS2___dbMigrate1To2(aConn) {
+ await aConn.execute("ALTER TABLE groups RENAME TO groupsOld");
+ await this._createTable(aConn, "groups");
+ await aConn.execute(`
INSERT INTO groups (id, name)
SELECT id, name FROM groupsOld
`);
- aDBConnection.executeSimpleSQL("DROP TABLE groupers");
- aDBConnection.executeSimpleSQL("DROP TABLE groupsOld");
- },
-
- _dbMigrate2To3: function ContentPrefService__dbMigrate2To3(aDBConnection) {
- this._dbCreateIndices(aDBConnection);
+ await aConn.execute("DROP TABLE groupers");
+ await aConn.execute("DROP TABLE groupsOld");
},
- _dbMigrate3To4: function ContentPrefService__dbMigrate3To4(aDBConnection) {
+ _dbMigrate2To3: async function CPS2__dbMigrate2To3(aConn) {
+ for (let name in this._dbSchema.indices) {
+ await this._createIndex(aConn, name);
+ }
+ },
+
+ _dbMigrate3To4: async function CPS2__dbMigrate3To4(aConn) {
// Add timestamp column if it does not exist yet. This operation is idempotent.
try {
- let stmt = aDBConnection.createStatement("SELECT timestamp FROM prefs");
- stmt.finalize();
+ await aConn.execute("SELECT timestamp FROM prefs");
} catch (e) {
- aDBConnection.executeSimpleSQL("ALTER TABLE prefs ADD COLUMN timestamp INTEGER NOT NULL DEFAULT 0");
+ await aConn.execute("ALTER TABLE prefs ADD COLUMN timestamp INTEGER NOT NULL DEFAULT 0");
}
// To modify prefs_idx drop it and create again.
- aDBConnection.executeSimpleSQL("DROP INDEX IF EXISTS prefs_idx");
- this._dbCreateIndices(aDBConnection);
+ await aConn.execute("DROP INDEX IF EXISTS prefs_idx");
+ for (let name in this._dbSchema.indices) {
+ await this._createIndex(aConn, name);
+ }
},
};
function checkGroupArg(group) {
if (!group || typeof(group) != "string")
throw invalidArg("domain must be nonempty string.");
}
