Source: lib/offline/indexeddb/v2_storage_cell.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.indexeddb.V2StorageCell');
  20. goog.require('shaka.offline.indexeddb.DBConnection');
  21. goog.require('shaka.util.Error');
  24. /**
  25.  * The V2StorageCell is for all stores that follow the shakaExterns V2 offline
  26.  * types. This storage cell will work for both IndexedDB version 2 and 3 as
  27.  * both used the shakaExterns V2 offline types.
  28.  *
  29.  * @implements {shakaExtern.StorageCell}
  30.  */
  31. shaka.offline.indexeddb.V2StorageCell = class {
  32.   /**
  33.    * @param {IDBDatabase} connection
  34.    * @param {string} segmentStore
  35.    * @param {string} manifestStore
  36.    * @param {boolean} isFixedKey
  37.    */
  38.   constructor(connection,
  39.               segmentStore,
  40.               manifestStore,
  41.               isFixedKey) {
  42.     /** @private {!shaka.offline.indexeddb.DBConnection} */
  43.     this.connection_ = new shaka.offline.indexeddb.DBConnection(connection);
  45.     /** @private {string} */
  46.     this.segmentStore_ = segmentStore;
  47.     /** @private {string} */
  48.     this.manifestStore_ = manifestStore;
  50.     /** @private {boolean} */
  51.     this.isFixedKey_ = isFixedKey;
  52.   }
  54.   /**
  55.    * @override
  56.    */
  57.   destroy() { return this.connection_.destroy(); }
  59.   /**
  60.    * @override
  61.    */
  62.   hasFixedKeySpace() { return this.isFixedKey_; }
  64.   /**
  65.    * @override
  66.    */
  67.   addSegments(segments) { return this.add_(this.segmentStore_, segments); }
  69.   /**
  70.    * @override
  71.    */
  72.   removeSegments(keys, onRemove) {
  73.     return this.remove_(this.segmentStore_, keys, onRemove);
  74.   }
  76.   /**
  77.    * @override
  78.    */
  79.   getSegments(keys) { return this.get_(this.segmentStore_, keys); }
  81.   /**
  82.    * @override
  83.    */
  84.   addManifests(manifests) { return this.add_(this.manifestStore_, manifests); }
  86.   /**
  87.    * @override
  88.    */
  89.   updateManifestExpiration(key, newExpiration) {
  90.     let op = this.connection_.startReadWriteOperation(this.manifestStore_);
  91.     let store = op.store();
  92.     store.get(key).onsuccess = (e) => {
  93.       let found = e.target.result;
  94.       // If we can't find the value, then there is nothing for us to update.
  95.       if (found) {
  96.         found.expiration = newExpiration;
  97.         store.put(found, key);
  98.       }
  99.     };
  101.     return op.promise();
  102.   }
  104.   /**
  105.    * @override
  106.    */
  107.   removeManifests(keys, onRemove) {
  108.     return this.remove_(this.manifestStore_, keys, onRemove);
  109.   }
  111.   /**
  112.    * @override
  113.    */
  114.   getManifests(keys) { return this.get_(this.manifestStore_, keys); }
  116.   /**
  117.    * @override
  118.    */
  119.   getAllManifests() {
  120.     let op = this.connection_.startReadOnlyOperation(this.manifestStore_);
  121.     let store = op.store();
  123.     let values = {};
  125.     store.openCursor().onsuccess = (event) => {
  126.       // When we reach the end of the data that the cursor is iterating
  127.       // over, |event.target.result| will be null to signal the end of the
  128.       // iteration.
  129.       // https://developer.mozilla.org/en-US/docs/Web/API/IDBCursor/continue
  130.       let cursor = event.target.result;
  131.       if (!cursor) {
  132.         return;
  133.       }
  135.       values[cursor.key] = cursor.value;
  137.       // Go to the next item in the store, which will cause |onsuccess| to be
  138.       // called again.
  139.       cursor.continue();
  140.     };
  142.     // Wait until the operation completes or else values may be missing from
  143.     // |values|.
  144.     return op.promise().then(() => values);
  145.   }
  147.   /**
  148.    * @param {string} storeName
  149.    * @param {!Array.<T>} values
  150.    * @return {!Promise.<!Array.<number>>}
  151.    * @template T
  152.    * @private
  153.    */
  154.   add_(storeName, values) {
  155.     // In the case that this storage cell does not support add-operations, just
  156.     // reject the request immediately instead of allowing it to try.
  157.     if (this.isFixedKey_) {
  158.       return Promise.reject(new shaka.util.Error(
  159.         shaka.util.Error.Severity.RECOVERABLE,
  160.         shaka.util.Error.Category.STORAGE,
  161.         shaka.util.Error.Code.NEW_KEY_OPERATION_NOT_SUPPORTED,
  162.         'Cannot add new value to ' + storeName));
  163.     }
  165.     let op = this.connection_.startReadWriteOperation(storeName);
  166.     let store = op.store();
  168.     /** @type {!Array.<number>} */
  169.     let keys = [];
  171.     // Write each segment out. When each request completes, the key will
  172.     // be in |event.target.result| as can be seen in
  173.     // https://w3c.github.io/IndexedDB/#key-generator-construct.
  174.     values.forEach((value) => {
  175.       let request = store.add(value);
  176.       request.onsuccess = (event) => {
  177.         let key = event.target.result;
  178.         keys.push(key);
  179.       };
  180.     });
  182.     // Wait until the operation completes or else |keys| will not be fully
  183.     // populated.
  184.     return op.promise().then(() => keys);
  185.   }
  187.   /**
  188.    * @param {string} storeName
  189.    * @param {!Array.<number>} keys
  190.    * @param {function(number)} onRemove
  191.    * @return {!Promise}
  192.    * @private
  193.    */
  194.   remove_(storeName, keys, onRemove) {
  195.     let op = this.connection_.startReadWriteOperation(storeName);
  196.     let store = op.store();
  198.     keys.forEach((key) => {
  199.       store.delete(key).onsuccess = () => onRemove(key);
  200.     });
  202.     return op.promise();
  203.   }
  205.   /**
  206.    * @param {string} storeName
  207.    * @param {!Array.<number>} keys
  208.    * @return {!Promise.<!Array.<T>>}
  209.    * @template T
  210.    * @private
  211.    */
  212.   get_(storeName, keys) {
  213.     let op = this.connection_.startReadOnlyOperation(storeName);
  214.     let store = op.store();
  216.     let values = {};
  217.     let missing = [];
  219.     // Use a map to store the objects so that we can reorder the results to
  220.     // match the order of |keys|.
  221.     keys.forEach((key) => {
  222.       let request = store.get(key);
  223.       request.onsuccess = () => {
  224.         // Make sure a defined value was found. Indexeddb treats no-value found
  225.         // as a success with an undefined result.
  226.         if (request.result == undefined) {
  227.           missing.push(key);
  228.         }
  230.         values[key] = request.result;
  231.       };
  232.     });
  234.     // Wait until the operation completes or else values may be missing from
  235.     // |values|. Use the original key list to convert the map to a list so that
  236.     // the order will match.
  237.     return op.promise().then(() => {
  238.       if (missing.length) {
  239.         return Promise.reject(new shaka.util.Error(
  240.             shaka.util.Error.Severity.RECOVERABLE,
  241.             shaka.util.Error.Category.STORAGE,
  242.             shaka.util.Error.Code.KEY_NOT_FOUND,
  243.             'Could not find values for ' + missing
  244.         ));
  245.       }
  247.       return keys.map((key) => values[key]);
  248.     });
  249.   }
  250. };