Source: lib/offline/indexeddb/storage_mechanism.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.offline.indexeddb.StorageMechanism');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.device.DeviceFactory');
  11. goog.require('shaka.log');
  12. goog.require('shaka.offline.StorageMuxer');
  13. goog.require('shaka.offline.indexeddb.EmeSessionStorageCell');
  14. goog.require('shaka.offline.indexeddb.V1StorageCell');
  15. goog.require('shaka.offline.indexeddb.V2StorageCell');
  16. goog.require('shaka.offline.indexeddb.V5StorageCell');
  17. goog.require('shaka.util.Error');
  18. goog.require('shaka.util.PublicPromise');
  19. goog.require('shaka.util.Timer');
  22. /**
  23.  * A storage mechanism to manage storage cells for an indexed db instance.
  24.  * The cells are just for interacting with the stores that are found in the
  25.  * database instance. The mechanism is responsible for creating new stores
  26.  * when opening the database. If the database is too old of a version, a
  27.  * cell will be added for the old stores but the cell won't support add
  28.  * operations. The mechanism will create the new versions of the stores and
  29.  * will allow add operations for those stores.
  30.  *
  31.  * @implements {shaka.extern.StorageMechanism}
  32.  */
  33. shaka.offline.indexeddb.StorageMechanism = class {
  34.   /** */
  35.   constructor() {
  36.     /** @private {IDBDatabase} */
  37.     this.db_ = null;
  39.     /** @private {shaka.extern.StorageCell} */
  40.     this.v1_ = null;
  41.     /** @private {shaka.extern.StorageCell} */
  42.     this.v2_ = null;
  43.     /** @private {shaka.extern.StorageCell} */
  44.     this.v3_ = null;
  45.     /** @private {shaka.extern.StorageCell} */
  46.     this.v5_ = null;
  47.     /** @private {shaka.extern.EmeSessionStorageCell} */
  48.     this.sessions_ = null;
  49.   }
  51.   /**
  52.    * @override
  53.    */
  54.   init() {
  55.     const name = shaka.offline.indexeddb.StorageMechanism.DB_NAME;
  56.     const version = shaka.offline.indexeddb.StorageMechanism.VERSION;
  58.     const p = new shaka.util.PublicPromise();
  60.     // Add a timeout mechanism, for the (rare?) case where no callbacks are
  61.     // called at all, so that this method doesn't hang forever.
  62.     let timedOut = false;
  63.     const timeOutTimer = new shaka.util.Timer(() => {
  64.       timedOut = true;
  65.       p.reject(new shaka.util.Error(
  66.           shaka.util.Error.Severity.CRITICAL,
  67.           shaka.util.Error.Category.STORAGE,
  68.           shaka.util.Error.Code.INDEXED_DB_INIT_TIMED_OUT));
  69.     });
  70.     const openTimeout = shaka.offline.indexeddb.StorageMechanismOpenTimeout;
  71.     if (typeof openTimeout === 'number' && openTimeout > 0) {
  72.       timeOutTimer.tickAfter(openTimeout);
  73.     }
  75.     const open = window.indexedDB.open(name, version);
  76.     open.onsuccess = (event) => {
  77.       if (timedOut) {
  78.         // Too late, we have already given up on opening the storage mechanism.
  79.         return;
  80.       }
  81.       timeOutTimer.stop();
  82.       const db = open.result;
  83.       this.db_ = db;
  84.       this.v1_ = shaka.offline.indexeddb.StorageMechanism.createV1_(db);
  85.       this.v2_ = shaka.offline.indexeddb.StorageMechanism.createV2_(db);
  86.       this.v3_ = shaka.offline.indexeddb.StorageMechanism.createV3_(db);
  87.       // NOTE: V4 of the database was when we introduced a special table to
  88.       // store EME session IDs.  It has no separate storage cell, so we skip to
  89.       // V5.
  90.       this.v5_ = shaka.offline.indexeddb.StorageMechanism.createV5_(db);
  91.       this.sessions_ =
  92.           shaka.offline.indexeddb.StorageMechanism.createEmeSessionCell_(db);
  93.       p.resolve();
  94.     };
  95.     open.onupgradeneeded = (event) => {
  96.       // Add object stores for the latest version only.
  97.       this.createStores_(open.result);
  98.     };
  99.     open.onerror = (event) => {
  100.       if (timedOut) {
  101.         // Too late, we have already given up on opening the storage mechanism.
  102.         return;
  103.       }
  104.       timeOutTimer.stop();
  105.       p.reject(new shaka.util.Error(
  106.           shaka.util.Error.Severity.CRITICAL,
  107.           shaka.util.Error.Category.STORAGE,
  108.           shaka.util.Error.Code.INDEXED_DB_ERROR,
  109.           open.error));
  111.       // Firefox will raise an error on the main thread unless we stop it here.
  112.       event.preventDefault();
  113.     };
  115.     return p;
  116.   }
  118.   /**
  119.    * @override
  120.    */
  121.   async destroy() {
  122.     if (this.v1_) {
  123.       await this.v1_.destroy();
  124.     }
  125.     if (this.v2_) {
  126.       await this.v2_.destroy();
  127.     }
  128.     if (this.v3_) {
  129.       await this.v3_.destroy();
  130.     }
  131.     if (this.v5_) {
  132.       await this.v5_.destroy();
  133.     }
  134.     if (this.sessions_) {
  135.       await this.sessions_.destroy();
  136.     }
  138.     // If we were never initialized, then |db_| will still be null.
  139.     if (this.db_) {
  140.       this.db_.close();
  141.     }
  142.   }
  144.   /**
  145.    * @override
  146.    */
  147.   getCells() {
  148.     const map = new Map();
  150.     if (this.v1_) {
  151.       map.set('v1', this.v1_);
  152.     }
  153.     if (this.v2_) {
  154.       map.set('v2', this.v2_);
  155.     }
  156.     if (this.v3_) {
  157.       map.set('v3', this.v3_);
  158.     }
  159.     if (this.v5_) {
  160.       map.set('v5', this.v5_);
  161.     }
  163.     return map;
  164.   }
  166.   /**
  167.    * @override
  168.    */
  169.   getEmeSessionCell() {
  170.     goog.asserts.assert(this.sessions_, 'Cannot be destroyed.');
  171.     return this.sessions_;
  172.   }
  174.   /**
  175.    * @override
  176.    */
  177.   async erase() {
  178.     // Not all cells may have been created, so only destroy the ones that
  179.     // were created.
  180.     if (this.v1_) {
  181.       await this.v1_.destroy();
  182.     }
  183.     if (this.v2_) {
  184.       await this.v2_.destroy();
  185.     }
  186.     if (this.v3_) {
  187.       await this.v3_.destroy();
  188.     }
  189.     if (this.v5_) {
  190.       await this.v5_.destroy();
  191.     }
  193.     // |db_| will only be null if the muxer was not initialized. We need to
  194.     // close the connection in order delete the database without it being
  195.     // blocked.
  196.     if (this.db_) {
  197.       this.db_.close();
  198.     }
  200.     await shaka.offline.indexeddb.StorageMechanism.deleteAll_();
  202.     // Reset before initializing.
  203.     this.db_ = null;
  204.     this.v1_ = null;
  205.     this.v2_ = null;
  206.     this.v3_ = null;
  207.     this.v5_ = null;
  209.     await this.init();
  210.   }
  212.   /**
  213.    * @param {!IDBDatabase} db
  214.    * @return {shaka.extern.StorageCell}
  215.    * @private
  216.    */
  217.   static createV1_(db) {
  218.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  219.     const segmentStore = StorageMechanism.V1_SEGMENT_STORE;
  220.     const manifestStore = StorageMechanism.V1_MANIFEST_STORE;
  221.     const stores = db.objectStoreNames;
  222.     if (stores.contains(manifestStore) && stores.contains(segmentStore)) {
  223.       shaka.log.debug('Mounting v1 idb storage cell');
  225.       return new shaka.offline.indexeddb.V1StorageCell(
  226.           db,
  227.           segmentStore,
  228.           manifestStore);
  229.     }
  230.     return null;
  231.   }
  233.   /**
  234.    * @param {!IDBDatabase} db
  235.    * @return {shaka.extern.StorageCell}
  236.    * @private
  237.    */
  238.   static createV2_(db) {
  239.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  240.     const segmentStore = StorageMechanism.V2_SEGMENT_STORE;
  241.     const manifestStore = StorageMechanism.V2_MANIFEST_STORE;
  242.     const stores = db.objectStoreNames;
  243.     if (stores.contains(manifestStore) && stores.contains(segmentStore)) {
  244.       shaka.log.debug('Mounting v2 idb storage cell');
  246.       return new shaka.offline.indexeddb.V2StorageCell(
  247.           db,
  248.           segmentStore,
  249.           manifestStore);
  250.     }
  251.     return null;
  252.   }
  254.   /**
  255.    * @param {!IDBDatabase} db
  256.    * @return {shaka.extern.StorageCell}
  257.    * @private
  258.    */
  259.   static createV3_(db) {
  260.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  261.     const segmentStore = StorageMechanism.V3_SEGMENT_STORE;
  262.     const manifestStore = StorageMechanism.V3_MANIFEST_STORE;
  263.     const stores = db.objectStoreNames;
  264.     if (stores.contains(manifestStore) && stores.contains(segmentStore)) {
  265.       shaka.log.debug('Mounting v3 idb storage cell');
  267.       // Version 3 uses the same structure as version 2, so we can use the same
  268.       // cells but it can support new entries.
  269.       return new shaka.offline.indexeddb.V2StorageCell(
  270.           db,
  271.           segmentStore,
  272.           manifestStore);
  273.     }
  274.     return null;
  275.   }
  277.   /**
  278.    * @param {!IDBDatabase} db
  279.    * @return {shaka.extern.StorageCell}
  280.    * @private
  281.    */
  282.   static createV5_(db) {
  283.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  284.     const segmentStore = StorageMechanism.V5_SEGMENT_STORE;
  285.     const manifestStore = StorageMechanism.V5_MANIFEST_STORE;
  286.     const stores = db.objectStoreNames;
  287.     if (stores.contains(manifestStore) && stores.contains(segmentStore)) {
  288.       shaka.log.debug('Mounting v5 idb storage cell');
  290.       return new shaka.offline.indexeddb.V5StorageCell(
  291.           db,
  292.           segmentStore,
  293.           manifestStore);
  294.     }
  295.     return null;
  296.   }
  298.   /**
  299.    * @param {!IDBDatabase} db
  300.    * @return {shaka.extern.EmeSessionStorageCell}
  301.    * @private
  302.    */
  303.   static createEmeSessionCell_(db) {
  304.     const StorageMechanism = shaka.offline.indexeddb.StorageMechanism;
  305.     const store = StorageMechanism.SESSION_ID_STORE;
  306.     if (db.objectStoreNames.contains(store)) {
  307.       shaka.log.debug('Mounting session ID idb storage cell');
  308.       return new shaka.offline.indexeddb.EmeSessionStorageCell(db, store);
  309.     }
  310.     return null;
  311.   }
  313.   /**
  314.    * @param {!IDBDatabase} db
  315.    * @private
  316.    */
  317.   createStores_(db) {
  318.     const storeNames = [
  319.       shaka.offline.indexeddb.StorageMechanism.V5_SEGMENT_STORE,
  320.       shaka.offline.indexeddb.StorageMechanism.V5_MANIFEST_STORE,
  321.       shaka.offline.indexeddb.StorageMechanism.SESSION_ID_STORE,
  322.     ];
  324.     for (const name of storeNames) {
  325.       if (!db.objectStoreNames.contains(name)) {
  326.         db.createObjectStore(name, {autoIncrement: true});
  327.       }
  328.     }
  329.   }
  331.   /**
  332.    * Delete the indexed db instance so that all stores are deleted and cleared.
  333.    * This will force the database to a like-new state next time it opens.
  334.    *
  335.    * @return {!Promise}
  336.    * @private
  337.    */
  338.   static deleteAll_() {
  339.     const name = shaka.offline.indexeddb.StorageMechanism.DB_NAME;
  341.     const p = new shaka.util.PublicPromise();
  343.     const del = window.indexedDB.deleteDatabase(name);
  344.     del.onblocked = (event) => {
  345.       shaka.log.warning('Deleting', name, 'is being blocked', event);
  346.     };
  347.     del.onsuccess = (event) => {
  348.       p.resolve();
  349.     };
  350.     del.onerror = (event) => {
  351.       p.reject(new shaka.util.Error(
  352.           shaka.util.Error.Severity.CRITICAL,
  353.           shaka.util.Error.Category.STORAGE,
  354.           shaka.util.Error.Code.INDEXED_DB_ERROR,
  355.           del.error));
  357.       // Firefox will raise an error on the main thread unless we stop it here.
  358.       event.preventDefault();
  359.     };
  361.     return p;
  362.   }
  363. };
  365. /** @const {string} */
  366. shaka.offline.indexeddb.StorageMechanism.DB_NAME = 'shaka_offline_db';
  367. /** @const {number} */
  368. shaka.offline.indexeddb.StorageMechanism.VERSION = 5;
  369. /** @const {string} */
  370. shaka.offline.indexeddb.StorageMechanism.V1_SEGMENT_STORE = 'segment';
  371. /** @const {string} */
  372. shaka.offline.indexeddb.StorageMechanism.V2_SEGMENT_STORE = 'segment-v2';
  373. /** @const {string} */
  374. shaka.offline.indexeddb.StorageMechanism.V3_SEGMENT_STORE = 'segment-v3';
  375. /** @const {string} */
  376. shaka.offline.indexeddb.StorageMechanism.V5_SEGMENT_STORE = 'segment-v5';
  377. /** @const {string} */
  378. shaka.offline.indexeddb.StorageMechanism.V1_MANIFEST_STORE = 'manifest';
  379. /** @const {string} */
  380. shaka.offline.indexeddb.StorageMechanism.V2_MANIFEST_STORE = 'manifest-v2';
  381. /** @const {string} */
  382. shaka.offline.indexeddb.StorageMechanism.V3_MANIFEST_STORE = 'manifest-v3';
  383. /** @const {string} */
  384. shaka.offline.indexeddb.StorageMechanism.V5_MANIFEST_STORE = 'manifest-v5';
  385. /** @const {string} */
  386. shaka.offline.indexeddb.StorageMechanism.SESSION_ID_STORE = 'session-ids';
  388. /**
  389.  * Timeout in seconds for opening the IndexedDB database,
  390.  * or <code>false</code> to disable the timeout and wait indefinitely
  391.  * for the database to open successfully or fail.
  392.  * @type {number|boolean}
  393.  * @export
  394.  */
  395. shaka.offline.indexeddb.StorageMechanismOpenTimeout = 5;
  397. // Since this may be called before the polyfills remove indexeddb support from
  398. // some platforms (looking at you Chromecast), we need to check for support
  399. // when we create the mechanism.
  400. //
  401. // Thankfully the storage muxer api allows us to return a null mechanism
  402. // to indicate that the mechanism is not supported on this platform.
  403. shaka.offline.StorageMuxer.register(
  404.     'idb',
  405.     () => {
  406.       const device = shaka.device.DeviceFactory.getDevice();
  407.       if (!device.supportsOfflineStorage()) {
  408.         return null;
  409.       }
  410.       return new shaka.offline.indexeddb.StorageMechanism();
  411.     });