bootstrap.js

/**
 * @file
 * Bootstrap the application to allow self-updating.
 */

'use strict';

const debug = require('debug')('bibbox:bootstrap');
const fork = require('child_process').fork;
const spawn = require('child_process').spawn;
const UrlParser = require('url');
const queryString = require('querystring');

const config = require(__dirname + '/config.json');
const Q = require('q');

const fs = require('fs');
const https = require('https');

const rfid_debug = process.env.RFID_DEBUG || false;

let shutdown = false;

const Bootstrap = function Bootstrap() {
  let self = this;
  this.bibbox = null;
  this.rfidApp = null;
  this.alive = 0;

  const options = {
    key: fs.readFileSync(__dirname + '/' + config.bootstrap.ssl.key),
    cert: fs.readFileSync(__dirname + '/' + config.bootstrap.ssl.cert)
  };

  https.createServer(options, function (req, res) {
    let ip = self.getRemoteIp(req);
    let url = req.url;
    if (config.bootstrap.allowed.indexOf(ip) > -1) {
      debug('Requested url: "' + url + '" from: "' + ip + '" allowed');
      res.setHeader('Content-Type', 'application/json');
      res.writeHead(200);
      url = UrlParser.parse(url);

      // Check if this is a post request, if it is parse the request an wait for
      // the data.
      if (req.method === 'POST') {
        self.parseBody(req).then(function (body) {
          self.handleRequest(req, res, url, body);
        }, function (err) {
          res.write(JSON.stringify({
            error: err
          }));
          res.end();
        });
      }
      else {
        self.handleRequest(req, res, url);
      }
    }
    else {
      debug('Requested url: "' + url + '" from: "' + ip + '" denied');
      res.writeHead(401);
      res.write('Unauthorized');
      res.end();
    }
  }).listen(config.bootstrap.port);

  debug('Https server started at: ' + config.bootstrap.port);
};

// Extend the object with event emitter.
const eventEmitter = require('events').EventEmitter;
const util = require('util');
util.inherits(Bootstrap, eventEmitter);

/**
 * Handler for the request.
 *
 * This is used after the body have been parsed into JSON, if it was a post
 * request.
 *
 * @param {object} req
 *  HTTP request object.
 * @param {object} res
 *  HTTP response object.
 * @param {string} url
 *   The URL the request came in on.
 * @param {object} body
 *   The body pay-load as JSON, if post request else undefined.
 */
Bootstrap.prototype.handleRequest = function handleRequest(req, res, url, body) {
  let self = this;
  let query = null;

  body = body || false;

  /**
   * Restart Node.js application.
   */
  switch (url.pathname) {
    case '/restart/application':
      self.restartApp().then(function () {
        res.write(JSON.stringify({
          pid: self.bibbox.pid,
          status: 'running'
        }));
        res.end();

      }, function (err) {
        res.write(JSON.stringify({
          pid: 0,
          status: 'stopped',
          error: err.message
        }));
        res.end();
      });

      break;

    /**
     * Send reload event to the UI.
     */
    case '/restart/ui':
      self.bibbox.send({
        command: 'reloadUi'
      });
      res.write(JSON.stringify({
        status: 'Reload sent'
      }));
      res.end();
      break;

    /**
     * Send reboot computer.
     */
    case '/reboot':
      spawn('/sbin/reboot');
      res.write(JSON.stringify({
        status: 'Reboot started'
      }));
      res.end();
      break;

    /**
     * Send out of order.
     */
    case '/outoforder':
      self.bibbox.send({
        command: 'outOfOrder'
      });
      res.write(JSON.stringify({
        status: 'Out of order sent.'
      }));
      res.end();
      break;

    case '/clearprinter':
      spawn('cancel', ['-a', '-x']);
      res.write(JSON.stringify({
        status: 'Clear printer queue command sent.'
      }));
      res.end();
      break;

    /**
     * Update based on pull from GitHub.
     *
     * @query version
     *   String with the tag to checkout.
     */
    case '/update/pull':
      query = JSON.parse(JSON.stringify(queryString.parse(url.query)));
      if (query.hasOwnProperty('version')) {
        self.updateApp(query.version).then(function () {
          res.write(JSON.stringify({
            status: 'Restating the application'
          }));
          res.end();

          // Restart the application to allow supervisor to reboot the
          // application.
          process.kill(process.pid, 'SIGTERM');
        }, function (err) {
          res.write(JSON.stringify({
            error: err.message
          }));
          res.end();
        });
      }
      else {
        res.write(JSON.stringify({
          error: 'Missing version in query string'
        }));
        res.end();
      }
      break;

    /**
     * Update based on release file.
     *
     * @query url
     *   String with URL to release file on github.
     */
    case '/update/download':
      query = JSON.parse(JSON.stringify(queryString.parse(url.query)));
      if (query.hasOwnProperty('url')) {
        const urlParser = require('url');
        const path = require('path');
        const dest = __dirname + '/../' + path.basename(urlParser.parse(query.url).pathname);

        self.downloadFile(query.url, dest).then(function (file) {
          // Try to detect version from the filename.
            const regEx = /v(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\da-z\-]+)?/;
            if (!regEx.test(path.basename(file))) {
            let msg = 'Version not found in filename: ' + path.basename(file);
            debug('Err: ' + msg);
            res.write(JSON.stringify({
              error: msg
            }));
            res.end();
            return;
          }

          let version = regEx.exec(path.basename(file))[0];
          let dir = __dirname.substr(0, __dirname.lastIndexOf('/')) + '/' + version;

          debug('Version to update to: ' + version);
          debug('File downloaded to: ' + file);
          debug('Destination: ' + dir);

          // Check that new dir exists.
          if (!fs.existsSync(dir)) {
            fs.mkdirSync(dir);
          }

          // Unpack file
          const tar = spawn('tar', ['-zxf', file, '-C', dir]);
          tar.stderr.on('data', function (data) {
            debug('Err unpacking file: ' + data.toString());
            res.write(JSON.stringify({
              error: data.toString()
            }));
            res.end();
          });

          tar.on('exit', function (code) {
            if (code !== 0) {
              // Not clean exit, so handled in standard error function above.
              return;
            }

            // Update symlink.
            debug('Update symlink.');

            // File unpacked, so clean up.
            fs.unlinkSync(file);

            let target = __dirname;
            target = target.substr(0, target.lastIndexOf('/')) + '/bibbox';

            fs.unlinkSync(target);
            fs.symlink(dir, target, function (err, data) {
              if (err) {
                res.write(JSON.stringify({
                  error: err.message
                }));
                res.end();
              }
              else {
                // Move files folder with config and translation.
                const src = __dirname + '/files';
                debug('Copy files from: ' + src + ' to: ' + dir);

                let cp = spawn('cp', ['-rfp', src, dir]);
                cp.stderr.on('data', function (data) {
                  debug('Err copying file: ' + data.toString());
                  res.write(JSON.stringify({
                    error: data.toString()
                  }));
                  res.end();
                });

                cp.on('exit', function (code) {
                  if (code === 0) {
                    res.write(JSON.stringify({
                      status: 'Restating the application'
                    }));
                    res.end();

                    // Restart the application to allow supervisor to reboot the
                    // application. The timeout is to allow the "res" transmission
                    // to be completed before restart.
                    setTimeout(function () {
                      // Trigger shutdown process with right signal, so clean up is executed.
                      process.kill(process.pid, 'SIGTERM');
                    }, 500);
                  }
                });
              }
            });

          });
        },
        function (err) {
          res.write(JSON.stringify({
            status: 'error',
            error: err.message
          }));
          res.end();
        });
      }
      else {
        res.write(JSON.stringify({
          error: 'Missing url in query string'
        }));
        res.end();
      }
      break;

    /**
     * Send update config to bibbox.
     */
    case '/config':
      self.bibbox.send({
        command: 'config',
        config: body
      });
      res.write(JSON.stringify({
        status: 'Config sent'
      }));
      res.end();
      break;

    /**
     * Send update translations to bibbox.
     */
    case '/translations':
      self.bibbox.send({
        command: 'translations',
        translations: body
      });
      res.write(JSON.stringify({
        status: 'Config sent'
      }));
      res.end();
      break;

    /**
     * Alive (last sean and version).
     */
    case '/alive':
      if (self.bibbox) {
        self.getVersion().then(function (version) {
          res.write(JSON.stringify({
            status: 'running',
            pid: self.bibbox.pid,
            version: version,
            time: Math.round(self.alive / 1000)
          }));
          res.end();
        }, function (err) {
          res.write(JSON.stringify({
            status: 'running',
            pid: self.bibbox.pid,
            version: err,
            time: Math.round(self.alive / 1000)
          }));
          res.end();
        });
      }
      else {
        res.write(JSON.stringify({
          status: 'stopped',
          pid: 0,
          time: Math.round(self.alive / 1000)
        }));
        res.end();
      }
      break;

    /**
     * Get list of failed offline jobs.
     */
    case '/offlineFailedJobs':
      self.bibbox.on('message', function offlineFailedJobs(message) {
        if (message.hasOwnProperty('offlineFailedJobs')) {
          res.write(JSON.stringify({
            status: 'running',
            jobs: message.offlineFailedJobs
          }));
          res.end();
          self.bibbox.removeListener('message', offlineFailedJobs);
        }
        if (message.hasOwnProperty('offlineFailedJobsError')) {
          res.write(JSON.stringify({
            status: 'error',
            message: message.offlineFailedJobsError
          }));
          res.end();
          self.bibbox.removeListener('message', offlineFailedJobs);
        }
      });
      self.bibbox.send({
        command: 'offlineFailedJobs'
      });
      break;

    /**
     * Get offline job counts.
     */
    case '/offlineJobCounts':
      self.bibbox.on('message', function offlineJobCounts(message) {
        if (message.hasOwnProperty('offlineCounts')) {
          res.write(JSON.stringify({
            status: 'running',
            jobs: message.offlineCounts
          }));
          res.end();
          self.bibbox.removeListener('message', offlineJobCounts);
        }
        if (message.hasOwnProperty('offlineCountsError')) {
          res.write(JSON.stringify({
            status: 'error',
            message: message.offlineCountsError
          }));
          res.end();
          self.bibbox.removeListener('message', offlineJobCounts);
        }
      });
      self.bibbox.send({
        command: 'offlineCounts'
      });
      break;

    default:
      res.write('Hello World!');
      res.end();
      break;
  }
};

/**
 * Down load file over https.
 *
 * @param {string} url
 *   Url to download
 * @param {string} destination
 *   Where to download the file.
 *
 * @return {*|promise}
 *   Resolves if file is downloaded correctly.
 */
Bootstrap.prototype.downloadFile = function downloadFile(url, destination) {
  const request = require('request');
  let deferred = Q.defer();
  let file = fs.createWriteStream(destination);

  file.on('finish', function () {
    file.close();
    deferred.resolve(destination);
  });

  request({
    followAllRedirects: true,
    method: 'get',
    url: url
  }).on('error', function (err) {
    debug('Download error: ' + err.message);
    deferred.reject(err);
  }).pipe(file);

  return deferred.promise;
};

/**
 * Parse POST request body.
 *
 * @param {object} req
 *   Request object.
 *
 * @return {*|promise}
 *   Resolved if parsed else rejected.
 */
Bootstrap.prototype.parseBody = function parseBody(req) {
  let deferred = Q.defer();

  let body = '';

  req.on('data', function (data) {
    body += data;

    // Too much POST data, kill the connection!
    // 1e6 === 1 * Math.pow(10, 6) === 1 * 1000000 ~~~ 1MB
    if (body.length > 1e6) {
      req.connection.destroy();
      deferred.reject('Killed');
    }
  });

  req.on('end', function () {
    if (body === '') {
      deferred.resolve();
    }
    else {
      deferred.resolve(JSON.parse(body));
    }
  });

  return deferred.promise;
};

/**
 * Get remote IP.
 *
 * Get the IP of the client.
 *
 * @param {object} req
 *   The http request.
 *
 * @return {*}
 *   The IP as an string.
 */
Bootstrap.prototype.getRemoteIp = function getRemoteIp(req) {
  let ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress || req.socket.remoteAddress || req.connection.socket.remoteAddress;

  // Take the first ip if this is a proxy list.
  if (ip.indexOf(',') !== -1) {
    ip = ip.split(',').unshift();
  }

  return ip;
};

/**
 * Get the current version.
 *
 * @return {*|promise}
 *   Resolve with version or reject with git output.
 */
Bootstrap.prototype.getVersion = function getVersion() {
  let deferred = Q.defer();
  let env = process.env;
  let git = spawn('git', ['describe', '--exact-match', '--tags'], {env: env});

  git.stdout.on('data', function (data) {
    let version = data.toString().replace("\n", '');
    debug('Version: ' + version);
    deferred.resolve(version);
  });

  git.stderr.on('data', function (data) {
    let err = data.toString().replace("\n", '');
    debug('Version error: ' + err);
    deferred.reject(err);
  });

  return deferred.promise;
};

/**
 * Restart the application.
 *
 * @return {*|promise}
 *   Resolves if app have been re-started.
 */
Bootstrap.prototype.restartApp = function restartApp() {
  let self = this;
  let deferred = Q.defer();

  debug('Restart called.');

  Q.all([
    self.stopApp(),
    self.startApp(),
    self.stopRFID(),
    self.startRFID()
  ]).then(function () {
    deferred.resolve();
  }).catch(function (err) {
    deferred.reject(err);
  });

  return deferred.promise;
};

/**
 * Start the application as a child process.
 *
 * @return {*|promise}
 *   Resolves if app have been started and the old one closed.
 */
Bootstrap.prototype.startApp = function startApp() {
  let deferred = Q.defer();
  let self = this;

  if (shutdown) {
    debug('App not started - in shutdown');
    deferred.resolve();
  }
  else {
    let app = fork(__dirname + '/app.js', [], { silent: true });
    debug('Started new application with pid: ' + app.pid);

    // Event handler for startup errors.
    app.once('close', function startupError(code) {
      debug('Bibbox not started exit code: ' + app.exitCode);

      deferred.reject(app.exitCode);
    });

    app.stdout.on('data', function (data) {
      console.log(data.toString());
    });

    app.stderr.on('data', function (data) {
      console.error(data.toString());
    });

    // Listen for "ready" events.
    app.once('message', function (message) {
      if (message.hasOwnProperty('ready')) {
        app.removeAllListeners('close');

        debug('Bibbox is ready with pid: ' + app.pid);
        self.bibbox = app;
        self.bibbox.on('message', function (message) {
          // React to ping events.
          if (message.hasOwnProperty('ping')) {
            self.alive = message.ping;
          }
        });

        // Restart node app on error.
        self.bibbox.on('close', startApp);

        deferred.resolve();
      }
    });
  }

  return deferred.promise;
};

/**
 * Start the RFID application as a new process.
 *
 * @return {*|promise}
 *   Resolves if stated.
 */
Bootstrap.prototype.startRFID = function startRFID() {
  let deferred = Q.defer();

  if (shutdown) {
    debug('RFID not started - in shutdown');
    deferred.resolve();
  }
  else if (!rfid_debug) {
    let env = process.env;
    env.LD_LIBRARY_PATH = '/opt/feig';
    let app = spawn('java', ['-jar', __dirname + '/plugins/rfid/device/rfid.jar'], {env: env});
    debug('Started new rfid application with pid: ' + app.pid);

    // Store ref. to the application.
    this.rfidApp = app;

    // Restart rfid app on error.
    this.rfidApp.on('close', startRFID);
  }
  else {
    debug('RFID not started in DEBUG mode.');
  }

  deferred.resolve();

  return deferred.promise;
};

/**
 * Stop the application.
 *
 * @return {*|promise}
 *   Resolves if app have been closed.
 */
Bootstrap.prototype.stopApp = function stopApp() {
  let deferred = Q.defer();
  let self = this;

  debug('Stop BibBox');

  if (this.bibbox) {
    // Remove auto-start event.
    this.bibbox.removeAllListeners('close');

    // Listen to new close event.
    self.bibbox.on('close', function (code) {
      debug('Stopped application with pid: ' + self.bibbox.pid + ' and exit code: ' + self.bibbox.exitCode);

      // Free memory.
      self.bibbox = null;

      deferred.resolve();
    });

    // Kill the application.
    self.bibbox.kill('SIGTERM');

  }
  else {
    debug('App not running');
    deferred.resolve('Not running.');
  }

  return deferred.promise;
};

/**
 * Stop the RFID application.
 *
 * @return {*|promise}
 *   Resolves if app have been closed.
 */
Bootstrap.prototype.stopRFID = function stopRFID() {
  let deferred = Q.defer();
  let self = this;

  debug('Stop RFID');

  if (this.rfidApp) {
    if (!rfid_debug) {
      // Remove auto-start event.
      this.rfidApp.removeAllListeners('close');

      self.rfidApp.on('close', function (code) {
        debug('Stopped RFID application with pid: ' + self.rfidApp.pid + ' and exit code: ' + self.rfidApp.exitCode);

        // Free memory.
        self.rfidApp = null;

        deferred.resolve();
      });

      self.rfidApp.kill('SIGTERM');
    }
    else {
      debug('RFID not stopped, as we are in DEBUG mode.');
      deferred.resolve();
    }
  }
  else {
    debug('RFID was not running');
    deferred.resolve('Not running');
  }

  return deferred.promise;
};

/**
 * Pull version form git-hub and restart application.
 *
 * @param {string} version
 *   The version to update to.
 *
 * @return {*|promise}
 *   Resolves it the app is updated.
 */
Bootstrap.prototype.updateApp = function updateApp(version) {
  let self = this;
  let deferred = Q.defer();

  debug('Update called.');

  // Update from github.com.
  spawn('git', ['fetch']).on('close', function (code) {
    // Checkout version.
    spawn('git', ['checkout', version]).on('close', function (code) {
      // Copy config file.
      spawn('cp', ['example.config.json', 'config.json']).on('close', function (code) {
        // Restart the application.
        self.restartApp().then(function () {
          deferred.resolve();
        }, function (err) {
          deferred.reject(err);
        });
      });
    });
  });

  return deferred.promise;
};

// Get the show on the road.
const bootstrap = new Bootstrap();
bootstrap.startApp();
bootstrap.startRFID();

/**
 * Handle bootstrap process exit and errors.
 *
 * @param {object} options
 *   Options to the exits handler.
 * @param {error} err
 *   Error object is error is detected.
 */
function exitHandler(options, err) {

  if (!shutdown) {
    shutdown = true;
    Q.all([
      bootstrap.stopApp(),
      bootstrap.stopRFID()
    ]).then(function () {
      debug('All process was closed');
      process.exit();
    }).catch(function (err) {
      debug('Not all process was closed');
      process.exit();
    });
  }
}

// Bootstrap app is closing.
process.once('exit', exitHandler);

// Craches supervisor stop.
process.on('SIGTERM', exitHandler);

// Catches ctrl+c event.
process.on('SIGINT', exitHandler);

// Catches uncaught exceptions.
process.on('uncaughtException', exitHandler);