passenger 1.0.5 → 2.0.1

data/ext/apache2/Configuration.h

@@ -2,6 +2,8 @@
  *  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.
@@ -29,7 +31,7 @@
  */
 
 /** Module version number. */
-#define PASSENGER_VERSION "1.0.5"
+#define PASSENGER_VERSION "2.0.1"
 
 #ifdef __cplusplus
 	#include <set>
@@ -38,33 +40,55 @@
 	namespace Passenger {
 	
 		using namespace std;
-
+		
 		/**
 		 * Per-directory configuration information.
 		 */
 		struct DirConfig {
 			enum Threeway { ENABLED, DISABLED, UNSET };
 			
-			std::set<std::string> base_uris;
-			Threeway autoDetect;
+			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 environment (i.e. value for RACK_ENV) under which
+			 * Rack applications should operate. */
+			const char *rackEnv;
+			
+			enum SpawnMethod { SM_UNSET, SM_SMART, SM_CONSERVATIVE };
+			/** The Rails spawn method to use. */
+			SpawnMethod spawnMethod;
 		};
 		
 		/**
-		 * Server-wide configuration information.
+		 * Server-wide (global, not per-virtual host) configuration information.
 		 */
 		struct ServerConfig {
 			/** The filename of the Ruby interpreter to use. */
 			const char *ruby;
 			
-			/** The environment (i.e. value for RAILS_ENV) under which the
-			 * Rails application should operate. */
-			const char *env;
+			/** The Passenger root folder. */
+			const char *root;
 			
-			/** The filename of the spawn server to use. */
-			const char *spawnServer;
+			/** The log verbosity. */
+			unsigned int logLevel;
 			
-			/** The maximum number of simultaneously alive Rails application
+			/** The maximum number of simultaneously alive application
 			 * instances. */
 			unsigned int maxPoolSize;
 			
@@ -72,7 +96,15 @@
 			 * this server config. */
 			bool maxPoolSizeSpecified;
 			
-			/** The maximum number of seconds that a Rails application may be
+			/** 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;
 			
@@ -87,7 +119,7 @@
 			 * this server config. */
 			bool userSwitchingSpecified;
 
-			/** User that Rails applications must run as if user switching
+			/** The user that applications must run as if user switching
 			 * fails or is disabled. NULL means the option is not specified.
 			 */
 			const char *defaultUser;

data/ext/apache2/DummySpawnManager.h

@@ -2,6 +2,8 @@
  *  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.

data/ext/apache2/Exceptions.h

@@ -2,6 +2,8 @@
  *  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.
@@ -99,6 +101,31 @@ public:
 	}
 };
 
+/**
+ * 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.
  *
@@ -122,6 +149,18 @@ public:
 	virtual ~FileNotFoundException() throw() {}
 };
 
+/**
+ * Thrown when an invalid configuration is given.
+ */
+class ConfigurationException: public 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
@@ -163,6 +202,20 @@ public:
 	}
 };
 
+/**
+ * The application pool is too busy and cannot fulfill a get() request.
+ *
+ * @ingroup Exceptions
+ */
+class BusyException: public 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_ */

data/ext/apache2/Hooks.cpp

@@ -2,6 +2,8 @@
  *  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.
@@ -27,17 +29,21 @@
 #include <apr_strings.h>
 #include <apr_lib.h>
 
+#include <boost/thread.hpp>
+
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <exception>
+#include <cstdio>
 #include <unistd.h>
 
 #include "Hooks.h"
 #include "Configuration.h"
 #include "Utils.h"
 #include "Logging.h"
-#include "ApplicationPoolClientServer.h"
+#include "ApplicationPoolServer.h"
 #include "MessageChannel.h"
+#include "System.h"
 
 using namespace std;
 using namespace Passenger;
@@ -45,69 +51,167 @@ using namespace Passenger;
 extern "C" module AP_MODULE_DECLARE_DATA passenger_module;
 
 #define DEFAULT_RUBY_COMMAND "ruby"
-#define DEFAULT_RAILS_ENV "production"
+#define DEFAULT_RAILS_ENV    "production"
+#define DEFAULT_RACK_ENV     "production"
+#define DEFAULT_WSGI_ENV     "production"
 
+/**
+ * If the HTTP client sends POST data larger than this value (in bytes),
+ * then the POST data will be fully saved into a temporary file, before
+ * allocating a Ruby web application session.
+ */
+#define UPLOAD_ACCELERATION_THRESHOLD 1024 * 8
 
-class Hooks {
-private:
-	struct Container {
-		Application::SessionPtr session;
-		
-		static apr_status_t cleanup(void *p) {
-			delete (Container *) p;
-			return APR_SUCCESS;
-		}
+
+/**
+ * Utility class for determining URI-to-Rails/Rack directory mappings.
+ * Given a URI, it will determine whether that URI belongs to a Rails/Rack
+ * application, what the base URI of that application is, and what the
+ * associated 'public' directory is.
+ *
+ * @note This class is not thread-safe, but is reentrant.
+ * @ingroup Core
+ */
+class DirectoryMapper {
+public:
+	enum ApplicationType {
+		NONE,
+		RAILS,
+		RACK,
+		WSGI
 	};
 
-	ApplicationPoolServerPtr applicationPoolServer;
-	ApplicationPoolPtr applicationPool;
+private:
+	DirConfig *config;
+	request_rec *r;
+	bool baseURIKnown;
+	const char *baseURI;
+	ApplicationType appType;
 	
-	DirConfig *getDirConfig(request_rec *r) {
-		return (DirConfig *) ap_get_module_config(r->per_dir_config, &passenger_module);
+	inline bool shouldAutoDetectRails() {
+		return config->autoDetectRails == DirConfig::ENABLED ||
+			config->autoDetectRails == DirConfig::UNSET;
 	}
 	
-	ServerConfig *getServerConfig(server_rec *s) {
-		return (ServerConfig *) ap_get_module_config(s->module_config, &passenger_module);
+	inline bool shouldAutoDetectRack() {
+		return config->autoDetectRack == DirConfig::ENABLED ||
+			config->autoDetectRack == DirConfig::UNSET;
+	}
+	
+	inline bool shouldAutoDetectWSGI() {
+		return config->autoDetectWSGI == DirConfig::ENABLED ||
+			config->autoDetectWSGI == DirConfig::UNSET;
+	}
+	
+public:
+	/**
+	 * @warning Do not use this object after the destruction of <tt>r</tt> or <tt>config</tt>.
+	 */
+	DirectoryMapper(request_rec *r, DirConfig *config) {
+		this->r = r;
+		this->config = config;
+		appType = NONE;
+		baseURIKnown = false;
+		baseURI = NULL;
 	}
 	
 	/**
 	 * Determine whether the given HTTP request falls under one of the specified
-	 * RailsBaseURIs. If yes, then the first matching base URI will be returned.
+	 * RailsBaseURIs or RackBaseURIs. If yes, then the first matching base URI will
+	 * be returned.
 	 *
-	 * If Rails autodetection was enabled in the configuration, then this function
-	 * will return '/' if the document root seems to be a valid Rails 'public' folder.
+	 * If Rails/Rack autodetection was enabled in the configuration, and the document
+	 * root seems to be a valid Rails/Rack 'public' folder, then this method will
+	 * return "/".
 	 *
 	 * Otherwise, NULL will be returned.
+	 *
+	 * @throws SystemException An error occured while examening the filesystem.
+	 * @warning The return value may only be used as long as <tt>config</tt>
+	 *          hasn't been destroyed.
 	 */
-	const char *determineRailsBaseURI(request_rec *r, DirConfig *config) {
+	const char *getBaseURI() {
+		if (baseURIKnown) {
+			return baseURI;
+		}
+		
 		set<string>::const_iterator it;
 		const char *uri = r->uri;
 		size_t uri_len = strlen(uri);
 		
 		if (uri_len == 0 || uri[0] != '/') {
+			baseURIKnown = true;
 			return NULL;
 		}
 		
-		for (it = config->base_uris.begin(); it != config->base_uris.end(); it++) {
+		for (it = config->railsBaseURIs.begin(); it != config->railsBaseURIs.end(); it++) {
 			const string &base(*it);
 			if (  base == "/"
 			 || ( uri_len == base.size() && memcmp(uri, base.c_str(), uri_len) == 0 )
 			 || ( uri_len  > base.size() && memcmp(uri, base.c_str(), base.size()) == 0
 			                             && uri[base.size()] == '/' )
 			) {
-				return apr_pstrdup(r->pool, base.c_str());
+				baseURIKnown = true;
+				baseURI = base.c_str();
+				appType = RAILS;
+				return baseURI;
 			}
 		}
 		
-		if ((config->autoDetect == DirConfig::ENABLED || config->autoDetect == DirConfig::UNSET)
-		 && verifyRailsDir(ap_document_root(r))) {
-			return "/";
+		for (it = config->rackBaseURIs.begin(); it != config->rackBaseURIs.end(); it++) {
+			const string &base(*it);
+			if (  base == "/"
+			 || ( uri_len == base.size() && memcmp(uri, base.c_str(), uri_len) == 0 )
+			 || ( uri_len  > base.size() && memcmp(uri, base.c_str(), base.size()) == 0
+			                             && uri[base.size()] == '/' )
+			) {
+				baseURIKnown = true;
+				baseURI = base.c_str();
+				appType = RACK;
+				return baseURI;
+			}
+		}
+		
+		if (shouldAutoDetectRails() && verifyRailsDir(ap_document_root(r))) {
+			baseURIKnown = true;
+			baseURI = "/";
+			appType = RAILS;
+			return baseURI;
+		}
+		if (shouldAutoDetectRack() && verifyRackDir(ap_document_root(r))) {
+			baseURIKnown = true;
+			baseURI = "/";
+			appType = RACK;
+			return baseURI;
+		}
+		if (shouldAutoDetectWSGI() && verifyWSGIDir(ap_document_root(r))) {
+			baseURIKnown = true;
+			baseURI = "/";
+			appType = WSGI;
+			return baseURI;
 		}
 		
+		baseURIKnown = true;
 		return NULL;
 	}
 	
-	string determineRailsDir(request_rec *r, const char *baseURI) {
+	/**
+	 * Returns the filename of the 'public' directory of the Rails/Rack application
+	 * that's associated with the HTTP request.
+	 *
+	 * Returns an empty string if the document root of the HTTP request
+	 * cannot be determined, or if it isn't a valid folder.
+	 *
+	 * @throws SystemException An error occured while examening the filesystem.
+	 */
+	string getPublicDirectory() {
+		if (!baseURIKnown) {
+			getBaseURI();
+		}
+		if (baseURI == NULL) {
+			return "";
+		}
+		
 		const char *docRoot = ap_document_root(r);
 		size_t len = strlen(docRoot);
 		if (len > 0) {
@@ -126,6 +230,112 @@ private:
 		}
 	}
 	
+	/**
+	 * Returns the application type that's associated with the HTTP request.
+	 *
+	 * @throws SystemException An error occured while examening the filesystem.
+	 */
+	ApplicationType getApplicationType() {
+		if (!baseURIKnown) {
+			getBaseURI();
+		}
+		return appType;
+	}
+	
+	/**
+	 * Returns the application type (as a string) that's associated
+	 * with the HTTP request.
+	 *
+	 * @throws SystemException An error occured while examening the filesystem.
+	 */
+	const char *getApplicationTypeString() {
+		if (!baseURIKnown) {
+			getBaseURI();
+		}
+		switch (appType) {
+		case RAILS:
+			return "rails";
+		case RACK:
+			return "rack";
+		case WSGI:
+			return "wsgi";
+		default:
+			return NULL;
+		};
+	}
+};
+
+
+/**
+ * Apache hook functions, wrapped in a class.
+ *
+ * @ingroup Core
+ */
+class Hooks {
+private:
+	struct Container {
+		Application::SessionPtr session;
+		
+		static apr_status_t cleanup(void *p) {
+			try {
+				this_thread::disable_interruption di;
+				this_thread::disable_syscall_interruption dsi;
+				delete (Container *) p;
+			} catch (const thread_interrupted &) {
+				P_TRACE(3, "A system call was interrupted during closing "
+					"of a session. Apache is probably restarting or "
+					"shutting down.");
+			} catch (const exception &e) {
+				P_TRACE(3, "Exception during closing of a session: " <<
+					e.what());
+			}
+			return APR_SUCCESS;
+		}
+	};
+
+	ApplicationPoolPtr applicationPool;
+	ApplicationPoolServerPtr applicationPoolServer;
+	
+	DirConfig *getDirConfig(request_rec *r) {
+		return (DirConfig *) ap_get_module_config(r->per_dir_config, &passenger_module);
+	}
+	
+	ServerConfig *getServerConfig(server_rec *s) {
+		return (ServerConfig *) ap_get_module_config(s->module_config, &passenger_module);
+	}
+	
+	int reportDocumentRootDeterminationError(request_rec *r) {
+		ap_set_content_type(r, "text/html; charset=UTF-8");
+		ap_rputs("<h1>Passenger error #1</h1>\n", r);
+		ap_rputs("Cannot determine the document root for the current request.", r);
+		return OK;
+	}
+	
+	int reportFileSystemError(request_rec *r, const FileSystemException &e) {
+		ap_set_content_type(r, "text/html; charset=UTF-8");
+		ap_rputs("<h1>Passenger error #2</h1>\n", r);
+		ap_rputs("An error occurred while trying to access '", r);
+		ap_rputs(ap_escape_html(r->pool, e.filename().c_str()), r);
+		ap_rputs("': ", r);
+		ap_rputs(ap_escape_html(r->pool, e.what()), r);
+		if (e.code() == EPERM) {
+			ap_rputs("<p>", r);
+			ap_rputs("Apache doesn't have read permissions to that file. ", r);
+			ap_rputs("Please fix the relevant file permissions.", r);
+			ap_rputs("</p>", r);
+		}
+		return OK;
+	}
+	
+	int reportBusyException(request_rec *r) {
+		ap_custom_response(r, HTTP_SERVICE_UNAVAILABLE,
+			"This website is too busy right now.  Please try again later.");
+		return HTTP_SERVICE_UNAVAILABLE;
+	}
+	
+	/**
+	 * Convert an HTTP header name to a CGI environment name.
+	 */
 	char *http2env(apr_pool_t *p, const char *name) {
 		char *env_name = apr_pstrcat(p, "HTTP_", name, NULL);
 		char *cp;
@@ -191,7 +401,7 @@ private:
 		return apr_pstrmemdup(r->pool, first, last - first);
 	}
 
-	void addHeader(apr_table_t *table, const char *name, const char *value) {
+	void inline addHeader(apr_table_t *table, const char *name, const char *value) {
 		if (name != NULL && value != NULL) {
 			apr_table_addn(table, name, value);
 		}
@@ -218,11 +428,12 @@ private:
 		addHeader(headers, "REQUEST_URI",     originalURI(r));
 		addHeader(headers, "QUERY_STRING",    r->args ? r->args : "");
 		if (strcmp(baseURI, "/") != 0) {
-			addHeader(headers, "SCRIPT_NAME",     baseURI);
+			addHeader(headers, "SCRIPT_NAME", baseURI);
 		}
 		addHeader(headers, "HTTPS",           lookupEnv(r, "HTTPS"));
 		addHeader(headers, "CONTENT_TYPE",    lookupHeader(r, "Content-type"));
 		addHeader(headers, "DOCUMENT_ROOT",   ap_document_root(r));
+		addHeader(headers, "PATH_INFO",       r->parsed_uri.path);
 		
 		// Set HTTP headers.
 		const apr_array_header_t *hdrs_arr;
@@ -236,7 +447,7 @@ private:
 				addHeader(headers, http2env(r->pool, hdrs[i].key), hdrs[i].val);
 			}
 		}
-	
+		
 		// Add other environment variables.
 		const apr_array_header_t *env_arr;
 		apr_table_entry_t *env;
@@ -290,33 +501,70 @@ private:
 		return APR_SUCCESS;
 	}
 	
-	apr_status_t sendRequestBody(request_rec *r, Application::SessionPtr &session) {
-		if (ap_should_client_block(r)) {
+	shared_ptr<TempFile> receiveRequestBody(request_rec *r) {
+		shared_ptr<TempFile> tempFile(new TempFile());
+		char buf[1024 * 32];
+		apr_off_t len;
+		
+		while ((len = ap_get_client_block(r, buf, sizeof(buf))) > 0) {
+			size_t written = 0;
+			do {
+				size_t ret = fwrite(buf, 1, len - written, tempFile->handle);
+				if (ret == 0) {
+					throw SystemException("An error occured while writing "
+						"HTTP upload data to a temporary file",
+						errno);
+				}
+				written += ret;
+			} while (written < len);
+		}
+		if (len == -1) {
+			throw IOException("An error occurred while receiving HTTP upload data.");
+		}
+		if (ftell(tempFile->handle) != atol(lookupHeader(r, "Content-Length"))) {
+			throw IOException("The HTTP client sent incomplete upload data.");
+		}
+		return tempFile;
+	}
+	
+	void sendRequestBody(request_rec *r, Application::SessionPtr &session, shared_ptr<TempFile> &uploadData) {
+		rewind(uploadData->handle);
+		P_DEBUG("Content-Length = " << lookupHeader(r, "Content-Length"));
+		while (!feof(uploadData->handle)) {
 			char buf[1024 * 32];
-			apr_off_t len;
+			size_t size;
 			
-			while ((len = ap_get_client_block(r, buf, sizeof(buf))) > 0) {
-				session->sendBodyBlock(buf, len);
-			}
-			if (len == -1) {
-				return HTTP_INTERNAL_SERVER_ERROR;
-			}
+			size = fread(buf, 1, sizeof(buf), uploadData->handle);
+			
+			session->sendBodyBlock(buf, size);
+		}
+	}
+	
+	void sendRequestBody(request_rec *r, Application::SessionPtr &session) {
+		char buf[1024 * 32];
+		apr_off_t len;
+
+		while ((len = ap_get_client_block(r, buf, sizeof(buf))) > 0) {
+			session->sendBodyBlock(buf, len);
+		}
+		if (len == -1) {
+			throw IOException("An error occurred while receiving HTTP upload data.");
 		}
-		session->closeWriter();
-		return APR_SUCCESS;
 	}
 
 public:
 	Hooks(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s) {
-		ap_add_version_component(pconf, "Phusion_Passenger/" PASSENGER_VERSION);
 		passenger_config_merge_all_servers(pconf, s);
-		
 		ServerConfig *config = getServerConfig(s);
-		const char *ruby, *environment, *user;
-		string spawnServer;
+		Passenger::setLogLevel(config->logLevel);
+		
+		P_DEBUG("Initializing Phusion Passenger...");
+		ap_add_version_component(pconf, "Phusion_Passenger/" PASSENGER_VERSION);
+		
+		const char *ruby, *user;
+		string applicationPoolServerExe, spawnServer;
 		
 		ruby = (config->ruby != NULL) ? config->ruby : DEFAULT_RUBY_COMMAND;
-		environment = (config->env != NULL) ? config->env : DEFAULT_RAILS_ENV;
 		if (config->userSwitching) {
 			user = "";
 		} else if (config->defaultUser != NULL) {
@@ -324,26 +572,35 @@ public:
 		} else {
 			user = "nobody";
 		}
-		if (config->spawnServer != NULL) {
-			spawnServer = config->spawnServer;
-		} else {
-			spawnServer = findSpawnServer();
-			if (spawnServer.empty()) {
-				throw FileNotFoundException("The Passenger spawn server script "
-					"could not be found. Please ensure that it can be found "
-					"in $PATH, or specify it with the RailsSpawnServer "
-					"configuration option.");
-			}
+		
+		if (config->root == NULL) {
+			throw ConfigurationException("The 'PassengerRoot' configuration option "
+				"is not specified. This option is required, so please specify it. "
+				"TIP: The correct value for this option was given to you by "
+				"'passenger-install-apache2-module'.");
 		}
+		
+		spawnServer = findSpawnServer(config->root);
 		if (!fileExists(spawnServer.c_str())) {
-			string message("The specified Passenger spawn server script, '");
+			string message("The Passenger spawn server script, '");
 			message.append(spawnServer);
-			message.append("', does not exist.");
+			message.append("', does not exist. Please check whether the 'PassengerRoot' "
+				"option is specified correctly.");
+			throw FileNotFoundException(message);
+		}
+		applicationPoolServerExe = findApplicationPoolServer(config->root);
+		if (!fileExists(applicationPoolServerExe.c_str())) {
+			string message("The Passenger application pool server, '");
+			message.append(applicationPoolServerExe);
+			message.append("', does not exist. Please check whether the 'PassengerRoot' "
+				"option is specified correctly.");
 			throw FileNotFoundException(message);
 		}
 		
 		applicationPoolServer = ptr(
-			new ApplicationPoolServer(spawnServer, "", environment, ruby, user)
+			new ApplicationPoolServer(
+				applicationPoolServerExe, spawnServer, "",
+				ruby, user)
 		);
 	}
 	
@@ -354,37 +611,34 @@ public:
 			applicationPool = applicationPoolServer->connect();
 			applicationPoolServer->detach();
 			applicationPool->setMax(config->maxPoolSize);
+			applicationPool->setMaxPerApp(config->maxInstancesPerApp);
 			applicationPool->setMaxIdleTime(config->poolIdleTime);
+		} catch (const thread_interrupted &) {
+			P_TRACE(3, "A system call was interrupted during initialization of "
+				"an Apache child process. Apache is probably restarting or "
+				"shutting down.");
 		} catch (const exception &e) {
-			fprintf(stderr, "*** Cannot initialize Passenger: %s\n", e.what());
-			fflush(stderr);
+			P_WARN("Cannot initialize Passenger in an Apache child process: " <<
+				e.what() <<
+				" (this warning is harmless if you're currently restarting "
+				"or shutting down Apache)\n");
 			abort();
 		}
 	}
 	
 	int handleRequest(request_rec *r) {
 		DirConfig *config = getDirConfig(r);
-		const char *railsBaseURI = determineRailsBaseURI(r, config);
-		if (railsBaseURI == NULL || r->filename == NULL || fileExists(r->filename)) {
+		DirectoryMapper mapper(r, config);
+		if (mapper.getBaseURI() == NULL || r->filename == NULL || fileExists(r->filename)) {
 			return DECLINED;
 		}
 		
-		string railsDir(determineRailsDir(r, railsBaseURI));
-		if (railsDir.empty()) {
-			ap_set_content_type(r, "text/html; charset=UTF-8");
-			ap_rputs("<h1>Passenger error #1</h1>\n", r);
-			ap_rputs("Cannot determine the location of the Rails application's \"public\" directory.", r);
-			return OK;
-		} else if (!verifyRailsDir(railsDir)) {
-			ap_set_content_type(r, "text/html; charset=UTF-8");
-			ap_rputs("<h1>Passenger error #2</h1>\n", r);
-			ap_rputs("Passenger thought that the Rails application's \"public\" directory is \"", r);
-			ap_rputs(ap_escape_html(r->pool, railsDir.c_str()), r);
-			ap_rputs("\". But upon further inspection, it doesn't seem to be a valid Rails ", r);
-			ap_rputs("\"public\" folder. It is possible that Apache doesn't have read ", r);
-			ap_rputs("permissions to your Rails application's folder. Please check your ", r);
-			ap_rputs("file permissions.", r);
-			return OK;
+		try {
+			if (mapper.getPublicDirectory().empty()) {
+				return reportDocumentRootDeterminationError(r);
+			}
+		} catch (const FileSystemException &e) {
+			return reportFileSystemError(r, e);
 		}
 		
 		int httpStatus = ap_setup_client_block(r, REQUEST_CHUNKED_ERROR);
@@ -393,13 +647,22 @@ public:
 		}
 		
 		try {
+			this_thread::disable_interruption di;
+			this_thread::disable_syscall_interruption dsi;
 			apr_bucket_brigade *bb;
 			apr_bucket *b;
 			Application::SessionPtr session;
+			bool expectingUploadData;
+			shared_ptr<TempFile> uploadData;
+			
+			expectingUploadData = ap_should_client_block(r);
+			if (expectingUploadData && atol(lookupHeader(r, "Content-Length"))
+			                                 > UPLOAD_ACCELERATION_THRESHOLD) {
+				uploadData = receiveRequestBody(r);
+			}
 			
-			P_DEBUG("Processing HTTP request: " << r->uri);
 			try {
-				const char *defaultUser;
+				const char *defaultUser, *environment, *spawnMethod;
 				ServerConfig *sconfig;
 				
 				sconfig = getServerConfig(r->server);
@@ -408,8 +671,32 @@ public:
 				} else {
 					defaultUser = "nobody";
 				}
-				session = applicationPool->get(canonicalizePath(railsDir + "/.."),
-					true, defaultUser);
+				if (mapper.getApplicationType() == DirectoryMapper::RAILS) {
+					if (config->railsEnv == NULL) {
+						environment = DEFAULT_RAILS_ENV;
+					} else {
+						environment = config->railsEnv;
+					}
+				} else if (mapper.getApplicationType() == DirectoryMapper::RACK) {
+					if (config->rackEnv == NULL) {
+						environment = DEFAULT_RACK_ENV;
+					} else {
+						environment = config->rackEnv;
+					}
+				} else {
+					environment = DEFAULT_WSGI_ENV;
+				}
+				if (config->spawnMethod == DirConfig::SM_CONSERVATIVE) {
+					spawnMethod = "conservative";
+				} else {
+					spawnMethod = "smart";
+				}
+				
+				session = applicationPool->get(
+					canonicalizePath(mapper.getPublicDirectory() + "/.."),
+					true, defaultUser, environment, spawnMethod,
+					mapper.getApplicationTypeString());
+				P_TRACE(3, "Forwarding " << r->uri << " to PID " << session->getPid());
 			} catch (const SpawnException &e) {
 				if (e.hasErrorPage()) {
 					ap_set_content_type(r, "text/html; charset=utf-8");
@@ -420,12 +707,22 @@ public:
 				} else {
 					throw;
 				}
+			} catch (const BusyException &e) {
+				return reportBusyException(r);
+			}
+			sendHeaders(r, session, mapper.getBaseURI());
+			if (expectingUploadData) {
+				if (uploadData != NULL) {
+					sendRequestBody(r, session, uploadData);
+					uploadData.reset();
+				} else {
+					sendRequestBody(r, session);
+				}
 			}
-			sendHeaders(r, session, railsBaseURI);
-			sendRequestBody(r, session);
+			session->shutdownWriter();
 			
 			apr_file_t *readerPipe = NULL;
-			int reader = session->getReader();
+			int reader = session->getStream();
 			apr_os_pipe_put(&readerPipe, &reader, r->pool);
 
 			bb = apr_brigade_create(r->connection->pool, r->connection->bucket_alloc);
@@ -441,8 +738,16 @@ public:
 			Container *container = new Container();
 			container->session = session;
 			apr_pool_cleanup_register(r->pool, container, Container::cleanup, apr_pool_cleanup_null);
+			
+			// Apparently apr_bucket_pipe or apr_brigade closes the
+			// file descriptor for us.
+			session->discardStream();
 
 			return OK;
+		} catch (const thread_interrupted &) {
+			P_TRACE(3, "A system call was interrupted during an HTTP request. Apache "
+				"is probably restarting or shutting down.");
+			return HTTP_INTERNAL_SERVER_ERROR;
 		} catch (const exception &e) {
 			ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "*** Unexpected error in Passenger: %s", e.what());
 			return HTTP_INTERNAL_SERVER_ERROR;
@@ -452,82 +757,87 @@ public:
 	int
 	mapToStorage(request_rec *r) {
 		DirConfig *config = getDirConfig(r);
-		bool forwardToRails;
-		const char *baseURI;
-		
-		baseURI = determineRailsBaseURI(r, config);
-		if (baseURI == NULL || fileExists(r->filename)) {
-			/*
-			 * fileExists():
-			 * If the file already exists, serve it directly.
-			 * This is for static assets like .css and .js files.
-			 */
-			forwardToRails = false;
-		} else if (r->method_number == M_GET) {
-			char *html_file;
-			size_t len;
-			
-			len = strlen(r->filename);
-			if (len > 0 && r->filename[len - 1] == '/') {
-				html_file = apr_pstrcat(r->pool, r->filename, "index.html", NULL);
-			} else {
-				html_file = apr_pstrcat(r->pool, r->filename, ".html", NULL);
-			}
-			if (fileExists(html_file)) {
-				/* If a .html version of the URI exists, serve it directly.
-				 * We're essentially accelerating Rails page caching.
+		DirectoryMapper mapper(r, config);
+		bool forwardToApplication;
+		
+		try {
+			if (mapper.getBaseURI() == NULL || fileExists(r->filename)) {
+				/*
+				 * fileExists():
+				 * If the file already exists, serve it directly.
+				 * This is for static assets like .css and .js files.
 				 */
-				r->filename = html_file;
-				r->canonical_filename = html_file;
-				forwardToRails = false;
+				forwardToApplication = false;
+			} else if (r->method_number == M_GET) {
+				char *html_file;
+				size_t len;
+				
+				len = strlen(r->filename);
+				if (len > 0 && r->filename[len - 1] == '/') {
+					html_file = apr_pstrcat(r->pool, r->filename, "index.html", NULL);
+				} else {
+					html_file = apr_pstrcat(r->pool, r->filename, ".html", NULL);
+				}
+				if (fileExists(html_file)) {
+					/* If a .html version of the URI exists, serve it directly.
+					 * We're essentially accelerating Rails page caching.
+					 */
+					r->filename = html_file;
+					r->canonical_filename = html_file;
+					forwardToApplication = false;
+				} else {
+					forwardToApplication = true;
+				}
 			} else {
-				forwardToRails = true;
-			}
-		} else {
-			/*
-			 * Non-GET requests are always forwarded to Rails.
-			 * This important because of REST conventions, e.g.
-			 * 'POST /foo' maps to 'FooController.create',
-			 * while 'GET /foo' maps to 'FooController.index'.
-			 * We wouldn't want our page caching support to interfere
-			 * with that.
-			 */
-			forwardToRails = true;
-		}
-		
-		if (forwardToRails) {
-			/* Apache's default map_to_storage process does strange
-			 * things with the filename. Suppose that the DocumentRoot
-			 * is /website, on server http://test.com/. If we access
-			 * http://test.com/foo/bar, and /website/foo/bar does not
-			 * exist, then Apache will change the filename to
-			 * /website/foo instead of the expected /website/bar.
-			 * We make sure that doesn't happen.
-			 *
-			 * Incidentally, this also disables mod_rewrite. That is a
-			 * good thing because the default Rails .htaccess file
-			 * interferes with Passenger anyway (it delegates requests
-			 * to the CGI script dispatch.cgi).
-			 */
-			if (config->allowModRewrite == DirConfig::UNSET
-			 || config->allowModRewrite == DirConfig::DISABLED) {
-				/* Of course, we only do that if the config allows us
-				 * to. Some people have complex mod_rewrite rules that
-				 * they don't want to abandon. Those people will have to
-				 * make sure that the Rails app's .htaccess doesn't
-				 * interfere.
+				/*
+				 * Non-GET requests are always forwarded to the application.
+				 * This important because of REST conventions, e.g.
+				 * 'POST /foo' maps to 'FooController.create',
+				 * while 'GET /foo' maps to 'FooController.index'.
+				 * We wouldn't want our page caching support to interfere
+				 * with that.
 				 */
-				return OK;
-			} else if (strcmp(r->uri, baseURI) == 0) {
-				/* But we ignore RailsAllowModRewrite for the base URI of
-				 * the Rails application. Otherwise, Apache will show a
-				 * directory listing. This fixes issue #11.
+				forwardToApplication = true;
+			}
+			
+			if (forwardToApplication) {
+				/* Apache's default map_to_storage process does strange
+				 * things with the filename. Suppose that the DocumentRoot
+				 * is /website, on server http://test.com/. If we access
+				 * http://test.com/foo/bar, and /website/foo/bar does not
+				 * exist, then Apache will change the filename to
+				 * /website/foo instead of the expected /website/bar.
+				 * We make sure that doesn't happen.
+				 *
+				 * Incidentally, this also disables mod_rewrite. That is a
+				 * good thing because the default Rails .htaccess file
+				 * interferes with Passenger anyway (it delegates requests
+				 * to the CGI script dispatch.cgi).
 				 */
-				return OK;
+				if (config->allowModRewrite != DirConfig::ENABLED
+				 && mapper.getApplicationType() == DirectoryMapper::RAILS) {
+					/* Of course, we only do that if all of the following
+					 * are true:
+					 * - the config allows us to. Some people have complex
+					 *   mod_rewrite rules that they don't want to abandon.
+					 *   Those people will have to make sure that the Rails
+					 *   app's .htaccess doesn't interfere.
+					 * - this is a Rails application.
+					 */
+					return OK;
+				} else if (strcmp(r->uri, mapper.getBaseURI()) == 0) {
+					/* If the request URI is the application's base URI,
+					 * then we'll want to take over control. Otherwise,
+					 * Apache will show a directory listing. This fixes issue #11.
+					 */
+					return OK;
+				} else {
+					return DECLINED;
+				}
 			} else {
 				return DECLINED;
 			}
-		} else {
+		} catch (const FileSystemException &e) {
 			return DECLINED;
 		}
 	}
@@ -548,7 +858,18 @@ static Hooks *hooks = NULL;
 
 static apr_status_t
 destroy_hooks(void *arg) {
-	delete hooks;
+	try {
+		this_thread::disable_interruption di;
+		this_thread::disable_syscall_interruption dsi;
+		P_DEBUG("Shutting down Phusion Passenger...");
+		delete hooks;
+	} catch (const thread_interrupted &) {
+		// Ignore interruptions, we're shutting down anyway.
+		P_TRACE(3, "A system call was interrupted during shutdown of mod_passenger.");
+	} catch (const exception &e) {
+		// Ignore other exceptions, we're shutting down anyway.
+		P_TRACE(3, "Exception during shutdown of mod_passenger: " << e.what());
+	}
 	return APR_SUCCESS;
 }
 
@@ -572,6 +893,7 @@ init_module(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *
 	 * hacks, and now we always initialize in the post_config hook.
 	 */
 	if (hooks != NULL) {
+		P_DEBUG("Restarting Phusion Passenger....");
 		delete hooks;
 	}
 	try {
@@ -580,6 +902,12 @@ init_module(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *
 			destroy_hooks,
 			apr_pool_cleanup_null);
 		return OK;
+	
+	} catch (const thread_interrupted &) {
+		P_TRACE(2, "A system call was interrupted during mod_passenger "
+			"initialization. Apache might be restarting or shutting down.");
+		return DECLINED;
+	
 	} catch (const thread_resource_error &e) {
 		struct rlimit lim;
 		string pthread_threads_max;