@@ -23,14 +23,16 @@
Let's suppose you were running multiple http application servers, but you only wanted to expose one machine to the internet. You could setup node-http-proxy on that one machine and then reverse-proxy the incoming http requests to locally running services which were not exposed to the outside network.
### Installing npm (node package manager)
-- curl http://npmjs.org/install.sh | sh -+ +``` +curl http://npmjs.org/install.sh | sh +``` ### Installing node-http-proxy -
- npm install http-proxy -+ +``` +npm install http-proxy +``` ## Using node-http-proxy @@ -47,251 +49,262 @@ In each of these scenarios node-http-proxy can handle any of these types of requ 1. HTTP Requests (http://) 2. HTTPS Requests (https://) 3. WebSocket Requests (ws://) +4. Secure WebSocket Requests (wss://) See the [examples][3] for more working sample code. ### Setup a basic stand-alone proxy server -
- var http = require('http'),
- httpProxy = require('http-proxy');
- //
- // Create your proxy server
- //
- httpProxy.createServer(9000, 'localhost').listen(8000);
- //
- // Create your target server
- //
- http.createServer(function (req, res) {
- res.writeHead(200, { 'Content-Type': 'text/plain' });
- res.write('request successfully proxied!' + '\n' + JSON.stringify(req.headers, true, 2));
- res.end();
- }).listen(9000);
-
+``` js
+var http = require('http'),
+ httpProxy = require('http-proxy');
+//
+// Create your proxy server
+//
+httpProxy.createServer(9000, 'localhost').listen(8000);
+
+//
+// Create your target server
+//
+http.createServer(function (req, res) {
+ res.writeHead(200, { 'Content-Type': 'text/plain' });
+ res.write('request successfully proxied!' + '\n' + JSON.stringify(req.headers, true, 2));
+ res.end();
+}).listen(9000);
+```
### Setup a stand-alone proxy server with custom server logic
-
- var http = require('http'),
- httpProxy = require('http-proxy');
-
- //
- // Create a proxy server with custom application logic
- //
- httpProxy.createServer(function (req, res, proxy) {
- //
- // Put your custom server logic here
- //
- proxy.proxyRequest(req, res, {
- host: 'localhost',
- port: 9000
- });
- }).listen(8000);
- http.createServer(function (req, res) {
- res.writeHead(200, { 'Content-Type': 'text/plain' });
- res.write('request successfully proxied: ' + req.url +'\n' + JSON.stringify(req.headers, true, 2));
- res.end();
- }).listen(9000);
-
+``` js
+var http = require('http'),
+ httpProxy = require('http-proxy');
+
+//
+// Create a proxy server with custom application logic
+//
+httpProxy.createServer(function (req, res, proxy) {
+ //
+ // Put your custom server logic here
+ //
+ proxy.proxyRequest(req, res, {
+ host: 'localhost',
+ port: 9000
+ });
+}).listen(8000);
+
+http.createServer(function (req, res) {
+ res.writeHead(200, { 'Content-Type': 'text/plain' });
+ res.write('request successfully proxied: ' + req.url +'\n' + JSON.stringify(req.headers, true, 2));
+ res.end();
+}).listen(9000);
+```
### Setup a stand-alone proxy server with latency (e.g. IO, etc)
-
- var http = require('http'),
- httpProxy = require('http-proxy');
+
+``` js
+var http = require('http'),
+ httpProxy = require('http-proxy');
+
+//
+// Create a proxy server with custom application logic
+//
+httpProxy.createServer(function (req, res, proxy) {
+ //
+ // Buffer the request so that `data` and `end` events
+ // are not lost during async operation(s).
+ //
+ var buffer = proxy.buffer(req);
//
- // Create a proxy server with custom application logic
+ // Wait for two seconds then respond: this simulates
+ // performing async actions before proxying a request
//
- httpProxy.createServer(function (req, res, proxy) {
- //
- // Buffer the request so that `data` and `end` events
- // are not lost during async operation(s).
- //
- var buffer = proxy.buffer(req);
-
- //
- // Wait for two seconds then respond: this simulates
- // performing async actions before proxying a request
- //
- setTimeout(function () {
- proxy.proxyRequest(req, res, {
- host: 'localhost',
- port: 9000,
- buffer: buffer
- });
- }, 2000);
- }).listen(8000);
-
- http.createServer(function (req, res) {
- res.writeHead(200, { 'Content-Type': 'text/plain' });
- res.write('request successfully proxied: ' + req.url +'\n' + JSON.stringify(req.headers, true, 2));
- res.end();
- }).listen(9000);
-
-
-### Proxy requests within another http server
-
- var http = require('http'),
- httpProxy = require('http-proxy');
-
- //
- // Create a new instance of HttProxy to use in your server
- //
- var proxy = new httpProxy.HttpProxy();
-
- //
- // Create a regular http server and proxy its handler
- //
- http.createServer(function (req, res) {
- //
- // Put your custom server logic here, then proxy
- //
+ setTimeout(function () {
proxy.proxyRequest(req, res, {
host: 'localhost',
- port: 9000
- });
- }).listen(8001);
+ port: 9000,
+ buffer: buffer
+ });
+ }, 2000);
+}).listen(8000);
- http.createServer(function (req, res) {
- res.writeHead(200, { 'Content-Type': 'text/plain' });
- res.write('request successfully proxied: ' + req.url +'\n' + JSON.stringify(req.headers, true, 2));
- res.end();
- }).listen(9000);
-
+http.createServer(function (req, res) {
+ res.writeHead(200, { 'Content-Type': 'text/plain' });
+ res.write('request successfully proxied: ' + req.url +'\n' + JSON.stringify(req.headers, true, 2));
+ res.end();
+}).listen(9000);
+```
+
+### Proxy requests within another http server
+
+``` js
+var http = require('http'),
+ httpProxy = require('http-proxy');
+
+//
+// Create a new instance of HttProxy to use in your server
+//
+var proxy = new httpProxy.HttpProxy();
+
+//
+// Create a regular http server and proxy its handler
+//
+http.createServer(function (req, res) {
+ //
+ // Put your custom server logic here, then proxy
+ //
+ proxy.proxyRequest(req, res, {
+ host: 'localhost',
+ port: 9000
+ });
+}).listen(8001);
+
+http.createServer(function (req, res) {
+ res.writeHead(200, { 'Content-Type': 'text/plain' });
+ res.write('request successfully proxied: ' + req.url +'\n' + JSON.stringify(req.headers, true, 2));
+ res.end();
+}).listen(9000);
+```
### Proxy requests using a ProxyTable
A Proxy Table is a simple lookup table that maps incoming requests to proxy target locations. Take a look at an example of the options you need to pass to httpProxy.createServer:
-
- var options = {
- router: {
- 'foo.com/baz': '127.0.0.1:8001',
- 'foo.com/buz': '127.0.0.1:8002',
- 'bar.com/buz': '127.0.0.1:8003'
- }
- };
-
+
+``` js
+var options = {
+ router: {
+ 'foo.com/baz': '127.0.0.1:8001',
+ 'foo.com/buz': '127.0.0.1:8002',
+ 'bar.com/buz': '127.0.0.1:8003'
+ }
+};
+```
The above route table will take incoming requests to 'foo.com/baz' and forward them to '127.0.0.1:8001'. Likewise it will take incoming requests to 'foo.com/buz' and forward them to '127.0.0.1:8002'. The routes themselves are later converted to regular expressions to enable more complex matching functionality. We can create a proxy server with these options by using the following code:
-- var proxyServer = httpProxy.createServer(options); - proxyServer.listen(80); -+ +``` js +var proxyServer = httpProxy.createServer(options); +proxyServer.listen(80); +``` ### Proxy requests using a 'Hostname Only' ProxyTable As mentioned in the previous section, all routes passes to the ProxyTable are by default converted to regular expressions that are evaluated at proxy-time. This is good for complex URL rewriting of proxy requests, but less efficient when one simply wants to do pure hostname routing based on the HTTP 'Host' header. If you are only concerned with hostname routing, you change the lookup used by the internal ProxyTable: -
- var options = {
- hostnameOnly, true,
- router: {
- 'foo.com': '127.0.0.1:8001',
- 'bar.com': '127.0.0.1:8002'
- }
+``` js
+var options = {
+ hostnameOnly: true,
+ router: {
+ 'foo.com': '127.0.0.1:8001',
+ 'bar.com': '127.0.0.1:8002'
}
-
+}
+```
Notice here that I have not included paths on the individual domains because this is not possible when using only the HTTP 'Host' header. Care to learn more? See [RFC2616: HTTP/1.1, Section 14.23, "Host"][4].
### Proxy requests with an additional forward proxy
Sometimes in addition to a reverse proxy, you may want your front-facing server to forward traffic to another location. For example, if you wanted to load test your staging environment. This is possible when using node-http-proxy using similar JSON-based configuration to a proxy table:
-
- var proxyServerWithForwarding = httpProxy.createServer(9000, 'localhost', {
- forward: {
- port: 9000,
- host: 'staging.com'
- }
- });
- proxyServerWithForwarding.listen(80);
-
+
+``` js
+var proxyServerWithForwarding = httpProxy.createServer(9000, 'localhost', {
+ forward: {
+ port: 9000,
+ host: 'staging.com'
+ }
+});
+proxyServerWithForwarding.listen(80);
+```
The forwarding option can be used in conjunction with the proxy table options by simply including both the 'forward' and 'router' properties in the options passed to 'createServer'.
### Using node-http-proxy from the command line
When you install this package with npm, a node-http-proxy binary will become available to you. Using this binary is easy with some simple options:
-- usage: node-http-proxy [options] - All options should be set with the syntax --option=value +``` js +usage: node-http-proxy [options] - options: - --port PORT Port that the proxy server should run on - --target HOST:PORT Location of the server the proxy will target - --config OUTFILE Location of the configuration file for the proxy server - --silent Silence the log output from the proxy server - -h, --help You're staring at it -+All options should be set with the syntax --option=value + +options: + --port PORT Port that the proxy server should run on + --target HOST:PORT Location of the server the proxy will target + --config OUTFILE Location of the configuration file for the proxy server + --silent Silence the log output from the proxy server + -h, --help You're staring at it +``` ### Proxying over HTTPS You have all the full flexibility of node-http-proxy offers in HTTPS as well as HTTP. The two basic scenarios are: with a stand-alone proxy server or in conjunction with another HTTPS server. -
- var fs = require('fs'),
- https = require('https'),
- httpProxy = require('http-proxy');
-
- var options = {
- https: {
- key: fs.readFileSync('path/to/your/key.pem', 'utf8'),
- cert: fs.readFileSync('path/to/your/cert.pem', 'utf8')
- }
- };
-
- //
- // Create a standalone HTTPS proxy server
- //
- httpProxy.createServer(8000, 'localhost', options).listen(8001);
-
- //
- // Create an instance of HttpProxy to use with another HTTPS server
- //
- var proxy = new httpProxy.HttpProxy({ https: true });
- https.createServer(options.https, function (req, res) {
- proxy.proxyRequest(req, res, {
- host: 'localhost',
- port: 8000
- })
- }).listen(8002);
-
- //
- // Create the target HTTPS server for both cases
- //
- https.createServer(options.https, function (req, res) {
- res.writeHead(200, { 'Content-Type': 'text/plain' });
- res.write('hello https\n');
- res.end();
- }).listen(8000);
-
+
+``` js
+var fs = require('fs'),
+ https = require('https'),
+ httpProxy = require('http-proxy');
+
+var options = {
+ https: {
+ key: fs.readFileSync('path/to/your/key.pem', 'utf8'),
+ cert: fs.readFileSync('path/to/your/cert.pem', 'utf8')
+ }
+};
+
+//
+// Create a standalone HTTPS proxy server
+//
+httpProxy.createServer(8000, 'localhost', options).listen(8001);
+
+//
+// Create an instance of HttpProxy to use with another HTTPS server
+//
+var proxy = new httpProxy.HttpProxy({ https: true });
+https.createServer(options.https, function (req, res) {
+ proxy.proxyRequest(req, res, {
+ host: 'localhost',
+ port: 8000
+ })
+}).listen(8002);
+
+//
+// Create the target HTTPS server for both cases
+//
+https.createServer(options.https, function (req, res) {
+ res.writeHead(200, { 'Content-Type': 'text/plain' });
+ res.write('hello https\n');
+ res.end();
+}).listen(8000);
+```
### Proxying WebSockets
Websockets are handled automatically when using the `httpProxy.createServer()`, but if you want to use it in conjunction with a stand-alone HTTP + WebSocket (such as [socket.io][5]) server here's how:
-
- var http = require('http'),
- httpProxy = require('http-proxy');
-
+
+``` js
+var http = require('http'),
+ httpProxy = require('http-proxy');
+
+//
+// Create an instance of node-http-proxy
+//
+var proxy = new httpProxy.HttpProxy();
+
+var server = http.createServer(function (req, res) {
//
- // Create an instance of node-http-proxy
+ // Proxy normal HTTP requests
//
- var proxy = new httpProxy.HttpProxy();
-
- var server = http.createServer(function (req, res) {
- //
- // Proxy normal HTTP requests
- //
- proxy.proxyRequest(req, res, {
- host: 'localhost',
- port: 8000
- })
+ proxy.proxyRequest(req, res, {
+ host: 'localhost',
+ port: 8000
+ })
+});
+
+server.on('upgrade', function(req, socket, head) {
+ //
+ // Proxy websocket requests too
+ //
+ proxy.proxyWebSocketRequest(req, socket, head, {
+ host: 'localhost',
+ port: 8000
});
-
- server.on('upgrade', function(req, socket, head) {
- //
- // Proxy websocket requests too
- //
- proxy.proxyWebSocketRequest(req, socket, head, {
- host: 'localhost',
- port: 8000
- });
- });
-
+});
+```
- vows test/*-test.js --spec - vows test/*-test.js --spec --https -+ +``` +vows test/*-test.js --spec +vows test/*-test.js --spec --https +```
exports.version = [0, 4, 2];exports.version = [0, 5, 3];Retreives an agent from the http module
-and sets the maxSockets property appropriately.
function _getAgent (host, port) {TODO (indexzero): Make this configurable for http / https
var agent = http.getAgent(host, port);
+@secure {boolean} Value indicating whether or not to use HTTPS
+
+Retreives an agent from the http or https module
+and sets the maxSockets property appropriately.
function _getAgent (host, port, secure) {
+ var agent = !secure ? http.getAgent(host, port) : https.getAgent({
+ host: host,
+ port: port
+ });
+
agent.maxSockets = maxSockets;
return agent;
+}httpsReturns the appropriate protocol based on the settings in
+secure. If the protocol is https this function will update
+the options in outgoing as appropriate by adding ca, key,
+and cert if they exist in secure.
function _getProtocol (secure, outgoing) {
+ var protocol = secure ? https : http;
+
+ if (typeof secure === 'object') {
+ outgoing = outgoing || {};
+ ['ca', 'cert', 'key'].forEach(function (prop) {
+ if (secure[prop]) {
+ outgoing[prop] = secure[prop];
+ }
+ })
+ }
+
+ return protocol;
}Returns the maximum number of sockets
@@ -67,11 +97,10 @@ made by all instances of HttpProxy
httpPRoxy.createServer(function (req, res, proxy) { ... })exports.createServer = function () {
- var args, callback, port, host, forward,
- silent, options, proxy, server;
-
- args = Array.prototype.slice.call(arguments);
- callback = typeof args[args.length - 1] === 'function' && args.pop();
+ var args = Array.prototype.slice.call(arguments),
+ callback = typeof args[0] === 'function' && args.shift(),
+ options = {},
+ port, host, forward, silent, proxy, server;
if (args.length >= 2) {
port = args[0];
@@ -86,21 +115,27 @@ made by all instances of HttpProxy
}
proxy = new HttpProxy(options);
- server = http.createServer(function (req, res) {
- proxy.emit('request', req, request.headers.host, req.url);If we were passed a callback to process the request -or response in some way, then call it.
if (callback) {
- callback(req, res, proxy);
+
+ handler = function (req, res) {
+ if (callback) {If we were passed a callback to process the request +or response in some way, then call it.
callback(req, res, proxy);
}
- else if (port && host) {
- proxy.proxyRequest(req, res, port, host);
+ else if (port && host) {If we have a target host and port for the request +then proxy to the specified location.
proxy.proxyRequest(req, res, {
+ port: port,
+ host: host
+ });
}
- else if (proxy.proxyTable) {
- proxy.proxyRequest(req, res);
+ else if (proxy.proxyTable) {If the proxy is configured with a ProxyTable +instance then use that before failing.
proxy.proxyRequest(req, res);
}
- else {
- throw new Error('Cannot proxy without port, host, or router.')
+ else {Otherwise this server is improperly configured.
throw new Error('Cannot proxy without port, host, or router.')
}
- });
+ };
+
+ server = options.https
+ ? https.createServer(options.https, handler)
+ : http.createServer(handler);
server.on('close', function () {
proxy.close();
@@ -110,14 +145,19 @@ or response in some way, then call it. WebSocket support: if callback is empty tunnel -websocket request automatically
server.on('upgrade', function(req, socket, head) {Tunnel websocket requests too
- proxy.proxyWebSocketRequest(port, host);
+ if (!callback) {WebSocket support: if callback is empty tunnel +websocket request automatically
server.on('upgrade', function(req, socket, head) {Tunnel websocket requests too
+ proxy.proxyWebSocketRequest(req, socket, head, {
+ port: port,
+ host: host
+ });
});
}
-
+ Set the proxy on the server so it is available +to the consumer of the server
server.proxy = proxy;
+
return server;
-};var HttpProxy = exports.HttpProxy = function (options) {
events.EventEmitter.call(this);
- options = options || {};
- this.options = options;
+ var self = this;
+ options = options || {};
+ this.forward = options.forward;
+ this.https = options.https;
+ this.changeOrigin = options.changeOrigin || false;
if (options.router) {
- var self = this;
this.proxyTable = new ProxyTable(options.router, options.silent, options.hostnameOnly);
this.proxyTable.on('routes', function (routes) {
self.emit('routes', routes);
});
}
-};Inherit from events.EventEmitter
util.inherits(HttpProxy, events.EventEmitter);Inherit from events.EventEmitter
util.inherits(HttpProxy, events.EventEmitter);Attribution: This approach is based heavily on Connect. -However, this is not a big leap from the implementation in node-http-proxy < 0.4.0. +However, this is not a big leap from the implementation in node-http-proxy < 0.4.0. This simply chooses to manage the scope of the events on a new Object literal as opposed to on the HttpProxy instance.
HttpProxy.prototype.buffer = function (obj) {
var onData, onEnd, events = [];
@@ -192,51 +234,54 @@ This simply chooses to manage the scope of the events on a new Object literal a
}
}
};
-};Frees the resources associated with this instance, if they exist.
HttpProxy.prototype.close = function () {
if (this.proxyTable) this.proxyTable.close();
-};httpProxy.buffer(req)HttpProxy.prototype.proxyRequest = function (req, res, port, host, buffer) {
- var self = this, reverseProxy, location, errState = false, opts;
- Check the proxy table for this instance to see if we need +
options.port {number} Port to use on the proxy target host.
+options.host {string} Host of the proxy target.
+options.buffer {Object} Result from `httpProxy.buffer(req)`
+options.https {Object|boolean} Settings for https.
+HttpProxy.prototype.proxyRequest = function (req, res, options) {
+ var self = this, errState = false, location, outgoing, protocol, reverseProxy;
+ Create an empty options hash if none is passed.
options = options || {};
+ Check the proxy table for this instance to see if we need
to get the proxy location for the request supplied. We will
always ignore the proxyTable if an explicit port and host
-arguments are supplied to proxyRequest.
if (this.proxyTable && !host) {
+arguments are supplied to proxyRequest. if (this.proxyTable && !options.host) {
location = this.proxyTable.getProxyLocation(req);
- If no location is returned from the ProxyTable instance +
If no location is returned from the ProxyTable instance
then respond with 404 since we do not have a valid proxy target.
if (!location) {
res.writeHead(404);
return res.end();
}
- When using the ProxyTable in conjunction with an HttpProxy instance +
When using the ProxyTable in conjunction with an HttpProxy instance only the following arguments are valid:
proxy.proxyRequest(req, res, port, host, buffer): This will be skippedproxy.proxyRequest(req, res, buffer): Buffer will get updated appropriatelyproxy.proxyRequest(req, res): No effect undefined = undefined buffer = port;
- port = location.port;
- host = location.host;
+proxy.proxyRequest(req, res, { host: 'localhost' }): This will be skippedproxy.proxyRequest(req, res, { buffer: buffer }): Buffer will get updated appropriatelyproxy.proxyRequest(req, res): Options will be assigned appropriately. options.port = location.port;
+ options.host = location.host;
}
- Emit the start event indicating that we have begun the proxy operation.
this.emit('start', req, res, host, port);
- If forwarding is enabled for this instance, foward proxy the
-specified request to the address provided in this.options.forward
if (this.options.forward) {
- this.emit('forward', req, res, this.options.forward.host, this.options.forward.port);
+ Add x-forwarded-for header to availible client IP to apps behind proxy
req.headers['x-forwarded-for'] = req.connection.remoteAddress;
+ Emit the start event indicating that we have begun the proxy operation.
this.emit('start', req, res, options);
+ If forwarding is enabled for this instance, foward proxy the
+specified request to the address provided in this.forward
if (this.forward) {
+ this.emit('forward', req, res, this.forward);
this._forwardRequest(req);
}
- host / port.
res.end();
}
- var opts = {
- host: host,
- port: port,
- agent: _getAgent(host, port),
+ outgoing = {
+ host: options.host,
+ port: options.port,
+ agent: _getAgent(options.host, options.port, options.https || this.https),
method: req.method,
path: req.url,
headers: req.headers
};
- Force the connection header to be 'close' until
-node.js core re-implements 'keep-alive'.
opts.headers['connection'] = 'close';
- Open new HTTP request to internal resource with will act as a reverse proxy pass
reverseProxy = http.request(opts, function (response) {
- Process the reverseProxy response when it's received.
if (response.headers.connection) {
+ Force the connection header to be 'close' until
+node.js core re-implements 'keep-alive'.
outgoing.headers['connection'] = 'close';
+
+ protocol = _getProtocol(options.https || this.https, outgoing);
+ Open new HTTP request to internal resource with will act as a reverse proxy pass
reverseProxy = protocol.request(outgoing, function (response) {
+ Process the reverseProxy response when it's received.
if (response.headers.connection) {
if (req.headers.connection) response.headers.connection = req.headers.connection;
else response.headers.connection = 'close';
- }Set the headers of the client response
res.writeHead(response.statusCode, response.headers);response.statusCode === 304: No 'data' event and no 'end'
if (response.statusCode === 304) {
+ }Set the headers of the client response
res.writeHead(response.statusCode, response.headers);response.statusCode === 304: No 'data' event and no 'end'
if (response.statusCode === 304) {
return res.end();
- }For each data chunk received from the reverseProxy
+ }
For each data chunk received from the reverseProxy
response write it to the outgoing res.
response.on('data', function (chunk) {
if (req.method !== 'HEAD') {
res.write(chunk);
}
- });When the reverseProxy response ends, end the
+ });
When the reverseProxy response ends, end the
corresponding outgoing res unless we have entered
an error state. In which case, assume res.end() has
already been called and the 'error' event listener
@@ -281,164 +328,182 @@ removed.
Emit the end event now that we have completed proxying
self.emit('end', req, res);
}
});
});
- Handle 'error' events from the reverseProxy.
reverseProxy.once('error', proxyError);
- For each data chunk received from the incoming
+
Handle 'error' events from the reverseProxy.
reverseProxy.once('error', proxyError);
+ For each data chunk received from the incoming
req write it to the reverseProxy request.
req.on('data', function (chunk) {
if (!errState) {
reverseProxy.write(chunk);
}
- });When the incoming req ends, end the corresponding reverseProxy
+ });
When the incoming req ends, end the corresponding reverseProxy
request unless we have entered an error state.
req.on('end', function () {
if (!errState) {
reverseProxy.end();
}
- });If we have been passed buffered data, resume it.
if (buffer && !errState) {
- buffer.resume();
+ });If we have been passed buffered data, resume it.
if (options.buffer && !errState) {
+ options.buffer.resume();
}
};
- Forwards the specified req to the location specified
-by this.options.forward ignoring errors and the subsequent response.
HttpProxy.prototype._forwardRequest = function (req) {
- var self = this, port, host, forwardProxy, opts;
+by this.forward ignoring errors and the subsequent response. HttpProxy.prototype._forwardRequest = function (req) {
+ var self = this, port, host, outgoing, protocol, forwardProxy;
- port = this.options.forward.port;
- host = this.options.forward.host;
+ port = this.forward.port;
+ host = this.forward.host;
- opts = {
+ outgoing = {
host: host,
port: port,
- agent: _getAgent(host, port),
+ agent: _getAgent(host, port, this.forward.https),
method: req.method,
path: req.url,
headers: req.headers
};
- Force the connection header to be 'close' until
-node.js core re-implements 'keep-alive'.
opts.headers['connection'] = 'close';
- Open new HTTP request to internal resource with will act as a reverse proxy pass
forwardProxy = http.request(opts, function (response) {Ignore the response from the forward proxy since this is a 'fire-and-forget' proxy. +
Force the connection header to be 'close' until
+node.js core re-implements 'keep-alive'.
outgoing.headers['connection'] = 'close';
+
+ protocol = _getProtocol(this.forward.https, outgoing);
+ Open new HTTP request to internal resource with will act as a reverse proxy pass
forwardProxy = protocol.request(outgoing, function (response) {Ignore the response from the forward proxy since this is a 'fire-and-forget' proxy. Remark (indexzero): We will eventually emit a 'forward' event here for performance tuning.
});
- Add a listener for the connection timeout event.
+Add a listener for the connection timeout event.
Remark: Ignoring this error in the event - forward target doesn't exist.
forwardProxy.once('error', function (err) { });Chunk the client request body as chunks from the proxied request come in
req.on('data', function (chunk) {
+ forward target doesn't exist. forwardProxy.once('error', function (err) { });Chunk the client request body as chunks from the proxied request come in
req.on('data', function (chunk) {
forwardProxy.write(chunk);
- })At the end of the client request, we are going to stop the proxied request
req.on('end', function () {
+ })At the end of the client request, we are going to stop the proxied request
req.on('end', function () {
forwardProxy.end();
});
};
-HttpProxy.prototype.proxyWebSocketRequest = function (port, server, host, data) {
- var self = this, req = self.req, socket = self.sock, head = self.head,
- headers = new _headers(req.headers), CRLF = '\r\n';Will generate clone of headers -To not change original
function _headers(headers) {
- var h = {};
- for (var i in headers) {
- h[i] = headers[i];
- }
- return h;
- }WebSocket requests has method = GET
if (req.method !== 'GET' || headers.upgrade.toLowerCase() !== 'websocket') {This request is not WebSocket request
return;
- }Turn of all bufferings +HttpProxy.prototype.proxyWebSocketRequest = function (req, socket, head, options) { + var self = this, outgoing, errState = false, CRLF = '\r\n';
WebSocket requests has method = GET
if (req.method !== 'GET' || req.headers.upgrade.toLowerCase() !== 'websocket') {This request is not WebSocket request
return;
+ }Turn of all bufferings For server set KeepAlive -For client set encoding
function _socket(socket, server) {
+For client set encoding function _socket(socket, keepAlive) {
socket.setTimeout(0);
socket.setNoDelay(true);
- if (server) {
- socket.setKeepAlive(true, 0);
+ if (keepAlive) {
+ if (socket.setKeepAlive) {
+ socket.setKeepAlive(true, 0);
+ }
+ else if (socket.pair.cleartext.socket.setKeepAlive) {
+ socket.pair.cleartext.socket.setKeepAlive(true, 0);
+ }
}
else {
socket.setEncoding('utf8');
}
- }Client socket
_socket(socket);If host is undefined -Get it from headers
if (!host) {
- host = headers.Host;
}
- Remote host address
var remote_host = server + (port - 80 === 0 ? '' : ':' + port);Change headers
headers.Host = remote_host;
- headers.Origin = 'http://' + remote_host;Open request
var p = manager.getPool(port, server);
-
- p.getClient(function(client) {Based on 'pool/main.js'
var request = client.request('GET', req.url, headers);
-
- var errorListener = function (error) {
- client.removeListener('error', errorListener);
- Remove the client from the pool's available clients since it has errored
p.clients.splice(p.clients.indexOf(client), 1);
- socket.end();
- }Not disconnect on update
client.on('upgrade', function(request, remote_socket, head) {Prepare socket
_socket(remote_socket, true);Emit event
onUpgrade(remote_socket);
- });
-
- client.on('error', errorListener);
- request.on('response', function (response) {
- response.on('end', function () {
- client.removeListener('error', errorListener);
- client.busy = false;
- p.onFree(client);
- })
- })
- client.busy = true;
-
- var handshake;
- request.socket.on('data', handshake = function(data) {Handshaking
Ok, kind of harmfull part of code -Socket.IO is sending hash at the end of handshake -If protocol = 76 -But we need to replace 'host' and 'origin' in response -So we split data to printable data and to non-printable -(Non-printable will come after double-CRLF)
var sdata = data.toString();Get Printable
sdata = sdata.substr(0, sdata.search(CRLF + CRLF));Get Non-Printable
data = data.slice(Buffer.byteLength(sdata), data.length);Replace host and origin
sdata = sdata.replace(remote_host, host)
- .replace(remote_host, host);
-
- try {Write printable
socket.write(sdata);Write non-printable
socket.write(data);
- }
- catch (e) {
- request.end();
- socket.end();
- }Catch socket errors
socket.on('error', function() {
- request.end();
- });Remove data listener now that the 'handshake' is complete
request.socket.removeListener('data', handshake);
- });Write upgrade-head
try {
- request.write(head);
- }
- catch(e) {
- request.end();
+
+ function onUpgrade(out, reverseProxy) {
+ if (!out) {
+ reverseProxy.end();
socket.end();
+ return;
}
- self.unwatch(socket);
- });Request
function onUpgrade(reverse_proxy) {
+
var listeners = {};
- We're now connected to the server, so lets change server socket
reverse_proxy.on('data', listeners._r_data = function(data) {Pass data to client
if (socket.writable) {
+ We're now connected to the server, so lets change server socket
reverseProxy.on('data', listeners._r_data = function(data) {Pass data to client
if (out.incoming.socket.writable) {
try {
- socket.write(data);
+ out.incoming.socket.write(data);
}
catch (e) {
- socket.end();
- reverse_proxy.end();
+ out.incoming.socket.end();
+ reverseProxy.end();
}
}
});
- socket.on('data', listeners._data = function(data) {Pass data from client to server
try {
- reverse_proxy.write(data);
+ out.incoming.socket.on('data', listeners._data = function(data) {Pass data from client to server
try {
+ reverseProxy.write(data);
}
catch (e) {
- reverse_proxy.end();
+ reverseProxy.end();
socket.end();
}
- });Detach event listeners from reverse_proxy
function detach() {
- reverse_proxy.removeListener('close', listeners._r_close);
- reverse_proxy.removeListener('data', listeners._r_data);
- socket.removeListener('data', listeners._data);
- socket.removeListener('close', listeners._close);
- }Hook disconnections
reverse_proxy.on('end', listeners._r_close = function() {
- socket.end();
+ });Detach event listeners from reverseProxy
function detach() {
+ reverseProxy.removeListener('close', listeners._r_close);
+ reverseProxy.removeListener('data', listeners._r_data);
+ out.incoming.socket.removeListener('data', listeners._data);
+ out.incoming.socket.removeListener('close', listeners._close);
+ }Hook disconnections
reverseProxy.on('end', listeners._r_close = function() {
+ out.incoming.socket.end();
detach();
});
socket.on('end', listeners._close = function() {
- reverse_proxy.end();
+ reverseProxy.end();
detach();
});
+ };Client socket
_socket(socket);
+ Remote host address
var protocolName = options.https || this.https ? 'https' : 'http',
+ agent = _getAgent(options.host, options.port, options.https || this.https),
+ remoteHost = options.host + (options.port - 80 === 0 ? '' : ':' + options.port);Change headers
if (this.changeOrigin) {
+ req.headers.host = remoteHost;
+ req.headers.origin = protocolName + '://' + remoteHost;
+ }
+
+ outgoing = {
+ host: options.host,
+ port: options.port,
+ method: 'GET',
+ path: req.url,
+ headers: req.headers,
+ };Make the outgoing WebSocket request
var request = agent.appendMessage(outgoing);Here we set the incoming req, socket and head data to the outgoing
+request so that we can reuse this data later on in the closure scope
+available to the upgrade event. This bookkeeping is not tracked anywhere
+in nodejs core and is very specific to proxying WebSockets.
request.agent = agent;
+ request.incoming = {
+ request: req,
+ socket: socket,
+ head: head
};
+ If the agent for this particular host and port combination
+is not already listening for the upgrade event, then do so once.
+This will force us not to disconnect.
In addition, it's important to note the closure scope here. Since +there is no mapping of the
if (!agent._events || agent._events['upgrade'].length === 0) {
+ agent.on('upgrade', function (out, remoteSocket, head) {Prepare socket
_socket(remoteSocket, true);
+ Emit event
onUpgrade(remoteSocket._httpMessage, remoteSocket);
+ });
+ }
+
+ if (typeof request.socket !== 'undefined') {
+ request.socket.on('data', function handshake (data) {Handshaking
Ok, kind of harmfull part of code +Socket.IO is sending hash at the end of handshake +If protocol = 76 +But we need to replace 'host' and 'origin' in response +So we split data to printable data and to non-printable +(Non-printable will come after double-CRLF)
var sdata = data.toString();Get Printable
sdata = sdata.substr(0, sdata.search(CRLF + CRLF));Get Non-Printable
data = data.slice(Buffer.byteLength(sdata), data.length);Replace host and origin
sdata = sdata.replace(remoteHost, options.host)
+ .replace(remoteHost, options.host);
+
+ try {Write printable
socket.write(sdata);Write non-printable
socket.write(data);
+ }
+ catch (e) {
+ request.end();
+ socket.end();
+ }Catch socket errors
socket.on('error', function() {
+ request.end();
+ });Remove data listener now that the 'handshake' is complete
request.socket.removeListener('data', handshake);
+ });
+ }Write upgrade-head
try {
+ request.write(head);
+ }
+ catch (ex) {
+ request.end();
+ socket.end();
+ }
+ If we have been passed buffered data, resume it.
if (options.buffer && !errState) {
+ options.buffer.resume();
+ }
};