rockdog-passenger 0.0.1

data/test/CxxTestMain.cpp

@@ -0,0 +1,25 @@
+#include "tut.h"
+#include "tut_reporter.h"
+#include <apr_general.h>
+#include <signal.h>
+#include <cstdlib>
+
+namespace tut {
+	test_runner_singleton runner;
+}
+
+int main() {
+	apr_initialize();
+	tut::reporter reporter;
+	tut::runner.get().set_callback(&reporter);
+	signal(SIGPIPE, SIG_IGN);
+	setenv("RAILS_ENV", "production", 1);
+	setenv("TESTING_PASSENGER", "1", 1);
+	try {
+		tut::runner.get().run_tests();
+	} catch (const std::exception &ex) {
+		std::cerr << "Exception raised: " << ex.what() << std::endl;
+		return 1;
+	}
+	return 0;
+}

data/test/MessageChannelTest.cpp

@@ -0,0 +1,312 @@
+#include "tut.h"
+#include "MessageChannel.h"
+
+#include <cstring>
+#include <cstdio>
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+using namespace Passenger;
+using namespace std;
+
+namespace tut {
+	struct MessageChannelTest {
+		MessageChannel reader, writer;
+		int p[2];
+
+		MessageChannelTest() {
+			if (pipe(p) != 0) {
+				throw SystemException("Cannot create a pipe", errno);
+			}
+			reader = MessageChannel(p[0]);
+			writer = MessageChannel(p[1]);
+		}
+		
+		~MessageChannelTest() {
+			close(p[0]);
+			close(p[1]);
+		}
+	};
+
+	DEFINE_TEST_GROUP(MessageChannelTest);
+
+	TEST_METHOD(1) {
+		// read() should be able to parse a message constructed by write(name, ...).
+		vector<string> args;
+		
+		writer.write("hello", "world", "!", NULL);
+		ensure("End of file has not been reached", reader.read(args));
+		ensure_equals("read() returns the same number of arguments as passed to write()", args.size(), 3u);
+		ensure_equals(args[0], "hello");
+		ensure_equals(args[1], "world");
+		ensure_equals(args[2], "!");
+	}
+	
+	TEST_METHOD(2) {
+		// read() should be able to parse a message constructed by write(list).
+		list<string> input;
+		vector<string> output;
+		
+		input.push_back("hello");
+		input.push_back("world");
+		input.push_back("!");
+		writer.write(input);
+		ensure("End of file has not been reached", reader.read(output));
+		ensure_equals("read() returns the same number of arguments as passed to write()", input.size(), output.size());
+		
+		list<string>::const_iterator it;
+		vector<string>::const_iterator it2;
+		for (it = input.begin(), it2 = output.begin(); it != input.end(); it++, it2++) {
+			ensure_equals(*it, *it2);
+		}
+	}
+	
+	TEST_METHOD(3) {
+		// write() should be able to properly serialize arguments that contain whitespace.
+		vector<string> args;
+		writer.write("hello", "world with whitespaces", "!!!", NULL);
+		ensure("End of file has not been reached", reader.read(args));
+		ensure_equals(args[1], "world with whitespaces");
+	}
+	
+	TEST_METHOD(4) {
+		// read() should be able to read messages constructed by the Ruby implementation.
+		// write() should be able to construct messages that can be read by the Ruby implementation.
+		// Multiple read() and write() calls should work (i.e. the MessageChannel should have stream properties).
+		// End of file should be properly detected.
+		int p1[2], p2[2];
+		pid_t pid;
+		
+		pipe(p1);
+		pipe(p2);
+		pid = fork();
+		if (pid == 0) {
+			close(p[0]);
+			close(p[1]);
+			dup2(p1[0], 0);
+			dup2(p2[1], 1);
+			close(p1[0]);
+			close(p1[1]);
+			close(p2[0]);
+			close(p2[1]);
+			execlp("ruby", "ruby", "./stub/message_channel.rb", (char *) 0);
+			perror("Cannot execute ruby");
+			_exit(1);
+		} else {
+			MessageChannel input(p1[1]);
+			MessageChannel output(p2[0]);
+			close(p1[0]);
+			close(p2[1]);
+			
+			input.write("hello", "my beautiful", "world", NULL);
+			input.write("you have", "not enough", "minerals", NULL);
+			input.close();
+			
+			vector<string> message1, message2, message3;
+			ensure("End of stream has not been reached (1)", output.read(message1));
+			ensure("End of stream has not been reached (2)", output.read(message2));
+			ensure("End of file has been reached", !output.read(message3));
+			output.close();
+			waitpid(pid, NULL, 0);
+			
+			ensure_equals("First message is correctly transformed by the mock object",
+				message1.size(), 4u);
+			ensure_equals(message1[0], "hello");
+			ensure_equals(message1[1], "my beautiful");
+			ensure_equals(message1[2], "world");
+			ensure_equals(message1[3], "!!");
+			
+			ensure_equals("Second message is correctly transformed by the mock object",
+				message2.size(), 4u);
+			ensure_equals(message2[0], "you have");
+			ensure_equals(message2[1], "not enough");
+			ensure_equals(message2[2], "minerals");
+			ensure_equals(message2[3], "??");
+		}
+	}
+	
+	TEST_METHOD(6) {
+		// write(name) should generate a correct message even if there are no additional arguments.
+		writer.write("hello", NULL);
+		vector<string> args;
+		reader.read(args);
+		ensure_equals(args.size(), 1u);
+		ensure_equals(args[0], "hello");
+	}
+	
+	TEST_METHOD(7) {
+		// writeFileDescriptor() and receiveFileDescriptor() should work.
+		int s[2], my_pipe[2], fd;
+		socketpair(AF_UNIX, SOCK_STREAM, 0, s);
+		MessageChannel channel1(s[0]);
+		MessageChannel channel2(s[1]);
+		
+		pipe(my_pipe);
+		channel1.writeFileDescriptor(my_pipe[1]);
+		fd = channel2.readFileDescriptor();
+		
+		char buf[5];
+		write(fd, "hello", 5);
+		close(fd);
+		read(my_pipe[0], buf, 5);
+		ensure(memcmp(buf, "hello", 5) == 0);
+		
+		close(s[0]);
+		close(s[1]);
+		close(my_pipe[0]);
+		close(my_pipe[1]);
+	}
+	
+	TEST_METHOD(8) {
+		// write() should be able to construct a message that consists of only an empty string.
+		// read() should be able to read a message that consists of only an empty string.
+		vector<string> args;
+		
+		writer.write("", NULL);
+		reader.read(args);
+		ensure_equals(args.size(), 1u);
+		ensure_equals(args[0], "");
+	}
+	
+	TEST_METHOD(9) {
+		// readScalar() should be able to read messages constructed by writeScalar().
+		// This also tests readRaw()/writeRaw() because readScalar()/writeScalar() uses
+		// them internally.
+		writer.writeScalar("hello\n\r world!!!");
+		writer.writeScalar("  and this is a second message");
+		
+		string output;
+		ensure("End of stream has not been reached (1)", reader.readScalar(output));
+		ensure_equals(output, "hello\n\r world!!!");
+		
+		ensure("End of stream has not been reached (2)", reader.readScalar(output));
+		ensure_equals(output, "  and this is a second message");
+	}
+	
+	TEST_METHOD(10) {
+		// writeScalar() should be able to produce messages that are compatible with the Ruby implementation.
+		// readScalar() should be able to read messages produced by the Ruby implementation.
+		int p1[2], p2[2];
+		pid_t pid;
+		
+		pipe(p1);
+		pipe(p2);
+		pid = fork();
+		if (pid == 0) {
+			close(p[0]);
+			close(p[1]);
+			dup2(p1[0], 0);
+			dup2(p2[1], 1);
+			close(p1[0]);
+			close(p1[1]);
+			close(p2[0]);
+			close(p2[1]);
+			execlp("ruby", "ruby", "./stub/message_channel_2.rb", (void *) 0);
+			perror("Cannot execute ruby");
+			_exit(1);
+		} else {
+			MessageChannel reader(p2[0]);
+			MessageChannel writer(p1[1]);
+			string output;
+			close(p1[0]);
+			close(p2[1]);
+			
+			writer.writeScalar("hello world\n!\r!");
+			ensure("End of file has not yet been reached (1)", reader.readScalar(output));
+			ensure_equals(output, "hello world\n!\r!!!");
+			
+			writer.writeScalar("");
+			ensure("End of file has not yet been reached (2)", reader.readScalar(output));
+			ensure_equals(output, "??");
+			writer.close();
+			
+			ensure("End of file has been reached", !reader.readScalar(output));
+			reader.close();
+			waitpid(pid, NULL, 0);
+		}
+	}
+	
+	TEST_METHOD(11) {
+		// If we send a lot of different messages (including file descriptor passing),
+		// and the other side sends the same stuff back to us, then MessageChannel
+		// should be able to read them all, if done in the correct order.
+		// writeScalar() should be able to produce messages that are compatible with the Ruby implementation.
+		// readScalar() should be able to read messages produced by the Ruby implementation.
+		int fd[2];
+		pid_t pid;
+		
+		socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
+		pid = fork();
+		if (pid == 0) {
+			close(p[0]);
+			close(p[1]);
+			dup2(fd[0], 3);
+			close(fd[0]);
+			close(fd[1]);
+			execlp("ruby", "ruby", "./stub/message_channel_3.rb", (void *) 0);
+			perror("Cannot execute ruby");
+			_exit(1);
+		} else {
+			MessageChannel channel(fd[1]);
+			close(fd[0]);
+			
+			vector<string> args;
+			string output;
+			int tmp[2];
+			
+			channel.write("hello ", "my!", "world", NULL);
+			ensure("End of file has not yet been reached", channel.read(args));
+			ensure_equals(args.size(), 3u);
+			ensure_equals(args[0], "hello ");
+			ensure_equals(args[1], "my!");
+			ensure_equals(args[2], "world");
+			
+			channel.writeScalar("testing 123");
+			ensure("End of file has not yet been reached", channel.readScalar(output));
+			ensure_equals(output, "testing 123");
+			
+			pipe(tmp);
+			close(tmp[0]);
+			channel.writeFileDescriptor(tmp[1]);
+			close(tmp[1]);
+			int x = channel.readFileDescriptor();
+			close(x);
+			
+			channel.write("the end", NULL);
+			ensure("End of file has not yet been reached", channel.read(args));
+			ensure_equals(args.size(), 1u);
+			ensure_equals(args[0], "the end");
+			
+			ensure("End of file has been reached", !channel.read(args));
+			channel.close();
+			waitpid(pid, NULL, 0);
+		}
+	}
+	
+	TEST_METHOD(12) {
+		// readScalar()/writeScalar() should be able to handle arbitrary binary data.
+		string data;
+		FILE *f = fopen("stub/garbage3.dat", "r");
+		while (!feof(f)) {
+			char buf[1024 * 32];
+			size_t ret = fread(buf, 1, sizeof(buf), f);
+			data.append(buf, ret);
+		}
+		fclose(f);
+		
+		pid_t pid = fork();
+		if (pid == 0) {
+			reader.close();
+			writer.writeScalar(data);
+			_exit(0);
+		} else {
+			writer.close();
+			string result;
+			reader.readScalar(result);
+			ensure_equals(result, data);
+			waitpid(pid, NULL, 0);
+		}
+	}
+}

data/test/SpawnManagerTest.cpp

@@ -0,0 +1,64 @@
+#include "tut.h"
+#include "SpawnManager.h"
+#include <sys/types.h>
+#include <signal.h>
+#include <cstring>
+#include <unistd.h>
+#include "valgrind.h"
+
+using namespace Passenger;
+
+namespace tut {
+	struct SpawnManagerTest {
+		SpawnManager manager;
+		
+		SpawnManagerTest(): manager("stub/spawn_server.rb") {}
+	};
+
+	DEFINE_TEST_GROUP(SpawnManagerTest);
+
+	TEST_METHOD(1) {
+		// Spawning an application should return a valid Application object.
+		ApplicationPtr app(manager.spawn(PoolOptions(".")));
+		ensure_equals("The Application object's PID is the same as the one specified by the stub",
+			app->getPid(), 1234);
+	}
+	
+	TEST_METHOD(2) {
+		// If something goes wrong during spawning, the spawn manager
+		// should be restarted and another (successful) spawn should be attempted.
+		pid_t old_pid = manager.getServerPid();
+		kill(manager.getServerPid(), SIGTERM);
+		// Give the spawn server the time to properly terminate.
+		usleep(500000);
+		
+		ApplicationPtr app(manager.spawn(PoolOptions(".")));
+		ensure_equals("The Application object's PID is the same as the one specified by the stub",
+			app->getPid(), 1234);
+		
+		// The following test will fail if we're inside Valgrind, but that's normal.
+		// Killing the spawn server doesn't work.
+		if (!RUNNING_ON_VALGRIND) {
+			ensure("The spawn server was restarted", manager.getServerPid() != old_pid);
+		}
+	}
+	
+	TEST_METHOD(3) {
+		// This test fails in Valgrind, but that's normal.
+		// Killing the spawn server doesn't work.
+		if (!RUNNING_ON_VALGRIND) {
+			// If the spawn server dies after a restart, a SpawnException should be thrown.
+			kill(manager.getServerPid(), SIGTERM);
+			// Give the spawn server the time to properly terminate.
+			usleep(500000);
+			
+			try {
+				manager.nextRestartShouldFail = true;
+				ApplicationPtr app(manager.spawn(PoolOptions(".")));
+				fail("SpawnManager did not throw a SpawnException");
+			} catch (const SpawnException &e) {
+				// Success.
+			}
+		}
+	}
+}

data/test/StandardApplicationPoolTest.cpp

@@ -0,0 +1,25 @@
+#include "tut.h"
+#include "StandardApplicationPool.h"
+#include "Utils.h"
+
+using namespace Passenger;
+
+namespace tut {
+	struct StandardApplicationPoolTest {
+		ApplicationPoolPtr pool, pool2;
+		
+		StandardApplicationPoolTest() {
+			pool = ptr(new StandardApplicationPool("../bin/passenger-spawn-server"));
+			pool2 = pool;
+		}
+		
+		ApplicationPoolPtr newPoolConnection() {
+			return pool;
+		}
+	};
+
+	DEFINE_TEST_GROUP(StandardApplicationPoolTest);
+
+	#define USE_TEMPLATE
+	#include "ApplicationPoolTest.cpp"
+}

data/test/UtilsTest.cpp

@@ -0,0 +1,238 @@
+#include "tut.h"
+#include "Utils.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <limits.h>
+
+using namespace Passenger;
+using namespace std;
+
+namespace tut {
+	struct UtilsTest {
+		vector<string> output;
+		string oldPath;
+		
+		UtilsTest() {
+			oldPath = getenv("PATH");
+			unsetenv("TMPDIR");
+			unsetenv("PHUSION_PASSENGER_TMP");
+		}
+		
+		~UtilsTest() {
+			setenv("PATH", oldPath.c_str(), 1);
+			unsetenv("TMPDIR");
+			unsetenv("PHUSION_PASSENGER_TMP");
+		}
+	};
+	
+	static vector<string>
+	listDir(const char *path) {
+		vector<string> result;
+		DIR *d = opendir(path);
+		struct dirent *ent;
+		
+		while ((ent = readdir(d)) != NULL) {
+			if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0) {
+				continue;
+			}
+			result.push_back(ent->d_name);
+		}
+		return result;
+	}
+
+	DEFINE_TEST_GROUP(UtilsTest);
+
+	/***** Test split() *****/
+
+	TEST_METHOD(1) {
+		split("", ':', output);
+		ensure_equals(output.size(), 1u);
+		ensure_equals(output[0], "");
+	}
+	
+	TEST_METHOD(2) {
+		split("hello world", ':', output);
+		ensure_equals(output.size(), 1u);
+		ensure_equals(output[0], "hello world");
+	}
+	
+	TEST_METHOD(3) {
+		split("hello world:foo bar", ':', output);
+		ensure_equals(output.size(), 2u);
+		ensure_equals(output[0], "hello world");
+		ensure_equals(output[1], "foo bar");
+	}
+	
+	TEST_METHOD(4) {
+		split("hello world:", ':', output);
+		ensure_equals(output.size(), 2u);
+		ensure_equals(output[0], "hello world");
+		ensure_equals(output[1], "");
+	}
+	
+	TEST_METHOD(5) {
+		split(":hello world", ':', output);
+		ensure_equals(output.size(), 2u);
+		ensure_equals(output[0], "");
+		ensure_equals(output[1], "hello world");
+	}
+	
+	TEST_METHOD(6) {
+		split("abc:def::ghi", ':', output);
+		ensure_equals(output.size(), 4u);
+		ensure_equals(output[0], "abc");
+		ensure_equals(output[1], "def");
+		ensure_equals(output[2], "");
+		ensure_equals(output[3], "ghi");
+	}
+	
+	TEST_METHOD(7) {
+		split("abc:::def", ':', output);
+		ensure_equals(output.size(), 4u);
+		ensure_equals(output[0], "abc");
+		ensure_equals(output[1], "");
+		ensure_equals(output[2], "");
+		ensure_equals(output[3], "def");
+	}
+	
+	
+	/**** Test findSpawnServer() ****/
+	
+	TEST_METHOD(8) {
+		// If $PATH is empty, it should not find anything.
+		setenv("PATH", "", 1);
+		ensure_equals(findSpawnServer(), "");
+	}
+	
+	TEST_METHOD(9) {
+		// It should ignore relative paths.
+		setenv("PATH", "../bin", 1);
+		ensure_equals(findSpawnServer(), "");
+	}
+	
+	TEST_METHOD(10) {
+		// It should find in $PATH.
+		char cwd[PATH_MAX];
+		string binpath(getcwd(cwd, sizeof(cwd)));
+		binpath.append("/../bin");
+		setenv("PATH", binpath.c_str(), 1);
+		ensure("Spawn server is found.", !findSpawnServer().empty());
+	}
+	
+	
+	/***** Test getTempDir() *****/
+	
+	TEST_METHOD(11) {
+		// It returns "/tmp" if the TMPDIR environment is NULL.
+		ensure_equals(string(getTempDir()), "/tmp");
+	}
+	
+	TEST_METHOD(12) {
+		// It returns "/tmp" if the TMPDIR environment is an empty string.
+		setenv("TMPDIR", "", 1);
+		ensure_equals(string(getTempDir()), "/tmp");
+	}
+	
+	TEST_METHOD(13) {
+		// It returns the value of the TMPDIR environment if it is not NULL and not empty.
+		setenv("TMPDIR", "/foo", 1);
+		ensure_equals(string(getTempDir()), "/foo");
+	}
+	
+	
+	/***** Test getPassengerTempDir() *****/
+	
+	TEST_METHOD(15) {
+		// It returns "(tempdir)/passenger.(pid)"
+		char dir[128];
+		
+		snprintf(dir, sizeof(dir), "/tmp/passenger.%d", getpid());
+		ensure_equals(getPassengerTempDir(), dir);
+	}
+	
+	TEST_METHOD(16) {
+		// It caches the result into the PHUSION_PASSENGER_TMP environment variable.
+		char dir[128];
+		
+		snprintf(dir, sizeof(dir), "/tmp/passenger.%d", getpid());
+		getPassengerTempDir();
+		ensure_equals(getenv("PHUSION_PASSENGER_TMP"), string(dir));
+	}
+	
+	TEST_METHOD(17) {
+		// It returns the value of the PHUSION_PASSENGER_TMP environment variable if it's not NULL and not an empty string.
+		setenv("PHUSION_PASSENGER_TMP", "/foo", 1);
+		ensure_equals(getPassengerTempDir(), "/foo");
+	}
+	
+	TEST_METHOD(18) {
+		// It does not use query the PHUSION_PASSENGER_TMP environment variable if bypassCache is true.
+		char dir[128];
+		
+		setenv("PHUSION_PASSENGER_TMP", "/foo", 1);
+		snprintf(dir, sizeof(dir), "/tmp/passenger.%d", getpid());
+		ensure_equals(getPassengerTempDir(true), dir);
+	}
+	
+	
+	/***** Test TempFile *****/
+	
+	TEST_METHOD(20) {
+		// It creates a temp file inside getPassengerTempDir().
+		setenv("PHUSION_PASSENGER_TMP", "utils_test.tmp", 1);
+		mkdir("utils_test.tmp", S_IRWXU);
+		TempFile t("temp", false);
+		unsigned int size = listDir("utils_test.tmp").size();
+		removeDirTree("utils_test.tmp");
+		ensure_equals(size, 1u);
+	}
+	
+	TEST_METHOD(21) {
+		// It deletes the temp file upon destruction.
+		setenv("PHUSION_PASSENGER_TMP", "utils_test.tmp", 1);
+		mkdir("utils_test.tmp", S_IRWXU);
+		{
+			TempFile t("temp", false);
+		}
+		bool dirEmpty = listDir("utils_test.tmp").empty();
+		removeDirTree("utils_test.tmp");
+		ensure(dirEmpty);
+	}
+	
+	TEST_METHOD(22) {
+		// The temp file's filename is constructed using the given identifier.
+		setenv("PHUSION_PASSENGER_TMP", "utils_test.tmp", 1);
+		mkdir("utils_test.tmp", S_IRWXU);
+		TempFile t("foobar", false);
+		vector<string> files(listDir("utils_test.tmp"));
+		removeDirTree("utils_test.tmp");
+		
+		ensure(files[0].find("foobar") != string::npos);
+	}
+	
+	TEST_METHOD(23) {
+		// It immediately unlinks the temp file if 'anonymous' is true.
+		// It creates a temp file inside getPassengerTempDir().
+		setenv("PHUSION_PASSENGER_TMP", "utils_test.tmp", 1);
+		mkdir("utils_test.tmp", S_IRWXU);
+		TempFile t;
+		unsigned int size = listDir("utils_test.tmp").size();
+		removeDirTree("utils_test.tmp");
+		ensure_equals(size, 0u);
+	}
+	
+	/***** Test escapeForXml() *****/
+	
+	TEST_METHOD(25) {
+		ensure_equals(escapeForXml(""), "");
+		ensure_equals(escapeForXml("hello world"), "hello world");
+		ensure_equals(escapeForXml("./hello_world/foo.txt"), "./hello_world/foo.txt");
+		ensure_equals(escapeForXml("hello<world"), "hello&#60;world");
+		ensure_equals(escapeForXml("hello\xFFworld"), "hello&#255;world");
+		ensure_equals(escapeForXml("hello\xFF\xCCworld"), "hello&#255;&#204;world");
+		ensure_equals(escapeForXml("hello\xFFworld\xCC"), "hello&#255;world&#204;");
+	}
+}