lirc/lib/lirc.js

An old IRC client for node

// Generated by CoffeeScript 1.12.7
(function() {
  var clone, cluster, crypto, empty, fs, lance, lirc, merge, net, path, ref, tls, typeOf;

  net = require('net');

  tls = require('tls');

  crypto = require('crypto');

  path = require('path');

  lance = require('lance');

  cluster = require('cluster');

  fs = require('fs');

  module.exports = lirc = function(newCfg) {
    var cfg;
    if (newCfg == null) {
      newCfg = {};
    }
    lirc.cfg = cfg = merge(lirc.cfg, newCfg);
    lirc.session.build(cfg);
    lirc.rootDir = path.dirname(__dirname);
    if (cluster.isWorker) {
      lirc.botnet.emit.master({
        cmd: 'botnet.info',
        args: {
          name: lirc.session.me,
          cfg: cfg,
          id: cluster.worker.id
        }
      });
    }
    if (cfg.ascii && cluster.isMaster) {
      console.log("\       __          \n\      / /__________\n\     / / / ___/___/\n\    / / / / / /__  \n\   /_/_/_/  \\___/  ");
    }
    if (cfg.catchUncaught) {
      process.on('uncaughtException', lirc.error);
    }
    return lirc;
  };

  lirc.cfg = require('../cfg/lirc');

  lirc.utils = lance.utils;

  ref = lirc.utils, merge = ref.merge, clone = ref.clone, typeOf = ref.typeOf, empty = ref.empty;

  lirc.error = function() {
    var error;
    error = lance.error.parse(arguments);
    console.error(error.text);
    lance.error.write(error.text, lirc.rootDir);
    if (error.severity === 'fatal') {
      if (cluster.isMaster) {
        lirc.web.emit('lirc', {
          text: error.text.replace(/\n/g, '<br/>'),
          time: new Date().getTime()
        });
        lirc.web.emit('lirc', {
          text: 'Master error, killing Lirc...',
          time: new Date().getTime()
        });
        return setTimeout(process.kill, 5000);
      } else {
        lirc.botnet.emit.master({
          cmd: 'emit.web',
          args: [
            'lirc', [
              {
                text: error.text.replace(/\n/g, '<br/>'),
                time: new Date().getTime()
              }
            ]
          ]
        });
        setTimeout((function() {
          return lirc.botnet.emit.master({
            cmd: 'restart',
            args: [lirc.session.me]
          });
        }), 5000);
        return setTimeout((function() {
          return cluster.worker.process.kill();
        }), 10000);
      }
    }
  };

  lirc.connect = function(newCfg, done) {
    var cfg, conn, keygen, session;
    if (done == null) {
      done = function() {};
    }
    if (!lirc.cfg) {
      if (typeOf(newCfg) === 'object') {
        lirc(newCfg);
      } else {
        return done('Lirc not initialized', null);
      }
    }
    cfg = lirc.cfg, session = lirc.session;
    if (!cfg.server.secure) {
      lirc.session.conn = conn = net.createConnection(cfg.server);
      conn.on('connect', function() {
        conn.connected = true;
        return lirc.auth();
      });
      lirc.connect.configure(conn);
      lirc.bind(lirc.listeners.irc, conn);
      return done(null, conn);
    } else {
      keygen = require('ssl-keygen').createKeyGen();
      return keygen.createKey('ssl_key', (function(_this) {
        return function(err, key) {
          return keygen.createCert('ssl_key', function(err, cert) {
            var creds;
            key = fs.readFileSync('/home/node/lirc/certs/ssl_key.key', 'utf8');
            cert = fs.readFileSync('/home/node/lirc/certs/ssl_key.crt', 'utf8');
            creds = crypto.createCredentials({
              key: key,
              cert: cert
            });
            lirc.session.conn = conn = tls.connect({
              port: cfg.server.port,
              host: cfg.server.host,
              key: creds.key,
              passphrase: creds.passphrase || null,
              pfx: creds.pfx,
              ca: creds.ca,
              cert: creds.cert,
              localAddress: cfg.server.localAddress,
              rejectUnauthorized: false
            }, function() {
              if (!conn.authorized && !(conn.authorizationError === 'DEPTH_ZERO_SELF_SIGNED_CERT' || conn.authorizationError === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE')) {
                return done('Connection failed, unauthorized', null);
              }
              lirc.auth();
              conn.connected = true;
              return done(null, conn);
            });
            lirc.connect.configure(conn);
            return lirc.bind(lirc.listeners.irc, conn);
          });
        };
      })(this));
    }
  };

  lirc.connect.configure = function(conn) {
    conn.setTimeout(lirc.cfg.timeout);
    conn.setEncoding(lirc.cfg.encoding);
    return conn.setKeepAlive(true, lirc.cfg.keepAlive);
  };

  lirc.codes = require('./format_codes');

  lirc.listeners = {
    irc: require('./listeners/irc')
  };

  lirc.mappings = {
    parsing: require('./mappings/parsing'),
    actions: require('./mappings/actions')
  };

  require('./build');

  require('./emitter');

  require('./commands');

  require('./botnet/botnet');

  require('./session');

  if (cluster.isMaster) {
    require('../web');
    cluster.on('disconnect', function(worker) {
      return console.log("Worker [ " + worker.id + " ] died");
    });
  } else {
    lirc.on('msg', function(msg) {
      return lirc.botnet.emit.master({
        cmd: 'emit.web',
        args: ['msg', [msg]]
      });
    });
    lirc.botnet.on('*', function(args) {
      var message;
      if (args == null) {
        args = [];
      }
      message = args[1];
      return lirc.botnet.emit.master({
        cmd: 'emit.web',
        args: [
          'botnet', {
            cmd: message.args[0],
            args: message.args[1] ? message.args.slice(1) : [],
            time: new Date().getTime()
          }
        ],
        fromWorkerId: message.workerId
      });
    });
  }

  module.exports = lirc;

}).call(this);