openhim-core/lib/upgradeDB.js

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

var Client, Keystore, Q, User, Visualizer, adaptOldVisualizerStructure, dbVersion, dedupName, logger, pem, runUpgradeFunc, upgradeFuncs,
  indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };

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

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

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

User = require('./model/users').User;

Visualizer = require('./model/visualizer').Visualizer;

logger = require('winston');

pem = require('pem');

Q = require('q');

dedupName = function(name, names, num) {
  var newName;
  if (num) {
    newName = name + " " + num;
  } else {
    newName = name;
  }
  if (indexOf.call(names, newName) >= 0) {
    if (!num) {
      num = 1;
    }
    return dedupName(name, names, ++num);
  } else {
    return newName;
  }
};

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;
  }
});

adaptOldVisualizerStructure = function(visualizer) {
  var component, endpoint, j, k, len, len1, ref, ref1, results, split;
  visualizer.channels = [];
  visualizer.mediators = [];
  visualizer.time.minDisplayPeriod = 100;
  if (visualizer.endpoints) {
    ref = visualizer.endpoints;
    for (j = 0, len = ref.length; j < len; j++) {
      endpoint = ref[j];
      visualizer.channels.push({
        eventType: 'channel',
        eventName: endpoint.event.replace('channel-', ''),
        display: endpoint.desc
      });
    }
    delete visualizer.endpoints;
  }
  if (visualizer.components) {
    ref1 = visualizer.components;
    results = [];
    for (k = 0, len1 = ref1.length; k < len1; k++) {
      component = ref1[k];
      split = component.event.split('-');
      if (split.length > 1) {
        component.eventType = split[0];
        component.eventName = split[1];
      } else {
        component.eventType = 'channel';
        component.eventName = component.event;
      }
      component.display = component.desc;
      delete component.event;
      results.push(delete component.desc);
    }
    return results;
  }
};

upgradeFuncs.push({
  description: "Migrate visualizer setting from a user's profile to a shared collection",
  func: function() {
    var defer;
    defer = Q.defer();
    User.find(function(err, users) {
      var promises, visNames;
      if (err) {
        return Q.defer().reject(err);
      }
      visNames = [];
      promises = [];
      users.forEach(function(user) {
        var name, ref, ref1, ref2, ref3, ref4, userDefer, vis;
        if (((ref = user.settings) != null ? ref.visualizer : void 0) != null) {
          vis = user.settings.visualizer;
          if (((ref1 = vis.components) != null ? ref1.length : void 0) > 0 || ((ref2 = vis.mediators) != null ? ref2.length : void 0) > 0 || ((ref3 = vis.channels) != null ? ref3.length : void 0) > 0 || ((ref4 = vis.endpoints) != null ? ref4.length : void 0) > 0) {
            userDefer = Q.defer();
            promises.push(userDefer.promise);
            if (vis.endpoints) {
              adaptOldVisualizerStructure(vis);
            }
            name = user.firstname + " " + user.surname + "'s visualizer";
            name = dedupName(name, visNames);
            vis.name = name;
            visNames.push(name);
            vis = new Visualizer(vis);
            logger.debug("Migrating visualizer from user profile " + user.email + ", using visualizer name '" + name + "'");
            return vis.save(function(err, vis) {
              if (err) {
                logger.error("Error migrating visualizer from user profile " + user.email + ": " + err.stack);
                return userDefer.reject(err);
              }
              user.set('settings.visualizer', null);
              return user.save(function(err, user) {
                if (err) {
                  return userDefer.reject(err);
                }
                return userDefer.resolve();
              });
            });
          }
        }
      });
      return Q.all(promises).then(function() {
        return defer.resolve();
      })["catch"](function(err) {
        return defer.reject(err);
      });
    });
    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();
    });
  })["catch"](function(err) {
    return defer.reject(err);
  });
  return defer.promise;
};

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

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();
      })["catch"](function(err) {
        logger.error("There was an error upgrading your database, you will need to fix this manually to continue. " + err.stack);
        return process.exit();
      });
    } else {
      logger.info('No database upgrades needed');
      return callback();
    }
  });
};

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

//# sourceMappingURL=upgradeDB.js.map