Source: encrypt/sqlite3-producer-db.js

  1. /**
  2.  * Copyright (C) 2015-2016 Regents of the University of California.
  3.  * @author: Jeff Thompson <jefft0@remap.ucla.edu>
  4.  * @author: From ndn-group-encrypt src/producer-db https://github.com/named-data/ndn-group-encrypt
  5.  *
  6.  * This program is free software: you can redistribute it and/or modify
  7.  * it under the terms of the GNU Lesser General Public License as published by
  8.  * the Free Software Foundation, either version 3 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  * A copy of the GNU Lesser General Public License is in the file COPYING.
  19.  */
  21. /** @ignore */
  22. var Blob = require('../util/blob.js').Blob; /** @ignore */
  23. var Sqlite3Promise = require('../util/sqlite3-promise.js').Sqlite3Promise; /** @ignore */
  24. var TlvWireFormat = require('../encoding/tlv-wire-format').TlvWireFormat; /** @ignore */
  25. var SyncPromise = require('../util/sync-promise.js').SyncPromise; /** @ignore */
  26. var ProducerDb = require('./producer-db.js').ProducerDb;
  28. /**
  29.  * Sqlite3ProducerDb extends ProducerDb to implement storage of keys for the
  30.  * producer using SQLite3. It contains one table that maps time slots (to the
  31.  * nearest hour) to the content key created for that time slot.
  32.  * Create a Sqlite3ProducerDb to use the given SQLite3 file.
  33.  * @param {string} databaseFilePath The path of the SQLite file.
  34.  * @throws ProducerDb.Error for a database error.
  35.  * @note This class is an experimental feature. The API may change.
  36.  * @constructor
  37.  */
  38. var Sqlite3ProducerDb = function Sqlite3ProducerDb(databaseFilePath)
  39. {
  40.   // Call the base constructor.
  41.   ProducerDb.call(this);
  43.   this.database_ = new Sqlite3Promise
  44.     (databaseFilePath, Sqlite3ProducerDb.initializeDatabasePromise_);
  45. };
  47. Sqlite3ProducerDb.prototype = new ProducerDb();
  48. Sqlite3ProducerDb.prototype.name = "Sqlite3ProducerDb";
  50. exports.Sqlite3ProducerDb = Sqlite3ProducerDb;
  52. /**
  53.  * Check if a content key exists for the hour covering timeSlot.
  54.  * @param {number} timeSlot The time slot as milliseconds since Jan 1, 1970 UTC.
  55.  * @param {boolean} useSync (optional) If true then return a rejected promise
  56.  * since this only supports async code.
  57.  * @return {Promise} A promise that returns true if there is a content key for
  58.  * timeSlot (else false), or that is rejected with ProducerDb.Error for a
  59.  * database error.
  60.  */
  61. Sqlite3ProducerDb.prototype.hasContentKeyPromise = function(timeSlot, useSync)
  62. {
  63.   if (useSync)
  64.     return Promise.reject(new ProducerDb.Error(new Error
  65.       ("Sqlite3ProducerDb.hasContentKeyPromise is only supported for async")));
  67.   var fixedTimeSlot = ProducerDb.getFixedTimeSlot(timeSlot);
  69.   return this.getPromise_
  70.     ("SELECT key FROM contentkeys where timeslot=?", fixedTimeSlot)
  71.   .then(function(row) {
  72.     if (row)
  73.       return Promise.resolve(true);
  74.     else
  75.       return Promise.resolve(false);
  76.   });
  77. };
  79. /**
  80.  * Get the content key for the hour covering timeSlot.
  81.  * @param {number} timeSlot The time slot as milliseconds since Jan 1, 1970 UTC.
  82.  * @param {boolean} useSync (optional) If true then return a rejected promise
  83.  * since this only supports async code.
  84.  * @return {Promise} A promise that returns a Blob with the encoded key, or that
  85.  * is rejected with ProducerDb.Error if there is no key covering timeSlot, or
  86.  * other database error
  87.  */
  88. Sqlite3ProducerDb.prototype.getContentKeyPromise = function(timeSlot, useSync)
  89. {
  90.   if (useSync)
  91.     return Promise.reject(new ProducerDb.Error(new Error
  92.       ("Sqlite3ProducerDb.getContentKeyPromise is only supported for async")));
  94.   var fixedTimeSlot = ProducerDb.getFixedTimeSlot(timeSlot);
  96.   return this.getPromise_
  97.     ("SELECT key FROM contentkeys where timeslot=?", fixedTimeSlot)
  98.   .then(function(row) {
  99.     if (row)
  100.       return Promise.resolve(new Blob(row.key, false));
  101.     else
  102.       return Promise.reject(new ProducerDb.Error(new Error
  103.         ("Sqlite3ProducerDb.getContentKeyPromise: Cannot get the key from the database")));
  104.   });
  105. };
  107. /**
  108.  * Add key as the content key for the hour covering timeSlot.
  109.  * @param {number} timeSlot The time slot as milliseconds since Jan 1, 1970 UTC.
  110.  * @param {Blob} key The encoded key.
  111.  * @param {boolean} useSync (optional) If true then return a rejected promise
  112.  * since this only supports async code.
  113.  * @return {Promise} A promise that fulfills when the key is added, or that
  114.  * is rejected with ProducerDb.Error if a key for the same hour already exists
  115.  * in the database, or other database error.
  116.  */
  117. Sqlite3ProducerDb.prototype.addContentKeyPromise = function
  118.   (timeSlot, key, useSync)
  119. {
  120.   if (useSync)
  121.     return Promise.reject(new ProducerDb.Error(new Error
  122.       ("Sqlite3ProducerDb.addContentKeyPromise is only supported for async")));
  124.   var fixedTimeSlot = ProducerDb.getFixedTimeSlot(timeSlot);
  126.   return this.runPromise_
  127.     ("INSERT INTO contentkeys (timeslot, key) values (?, ?)",
  128.      [fixedTimeSlot, key.buf()]);
  129. };
  131. /**
  132.  * Delete the content key for the hour covering timeSlot. If there is no key for
  133.  * the time slot, do nothing.
  134.  * @param {number} timeSlot The time slot as milliseconds since Jan 1, 1970 UTC.
  135.  * @param {boolean} useSync (optional) If true then return a rejected promise
  136.  * since this only supports async code.
  137.  * @return {Promise} A promise that fulfills when the key is deleted (or there
  138.  * is no such key), or that is rejected with ProducerDb.Error for a database
  139.  * error.
  140.  */
  141. Sqlite3ProducerDb.prototype.deleteContentKeyPromise = function(timeSlot, useSync)
  142. {
  143.   if (useSync)
  144.     return Promise.reject(new ProducerDb.Error(new Error
  145.       ("Sqlite3ProducerDb.deleteContentKeyPromise is only supported for async")));
  147.   var fixedTimeSlot = ProducerDb.getFixedTimeSlot(timeSlot);
  149.   return this.runPromise_
  150.     ("DELETE FROM contentkeys WHERE timeslot=?", fixedTimeSlot);
  151. };
  153. /**
  154.  * Call Sqlite3Promise.runPromise, wrapping an Error in ProducerDb.Error.
  155.  */
  156. Sqlite3ProducerDb.prototype.runPromise_ = function(sql, params)
  157. {
  158.   return this.database_.runPromise(sql, params)
  159.   .catch(function(error) {
  160.     return Promise.reject(new ProducerDb.Error(error));
  161.   });
  162. };
  164. /**
  165.  * Call Sqlite3Promise.getPromise, wrapping an Error in ProducerDb.Error.
  166.  */
  167. Sqlite3ProducerDb.prototype.getPromise_ = function(sql, params)
  168. {
  169.   return this.database_.getPromise(sql, params)
  170.   .catch(function(error) {
  171.     return Promise.reject(new ProducerDb.Error(error));
  172.   });
  173. };
  175. Sqlite3ProducerDb.initializeDatabasePromise_ = function(database)
  176. {
  177.   return database.runPromise(Sqlite3ProducerDb.INITIALIZATION1)
  178.   .then(function() {
  179.     return database.runPromise(Sqlite3ProducerDb.INITIALIZATION2);
  180.   });
  181. };
  183. Sqlite3ProducerDb.INITIALIZATION1 =
  184.   "CREATE TABLE IF NOT EXISTS                         \n" +
  185.   "  contentkeys(                                     \n" +
  186.   "    rowId            INTEGER PRIMARY KEY,          \n" +
  187.   "    timeSlot         INTEGER,                      \n" +
  188.   "    key              BLOB NOT NULL                 \n" +
  189.   "  );                                               \n";
  190. Sqlite3ProducerDb.INITIALIZATION2 =
  191.   "CREATE UNIQUE INDEX IF NOT EXISTS                  \n" +
  192.   "   timeSlotIndex ON contentkeys(timeSlot);         \n";