passenger 4.0.27 → 4.0.28

data/lib/phusion_passenger/platform_info/cxx_portability.rb

@@ -153,6 +153,8 @@ private
 		flags << "-DPASSENGER_DEBUG -DBOOST_DISABLE_ASSERTS"
 
 		if cc_or_cxx == :cxx
+			flags << cxx_11_flag if cxx_11_flag
+
 			# There are too many implementations of of the hash map!
 			# Figure out the right one.
 			check_unordered_map(flags, "std::unordered_map", "unordered_map", "HAS_UNORDERED_MAP") ||

data/node_lib/phusion_passenger/httplib_emulation.js

@@ -81,15 +81,13 @@ function createIncomingMessage(headers, socket, bodyBegin) {
 	message.url    = headers['REQUEST_URI'];
 	message.connection.remoteAddress = headers['REMOTE_ADDR'];
 	message.connection.remotePort = parseInt(headers['REMOTE_PORT']);
+	message._mayHaveRequestBody = mayHaveRequestBody(headers);
+	message._emitEndEvent = IncomingMessage_emitEndEvent;
+	resetIncomingMessageOverridedMethods(message);
 
-	function onSocketData(chunk) {
-		message.emit('data', chunk);
-	}
-
-	function onSocketEnd() {
-		message.emit('end');
-	}
-
+	socket.on('end', function() {
+		message._emitEndEvent();
+	});
 	socket.on('drain', function() {
 		message.emit('drain');
 	});
@@ -104,23 +102,93 @@ function createIncomingMessage(headers, socket, bodyBegin) {
 	 * to have a request body. For compatibility reasons we implement the
 	 * same behavior as Node's HTTP parser.
 	 */
-	if (mayHaveRequestBody(headers)) {
-		socket.on('data', onSocketData);
-		socket.on('end', onSocketEnd);
+	if (message._mayHaveRequestBody) {
 		if (bodyBegin.length > 0) {
-			process.nextTick(function() {
-				// TODO: we should check here whether the socket hasn't already been closed
-				socket.emit('data', bodyBegin);
-			});
+			message.push(bodyBegin);
+		}
+		socket.ondata = function(buffer, offset, end) {
+			if (!message.push(buffer.slice(offset, end))) {
+				socket._handle.readStop();
+			}
 		}
 	} else {
-		// TODO: we should check in the next tick whether the socket hasn't already been closed
-		process.nextTick(onSocketEnd);
+		message.push(null);
 	}
 
 	return message;
 }
 
+function IncomingMessage_pause() {
+	this._flowing = false;
+	this._orig_pause();
+	resetIncomingMessageOverridedMethods(this);
+}
+
+function IncomingMessage_resume() {
+	this._flowing = true;
+	this._orig_resume();
+	resetIncomingMessageOverridedMethods(this);
+}
+
+function IncomingMessage_on(event, listener) {
+	if (event == 'data') {
+		this._flowing = true;
+		installDataEventHandler(this);
+	} else if (event == 'readable') {
+		installReadableEventHandler(this);
+	}
+	this._orig_on.call(this, event, listener);
+	resetIncomingMessageOverridedMethods(this);
+}
+
+function IncomingMessage_emitEndEvent() {
+	if (!this._readableState.endEmitted) {
+		this._readableState.endEmitted = true;
+		this.emit('end');
+	}
+}
+
+/*
+ * Calling on(), pause() etc on the message object may cause our overrided
+ * methods to be set to something else. This is probably becaused by the code
+ * in Node.js responsible for switching a stream to flowing mode, e.g.
+ * emitDataEvents() in _stream_readable.js. Thus, this function
+ * should be called from on(), pause() etc.
+ */
+function resetIncomingMessageOverridedMethods(message) {
+	if (message.pause !== IncomingMessage_pause) {
+		message._orig_pause = message.pause;
+		message.pause = IncomingMessage_pause;
+	}
+	if (message.resume !== IncomingMessage_resume) {
+		message._orig_resume = message.resume;
+		message.resume = IncomingMessage_resume;
+	}
+	if (message.on !== IncomingMessage_on) {
+		message._orig_on = message.on;
+		message.on = IncomingMessage_on;
+		message.addListener = IncomingMessage_on;
+	}
+}
+
+function installDataEventHandler(message) {
+	if (!message._dataEventHandlerInstalled) {
+		message._dataEventHandlerInstalled = true;
+		message.socket.on('data', function(chunk) {
+			message.emit('data', chunk);
+		});
+	}
+}
+
+function installReadableEventHandler(message) {
+	if (!message._readableEventHandlerInstalled) {
+		message._readableEventHandlerInstalled = true;
+		message.socket.on('readable', function() {
+			message.emit('readable');
+		});
+	}
+}
+
 function createServerResponse(req) {
 	var res = new http.ServerResponse(req);
 	res.assignSocket(req.socket);

data/node_lib/phusion_passenger/request_handler.js

@@ -36,12 +36,20 @@ function RequestHandler(readyCallback, clientCallback) {
 		var state = 'PARSING_HEADER';
 		var parser = new SessionProtocolParser();
 
+		function handleReadable() {
+			// read(n) returns null unless the buffer is at least n bytes.
+			// We just want to read whatever we can we poke into its buffer.
+			// Hope they don't change the this.
+			var len = socket._readableState.length;
+			handleData(socket.read(len));
+		}
+
 		function handleData(data) {
 			if (state == 'PARSING_HEADER') {
 				var consumed = parser.feed(data);
 				if (parser.state == SessionProtocolParser.SPP_DONE) {
 					state = 'HEADER_SEEN';
-					socket.removeListener('data', handleData);
+					socket.removeListener('readable', handleReadable);
 					PhusionPassenger.emit('request', parser, socket, data.slice(consumed));
 				} else if (parser.state == SessionProtocolParser.SPP_ERROR) {
 					console.error('Header parse error');
@@ -52,7 +60,7 @@ function RequestHandler(readyCallback, clientCallback) {
 			}
 		}
 
-		socket.on('data', handleData);
+		socket.on('readable', handleReadable);
 	}
 
 	var server = net.createServer({ allowHalfOpen: true }, handleNewClient);

data/rpm/Vagrantfile

@@ -0,0 +1,32 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# This Vagrantfile sets up a CentOS VM, for the purpose of RPM development.
+
+ROOT = File.expand_path(File.dirname(__FILE__) + "/..")
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  config.vm.box = "centos-6.4-x86_64"
+  config.vm.box_url = "http://developer.nrel.gov/downloads/vagrant-boxes/CentOS-6.4-x86_64-v20130731.box"
+  config.vm.synced_folder ROOT, "/vagrant"
+  config.ssh.forward_agent = true
+
+  config.vm.provider :vmware_fusion do |f, override|
+    override.vm.box_url = "https://dl.dropbox.com/u/5721940/vagrant-boxes/vagrant-centos-6.4-x86_64-vmware_fusion.box"
+  end
+
+  pkg_cmd = %Q{
+    rpm -Uvh http://mirror.overthewire.com.au/pub/epel/6/i386/epel-release-6-8.noarch.rpm &&
+    yum update -y &&
+    yum install -y @development-tools fedora-packager git sudo nano &&
+    yum install -y gcc gcc-c++ ccache curl-devel openssl-devel zlib-devel &&
+    yum install -y ruby ruby-devel rubygems rubygem-rake httpd httpd-devel apr-devel apr-util-devel &&
+    usermod -a -G mock vagrant &&
+    sed -i 's/Defaults    requiretty//' /etc/sudoers &&
+    sudo -u vagrant -H rpmdev-setuptree
+  }
+  config.vm.provision :shell, :inline => pkg_cmd
+end

data/rpm/get_distro_id.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+vars = { 'config_opts': {} }
+execfile("/etc/mock/default.cfg", vars)
+print(vars['config_opts']['dist'])

data/test/cxx/ApplicationPool2/DirectSpawnerTest.cpp

@@ -22,10 +22,12 @@ namespace tut {
 			PipeWatcher::onData = PipeWatcher::DataCallback();
 			gatherOutput = boost::bind(&ApplicationPool2_DirectSpawnerTest::_gatherOutput, this, _1, _2);
 			setLogLevel(LVL_ERROR); // TODO: change to LVL_WARN
+			setPrintAppOutputAsDebuggingMessages(true);
 		}
 
 		~ApplicationPool2_DirectSpawnerTest() {
 			setLogLevel(DEFAULT_LOG_LEVEL);
+			setPrintAppOutputAsDebuggingMessages(false);
 			unlink("stub/wsgi/passenger_wsgi.pyc");
 			PipeWatcher::onData = PipeWatcher::DataCallback();
 		}
@@ -63,7 +65,6 @@ namespace tut {
 		options.startTimeout = 300;
 		
 		DirectSpawner spawner(bg.safe, *resourceLocator, generation);
-		spawner.getConfig()->forwardStderr = false;
 		
 		try {
 			process = spawner.spawn(options);
@@ -86,7 +87,6 @@ namespace tut {
 		options.startupFile  = ".";
 		
 		DirectSpawner spawner(bg.safe, *resourceLocator, generation);
-		spawner.getConfig()->forwardStderr = false;
 		
 		try {
 			process = spawner.spawn(options);

data/test/cxx/ApplicationPool2/PoolTest.cpp

@@ -37,11 +37,12 @@ namespace tut {
 			spawnerConfig = boost::make_shared<SpawnerConfig>();
 			spawnerFactory = boost::make_shared<SpawnerFactory>(bg.safe, *resourceLocator,
 				generation, spawnerConfig);
-			pool = boost::make_shared<Pool>(bg.safe.get(), spawnerFactory);
+			pool = boost::make_shared<Pool>(spawnerFactory);
 			pool->initialize();
 			bg.start();
 			callback = boost::bind(&ApplicationPool2_PoolTest::_callback, this, _1, _2);
 			setLogLevel(LVL_ERROR); // TODO: change to LVL_WARN
+			setPrintAppOutputAsDebuggingMessages(true);
 		}
 		
 		~ApplicationPool2_PoolTest() {
@@ -55,6 +56,7 @@ namespace tut {
 			UPDATE_TRACE_POINT();
 			pool.reset();
 			setLogLevel(DEFAULT_LOG_LEVEL);
+			setPrintAppOutputAsDebuggingMessages(false);
 			SystemTime::releaseAll();
 		}
 
@@ -468,7 +470,7 @@ namespace tut {
 			pool->superGroups.get("test")->groups[0]->getWaitlist.size(), 1u);
 		
 		// Close an existing session so that one process is no
-		// longer at full capacity.
+		// longer at full utilization.
 		sessions[0].reset();
 		ensure_equals("The get request has been removed from the wait list",
 			pool->superGroups.get("test")->groups[0]->getWaitlist.size(), 0u);
@@ -476,11 +478,11 @@ namespace tut {
 	}
 	
 	TEST_METHOD(10) {
-		// If multiple matching processes exist, and all of them are at full capacity,
+		// If multiple matching processes exist, and all of them are at full utilization,
 		// and a new process may be spawned,
 		// then asyncGet() will put the action on the group's wait queue and spawn the
 		// new process.
-		// The process that first becomes not at full capacity
+		// The process that first becomes not at full utilization
 		// or the newly spawned process
 		// will process the action, whichever is earlier.
 		// Here we test the case where an existing process is earlier.
@@ -1316,7 +1318,6 @@ namespace tut {
 		options.appRoot = "tmp.wsgi";
 		options.appType = "wsgi";
 		options.spawnMethod = "direct";
-		spawnerConfig->forwardStderr = false;
 
 		writeFile("tmp.wsgi/passenger_wsgi.py",
 			"import sys\n"
@@ -1342,7 +1343,6 @@ namespace tut {
 		options.appType = "wsgi";
 		options.spawnMethod = "direct";
 		options.minProcesses = 4;
-		spawnerConfig->forwardStderr = false;
 
 		writeFile("tmp.wsgi/counter", "0");
 		chmod("tmp.wsgi/counter", 0666);
@@ -1547,7 +1547,6 @@ namespace tut {
 		options.appRoot = "tmp.wsgi";
 		options.appType = "wsgi";
 		options.spawnMethod = "direct";
-		spawnerConfig->forwardStderr = false;
 		pool->setMax(1);
 
 		writeFile("tmp.wsgi/passenger_wsgi.py",
@@ -1598,7 +1597,6 @@ namespace tut {
 		options.appType = "wsgi";
 		options.spawnMethod = "direct";
 		options.minProcesses = 2;
-		spawnerConfig->forwardStderr = false;
 
 		// Spawn 2 processes.
 		retainSessions = true;
@@ -1722,6 +1720,59 @@ namespace tut {
 		debug->debugger->recv("Restarting aborted");
 	}
 
+	TEST_METHOD(79) {
+		// Test sticky sessions.
+		
+		// Spawn 2 processes and get their sticky session IDs and PIDs.
+		ensureMinProcesses(2);
+		Options options = createOptions();
+		SessionPtr session1 = pool->get(options, &ticket);
+		SessionPtr session2 = pool->get(options, &ticket);
+		int id1 = session1->getStickySessionId();
+		int id2 = session2->getStickySessionId();
+		pid_t pid1 = session1->getPid();
+		pid_t pid2 = session2->getPid();
+		session1.reset();
+		session2.reset();
+
+		// Make two requests with id1 as sticky session ID. They should
+		// both go to process pid1.
+		options.stickySessionId = id1;
+		session1 = pool->get(options, &ticket);
+		ensure_equals("Request 1.1 goes to process 1", session1->getPid(), pid1);
+		// The second request should be queued, and should not finish until
+		// the first request is finished.
+		ensure_equals(number, 1);
+		pool->asyncGet(options, callback);
+		SHOULD_NEVER_HAPPEN(100,
+			result = number > 1;
+		);
+		session1.reset();
+		EVENTUALLY(1,
+			result = number == 2;
+		);
+		ensure_equals("Request 1.2 goes to process 1", currentSession->getPid(), pid1);
+		currentSession.reset();
+
+		// Make two requests with id2 as sticky session ID. They should
+		// both go to process pid2.
+		options.stickySessionId = id2;
+		session1 = pool->get(options, &ticket);
+		ensure_equals("Request 2.1 goes to process 2", session1->getPid(), pid2);
+		// The second request should be queued, and should not finish until
+		// the first request is finished.
+		pool->asyncGet(options, callback);
+		SHOULD_NEVER_HAPPEN(100,
+			result = number > 2;
+		);
+		session1.reset();
+		EVENTUALLY(1,
+			result = number == 3;
+		);
+		ensure_equals("Request 2.2 goes to process 2", currentSession->getPid(), pid2);
+		currentSession.reset();
+	}
+
 	// TODO: Persistent connections.
 	// TODO: If one closes the session before it has reached EOF, and process's maximum concurrency
 	//       has already been reached, then the pool should ping the process so that it can detect
@@ -1730,7 +1781,7 @@ namespace tut {
 	
 	/*********** Test previously discovered bugs ***********/
 	
-	TEST_METHOD(79) {
+	TEST_METHOD(85) {
 		// Test detaching, then restarting. This should not violate any invariants.
 		TempDirCopy dir("stub/wsgi", "tmp.wsgi");
 		Options options = createOptions();

data/test/cxx/ApplicationPool2/SmartSpawnerTest.cpp

@@ -27,10 +27,12 @@ namespace tut {
 			PipeWatcher::onData = PipeWatcher::DataCallback();
 			gatherOutput = boost::bind(&ApplicationPool2_SmartSpawnerTest::_gatherOutput, this, _1, _2);
 			setLogLevel(LVL_ERROR); // TODO: should be LVL_WARN
+			setPrintAppOutputAsDebuggingMessages(true);
 		}
 		
 		~ApplicationPool2_SmartSpawnerTest() {
 			setLogLevel(DEFAULT_LOG_LEVEL);
+			setPrintAppOutputAsDebuggingMessages(false);
 			unlink("stub/wsgi/passenger_wsgi.pyc");
 			PipeWatcher::onData = PipeWatcher::DataCallback();
 		}
@@ -128,8 +130,6 @@ namespace tut {
 			generation,
 			preloaderCommand,
 			options);
-		spawner.getConfig()->forwardStdout = false;
-		spawner.getConfig()->forwardStderr = false;
 		
 		try {
 			process = spawner.spawn(options);
@@ -160,8 +160,6 @@ namespace tut {
 			generation,
 			preloaderCommand,
 			options);
-		spawner.getConfig()->forwardStdout = false;
-		spawner.getConfig()->forwardStderr = false;
 		
 		try {
 			process = spawner.spawn(options);
@@ -192,8 +190,6 @@ namespace tut {
 			generation,
 			preloaderCommand,
 			options);
-		spawner.getConfig()->forwardStdout = false;
-		spawner.getConfig()->forwardStderr = false;
 		
 		try {
 			process = spawner.spawn(options);

data/test/cxx/CachedFileStatTest.cpp

@@ -393,10 +393,10 @@ namespace tut {
 		stat.stat("test4.txt", &buf, 1);
 		stat.stat("test5.txt", &buf, 1);
 		stat.setMaxSize(2);
-		ensure(!stat.knows("test.txt"));
-		ensure(!stat.knows("test2.txt"));
-		ensure(!stat.knows("test3.txt"));
-		ensure(stat.knows("test4.txt"));
-		ensure(stat.knows("test5.txt"));
+		ensure("(1)", !stat.knows("test.txt"));
+		ensure("(2)", !stat.knows("test2.txt"));
+		ensure("(3)", !stat.knows("test3.txt"));
+		ensure("(4)", stat.knows("test4.txt"));
+		ensure("(5)", stat.knows("test5.txt"));
 	}
 }

data/test/cxx/RequestHandlerTest.cpp

@@ -42,12 +42,13 @@ namespace tut {
 		RequestHandlerTest() {
 			createServerInstanceDirAndGeneration(serverInstanceDir, generation);
 			spawnerFactory = boost::make_shared<SpawnerFactory>(bg.safe, *resourceLocator, generation);
-			pool = boost::make_shared<Pool>(bg.safe.get(), spawnerFactory);
+			pool = boost::make_shared<Pool>(spawnerFactory);
 			pool->initialize();
 			serverFilename = generation->getPath() + "/server";
 			requestSocket = createUnixServer(serverFilename);
 			setNonBlocking(requestSocket);
 			setLogLevel(LVL_ERROR); // TODO: set to LVL_WARN
+			setPrintAppOutputAsDebuggingMessages(true);
 
 			agentOptions.passengerRoot = resourceLocator->getRoot();
 			agentOptions.defaultUser   = testConfig["default_user"].asString();
@@ -63,6 +64,7 @@ namespace tut {
 		
 		~RequestHandlerTest() {
 			setLogLevel(DEFAULT_LOG_LEVEL);
+			setPrintAppOutputAsDebuggingMessages(false);
 			if (bg.isStarted()) {
 				bg.safe->runSync(boost::bind(&RequestHandlerTest::destroy, this));
 			} else {
@@ -332,7 +334,6 @@ namespace tut {
 			"STDERR.puts 'I have failed'");
 
 		setLogLevel(-2);
-		spawnerFactory->getConfig()->forwardStderr = false;
 		init();
 		connect();
 		sendHeaders(defaultHeaders,
@@ -357,7 +358,6 @@ namespace tut {
 			"STDERR.puts 'I have failed'\n");
 
 		setLogLevel(-2);
-		spawnerFactory->getConfig()->forwardStderr = false;
 		init();
 		connect();
 		sendHeaders(defaultHeaders,
@@ -380,7 +380,6 @@ namespace tut {
 		writeFile("tmp.handler/start.rb", "");
 
 		setLogLevel(-2);
-		spawnerFactory->getConfig()->forwardStderr = false;
 		init();
 		connect();
 		sendHeaders(defaultHeaders,
@@ -408,7 +407,6 @@ namespace tut {
 			"STDERR.puts 'I have failed'");
 
 		setLogLevel(-2);
-		spawnerFactory->getConfig()->forwardStderr = false;
 		init();
 		connect();
 		sendHeaders(defaultHeaders,
@@ -434,7 +432,6 @@ namespace tut {
 			"STDERR.puts 'I have failed'\n");
 
 		setLogLevel(-2);
-		spawnerFactory->getConfig()->forwardStderr = false;
 		init();
 		connect();
 		sendHeaders(defaultHeaders,