rockdog-passenger 0.0.1

data/ext/apache2/Configuration.h

@@ -0,0 +1,327 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (C) 2008  Phusion
+ *
+ *  Phusion Passenger is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef _PASSENGER_CONFIGURATION_H_
+#define _PASSENGER_CONFIGURATION_H_
+
+#include <apr_pools.h>
+#include <httpd.h>
+#include <http_config.h>
+
+#include "Utils.h"
+
+/**
+ * @defgroup Configuration Apache module configuration
+ * @ingroup Core
+ * @{
+ */
+
+/** Module version number. */
+#define PASSENGER_VERSION "2.1.0"
+
+#ifdef __cplusplus
+	#include <set>
+	#include <string>
+
+	namespace Passenger {
+	
+		using namespace std;
+		
+		/**
+		 * Per-directory configuration information.
+		 *
+		 * Use the getter methods to query information, because those will return
+		 * the default value if the value is not specified.
+		 */
+		struct DirConfig {
+			enum Threeway { ENABLED, DISABLED, UNSET };
+			enum SpawnMethod { SM_UNSET, SM_SMART, SM_SMART_LV2, SM_CONSERVATIVE };
+			
+			Threeway enabled;
+			
+			std::set<std::string> railsBaseURIs;
+			std::set<std::string> rackBaseURIs;
+			
+			/** Whether to autodetect Rails applications. */
+			Threeway autoDetectRails;
+			
+			/** Whether to autodetect Rack applications. */
+			Threeway autoDetectRack;
+			
+			/** Whether to autodetect WSGI applications. */
+			Threeway autoDetectWSGI;
+			
+			/** Whether mod_rewrite should be allowed for Rails applications. */
+			Threeway allowModRewrite;
+			
+			/** The environment (i.e. value for RAILS_ENV) under which
+			 * Rails applications should operate. */
+			const char *railsEnv;
+			
+			/** The path to the application's root (for example: RAILS_ROOT
+			 * for Rails applications, directory containing 'config.ru'
+			 * for Rack applications). If this value is NULL, the default
+			 * autodetected path will be used.
+			 */
+			const char *appRoot;
+			
+			/** The environment (i.e. value for RACK_ENV) under which
+			 * Rack applications should operate. */
+			const char *rackEnv;
+			
+			/** The Rails spawn method to use. */
+			SpawnMethod spawnMethod;
+			
+			/**
+			 * The idle timeout, in seconds, of Rails framework spawners.
+			 * May also be 0 (which indicates that the framework spawner should
+			 * never idle timeout) or -1 (which means that the value is not specified).
+			 */
+			long frameworkSpawnerTimeout;
+			
+			/**
+			 * The idle timeout, in seconds, of Rails application spawners.
+			 * May also be 0 (which indicates that the application spawner should
+			 * never idle timeout) or -1 (which means that the value is not specified).
+			 */
+			long appSpawnerTimeout;
+			
+			/**
+			 * The maximum number of requests that the spawned application may process
+			 * before exiting. A value of 0 means unlimited.
+			 */
+			unsigned long maxRequests;
+			
+			/** Indicates whether the maxRequests option was explicitly specified
+			 * in the directory configuration. */
+			bool maxRequestsSpecified;
+			
+			/**
+			 * The maximum amount of memory (in MB) the spawned application may use.
+			 * A value of 0 means unlimited.
+			 */
+			unsigned long memoryLimit;
+			
+			/** Indicates whether the memoryLimit option was explicitly specified
+			 * in the directory configuration. */
+			bool memoryLimitSpecified;
+			
+			Threeway highPerformance;
+			
+			/** Whether global queuing should be used. */
+			Threeway useGlobalQueue;
+			
+			/**
+			 * Throttle the number of stat() calls on files like
+			 * restart.txt to the once per given number of seconds.
+			 */
+			unsigned long statThrottleRate;
+			
+			/** Indicates whether the statThrottleRate option was
+			 * explicitly specified in the directory configuration. */
+			bool statThrottleRateSpecified;
+			
+			/** The directory in which Passenger should look for
+			 * restart.txt. NULL means that the default directory
+			 * should be used.
+			 */
+			const char *restartDir;
+			
+			/*************************************/
+			
+			bool isEnabled() const {
+				return enabled != DISABLED;
+			}
+			
+			string getAppRoot(const char *documentRoot) const {
+				if (appRoot == NULL) {
+					return string(documentRoot).append("/..");
+				} else {
+					return appRoot;
+				}
+			}
+			
+			const char *getRailsEnv() const {
+				if (railsEnv != NULL) {
+					return railsEnv;
+				} else {
+					return "production";
+				}
+			}
+			
+			const char *getRackEnv() const {
+				if (rackEnv != NULL) {
+					return rackEnv;
+				} else {
+					return "production";
+				}
+			}
+			
+			const char *getSpawnMethodString() {
+				switch (spawnMethod) {
+				case SM_SMART:
+					return "smart";
+				case SM_SMART_LV2:
+					return "smart-lv2";
+				case SM_CONSERVATIVE:
+					return "conservative";
+				default:
+					return "smart-lv2";
+				}
+			}
+			
+			unsigned long getMaxRequests() {
+				if (maxRequestsSpecified) {
+					return maxRequests;
+				} else {
+					return 0;
+				}
+			}
+			
+			unsigned long getMemoryLimit() {
+				if (memoryLimitSpecified) {
+					return memoryLimit;
+				} else {
+					return 200;
+				}
+			}
+			
+			bool highPerformanceMode() const {
+				return highPerformance == ENABLED;
+			}
+			
+			bool usingGlobalQueue() const {
+				return useGlobalQueue == ENABLED;
+			}
+			
+			unsigned long getStatThrottleRate() const {
+				if (statThrottleRateSpecified) {
+					return statThrottleRate;
+				} else {
+					return 0;
+				}
+			}
+			
+			const char *getRestartDir() const {
+				if (restartDir != NULL) {
+					return restartDir;
+				} else {
+					return "";
+				}
+			}
+			
+			/*************************************/
+		};
+		
+		/**
+		 * Server-wide (global, not per-virtual host) configuration information.
+		 *
+		 * Use the getter methods to query information, because those will return
+		 * the default value if the value is not specified.
+		 */
+		struct ServerConfig {
+			/** The filename of the Ruby interpreter to use. */
+			const char *ruby;
+			
+			/** The Passenger root folder. */
+			const char *root;
+			
+			/** The log verbosity. */
+			unsigned int logLevel;
+			
+			/** The maximum number of simultaneously alive application
+			 * instances. */
+			unsigned int maxPoolSize;
+			
+			/** Whether the maxPoolSize option was explicitly specified in
+			 * this server config. */
+			bool maxPoolSizeSpecified;
+			
+			/** The maximum number of simultaneously alive Rails application
+			 * that a single Rails application may occupy. */
+			unsigned int maxInstancesPerApp;
+			
+			/** Whether the maxInstancesPerApp option was explicitly specified in
+			 * this server config. */
+			bool maxInstancesPerAppSpecified;
+			
+			/** The maximum number of seconds that an application may be
+			 * idle before it gets terminated. */
+			unsigned int poolIdleTime;
+			
+			/** Whether the poolIdleTime option was explicitly specified in
+			 * this server config. */
+			bool poolIdleTimeSpecified;
+			
+			/** Whether user switching support is enabled. */
+			bool userSwitching;
+			
+			/** Whether the userSwitching option was explicitly specified in
+			 * this server config. */
+			bool userSwitchingSpecified;
+
+			/** The user that applications must run as if user switching
+			 * fails or is disabled. NULL means the option is not specified.
+			 */
+			const char *defaultUser;
+			
+			/** The temp directory that Passenger should use. NULL
+			 * means unspecified.
+			 */
+			const char *tempDir;
+			
+			const char *getDefaultUser() const {
+				if (defaultUser != NULL) {
+					return defaultUser;
+				} else {
+					return "nobody";
+				}
+			}
+		};
+	}
+
+	extern "C" {
+#endif
+
+/** Configuration hook for per-directory configuration structure creation. */
+void *passenger_config_create_dir(apr_pool_t *p, char *dirspec);
+
+/** Configuration hook for per-directory configuration structure merging. */
+void *passenger_config_merge_dir(apr_pool_t *p, void *basev, void *addv);
+
+/** Configuration hook for per-server configuration structure creation. */
+void *passenger_config_create_server(apr_pool_t *p, server_rec *s);
+
+/** Configuration hook for per-server configuration structure merging. */
+void *passenger_config_merge_server(apr_pool_t *p, void *basev, void *overridesv);
+
+void passenger_config_merge_all_servers(apr_pool_t *pool, server_rec *main_server);
+
+/** Apache module commands array. */
+extern const command_rec passenger_commands[];
+
+#ifdef __cplusplus
+	}
+#endif
+
+/**
+ * @}
+ */
+
+#endif /* _PASSENGER_CONFIGURATION_H_ */

data/ext/apache2/DummySpawnManager.h

@@ -0,0 +1,103 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (C) 2008  Phusion
+ *
+ *  Phusion Passenger is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef _PASSENGER_DUMMY_SPAWN_MANAGER_H_
+#define _PASSENGER_DUMMY_SPAWN_MANAGER_H_
+
+// TODO: make this path not hardcoded
+#define DUMMY_REQUEST_HANDLER_EXECUTABLE "/home/hongli/Projects/passenger/benchmark/DummyRequestHandler"
+
+#include <string>
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <cstdio>
+#include <unistd.h>
+#include <errno.h>
+
+#include "Application.h"
+#include "Exceptions.h"
+
+namespace Passenger {
+
+using namespace std;
+
+/**
+ * A dummy SpawnManager replacement for testing/debugging purposes.
+ *
+ * This class implements a dummy spawn manager, and is 100% interface-compatible with
+ * SpawnManager. This spawn manager will spawn <tt>benchmark/DummyRequestHandler</tt>,
+ * which is probably the fastest possible implementation of a request handler. The purpose
+ * of this class to benchmark the performance of the Apache module (i.e. not benchmarking
+ * the Ruby request handler or Rails itself).
+ *
+ * This header file is not used by default. Define the macro <tt>PASSENGER_USE_DUMMY_SPAWN_MANAGER</tt>
+ * to make ApplicationPool use DummySpawnManager instead of SpawnManager.
+ *
+ * Of course, don't forget to compile benchmark/DummyRequestHandler!
+ *
+ * @ingroup Support
+ */
+class DummySpawnManager {
+public:
+	ApplicationPtr spawn(const string &appRoot, const string &user = "", const string &group = "") {
+		int fds[2];
+		pid_t pid;
+		
+		if(socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == -1) {
+			throw SystemException("Cannot create a Unix socket", errno);
+		}
+		pid = fork();
+		if (pid == 0) {
+			pid = fork();
+			if (pid == 0) {
+				dup2(fds[0], STDIN_FILENO);
+				close(fds[0]);
+				close(fds[1]);
+				execlp(DUMMY_REQUEST_HANDLER_EXECUTABLE, DUMMY_REQUEST_HANDLER_EXECUTABLE, NULL);
+				int e = errno;
+				fprintf(stderr, "Unable to run %s: %s\n", DUMMY_REQUEST_HANDLER_EXECUTABLE, strerror(e));
+				fflush(stderr);
+				_exit(1);
+			} else if (pid == -1) {
+				perror("Cannot fork a new process");
+				fflush(stderr);
+				_exit(1);
+			} else {
+				_exit(0);
+			}
+		} else if (pid == -1) {
+			close(fds[0]);
+			close(fds[1]);
+			throw SystemException("Cannot fork a new process", errno);
+		} else {
+			close(fds[0]);
+			waitpid(pid, NULL, 0);
+			return ApplicationPtr(new Application(appRoot, pid, fds[1]));
+		}
+	}
+	
+	pid_t getServerPid() const {
+		return 0;
+	}
+};
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_DUMMY_SPAWN_MANAGER_H_ */

data/ext/apache2/Exceptions.h

@@ -0,0 +1,240 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (C) 2008  Phusion
+ *
+ *  Phusion Passenger is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef _PASSENGER_EXCEPTIONS_H_
+#define _PASSENGER_EXCEPTIONS_H_
+
+#include <oxt/tracable_exception.hpp>
+#include <string>
+#include <sstream>
+#include <cstring>
+
+/**
+ * @defgroup Exceptions Exceptions
+ */
+
+namespace Passenger {
+
+using namespace std;
+
+/**
+ * Represents an error returned by a system call or a standard library call.
+ *
+ * Use the code() method to find out the value of <tt>errno</tt> at the time
+ * the error occured.
+ *
+ * @ingroup Exceptions
+ */
+class SystemException: public oxt::tracable_exception {
+private:
+	string briefMessage;
+	string systemMessage;
+	string fullMessage;
+	int m_code;
+public:
+	/**
+	 * Create a new SystemException.
+	 *
+	 * @param briefMessage A brief message describing the error.
+	 * @param errorCode The error code, i.e. the value of errno right after the error occured.
+	 * @note A system description of the error will be appended to the given message.
+	 *    For example, if <tt>errorCode</tt> is <tt>EBADF</tt>, and <tt>briefMessage</tt>
+	 *    is <em>"Something happened"</em>, then what() will return <em>"Something happened: Bad
+	 *    file descriptor (10)"</em> (if 10 is the number for EBADF).
+	 * @post code() == errorCode
+	 * @post brief() == briefMessage
+	 */
+	SystemException(const string &briefMessage, int errorCode) {
+		stringstream str;
+		
+		str << strerror(errorCode) << " (" << errorCode << ")";
+		systemMessage = str.str();
+		
+		setBriefMessage(briefMessage);
+		m_code = errorCode;
+	}
+	
+	virtual ~SystemException() throw() {}
+	
+	virtual const char *what() const throw() {
+		return fullMessage.c_str();
+	}
+	
+	void setBriefMessage(const string &message) {
+		briefMessage = message;
+		fullMessage = briefMessage + ": " + systemMessage;
+	}
+	
+	/**
+	 * The value of <tt>errno</tt> at the time the error occured.
+	 */
+	int code() const throw() {
+		return m_code;
+	}
+	
+	/**
+	 * Returns a brief version of the exception message. This message does
+	 * not include the system error description, and is equivalent to the
+	 * value of the <tt>message</tt> parameter as passed to the constructor.
+	 */
+	string brief() const throw() {
+		return briefMessage;
+	}
+	
+	/**
+	 * Returns the system's error message. This message contains both the
+	 * content of <tt>strerror(errno)</tt> and the errno number itself.
+	 */
+	string sys() const throw() {
+		return systemMessage;
+	}
+};
+
+/**
+ * A filesystem error, as returned by the operating system. This may include,
+ * for example, permission errors.
+ *
+ * @ingroup Exceptions
+ */
+class FileSystemException: public SystemException {
+private:
+	string m_filename;
+public:
+	FileSystemException(const string &message, int errorCode,
+		const string &filename)
+		: SystemException(message, errorCode),
+		  m_filename(filename) {}
+	
+	virtual ~FileSystemException() throw() {}
+	
+	/**
+	 * The filename that's associated to the error.
+	 */
+	string filename() const throw() {
+		return m_filename;
+	}
+};
+
+/**
+ * Represents an error that occured during an I/O operation.
+ *
+ * @ingroup Exceptions
+ */
+class IOException: public oxt::tracable_exception {
+private:
+	string msg;
+public:
+	IOException(const string &message): msg(message) {}
+	virtual ~IOException() throw() {}
+	virtual const char *what() const throw() { return msg.c_str(); }
+};
+
+/**
+ * Thrown when a certain file cannot be found.
+ */
+class FileNotFoundException: public IOException {
+public:
+	FileNotFoundException(const string &message): IOException(message) {}
+	virtual ~FileNotFoundException() throw() {}
+};
+
+/**
+ * Thrown when an invalid configuration is given.
+ */
+class ConfigurationException: public oxt::tracable_exception {
+private:
+	string msg;
+public:
+	ConfigurationException(const string &message): msg(message) {}
+	virtual ~ConfigurationException() throw() {}
+	virtual const char *what() const throw() { return msg.c_str(); }
+};
+
+/**
+ * Thrown when SpawnManager or ApplicationPool fails to spawn an application
+ * instance. The exception may contain an error page, which is a user-friendly
+ * HTML page with details about the error.
+ */
+class SpawnException: public oxt::tracable_exception {
+private:
+	string msg;
+	bool m_hasErrorPage;
+	string m_errorPage;
+public:
+	SpawnException(const string &message)
+		: msg(message) {
+		m_hasErrorPage = false;
+	}
+	
+	SpawnException(const string &message, const string &errorPage)
+		: msg(message), m_errorPage(errorPage) {
+		m_hasErrorPage = true;
+	}
+	
+	virtual ~SpawnException() throw() {}
+	virtual const char *what() const throw() { return msg.c_str(); }
+	
+	/**
+	 * Check whether an error page is available.
+	 */
+	bool hasErrorPage() const {
+		return m_hasErrorPage;
+	}
+	
+	/**
+	 * Return the error page content.
+	 *
+	 * @pre hasErrorPage()
+	 */
+	const string getErrorPage() const {
+		return m_errorPage;
+	}
+};
+
+/**
+ * A generic runtime exception.
+ *
+ * @ingroup Exceptions
+ */
+class RuntimeException: public oxt::tracable_exception {
+private:
+	string msg;
+public:
+	RuntimeException(const string &message): msg(message) {}
+	virtual ~RuntimeException() throw() {}
+	virtual const char *what() const throw() { return msg.c_str(); }
+};
+
+/**
+ * The application pool is too busy and cannot fulfill a get() request.
+ *
+ * @ingroup Exceptions
+ */
+class BusyException: public oxt::tracable_exception {
+private:
+	string msg;
+public:
+	BusyException(const string &message): msg(message) {}
+	virtual ~BusyException() throw() {}
+	virtual const char *what() const throw() { return msg.c_str(); }
+};
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_EXCEPTIONS_H_ */