passenger 4.0.36 → 4.0.37

data/test/node/httplib_emulation_spec.js

@@ -91,6 +91,52 @@ describe('HttplibEmulation', function() {
 		return result;
 	}
 
+	describe('the request object', function() {
+		beforeEach(function() {
+			var state = this.state;
+			state.setup = function(headers, callback) {
+				if (!callback) {
+					callback = headers;
+					headers = {};
+				}
+				state.headers = createHeaders(headers);
+				state.createSocket(function(serverSocket, client) {
+					state.req = HttplibEmulation.createIncomingMessage(
+						state.headers, serverSocket, "");
+					callback();
+				});
+			}
+		});
+
+		specify('.on() returns the request object', function(done) {
+			var state = this.state;
+			state.setup(function() {
+				var result = state.req.on('foo', function() {});
+				assert.strictEqual(result, state.req);
+				done();
+			});
+		});
+
+		it('sets no "upgrade" flag if there is no Upgrade header', function(done) {
+			var state = this.state;
+			state.setup(function() {
+				assert.ok(!state.req.upgrade);
+				done();
+			});
+		});
+
+		it('sets the "upgrade" flag if there is an Upgrade header', function(done) {
+			var state = this.state;
+			var headers = {
+				'HTTP_UPGRADE': 'WebSocket'
+			};
+			state.setup(headers, function() {
+				assert.ok(state.req.upgrade);
+				done();
+			});
+		});
+	});
+
 	describe('if the request may have a request body', function() {
 		beforeEach(function() {
 			var state = this.state;
@@ -105,7 +151,6 @@ describe('HttplibEmulation', function() {
 				state.createSocket(function(serverSocket, client) {
 					state.req = HttplibEmulation.createIncomingMessage(
 						state.headers, serverSocket, "");
-					assert.ok(state.req._mayHaveRequestBody);
 					callback();
 				});
 			}
@@ -165,7 +210,7 @@ describe('HttplibEmulation', function() {
 				});
 			});
 
-			it("sends data events as data is received", function(done) {
+			specify("the request object emits data events as data is received", function(done) {
 				var state = this.state;
 				var chunks = [];
 
@@ -182,7 +227,7 @@ describe('HttplibEmulation', function() {
 				});
 			});
 
-			it("sends the end event after the client closes the socket", function(done) {
+			specify("the request object emits the end event after the client closes the socket", function(done) {
 				var state = this.state;
 				var finished;
 
@@ -214,7 +259,7 @@ describe('HttplibEmulation', function() {
 				});
 			});
 
-			it("emits readable events upon receiving data", function(done) {
+			specify("the request object emits readable events upon receiving data", function(done) {
 				var state = this.state;
 				var readable = 0;
 				state.req.on('readable', function() {
@@ -380,7 +425,6 @@ describe('HttplibEmulation', function() {
 				state.createSocket(function(serverSocket, client) {
 					state.req = HttplibEmulation.createIncomingMessage(
 						state.headers, serverSocket, "");
-					assert.ok(!state.req._mayHaveRequestBody);
 					callback();
 				});
 			}
@@ -488,4 +532,92 @@ describe('HttplibEmulation', function() {
 			});
 		});
 	});
+
+	describe('requests with Upgrade header', function() {
+		beforeEach(function() {
+			var state = this.state;
+			state.setup = function(headers, callback) {
+				if (!callback) {
+					callback = headers;
+					headers = {
+						'HTTP_UPGRADE': 'websocket'
+					};
+				}
+				state.headers = createHeaders(headers);
+				state.createSocket(function(serverSocket, client) {
+					state.req = HttplibEmulation.createIncomingMessage(
+						state.headers, serverSocket, "");
+					callback();
+				});
+			}
+		});
+
+		specify('the request object emits no data events', function(done) {
+			var state = this.state;
+			state.setup(function() {
+				var hasData = false;
+
+				state.req.on('data', function(data) {
+					hasData = true;
+				});
+				state.client.write("hello");
+
+				Helper.shouldNeverHappen(50, function() {
+					return hasData;
+				}, done);
+			});
+		});
+
+		specify('the request object ends immediately', function(done) {
+			var state = this.state;
+			state.setup(function() {
+				var readable = false;
+				var readData;
+				var ended = false;
+
+				state.req.on('readable', function() {
+					readable = true;
+					readData = state.req.read(100);
+				});
+				state.req.on('end', function() {
+					ended = true;
+				});
+
+				Helper.eventually(50, function() {
+					return readable && ended;
+				}, function() {
+					assert.strictEqual(readData, null);
+					done();
+				});
+			});
+		});
+
+		specify('the socket emits data events as data is received', function(done) {
+			var state = this.state;
+			state.setup(function() {
+				var hasData = false;
+
+				state.req.socket.on('data', function(data) {
+					hasData = true;
+				});
+				state.client.write("hello");
+
+				Helper.eventually(50, function() {
+					return hasData;
+				}, done);
+			});
+		});
+
+		it('allows reading from the socket', function(done) {
+			var state = this.state;
+			state.setup(function() {
+				state.req.socket.on('readable', function() {
+					var chunk = state.req.socket.read(5).toString('utf-8');
+					chunk.should.eql("hello");
+					done();
+				});
+				state.client.write("hello");
+			});
+		});
+	});
 });

data/test/node/spec_helper.js

@@ -46,6 +46,19 @@ var Helper = {
 				assert.fail("Something which should eventually happen never happened");
 			}
 		}, 10);
+	},
+
+	shouldNeverHappen: function(timeout, check, done) {
+		var startTime = new Date();
+		var id = setInterval(function() {
+			if (check()) {
+				clearInterval(id);
+				assert.fail("Something which should never happen, happened anyway");
+			} else if (new Date() - startTime > timeout) {
+				clearInterval(id);
+				done();
+			}
+		}, 10);
 	}
 };
 

data/test/stub/node/app.js

@@ -0,0 +1,125 @@
+var fs = require('fs');
+var url = require('url');
+var express = require('express');
+var app = express();
+var bodyParser = express.bodyParser();
+
+function textResponse(res, content) {
+	content = String(content);
+	res.setHeader("Content-Type", "text/plain");
+	res.setHeader("Content-Length", content.length);
+	res.end(content);
+}
+
+function fileExists(filename) {
+	try {
+		fs.statSync(filename);
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+
+if (process.env.PASSENGER_BASE_URI) {
+	app.use(process.env.PASSENGER_BASE_URI, app.router);
+}
+
+app.all('/', function(req, res) {
+	if (fileExists("front_page.txt")) {
+		textResponse(res, fs.readFileSync("front_page.txt"));
+	} else {
+		textResponse(res, "front page");
+	}
+});
+
+app.all('/parameters', function(req, res) {
+	bodyParser(req, res, function() {
+		var first = req.query.first || req.body.first;
+		var second = req.query.second || req.body.second;
+		textResponse(res, "Method: " + req.method + "\n" +
+			"First: " + first + "\n" +
+			"Second: " + second + "\n")
+	});
+});
+
+app.all('/chunked', function(req, res) {
+	res.setHeader("Content-Type", "text/plain");
+	res.setHeader("Transfer-Encoding", "chunked");
+	res.write("chunk1\n");
+	res.write("chunk2\n");
+	res.write("chunk3\n");
+	res.end();
+});
+
+app.all('/pid', function(req, res) {
+	textResponse(res, process.pid);
+});
+
+app.all(/^\/env/, function(req, res) {
+	var body = '';
+	var keys = [];
+	for (var key in req.cgiHeaders) {
+		keys.push(key);
+	}
+	keys.sort();
+	for (var i = 0; i < keys.length; i++) {
+		var val = req.cgiHeaders[keys[i]];
+		if (val === undefined) {
+			val = '';
+		}
+		body += keys[i] + " = " + val + "\n";
+	}
+	textResponse(res, body);
+});
+
+app.all('/touch_file', function(req, res) {
+	bodyParser(req, res, function() {
+		var filename = req.query.file || req.body.file;
+		fs.writeFileSync(filename, "");
+		textResponse(res, "ok")
+	});
+});
+
+app.all('/extra_header', function(req, res) {
+	res.setHeader("Content-Type", "text/html");
+	res.setHeader("Content-Length", "2");
+	res.setHeader("X-Foo", "Bar");
+	res.end("ok");
+});
+
+app.all('/cached', function(req, res) {
+	textResponse(res, "This is the uncached version of /cached");
+});
+
+app.all('/upload_with_params', function(req, res) {
+	bodyParser(req, res, function() {
+		var name1 = req.query.name1 || req.body.name1;
+		var name2 = req.query.name2 || req.body.name2;
+		var data = fs.readFileSync(req.files.data.path);
+		var body =
+			"name 1 = " + name1 + "\n" +
+			"name 2 = " + name2 + "\n" +
+			"data = ";
+		var bodyBuffer = new Buffer(body);
+		res.setHeader("Content-Type", "text/plain");
+		res.setHeader("Content-Length", bodyBuffer.length + data.length);
+		res.write(bodyBuffer);
+		res.write(data);
+		res.end();
+	});
+});
+
+app.all('/raw_upload_to_file', function(req, res) {
+	var filename = req.headers['x-output'];
+	var stream = fs.createWriteStream(filename);
+	req.on('data', function(data) {
+		stream.write(data);
+	});
+	req.on('end', function() {
+		stream.end(function() {
+			textResponse(res, "ok");
+		});
+	});
+});
+
+app.listen(3000);

data/test/stub/rack/config.ru

@@ -75,6 +75,25 @@ app = lambda do |env|
 		sleep 0.1  # Give HelperAgent the time to process stdout first.
 		STDERR.puts "hello stderr!"
 		text_response("ok")
+	when '/switch_protocol'
+		if env['HTTP_UPGRADE'] != 'raw' || env['HTTP_CONNECTION'].downcase != 'upgrade'
+			return [500, { "Content-Type" => "text/plain" }, ["Invalid headers"]]
+		end
+		env['rack.hijack'].call
+		io = env['rack.hijack_io']
+		begin
+			io.write("Status: 101 Switching Protocols\r\n")
+			io.write("Upgrade: raw\r\n")
+			io.write("Connection: Upgrade\r\n")
+			io.write("\r\n")
+			while !io.eof?
+				line = io.readline
+				io.write("Echo: #{line}")
+				io.flush
+			end
+		ensure
+			io.close
+		end
 	else
 		[404, { "Content-Type" => "text/plain" }, ["Unknown URI"]]
 	end

data/test/stub/wsgi/passenger_wsgi.py

@@ -1,4 +1,4 @@
-import os, time, cgi
+import os, sys, time, cgi
 
 def file_exist(filename):
 	try:
@@ -7,6 +7,19 @@ def file_exist(filename):
 	except OSError:
 		return False
 
+if sys.version_info[0] >= 3:
+	def bytes_to_str(b):
+		return b.decode()
+
+	def str_to_bytes(s):
+		return s.encode('latin-1')
+else:
+	def bytes_to_str(b):
+		return b
+
+	def str_to_bytes(s):
+		return s
+
 def application(env, start_response):
 	status = '200 OK'
 	body   = None
@@ -131,6 +144,29 @@ def application(env, start_response):
 	elif path == '/oobw':
 		start_response(status, [('Content-Type', 'text/plain'), ('X-Passenger-Request-OOB-Work', 'true')])
 		return [str(os.getpid())]
+	elif path == '/switch_protocol':
+		if env['HTTP_UPGRADE'] != 'raw' or env['HTTP_CONNECTION'].lower() != 'upgrade':
+			status = '500 Internal Server Error'
+			body = str('Invalid headers')
+			start_response(status, [('Content-Type', 'text/plain'), ('Content-Length', len(body))])
+			return [body]
+		socket = env['passenger.hijack']()
+		io = socket.makefile()
+		socket.close()
+		try:
+			io.write(
+				b"HTTP/1.1 101 Switching Protocols\r\n" +
+				b"Upgrade: raw\r\n" +
+				b"Connection: Upgrade\r\n" +
+				b"\r\n")
+			io.flush()
+			line = io.readline()
+			while line != "":
+				io.write("Echo: " + line)
+				io.flush()
+				line = io.readline()
+		finally:
+			io.close()
 	else:
 		status = "404 Not Found"
 		body = "Unknown URI"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: passenger
 version: !ruby/object:Gem::Version
-  version: 4.0.36
+  version: 4.0.37
 platform: ruby
 authors:
 - Phusion - http://www.phusion.nl/
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-24 00:00:00.000000000 Z
+date: 2014-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -2363,6 +2363,7 @@ files:
 - lib/phusion_passenger/common_library.rb
 - lib/phusion_passenger/config/about_command.rb
 - lib/phusion_passenger/config/command.rb
+- lib/phusion_passenger/config/detach_process_command.rb
 - lib/phusion_passenger/config/main.rb
 - lib/phusion_passenger/config/restart_app_command.rb
 - lib/phusion_passenger/config/utils.rb
@@ -2590,6 +2591,9 @@ files:
 - test/stub/nginx/mime.types
 - test/stub/nginx/nginx.conf.erb
 - test/stub/nginx/win-utf
+- test/stub/node/app.js
+- test/stub/node/public/.gitignore
+- test/stub/node/tmp/.gitignore
 - test/stub/rack/config.ru
 - test/stub/rack/public/.gitignore
 - test/stub/rack/start.rb