refactor server

* shows some basic statistics on main page
* move tcp proxy setup into separate file
* migrate github page theme to be hosted locally

proxy.js

@@ -0,0 +1,235 @@
+var http = require('http');
+var net = require('net');
+var EventEmitter = require('events').EventEmitter;
+
+var log = require('bookrc');
+var debug = require('debug')('localtunnel-server');
+
+// here be dragons, understanding of node http internals will be required
+var HTTPParser = process.binding('http_parser').HTTPParser;
+
+// available parsers for requests
+// this is borrowed from how node does things by preallocating parsers
+var parsers = http.parsers;
+
+var Proxy = function(opt, cb) {
+    if (!(this instanceof Proxy)) {
+        return new Proxy(opt, cb);
+    }
+
+    var self = this;
+
+    self.sockets = [];
+    self.waiting = [];
+
+    var id = opt.id;
+
+    // default max is 5
+    var max_tcp_sockets = opt.max_tcp_sockets || 5;
+
+    // new tcp server to service requests for this client
+    var client_server = net.createServer();
+    client_server.listen(function() {
+        var port = client_server.address().port;
+        debug('tcp server listening on port: %d', port);
+
+        cb(null, {
+            // port for lt client tcp connections
+            port: port,
+            // maximum number of tcp connections allowed by lt client
+            max_conn_count: max_tcp_sockets
+        });
+    });
+
+    // track initial user connection setup
+    var conn_timeout;
+
+    // user has 5 seconds to connect before their slot is given up
+    function maybe_tcp_close() {
+        clearTimeout(conn_timeout);
+        conn_timeout = setTimeout(client_server.close.bind(client_server), 5000);
+    }
+
+    maybe_tcp_close();
+
+    // no longer accepting connections for this id
+    client_server.on('close', function() {
+        debug('closed tcp socket for client(%s)', id);
+
+        clearTimeout(conn_timeout);
+
+        // clear waiting by ending responses, (requests?)
+        self.waiting.forEach(function(waiting) {
+            waiting[1].end();
+            waiting[3].end(); // write stream
+        });
+
+        self.emit('end');
+    });
+
+    // new tcp connection from lt client
+    client_server.on('connection', function(socket) {
+
+        // no more socket connections allowed
+        if (self.sockets.length >= max_tcp_sockets) {
+            return socket.end();
+        }
+
+        debug('new connection on port: %s', id);
+
+        // a single connection is enough to keep client id slot open
+        clearTimeout(conn_timeout);
+
+        // allocate a response parser for the socket
+        // it only needs one since it will reuse it
+        socket.parser = parsers.alloc();
+
+        socket._orig_ondata = socket.ondata;
+        socket.ondata = upstream_response;
+
+        socket.once('close', function(had_error) {
+            debug('client %s closed socket (error: %s)', id, had_error);
+
+            // what if socket was servicing a request at this time?
+            // then it will be put back in available after right?
+
+            // remove this socket
+            var idx = self.sockets.indexOf(socket);
+            if (idx >= 0) {
+                self.sockets.splice(idx, 1);
+            }
+
+            // need to track total sockets, not just active available
+
+            debug('remaining client sockets: %s', self.sockets.length);
+
+            // no more sockets for this ident
+            if (self.sockets.length === 0) {
+                debug('all client(%s) sockets disconnected', id);
+                maybe_tcp_close();
+            }
+        });
+
+        // close will be emitted after this
+        socket.on('error', function(err) {
+            log.error(err);
+            socket.end();
+        });
+
+        self.sockets.push(socket);
+
+        var next = self.waiting.shift();
+        if (next) {
+            debug('handling queued request');
+            self.proxy_request(next[0], next[1], next[2], next[3]);
+        }
+    });
+
+    client_server.on('error', function(err) {
+        log.error(err);
+    });
+};
+
+Proxy.prototype.__proto__ = EventEmitter.prototype;
+
+Proxy.prototype.proxy_request = function(req, res, rs, ws) {
+    var self = this;
+
+    // socket is a tcp connection back to the user hosting the site
+    var sock = self.sockets.shift();
+
+    // queue request
+    if (!sock) {
+        debug('no more clients, queued: %s', req.url);
+        rs.pause();
+        self.waiting.push([req, res, rs, ws]);
+        return;
+    }
+
+    debug('handle req: %s', req.url);
+
+    // pipe incoming request into tcp socket
+    // incoming request will close the socket when done
+    // lt client should establish a new socket once request is finished
+    // we do this instead of keeping socket open to make things easier
+    rs.pipe(sock);
+
+    sock.ws = ws;
+    sock.req = req;
+
+    // since tcp connection to upstream are kept open
+    // invoke parsing so we know when the response is complete
+    var parser = sock.parser;
+    parser.reinitialize(HTTPParser.RESPONSE);
+    parser.socket = sock;
+
+    // we have completed a response
+    // the tcp socket is free again
+    parser.onIncoming = function (res) {
+        parser.onMessageComplete = function() {
+            debug('ended response: %s', req.url);
+
+            // any request we had going on is now done
+            ws.end();
+            sock.end();
+
+            // no more forwarding
+            delete sock.ws;
+            delete sock.req;
+            delete parser.onIncoming;
+        };
+    };
+
+    rs.resume();
+};
+
+Proxy.prototype.proxy_upgrade = function(req, socket, head) {
+
+    var sock = self.sockets.shift();
+    if (!sock) {
+        // no available sockets to upgrade to
+        // TODO queue?
+        return socket.end();
+    }
+
+    var stream = req.createRawStream();
+
+    sock.ws = ws;
+    sock.upgraded = true;
+
+    stream.once('end', function() {
+        delete sock.ws;
+
+        // when this ends, we just reset the socket to the lt client
+        // this is easier than trying to figure anything else out
+        sock.end();
+    });
+
+    stream.pipe(sock);
+    sock.once('end', socket.end.bind(ws));
+};
+
+function upstream_response(d, start, end) {
+    var socket = this;
+
+    var ws = socket.ws;
+    if (!ws) {
+        return log.warn('no stream set for req:', socket.req.url);
+    }
+
+    ws.write(d.slice(start, end));
+
+    if (socket.upgraded) {
+        return;
+    }
+
+    var ret = socket.parser.execute(d, start, end - start);
+    if (ret instanceof Error) {
+        log.error(ret);
+        parsers.free(parser);
+        socket.destroy(ret);
+    }
+}
+
+module.exports = Proxy;
+