division/lib/worker.js

Simple yet powerful wrapper over node.js cluster API. This module is inspired by impressive, but abandoned project Cluster created by TJ Holowaychuk.

var EventEmitter, Worker, cluster, exec,
  __hasProp = {}.hasOwnProperty,
  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  __slice = [].slice;

exec = require('child_process').exec;

cluster = require('cluster');

EventEmitter = require('events').EventEmitter;

module.exports = Worker = (function(_super) {
  var __define;

  __extends(Worker, _super);

  function Worker() {
    var __define;
    __define = (function(_this) {
      return function() {
        var args;
        args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
        return Object.defineProperty.apply(null, [].concat(_this, args));
      };
    })(this);
    __define('instance', {
      value: cluster.fork()
    });
    __define('id', {
      enumerable: true,
      value: this.instance.id
    });
    __define('pid', {
      enumerable: true,
      value: this.instance.process.pid
    });
    __define('startup', {
      enumerable: true,
      value: Date.now()
    });
    __define('status', {
      enumerable: true,
      get: function() {
        return this.instance.state;
      }
    });
    __define('decreased', {
      writable: true,
      value: false
    });
  }

  __define = function() {
    var args;
    args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
    return Object.defineProperty.apply(null, [].concat(Worker.prototype, args));
  };

  __define('close', {
    enumerable: true,
    value: function(timeout, decrease) {
      if (timeout == null) {
        timeout = 2000;
      }
      this.emit.call(this, 'close');
      if (decrease) {
        this.decreased = true;
      }
      try {
        if (!(this.status === 'disconnected' || this.status === 'dead')) {
          this.instance.disconnect();
        }
      } catch (_error) {}
      setTimeout((function(_this) {
        return function() {
          if (_this.status !== 'dead') {
            return exec("kill -s kill " + _this.pid, function() {});
          }
        };
      })(this), timeout);
      return this;
    }
  });

  __define('kill', {
    enumerable: true,
    value: function(signal) {
      if (signal == null) {
        signal = 'SIGTERM';
      }
      this.emit.call(this, 'kill', signal);
      process.nextTick((function(_this) {
        return function() {
          try {
            return _this.instance.kill(signal);
          } catch (_error) {}
        };
      })(this));
      return this;
    }
  });

  __define('publish', {
    enumerable: true,
    value: function() {
      var event, parameters;
      event = arguments[0], parameters = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
      if (parameters.length === 1) {
        parameters = parameters[0];
      }
      this.emit.call(this, 'publish', event, parameters);
      try {
        this.instance.send({
          event: event,
          parameters: parameters
        });
      } catch (_error) {}
      return this;
    }
  });

  return Worker;

})(EventEmitter);