openhim-mediator-shell-script/lib/index.js

OpenHIM Mediator for executing shell scripts

var app, bodyParser, buildArgs, config, debugLogConfig, express, fs, getAvailableScripts, handler, isScriptNameValid, logger, mediatorUtils, path, restartExpress, server, setupEnv, spawn, startExpress, util,
  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; };

require('./init');

logger = require('winston');

config = require('./config');

express = require('express');

bodyParser = require('body-parser');

mediatorUtils = require('openhim-mediator-utils');

util = require('./util');

fs = require('fs');

path = require('path');

spawn = require('child_process').spawn;

buildArgs = function(script) {
  var args, cArg;
  args = [];
  if (script["arguments"]) {
    for (cArg in script["arguments"]) {
      args.push(cArg);
      if (script["arguments"][cArg]) {
        args.push(script["arguments"][cArg]);
      }
    }
  }
  return args;
};

setupEnv = function(script) {
  var env, k;
  if (script.env) {
    env = {};
    for (k in process.env) {
      env[k] = process.env[k];
    }
    for (k in script.env) {
      env[k] = script.env[k];
    }
    return env;
  } else {
    return process.env;
  }
};

handler = function(script) {
  return function(req, res) {
    var appendToOut, args, cmd, openhimTransactionID, out, scriptCmd;
    openhimTransactionID = req.headers['x-openhim-transactionid'];
    scriptCmd = path.join(config.getConf().scriptsDirectory, script.filename);
    args = buildArgs(script);
    cmd = spawn(scriptCmd, args, {
      env: setupEnv(script)
    });
    logger.info("[" + openhimTransactionID + "] Executing " + scriptCmd + " " + (args.join(' ')));
    out = "";
    appendToOut = function(data) {
      out = "" + out + data;
      return logger.info("[" + openhimTransactionID + "] Script output: " + data);
    };
    cmd.stdout.on('data', appendToOut);
    cmd.stderr.on('data', appendToOut);
    return cmd.on('close', function(code) {
      logger.info("[" + openhimTransactionID + "] Script exited with status " + code);
      res.set('Content-Type', 'application/json+openhim');
      return res.send({
        'x-mediator-urn': config.getMediatorConf().urn,
        status: code === 0 ? 'Successful' : 'Failed',
        response: {
          status: code === 0 ? 200 : 500,
          headers: {
            'content-type': 'application/json'
          },
          body: out,
          timestamp: new Date()
        }
      });
    });
  };
};

app = null;

server = null;

getAvailableScripts = function(callback) {
  return fs.readdir(config.getConf().scriptsDirectory, callback);
};

isScriptNameValid = function(name) {
  return !(name.length === 0 || name[0] === '.' || name.indexOf('/') > -1 || name.indexOf('\\') > -1);
};

startExpress = function() {
  return getAvailableScripts(function(err, scriptNames) {
    var fn, i, len, ref, script;
    if (err) {
      logger.error(err);
      process.exit(1);
    }
    logger.info("Available scripts: " + ((scriptNames.filter(function(d) {
      return !d.startsWith('.');
    })).join(', ')));
    app = express();
    app.use(bodyParser.json());
    if (config.getConf().scripts) {
      ref = config.getConf().scripts;
      fn = function(script) {
        var ref1;
        if (isScriptNameValid(script.filename) && (ref1 = script.filename, indexOf.call(scriptNames, ref1) >= 0)) {
          app.get(script.endpoint, handler(script));
          return logger.info("Initialized endpoint '" + script.endpoint + "' for script '" + script.filename + "'");
        } else {
          logger.warn("Invalid script name specified '" + script.filename + "'");
          return logger.warn("Check that this script is located in the scripts directory '" + (config.getConf().scriptsDirectory) + "'");
        }
      };
      for (i = 0, len = ref.length; i < len; i++) {
        script = ref[i];
        fn(script);
      }
    }
    server = app.listen(config.getConf().server.port, config.getConf().server.hostname, function() {
      return logger.info("[" + process.env.NODE_ENV + "] " + (config.getMediatorConf().name) + " running on port " + (server.address().address) + ":" + (server.address().port));
    });
    return server.timeout = 0;
  });
};

restartExpress = function() {
  if (server) {
    logger.info("Re-initializing express server ...");
    server.close();
    return startExpress();
  }
};

debugLogConfig = function() {
  if (config.getConf().logger.level === 'debug') {
    logger.debug('Full config:');
    return logger.debug(JSON.stringify(config.getConf(), null, '  '));
  }
};

if (process.env.NODE_ENV !== 'test') {
  logger.info('Attempting to register mediator with core ...');
  config.getConf().openhim.api.urn = config.getMediatorConf().urn;
  mediatorUtils.registerMediator(config.getConf().openhim.api, config.getMediatorConf(), function(err) {
    var configEmitter;
    if (err) {
      logger.error(err);
      process.exit(1);
    }
    logger.info('Mediator has been successfully registered');
    configEmitter = mediatorUtils.activateHeartbeat(config.getConf().openhim.api);
    configEmitter.on('config', function(newConfig) {
      logger.info('Received updated config from core');
      config.updateConf(newConfig);
      debugLogConfig();
      return restartExpress();
    });
    configEmitter.on('error', function(err) {
      return logger.error(err);
    });
    return mediatorUtils.fetchConfig(config.getConf().openhim.api, function(err, newConfig) {
      if (err) {
        return logger.error(err);
      }
      logger.info('Received initial config from core');
      config.updateConf(newConfig);
      debugLogConfig();
      return startExpress();
    });
  });
}

exports.app = app;

//# sourceMappingURL=index.js.map