Source: lib/offline/db_engine.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.offline.DBEngine');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.offline.IStorageEngine');
  23. goog.require('shaka.util.Error');
  24. goog.require('shaka.util.Functional');
  25. goog.require('shaka.util.PublicPromise');
  29. /**
  30.  * This manages all operations on an IndexedDB.  This wraps all operations
  31.  * in Promises.  All Promises will resolve once the transaction has completed.
  32.  * Depending on the browser, this may or may not be after the data is flushed
  33.  * to disk.  https://goo.gl/zMOeJc
  34.  *
  35.  * @struct
  36.  * @constructor
  37.  * @implements {shaka.offline.IStorageEngine}
  38.  */
  39. shaka.offline.DBEngine = function() {
  40.   goog.asserts.assert(
  41.       shaka.offline.DBEngine.isSupported(),
  42.       'DBEngine should not be called when DBEngine is not supported');
  44.   /** @private {IDBDatabase} */
  45.   this.db_ = null;
  47.   /** @private {!Array.<shaka.offline.DBEngine.Operation>} */
  48.   this.operations_ = [];
  50.   /** @private {!Object.<string, number>} */
  51.   this.currentIdMap_ = {};
  52. };
  55. /**
  56.  * @typedef {{
  57.  *   transaction: !IDBTransaction,
  58.  *   promise: !shaka.util.PublicPromise
  59.  * }}
  60.  *
  61.  * @property {!IDBTransaction} transaction
  62.  *   The transaction that this operation is using.
  63.  * @property {!shaka.util.PublicPromise} promise
  64.  *   The promise associated with the operation.
  65.  */
  66. shaka.offline.DBEngine.Operation;
  69. /** @private {string} */
  70. shaka.offline.DBEngine.DB_NAME_ = 'shaka_offline_db';
  73. /** @private @const {number} */
  74. shaka.offline.DBEngine.DB_VERSION_ = 1;
  77. /**
  78.  * Determines if the browsers supports IndexedDB.
  79.  * @return {boolean}
  80.  */
  81. shaka.offline.DBEngine.isSupported = function() {
  82.   return window.indexedDB != null;
  83. };
  86. /**
  87.  * Delete the database.  There must be no open connections to the database.
  88.  * @return {!Promise}
  89.  */
  90. shaka.offline.DBEngine.deleteDatabase = function() {
  91.   if (!window.indexedDB)
  92.     return Promise.resolve();
  93.   var request =
  94.       window.indexedDB.deleteDatabase(shaka.offline.DBEngine.DB_NAME_);
  96.   var p = new shaka.util.PublicPromise();
  97.   request.onsuccess = function(event) {
  98.     goog.asserts.assert(event.newVersion == null, 'Unexpected database update');
  99.     p.resolve();
  100.   };
  101.   request.onerror = shaka.offline.DBEngine.onError_.bind(null, request, p);
  102.   return p;
  103. };
  106. /** @override */
  107. shaka.offline.DBEngine.prototype.initialized = function() {
  108.   return this.db_ != null;
  109. };
  112. /** @override */
  113. shaka.offline.DBEngine.prototype.init = function(storeMap, opt_retryCount) {
  114.   goog.asserts.assert(!this.db_, 'Already initialized');
  116.   return this.createConnection_(storeMap, opt_retryCount).then(function() {
  117.     // For each store, get the next ID and store in the map.
  118.     var stores = Object.keys(storeMap);
  119.     return Promise.all(stores.map(function(store) {
  120.       return this.getNextId_(store).then(function(id) {
  121.         this.currentIdMap_[store] = id;
  122.       }.bind(this));
  123.     }.bind(this)));
  124.   }.bind(this));
  125. };
  128. /** @override */
  129. shaka.offline.DBEngine.prototype.destroy = function() {
  130.   return Promise.all(this.operations_.map(function(op) {
  131.     try {
  132.       // If the transaction is considered finished but has not called the
  133.       // callbacks yet, it will still be in the list and this call will fail.
  134.       // Simply ignore errors.
  135.       op.transaction.abort();
  136.     } catch (e) {}
  138.     var Functional = shaka.util.Functional;
  139.     return op.promise.catch(Functional.noop);
  140.   })).then(function() {
  141.     goog.asserts.assert(this.operations_.length == 0,
  142.                         'All operations should have been closed');
  143.     if (this.db_) {
  144.       this.db_.close();
  145.       this.db_ = null;
  146.     }
  147.   }.bind(this));
  148. };
  151. /** @override */
  152. shaka.offline.DBEngine.prototype.get = function(storeName, key) {
  153.   /** @type {!IDBRequest} */
  154.   var request;
  155.   return this.createTransaction_(storeName, 'readonly', function(store) {
  156.     request = store.get(key);
  157.   }).then(function() { return request.result; });
  158. };
  161. /** @override */
  162. shaka.offline.DBEngine.prototype.forEach = function(storeName, callback) {
  163.   return this.createTransaction_(storeName, 'readonly', function(store) {
  164.     var request = store.openCursor();
  165.     request.onsuccess = function(event) {
  166.       var cursor = event.target.result;
  167.       if (cursor) {
  168.         callback(cursor.value);
  169.         cursor.continue();
  170.       }
  171.     };
  172.   });
  173. };
  176. /** @override */
  177. shaka.offline.DBEngine.prototype.insert = function(storeName, value) {
  178.   return this.createTransaction_(storeName, 'readwrite', function(store) {
  179.     store.put(value);
  180.   });
  181. };
  184. /** @override */
  185. shaka.offline.DBEngine.prototype.remove = function(storeName, key) {
  186.   return this.createTransaction_(storeName, 'readwrite', function(store) {
  187.     store.delete(key);
  188.   });
  189. };
  192. /** @override */
  193. shaka.offline.DBEngine.prototype.removeKeys = function(storeName,
  194.                                                        keys,
  195.                                                        opt_onKeyRemoved) {
  196.   return this.createTransaction_(storeName, 'readwrite', function(store) {
  197.     for (var i = 0; i < keys.length; i++) {
  198.       var request = store.delete(keys[i]);
  199.       request.onsuccess = opt_onKeyRemoved || function(event) { };
  200.     }
  201.   });
  202. };
  205. /** @override */
  206. shaka.offline.DBEngine.prototype.reserveId = function(storeName) {
  207.   goog.asserts.assert(storeName in this.currentIdMap_,
  208.                       'Store name must be passed to init()');
  209.   return this.currentIdMap_[storeName]++;
  210. };
  213. /**
  214.  * Gets the ID to start at.
  215.  *
  216.  * @param {string} storeName
  217.  * @return {!Promise.<number>}
  218.  * @private
  219.  */
  220. shaka.offline.DBEngine.prototype.getNextId_ = function(storeName) {
  221.   var id = 0;
  222.   return this.createTransaction_(storeName, 'readonly', function(store) {
  223.     var request = store.openCursor(null, 'prev');
  224.     request.onsuccess = function(event) {
  225.       var cursor = event.target.result;
  226.       if (cursor) {
  227.         id = cursor.key + 1;
  228.       }
  229.     };
  230.   }).then(function() { return id; });
  231. };
  234. /**
  235.  * Creates a new transaction for the given store name and calls |action| to
  236.  * modify the store. The transaction will resolve or reject the promise
  237.  * returned by this function.
  238.  *
  239.  * @param {string} storeName
  240.  * @param {string} type
  241.  * @param {!function(IDBObjectStore)} action
  242.  *
  243.  * @return {!Promise}
  244.  * @private
  245.  */
  246. shaka.offline.DBEngine.prototype.createTransaction_ = function(storeName,
  247.                                                                type,
  248.                                                                action) {
  250.   goog.asserts.assert(this.db_, 'DBEngine must not be destroyed');
  251.   goog.asserts.assert(type == 'readonly' || type == 'readwrite',
  252.                       'Type must be "readonly" or "readwrite"');
  254.   var op = {
  255.     transaction: this.db_.transaction([storeName], type),
  256.     promise: new shaka.util.PublicPromise()
  257.   };
  259.   op.transaction.oncomplete = (function(event) {
  260.     this.closeOperation_(op);
  261.     op.promise.resolve();
  262.   }.bind(this));
  264.   // We will see an onabort call via:
  265.   //   1. request error -> transaction error -> transaction abort
  266.   //   2. transaction commit fail -> transaction abort
  267.   // As any transaction error will result in an abort, it is better to listen
  268.   // for an abort so that we will catch all failed transaction operations.
  269.   op.transaction.onabort = (function(event) {
  270.     this.closeOperation_(op);
  271.     shaka.offline.DBEngine.onError_(op.transaction, op.promise, event);
  272.   }.bind(this));
  274.   // We need to prevent default on the onerror event or else Firefox will
  275.   // raise an error which will cause a karma failure. This will not stop the
  276.   // onabort callback from firing.
  277.   op.transaction.onerror = (function(event) {
  278.     event.preventDefault();
  279.   }.bind(this));
  281.   var store = op.transaction.objectStore(storeName);
  282.   action(store);
  284.   this.operations_.push(op);
  286.   return op.promise;
  287. };
  290. /**
  291.  * Close an open operation.
  292.  *
  293.  * @param {!shaka.offline.DBEngine.Operation} op
  294.  * @private
  295.  */
  296. shaka.offline.DBEngine.prototype.closeOperation_ = function(op) {
  297.   var i = this.operations_.indexOf(op);
  298.   goog.asserts.assert(i >= 0, 'Operation must be in the list.');
  299.   this.operations_.splice(i, 1);
  300. };
  303. /**
  304.  * Creates a new connection to the database.
  305.  *
  306.  * On IE/Edge, it is possible for the database to not be deleted when the
  307.  * success callback is fired.  This means that when we delete the database and
  308.  * immediately create a new connection, we will connect to the old database.
  309.  * If this happens, we need to close the connection and retry.
  310.  *
  311.  * @see https://goo.gl/hOYJvN
  312.  *
  313.  * @param {!Object.<string, string>} storeMap
  314.  * @param {number=} opt_retryCount
  315.  * @return {!Promise}
  316.  * @private
  317.  */
  318. shaka.offline.DBEngine.prototype.createConnection_ = function(
  319.     storeMap, opt_retryCount) {
  320.   var DBEngine = shaka.offline.DBEngine;
  322.   var indexedDB = window.indexedDB;
  323.   var request = indexedDB.open(DBEngine.DB_NAME_, DBEngine.DB_VERSION_);
  325.   var upgraded = false;
  326.   var createPromise = new shaka.util.PublicPromise();
  327.   request.onupgradeneeded = function(event) {
  328.     upgraded = true;
  329.     var db = event.target.result;
  330.     goog.asserts.assert(event.oldVersion == 0,
  331.                         'Must be upgrading from version 0');
  332.     goog.asserts.assert(db.objectStoreNames.length == 0,
  333.                         'Version 0 database should be empty');
  334.     for (var name in storeMap) {
  335.       db.createObjectStore(name, {keyPath: storeMap[name]});
  336.     }
  337.   };
  338.   request.onsuccess = (function(event) {
  339.     if (opt_retryCount && !upgraded) {
  340.       event.target.result.close();
  342.       shaka.log.info('Didn\'t get an upgrade event... trying again.');
  343.       setTimeout(function() {
  344.         var p = this.createConnection_(storeMap, opt_retryCount - 1);
  345.         p.then(createPromise.resolve, createPromise.reject);
  346.       }.bind(this), 1000);
  347.       return;
  348.     }
  351.     goog.asserts.assert(opt_retryCount == undefined || upgraded,
  352.                         'Should get upgrade event');
  353.     this.db_ = event.target.result;
  354.     createPromise.resolve();
  355.   }.bind(this));
  356.   request.onerror = DBEngine.onError_.bind(null, request, createPromise);
  358.   return createPromise;
  359. };
  362. /**
  363.  * Rejects the given Promise using the error fromt the transaction.
  364.  *
  365.  * @param {!IDBTransaction|!IDBRequest} errorSource
  366.  * @param {!shaka.util.PublicPromise} promise
  367.  * @param {Event} event
  368.  * @private
  369.  */
  370. shaka.offline.DBEngine.onError_ = function(errorSource, promise, event) {
  372.   if (errorSource.error) {
  373.     promise.reject(new shaka.util.Error(
  374.         shaka.util.Error.Severity.CRITICAL,
  375.         shaka.util.Error.Category.STORAGE,
  376.         shaka.util.Error.Code.INDEXED_DB_ERROR, errorSource.error));
  377.   } else {
  378.     promise.reject(new shaka.util.Error(
  379.         shaka.util.Error.Severity.CRITICAL,
  380.         shaka.util.Error.Category.STORAGE,
  381.         shaka.util.Error.Code.OPERATION_ABORTED));
  382.   }
  384.   // Firefox will raise an error which will cause a karma failure.
  385.   event.preventDefault();
  386. };