passenger 3.0.8 → 3.0.9

data/lib/phusion_passenger/app_process.rb

@@ -70,7 +70,7 @@ class AppProcess
 			return nil
 		end
 		
-		search_results = Gem.cache.search(Gem::Dependency.new('rails', gem_version_spec), true)
+		search_results = search_gem('rails', gem_version_spec)
 		found_version = search_results.map do |x|
 			x.version.version
 		end.sort.last
@@ -79,7 +79,7 @@ class AppProcess
 			# date because the Rails version may have been installed now.
 			# So we reload the RubyGems cache and try again.
 			Gem.clear_paths
-			search_results = Gem.cache.search(Gem::Dependency.new('rails', gem_version_spec), true)
+			search_results = search_gem('rails', gem_version_spec)
 			found_version = search_results.map do |x|
 				x.version.version
 			end.sort.last
@@ -94,6 +94,18 @@ class AppProcess
 		end
 	end
 	
+	def self.search_gem(gem_name, gem_version_spec)
+		if defined?(Gem::Specification) && Gem::Specification.respond_to?(:find_all_by_name)
+			return Gem::Specification.find_all_by_name(gem_name, gem_version_spec)
+		elsif Gem.respond_to?(:source_index)
+			dep = Gem::Dependency.new(gem_name, gem_version_spec)
+			return Gem.source_index.search(dep, true)
+		else
+			dep = Gem::Dependency.new(gem_name, gem_version_spec)
+			return Gem.cache.search(dep, true)
+		end
+	end
+	
 	# Construct an AppProcess by reading information from the given MessageChannel.
 	# The other side of the channel must be writing AppProcess information using
 	# AppProcess#write_to_channel.

data/test/cxx/CxxTestMain.cpp

@@ -98,25 +98,20 @@ main(int argc, char *argv[]) {
 	allGroups = tut::runner.get().list_groups();
 	parseOptions(argc, argv);
 	
-	try {
-		bool all_ok = true;
-		if (runMode == RUN_ALL_GROUPS) {
-			tut::runner.get().run_tests();
-			all_ok = reporter.all_ok();
-		} else {
-			all_ok = true;
-			for (groupnames_iterator it = groupsToRun.begin(); it != groupsToRun.end(); it++) {
-				tut::runner.get().run_tests(*it);
-				all_ok = all_ok && reporter.all_ok();
-			}
+	bool all_ok = true;
+	if (runMode == RUN_ALL_GROUPS) {
+		tut::runner.get().run_tests();
+		all_ok = reporter.all_ok();
+	} else {
+		all_ok = true;
+		for (groupnames_iterator it = groupsToRun.begin(); it != groupsToRun.end(); it++) {
+			tut::runner.get().run_tests(*it);
+			all_ok = all_ok && reporter.all_ok();
 		}
-		if (all_ok) {
-			return 0;
-		} else {
-			return 1;
-		}
-	} catch (const std::exception &ex) {
-		cerr << "*** Exception raised: " << ex.what() << endl;
-		return 2;
+	}
+	if (all_ok) {
+		return 0;
+	} else {
+		return 1;
 	}
 }

data/test/cxx/IOUtilsTest.cpp

@@ -1,5 +1,6 @@
 #include "TestSupport.h"
-#include "Utils/IOUtils.h"
+#include <Utils/IOUtils.h>
+#include <Utils/SystemTime.h>
 #include <oxt/system_calls.hpp>
 #include <boost/bind.hpp>
 #include <sys/types.h>
@@ -54,23 +55,6 @@ namespace tut {
 			return p;
 		}
 		
-		void writeUntilFull(int fd) {
-			char buf[1024 * 4];
-			memset(buf, 0, sizeof(buf));
-			bool done = false;
-			while (!done) {
-				ssize_t ret = write(fd, buf, sizeof(buf));
-				if (ret == -1) {
-					if (errno == EAGAIN) {
-						done = true;
-					} else {
-						int e = errno;
-						throw SystemException("Cannot write to pipe", e);
-					}
-				}
-			}
-		}
-		
 		static void writeDataAfterSomeTime(int fd, unsigned int sleepTimeInUsec) {
 			try {
 				syscalls::usleep(sleepTimeInUsec);
@@ -485,6 +469,25 @@ namespace tut {
 		ensure_equals(writevData, "hellomyworld!!");
 	}
 	
+	TEST_METHOD(45) {
+		// Test writev() timeout support.
+		setWritevFunction(NULL);
+		Pipe p = createPipe();
+		unsigned long long startTime = SystemTime::getUsec();
+		unsigned long long timeout = 30000;
+		try {
+			StaticString data[] = { "hello", "world" };
+			for (int i = 0; i < 1024 * 1024; i++) {
+				gatheredWrite(p[1], data, 2, &timeout);
+			}
+			fail("TimeoutException expected");
+		} catch (const TimeoutException &) {
+			unsigned long long elapsed = SystemTime::getUsec() - startTime;
+			ensure("30 msec have passed", elapsed >= 29000 && elapsed <= 45000);
+			ensure(timeout <= 2000);
+		}
+	}
+	
 	/***** Test waitUntilReadable() *****/
 	
 	TEST_METHOD(50) {
@@ -793,4 +796,51 @@ namespace tut {
 			// Pass.
 		}
 	}
+	
+	/***** Test readFileDescriptor() and writeFileDescriptor() *****/
+	
+	TEST_METHOD(80) {
+		// Test whether it works.
+		SocketPair sockets = createUnixSocketPair();
+		Pipe pipes = createPipe();
+		writeFileDescriptor(sockets[0], pipes[1]);
+		FileDescriptor fd = readFileDescriptor(sockets[1]);
+		writeExact(fd, "hello");
+		char buf[6];
+		ensure_equals(readExact(pipes[0], buf, 5), 5u);
+		buf[5] = '\0';
+		ensure_equals(StaticString(buf), "hello");
+	}
+	
+	TEST_METHOD(81) {
+		// Test whether timeout works.
+		SocketPair sockets = createUnixSocketPair();
+		Pipe pipes = createPipe();
+		
+		unsigned long long timeout = 30000;
+		unsigned long long startTime = SystemTime::getUsec();
+		try {
+			FileDescriptor fd = readFileDescriptor(sockets[0], &timeout);
+			fail("TimeoutException expected");
+		} catch (const TimeoutException &) {
+			unsigned long long elapsed = SystemTime::getUsec() - startTime;
+			ensure("readFileDescriptor() timed out after 30 msec",
+				elapsed >= 29000 && elapsed <= 45000);
+			ensure(timeout <= 2000);
+		}
+		
+		writeUntilFull(sockets[0]);
+		
+		startTime = SystemTime::getUsec();
+		timeout = 30000;
+		try {
+			writeFileDescriptor(sockets[0], pipes[0], &timeout);
+			fail("TimeoutException expected");
+		} catch (const TimeoutException &) {
+			unsigned long long elapsed = SystemTime::getUsec() - startTime;
+			ensure("writeFileDescriptor() timed out after 30 msec",
+				elapsed >= 29000 && elapsed <= 45000);
+			ensure(timeout <= 2000);
+		}
+	}
 }

data/test/cxx/LoggingTest.cpp

@@ -152,7 +152,7 @@ namespace tut {
 			log->getGroupName(), log->getCategory());
 		log2->message("message 2");
 		log2->flushToDiskAfterClose(true);
-
+		
 		log.reset();
 		log2.reset();
 		
@@ -268,24 +268,6 @@ namespace tut {
 		ensure_equals(data, "localhost");
 	}
 	
-	TEST_METHOD(10) {
-		// newTransaction() reestablishes the connection to the logging
-		// server if the logging server crashed and was restarted
-		SystemTime::forceAll(TODAY);
-		
-		logger->newTransaction("foobar");
-		stopLoggingServer();
-		startLoggingServer();
-		
-		AnalyticsLogPtr log = logger->newTransaction("foobar");
-		log->message("hello");
-		log->flushToDiskAfterClose(true);
-		log.reset();
-		
-		string data = readAll(loggingDir + "/1/" FOOBAR_LOCALHOST_PREFIX "/requests/2010/01/13/12/log.txt");
-		ensure("(1)", data.find("hello\n") != string::npos);
-	}
-	
 	TEST_METHOD(11) {
 		// newTransaction() does not reconnect to the server for a short
 		// period of time if connecting failed
@@ -305,22 +287,36 @@ namespace tut {
 	}
 	
 	TEST_METHOD(12) {
-		// continueTransaction() reestablishes the connection to the logging
-		// server if the logging server crashed and was restarted
+		// If the logging server crashed and was restarted then
+		// newTransaction() and continueTransaction() print a warning and return
+		// a null log object. One of the next newTransaction()/continueTransaction()
+		// calls will reestablish the connection when the connection timeout
+		// has passed.
 		SystemTime::forceAll(TODAY);
+		AnalyticsLogPtr log, log2;
 		
-		AnalyticsLogPtr log = logger->newTransaction("foobar");
+		log = logger->newTransaction("foobar");
 		logger2->continueTransaction(log->getTxnId(), "foobar");
 		stopLoggingServer();
 		startLoggingServer();
 		
-		AnalyticsLogPtr log2 = logger2->continueTransaction(log->getTxnId(), "foobar");
+		log = logger->newTransaction("foobar");
+		ensure("(1)", log->isNull());
+		log2 = logger2->continueTransaction("some-id", "foobar");
+		ensure("(2)", log2->isNull());
+		
+		SystemTime::forceAll(TODAY + 60000000);
+		log = logger->newTransaction("foobar");
+		ensure("(3)", !log->isNull());
+		log2 = logger2->continueTransaction(log->getTxnId(), "foobar");
+		ensure("(4)", !log2->isNull());
 		log2->message("hello");
 		log2->flushToDiskAfterClose(true);
+		log.reset();
 		log2.reset();
 		
 		string data = readAll(loggingDir + "/1/" FOOBAR_LOCALHOST_PREFIX "/requests/2010/01/13/12/log.txt");
-		ensure("(1)", data.find("hello\n") != string::npos);
+		ensure("(5)", data.find("hello\n") != string::npos);
 	}
 	
 	TEST_METHOD(13) {

data/test/cxx/MessageChannelTest.cpp

@@ -458,7 +458,7 @@ namespace tut {
 			fail("TimeoutException expected");
 		} catch (const TimeoutException &) {
 			unsigned long long elapsed = timer.elapsed();
-			ensure("Spent at least 35 msec waiting", elapsed >= 35);
+			ensure("Spent at least 35 msec waiting", elapsed >= 34);
 			ensure("Spent at most 60 msec waiting", elapsed <= 60);
 			ensure("The passed time is deducted from timeout", timeout < 5);
 		}

data/test/cxx/MessageIOTest.cpp

@@ -0,0 +1,310 @@
+#include "TestSupport.h"
+#include <Utils/IOUtils.h>
+#include <Utils/MessageIO.h>
+#include <Utils/SystemTime.h>
+
+using namespace Passenger;
+using namespace std;
+using namespace boost;
+
+namespace tut {
+	struct MessageIOTest {
+		Pipe pipes;
+		
+		MessageIOTest() {
+			pipes = createPipe();
+		}
+	};
+
+	DEFINE_TEST_GROUP(MessageIOTest);
+	
+	/***** Test readUint16() and writeUint16() *****/
+	
+	TEST_METHOD(1) {
+		// They work.
+		writeUint16(pipes[1], 0x3F56);
+		writeUint16(pipes[1], 0x3F57);
+		writeUint16(pipes[1], 0x3F58);
+		
+		unsigned char buf[2];
+		ensure_equals(readExact(pipes[0], buf, 2), 2u);
+		ensure_equals(buf[0], 0x3F);
+		ensure_equals(buf[1], 0x56);
+		
+		ensure_equals(readUint16(pipes[0]), 0x3F57u);
+		
+		uint16_t out;
+		ensure(readUint16(pipes[0], out));
+		ensure_equals(out, 0x3F58);
+	}
+	
+	TEST_METHOD(2) {
+		// readUint16() throws EOFException on premature EOF.
+		writeExact(pipes[1], "x", 1);
+		pipes[1].close();
+		try {
+			readUint16(pipes[0]);
+			fail("EOFException expected");
+		} catch (const EOFException &) {
+		}
+	}
+	
+	TEST_METHOD(3) {
+		// readUint16(uint32_t &) returns false EOFException on premature EOF.
+		writeExact(pipes[1], "x", 1);
+		pipes[1].close();
+		uint16_t out;
+		ensure(!readUint16(pipes[0], out));
+	}
+	
+	TEST_METHOD(4) {
+		// Test timeout.
+		unsigned long long timeout = 30000;
+		unsigned long long startTime = SystemTime::getUsec();
+		try {
+			readUint16(pipes[0], &timeout);
+			fail("TimeoutException expected");
+		} catch (const TimeoutException &) {
+			unsigned long long elapsed = SystemTime::getUsec() - startTime;
+			ensure("About 30 ms elapsed (1)", elapsed >= 29000 && elapsed <= 50000);
+			ensure("Time is correctly deducted from 'timeout' (1)", timeout <= 2000);
+		}
+		
+		writeUntilFull(pipes[1]);
+		
+		timeout = 30000;
+		startTime = SystemTime::getUsec();
+		try {
+			writeUint16(pipes[1], 0x12, &timeout);
+			fail("TimeoutException expected");
+		} catch (const TimeoutException &) {
+			unsigned long long elapsed = SystemTime::getUsec() - startTime;
+			ensure("About 30 ms elapsed (3)", elapsed >= 29000 && elapsed <= 50000);
+			ensure("Time is correctly deducted from 'timeout' (4)", timeout <= 2000);
+		}
+	}
+	
+	/***** Test readUint32() and writeUint32() *****/
+	
+	TEST_METHOD(10) {
+		// They work.
+		writeUint32(pipes[1], 0x12343F56);
+		writeUint32(pipes[1], 0x12343F57);
+		writeUint32(pipes[1], 0x12343F58);
+		
+		unsigned char buf[4];
+		ensure_equals(readExact(pipes[0], buf, 4), 4u);
+		ensure_equals(buf[0], 0x12);
+		ensure_equals(buf[1], 0x34);
+		ensure_equals(buf[2], 0x3F);
+		ensure_equals(buf[3], 0x56);
+		
+		ensure_equals(readUint32(pipes[0]), 0x12343F57u);
+		
+		uint32_t out;
+		ensure(readUint32(pipes[0], out));
+		ensure_equals(out, 0x12343F58u);
+	}
+	
+	TEST_METHOD(11) {
+		// readUint32() throws EOFException on premature EOF.
+		writeExact(pipes[1], "xyz", 3);
+		pipes[1].close();
+		try {
+			readUint32(pipes[0]);
+			fail("EOFException expected");
+		} catch (const EOFException &) {
+		}
+	}
+	
+	TEST_METHOD(12) {
+		// readUint16(uint32_t &) returns false EOFException on premature EOF.
+		writeExact(pipes[1], "xyz", 3);
+		pipes[1].close();
+		uint32_t out;
+		ensure(!readUint32(pipes[0], out));
+	}
+	
+	TEST_METHOD(13) {
+		// Test timeout.
+		unsigned long long timeout = 30000;
+		unsigned long long startTime = SystemTime::getUsec();
+		try {
+			readUint32(pipes[0], &timeout);
+			fail("TimeoutException expected");
+		} catch (const TimeoutException &) {
+			unsigned long long elapsed = SystemTime::getUsec() - startTime;
+			ensure(elapsed >= 29000 && elapsed <= 50000);
+			ensure(timeout <= 2000);
+		}
+		
+		writeUntilFull(pipes[1]);
+		
+		timeout = 30000;
+		startTime = SystemTime::getUsec();
+		try {
+			writeUint32(pipes[1], 0x1234, &timeout);
+			fail("TimeoutException expected");
+		} catch (const TimeoutException &) {
+			unsigned long long elapsed = SystemTime::getUsec() - startTime;
+			ensure(elapsed >= 29000 && elapsed <= 50000);
+			ensure(timeout <= 2000);
+		}
+	}
+	
+	/***** Test readArrayMessage() and writeArrayMessage() *****/
+	
+	TEST_METHOD(20) {
+		// They work.
+		writeArrayMessage(pipes[1], "ab", "cd", "efg", NULL);
+		writeArrayMessage(pipes[1], "ab", "cd", "efh", NULL);
+		
+		unsigned char buf[12];
+		readExact(pipes[0], buf, 12);
+		ensure_equals(buf[0], 0u);
+		ensure_equals(buf[1], 10u);
+		ensure_equals(buf[2], 'a');
+		ensure_equals(buf[3], 'b');
+		ensure_equals(buf[4], '\0');
+		ensure_equals(buf[5], 'c');
+		ensure_equals(buf[6], 'd');
+		ensure_equals(buf[7], '\0');
+		ensure_equals(buf[8], 'e');
+		ensure_equals(buf[9], 'f');
+		ensure_equals(buf[10], 'g');
+		ensure_equals(buf[11], '\0');
+		
+		vector<string> args = readArrayMessage(pipes[0]);
+		ensure_equals(args.size(), 3u);
+		ensure_equals(args[0], "ab");
+		ensure_equals(args[1], "cd");
+		ensure_equals(args[2], "efh");
+	}
+	
+	TEST_METHOD(21) {
+		// readArrayMessage() throws EOFException on premature EOF.
+		writeExact(pipes[1], "\x00");
+		pipes[1].close();
+		try {
+			readArrayMessage(pipes[0]);
+			fail("EOFException expected (1)");
+		} catch (const EOFException &) {
+		}
+		
+		pipes = createPipe();
+		writeExact(pipes[1], "\x00\x04a\x00b");
+		pipes[1].close();
+		try {
+			readArrayMessage(pipes[0]);
+			fail("EOFException expected (2)");
+		} catch (const EOFException &) {
+		}
+	}
+	
+	TEST_METHOD(22) {
+		// Test timeout.
+		unsigned long long timeout = 30000;
+		unsigned long long startTime = SystemTime::getUsec();
+		try {
+			readArrayMessage(pipes[0], &timeout);
+			fail("TimeoutException expected (1)");
+		} catch (const TimeoutException &) {
+			unsigned long long elapsed = SystemTime::getUsec() - startTime;
+			ensure(elapsed >= 29000 && elapsed <= 50000);
+			ensure(timeout <= 2000);
+		}
+		
+		writeUntilFull(pipes[1]);
+		
+		timeout = 30000;
+		startTime = SystemTime::getUsec();
+		try {
+			writeArrayMessage(pipes[1], &timeout, "hi", "ho", NULL);
+			fail("TimeoutException expected (2)");
+		} catch (const TimeoutException &) {
+			unsigned long long elapsed = SystemTime::getUsec() - startTime;
+			ensure(elapsed >= 29000 && elapsed <= 50000);
+			ensure(timeout <= 2000);
+		}
+	}
+	
+	/***** Test readArrayMessage() and writeArrayMessage() *****/
+	
+	TEST_METHOD(30) {
+		// They work.
+		writeScalarMessage(pipes[1], "hello");
+		writeScalarMessage(pipes[1], "world");
+		
+		unsigned char buf[4 + 5];
+		readExact(pipes[0], buf, 4 + 5);
+		ensure_equals(buf[0], 0u);
+		ensure_equals(buf[1], 0u);
+		ensure_equals(buf[2], 0u);
+		ensure_equals(buf[3], 5u);
+		ensure_equals(buf[4], 'h');
+		ensure_equals(buf[5], 'e');
+		ensure_equals(buf[6], 'l');
+		ensure_equals(buf[7], 'l');
+		ensure_equals(buf[8], 'o');
+		
+		ensure_equals(readScalarMessage(pipes[0]), "world");
+	}
+	
+	TEST_METHOD(31) {
+		// readScalarMessage() throws EOFException on premature EOF.
+		writeExact(pipes[1], StaticString("\x00", 1));
+		pipes[1].close();
+		try {
+			readScalarMessage(pipes[0]);
+			fail("EOFException expected (1)");
+		} catch (const EOFException &) {
+		}
+		
+		pipes = createPipe();
+		writeExact(pipes[1], StaticString("\x00\x00\x00\x04" "abc", 4 + 3));
+		pipes[1].close();
+		try {
+			readScalarMessage(pipes[0]);
+			fail("EOFException expected (2)");
+		} catch (const EOFException &) {
+		}
+	}
+	
+	TEST_METHOD(32) {
+		// readScalarMessage() throws SecurityException if the
+		// body larger than the limit
+		writeExact(pipes[1], StaticString("\x00\x00\x00\x05", 4));
+		try {
+			readScalarMessage(pipes[0], 4);
+			fail("SecurityException expected (1)");
+		} catch (const SecurityException &) {
+		}
+	}
+	
+	TEST_METHOD(33) {
+		// Test timeout.
+		unsigned long long timeout = 30000;
+		unsigned long long startTime = SystemTime::getUsec();
+		try {
+			readScalarMessage(pipes[0], 0, &timeout);
+			fail("TimeoutException expected (1)");
+		} catch (const TimeoutException &) {
+			unsigned long long elapsed = SystemTime::getUsec() - startTime;
+			ensure(elapsed >= 29000 && elapsed <= 50000);
+			ensure(timeout <= 2000);
+		}
+		
+		writeUntilFull(pipes[1]);
+		
+		timeout = 30000;
+		startTime = SystemTime::getUsec();
+		try {
+			writeScalarMessage(pipes[1], "hello", &timeout);
+			fail("TimeoutException expected (2)");
+		} catch (const TimeoutException &) {
+			unsigned long long elapsed = SystemTime::getUsec() - startTime;
+			ensure(elapsed >= 29000 && elapsed <= 50000);
+			ensure(timeout <= 2000);
+		}
+	}
+}