Source: encrypt/sqlite3-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 Schedule = require('./schedule.js').Schedule; /** @ignore */
  23. var Blob = require('../util/blob.js').Blob; /** @ignore */
  24. var Sqlite3Promise = require('../util/sqlite3-promise.js').Sqlite3Promise; /** @ignore */
  25. var Name = require('../name.js').Name; /** @ignore */
  26. var TlvWireFormat = require('../encoding/tlv-wire-format').TlvWireFormat; /** @ignore */
  27. var GroupManagerDb = require('./group-manager-db.js').GroupManagerDb;
  29. /**
  30.  * Sqlite3GroupManagerDb extends GroupManagerDb to implement the storage of
  31.  * data used by the GroupManager using the Node.js sqlite3 module.
  32.  * Create a Sqlite3GroupManagerDb to use the given SQLite3 file.
  33.  * @param {string} databaseFilePath The path of the SQLite file.
  34.  * @throws GroupManagerDb.Error for a database error.
  35.  * @note This class is an experimental feature. The API may change.
  36.  * @constructor
  37.  */
  38. var Sqlite3GroupManagerDb = function Sqlite3GroupManagerDb(databaseFilePath)
  39. {
  40.   // Call the base constructor.
  41.   GroupManagerDb.call(this);
  43.   this.database_ = new Sqlite3Promise
  44.     (databaseFilePath, Sqlite3GroupManagerDb.initializeDatabasePromise_);
  45.   // The map key is the E-KEY name URI string. The value is the private key Blob.
  46.   // (Use a string because we can't use the Name object as the key in JavaScript.)
  47.   this.privateKeyBase_ = {};
  48. };
  50. Sqlite3GroupManagerDb.prototype = new GroupManagerDb();
  51. Sqlite3GroupManagerDb.prototype.name = "Sqlite3GroupManagerDb";
  53. exports.Sqlite3GroupManagerDb = Sqlite3GroupManagerDb;
  55. ////////////////////////////////////////////////////// Schedule management.
  57. /**
  58.  * Check if there is a schedule with the given name.
  59.  * @param {string} name The name of the schedule.
  60.  * @param {boolean} useSync (optional) If true then return a rejected promise
  61.  * since this only supports async code.
  62.  * @return {Promise} A promise that returns true if there is a schedule (else
  63.  * false), or that is rejected with GroupManagerDb.Error for a database error.
  64.  */
  65. Sqlite3GroupManagerDb.prototype.hasSchedulePromise = function(name, useSync)
  66. {
  67.   if (useSync)
  68.     return Promise.reject(new GroupManagerDb.Error(new Error
  69.       ("Sqlite3GroupManagerDb.hasSchedulePromise is only supported for async")));
  71.   return this.getPromise_
  72.     ("SELECT schedule_id FROM schedules where schedule_name=?", name)
  73.   .then(function(row) {
  74.     if (row)
  75.       return Promise.resolve(true);
  76.     else
  77.       return Promise.resolve(false);
  78.   });
  79. };
  81. /**
  82.  * List all the names of the schedules.
  83.  * @param {boolean} useSync (optional) If true then return a rejected promise
  84.  * since this only supports async code.
  85.  * @return {Promise} A promise that returns a new array of string with the names
  86.  * of all schedules, or that is rejected with GroupManagerDb.Error for a
  87.  * database error.
  88.  */
  89. Sqlite3GroupManagerDb.prototype.listAllScheduleNamesPromise = function(useSync)
  90. {
  91.   if (useSync)
  92.     return Promise.reject(new GroupManagerDb.Error(new Error
  93.       ("Sqlite3GroupManagerDb.listAllScheduleNamesPromise is only supported for async")));
  95.   var list = [];
  96.   return this.eachPromise_
  97.     ("SELECT schedule_name FROM schedules", [], function(err, row) {
  98.       list.push(row.schedule_name);
  99.     })
  100.   .then(function() {
  101.     return Promise.resolve(list);
  102.   });
  103. };
  105. /**
  106.  * Get a schedule with the given name.
  107.  * @param {string} name The name of the schedule.
  108.  * @param {boolean} useSync (optional) If true then return a rejected promise
  109.  * since this only supports async code.
  110.  * @return {Promise} A promise that returns a new Schedule object, or that is
  111.  * rejected with GroupManagerDb.Error if the schedule does not exist or other
  112.  * database error.
  113.  */
  114. Sqlite3GroupManagerDb.prototype.getSchedulePromise = function(name, useSync)
  115. {
  116.   if (useSync)
  117.     return Promise.reject(new GroupManagerDb.Error(new Error
  118.       ("Sqlite3GroupManagerDb.getSchedulePromise is only supported for async")));
  120.   return this.getPromise_
  121.     ("SELECT schedule FROM schedules WHERE schedule_name=?", name)
  122.   .then(function(row) {
  123.     if (row) {
  124.       try {
  125.         var schedule = new Schedule();
  126.         schedule.wireDecode(new Blob(row.schedule, false));
  127.         return Promise.resolve(schedule);
  128.       } catch (ex) {
  129.         // We don't expect this to happen.
  130.         return Promise.reject(new GroupManagerDb.Error(new Error
  131.           ("Sqlite3GroupManagerDb.getSchedulePromise: Error decoding schedule: " + ex)));
  132.       }
  133.     }
  134.     else
  135.       return Promise.reject(new GroupManagerDb.Error(new Error
  136.         ("Sqlite3GroupManagerDb.getSchedulePromise: Cannot get the result from the database")));
  137.   });
  138. };
  140. /**
  141.  * For each member using the given schedule, get the name and public key DER
  142.  * of the member's key.
  143.  * @param {string} name The name of the schedule.
  144.  * @param {boolean} useSync (optional) If true then return a rejected promise
  145.  * since this only supports async code.
  146.  * @return {Promise} A promise that returns a new array of object (where
  147.  * "keyName" is the Name of the public key and "publicKey" is the Blob of the
  148.  * public key DER), or that is rejected with GroupManagerDb.Error for a database
  149.  * error. Note that the member's identity name is keyName.getPrefix(-1). If the
  150.  * schedule name is not found, the list is empty.
  151.  */
  152. Sqlite3GroupManagerDb.prototype.getScheduleMembersPromise = function
  153.   (name, useSync)
  154. {
  155.   if (useSync)
  156.     return Promise.reject(new GroupManagerDb.Error(new Error
  157.       ("Sqlite3GroupManagerDb.getScheduleMembersPromise is only supported for async")));
  159.   var list = [];
  160.   var onRowError = null;
  161.   return this.eachPromise_
  162.     ("SELECT key_name, pubkey " +
  163.      "FROM members JOIN schedules " +
  164.      "ON members.schedule_id=schedules.schedule_id " +
  165.      "WHERE schedule_name=?", name, function(err, row) {
  166.       try {
  167.         var keyName = new Name();
  168.         keyName.wireDecode(new Blob(row.key_name, false), TlvWireFormat.get());
  170.         list.push({ keyName: keyName, publicKey: new Blob(row.pubkey, false) });
  171.       } catch (ex) {
  172.         // We don't expect this to happen.
  173.         onRowError = new GroupManagerDb.Error(new Error
  174.           ("Sqlite3GroupManagerDb.getScheduleMembersPromise: Error decoding name: " + ex));
  175.       }
  176.     })
  177.   .then(function() {
  178.     if (onRowError)
  179.       return Promise.reject(onRowError);
  180.     else
  181.       return Promise.resolve(list);
  182.   });
  183. };
  185. /**
  186.  * Add a schedule with the given name.
  187.  * @param {string} name The name of the schedule. The name cannot be empty.
  188.  * @param {Schedule} schedule The Schedule to add.
  189.  * @param {boolean} useSync (optional) If true then return a rejected promise
  190.  * since this only supports async code.
  191.  * @return {Promise} A promise that fulfills when the schedule is added, or that
  192.  * is rejected with GroupManagerDb.Error if a schedule with the same name
  193.  * already exists, if the name is empty, or other database error.
  194.  */
  195. Sqlite3GroupManagerDb.prototype.addSchedulePromise = function
  196.   (name, schedule, useSync)
  197. {
  198.   if (useSync)
  199.     return Promise.reject(new GroupManagerDb.Error(new Error
  200.       ("Sqlite3GroupManagerDb.addSchedulePromise is only supported for async")));
  202.   if (name.length == 0)
  203.     return Promise.reject(new GroupManagerDb.Error
  204.       ("Sqlite3GroupManagerDb.addSchedulePromise: The schedule name cannot be empty"));
  206.   return this.runPromise_
  207.     ("INSERT INTO schedules (schedule_name, schedule) values (?, ?)",
  208.      [name, schedule.wireEncode().buf()]);
  209. };
  211. /**
  212.  * Delete the schedule with the given name. Also delete members which use this
  213.  * schedule. If there is no schedule with the name, then do nothing.
  214.  * @param {string} name The name of the schedule.
  215.  * @param {boolean} useSync (optional) If true then return a rejected promise
  216.  * since this only supports async code.
  217.  * @return {Promise} A promise that fulfills when the schedule is deleted (or
  218.  * there is no such schedule), or that is rejected with GroupManagerDb.Error for
  219.  * a database error.
  220.  */
  221. Sqlite3GroupManagerDb.prototype.deleteSchedulePromise = function
  222.   (name, useSync)
  223. {
  224.   if (useSync)
  225.     return Promise.reject(new GroupManagerDb.Error(new Error
  226.       ("Sqlite3GroupManagerDb.deleteSchedulePromise is only supported for async")));
  228.   return this.runPromise_
  229.     ("DELETE FROM schedules WHERE schedule_name=?", name);
  230. };
  232. /**
  233.  * Rename a schedule with oldName to newName.
  234.  * @param {string} oldName The name of the schedule to be renamed.
  235.  * @param {string} newName The new name of the schedule. The name cannot be empty.
  236.  * @param {boolean} useSync (optional) If true then return a rejected promise
  237.  * since this only supports async code.
  238.  * @return {Promise} A promise that fulfills when the schedule is renamed, or
  239.  * that is rejected with GroupManagerDb.Error if a schedule with newName already
  240.  * exists, if the schedule with oldName does not exist, if newName is empty, or
  241.  * other database error.
  242.  */
  243. Sqlite3GroupManagerDb.prototype.renameSchedulePromise = function
  244.   (oldName, newName, useSync)
  245. {
  246.   if (useSync)
  247.     return Promise.reject(new GroupManagerDb.Error(new Error
  248.       ("Sqlite3GroupManagerDb.renameSchedulePromise is only supported for async")));
  250.   if (newName.length == 0)
  251.     return Promise.reject(new GroupManagerDb.Error(new Error
  252.       ("Sqlite3GroupManagerDb.renameSchedule: The schedule newName cannot be empty")));
  254.   return this.runPromise_
  255.     ("UPDATE schedules SET schedule_name=? WHERE schedule_name=?",
  256.      [newName, oldName]);
  257. };
  259. /**
  260.  * Update the schedule with name and replace the old object with the given
  261.  * schedule. Otherwise, if no schedule with name exists, a new schedule
  262.  * with name and the given schedule will be added to database.
  263.  * @param {string} name The name of the schedule. The name cannot be empty.
  264.  * @param {Schedule} schedule The Schedule to update or add.
  265.  * @param {boolean} useSync (optional) If true then return a rejected promise
  266.  * since this only supports async code.
  267.  * @return {Promise} A promise that fulfills when the schedule is updated, or
  268.  * that is rejected with GroupManagerDb.Error if the name is empty, or other
  269.  * database error.
  270.  */
  271. Sqlite3GroupManagerDb.prototype.updateSchedulePromise = function
  272.   (name, schedule, useSync)
  273. {
  274.   if (useSync)
  275.     return Promise.reject(new GroupManagerDb.Error(new Error
  276.       ("Sqlite3GroupManagerDb.updateSchedulePromise is only supported for async")));
  278.   var thisManager = this;
  279.   return this.hasSchedulePromise(name)
  280.   .then(function(hasSchedule) {
  281.     if (!hasSchedule)
  282.       return thisManager.addSchedulePromise(name, schedule);
  284.     return thisManager.runPromise_
  285.       ("UPDATE schedules SET schedule=? WHERE schedule_name=?",
  286.        [schedule.wireEncode().buf(), name]);
  287.   });
  288. };
  290. ////////////////////////////////////////////////////// Member management.
  292. /**
  293.  * Check if there is a member with the given identity name.
  294.  * @param {Name} identity The member's identity name.
  295.  * @param {boolean} useSync (optional) If true then return a rejected promise
  296.  * since this only supports async code.
  297.  * @return {Promise} A promise that returns true if there is a member (else
  298.  * false), or that is rejected with GroupManagerDb.Error for a database error.
  299.  */
  300. Sqlite3GroupManagerDb.prototype.hasMemberPromise = function(identity, useSync)
  301. {
  302.   if (useSync)
  303.     return Promise.reject(new GroupManagerDb.Error(new Error
  304.       ("Sqlite3GroupManagerDb.hasMemberPromise is only supported for async")));
  306.   return this.getPromise_
  307.     ("SELECT member_id FROM members WHERE member_name=?",
  308.      identity.wireEncode(TlvWireFormat.get()).buf())
  309.   .then(function(row) {
  310.     if (row)
  311.       return Promise.resolve(true);
  312.     else
  313.       return Promise.resolve(false);
  314.   });
  315. };
  317. /**
  318.  * List all the members.
  319.  * @param {boolean} useSync (optional) If true then return a rejected promise
  320.  * since this only supports async code.
  321.  * @return {Promise} A promise that returns a new array of Name with the names
  322.  * of all members, or that is rejected with GroupManagerDb.Error for a
  323.  * database error.
  324.  */
  325. Sqlite3GroupManagerDb.prototype.listAllMembersPromise = function(useSync)
  326. {
  327.   if (useSync)
  328.     return Promise.reject(new GroupManagerDb.Error(new Error
  329.       ("Sqlite3GroupManagerDb.listAllMembersPromise is only supported for async")));
  331.   var list = [];
  332.   var onRowError = null;
  333.   return this.eachPromise_
  334.     ("SELECT member_name FROM members", [], function(err, row) {
  335.       try {
  336.         var identity = new Name();
  337.         identity.wireDecode(new Blob(row.member_name, false), TlvWireFormat.get());
  338.         list.push(identity);
  339.       } catch (ex) {
  340.         // We don't expect this to happen.
  341.         onRowError = new GroupManagerDb.Error(new Error
  342.           ("Sqlite3GroupManagerDb.listAllMembersPromise: Error decoding name: " + ex));
  343.       }
  344.     })
  345.   .then(function() {
  346.     if (onRowError)
  347.       return Promise.reject(onRowError);
  348.     else
  349.       return Promise.resolve(list);
  350.   });
  351. };
  353. /**
  354.  * Get the name of the schedule for the given member's identity name.
  355.  * @param {Name} identity The member's identity name.
  356.  * @param {boolean} useSync (optional) If true then return a rejected promise
  357.  * since this only supports async code.
  358.  * @return {Promise} A promise that returns the string schedule name, or that is
  359.  * rejected with GroupManagerDb.Error if there's no member with the given
  360.  * identity name in the database, or other database error.
  361.  */
  362. Sqlite3GroupManagerDb.prototype.getMemberSchedulePromise = function
  363.   (identity, useSync)
  364. {
  365.   if (useSync)
  366.     return Promise.reject(new GroupManagerDb.Error(new Error
  367.       ("Sqlite3GroupManagerDb.getMemberSchedulePromise is only supported for async")));
  369.   return this.getPromise_
  370.     ("SELECT schedule_name " +
  371.      "FROM schedules JOIN members " +
  372.      "ON schedules.schedule_id = members.schedule_id " +
  373.      "WHERE member_name=?",
  374.      identity.wireEncode(TlvWireFormat.get()).buf())
  375.   .then(function(row) {
  376.     if (row)
  377.       return Promise.resolve(row.schedule_name);
  378.     else
  379.       return Promise.reject(new GroupManagerDb.Error(new Error
  380.         ("Sqlite3GroupManagerDb.getMemberSchedulePromise: Cannot get the result from the database")));
  381.   });
  382. };
  384. /**
  385.  * Add a new member with the given key named keyName into a schedule named
  386.  * scheduleName. The member's identity name is keyName.getPrefix(-1).
  387.  * @param {string} scheduleName The schedule name.
  388.  * @param {Name} keyName The name of the key.
  389.  * @param {Blob} key A Blob of the public key DER.
  390.  * @param {boolean} useSync (optional) If true then return a rejected promise
  391.  * since this only supports async code.
  392.  * @return {Promise} A promise that fulfills when the member is added, or that
  393.  * is rejected with GroupManagerDb.Error if there's no schedule named
  394.  * scheduleName, if the member's identity name already exists, or other database
  395.  * error.
  396.  */
  397. Sqlite3GroupManagerDb.prototype.addMemberPromise = function
  398.   (scheduleName, keyName, key, useSync)
  399. {
  400.   if (useSync)
  401.     return Promise.reject(new GroupManagerDb.Error(new Error
  402.       ("Sqlite3GroupManagerDb.addMemberPromise is only supported for async")));
  404.   var thisManager = this;
  405.   return this.getScheduleIdPromise_(scheduleName)
  406.   .then(function(scheduleId) {
  407.     if (scheduleId == -1)
  408.       return Promise.reject(new GroupManagerDb.Error(new Error
  409.         ("Sqlite3GroupManagerDb.addMemberPromise: The schedule does not exist")));
  411.     // Needs to be changed in the future.
  412.     var memberName = keyName.getPrefix(-1);
  414.     return thisManager.runPromise_
  415.         ("INSERT INTO members(schedule_id, member_name, key_name, pubkey) " +
  416.          "values (?, ?, ?, ?)",
  417.          [scheduleId, memberName.wireEncode(TlvWireFormat.get()).buf(),
  418.           keyName.wireEncode(TlvWireFormat.get()).buf(), key.buf()]);
  419.   });
  420. };
  422. /**
  423.  * Change the name of the schedule for the given member's identity name.
  424.  * @param {Name} identity The member's identity name.
  425.  * @param {string} scheduleName The new schedule name.
  426.  * @param {boolean} useSync (optional) If true then return a rejected promise
  427.  * since this only supports async code.
  428.  * @return {Promise} A promise that fulfills when the member is updated, or that
  429.  * is rejected with GroupManagerDb.Error if there's no member with the given
  430.  * identity name in the database, or there's no schedule named scheduleName, or
  431.  * other database error.
  432.  */
  433. Sqlite3GroupManagerDb.prototype.updateMemberSchedulePromise = function
  434.   (identity, scheduleName, useSync)
  435. {
  436.   if (useSync)
  437.     return Promise.reject(new GroupManagerDb.Error(new Error
  438.       ("Sqlite3GroupManagerDb.updateMemberSchedulePromise is only supported for async")));
  440.   var thisManager = this;
  441.   return this.getScheduleIdPromise_(scheduleName)
  442.   .then(function(scheduleId) {
  443.     if (scheduleId == -1)
  444.       return Promise.reject(new GroupManagerDb.Error(new Error
  445.         ("Sqlite3GroupManagerDb.updateMemberSchedulePromise: The schedule does not exist")));
  447.     return thisManager.runPromise_
  448.         ("UPDATE members SET schedule_id=? WHERE member_name=?",
  449.          [scheduleId, identity.wireEncode(TlvWireFormat.get()).buf()]);
  450.   });
  451. };
  453. /**
  454.  * Delete a member with the given identity name. If there is no member with
  455.  * the identity name, then do nothing.
  456.  * @param {Name} identity The member's identity name.
  457.  * @param {boolean} useSync (optional) If true then return a rejected promise
  458.  * since this only supports async code.
  459.  * @return {Promise} A promise that fulfills when the member is deleted (or
  460.  * there is no such member), or that is rejected with GroupManagerDb.Error for a
  461.  * database error.
  462.  */
  463. Sqlite3GroupManagerDb.prototype.deleteMemberPromise = function
  464.   (identity, useSync)
  465. {
  466.   if (useSync)
  467.     return Promise.reject(new GroupManagerDb.Error(new Error
  468.       ("Sqlite3GroupManagerDb.deleteMemberPromise is only supported for async")));
  470.   return this.runPromise_
  471.     ("DELETE FROM members WHERE member_name=?",
  472.      identity.wireEncode(TlvWireFormat.get()).buf());
  473. };
  475. /**
  476.  * Check if there is an EKey with the name eKeyName in the database.
  477.  * @param {Name} eKeyName The name of the EKey.
  478.  * @param {boolean} useSync (optional) If true then return a rejected promise
  479.  * since this only supports async code.
  480.  * @return {Promise|SyncPromise} A promise that returns true if the EKey exists
  481.  * (else false), or that is rejected with GroupManagerDb.Error for a database
  482.  * error.
  483.  */
  484. GroupManagerDb.prototype.hasEKeyPromise = function(eKeyName, useSync)
  485. {
  486.   if (useSync)
  487.     return Promise.reject(new GroupManagerDb.Error(new Error
  488.       ("Sqlite3GroupManagerDb.hasEKeyPromise is only supported for async")));
  490.   return this.getPromise_
  491.     ("SELECT ekey_id FROM ekeys where ekey_name=?",
  492.      eKeyName.wireEncode(TlvWireFormat.get()).buf())
  493.   .then(function(row) {
  494.     if (row)
  495.       return Promise.resolve(true);
  496.     else
  497.       return Promise.resolve(false);
  498.   });
  499. };
  501. /**
  502.  * Add the EKey with name eKeyName to the database.
  503.  * Add the EKey with name eKeyName to the database.
  504.  * @param {Name} eKeyName The name of the EKey. This copies the Name.
  505.  * @param {Blob} publicKey The encoded public Key of the group key pair.
  506.  * @param {Blob} privateKey The encoded private Key of the group key pair.
  507.  * @param {boolean} useSync (optional) If true then return a rejected promise
  508.  * since this only supports async code.
  509.  * @return {Promise|SyncPromise} A promise that fulfills when the EKey is added,
  510.  * or that is rejected with GroupManagerDb.Error if a key with name eKeyName
  511.  * already exists in the database, or other database error.
  512.  */
  513. Sqlite3GroupManagerDb.prototype.addEKeyPromise = function
  514.   (eKeyName, publicKey, privateKey, useSync)
  515. {
  516.   if (useSync)
  517.     return Promise.reject(new GroupManagerDb.Error(new Error
  518.       ("Sqlite3GroupManagerDb.addEKeyPromise is only supported for async")));
  520.   var thisManager = this;
  521.   return this.runPromise_
  522.     ("INSERT INTO ekeys(ekey_name, pub_key) values (?, ?)",
  523.      [eKeyName.wireEncode(TlvWireFormat.get()).buf(), publicKey.buf()])
  524.   .then(function() {
  525.     thisManager.privateKeyBase_[eKeyName.toUri()] = privateKey;
  527.     return Promise.resolve();
  528.   });
  529. };
  531. /**
  532.  * Get the group key pair with the name eKeyName from the database.
  533.  * @param {Name} eKeyName The name of the EKey.
  534.  * @param {boolean} useSync (optional) If true then return a rejected promise
  535.  * since this only supports async code.
  536.  * @return {Promise|SyncPromise} A promise that returns an object (where
  537.  * "publicKey" is the public key Blob and "privateKey" is the private key Blob),
  538.  * or that is rejected with GroupManagerDb.Error for a database error.
  539.  */
  540. Sqlite3GroupManagerDb.prototype.getEKeyPromise = function(eKeyName, useSync)
  541. {
  542.   if (useSync)
  543.     return Promise.reject(new GroupManagerDb.Error(new Error
  544.       ("Sqlite3GroupManagerDb.getEKeyPromise is only supported for async")));
  546.   var thisManager = this;
  547.   return this.getPromise_
  548.     ("SELECT pub_key FROM ekeys where ekey_name=?",
  549.      eKeyName.wireEncode(TlvWireFormat.get()).buf())
  550.   .then(function(row) {
  551.     if (row)
  552.       return Promise.resolve({
  553.         publicKey: new Blob(row.pub_key, false),
  554.         privateKey: thisManager.privateKeyBase_[eKeyName.toUri()]  });
  555.     else
  556.       return Promise.reject(new GroupManagerDb.Error(new Error
  557.         ("Sqlite3GroupManagerDb.getEKeyPromise: Cannot get the result from the database")));
  558.   });
  559. };
  561. /**
  562.  * Delete all the EKeys in the database. The database will keep growing because
  563.  * EKeys will keep being added, so this method should be called periodically.
  564.  * @param {boolean} useSync (optional) If true then return a rejected promise
  565.  * since this only supports async code.
  566.  * @return {Promise|SyncPromise} A promise that fulfills when the EKeys are
  567.  * deleted, or that is rejected with GroupManagerDb.Error for a database error.
  568.  */
  569. GroupManagerDb.prototype.cleanEKeysPromise = function(useSync)
  570. {
  571.   return Promise.reject(new Error
  572.     ("GroupManagerDb.cleanEKeysPromise is not implemented"));
  574.   var thisManager = this;
  575.   return this.runPromise_("DELETE FROM ekeys")
  576.   .then(function() {
  577.     thisManager.privateKeyBase_ = {};
  579.     return Promise.resolve();
  580.   });
  581. };
  583. /**
  584.  * Delete the EKey with name eKeyName from the database. If no key with the
  585.  * name exists in the database, do nothing.
  586.  * @param {Name} eKeyName The name of the EKey.
  587.  * @param {boolean} useSync (optional) If true then return a rejected promise
  588.  * since this only supports async code.
  589.  * @return {Promise|SyncPromise} A promise that fulfills when the EKey is
  590.  * deleted (or there is no such key), or that is rejected with
  591.  * GroupManagerDb.Error for a database error.
  592.  */
  593. Sqlite3GroupManagerDb.prototype.deleteEKeyPromise = function(eKeyName, useSync)
  594. {
  595.   if (useSync)
  596.     return Promise.reject(new GroupManagerDb.Error(new Error
  597.       ("Sqlite3GroupManagerDb.deleteEKeyPromise is only supported for async")));
  599.   var thisManager = this;
  600.   return this.runPromise_
  601.     ("DELETE FROM ekeys WHERE ekey_name=?",
  602.      [eKeyName.wireEncode(TlvWireFormat.get()).buf()])
  603.   .then(function() {
  604.     delete thisManager.privateKeyBase_[eKeyName.toUri()];
  606.     return Promise.resolve();
  607.   });
  608. };
  610. /**
  611.  * Get the ID for the schedule.
  612.  * @param {string} name The schedule name.
  613.  * @return {Promise} A promise that returns the ID (or -1 if not found), or that
  614.  * is rejected with GroupManagerDb.Error for a database error.
  615.  */
  616. Sqlite3GroupManagerDb.prototype.getScheduleIdPromise_ = function(name)
  617. {
  618.   return this.getPromise_
  619.     ("SELECT schedule_id FROM schedules WHERE schedule_name=?", name)
  620.   .then(function(row) {
  621.     if (row)
  622.       return Promise.resolve(row.schedule_id);
  623.     else
  624.       return Promise.resolve(-1);
  625.   });
  626. };
  628. /**
  629.  * Call Sqlite3Promise.runPromise, wrapping an Error in GroupManagerDb.Error.
  630.  */
  631. Sqlite3GroupManagerDb.prototype.runPromise_ = function(sql, params)
  632. {
  633.   return this.database_.runPromise(sql, params)
  634.   .catch(function(error) {
  635.     return Promise.reject(new GroupManagerDb.Error(error));
  636.   });
  637. };
  639. /**
  640.  * Call Sqlite3Promise.getPromise, wrapping an Error in GroupManagerDb.Error.
  641.  */
  642. Sqlite3GroupManagerDb.prototype.getPromise_ = function(sql, params)
  643. {
  644.   return this.database_.getPromise(sql, params)
  645.   .catch(function(error) {
  646.     return Promise.reject(new GroupManagerDb.Error(error));
  647.   });
  648. };
  650. /**
  651.  * Call Sqlite3Promise.eachPromise, wrapping an Error in GroupManagerDb.Error.
  652.  */
  653. Sqlite3GroupManagerDb.prototype.eachPromise_ = function(sql, params, onRow)
  654. {
  655.   return this.database_.eachPromise(sql, params, onRow)
  656.   .catch(function(error) {
  657.     return Promise.reject(new GroupManagerDb.Error(error));
  658.   });
  659. };
  661. Sqlite3GroupManagerDb.initializeDatabasePromise_ = function(database)
  662. {
  663.   // Enable foreign keys.
  664.   return database.runPromise("PRAGMA foreign_keys = ON")
  665.   .then(function() {
  666.     return database.runPromise(Sqlite3GroupManagerDb.INITIALIZATION1);
  667.   })
  668.   .then(function() {
  669.     return database.runPromise(Sqlite3GroupManagerDb.INITIALIZATION2);
  670.   })
  671.   .then(function() {
  672.     return database.runPromise(Sqlite3GroupManagerDb.INITIALIZATION3);
  673.   })
  674.   .then(function() {
  675.     return database.runPromise(Sqlite3GroupManagerDb.INITIALIZATION4);
  676.   })
  677.   .then(function() {
  678.     return database.runPromise(Sqlite3GroupManagerDb.INITIALIZATION5);
  679.   })
  680.   .then(function() {
  681.     return database.runPromise(Sqlite3GroupManagerDb.INITIALIZATION6);
  682.   });
  683. };
  685. Sqlite3GroupManagerDb.INITIALIZATION1 =
  686.   "CREATE TABLE IF NOT EXISTS                         \n" +
  687.   "  schedules(                                       \n" +
  688.   "    schedule_id         INTEGER PRIMARY KEY,       \n" +
  689.   "    schedule_name       TEXT NOT NULL,             \n" +
  690.   "    schedule            BLOB NOT NULL              \n" +
  691.   "  );                                               \n";
  692. Sqlite3GroupManagerDb.INITIALIZATION2 =
  693.   "CREATE UNIQUE INDEX IF NOT EXISTS                  \n" +
  694.   "   scheduleNameIndex ON schedules(schedule_name);  \n";
  695. Sqlite3GroupManagerDb.INITIALIZATION3 =
  696.   "CREATE TABLE IF NOT EXISTS                         \n" +
  697.   "  members(                                         \n" +
  698.   "    member_id           INTEGER PRIMARY KEY,       \n" +
  699.   "    schedule_id         INTEGER NOT NULL,          \n" +
  700.   "    member_name         BLOB NOT NULL,             \n" +
  701.   "    key_name            BLOB NOT NULL,             \n" +
  702.   "    pubkey              BLOB NOT NULL,             \n" +
  703.   "    FOREIGN KEY(schedule_id)                       \n" +
  704.   "      REFERENCES schedules(schedule_id)            \n" +
  705.   "      ON DELETE CASCADE                            \n" +
  706.   "      ON UPDATE CASCADE                            \n" +
  707.   "  );                                               \n";
  708. Sqlite3GroupManagerDb.INITIALIZATION4 =
  709.   "CREATE UNIQUE INDEX IF NOT EXISTS                  \n" +
  710.   "   memNameIndex ON members(member_name);           \n";
  711. Sqlite3GroupManagerDb.INITIALIZATION5 =
  712.   "CREATE TABLE IF NOT EXISTS                         \n" +
  713.   "  ekeys(                                           \n" +
  714.   "    ekey_id             INTEGER PRIMARY KEY,       \n" +
  715.   "    ekey_name           BLOB NOT NULL,             \n" +
  716.   "    pub_key             BLOB NOT NULL              \n" +
  717.   "  );                                               \n";
  718. Sqlite3GroupManagerDb.INITIALIZATION6 =
  719.     "CREATE UNIQUE INDEX IF NOT EXISTS                  \n" +
  720.     "   ekeyNameIndex ON ekeys(ekey_name);              \n";