passenger 3.0.0 → 3.0.1

data/test/cxx/EventedClientTest.cpp

@@ -4,9 +4,6 @@
 #include "Utils/IOUtils.h"
 
 #include <oxt/thread.hpp>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/un.h>
 
 using namespace Passenger;
 using namespace std;
@@ -19,21 +16,23 @@ namespace tut {
 		ev::dynamic_loop eventLoop;
 		ev::async exitWatcher;
 		oxt::thread *thr;
+		string lastErrorMessage;
+		int lastErrorCode;
 		AtomicInt integer;
+		string data;
 		
 		EventedClientTest()
 			: exitWatcher(eventLoop)
 		{
-			int fds[2];
-			
-			socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
-			fd1 = fds[0];
-			fd2 = fds[1];
+			SocketPair sockets = createUnixSocketPair();
+			fd1 = sockets.first;
+			fd2 = sockets.second;
 			setNonBlocking(fd2);
 			
 			exitWatcher.set<EventedClientTest, &EventedClientTest::unloop>(this);
 			exitWatcher.start();
 			thr = NULL;
+			lastErrorCode = -1;
 		}
 		
 		~EventedClientTest() {
@@ -49,6 +48,12 @@ namespace tut {
 		void stopEventLoop() {
 			if (thr != NULL) {
 				exitWatcher.send();
+				waitUntilEventLoopExits();
+			}
+		}
+		
+		void waitUntilEventLoopExits() {
+			if (thr != NULL) {
 				thr->join();
 				delete thr;
 				thr = NULL;
@@ -72,6 +77,28 @@ namespace tut {
 			EventedClientTest *test = (EventedClientTest *) client->userData;
 			test->integer = 2;
 		}
+		
+		static void saveSystemError(EventedClient *client, const string &message, int code) {
+			EventedClientTest *self = (EventedClientTest *) client->userData;
+			self->lastErrorMessage = message;
+			self->lastErrorCode = code;
+		}
+		
+		static void exitEventLoop(EventedClient *client) {
+			EventedClientTest *self = (EventedClientTest *) client->userData;
+			self->eventLoop.unloop();
+		}
+		
+		static void readAndExitOnEof(EventedClient *client) {
+			EventedClientTest *self = (EventedClientTest *) client->userData;
+			char buf[1024];
+			ssize_t ret = read(client->fd, buf, sizeof(buf));
+			if (ret <= 0) {
+				self->eventLoop.unloop();
+			} else {
+				self->data.append(buf, ret);
+			}
+		}
 	};
 
 	DEFINE_TEST_GROUP(EventedClientTest);
@@ -128,7 +155,7 @@ namespace tut {
 		
 		char buf[100];
 		memset(buf, 0, sizeof(buf));
-		ensure(MessageChannel(fd1).readRaw(buf, strlen("hello world")));
+		ensure(readExact(fd1, buf, strlen("hello world")));
 		ensure_equals(string(buf), "hello world");
 	}
 	
@@ -154,7 +181,7 @@ namespace tut {
 		
 		char buf[str.size()];
 		memset(buf, 0, sizeof(buf));
-		ensure(MessageChannel(fd1).readRaw(buf, str.size()));
+		ensure(readExact(fd1, buf, str.size()));
 		ensure(memcmp(buf, str.c_str(), str.size()) == 0);
 	}
 	
@@ -182,7 +209,7 @@ namespace tut {
 		
 		char buf[str.size()];
 		memset(buf, 0, sizeof(buf));
-		ensure(MessageChannel(fd1).readRaw(buf, str.size()));
+		ensure(readExact(fd1, buf, str.size()));
 		ensure(memcmp(buf, str.c_str(), str.size()) == 0);
 		
 		// readWatcher will become active again after all pending data has been sent.
@@ -238,7 +265,7 @@ namespace tut {
 		);
 		
 		memset(buf, 0, sizeof(buf));
-		ensure(MessageChannel(fd1).readRaw(buf, str.size() - 1));
+		ensure(readExact(fd1, buf, str.size() - 1));
 		ensure(memcmp(buf, str.c_str() + 1, str.size() - 1) == 0);
 		
 		ensure_equals(read(fd1, buf, 1), (ssize_t) 0);
@@ -378,9 +405,119 @@ namespace tut {
 		EVENT_LOOP_GUARD;
 		
 		char buf[str.size()];
-		MessageChannel(fd1).readRaw(buf, str.size());
+		readExact(fd1, buf, str.size());
 		EVENTUALLY(2,
 			result = integer == 2;
 		);
 	}
+	
+	TEST_METHOD(17) {
+		// EventedClient.write() ensures that the given data is written
+		// after what's already in the outbox.
+		EventedClient client(eventLoop, fd2);
+		string header(1024 * 4, 'x');
+		string body(1024 * 128, 'y');
+		char buf[header.size() + body.size() + 1024];
+		
+		client.write(header);
+		client.write(body);
+		ensure(client.pendingWrites() > 0);
+		
+		ensure_equals(readExact(fd1, buf, header.size()), (unsigned int) header.size());
+		ensure_equals(StaticString(buf, header.size()), header);
+		
+		client.write("hello world");
+		
+		startEventLoop();
+		EVENT_LOOP_GUARD;
+		
+		unsigned int len = body.size() + strlen("hello world");
+		ensure_equals(readExact(fd1, buf, len), len);
+		ensure_equals(StaticString(buf, len), body + "hello world");
+	}
+	
+	TEST_METHOD(18) {
+		// If writeErrorAction is DISCONNECT_FULL then
+		// EventedClient.write(), upon encountering a write error,
+		// will forcefully disconnect the connection.
+		EventedClient client(eventLoop, fd2);
+		client.userData = this;
+		client.writeErrorAction = EventedClient::DISCONNECT_FULL;
+		client.onSystemError = saveSystemError;
+		fd1.close();
+		client.write("hello");
+		ensure_equals(lastErrorCode, EPIPE);
+		ensure_equals(client.fd, -1);
+	}
+	
+	TEST_METHOD(19) {
+		// If writeErrorAction is DISCONNECT_FULL then
+		// the background writer disconnects the connection
+		// on write error.
+		EventedClient client(eventLoop, fd2);
+		client.userData = this;
+		client.writeErrorAction = EventedClient::DISCONNECT_FULL;
+		client.onSystemError = saveSystemError;
+		
+		string str(1024 * 128, 'x');
+		client.write(str);
+		ensure(client.pendingWrites() > 0);
+		
+		fd1.close();
+		client.onDisconnect = exitEventLoop;
+		startEventLoop();
+		waitUntilEventLoopExits();
+		
+		ensure_equals(lastErrorCode, EPIPE);
+		ensure_equals(client.fd, -1);
+	}
+	
+	TEST_METHOD(20) {
+		// If writeErrorAction is DISCONNECT_WRITE then
+		// EventedClient.write(), upon encountering a write error,
+		// will forcefully disconnect the writer side of the
+		// connection but continue allowing reading.
+		EventedClient client(eventLoop, fd2);
+		client.userData = this;
+		client.writeErrorAction = EventedClient::DISCONNECT_WRITE;
+		client.onSystemError = saveSystemError;
+		client.onReadable = readAndExitOnEof;
+		client.notifyReads(true);
+		
+		writeExact(fd1, "world", 5);
+		fd1.close();
+		client.write("hello");
+		
+		startEventLoop();
+		waitUntilEventLoopExits();
+		
+		ensure(client.fd != -1);
+		ensure_equals(data, "world");
+	}
+	
+	TEST_METHOD(21) {
+		// If writeErrorAction is DISCONNECT_WRITE then
+		// the background writer, upon encountering a write error,
+		// will forcefully disconnect the writer side of the
+		// connection but continue allowing reading.
+		EventedClient client(eventLoop, fd2);
+		client.userData = this;
+		client.writeErrorAction = EventedClient::DISCONNECT_WRITE;
+		client.onSystemError = saveSystemError;
+		client.onReadable = readAndExitOnEof;
+		client.notifyReads(true);
+		
+		string str(1024 * 128, 'x');
+		client.write(str);
+		ensure(client.pendingWrites() > 0);
+		
+		writeExact(fd1, "world", 5);
+		fd1.close();
+		
+		startEventLoop();
+		waitUntilEventLoopExits();
+		
+		ensure(client.fd != -1);
+		ensure_equals(data, "world");
+	}
 }

data/test/cxx/IOUtilsTest.cpp

@@ -1,11 +1,15 @@
 #include "TestSupport.h"
 #include "Utils/IOUtils.h"
+#include <oxt/system_calls.hpp>
+#include <boost/bind.hpp>
 #include <sys/types.h>
 #include <cerrno>
 #include <string>
 
 using namespace Passenger;
 using namespace std;
+using namespace boost;
+using namespace oxt;
 
 namespace tut {
 	static ssize_t writevResult;
@@ -43,9 +47,94 @@ namespace tut {
 		~IOUtilsTest() {
 			setWritevFunction(NULL);
 		}
+		
+		Pipe createNonBlockingPipe() {
+			Pipe p = createPipe();
+			setNonBlocking(p.second);
+			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);
+				syscalls::write(fd, "hi", 2);
+			} catch (const boost::thread_interrupted &) {
+				// Do nothing.
+			}
+		}
+		
+		static void writeDataSlowly(int fd, unsigned int bytesToWrite, unsigned int bytesPerSec) {
+			try {
+				for (unsigned i = 0; i < bytesToWrite && !this_thread::interruption_requested(); i++) {
+					syscalls::write(fd, "x", 1);
+					syscalls::usleep(1000000 / bytesPerSec);
+				}
+			} catch (const boost::thread_interrupted &) {
+				// Do nothing.
+			}
+		}
+		
+		static void readDataAfterSomeTime(int fd, unsigned int sleepTimeInUsec) {
+			try {
+				char buf[1024 * 8];
+				syscalls::usleep(sleepTimeInUsec);
+				syscalls::read(fd, buf, sizeof(buf));
+			} catch (const boost::thread_interrupted &) {
+				// Do nothing.
+			}
+		}
+		
+		static void readDataSlowly(int fd, int bytesToRead, int bytesPerSec) {
+			try {
+				unsigned long long start = SystemTime::getUsec();
+				unsigned long long deadline = start +
+					(bytesToRead * 1000000.0 / bytesPerSec);
+				int alreadyRead = 0;
+				
+				while (alreadyRead < bytesToRead && !this_thread::interruption_requested()) {
+					unsigned long long elapsed = SystemTime::getUsec();
+					double progress = (elapsed - start) / (double) (deadline - start);
+					int shouldHaveRead = progress * bytesToRead;
+					int shouldNowRead = shouldHaveRead - alreadyRead;
+					
+					if (shouldNowRead > 0) {
+						char *buf = new char[shouldNowRead];
+						ssize_t ret = syscalls::read(fd, buf, shouldNowRead);
+						int e = errno;
+						delete buf;
+						if (ret == -1) {
+							throw SystemException("read error", e);
+						} else if (ret == 0) {
+							break;
+						}
+						alreadyRead += ret;
+					}
+					syscalls::usleep(1000);
+				}
+			} catch (const boost::thread_interrupted &) {
+				// Do nothing.
+			}
+		}
 	};
 	
-	DEFINE_TEST_GROUP(IOUtilsTest);
+	DEFINE_TEST_GROUP_WITH_LIMIT(IOUtilsTest, 100);
 	
 	/***** Test gatheredWrite() with empty input rest buffer *****/
 	
@@ -395,4 +484,313 @@ namespace tut {
 		ensure_equals(writevCalled, 4);
 		ensure_equals(writevData, "hellomyworld!!");
 	}
+	
+	/***** Test waitUntilReadable() *****/
+	
+	TEST_METHOD(50) {
+		// waitUntilReadable() waits for the specified timeout if no data is readable.
+		Pipe p = createPipe();
+		unsigned long long timeout = 25000;
+		ensure("No data is available", !waitUntilReadable(p.first, &timeout));
+		ensure("The passed time is deducted from the timeout", timeout < 5000);
+	}
+	
+	TEST_METHOD(51) {
+		// waitUntilReadable() waits for less than the specified timeout if data
+		// is not available immediately but still available before the timeout.
+		Pipe p = createPipe();
+		TempThread thr(boost::bind(&writeDataAfterSomeTime, p.second, 35000));
+		
+		unsigned long long timeout = 1000000;
+		ensure("Data is available", waitUntilReadable(p.first, &timeout));
+		ensure("At least 35 msec passed.", timeout <= 1000000 - 35000);
+		ensure("At most 70 msec passed.", timeout >= 1000000 - 70000);  // depends on system scheduler though
+	}
+	
+	TEST_METHOD(52) {
+		// waitUntilReadable() returns immediately if timeout is 0.
+		Pipe p = createPipe();
+		unsigned long long timeout = 0;
+		ensure("No data is available", !waitUntilReadable(p.first, &timeout));
+		ensure_equals("Timeout is not modified", timeout, 0u);
+		
+		write(p.second, "hi", 2);
+		ensure("Data is available", waitUntilReadable(p.first, &timeout));
+		ensure_equals("Timeout is not modified", timeout, 0u);
+	}
+	
+	TEST_METHOD(53) {
+		// waitUntilReadable() returns immediately if there's data immediately available.
+		Pipe p = createPipe();
+		unsigned long long timeout = 100000;
+		write(p.second, "hi", 2);
+		ensure("Data is available", waitUntilReadable(p.first, &timeout));
+		ensure("Timeout is not modified", timeout >= 100000 - 5000);
+	}
+	
+	/***** Test readExact() *****/
+	
+	TEST_METHOD(54) {
+		// readExact() throws TimeoutException if no data is received within the timeout.
+		Pipe p = createPipe();
+		unsigned long long timeout = 50000;
+		char buf;
+		try {
+			readExact(p.first, &buf, 1, &timeout);
+			fail("No TimeoutException thrown.");
+		} catch (const TimeoutException &) {
+			ensure("The passed time is deducted from timeout", timeout < 5000);
+		}
+	}
+	
+	TEST_METHOD(55) {
+		// readExact() throws TimeoutException if not enough data is received within the timeout.
+		Pipe p = createPipe();
+		unsigned long long timeout = 20000;
+		char buf[100];
+		
+		TempThread thr(boost::bind(&writeDataSlowly, p.second, sizeof(buf), 1));
+		
+		try {
+			readExact(p.first, &buf, sizeof(buf), &timeout);
+			fail("No TimeoutException thrown.");
+		} catch (const TimeoutException &) {
+			ensure("The passed time is deducted from timeout", timeout < 5000);
+		}
+	}
+	
+	TEST_METHOD(56) {
+		// readExact() throws TimeoutException if timeout is 0 and no data is immediately available.
+		Pipe p = createPipe();
+		unsigned long long timeout = 0;
+		char buf;
+		try {
+			readExact(p.first, &buf, 1, &timeout);
+			fail("No TimeoutException thrown.");
+		} catch (const TimeoutException &) {
+			ensure_equals("Timeout unchanged", timeout, 0u);
+		}
+	}
+	
+	TEST_METHOD(57) {
+		// readExact() throws TimeoutException if timeout is 0 and not enough data is
+		// immediately available.
+		Pipe p = createPipe();
+		unsigned long long timeout = 0;
+		write(p.second, "hi", 2);
+		try {
+			char buf[100];
+			readExact(p.first, &buf, sizeof(buf), &timeout);
+			fail("No TimeoutException thrown.");
+		} catch (const TimeoutException &) {
+			ensure_equals("Timeout is unchanged", timeout, 0u);
+		}
+	}
+	
+	TEST_METHOD(58) {
+		// readExact() deducts the amount of time spent on waiting from the timeout variable.
+		Pipe p = createPipe();
+		unsigned long long timeout = 60000;
+		char buf[3];
+		
+		// Spawn a thread that writes 100 bytes per second, i.e. each byte takes 10 msec.
+		TempThread thr(boost::bind(&writeDataSlowly, p.second, 1000, 100));
+		
+		// We read 3 bytes.
+		ensure_equals(readExact(p.first, &buf, sizeof(buf), &timeout), 3u);
+		ensure("Should have taken at least 20 msec", timeout <= 60000 - 20000);
+		ensure("Should have taken at most 40 msec", timeout >= 60000 - 40000);
+	}
+	
+	TEST_METHOD(59) {
+		// readExact() does not wait and does not modify the timeout variable if there's
+		// immediately enough data available.
+		Pipe p = createPipe();
+		unsigned long long timeout = 100000;
+		char buf[2];
+		
+		write(p.second, "hi", 2);
+		ensure_equals(readExact(p.first, &buf, 2, &timeout), 2u);
+		ensure("Timeout not modified", timeout >= 95000);
+	}
+	
+	/***** Test waitUntilWritable() *****/
+	
+	TEST_METHOD(60) {
+		// waitUntilWritable() waits for the specified timeout if no data is writable.
+		Pipe p = createNonBlockingPipe();
+		writeUntilFull(p.second);
+		unsigned long long timeout = 25000;
+		ensure("Socket did not become writable", !waitUntilWritable(p.second, &timeout));
+		ensure("The passed time is deducted from the timeout", timeout < 5000);
+	}
+	
+	TEST_METHOD(61) {
+		// waitUntilWritable() waits for less than the specified timeout if the fd
+		// is not immediately writable but still writable before the timeout.
+		Pipe p = createNonBlockingPipe();
+		writeUntilFull(p.second);
+		TempThread thr(boost::bind(&readDataAfterSomeTime, p.first, 35000));
+		
+		unsigned long long timeout = 1000000;
+		ensure("Socket became writable", waitUntilWritable(p.second, &timeout));
+		ensure("At least 35 msec passed.", timeout <= 1000000 - 35000);
+		ensure("At most 70 msec passed.", timeout >= 1000000 - 70000);  // depends on system scheduler though
+	}
+	
+	TEST_METHOD(62) {
+		// waitUntilWritable() returns immediately if timeout is 0.
+		Pipe p = createNonBlockingPipe();
+		writeUntilFull(p.second);
+		unsigned long long timeout = 0;
+		ensure("Socket is not writable", !waitUntilWritable(p.second, &timeout));
+		ensure_equals("Timeout is not modified", timeout, 0u);
+		
+		char buf[1024 * 8];
+		read(p.first, buf, sizeof(buf));
+		ensure("Socket became writable", waitUntilWritable(p.second, &timeout));
+		ensure_equals("Timeout is not modified", timeout, 0u);
+	}
+	
+	TEST_METHOD(63) {
+		// waitUntilWritable() returns immediately if the fd is immediately writable.
+		Pipe p = createNonBlockingPipe();
+		writeUntilFull(p.second);
+		unsigned long long timeout = 100000;
+		char buf[1024 * 8];
+		read(p.first, buf, sizeof(buf));
+		ensure("Socket became writable", waitUntilWritable(p.second, &timeout));
+		ensure("Timeout is not modified", timeout >= 100000 - 5000);
+	}
+	
+	/***** Test readExact() *****/
+	
+	TEST_METHOD(64) {
+		// writeExact() throws TimeoutException if fd does not become writable within the timeout.
+		Pipe p = createNonBlockingPipe();
+		writeUntilFull(p.second);
+		unsigned long long timeout = 50000;
+		try {
+			writeExact(p.second, "x", 1, &timeout);
+			fail("No TimeoutException thrown.");
+		} catch (const TimeoutException &) {
+			ensure("The passed time is deducted from timeout", timeout < 5000);
+		}
+	}
+	
+	TEST_METHOD(65) {
+		// writeExact() throws TimeoutException if not enough data is written within the timeout.
+		Pipe p = createNonBlockingPipe();
+		writeUntilFull(p.second);
+		unsigned long long timeout = 20000;
+		char buf[1024 * 3];
+		
+		TempThread thr(boost::bind(&readDataSlowly, p.first, sizeof(buf), 512));
+		
+		try {
+			writeExact(p.second, "x", 1, &timeout);
+			fail("No TimeoutException thrown.");
+		} catch (const TimeoutException &) {
+			ensure("The passed time is deducted from timeout", timeout < 5000);
+		}
+	}
+	
+	TEST_METHOD(66) {
+		// writeExact() throws TimeoutException if timeout is 0 and the fd is not immediately writable.
+		Pipe p = createNonBlockingPipe();
+		writeUntilFull(p.second);
+		unsigned long long timeout = 0;
+		try {
+			writeExact(p.second, "x", 1, &timeout);
+			fail("No TimeoutException thrown.");
+		} catch (const TimeoutException &) {
+			ensure_equals("Timeout unchanged", timeout, 0u);
+		}
+	}
+	
+	TEST_METHOD(67) {
+		// writeExact() throws TimeoutException if timeout is 0 not enough data could be written immediately.
+		Pipe p = createNonBlockingPipe();
+		writeUntilFull(p.second);
+		unsigned long long timeout = 0;
+		
+		char buf[1024];
+		read(p.first, buf, sizeof(buf));
+		
+		char buf2[1024 * 8];
+		memset(buf2, 0, sizeof(buf2));
+		
+		try {
+			writeExact(p.second, buf2, sizeof(buf2), &timeout);
+			fail("No TimeoutException thrown.");
+		} catch (const TimeoutException &) {
+			ensure_equals("Timeout is unchanged", timeout, 0u);
+		}
+	}
+	
+	TEST_METHOD(68) {
+		// readExact() deducts the amount of time spent on waiting from the timeout variable.
+		Pipe p = createNonBlockingPipe();
+		unsigned long long timeout = 60000;
+		
+		// Spawn a thread that reads 200000 bytes in 35 msec.
+		TempThread thr(boost::bind(&readDataSlowly, p.first, 5714286, 5714286));
+		
+		// We write 200000 bytes.
+		char buf[200000];
+		writeExact(p.second, &buf, sizeof(buf), &timeout);
+		ensure("Should have taken at least 20 msec", timeout <= 60000 - 20000);
+		ensure("Should have taken at most 40 msec", timeout >= 60000 - 40000);
+	}
+	
+	TEST_METHOD(69) {
+		// writeExact() does not wait and does not modify the timeout variable if
+		// all data can be written immediately.
+		Pipe p = createNonBlockingPipe();
+		unsigned long long timeout = 100000;
+		char buf[1024];
+		writeExact(p.second, buf, sizeof(buf), &timeout);
+		ensure("Timeout not modified", timeout >= 95000);
+	}
+	
+	/***** Test getSocketAddressType() *****/
+	
+	TEST_METHOD(70) {
+		ensure_equals(getSocketAddressType(""), SAT_UNKNOWN);
+		ensure_equals(getSocketAddressType("/foo.socket"), SAT_UNKNOWN);
+		ensure_equals(getSocketAddressType("unix:"), SAT_UNKNOWN);
+		ensure_equals(getSocketAddressType("unix:/"), SAT_UNIX);
+		ensure_equals(getSocketAddressType("unix:/foo.socket"), SAT_UNIX);
+		ensure_equals(getSocketAddressType("tcp:"), SAT_UNKNOWN);
+		ensure_equals(getSocketAddressType("tcp://"), SAT_UNKNOWN);
+		// Doesn't check whether it contains port
+		ensure_equals(getSocketAddressType("tcp://127.0.0.1"), SAT_TCP);
+		ensure_equals(getSocketAddressType("tcp://127.0.0.1:80"), SAT_TCP);
+	}
+	
+	TEST_METHOD(71) {
+		ensure_equals(parseUnixSocketAddress("unix:/foo.socket"), "/foo.socket");
+		try {
+			parseUnixSocketAddress("unix:");
+			fail("ArgumentException expected");
+		} catch (const ArgumentException &e) {
+			// Pass.
+		}
+	}
+	
+	TEST_METHOD(72) {
+		string host;
+		unsigned short port;
+		
+		parseTcpSocketAddress("tcp://127.0.0.1:80", host, port);
+		ensure_equals(host, "127.0.0.1");
+		ensure_equals(port, 80);
+		
+		try {
+			parseTcpSocketAddress("tcp://", host, port);
+			fail("ArgumentException expected");
+		} catch (const ArgumentException &e) {
+			// Pass.
+		}
+	}
 }