1.2.0

return client from 'localtunnel' api call

.travis.yml

@@ -1,4 +1,3 @@
 language: node_js
 node_js:
-    - 0.8
-    - 0.9
+    - "0.10"

History.md

@@ -0,0 +1,7 @@
+# 1.0.0 / 2014-02-14
+
+* default to localltunnel.me for host
+* remove exported `connect` method (just export one function that does the same thing)
+* change localtunnel signature to (port, opt, fn)
+
+# 0.2.2 / 2014-01-09

README.md

@@ -1,4 +1,4 @@
-# localtunnel #
+# localtunnel [![Build Status](https://travis-ci.org/defunctzombie/localtunnel.png?branch=master)](https://travis-ci.org/defunctzombie/localtunnel) #
 
 localtunnel exposes your localhost to the world for easy testing and sharing! No need to mess with DNS or deploy just to have others test out your changes.
 
@@ -14,7 +14,7 @@ This will install the localtunnel module globally and add the 'lt' client cli to
 
 ## use ##
 
-Super Easy! Assuming your local server is running on port 8000, just use the ```lt``` command to start the tunnel.
+Assuming your local server is running on port 8000, just use the ```lt``` command to start the tunnel.
 
 ```
 lt --port 8000
@@ -24,34 +24,62 @@ Thats it! It will connect to the tunnel server, setup the tunnel, and tell you w
 
 You can restart your local server all you want, ```lt``` is smart enough to detect this and reconnect once it is back.
 
+### arguments
+
+Below are some common arguments. See `lt --help` for additional arguments
+
+* `--subdomain` request a named subdomain on the localtunnel server (default is random characters)
+* `--local-host` proxy to a hostname other than localhost
+
 ## API ##
 
 The localtunnel client is also usable through an API (for test integration, automation, etc)
 
+### localtunnel(port [,opts], fn)
+
+Creates a new localtunnel to the specified local `port`. `fn` will be called once you have been assigned a public localtunnel url. `opts` can be used to request a specific `subdomain`.
+
 ```javascript
 var localtunnel = require('localtunnel');
 
-var client = localtunnel.connect({
-    // the localtunnel server
-    host: 'http://localtunnel.me',
-    // your local application port
-    port: 12345
-});
+localtunnel(port, function(err, tunnel) {
+    if (err) ...
 
-// when your are assigned a url
-client.on('url', function(url) {
-    // you can now make http requests to the url
-    // they will be proxied to your local server on port [12345]
-});
-
-client.on('error', function(err) {
-    // uh oh!
+    // the assigned public url for your tunnel
+    // i.e. https://abcdefgjhij.localtunnel.me
+    tunnel.url;
 });
 ```
 
+### opts
+
+* `subdomain` A *string* value requesting a specific subdomain on the proxy server. **Note** You may not actually receive this name depending on availablily.
+* `local_host` Proxy to this hostname instead of `localhost`. This will also cause the `Host` header to be re-written to this value in proxied requests.
+
+### Tunnel
+
+The `tunnel` instance returned to your callback emits the following events
+
+|event|args|description|
+|----|----|----|
+|error|err|fires when an error happens on the tunnel|
+|close||fires when the tunnel has closed|
+
+The `tunnel instance has the following methods
+
+|method|args|description|
+|----|----|----|
+|close||close the tunnel|
+
+## other clients ##
+
+Clients in other languages
+
+*go* [gotunnelme](https://github.com/NoahShen/gotunnelme)
+
 ## server ##
 
-See shtylman/localtunnel-server for details on the server that powers localtunnel.
+See defunctzombie/localtunnel-server for details on the server that powers localtunnel.
 
 ## License ##
 MIT

bin/client

@@ -3,7 +3,6 @@ var lt_client = require('../client');
 
 var argv = require('optimist')
     .usage('Usage: $0 --port [num]')
-    .demand(['port'])
     .options('host', {
         default: 'http://localtunnel.me',
         describe: 'upstream server providing forwarding'
@@ -11,24 +10,44 @@ var argv = require('optimist')
     .options('subdomain', {
         describe: 'request this subdomain'
     })
+    .options('local-host', {
+        describe: 'tunnel traffic to this host instead of localhost'
+    })
+    .options('version', {
+        describe: 'print version and exit'
+    })
+    .default('local-host', 'localhost')
     .describe('port', 'internal http server port')
     .argv;
 
+if (argv.version) {
+    console.log(require('../package.json').version);
+    process.exit(0);
+}
+
+if (argv.port == null) {
+    require('optimist').showHelp();
+    console.error('Missing required arguments: port');
+    process.exit(1);
+}
+
 var opt = {
     host: argv.host,
     port: argv.port,
+    local_host: argv['local-host'],
     subdomain: argv.subdomain,
-}
+};
 
-var client = lt_client.connect(opt);
+lt_client(opt.port, opt, function(err, tunnel) {
+    if (err) {
+        throw err;
+    }
 
-// only emitted when the url changes
-client.on('url', function(url) {
-    console.log('your url is: %s', url);
-});
+    console.log('your url is: %s', tunnel.url);
 
-client.on('error', function(err) {
-    console.error(err);
+    tunnel.on('error', function(err) {
+        throw err;
+    });
 });
 
 // vim: ft=javascript

client.js

@@ -3,23 +3,182 @@ var url = require('url');
 var EventEmitter = require('events').EventEmitter;
 
 var request = require('request');
+var debug = require('debug')('localtunnel:client');
 
-// request upstream url and connection info
-var request_url = function(params, cb) {
-    request(params, function(err, res, body) {
-        if (err) {
-            return cb(err);
+var stream = require('stream');
+var util = require('util');
+
+var Transform = stream.Transform;
+
+var HeaderHostTransformer = function(opts) {
+    if (!(this instanceof HeaderHostTransformer)) {
+        return new HeaderHostTransformer(opts);
+    }
+
+    opts = opts || {}
+    Transform.call(this, opts);
+
+    var self = this;
+    self.host = opts.host || 'localhost';
+    self.replaced = false;
+}
+util.inherits(HeaderHostTransformer, Transform);
+
+HeaderHostTransformer.prototype._transform = function (chunk, enc, cb) {
+    var self = this;
+    chunk = chunk.toString();
+
+    // after replacing the first instance of the Host header
+    // we just become a regular passthrough
+    self.push(chunk.replace(/(\r\nHost: )\S+/, function(match, $1) {
+        self._transform = undefined;
+        return $1 + self.host;
+    }));
+    cb();
+};
+
+// manages groups of tunnels
+var TunnelCluster = function(opt) {
+    if (!(this instanceof TunnelCluster)) {
+        return new TunnelCluster(opt);
+    }
+
+    var self = this;
+    self._opt = opt;
+
+    EventEmitter.call(self);
+};
+
+TunnelCluster.prototype.__proto__ = EventEmitter.prototype;
+
+// establish a new tunnel
+TunnelCluster.prototype.open = function() {
+    var self = this;
+
+    var opt = self._opt || {};
+
+    var remote_host = opt.remote_host;
+    var remote_port = opt.remote_port;
+
+    var local_host = opt.local_host;
+    var local_port = opt.local_port;
+
+    debug('establishing tunnel %s:%s <> %s:%s', local_host, local_port, remote_host, remote_port);
+
+    // connection to localtunnel server
+    var remote = net.connect({
+        host: remote_host,
+        port: remote_port
+    });
+
+    remote.once('error', function(err) {
+        // emit connection refused errors immediately, because they
+        // indicate that the tunnel can't be established.
+        if (err.code === 'ECONNREFUSED') {
+            self.emit('error', new Error('connection refused: ' + remote_host + ':' + remote_port + ' (check your firewall settings)'));
+        }
+        else {
+            self.emit('error', err);
         }
 
-        cb(null, body);
+        setTimeout(function() {
+            self.emit('dead');
+        }, 1000);
+    });
+
+    function conn_local() {
+        if (remote.destroyed) {
+            debug('remote destroyed');
+            self.emit('dead');
+            return;
+        }
+
+        debug('connecting locally to %s:%d', local_host, local_port);
+        remote.pause();
+
+        // connection to local http server
+        var local = net.connect({
+            host: local_host,
+            port: local_port
+        });
+
+        function remote_close() {
+            debug('remote close');
+            self.emit('dead');
+            local.end();
+        };
+
+        remote.once('close', remote_close);
+
+        // TODO some languages have single threaded servers which makes opening up
+        // multiple local connections impossible. We need a smarter way to scale
+        // and adjust for such instances to avoid beating on the door of the server
+        local.once('error', function(err) {
+            debug('local error %s', err.message);
+            local.end();
+
+            remote.removeListener('close', remote_close);
+
+            if (err.code !== 'ECONNREFUSED') {
+                return remote.end();
+            }
+
+            // retrying connection to local server
+            setTimeout(conn_local, 1000);
+        });
+
+        local.once('connect', function() {
+            debug('connected locally');
+            remote.resume();
+
+            var stream = remote;
+
+            // if user requested something other than localhost
+            // then we use host header transform to replace the host header
+            if (local_host !== 'localhost') {
+                stream = remote.pipe(HeaderHostTransformer({ host: local_host }));
+            }
+
+            stream.pipe(local).pipe(remote);
+
+            // when local closes, also get a new remote
+            local.once('close', function(had_error) {
+                debug('local connection closed [%s]', had_error);
+            });
+        });
+    }
+
+    // tunnel is considered open when remote connects
+    remote.once('connect', function() {
+        self.emit('open', remote);
+        conn_local();
     });
 };
 
-var connect = function(opt) {
-    var ev = new EventEmitter();
+var Tunnel = function(opt) {
+    if (!(this instanceof Tunnel)) {
+        return new Tunnel(opt);
+    }
 
-    // local port
-    var local_port = opt.port;
+    var self = this;
+    self._closed = false;
+    self._opt = opt || {};
+
+    self._opt.host = self._opt.host || 'https://localtunnel.me';
+};
+
+Tunnel.prototype.__proto__ = EventEmitter.prototype;
+
+// initialize connection
+// callback with connection info
+Tunnel.prototype._init = function(cb) {
+    var self = this;
+    var opt = self._opt;
+
+    var params = {
+        path: '/',
+        json: true
+    };
 
     var base_uri = opt.host + '/';
 
@@ -29,118 +188,129 @@ var connect = function(opt) {
     // no subdomain at first, maybe use requested domain
     var assigned_domain = opt.subdomain;
 
-    // connect to upstream given connection parameters
-    var tunnel = function (remote_host, remote_port) {
-
-        var remote_opt = {
-            host: remote_host,
-            port: remote_port
-        };
-
-        var local_opt = {
-            host: 'localhost',
-            port: local_port
-        };
-
-        var remote_attempts = 0;
-
-        (function conn(conn_had_error) {
-            if (conn_had_error) {
-                return;
-            }
-
-            if (++remote_attempts >= 3) {
-                console.error('localtunnel server offline - try again');
-                process.exit(-1);
-            }
-
-            // connection to localtunnel server
-            var remote = net.connect(remote_opt);
-
-            remote.once('error', function(err) {
-                if (err.code !== 'ECONNREFUSED') {
-                    remote.emit('error', err);
-                }
-
-                // retrying connection to local server
-                setTimeout(conn, 1000);
-            });
-
-            function recon_local() {
-                remote.pause();
-                remote_attempts = 0;
-
-                // connection to local http server
-                var local = net.connect(local_opt);
-
-                local.once('error', function(err) {
-                    if (err.code !== 'ECONNREFUSED') {
-                        local.emit('error', err);
-                    }
-
-                    // retrying connection to local server
-                    setTimeout(recon_local, 1000);
-                });
-
-                local.once('connect', function() {
-                    remote.resume();
-                    remote.pipe(local).pipe(remote, {end: false});
-                });
-
-                local.once('close', function(had_error) {
-                    if (had_error) {
-                        return;
-                    }
-                    recon_local();
-                });
-            }
-
-            remote.once('close', conn);
-            remote.once('connect', recon_local);
-        })();
-    };
-
-    var params = {
-        path: '/',
-        json: true
-    };
-
     // where to quest
     params.uri = base_uri + ((assigned_domain) ? assigned_domain : '?new');
 
-    // get an id from lt server and setup forwarding tcp connections
-    request_url(params, function(err, body) {
+    (function get_url() {
+        request(params, function(err, res, body) {
+            if (err) {
+                // TODO (shtylman) don't print to stdout?
+                console.log('tunnel server offline: ' + err.message + ', retry 1s');
+                return setTimeout(get_url, 1000);
+            }
 
-        if (err) {
-            ev.emit('error', new Error('tunnel server not available: %s, retry 1s', err.message));
+            if (res.statusCode !== 200) {
+                var err = new Error((body && body.message) || 'localtunnel server returned an error, please try again');
+                return cb(err);
+            }
 
-            // retry interval for id request
-            return setTimeout(function() {
-                connect_proxy(opt);
-            }, 1000);
-        }
+            var port = body.port;
+            var host = upstream.hostname;
 
-        // our assigned hostname and tcp port
-        var port = body.port;
-        var host = upstream.hostname;
+            var max_conn = body.max_conn_count || 1;
 
-        // store the id so we can try to get the same one
-        assigned_domain = body.id;
-
-        var max_conn = body.max_conn_count || 1;
-        for (var count = 0 ; count < max_conn ; ++count) {
-            tunnel(host, port);
-        }
-
-        ev.emit('url', body.url);
-    });
-
-    return ev;
+            cb(null, {
+                remote_host: upstream.hostname,
+                remote_port: body.port,
+                name: body.id,
+                url: body.url,
+                max_conn: max_conn
+            });
+        });
+    })();
 };
 
-module.exports.connect = connect;
+Tunnel.prototype._establish = function(info) {
+    var self = this;
+    var opt = self._opt;
 
-// for backwards compatibility
-// old localtunnel modules had server and client code in same module
-// so to keep .client working we expose it here
-module.exports.client = module.exports;
+    info.local_host = opt.local_host || 'localhost';
+    info.local_port = opt.port;
+
+    var tunnels = self.tunnel_cluster = TunnelCluster(info);
+
+    // only emit the url the first time
+    tunnels.once('open', function() {
+        self.emit('url', info.url);
+    });
+
+    var tunnel_count = 0;
+
+    // track open count
+    tunnels.on('open', function(tunnel) {
+        tunnel_count++;
+        debug('tunnel open [total: %d]', tunnel_count);
+
+        var close_handler = function() {
+            tunnel.destroy();
+        };
+
+        if (self._closed) {
+            return close_handler();
+        }
+
+        self.once('close', close_handler);
+        tunnel.once('close', function() {
+            self.removeListener('close', close_handler);
+        });
+    });
+
+    // when a tunnel dies, open a new one
+    tunnels.on('dead', function(tunnel) {
+        tunnel_count--;
+        debug('tunnel dead [total: %d]', tunnel_count);
+
+        if (self._closed) {
+            return;
+        }
+
+        tunnels.open();
+    });
+
+    // establish as many tunnels as allowed
+    for (var count = 0 ; count < info.max_conn ; ++count) {
+        tunnels.open();
+    }
+};
+
+Tunnel.prototype.open = function(cb) {
+    var self = this;
+
+    self._init(function(err, info) {
+        if (err) {
+            return cb(err);
+        }
+
+        self.url = info.url;
+        self._establish(info);
+        cb();
+    });
+};
+
+// shutdown tunnels
+Tunnel.prototype.close = function() {
+    var self = this;
+
+    self._closed = true;
+    self.emit('close');
+};
+
+module.exports = function localtunnel(port, opt, fn) {
+    if (typeof opt === 'function') {
+        fn = opt;
+        opt = {};
+    }
+
+    opt = opt || {};
+    opt.port = port;
+
+    var client = Tunnel(opt);
+    client.open(function(err) {
+        if (err) {
+            return fn(err);
+        }
+
+        fn(null, client);
+    });
+    return client;
+};

package.json

@@ -2,16 +2,22 @@
   "author": "Roman Shtylman <shtylman@gmail.com>",
   "name": "localtunnel",
   "description": "expose localhost to the world",
-  "version": "0.1.1",
+  "version": "1.2.0",
   "repository": {
     "type": "git",
     "url": "git://github.com/shtylman/localtunnel.git"
   },
   "dependencies": {
     "request": "2.11.4",
-    "optimist": "0.3.4"
+    "optimist": "0.3.4",
+    "debug": "0.7.4"
+  },
+  "devDependencies": {
+    "mocha": "~1.17.0"
+  },
+  "scripts": {
+    "test": "mocha --ui qunit --reporter list --timeout 10000 -- test/index.js"
   },
-  "devDependencies": {},
   "bin": {
     "lt": "./bin/client"
   },

test/index.js

@@ -0,0 +1,113 @@
+var http = require('http');
+var https = require('https');
+var url = require('url');
+var assert = require('assert');
+
+var localtunnel = require('../');
+
+test('setup local http server', function(done) {
+    var server = http.createServer();
+    server.on('request', function(req, res) {
+        res.write(req.headers.host);
+        res.end();
+    });
+    server.listen(function() {
+        var port = server.address().port;
+
+        test._fake_port = port;
+        console.log('local http on:', port);
+        done();
+    });
+});
+
+test('setup localtunnel client', function(done) {
+    localtunnel(test._fake_port, function(err, tunnel) {
+        assert.ifError(err);
+        assert.ok(new RegExp('^https:\/\/.*localtunnel.me' + '$').test(tunnel.url));
+        test._fake_url = tunnel.url;
+        done();
+    });
+});
+
+test('query localtunnel server w/ ident', function(done) {
+    var uri = test._fake_url;
+    var parsed = url.parse(uri);
+
+    var opt = {
+        host: parsed.host,
+        port: 443,
+        headers: {
+            host: parsed.hostname
+        },
+        path: '/'
+    };
+
+    var req = https.request(opt, function(res) {
+        res.setEncoding('utf8');
+        var body = '';
+
+        res.on('data', function(chunk) {
+            body += chunk;
+        });
+
+        res.on('end', function() {
+            assert(/.*[.]localtunnel[.]me/.test(body), body);
+            done();
+        });
+    });
+
+    req.end();
+});
+
+test('request specific domain', function(done) {
+    localtunnel(test._fake_port, { subdomain: 'abcd' }, function(err, tunnel) {
+        assert.ifError(err);
+        assert.ok(new RegExp('^https:\/\/abcd.localtunnel.me' + '$').test(tunnel.url));
+        tunnel.close();
+        done();
+    });
+});
+
+suite('local-host');
+
+test('setup localtunnel client', function(done) {
+    var opt = {
+        local_host: '127.0.0.1'
+    };
+    localtunnel(test._fake_port, opt, function(err, tunnel) {
+        assert.ifError(err);
+        assert.ok(new RegExp('^https:\/\/.*localtunnel.me' + '$').test(tunnel.url));
+        test._fake_url = tunnel.url;
+        done();
+    });
+});
+
+test('override Host header with local-host', function(done) {
+    var uri = test._fake_url;
+    var parsed = url.parse(uri);
+
+    var opt = {
+        host: parsed.host,
+        port: 443,
+        headers: {
+            host: parsed.hostname
+        },
+        path: '/'
+    };
+
+    var req = https.request(opt, function(res) {
+        res.setEncoding('utf8');
+        var body = '';
+
+        res.on('data', function(chunk) {
+            body += chunk;
+        });
+
+        res.on('end', function() {
+            assert.equal(body, '127.0.0.1');
+            done();
+        });
+    });
+
+    req.end();
+});