Source: encrypt/indexeddb-producer-db.js

  1. /**
  2.  * Copyright (C) 2015-2016 Regents of the University of California.
  3.  * @author: Jeff Thompson <jefft0@remap.ucla.edu>
  4.  *
  5.  * This program is free software: you can redistribute it and/or modify
  6.  * it under the terms of the GNU Lesser General Public License as published by
  7.  * the Free Software Foundation, either version 3 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU Lesser General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU Lesser General Public License
  16.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17.  * A copy of the GNU Lesser General Public License is in the file COPYING.
  18.  */
  20. // Don't require modules since this is meant for the browser, not Node.js.
  22. /**
  23.  * IndexedDbProducerDb extends ProducerDb to implement storage of keys for the
  24.  * producer using the browser's IndexedDB service. It contains one table that
  25.  * maps time slots (to the nearest hour) to the content key created for that
  26.  * time slot.
  27.  * Create an IndexedDbProducerDb to use the given IndexedDB database name.
  28.  * @param {string} databaseName IndexedDB database name.
  29.  * @note This class is an experimental feature. The API may change.
  30.  * @constructor
  31.  */
  32. var IndexedDbProducerDb = function IndexedDbProducerDb(databaseName)
  33. {
  34.   ProducerDb.call(this);
  36.   this.database = new Dexie(databaseName);
  37.   this.database.version(1).stores({
  38.     // "timeSlot" is the hour-based time slot as hours since Jan 1, 1970 UTC. // number
  39.     // "key" is the encoded key // Uint8Array
  40.     contentKeys: "timeSlot"
  41.   });
  42.   this.database.open();
  43. };
  45. IndexedDbProducerDb.prototype = new ProducerDb();
  46. IndexedDbProducerDb.prototype.name = "IndexedDbProducerDb";
  48. /**
  49.  * Check if a content key exists for the hour covering timeSlot.
  50.  * @param {number} timeSlot The time slot as milliseconds since Jan 1, 1970 UTC.
  51.  * @param {boolean} useSync (optional) If true then return a rejected promise
  52.  * since this only supports async code.
  53.  * @return {Promise} A promise that returns true if there is a content key for
  54.  * timeSlot (else false), or that is rejected with ProducerDb.Error for a
  55.  * database error.
  56.  */
  57. IndexedDbProducerDb.prototype.hasContentKeyPromise = function(timeSlot, useSync)
  58. {
  59.   if (useSync)
  60.     return Promise.reject(new ProducerDb.Error(new Error
  61.       ("IndexedDbProducerDb.hasContentKeyPromise is only supported for async")));
  63.   var fixedTimeSlot = ProducerDb.getFixedTimeSlot(timeSlot);
  65.   return this.database.contentKeys.get(fixedTimeSlot)
  66.   .then(function(contentKeysEntry) {
  67.     return Promise.resolve(contentKeysEntry != undefined);
  68.   })
  69.   .catch(function(ex) {
  70.     return Promise.reject(new ProducerDb.Error(new Error
  71.       ("IndexedDbProducerDb.hasContentKeyPromise: Error: " + ex)));
  72.   });
  73. };
  75. /**
  76.  * Get the content key for the hour covering timeSlot.
  77.  * @param {number} timeSlot The time slot as milliseconds since Jan 1, 1970 UTC.
  78.  * @param {boolean} useSync (optional) If true then return a rejected promise
  79.  * since this only supports async code.
  80.  * @return {Promise} A promise that returns a Blob with the encoded key, or that
  81.  * is rejected with ProducerDb.Error if there is no key covering timeSlot, or
  82.  * other database error
  83.  */
  84. IndexedDbProducerDb.prototype.getContentKeyPromise = function(timeSlot, useSync)
  85. {
  86.   if (useSync)
  87.     return Promise.reject(new ProducerDb.Error(new Error
  88.       ("IndexedDbProducerDb.getContentKeyPromise is only supported for async")));
  90.   var fixedTimeSlot = ProducerDb.getFixedTimeSlot(timeSlot);
  92.   return this.database.contentKeys.get(fixedTimeSlot)
  93.   .then(function(contentKeysEntry) {
  94.     if (contentKeysEntry)
  95.       return Promise.resolve(new Blob(contentKeysEntry.key));
  96.     else
  97.       return Promise.reject(new ProducerDb.Error(new Error
  98.         ("IndexedDbProducerDb.getContentKeyPromise: Cannot get the key from the database")));
  99.   }, function(ex) {
  100.     return Promise.reject(new ProducerDb.Error(new Error
  101.       ("IndexedDbProducerDb.getContentKeyPromise: Error: " + ex)));
  102.   });
  103. };
  105. /**
  106.  * Add key as the content key for the hour covering timeSlot.
  107.  * @param {number} timeSlot The time slot as milliseconds since Jan 1, 1970 UTC.
  108.  * @param {Blob} key The encoded key.
  109.  * @param {boolean} useSync (optional) If true then return a rejected promise
  110.  * since this only supports async code.
  111.  * @return {Promise} A promise that fulfills when the key is added, or that
  112.  * is rejected with ProducerDb.Error if a key for the same hour already exists
  113.  * in the database, or other database error.
  114.  */
  115. IndexedDbProducerDb.prototype.addContentKeyPromise = function
  116.   (timeSlot, key, useSync)
  117. {
  118.   if (useSync)
  119.     return Promise.reject(new ProducerDb.Error(new Error
  120.       ("IndexedDbProducerDb.addContentKeyPromise is only supported for async")));
  122.   var fixedTimeSlot = ProducerDb.getFixedTimeSlot(timeSlot);
  124.   // Add rejects if the primary key already exists.
  125.   return this.database.contentKeys.add
  126.     ({ timeSlot: fixedTimeSlot, key: key.buf() })
  127.   .catch(function(ex) {
  128.     return Promise.reject(new ProducerDb.Error(new Error
  129.       ("IndexedDbProducerDb.addContentKeyPromise: Error: " + ex)));
  130.   });
  131. };
  133. /**
  134.  * Delete the content key for the hour covering timeSlot. If there is no key for
  135.  * the time slot, do nothing.
  136.  * @param {number} timeSlot The time slot as milliseconds since Jan 1, 1970 UTC.
  137.  * @param {boolean} useSync (optional) If true then return a rejected promise
  138.  * since this only supports async code.
  139.  * @return {Promise} A promise that fulfills when the key is deleted (or there
  140.  * is no such key), or that is rejected with ProducerDb.Error for a database
  141.  * error.
  142.  */
  143. IndexedDbProducerDb.prototype.deleteContentKeyPromise = function(timeSlot, useSync)
  144. {
  145.   if (useSync)
  146.     return Promise.reject(new ProducerDb.Error(new Error
  147.       ("IndexedDbProducerDb.deleteContentKeyPromise is only supported for async")));
  149.   var fixedTimeSlot = ProducerDb.getFixedTimeSlot(timeSlot);
  151.   return this.database.contentKeys.delete(fixedTimeSlot)
  152.   .catch(function(ex) {
  153.     return Promise.reject(new ProducerDb.Error(new Error
  154.       ("IndexedDbProducerDb.deleteContentKeyPromise: Error: " + ex)));
  155.   });
  156. };