connect

#!/usr/bin/env node

/*!
 * Ext JS Connect
 * Copyright(c) 2010 Ext JS, Inc.
 * MIT Licensed
 */

/**
 * Module dependencies.
 */

var child_process = require('child_process'),
    netBinding = process.binding('net'),
    dirname = require('path').dirname,
    http = require('http'),
    sys = require('sys'),
    fs = require('fs'),
    cwd = process.cwd(),
    net = require('net');

/**
 * Framework version.
 */

var version = '0.2.1';

/**
 * Use child process workers to utilize all cores
 */

var workers;

/**
 * Verbose output.
 */

var verbose;

/**
 * Colored terminal output.
 */

var useColors = true;

/**
 * Environment defaults.
 */

var env = process.connectEnv = {
    name: process.env.CONNECT_ENV || 'development',
    logfile: 'logs/connect.log',
    pidfile: 'pids/connect.pid',
    port: 3000,
    host: null
};

/**
 * Usage documentation.
 */

var usage = ''
    + '[bold]{Usage}: connect [options] start|stop|restart|status\n'
    + '\n'
    + '[bold]{Options}:\n'
    + '  -H, --host ADDR      Host address, defaults to INADDR_ANY\n'
    + '  -p, --port NUM       Port number, defaults to 3000\n'
    + '  -n, --workers NUM    Number of worker processes to spawn\n'
    + '  -I, --include PATH   Unshift the given path to require.paths\n'
    + '  -E, --env NAME       Set environment, defaults to "development"\n'
    + '  -e, --eval CODE      Evaluate the given string\n'
    + '  -C, --chdir PATH     Change to the given path\n'
    + '  -c, --config PATH    Load configuration module\n'
    + '  -P, --pidfile PATH   PID file, defaults to pids/connect.pid\n'
    + '  -l, --logfile PATH   Log file, defaults to logs/connect.log\n'
    + '  -u, --user ID|NAME   Change user with setuid()\n'
    + '  -g, --group ID|NAME  Change group with setgid()\n'
    + '  -v, --verbose        Enable verbose output\n'
    + '  -V, --version        Output connect version\n'
    + '  -K, --no-color       Suppress colored terminal output\n'
    + '  -h, --help           Outputy help information\n'
    + '  --ENV VAL            Sets the given connect environment variable\n'
    + '\n'
    + '[bold]{Documentation}:\n'
    + '\n'
    + '  man connect\n'
    + '  man connect-MIDDLEWARE\n';

/**
 * Log the given msg to stderr.
 *
 * @param  {String} msg
 */

function log(msg) {
    if (verbose) sys.error('... ' + colorize(msg));
}

/**
 * Colorize the given string when color is enabled,
 * otherwise strip placeholders.
 *
 * @param  {String} str
 * @return {String}
 */

function colorize(str) {
    var colors = useColors
        ? { bold: 1 }
        : {};
    return str.replace(/\[(\w+)\]\{([^}]+)\}/g, function(_, color, str){
        return '\x1B[' + colors[color] + 'm' + str +'\x1B[0m';
    });
}

/**
 * Ad-hoc sync mkdir -p implementation.
 *
 * @param {String} path
 * @param {Number} mode
 */

function mkdirs(path, mode) {
    var segs = path.split('/'),
        mode = mode || 0755;
    if (segs[0]) {
        segs.unshift(process.cwd());
    } else {
        segs[0] = '/';
    }
    for (var i = 0, len = segs.length; i < len; ++i) {
        var dir = segs.slice(0, i + 1).join('/'),
            dir = dir[1] === '/' ? dir.slice(1) : dir;
        try {
            var stat = fs.statSync(dir);
            if (!stat.isDirectory()) {
                throw new Error('Failed to mkdir "' + dir + '"');
            }
        } catch (err) {
            if (err.errno === process.ENOENT) {
                fs.mkdirSync(dir, mode);
            } else {
                throw err;
            }
        }
    }
}

/**
 * Strip ".js" extension from the given path.
 *
 * @param {String} path
 * @return {String}
 */

function modulePath(path){
    return path.replace(/\.js$/, '');
}

/**
 * Exit with the given message.
 *
 * @param  {String} msg
 * @param  {Number} code
 */

function abort(msg, code) {
    sys.error(colorize(msg));
    process.exit(code || 1);
}

/**
 * Load the given configuration file.
 *
 * @param  {String} file
 */

function loadConfig(file) {
    file = process.cwd() + '/' + file;
    log('loading config [bold]{`' + file + "'}");
    var args = [],
        config = require(file);
    for (var key in config) {
        var val = config[key] instanceof Array
                ? config[key]
                : [config[key]];

        // Prefix flag
        var key = '--' + key;
        
        // Apply flags
        val.forEach(function(val){
            log('  ' + key + ' ' + (val === true ? '' : sys.inspect(val)));
            args.push(key);
            if (typeof val !== 'boolean') {
                args.push(val);
            }
        });
    }
    parseArguments(args);
}

/**
 * Return pid from the given path.
 *
 * @param {String} path
 * @return {Number}
 */

function getpid(path) {
    try {
        return parseInt(fs.readFileSync(path), 10);
    } catch (err) {
        if (err.errno === process.ENOENT) {
            log('[bold]{' + err.path + '} does not exist');
        } else {
            throw err;
        }
    }
}

/**
 * Check status of the given pid.
 *
 * @param {Number} pid
 */

function checkStatus(pid){
    if (pid) {
        try {
            verbose = true;
            process.kill(pid, 0);
            log('[bold]{' + pid + '} is running');
        } catch (err) {
            if (err.message === 'No such process') {
                log('[bold]{' + pid + '} is not running');
            } else {
                throw err;
            }
        }
    }
}

/**
 * Check status of process(es).
 */

function status() {
    checkStatus(getpid(env.pidfile));
    for (var i = 0; i < workers; ++i) {
        checkStatus(getpid(workerPidfile(i)));
    }
}

/**
 * Attempt to stop the given pid.
 *
 * @param {Number} pid
 */

function stopProcess(pid){
    if (pid) {
        try {
            process.kill(pid, 'SIGTERM');
            log('killed [bold]{' + pid + '}');
        } catch (err) {
            if (err.message === 'No such process') {
                log('process [bold]{' + pid + '} is not running')
            } else {
                throw err;
            }
        }
    }
}

/**
 * Stop process(es).
 */

function stop(pid){
    stopProcess(getpid(env.pidfile));
    for (var i = 0; i < workers; ++i) {
        stopProcess(getpid(workerPidfile(i)));
    }
}

/**
 * Check if the given path exists (sync).
 *
 * @param  {String} path
 * @return {Boolean}
 */

function exists(path) {
    try {
        return fs.statSync(path);
    } catch (err) {
        return false;
    }
}

/**
 * Return worker pidfile for the given index.
 *
 * @param {Number} i
 * @return {String}
 */

function workerPidfile(i){
    return env.pidfile.replace('.pid', '.' + i + '.pid');    
}

/**
 * Require application module at the given path,
 * which must be an instanceof net.Server, otherwise
 * abort.
 *
 * @param  {String} path
 * @return {Server}
 */

function requireApp(path) {
    var app = require(path);
    try {
        if (app instanceof net.Server) {
            return app;
        } else {
            throw new Error('invalid server');
        }
    } catch (err) {
        abort("invalid application.\n"
            + "at: `" + path + "'\n"
            + "must export a , ex: `module.exports = http.createServer(...);'\n");
    }
}

/**
 * Get path to application.
 *
 *  - supports env.appPath
 *  - auto-detects {app,server}.js
 *
 * @return {String}
 */

function getAppPath() {
    var path = process.cwd() + '/' + (env.appPath || '');

    // App path not given, try app.js and server.js
    if (!env.appPath) {
        if (exists(path + 'app.js')) {
            log('detected app.js');
            path += 'app';
        } else if (exists(path + 'server.js')) {
            log('detected server.js');
            path += 'server';
        } else {
            abort('app not found, pass a module path, or create {app,server}.js');
        }
    }
    
    return path;
}

/**
 * Start child worker process.
 */

function startWorker() {
    var stdin = new net.Stream(0, 'unix');
    stdin.addListener('data', function(json){
        env = JSON.parse(json.toString());
    });
    stdin.addListener('fd', function(fd){
        var app = requireApp(getAppPath());
        app.env = env;
        sys.error('Connect server(' + process.pid + ') listening on http://'
            + (env.host || '*') + ':' + env.port
            + ' in ' + env.name + ' mode');
        app.listenFD(fd, 'tcp4');
    });
    stdin.resume();
}

/**
 * Start the process.
 */

function start() {
    log('starting');
    
    // Detect config.js
    if (exists('./config.js')) {
        log('detected config.js');
        loadConfig('./config');
    }
    
    // Application path
    var path = getAppPath();

    // Spawn worker processes
    if (workers) {
        if (process.version < '0.1.98' && process.version > "0.1.100") {
            abort('Cannot use workers with a version older than v0.1.98');
        }

        // Ensure logfile and pidfile directories are available
        mkdirs(dirname(env.logfile));
        mkdirs(dirname(env.pidfile));

        var errlogfile = env.logfile.replace('.log', '.error.log'),
            logStream = fs.createWriteStream(env.logfile, { flags: 'a' }),
            errlogStream = fs.createWriteStream(errlogfile, { flags: 'a' });

        var fd = netBinding.socket('tcp4');
        netBinding.bind(fd, env.port);
        netBinding.listen(fd, 128);

        for (var i = 0; i < workers; i++) {
            // Create an unnamed unix socket to pass the fd to the child.
            var fds = netBinding.socketpair();

            // Spawn the child process
            var child = child_process.spawn(
                process.argv[0],
                [__filename, '--child'],
                undefined,
                [fds[1], -1, -1]
            );
            log('child spawned [bold]{' + child.pid + '}');

            // For some reason stdin isn't getting set, patch it externally
            if (!child.stdin) {
                child.stdin = new net.Stream(fds[0], 'unix');
            }
            
            // Write out worker pids
            fs.writeFileSync(workerPidfile(i), child.pid.toString(), 'ascii');
            
            child.stdin.write(JSON.stringify(env), 'ascii', fd);
            
            // Log stdout / stderr
            child.stdout.addListener('data', function(data){
                logStream.write(data);
            });
            child.stderr.addListener('data', function(data){
                errlogStream.write(data);
            });
        }
        return;
    }

    // Load the app module
    var app = requireApp(path);
    app.env = env;
    sys.error('Connect server(' + process.pid + ') listening on http://'
        + (env.host || '*') + ':' + env.port
        + ' in ' + env.name + ' mode');
    app.listen(env.port, env.host);
}

/**
 * Parse the arguments.
 */

function parseArguments(args, cmd) {
    var arg;
    
    /**
     * Return shifted argument, or
     * abort with the given prefix.
     *
     * @param  {String} prefix
     * @return {String}
     */

    function requireArg(prefix) {
        if (args.length) {
            return args.shift();
        } else {
            abort(prefix + ' requires an argument.');
        }
    }
    
    // Iterate
    while (args.length) {
        switch (arg = args.shift()) {
            case '--child':
              cmd = "worker";
              break;
            case '-h':
            case '--help':
                abort(usage);
                break;
            case '-I':
            case '--include':
                require.paths.unshift(requireArg('--include'));
                break;
            case '-e':
            case '--eval':
                eval(requireArg('--eval'));
                break;
            case '-p':
            case '--port':
                env.port = parseInt(requireArg('--port'), 10);
                break;
            case '-H':
            case '--host':
                env.host = requireArg('--host');
                break;
            case '-u':
            case '--user':
                env.uid = requireArg('--user');
                break;
            case '-g':
            case '--group':
                env.gid = requireArg('--group');
                break;
            case '-C':
            case '--chdir':
                process.chdir(requireArg('--chdir'));
                break;
            case '-l':
            case '--logfile':
                env.logfile = requireArg('--logfile');
                break;
            case '-E':
            case '--env':
                env.name = requireArg('--env');
                break;
            case '-P':
            case '--pidfile':
                env.pidfile = requireArg('--pidfile');
                break;
            case '-c':
            case '--config':
                loadConfig(modulePath(requireArg('--config')));
                break;
            case '-v':
            case '--verbose':
                verbose = true;
                break;
            case '-V':
            case '--version':
                abort(version);
                break;
            case '-K':
            case '--no-color':
                useColors = false;
                break;
            case '-n':
            case '--workers':
                workers = parseInt(requireArg('--workers'), 10);
                break;
            case 'stop':
            case 'start':
            case 'restart':
            case 'status':
                cmd = arg;
                break;
            default:
                if (arg[0] === '-') {
                    arg = arg.substr(2);
                    env[arg] = requireArg('--' + arg);
                } else {
                    env.appPath = modulePath(arg);
                }
        }
    }

    // Run the command

    switch (cmd) {
        case 'stop':
            stop();
            break;
        case 'start':
            start();
            break;
        case 'restart':
            stop();
            start();
            break;
        case 'status':
            status();
            break;
        case 'worker':
            startWorker();
            break;
    }
}

// Parse cli arguments
parseArguments(process.argv.slice(2), 'start');