openhim-core/lib/upgradeDB.js

The OpenHIM core application that provides logging and routing of http requests

var Client, Keystore, Q, dbVersion, logger, pem, runUpgradeFunc, upgradeFuncs;

dbVersion = require('./model/dbVersion').dbVersion;

Keystore = require('./model/keystore').Keystore;

Client = require('./model/clients').Client;

logger = require('winston');

pem = require('pem');

Q = require('q');

upgradeFuncs = [];

upgradeFuncs.push({
  description: "Ensure that all certs have a fingerprint property",
  func: function() {
    var defer;
    defer = Q.defer();
    Keystore.findOne(function(err, keystore) {
      if (!keystore) {
        return defer.resolve();
      }
      return pem.getFingerprint(keystore.cert.data, function(err, obj) {
        var caDefer, cert, fn, i, j, len, promises, ref;
        keystore.cert.fingerprint = obj.fingerprint;
        promises = [];
        ref = keystore.ca;
        fn = function(caDefer, i) {
          return pem.getFingerprint(cert.data, function(err, obj) {
            keystore.ca[i].fingerprint = obj.fingerprint;
            return caDefer.resolve();
          });
        };
        for (i = j = 0, len = ref.length; j < len; i = ++j) {
          cert = ref[i];
          caDefer = Q.defer();
          promises.push(caDefer.promise);
          fn(caDefer, i);
        }
        return Q.all(promises).then(function() {
          return keystore.save(function(err) {
            if (err != null) {
              logger.error("Failed to save keystore: " + err);
            }
            return defer.resolve();
          });
        });
      });
    });
    return defer.promise;
  }
});

upgradeFuncs.push({
  description: "Convert clients link to certs via their domain to use the cert fingerprint instead",
  func: function() {
    var defer;
    defer = Q.defer();
    Client.find(function(err, clients) {
      if (err != null) {
        logger.error("Couldn't fetch all clients to upgrade db: " + err);
        return defer.reject();
      }
      return Keystore.findOne(function(err, keystore) {
        var cert, client, clientDefer, fn, j, k, len, len1, promises, ref;
        if (err != null) {
          logger.error("Couldn't fetch keystore to upgrade db: " + err);
          return defer.reject();
        }
        promises = [];
        fn = function(clientDefer) {
          return client.save(function(err) {
            if (err != null) {
              logger.error("Couldn't save client " + client.clientID + " while upgrading db: " + err);
              return clientDefer.reject();
            }
            return clientDefer.resolve();
          });
        };
        for (j = 0, len = clients.length; j < len; j++) {
          client = clients[j];
          clientDefer = Q.defer();
          promises.push(clientDefer.promise);
          if ((keystore != null ? keystore.ca : void 0) != null) {
            ref = keystore.ca;
            for (k = 0, len1 = ref.length; k < len1; k++) {
              cert = ref[k];
              if (client.clientDomain === cert.commonName && (client.certFingerprint == null)) {
                client.certFingerprint = cert.fingerprint;
                break;
              }
            }
          }
          fn(clientDefer);
        }
        return Q.all(promises).then(function() {
          return defer.resolve();
        });
      });
    });
    return defer.promise;
  }
});

runUpgradeFunc = function(i, dbVer) {
  var defer;
  logger.info("  \u2022 Running update: " + upgradeFuncs[i].description + "...");
  defer = Q.defer();
  upgradeFuncs[i].func().then(function() {
    dbVer.version = i;
    dbVer.lastUpdated = new Date();
    return dbVer.save(function(err) {
      if (err != null) {
        logger.error(err);
      }
      logger.info("  \u2713 Done.");
      return defer.resolve();
    });
  });
  return defer.promise;
};

if (process.env.NODE_ENV === "test") {
  exports.upgradeFuncs = upgradeFuncs;
  exports.runUpgradeFunc = runUpgradeFunc;
}

exports.upgradeDb = function(callback) {
  return dbVersion.findOne(function(err, dbVer) {
    var fn, i, j, promise, ref, ref1;
    if (dbVer === null) {
      dbVer = new dbVersion({
        version: -1,
        lastUpdated: new Date()
      });
    }
    if (dbVer.version < (upgradeFuncs.length - 1)) {
      logger.info('Upgrading the database...');
      promise = null;
      fn = function(i) {
        if (promise == null) {
          return promise = runUpgradeFunc(i, dbVer);
        } else {
          return promise = promise.then(function() {
            return runUpgradeFunc(i, dbVer);
          });
        }
      };
      for (i = j = ref = dbVer.version + 1, ref1 = upgradeFuncs.length - 1; ref <= ref1 ? j <= ref1 : j >= ref1; i = ref <= ref1 ? ++j : --j) {
        fn(i);
      }
      return promise.then(function() {
        logger.info('Completed database upgrade');
        return callback();
      });
    } else {
      logger.info('No database upgrades needed');
      return callback();
    }
  });
};

if (!module.parent) {
  exports.upgradeDb(function() {
    return process.exit();
  });
}

//# sourceMappingURL=upgradeDB.js.map