passenger 2.0.6 → 2.1.2

data/ext/apache2/LICENSE-CNRI.TXT

@@ -2,6 +2,21 @@ A few functions in ext/apache2/Hooks.cpp are based on the source code of
 mod_scgi version 1.9. Its license is included in this file.
 Please note that these licensing terms *only* encompass those few
 functions, and not Passenger as a whole.
+
+The functions which are based on mod_scgi's code are as follows:
+- Hooks::prepareRequest(). Although our version looks nothing like the
+  original, the idea of checking for the file's existance from the
+  map_to_storage/fixups hook is inspired by mod_scgi's code.
+- Hooks::handleRequest(). Although our version looks nothing like the original,
+  the idea of passing the backend process's socket file descriptor up to the
+  bucket brigade chain is inspired by mod_scgi's code.
+- Hooks::http2env(), Hooks::lookupName(), Hooks::lookupHeader(),
+  Hooks::lookupEnv(), Hooks::addHeader(): Copied from mod_scgi's functions that
+  are named similarly. Slightly modified to make the coding style consistent
+  with the rest of Phusion Passenger.
+- Hooks::sendHeaders(): Based for the most part on mod_scgi's send_headers()
+  function.
+
 ------------------------------------------------------------------------
 CNRI OPEN SOURCE LICENSE AGREEMENT
 

data/ext/apache2/Logging.h

@@ -24,6 +24,7 @@
 #include <sys/time.h>
 #include <unistd.h>
 #include <ostream>
+#include <sstream>
 #include <ctime>
 
 namespace Passenger {
@@ -39,24 +40,38 @@ void setLogLevel(unsigned int value);
 void setDebugFile(const char *logFile = NULL);
 
 /**
- * Write the given expression to the log stream.
+ * Write the given expression to the given stream.
+ *
+ * @param expr The expression to write.
+ * @param stream A pointer to an object that accepts the '<<' operator.
  */
-#define P_LOG(expr) \
+#define P_LOG_TO(expr, stream) \
 	do { \
-		if (Passenger::_logStream != 0) { \
-			time_t the_time = time(NULL); \
-			struct tm *the_tm = localtime(&the_time); \
-			char datetime_buf[60]; \
-			struct timeval tv; \
-			strftime(datetime_buf, sizeof(datetime_buf), "%x %H:%M:%S", the_tm); \
+		if (stream != 0) { \
+			time_t the_time;			\
+			struct tm *the_tm;			\
+			char datetime_buf[60];			\
+			struct timeval tv;			\
+			std::stringstream sstream;              \
+								\
+			the_time = time(NULL);			\
+			the_tm = localtime(&the_time);		\
+			strftime(datetime_buf, sizeof(datetime_buf), "%F %H:%M:%S", the_tm); \
 			gettimeofday(&tv, NULL); \
-			*Passenger::_logStream << \
+			sstream << \
 				"[ pid=" << getpid() << " file=" << __FILE__ << ":" << __LINE__ << \
 				" time=" << datetime_buf << "." << (tv.tv_usec / 1000) << " ]:" << \
-				"\n  " << expr << std::endl; \
+				"\n  " << expr << std::endl;	\
+			*stream << sstream.str();		\
+			stream->flush();			\
 		} \
 	} while (false)
 
+/**
+ * Write the given expression to the log stream.
+ */
+#define P_LOG(expr) P_LOG_TO(expr, Passenger::_logStream)
+
 /**
  * Write the given expression, which represents a warning,
  * to the log stream.
@@ -79,18 +94,7 @@ void setDebugFile(const char *logFile = NULL);
 	#define P_TRACE(level, expr) \
 		do { \
 			if (Passenger::_logLevel >= level) { \
-				if (Passenger::_debugStream != 0) { \
-					time_t the_time = time(NULL); \
-					struct tm *the_tm = localtime(&the_time); \
-					char datetime_buf[60]; \
-					struct timeval tv; \
-					strftime(datetime_buf, sizeof(datetime_buf), "%x %H:%M:%S", the_tm); \
-					gettimeofday(&tv, NULL); \
-					*Passenger::_debugStream << \
-						"[ pid=" << getpid() << " file=" << __FILE__ << ":" << __LINE__ << \
-						" time=" << datetime_buf << "." << (tv.tv_usec / 1000) << " ]:" << \
-						"\n  " << expr << std::endl; \
-				} \
+				P_LOG_TO(expr, Passenger::_debugStream); \
 			} \
 		} while (false)
 	

data/ext/apache2/MessageChannel.h

@@ -20,6 +20,8 @@
 #ifndef _PASSENGER_MESSAGE_CHANNEL_H_
 #define _PASSENGER_MESSAGE_CHANNEL_H_
 
+#include <oxt/system_calls.hpp>
+
 #include <algorithm>
 #include <string>
 #include <list>
@@ -31,14 +33,25 @@
 #include <errno.h>
 #include <unistd.h>
 #include <cstdarg>
+#ifdef __OpenBSD__
+	// OpenBSD needs this for 'struct iovec'. Apparently it isn't
+	// always included by unistd.h and sys/types.h.
+	#include <sys/uio.h>
+#endif
+#if !APR_HAVE_IOVEC
+	// We don't want apr_want.h to redefine 'struct iovec'.
+	// http://tinyurl.com/b6aatw
+	#undef APR_HAVE_IOVEC
+	#define APR_HAVE_IOVEC 1
+#endif
 
-#include "System.h"
 #include "Exceptions.h"
 #include "Utils.h"
 
 namespace Passenger {
 
 using namespace std;
+using namespace oxt;
 
 /**
  * Convenience class for I/O operations on file descriptors.
@@ -99,6 +112,11 @@ class MessageChannel {
 private:
 	const static char DELIMITER = '\0';
 	int fd;
+	
+	#ifdef __OpenBSD__
+		typedef u_int32_t uint32_t;
+		typedef u_int16_t uint16_t;
+	#endif
 
 public:
 	/**
@@ -127,7 +145,7 @@ public:
 	 */
 	void close() {
 		if (fd != -1) {
-			int ret = InterruptableCalls::close(fd);
+			int ret = syscalls::close(fd);
 			if (ret == -1) {
 				throw SystemException("Cannot close file descriptor", errno);
 			}
@@ -139,14 +157,18 @@ public:
 	 * Send an array message, which consists of the given elements, over the underlying
 	 * file descriptor.
 	 *
-	 * @param args The message elements.
+	 * @param args An object which contains the message elements. This object must
+	 *             support STL-style iteration, and each iterator must have an
+	 *             std::string as value. Use the StringArrayType and
+	 *             StringArrayConstIteratorType template parameters to specify the exact type names.
 	 * @throws SystemException An error occured while writing the data to the file descriptor.
 	 * @throws boost::thread_interrupted
 	 * @pre None of the message elements may contain a NUL character (<tt>'\\0'</tt>).
 	 * @see read(), write(const char *, ...)
 	 */
-	void write(const list<string> &args) {
-		list<string>::const_iterator it;
+	template<typename StringArrayType, typename StringArrayConstIteratorType>
+	void write(const StringArrayType &args) {
+		StringArrayConstIteratorType it;
 		string data;
 		uint16_t dataSize = 0;
 
@@ -164,6 +186,34 @@ public:
 		writeRaw(data);
 	}
 	
+	/**
+	 * Send an array message, which consists of the given elements, over the underlying
+	 * file descriptor.
+	 *
+	 * @param args The message elements.
+	 * @throws SystemException An error occured while writing the data to the file descriptor.
+	 * @throws boost::thread_interrupted
+	 * @pre None of the message elements may contain a NUL character (<tt>'\\0'</tt>).
+	 * @see read(), write(const char *, ...)
+	 */
+	void write(const list<string> &args) {
+		write<list<string>, list<string>::const_iterator>(args);
+	}
+	
+	/**
+	 * Send an array message, which consists of the given elements, over the underlying
+	 * file descriptor.
+	 *
+	 * @param args The message elements.
+	 * @throws SystemException An error occured while writing the data to the file descriptor.
+	 * @throws boost::thread_interrupted
+	 * @pre None of the message elements may contain a NUL character (<tt>'\\0'</tt>).
+	 * @see read(), write(const char *, ...)
+	 */
+	void write(const vector<string> &args) {
+		write<vector<string>, vector<string>::const_iterator>(args);
+	}
+	
 	/**
 	 * Send an array message, which consists of the given strings, over the underlying
 	 * file descriptor.
@@ -237,7 +287,7 @@ public:
 		ssize_t ret;
 		unsigned int written = 0;
 		do {
-			ret = InterruptableCalls::write(fd, data + written, size - written);
+			ret = syscalls::write(fd, data + written, size - written);
 			if (ret == -1) {
 				throw SystemException("write() failed", errno);
 			} else {
@@ -273,7 +323,7 @@ public:
 		struct msghdr msg;
 		struct iovec vec;
 		char dummy[1];
-		#ifdef __APPLE__
+		#if defined(__APPLE__) || defined(__SOLARIS__)
 			struct {
 				struct cmsghdr header;
 				int fd;
@@ -301,7 +351,7 @@ public:
 		control_header = CMSG_FIRSTHDR(&msg);
 		control_header->cmsg_level = SOL_SOCKET;
 		control_header->cmsg_type  = SCM_RIGHTS;
-		#ifdef __APPLE__
+		#if defined(__APPLE__) || defined(__SOLARIS__)
 			control_header->cmsg_len = sizeof(control_data);
 			control_data.fd = fileDescriptor;
 		#else
@@ -309,7 +359,7 @@ public:
 			memcpy(CMSG_DATA(control_header), &fileDescriptor, sizeof(int));
 		#endif
 		
-		ret = InterruptableCalls::sendmsg(fd, &msg, 0);
+		ret = syscalls::sendmsg(fd, &msg, 0);
 		if (ret == -1) {
 			throw SystemException("Cannot send file descriptor with sendmsg()", errno);
 		}
@@ -331,7 +381,7 @@ public:
 		unsigned int alreadyRead = 0;
 		
 		do {
-			ret = InterruptableCalls::read(fd, (char *) &size + alreadyRead, sizeof(size) - alreadyRead);
+			ret = syscalls::read(fd, (char *) &size + alreadyRead, sizeof(size) - alreadyRead);
 			if (ret == -1) {
 				throw SystemException("read() failed", errno);
 			} else if (ret == 0) {
@@ -346,7 +396,7 @@ public:
 		buffer.reserve(size);
 		while (buffer.size() < size) {
 			char tmp[1024 * 8];
-			ret = InterruptableCalls::read(fd, tmp, min(size - buffer.size(), sizeof(tmp)));
+			ret = syscalls::read(fd, tmp, min(size - buffer.size(), sizeof(tmp)));
 			if (ret == -1) {
 				throw SystemException("read() failed", errno);
 			} else if (ret == 0) {
@@ -421,7 +471,7 @@ public:
 		unsigned int alreadyRead = 0;
 		
 		while (alreadyRead < size) {
-			ret = InterruptableCalls::read(fd, (char *) buf + alreadyRead, size - alreadyRead);
+			ret = syscalls::read(fd, (char *) buf + alreadyRead, size - alreadyRead);
 			if (ret == -1) {
 				throw SystemException("read() failed", errno);
 			} else if (ret == 0) {
@@ -449,7 +499,7 @@ public:
 		struct msghdr msg;
 		struct iovec vec;
 		char dummy[1];
-		#ifdef __APPLE__
+		#if defined(__APPLE__) || defined(__SOLARIS__)
 			// File descriptor passing macros (CMSG_*) seem to be broken
 			// on 64-bit MacOS X. This structure works around the problem.
 			struct {
@@ -477,7 +527,7 @@ public:
 		msg.msg_controllen = sizeof(control_data);
 		msg.msg_flags      = 0;
 		
-		ret = InterruptableCalls::recvmsg(fd, &msg, 0);
+		ret = syscalls::recvmsg(fd, &msg, 0);
 		if (ret == -1) {
 			throw SystemException("Cannot read file descriptor with recvmsg()", errno);
 		}
@@ -488,12 +538,71 @@ public:
 		 || control_header->cmsg_type  != SCM_RIGHTS) {
 			throw IOException("No valid file descriptor received.");
 		}
-		#ifdef __APPLE__
+		#if defined(__APPLE__) || defined(__SOLARIS__)
 			return control_data.fd;
 		#else
 			return *((int *) CMSG_DATA(control_header));
 		#endif
 	}
+	
+	/**
+	 * Set the timeout value for reading data from this channel.
+	 * If no data can be read within the timeout period, then a
+	 * SystemException will be thrown by one of the read methods,
+	 * with error code EAGAIN or EWOULDBLOCK.
+	 *
+	 * @param msec The timeout, in milliseconds. If 0 is given,
+	 *             there will be no timeout.
+	 * @throws SystemException Cannot set the timeout.
+	 */
+	void setReadTimeout(unsigned int msec) {
+		// See the comment for setWriteTimeout().
+		struct timeval tv;
+		int ret;
+		
+		tv.tv_sec = msec / 1000;
+		tv.tv_usec = msec % 1000 * 1000;
+		ret = syscalls::setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO,
+			&tv, sizeof(tv));
+		#ifndef __SOLARIS__
+		// SO_RCVTIMEO is unimplemented and retuns an error on Solaris
+		// 9 and 10 SPARC.  Seems to work okay without it.
+		if (ret == -1) {
+			throw SystemException("Cannot set read timeout for socket", errno);
+		}
+		#endif
+	}
+	
+	/**
+	 * Set the timeout value for writing data to this channel.
+	 * If no data can be written within the timeout period, then a
+	 * SystemException will be thrown, with error code EAGAIN or
+	 * EWOULDBLOCK.
+	 *
+	 * @param msec The timeout, in milliseconds. If 0 is given,
+	 *             there will be no timeout.
+	 * @throws SystemException Cannot set the timeout.
+	 */
+	void setWriteTimeout(unsigned int msec) {
+		// People say that SO_RCVTIMEO/SO_SNDTIMEO are unreliable and
+		// not well-implemented on all platforms.
+		// http://www.developerweb.net/forum/archive/index.php/t-3439.html
+		// That's why we use APR's timeout facilities as well (see Hooks.cpp).
+		struct timeval tv;
+		int ret;
+		
+		tv.tv_sec = msec / 1000;
+		tv.tv_usec = msec % 1000 * 1000;
+		ret = syscalls::setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO,
+			&tv, sizeof(tv));
+		#ifndef __SOLARIS__
+		// SO_SNDTIMEO is unimplemented and returns an error on Solaris
+		// 9 and 10 SPARC.  Seems to work okay without it.
+		if (ret == -1) {
+			throw SystemException("Cannot set read timeout for socket", errno);
+		}
+		#endif
+	}
 };
 
 } // namespace Passenger

data/ext/apache2/PoolOptions.h

@@ -0,0 +1,283 @@
+/*
+ *  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_SPAWN_OPTIONS_H_
+#define _PASSENGER_SPAWN_OPTIONS_H_
+
+#include <string>
+#include "Utils.h"
+
+namespace Passenger {
+
+using namespace std;
+
+/**
+ * This struct encapsulates information for ApplicationPool::get() and for
+ * SpawnManager::spawn(), such as which application is to be spawned.
+ *
+ * <h2>Notes on privilege lowering support</h2>
+ *
+ * If <tt>lowerPrivilege</tt> is true, then it will be attempt to
+ * switch the spawned application instance to the user who owns the
+ * application's <tt>config/environment.rb</tt>, and to the default
+ * group of that user.
+ *
+ * If that user doesn't exist on the system, or if that user is root,
+ * then it will be attempted to switch to the username given by
+ * <tt>lowestUser</tt> (and to the default group of that user).
+ * If <tt>lowestUser</tt> doesn't exist either, or if switching user failed
+ * (because the spawn server process does not have the privilege to do so),
+ * then the application will be spawned anyway, without reporting an error.
+ *
+ * It goes without saying that lowering privilege is only possible if
+ * the spawn server is running as root (and thus, by induction, that
+ * Phusion Passenger and Apache's control process are also running as root).
+ * Note that if Apache is listening on port 80, then its control process must
+ * be running as root. See "doc/Security of user switching.txt" for
+ * a detailed explanation.
+ */
+struct PoolOptions {
+	/**
+	 * The root directory of the application to spawn. In case of a Ruby on Rails
+	 * application, this is the folder that contains 'app/', 'public/', 'config/',
+	 * etc. This must be a valid directory, but the path does not have to be absolute.
+	 */
+	string appRoot;
+	
+	/** Whether to lower the application's privileges. */
+	bool lowerPrivilege;
+	
+	/**
+	 * The user to fallback to if lowering privilege fails.
+	 */
+	string lowestUser;
+	
+	/**
+	 * The RAILS_ENV/RACK_ENV environment that should be used. May not be an
+	 * empty string.
+	 */
+	string environment;
+	
+	/**
+	 * The spawn method to use. Either "smart" or "conservative". See the Ruby
+	 * class <tt>SpawnManager</tt> for details.
+	 */
+	string spawnMethod;
+	
+	/** The application type. Either "rails", "rack" or "wsgi". */
+	string appType;
+	
+	/**
+	 * The idle timeout, in seconds, of Rails framework spawners.
+	 * A timeout of 0 means that the framework spawner should never idle timeout. A timeout
+	 * of -1 means that the default timeout value should be used.
+	 *
+	 * For more details about Rails framework spawners, please
+	 * read the documentation on the Railz::FrameworkSpawner
+	 * Ruby class.
+	 */
+	long frameworkSpawnerTimeout;
+	
+	/**
+	 * The idle timeout, in seconds, of Rails application spawners.
+	 * A timeout of 0 means that the application spawner should never idle timeout. A timeout
+	 * of -1 means that the default timeout value should be used.
+	 *
+	 * For more details about Rails application spawners, please
+	 * read the documentation on the Railz::ApplicationSpawner
+	 * Ruby class.
+	 */
+	long appSpawnerTimeout;
+	
+	/**
+	 * The maximum number of requests that the spawned application may process
+	 * before exiting. A value of 0 means unlimited.
+	 */
+	unsigned long maxRequests;
+	
+	/**
+	 * The maximum amount of memory (in MB) the spawned application may use.
+	 * A value of 0 means unlimited.
+	 */
+	unsigned long memoryLimit;
+	
+	/**
+	 * Whether to use a global queue instead of a per-backend process
+	 * queue. This option is only used by ApplicationPool::get().
+	 *
+	 * If enabled, when all backend processes are active, get() will
+	 * wait until there's at least one backend process that's idle, instead
+	 * of queuing the request into a random process's private queue.
+	 * This is especially useful if a website has one or more long-running
+	 * requests.
+	 */
+	bool useGlobalQueue;
+	
+	/**
+	 * A throttling rate for file stats. When set to a non-zero value N,
+	 * restart.txt and other files which are usually stat()ted on every
+	 * ApplicationPool::get() call will be stat()ed at most every N seconds.
+	 */
+	unsigned long statThrottleRate;
+	
+	/**
+	 * The directory which contains restart.txt and always_restart.txt.
+	 * An empty string means that the default directory should be used.
+	 */
+	string restartDir;
+	
+	/**
+	 * Creates a new PoolOptions object with the default values filled in.
+	 * One must still set appRoot manually, after having used this constructor.
+	 */
+	PoolOptions() {
+		lowerPrivilege = true;
+		lowestUser     = "nobody";
+		environment    = "production";
+		spawnMethod    = "smart";
+		appType        = "rails";
+		frameworkSpawnerTimeout = -1;
+		appSpawnerTimeout       = -1;
+		maxRequests    = 0;
+		memoryLimit    = 0;
+		useGlobalQueue = false;
+		statThrottleRate        = 0;
+	}
+	
+	/**
+	 * Creates a new PoolOptions object with the given values.
+	 */
+	PoolOptions(const string &appRoot,
+		bool lowerPrivilege       = true,
+		const string &lowestUser  = "nobody",
+		const string &environment = "production",
+		const string &spawnMethod = "smart",
+		const string &appType     = "rails",
+		long frameworkSpawnerTimeout = -1,
+		long appSpawnerTimeout       = -1,
+		unsigned long maxRequests    = 0,
+		unsigned long memoryLimit    = 0,
+		bool useGlobalQueue          = false,
+		unsigned long statThrottleRate = 0,
+		const string &restartDir  = ""
+	) {
+		this->appRoot        = appRoot;
+		this->lowerPrivilege = lowerPrivilege;
+		this->lowestUser     = lowestUser;
+		this->environment    = environment;
+		this->spawnMethod    = spawnMethod;
+		this->appType        = appType;
+		this->frameworkSpawnerTimeout = frameworkSpawnerTimeout;
+		this->appSpawnerTimeout       = appSpawnerTimeout;
+		this->maxRequests    = maxRequests;
+		this->memoryLimit    = memoryLimit;
+		this->useGlobalQueue = useGlobalQueue;
+		this->statThrottleRate        = statThrottleRate;
+		this->restartDir     = restartDir;
+	}
+	
+	/**
+	 * Creates a new PoolOptions object from the given string vector.
+	 * This vector contains information that's written to by toVector().
+	 *
+	 * For example:
+	 * @code
+	 *   PoolOptions options(...);
+	 *   vector<string> vec;
+	 *
+	 *   vec.push_back("my");
+	 *   vec.push_back("data");
+	 *   options.toVector(vec);  // PoolOptions information will start at index 2.
+	 *
+	 *   PoolOptions copy(vec, 2);
+	 * @endcode
+	 *
+	 * @param vec The vector containing spawn options information.
+	 * @param startIndex The index in vec at which the information starts.
+	 */
+	PoolOptions(const vector<string> &vec, unsigned int startIndex = 0) {
+		appRoot        = vec[startIndex + 1];
+		lowerPrivilege = vec[startIndex + 3] == "true";
+		lowestUser     = vec[startIndex + 5];
+		environment    = vec[startIndex + 7];
+		spawnMethod    = vec[startIndex + 9];
+		appType        = vec[startIndex + 11];
+		frameworkSpawnerTimeout = atol(vec[startIndex + 13]);
+		appSpawnerTimeout       = atol(vec[startIndex + 15]);
+		maxRequests    = atol(vec[startIndex + 17]);
+		memoryLimit    = atol(vec[startIndex + 19]);
+		useGlobalQueue = vec[startIndex + 21] == "true";
+		statThrottleRate = atol(vec[startIndex + 23]);
+		restartDir     = vec[startIndex + 25];
+	}
+	
+	/**
+	 * Append the information in this PoolOptions object to the given
+	 * string vector. The resulting array could, for example, be used
+	 * as a message to be sent to the spawn server.
+	 */
+	void toVector(vector<string> &vec) const {
+		if (vec.capacity() < vec.size() + 10) {
+			vec.reserve(vec.size() + 10);
+		}
+		appendKeyValue (vec, "app_root",        appRoot);
+		appendKeyValue (vec, "lower_privilege", lowerPrivilege ? "true" : "false");
+		appendKeyValue (vec, "lowest_user",     lowestUser);
+		appendKeyValue (vec, "environment",     environment);
+		appendKeyValue (vec, "spawn_method",    spawnMethod);
+		appendKeyValue (vec, "app_type",        appType);
+		appendKeyValue2(vec, "framework_spawner_timeout", frameworkSpawnerTimeout);
+		appendKeyValue2(vec, "app_spawner_timeout",       appSpawnerTimeout);
+		appendKeyValue3(vec, "max_requests",    maxRequests);
+		appendKeyValue3(vec, "memory_limit",    memoryLimit);
+		appendKeyValue (vec, "use_global_queue", useGlobalQueue ? "true" : "false");
+		appendKeyValue3(vec, "stat_throttle_rate", statThrottleRate);
+		appendKeyValue (vec, "restart_dir",     restartDir);
+	}
+
+private:
+	static inline void
+	appendKeyValue(vector<string> &vec, const char *key, const string &value) {
+		vec.push_back(key);
+		vec.push_back(const_cast<string &>(value));
+	}
+	
+	static inline void
+	appendKeyValue(vector<string> &vec, const char *key, const char *value) {
+		vec.push_back(key);
+		vec.push_back(value);
+	}
+	
+	static inline void
+	appendKeyValue2(vector<string> &vec, const char *key, long value) {
+		vec.push_back(key);
+		vec.push_back(toString(value));
+	}
+	
+	static inline void
+	appendKeyValue3(vector<string> &vec, const char *key, unsigned long value) {
+		vec.push_back(key);
+		vec.push_back(toString(value));
+	}
+};
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_SPAWN_OPTIONS_H_ */
+