Source: encrypt/group-manager-db.js

  1. /**
  2.  * Copyright (C) 2015-2018 Regents of the University of California.
  3.  * @author: Jeff Thompson <jefft0@remap.ucla.edu>
  4.  * @author: From ndn-group-encrypt src/group-manager-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 SyncPromise = require('../util/sync-promise.js').SyncPromise;
  24. /**
  25.  * GroupManagerDb is a base class for the storage of data used by the
  26.  * GroupManager. It contains two tables to store Schedules and Members.
  27.  * This is an abstract base class. A subclass must implement the methods.
  28.  * For example, see Sqlite3GroupManagerDb (for Nodejs) or IndexedDbGroupManagerDb
  29.  * (for the browser).
  30.  * @note This class is an experimental feature. The API may change.
  31.  * @constructor
  32.  */
  33. var GroupManagerDb = function GroupManagerDb()
  34. {
  35. };
  37. exports.GroupManagerDb = GroupManagerDb;
  39. /**
  40.  * Create a new GroupManagerDb.Error to report an error using GroupManagerDb
  41.  * methods, wrapping the given error object.
  42.  * Call with: throw new GroupManagerDb.Error(new Error("message")).
  43.  * @constructor
  44.  * @param {Error} error The exception created with new Error.
  45.  */
  46. GroupManagerDb.Error = function GroupManagerDbError(error)
  47. {
  48.   if (error) {
  49.     error.__proto__ = GroupManagerDb.Error.prototype;
  50.     return error;
  51.   }
  52. };
  54. GroupManagerDb.Error.prototype = new Error();
  55. GroupManagerDb.Error.prototype.name = "GroupManagerDbError";
  57. ////////////////////////////////////////////////////// Schedule management.
  59. /**
  60.  * Check if there is a schedule with the given name.
  61.  * @param {string} name The name of the schedule.
  62.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  63.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  64.  * an async Promise.
  65.  * @return {Promise|SyncPromise} A promise that returns true if there is a
  66.  * schedule (else false), or that is rejected with GroupManagerDb.Error for a
  67.  * database error.
  68.  */
  69. GroupManagerDb.prototype.hasSchedulePromise = function(name, useSync)
  70. {
  71.   return SyncPromise.reject(new Error
  72.     ("GroupManagerDb.hasSchedulePromise is not implemented"));
  73. };
  75. /**
  76.  * List all the names of the schedules.
  77.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  78.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  79.  * an async Promise.
  80.  * @return {Promise|SyncPromise} A promise that returns a new array of string
  81.  * with the names of all schedules, or that is rejected with
  82.  * GroupManagerDb.Error for a database error.
  83.  */
  84. GroupManagerDb.prototype.listAllScheduleNamesPromise = function(useSync)
  85. {
  86.   return SyncPromise.reject(new Error
  87.     ("GroupManagerDb.listAllScheduleNamesPromise is not implemented"));
  88. };
  90. /**
  91.  * Get a schedule with the given name.
  92.  * @param {string} name The name of the schedule.
  93.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  94.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  95.  * an async Promise.
  96.  * @return {Promise|SyncPromise} A promise that returns a new Schedule object,
  97.  * or that is rejected with GroupManagerDb.Error if the schedule does not exist
  98.  * or other database error.
  99.  */
  100. GroupManagerDb.prototype.getSchedulePromise = function(name, useSync)
  101. {
  102.   return SyncPromise.reject(new Error
  103.     ("GroupManagerDb.getSchedulePromise is not implemented"));
  104. };
  106. /**
  107.  * For each member using the given schedule, get the name and public key DER
  108.  * of the member's key.
  109.  * @param {string} name The name of the schedule.
  110.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  111.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  112.  * an async Promise.
  113.  * @return {Promise|SyncPromise} A promise that returns a new array of object
  114.  * (where "keyName" is the Name of the public key and "publicKey" is the Blob of
  115.  * the public key DER), or that is rejected with GroupManagerDb.Error for a
  116.  * database error. Note that the member's identity name is keyName.getPrefix(-1).
  117.  * If the schedule name is not found, the list is empty.
  118.  */
  119. GroupManagerDb.prototype.getScheduleMembersPromise = function
  120.   (name, useSync)
  121. {
  122.   return SyncPromise.reject(new Error
  123.     ("GroupManagerDb.getScheduleMembersPromise is not implemented"));
  124. };
  126. /**
  127.  * Add a schedule with the given name.
  128.  * @param {string} name The name of the schedule. The name cannot be empty.
  129.  * @param {Schedule} schedule The Schedule to add.
  130.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  131.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  132.  * an async Promise.
  133.  * @return {Promise|SyncPromise} A promise that fulfills when the schedule is
  134.  * added, or that is rejected with GroupManagerDb.Error if a schedule with the
  135.  * same name already exists, if the name is empty, or other database error.
  136.  */
  137. GroupManagerDb.prototype.addSchedulePromise = function(name, schedule, useSync)
  138. {
  139.   return SyncPromise.reject(new Error
  140.     ("GroupManagerDb.addSchedulePromise is not implemented"));
  141. };
  143. /**
  144.  * Delete the schedule with the given name. Also delete members which use this
  145.  * schedule. If there is no schedule with the name, then do nothing.
  146.  * @param {string} name The name of the schedule.
  147.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  148.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  149.  * an async Promise.
  150.  * @return {Promise|SyncPromise} A promise that fulfills when the schedule is
  151.  * deleted (or there is no such schedule), or that is rejected with
  152.  * GroupManagerDb.Error for a database error.
  153.  */
  154. GroupManagerDb.prototype.deleteSchedulePromise = function(name, useSync)
  155. {
  156.   return SyncPromise.reject(new Error
  157.     ("GroupManagerDb.deleteSchedulePromise is not implemented"));
  158. };
  160. /**
  161.  * Rename a schedule with oldName to newName.
  162.  * @param {string} oldName The name of the schedule to be renamed.
  163.  * @param {string} newName The new name of the schedule. The name cannot be empty.
  164.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  165.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  166.  * an async Promise.
  167.  * @return {Promise|SyncPromise} A promise that fulfills when the schedule is
  168.  * renamed, or that is rejected with GroupManagerDb.Error if a schedule with
  169.  * newName already exists, if the schedule with oldName does not exist, if
  170.  * newName is empty, or other database error.
  171.  */
  172. GroupManagerDb.prototype.renameSchedulePromise = function
  173.   (oldName, newName, useSync)
  174. {
  175.   return SyncPromise.reject(new Error
  176.     ("GroupManagerDb.renameSchedulePromise is not implemented"));
  177. };
  179. /**
  180.  * Update the schedule with name and replace the old object with the given
  181.  * schedule. Otherwise, if no schedule with name exists, a new schedule
  182.  * with name and the given schedule will be added to database.
  183.  * @param {string} name The name of the schedule. The name cannot be empty.
  184.  * @param {Schedule} schedule The Schedule to update or add.
  185.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  186.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  187.  * an async Promise.
  188.  * @return {Promise|SyncPromise} A promise that fulfills when the schedule is
  189.  * updated, or that is rejected with GroupManagerDb.Error if the name is empty,
  190.  * or other database error.
  191.  */
  192. GroupManagerDb.prototype.updateSchedulePromise = function
  193.   (name, schedule, useSync)
  194. {
  195.   return SyncPromise.reject(new Error
  196.     ("GroupManagerDb.updateSchedulePromise is not implemented"));
  197. };
  199. ////////////////////////////////////////////////////// Member management.
  201. /**
  202.  * Check if there is a member with the given identity name.
  203.  * @param {Name} identity The member's identity name.
  204.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  205.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  206.  * an async Promise.
  207.  * @return {Promise|SyncPromise} A promise that returns true if there is a
  208.  * member (else false), or that is rejected with GroupManagerDb.Error for a
  209.  * database error.
  210.  */
  211. GroupManagerDb.prototype.hasMemberPromise = function(identity, useSync)
  212. {
  213.   return SyncPromise.reject(new Error
  214.     ("GroupManagerDb.hasMemberPromise is not implemented"));
  215. };
  217. /**
  218.  * List all the members.
  219.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  220.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  221.  * an async Promise.
  222.  * @return {Promise|SyncPromise} A promise that returns a new array of Name with
  223.  * the names of all members, or that is rejected with GroupManagerDb.Error for a
  224.  * database error.
  225.  */
  226. GroupManagerDb.prototype.listAllMembersPromise = function(useSync)
  227. {
  228.   return SyncPromise.reject(new Error
  229.     ("GroupManagerDb.listAllMembersPromise is not implemented"));
  230. };
  232. /**
  233.  * Get the name of the schedule for the given member's identity name.
  234.  * @param {Name} identity The member's identity name.
  235.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  236.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  237.  * an async Promise.
  238.  * @return {Promise|SyncPromise} A promise that returns the string schedule name,
  239.  * or that is rejected with GroupManagerDb.Error if there's no member with the
  240.  * given identity name in the database, or other database error.
  241.  */
  242. GroupManagerDb.prototype.getMemberSchedulePromise = function(identity, useSync)
  243. {
  244.   return SyncPromise.reject(new Error
  245.     ("GroupManagerDb.getMemberSchedulePromise is not implemented"));
  246. };
  248. /**
  249.  * Add a new member with the given key named keyName into a schedule named
  250.  * scheduleName. The member's identity name is keyName.getPrefix(-1).
  251.  * @param {string} scheduleName The schedule name.
  252.  * @param {Name} keyName The name of the key.
  253.  * @param {Blob} key A Blob of the public key DER.
  254.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  255.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  256.  * an async Promise.
  257.  * @return {Promise|SyncPromise} A promise that fulfills when the member is
  258.  * added, or that is rejected with GroupManagerDb.Error if there's no schedule
  259.  * named scheduleName, if the member's identity name already exists, or other
  260.  * database error.
  261.  */
  262. GroupManagerDb.prototype.addMemberPromise = function
  263.   (scheduleName, keyName, key, useSync)
  264. {
  265.   return SyncPromise.reject(new Error
  266.     ("GroupManagerDb.addMemberPromise is not implemented"));
  267. };
  269. /**
  270.  * Change the name of the schedule for the given member's identity name.
  271.  * @param {Name} identity The member's identity name.
  272.  * @param {string} scheduleName The new schedule name.
  273.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  274.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  275.  * an async Promise.
  276.  * @return {Promise|SyncPromise} A promise that fulfills when the member is
  277.  * updated, or that is rejected with GroupManagerDb.Error if there's no member
  278.  * with the given identity name in the database, or there's no schedule named
  279.  * scheduleName, or other database error.
  280.  */
  281. GroupManagerDb.prototype.updateMemberSchedulePromise = function
  282.   (identity, scheduleName, useSync)
  283. {
  284.   return SyncPromise.reject(new Error
  285.     ("GroupManagerDb.updateMemberSchedulePromise is not implemented"));
  286. };
  288. /**
  289.  * Delete a member with the given identity name. If there is no member with
  290.  * the identity name, then do nothing.
  291.  * @param {Name} identity The member's identity name.
  292.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  293.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  294.  * an async Promise.
  295.  * @return {Promise|SyncPromise} A promise that fulfills when the member is
  296.  * deleted (or there is no such member), or that is rejected with
  297.  * GroupManagerDb.Error for a database error.
  298.  */
  299. GroupManagerDb.prototype.deleteMemberPromise = function(identity, useSync)
  300. {
  301.   return SyncPromise.reject(new Error
  302.     ("GroupManagerDb.deleteMemberPromise is not implemented"));
  303. };
  305. /**
  306.  * Check if there is an EKey with the name eKeyName in the database.
  307.  * @param {Name} eKeyName The name of the EKey.
  308.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  309.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  310.  * an async Promise.
  311.  * @return {Promise|SyncPromise} A promise that returns true if the EKey exists
  312.  * (else false), or that is rejected with GroupManagerDb.Error for a database
  313.  * error.
  314.  */
  315. GroupManagerDb.prototype.hasEKeyPromise = function(eKeyName, useSync)
  316. {
  317.   return SyncPromise.reject(new Error
  318.     ("GroupManagerDb.hasEKeyPromise is not implemented"));
  319. };
  321. /**
  322.  * Add the EKey with name eKeyName to the database.
  323.  * @param {Name} eKeyName The name of the EKey. This copies the Name.
  324.  * @param {Blob} publicKey The encoded public Key of the group key pair.
  325.  * @param {Blob} privateKey The encoded private Key of the group key pair.
  326.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  327.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  328.  * an async Promise.
  329.  * @return {Promise|SyncPromise} A promise that fulfills when the EKey is added,
  330.  * or that is rejected with GroupManagerDb.Error if a key with name eKeyName
  331.  * already exists in the database, or other database error.
  332.  */
  333. GroupManagerDb.prototype.addEKeyPromise = function
  334.   (eKeyName, publicKey, privateKey, useSync)
  335. {
  336.   return SyncPromise.reject(new Error
  337.     ("GroupManagerDb.addEKeyPromise is not implemented"));
  338. };
  340. /**
  341.  * Get the group key pair with the name eKeyName from the database.
  342.  * @param {Name} eKeyName The name of the EKey.
  343.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  344.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  345.  * an async Promise.
  346.  * @return {Promise|SyncPromise} A promise that returns an object (where
  347.  * "publicKey" is the public key Blob and "privateKey" is the private key Blob),
  348.  * or that is rejected with GroupManagerDb.Error for a database error.
  349.  */
  350. GroupManagerDb.prototype.getEKeyPromise = function(eKeyName, useSync)
  351. {
  352.   return SyncPromise.reject(new Error
  353.     ("GroupManagerDb.getEKeyPromise is not implemented"));
  354. };
  356. /**
  357.  * Delete all the EKeys in the database. The database will keep growing because
  358.  * EKeys will keep being added, so this method should be called periodically.
  359.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  360.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  361.  * an async Promise.
  362.  * @return {Promise|SyncPromise} A promise that fulfills when the EKeys are
  363.  * deleted, or that is rejected with GroupManagerDb.Error for a database error.
  364.  */
  365. GroupManagerDb.prototype.cleanEKeysPromise = function(useSync)
  366. {
  367.   return SyncPromise.reject(new Error
  368.     ("GroupManagerDb.cleanEKeysPromise is not implemented"));
  369. };
  371. /**
  372.  * Delete the EKey with name eKeyName from the database. If no key with the
  373.  * name exists in the database, do nothing.
  374.  * @param {Name} eKeyName The name of the EKey.
  375.  * @param {boolean} useSync (optional) If true then return a SyncPromise which
  376.  * is already fulfilled. If omitted or false, this may return a SyncPromise or
  377.  * an async Promise.
  378.  * @return {Promise|SyncPromise} A promise that fulfills when the EKey is
  379.  * deleted (or there is no such key), or that is rejected with
  380.  * GroupManagerDb.Error for a database error.
  381.  */
  382. GroupManagerDb.prototype.deleteEKeyPromise = function(eKeyName, useSync)
  383. {
  384.   return SyncPromise.reject(new Error
  385.     ("GroupManagerDb.deleteEKeyPromise is not implemented"));
  386. };