passenger 2.2.15 → 3.0.0.pre1

data/test/cxx/ServerInstanceDirTest.cpp

@@ -0,0 +1,186 @@
+#include "TestSupport.h"
+#include "ServerInstanceDir.h"
+
+using namespace Passenger;
+using namespace std;
+
+namespace tut {
+	struct ServerInstanceDirTest {
+		string parentDir;
+		TempDir tmpDir;
+		string nobodyGroup;
+		
+		ServerInstanceDirTest(): tmpDir("server_instance_dir_test.tmp") {
+			parentDir = "server_instance_dir_test.tmp";
+			nobodyGroup = getPrimaryGroupName("nobody");
+		}
+		
+		void createGenerationDir(const string &instanceDir, unsigned int number) {
+			string command = "mkdir " + instanceDir + "/generation-" + toString(number);
+			system(command.c_str());
+		}
+	};
+	
+	DEFINE_TEST_GROUP(ServerInstanceDirTest);
+	
+	TEST_METHOD(1) {
+		// The (pid_t, string) constructor creates a server instance directory
+		// in the given parent directory, and this server instance directory
+		// name contains the major and minor structure versions and the given PID.
+		ServerInstanceDir dir(1234, parentDir);
+		vector<string> contents = listDir(parentDir);
+		ensure_equals(contents.size(), 1u);
+		ensure_equals(contents[0],
+			"passenger." +
+			toString(ServerInstanceDir::DIR_STRUCTURE_MAJOR_VERSION) +
+			"." +
+			toString(ServerInstanceDir::DIR_STRUCTURE_MINOR_VERSION) +
+			".1234");
+	}
+	
+	TEST_METHOD(2) {
+		// The (string) constructor creates a ServerInstanceDir object that's
+		// associated with the given directory, and creates the directory
+		// if it doesn't exist.
+		ServerInstanceDir dir(1234, parentDir);
+		ServerInstanceDir dir2(dir.getPath());
+		ServerInstanceDir dir3(parentDir + "/foo");
+		ensure_equals(dir2.getPath(), dir.getPath());
+		ensure_equals(dir3.getPath(), parentDir + "/foo");
+		ensure_equals(getFileType(dir3.getPath()), FT_DIRECTORY);
+	}
+	
+	TEST_METHOD(3) {
+		// A ServerInstanceDir object removes the server instance directory
+		// upon destruction, but only if there are no more generations in it.
+		{
+			ServerInstanceDir dir(1234, parentDir);
+		}
+		ensure_equals(listDir(parentDir).size(), 0u);
+		
+		{
+			ServerInstanceDir dir(1234, parentDir);
+			createGenerationDir(dir.getPath(), 1);
+		}
+		ensure_equals(listDir(parentDir).size(), 1u);
+	}
+	
+	TEST_METHOD(4) {
+		// The destructor does not throw any exceptions if the server instance
+		// directory doesn't exist anymore.
+		ServerInstanceDir dir(1234, parentDir);
+		removeDirTree(dir.getPath());
+	}
+	
+	TEST_METHOD(5) {
+		// The destructor doesnn't remove the server instance directory if it
+		// wasn't created with the ownership flag or if it's been detached.
+		string path, path2;
+		{
+			ServerInstanceDir dir(1234, parentDir, false);
+			ServerInstanceDir dir2(5678, parentDir);
+			dir2.detach();
+			path = dir.getPath();
+			path2 = dir2.getPath();
+		}
+		ensure_equals(getFileType(path), FT_DIRECTORY);
+		ensure_equals(getFileType(path2), FT_DIRECTORY);
+	}
+	
+	TEST_METHOD(6) {
+		// If there are no existing generations, newGeneration() creates a new
+		// generation directory with number 0.
+		ServerInstanceDir dir(1234, parentDir);
+		unsigned int ncontents = listDir(dir.getPath()).size();
+		ServerInstanceDir::GenerationPtr generation = dir.newGeneration(true,
+			"nobody", nobodyGroup, 0, 0);
+		
+		ensure_equals(generation->getNumber(), 0u);
+		ensure_equals(getFileType(generation->getPath()), FT_DIRECTORY);
+		ensure_equals(listDir(dir.getPath()).size(), ncontents + 1);
+	}
+	
+	TEST_METHOD(7) {
+		// A Generation object returned by newGeneration() deletes the associated
+		// generation directory upon destruction.
+		ServerInstanceDir dir(1234, parentDir);
+		ServerInstanceDir::GenerationPtr generation = dir.newGeneration(true,
+			"nobody", nobodyGroup, 0, 0);
+		string path = generation->getPath();
+		generation.reset();
+		ensure_equals(getFileType(path), FT_NONEXISTANT);
+	}
+	
+	TEST_METHOD(8) {
+		// getNewestGeneration() returns the newest generation.
+		ServerInstanceDir dir(1234, parentDir);
+		ServerInstanceDir::GenerationPtr generation0 = dir.newGeneration(true, "nobody", nobodyGroup, 0, 0);
+		ServerInstanceDir::GenerationPtr generation1 = dir.newGeneration(true, "nobody", nobodyGroup, 0, 0);
+		ServerInstanceDir::GenerationPtr generation2 = dir.newGeneration(true, "nobody", nobodyGroup, 0, 0);
+		ServerInstanceDir::GenerationPtr generation3 = dir.newGeneration(true, "nobody", nobodyGroup, 0, 0);
+		
+		generation2.reset();
+		ensure_equals(dir.getNewestGeneration()->getNumber(), 3u);
+		generation3.reset();
+		ensure_equals(dir.getNewestGeneration()->getNumber(), 1u);
+	}
+	
+	TEST_METHOD(9) {
+		// getNewestGeneration returns null if there are no generations.
+		ServerInstanceDir dir(1234, parentDir);
+		ensure(dir.getNewestGeneration() == NULL);
+	}
+	
+	TEST_METHOD(10) {
+		// A Generation object returned by getNewestGeneration() doesn't delete
+		// the associated generation directory upon destruction.
+		ServerInstanceDir dir(1234, parentDir);
+		ServerInstanceDir::GenerationPtr generation = dir.newGeneration(true, "nobody", nobodyGroup, 0, 0);
+		ServerInstanceDir::GenerationPtr newestGeneration = dir.getNewestGeneration();
+		newestGeneration.reset();
+		ensure_equals(getFileType(generation->getPath()), FT_DIRECTORY);
+	}
+	
+	TEST_METHOD(11) {
+		// getGeneration() returns the given generation.
+		ServerInstanceDir dir(1234, parentDir);
+		ServerInstanceDir::GenerationPtr generation0 = dir.newGeneration(true, "nobody", nobodyGroup, 0, 0);
+		ServerInstanceDir::GenerationPtr generation1 = dir.newGeneration(true, "nobody", nobodyGroup, 0, 0);
+		ServerInstanceDir::GenerationPtr generation2 = dir.newGeneration(true, "nobody", nobodyGroup, 0, 0);
+		ServerInstanceDir::GenerationPtr generation3 = dir.newGeneration(true, "nobody", nobodyGroup, 0, 0);
+		
+		ensure_equals(dir.getGeneration(0)->getNumber(), 0u);
+		ensure_equals(dir.getGeneration(3)->getNumber(), 3u);
+	}
+	
+	TEST_METHOD(12) {
+		// A Generation object returned by getGeneration() doesn't delete the
+		// associated generation directory upon destruction.
+		ServerInstanceDir dir(1234, parentDir);
+		ServerInstanceDir::GenerationPtr generation0 = dir.newGeneration(true, "nobody", nobodyGroup, 0, 0);
+		ServerInstanceDir::GenerationPtr generation1 = dir.newGeneration(true, "nobody", nobodyGroup, 0, 0);
+		
+		dir.getGeneration(0).reset();
+		dir.getGeneration(1).reset();
+		ensure_equals(getFileType(generation0->getPath()), FT_DIRECTORY);
+		ensure_equals(getFileType(generation1->getPath()), FT_DIRECTORY);
+	}
+	
+	TEST_METHOD(13) {
+		// A detached Generation doesn't delete the associated generation
+		// directory upon destruction.
+		ServerInstanceDir dir(1234, parentDir);
+		ServerInstanceDir::GenerationPtr generation = dir.newGeneration(true, "nobody", nobodyGroup, 0, 0);
+		string path = generation->getPath();
+		generation->detach();
+		generation.reset();
+		ensure_equals(getFileType(path), FT_DIRECTORY);
+	}
+	
+	TEST_METHOD(14) {
+		// It's possible to have two ServerInstanceDir objects constructed
+		// with the same (pid_t, string) constructor arguments.
+		ServerInstanceDir dir1(1234, parentDir);
+		ServerInstanceDir dir2(1234, parentDir);
+	}
+}

data/test/cxx/SpawnManagerTest.cpp

@@ -0,0 +1,161 @@
+#include "TestSupport.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 {
+		ServerInstanceDirPtr serverInstanceDir;
+		ServerInstanceDir::GenerationPtr generation;
+		SpawnManagerPtr manager;
+		AccountsDatabasePtr accountsDatabase;
+		PoolOptions rackOptions;
+		
+		SpawnManagerTest() {
+			createServerInstanceDirAndGeneration(serverInstanceDir, generation);
+			rackOptions.appRoot = "stub/rack";
+			rackOptions.appType = "rack";
+		}
+		
+		void initialize() {
+			manager = ptr(new SpawnManager("../helper-scripts/passenger-spawn-server", generation,
+				accountsDatabase));
+		}
+		
+		void sendTestRequest(SessionPtr &session, bool authenticate = true, const char *uri = "/foo/new") {
+			string headers;
+			#define ADD_HEADER(name, value) \
+				headers.append(name); \
+				headers.append(1, '\0'); \
+				headers.append(value); \
+				headers.append(1, '\0')
+			ADD_HEADER("HTTP_HOST", "www.test.com");
+			ADD_HEADER("QUERY_STRING", "");
+			ADD_HEADER("REQUEST_URI", uri);
+			ADD_HEADER("REQUEST_METHOD", "GET");
+			ADD_HEADER("REMOTE_ADDR", "localhost");
+			ADD_HEADER("SCRIPT_NAME", "");
+			ADD_HEADER("PATH_INFO", uri);
+			if (authenticate) {
+				ADD_HEADER("PASSENGER_CONNECT_PASSWORD", session->getConnectPassword());
+			}
+			session->sendHeaders(headers);
+		}
+	};
+
+	DEFINE_TEST_GROUP(SpawnManagerTest);
+
+	TEST_METHOD(1) {
+		// Spawning an application should return a valid Application object.
+		initialize();
+		ProcessPtr process = manager->spawn(rackOptions);
+		SessionPtr session = process->newSession();
+		sendTestRequest(session);
+		session->shutdownWriter();
+		string result = readAll(session->getStream());
+		ensure(result.find("hello <b>world</b>") != string::npos);
+	}
+	
+	TEST_METHOD(2) {
+		// If something goes wrong during spawning, the spawn manager
+		// should be restarted and another (successful) spawn should be attempted.
+		initialize();
+		pid_t old_pid = manager->getServerPid();
+		manager->killSpawnServer();
+		// Give the spawn server the time to properly terminate.
+		usleep(500000);
+		
+		ProcessPtr process = manager->spawn(rackOptions);
+		SessionPtr session = process->newSession();
+		sendTestRequest(session);
+		session->shutdownWriter();
+		string result = readAll(session->getStream());
+		ensure(result.find("hello <b>world</b>") != string::npos);
+		
+		// The following test will fail if we're inside Valgrind, but that's normal.
+		// Killing the spawn server doesn't work there.
+		if (!RUNNING_ON_VALGRIND) {
+			ensure("The spawn server was restarted", manager->getServerPid() != old_pid);
+		}
+	}
+	
+	class BuggySpawnManager: public SpawnManager {
+	protected:
+		virtual void spawnServerStarted() {
+			if (nextRestartShouldFail) {
+				nextRestartShouldFail = false;
+				killSpawnServer();
+				usleep(25000);
+			}
+		}
+		
+	public:
+		bool nextRestartShouldFail;
+		
+		BuggySpawnManager(const ServerInstanceDir::GenerationPtr &generation)
+			: SpawnManager("stub/spawn_server.rb", generation)
+		{
+			nextRestartShouldFail = false;
+		}
+	};
+	
+	TEST_METHOD(3) {
+		// If the spawn server dies after a restart, a SpawnException should be thrown.
+		
+		// This test fails in Valgrind, but that's normal.
+		// Killing the spawn server doesn't work there.
+		if (!RUNNING_ON_VALGRIND) {
+			BuggySpawnManager manager(generation);
+			manager.killSpawnServer();
+			// Give the spawn server the time to properly terminate.
+			usleep(250000);
+			
+			try {
+				manager.nextRestartShouldFail = true;
+				ProcessPtr process = manager.spawn(rackOptions);
+				fail("SpawnManager did not throw a SpawnException");
+			} catch (const SpawnException &e) {
+				// Success.
+			}
+		}
+	}
+	
+	TEST_METHOD(4) {
+		// The connect password is passed to the spawned application, which rejects
+		// sessions that aren't authenticated with the right password.
+		initialize();
+		ProcessPtr process = manager->spawn(rackOptions);
+		SessionPtr session = process->newSession();
+		sendTestRequest(session, false);
+		session->shutdownWriter();
+		string result = readAll(session->getStream());
+		ensure_equals(result, "");
+	}
+	
+	TEST_METHOD(5) {
+		// It automatically creates a unique account for the application,
+		// which is deleted when no longer needed.
+		accountsDatabase = ptr(new AccountsDatabase());
+		initialize();
+		
+		ProcessPtr process1 = manager->spawn(rackOptions);
+		vector<string> usernames1 = accountsDatabase->listUsernames();
+		ensure_equals(accountsDatabase->size(), 1u);
+		
+		ProcessPtr process2 = manager->spawn(rackOptions);
+		vector<string> usernames2 = accountsDatabase->listUsernames();
+		ensure_equals(accountsDatabase->size(), 2u);
+		
+		process1.reset();
+		ensure_equals(accountsDatabase->size(), 1u);
+		ensure_equals(accountsDatabase->get(usernames1[0]), AccountPtr());
+		
+		process2.reset();
+		ensure_equals(accountsDatabase->size(), 0u);
+	}
+}

data/test/cxx/StaticStringTest.cpp

@@ -0,0 +1,86 @@
+#include "TestSupport.h"
+#include "StaticString.h"
+
+using namespace Passenger;
+using namespace std;
+
+namespace tut {
+	struct StaticStringTest {
+	};
+	
+	DEFINE_TEST_GROUP(StaticStringTest);
+
+	TEST_METHOD(1) {
+		// Test == operator.
+		ensure(StaticString("") == "");
+		ensure(StaticString("foo") == "foo");
+		ensure(!(StaticString("foo") == "bar"));
+		ensure(!(StaticString("barr") == "bar"));
+		ensure(!(StaticString("bar") == "barr"));
+		
+		ensure(StaticString("") == StaticString(""));
+		ensure(StaticString("foo") == StaticString("foo"));
+		ensure(!(StaticString("foo") == StaticString("bar")));
+		ensure(!(StaticString("barr") == StaticString("bar")));
+		ensure(!(StaticString("bar") == StaticString("barr")));
+		
+		ensure(StaticString("") == string(""));
+		ensure(StaticString("foo") == string("foo"));
+		ensure(!(StaticString("foo") == string("bar")));
+		ensure(!(StaticString("barr") == string("bar")));
+		ensure(!(StaticString("bar") == string("barr")));
+	}
+	
+	TEST_METHOD(2) {
+		// Test != operator
+		ensure(!(StaticString("") != ""));
+		ensure(!(StaticString("foo") != "foo"));
+		ensure(StaticString("foo") != "bar");
+		ensure(StaticString("barr") != "bar");
+		ensure(StaticString("bar") != "barr");
+		
+		ensure(!(StaticString("") != StaticString("")));
+		ensure(!(StaticString("foo") != StaticString("foo")));
+		ensure(StaticString("foo") != StaticString("bar"));
+		ensure(StaticString("barr") != StaticString("bar"));
+		ensure(StaticString("bar") != StaticString("barr"));
+		
+		ensure(!(StaticString("") != string("")));
+		ensure(!(StaticString("foo") != string("foo")));
+		ensure(StaticString("foo") != string("bar"));
+		ensure(StaticString("barr") != string("bar"));
+		ensure(StaticString("bar") != string("barr"));
+	}
+	
+	TEST_METHOD(3) {
+		// Test < operator.
+		ensure_equals("Assertion 1",
+			StaticString("") < "",
+			string("") < string("")
+		);
+		ensure_equals("Assertion 2",
+			StaticString("abc") < "abc",
+			string("abc") < string("abc")
+		);
+		ensure_equals("Assertion 3",
+			StaticString("foo") < "bar",
+			string("foo") < string("bar")
+		);
+		ensure_equals("Assertion 4",
+			StaticString("foo") < "bar!",
+			string("foo") < string("bar!")
+		);
+		ensure_equals("Assertion 5",
+			StaticString("bar!") < "foo",
+			string("bar!") < string("foo")
+		);
+		ensure_equals("Assertion 6",
+			StaticString("hello") < "hello world",
+			string("hello") < string("hello world")
+		);
+		ensure_equals("Assertion 7",
+			StaticString("hello world") < "hello",
+			string("hello world") < string("hello")
+		);
+	}
+}

data/test/{SystemTimeTest.cpp → cxx/SystemTimeTest.cpp}

@@ -1,5 +1,5 @@
-#include "tut.h"
-#include "SystemTime.h"
+#include "TestSupport.h"
+#include "Utils/SystemTime.h"
 
 using namespace Passenger;
 using namespace std;

data/test/cxx/TestSupport.cpp

@@ -0,0 +1,166 @@
+#include <dirent.h>
+#include <unistd.h>
+#include <pwd.h>
+#include <grp.h>
+#include "TestSupport.h"
+
+namespace TestSupport {
+
+void createServerInstanceDirAndGeneration(ServerInstanceDirPtr &serverInstanceDir,
+                                          ServerInstanceDir::GenerationPtr &generation)
+{
+	serverInstanceDir.reset(new ServerInstanceDir(getpid()));
+	generation = serverInstanceDir->newGeneration(geteuid() == 0,
+		"nobody", getPrimaryGroupName("nobody"),
+		geteuid(), getegid());
+}
+
+string
+readAll(const string &filename) {
+	FILE *f = fopen(filename.c_str(), "rb");
+	if (f != NULL) {
+		try {
+			string result = readAll(fileno(f));
+			fclose(f);
+			return result;
+		} catch (...) {
+			fclose(f);
+			throw;
+		}
+	} else {
+		int e = errno;
+		throw FileSystemException("Cannot open '" + filename + "' for reading",
+			e, filename);
+	}
+}
+
+string
+readAll(int fd) {
+	string result;
+	char buf[1024 * 32];
+	ssize_t ret;
+	while (true) {
+		do {
+			ret = read(fd, buf, sizeof(buf));
+		} while (ret == -1 && errno == EINTR);
+		if (ret == 0) {
+			break;
+		} else if (ret == -1) {
+			throw SystemException("Cannot read from socket", errno);
+		} else {
+			result.append(buf, ret);
+		}
+	}
+	return result;
+}
+
+string
+replaceString(const string &str, const string &toFind, const string &replaceWith) {
+	string::size_type pos = str.find(toFind);
+	if (pos == string::npos) {
+		return str;
+	} else {
+		string result(str);
+		return result.replace(pos, toFind.size(), replaceWith);
+	}
+}
+
+void
+replaceStringInFile(const char *filename, const string &toFind, const string &replaceWith) {
+	FILE *f = fopen(filename, "r");
+	if (f == NULL) {
+		int e = errno;
+		string message = "Cannot open file '";
+		message.append(filename);
+		message.append("' for reading");
+		throw FileSystemException(message, e, filename);
+	}
+	string content(readAll(fileno(f)));
+	fclose(f);
+	
+	f = fopen(filename, "w");
+	if (f == NULL) {
+		int e = errno;
+		string message = "Cannot open file '";
+		message.append(filename);
+		message.append("' for writing");
+		throw FileSystemException(message, e, filename);
+	}
+	content = replaceString(content, toFind, replaceWith);
+	fwrite(content.data(), 1, content.size(), f);
+	fclose(f);
+}
+
+void
+writeFile(const string &filename, const string &contents) {
+	FILE *f = fopen(filename.c_str(), "w");
+	if (f == NULL) {
+		int e = errno;
+		string message = "Cannot open file '";
+		message.append(filename);
+		message.append("' for writing");
+		throw FileSystemException(message, e, filename);
+	}
+	fwrite(contents.data(), 1, contents.size(), f);
+	fclose(f);
+}
+
+void
+touchFile(const char *filename, time_t timestamp) {
+	FILE *f = fopen(filename, "a");
+	if (f != NULL) {
+		fclose(f);
+	} else if (errno != EISDIR) {
+		int e = errno;
+		string message = "Cannot touch file '";
+		message.append(filename);
+		message.append("'");
+		throw FileSystemException(message, e, filename);
+	}
+	
+	if (timestamp != (time_t) -1) {
+		struct utimbuf times;
+		times.actime = timestamp;
+		times.modtime = timestamp;
+		utime(filename, &times);
+	}
+}
+
+vector<string>
+listDir(const string &path) {
+	vector<string> result;
+	DIR *d = opendir(path.c_str());
+	struct dirent *ent;
+	
+	if (d == NULL) {
+		int e = errno;
+		throw FileSystemException("Cannot open directory " + path,
+			e, path);
+	}
+	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;
+}
+
+string
+getPrimaryGroupName(const string &username) {
+	struct passwd *user;
+	struct group  *group;
+	
+	user = getpwnam(username.c_str());
+	if (user == NULL) {
+		throw RuntimeException(string("User '") + username + "' does not exist.");
+	}
+	group = getgrgid(user->pw_gid);
+	if (group == NULL) {
+		throw RuntimeException(string("Primary group for user '") + username + "' does not exist.");
+	}
+	
+	return group->gr_name;
+}
+
+} // namespace TestSupport