passenger 2.2.15 → 3.0.0.pre1

data/ext/common/{SystemTime.cpp → Utils/SystemTime.cpp}

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - http://www.modrails.com/
- *  Copyright (c) 2009 Phusion
+ *  Copyright (c) 2010 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -29,5 +29,9 @@ namespace Passenger {
 	namespace SystemTimeData {
 		bool hasForcedValue = false;
 		time_t forcedValue = 0;
+		bool hasForcedMsecValue = false;
+		unsigned long long forcedMsecValue = 0;
+		bool hasForcedUsecValue = false;
+		unsigned long long forcedUsecValue = 0;
 	}
 }

data/ext/common/Utils/SystemTime.h

@@ -0,0 +1,201 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2010 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+#ifndef _PASSENGER_SYSTEM_TIME_H_
+#define _PASSENGER_SYSTEM_TIME_H_
+
+#include <boost/thread.hpp>
+#include <oxt/system_calls.hpp>
+#include "../Exceptions.h"
+
+namespace Passenger {
+
+using namespace oxt;
+
+namespace SystemTimeData {
+	extern bool hasForcedValue;
+	extern time_t forcedValue;
+	extern bool hasForcedMsecValue;
+	extern unsigned long long forcedMsecValue;
+	extern bool hasForcedUsecValue;
+	extern unsigned long long forcedUsecValue;
+}
+
+/**
+ * This class allows one to obtain the system time, similar to time() and
+ * gettimeofday(). Unlike time(), it is possible to force a certain time
+ * to be returned, which is useful for testing code that depends on the
+ * system time.
+ *
+ * get() provides seconds resolution while getMsec() provides milliseconds
+ * resolution. Both clocks can be independently forced to a certain value
+ * through force() and forceMsec().
+ */
+class SystemTime {
+public:
+	/**
+	 * Returns the time since the Epoch, measured in seconds. Or, if a time
+	 * was forced with force(), then the forced time is returned instead.
+	 *
+	 * @throws TimeRetrievalException Something went wrong while retrieving the time.
+	 * @throws boost::thread_interrupted
+	 */
+	static time_t get() {
+		if (SystemTimeData::hasForcedValue) {
+			return SystemTimeData::forcedValue;
+		} else {
+			time_t ret = syscalls::time(NULL);
+			if (ret == -1) {
+				int e = errno;
+				throw TimeRetrievalException(
+					"Unable to retrieve the system time",
+					e);
+			}
+			return ret;
+		}
+	}
+	
+	/**
+	 * Returns the time since the Epoch, measured in milliseconds. Or, if a
+	 * time was forced with forceMsec(), then the forced time is returned instead.
+	 *
+	 * @param real Whether to get the real time, even if a value was forced.
+	 * @throws TimeRetrievalException Something went wrong while retrieving the time.
+	 * @throws boost::thread_interrupted
+	 */
+	static unsigned long long getMsec(bool real = false) {
+		if (SystemTimeData::hasForcedMsecValue && !real) {
+			return SystemTimeData::forcedMsecValue;
+		} else {
+			struct timeval t;
+			int ret;
+			
+			do {
+				ret = gettimeofday(&t, NULL);
+			} while (ret == -1 && errno == EINTR);
+			if (ret == -1) {
+				int e = errno;
+				throw TimeRetrievalException(
+					"Unable to retrieve the system time",
+					e);
+			}
+			return (unsigned long long) t.tv_sec * 1000 + t.tv_usec / 1000;
+		}
+	}
+	
+	/**
+	 * Returns the time since the Epoch, measured in microseconds. Or, if a
+	 * time was forced with forceUsec(), then the forced time is returned instead.
+	 *
+	 * @throws TimeRetrievalException Something went wrong while retrieving the time.
+	 * @throws boost::thread_interrupted
+	 */
+	static unsigned long long getUsec() {
+		if (SystemTimeData::hasForcedUsecValue) {
+			return SystemTimeData::forcedUsecValue;
+		} else {
+			struct timeval t;
+			int ret;
+			
+			do {
+				ret = gettimeofday(&t, NULL);
+			} while (ret == -1 && errno == EINTR);
+			if (ret == -1) {
+				int e = errno;
+				throw TimeRetrievalException(
+					"Unable to retrieve the system time",
+					e);
+			}
+			return (unsigned long long) t.tv_sec * 1000000 + t.tv_usec;
+		}
+	}
+
+	/**
+	 * Force get() to return the given value.
+	 */
+	static void force(time_t value) {
+		SystemTimeData::hasForcedValue = true;
+		SystemTimeData::forcedValue = value;
+	}
+	
+	/**
+	 * Force getMsec() to return the given value.
+	 */
+	static void forceMsec(unsigned long long value) {
+		SystemTimeData::hasForcedMsecValue = true;
+		SystemTimeData::forcedMsecValue = value;
+	}
+	
+	/**
+	 * Force getUsec() to return the given value.
+	 */
+	static void forceUsec(unsigned long long value) {
+		SystemTimeData::hasForcedUsecValue = true;
+		SystemTimeData::forcedUsecValue = value;
+	}
+	
+	static void forceAll(unsigned long long usec) {
+		force(usec / 1000000);
+		forceMsec(usec / 1000);
+		forceUsec(usec);
+	}
+
+	/**
+	 * Release the previously forced seconds value, so that get()
+	 * returns the system time once again.
+	 */
+	static void release() {
+		SystemTimeData::hasForcedValue = false;
+	}
+	
+	/**
+	 * Release the previously forced msec value, so that getMsec()
+	 * returns the system time once again.
+	 */
+	static void releaseMsec() {
+		SystemTimeData::hasForcedMsecValue = false;
+	}
+	
+	/**
+	 * Release the previously forced usec value, so that getUsec()
+	 * returns the system time once again.
+	 */
+	static void releaseUsec() {
+		SystemTimeData::hasForcedUsecValue = false;
+	}
+	
+	/**
+	 * Release all previously forced values, so that get(), getMsec()
+	 * and getUsec() return the system time once again.
+	 */
+	static void releaseAll() {
+		SystemTimeData::hasForcedValue = false;
+		SystemTimeData::hasForcedMsecValue = false;
+		SystemTimeData::hasForcedUsecValue = false;
+	}
+};
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_SYSTEM_TIME_H_ */

data/ext/common/{Timer.h → Utils/Timer.h}

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - http://www.modrails.com/
- *  Copyright (c) 2008, 2009 Phusion
+ *  Copyright (c) 2010 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -25,14 +25,22 @@
 #ifndef _PASSENGER_TIMER_H_
 #define _PASSENGER_TIMER_H_
 
+#include <boost/thread.hpp>
+#include <oxt/system_calls.hpp>
 #include <sys/time.h>
+#include <cerrno>
 
 namespace Passenger {
 
+using namespace boost;
+using namespace oxt;
+
 /**
- * A Timer which one can use to check how much time has elapsed since the timer started.
- * This timer support microseconds-resolution, but the exact resolution depends on the OS
- * and the hardware.
+ * A Timer which one can use to check how much time has elapsed since the
+ * timer started. This timer support miliseconds-resolution, but the exact
+ * resolution depends on the OS and the hardware.
+ *
+ * This class is thread-safe.
  *
  * @code
  * Timer timer;
@@ -43,6 +51,7 @@ namespace Passenger {
 class Timer {
 private:
 	struct timeval startTime;
+	mutable boost::mutex lock;
 public:
 	/**
 	 * Creates a new Timer object.
@@ -53,8 +62,7 @@ public:
 		if (startNow) {
 			start();
 		} else {
-			startTime.tv_sec = 0;
-			startTime.tv_usec = 0;
+			stop();
 		}
 	}
 	
@@ -65,23 +73,55 @@ public:
 	void start() {
 		// TODO: We really use should clock_gettime() and the monotonic
 		// clock whenever possible, instead of gettimeofday()...
-		gettimeofday(&startTime, NULL);
+		// On OS X we can use mach_absolute_time()
+		lock_guard<boost::mutex> l(lock);
+		int ret;
+		do {
+			ret = gettimeofday(&startTime, NULL);
+		} while (ret == -1 && errno == EINTR);
 	}
 	
 	/**
-	 * Checks how much time has elapsed since the timer was last started.
-	 *
-	 * @pre The timer must have been started.
-	 * @return The elapsed time, in miliseconds.
+	 * Stop the timer. If there's currently another thread waiting on the wait()
+	 * call, then that wait() call will block indefinitely until you call start()
+	 * and sufficient amount of time has elapsed.
+	 */
+	void stop() {
+		lock_guard<boost::mutex> l(lock);
+		startTime.tv_sec = 0;
+		startTime.tv_usec = 0;
+	}
+	
+	/**
+	 * Returns the amount of time that has elapsed since the timer was last started,
+	 * in miliseconds. If the timer is currently stopped, then 0 is returned.
 	 */
 	unsigned long long elapsed() const {
-		struct timeval t;
-		unsigned long long now, beginning;
-		
-		gettimeofday(&t, NULL);
-		now = (unsigned long long) t.tv_sec * 1000 + t.tv_usec / 1000;
-		beginning = (unsigned long long) startTime.tv_sec * 1000 + startTime.tv_usec / 1000;
-		return now - beginning;
+		lock_guard<boost::mutex> l(lock);
+		if (startTime.tv_sec == 0 && startTime.tv_usec == 0) {
+			return 0;
+		} else {
+			struct timeval t;
+			unsigned long long now, beginning;
+			int ret;
+			
+			do {
+				ret = gettimeofday(&t, NULL);
+			} while (ret == -1 && errno == EINTR);
+			now = (unsigned long long) t.tv_sec * 1000 + t.tv_usec / 1000;
+			beginning = (unsigned long long) startTime.tv_sec * 1000 + startTime.tv_usec / 1000;
+			return now - beginning;
+		}
+	}
+	
+	/**
+	 * Wait until <em>time</em> miliseconds have elapsed since the timer
+	 * was last started.
+	 */
+	void wait(unsigned long long time) const {
+		while (elapsed() < time) {
+			syscalls::usleep(25000);
+		}
 	}
 };
 

data/ext/common/Utils/VariantMap.h

@@ -0,0 +1,363 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2010 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+#ifndef _PASSENGER_VARIANT_MAP_H_
+#define _PASSENGER_VARIANT_MAP_H_
+
+#include <oxt/backtrace.hpp>
+#include <oxt/macros.hpp>
+#include <sys/types.h>
+#include <map>
+#include <string>
+#include "MessageChannel.h"
+#include "Exceptions.h"
+#include "Utils/StrIntUtils.h"
+
+namespace Passenger {
+
+using namespace std;
+
+/**
+ * A map which maps string keys to values of any type. Internally all values
+ * are stored as strings, but convenience functions are provided to cast
+ * to and from other types.
+ *
+ * <h2>get() methods</h2>
+ *
+ * There are many get() versions but they all behave the same way, just returning
+ * different types.
+ * <tt>get(name)</tt> returns the value associated with the key <em>name</em>.
+ * If the key doesn't exist then the behavior depends on the <em>required</em> argument:
+ * - If <em>required</em> is true, then a MissingKeyException will be thrown.
+ * - If <em>required</em> is false, then <em>defaultValue</em> will be returned.
+ *   (In case of the string version, <em>defaultValue</em> defaults to the empty string.)
+ */
+class VariantMap {
+private:
+	map<string, string> store;
+	string empty;
+	
+	/**
+	 * Looks up the string value associated with <em>name</em>.
+	 * If found, then <tt>true</tt> is returned and a pointer to
+	 * the string value is stored in <tt>*strValue</tt>.
+	 *
+	 * If not found, and <em>required</em> is true, then a
+	 * MissingKeyException will be thrown.
+	 *
+	 * If not found, and <em>required</em> is false, then
+	 * <tt>false</tt> is returned.
+	 */
+	bool lookup(const string &name, bool required, const string **strValue) const {
+		map<string, string>::const_iterator it = store.find(name);
+		if (it == store.end()) {
+			if (required) {
+				throw MissingKeyException(name);
+			} else {
+				return false;
+			}
+		} else {
+			*strValue = &it->second;
+			return true;
+		}
+	}
+	
+public:
+	/** Thrown when a required key is not found by one of the get() methods. */
+	class MissingKeyException: public oxt::tracable_exception {
+	private:
+		string message;
+		string key;
+		
+	public:
+		MissingKeyException(const string &key) {
+			this->key = key;
+			message = string("Required key '") + key + "' is missing";
+		}
+		
+		virtual ~MissingKeyException() throw() { }
+		
+		virtual const char *what() const throw() {
+			return message.c_str();
+		}
+		
+		/** The key that wasn't found. */
+		string getKey() const {
+			return key;
+		}
+	};
+	
+	/**
+	 * Populates a VariantMap from the data in <em>argv</em>, which
+	 * consists of <em>argc</em> elements.
+	 * <em>argv</em> must be an array containing keys followed by
+	 * values, like this:
+	 * <tt>[key1, value1, key2, value2, ...]</tt>
+	 *
+	 * @throws ArgumentException The <em>argv</em> array does not
+	 *                           contain valid key-value pairs.
+	 */
+	void readFrom(const char **argv, unsigned int argc) {
+		if (OXT_UNLIKELY(argc % 2 != 0)) {
+			throw ArgumentException("argc must be a multiple of 2");
+		}
+		unsigned int i = 0;
+		while (i < argc) {
+			store[argv[i]] = argv[i + 1];
+			i += 2;
+		}
+	}
+	
+	/**
+	 * Populates a VariantMap from the data in <em>fd</em>. MessageChannel
+	 * is used to read from the file descriptor.
+	 *
+	 * @throws SystemException
+	 * @throws IOException
+	 * @see <tt>readFrom(MessageChannel &)</tt>
+	 */
+	void readFrom(int fd) {
+		MessageChannel channel(fd);
+		readFrom(channel);
+	}
+	
+	/**
+	 * Populates a VariantMap from the data in <em>channel</em>. The first
+	 * message in the channel must be a message as sent by writeToChannel().
+	 *
+	 * @throws SystemException
+	 * @throws IOException
+	 */
+	void readFrom(MessageChannel &channel) {
+		TRACE_POINT();
+		vector<string> args;
+		
+		if (!channel.read(args)) {
+			throw IOException("Unexpected end-of-file encountered");
+		}
+		if (args.size() == 0) {
+			throw IOException("Unexpected empty message received from channel");
+		}
+		if (args[0] != "VariantMap") {
+			throw IOException("Unexpected message '" + args[0] + "' received from channel");
+		}
+		if (args.size() % 2 != 1) {
+			throw IOException("Message from channel has an unexpected number of arguments");
+		}
+		
+		vector<string>::const_iterator it = args.begin();
+		it++;
+		while (it != args.end()) {
+			const string &key = *it;
+			it++;
+			const string &value = *it;
+			it++;
+			store[key] = value;
+		}
+	}
+	
+	VariantMap &set(const string &name, const string &value) {
+		store[name] = value;
+		return *this;
+	}
+	
+	VariantMap &setInt(const string &name, int value) {
+		store[name] = toString(value);
+		return *this;
+	}
+	
+	VariantMap &setULL(const string &name, unsigned long long value) {
+		store[name] = toString(value);
+		return *this;
+	}
+	
+	VariantMap &setPid(const string &name, pid_t value) {
+		store[name] = toString((unsigned long long) value);
+		return *this;
+	}
+	
+	VariantMap &setUid(const string &name, uid_t value) {
+		store[name] = toString((long long) value);
+		return *this;
+	}
+	
+	VariantMap &setGid(const string &name, gid_t value) {
+		store[name] = toString((long long) value);
+		return *this;
+	}
+	
+	VariantMap &setBool(const string &name, bool value) {
+		store[name] = value ? "true" : "false";
+		return *this;
+	}
+	
+	const string &get(const string &name, bool required = true) const {
+		map<string, string>::const_iterator it = store.find(name);
+		if (it == store.end()) {
+			if (required) {
+				throw MissingKeyException(name);
+			} else {
+				return empty;
+			}
+		} else {
+			return it->second;
+		}
+	}
+	
+	const string &get(const string &name, bool required, const string &defaultValue) const {
+		map<string, string>::const_iterator it = store.find(name);
+		if (it == store.end()) {
+			if (required) {
+				throw MissingKeyException(name);
+			} else {
+				return defaultValue;
+			}
+		} else {
+			return it->second;
+		}
+	}
+	
+	int getInt(const string &name, bool required = true, int defaultValue = 0) const {
+		int result = defaultValue;
+		const string *str;
+		if (lookup(name, required, &str)) {
+			result = (int) stringToLL(*str);
+		}
+		return result;
+	}
+	
+	unsigned long long getULL(const string &name, bool required = true,
+		unsigned long long defaultValue = 0) const
+	{
+		unsigned long long result = defaultValue;
+		const string *str;
+		if (lookup(name, required, &str)) {
+			result = stringToULL(*str);
+		}
+		return result;
+	}
+	
+	pid_t getPid(const string &name, bool required = true, pid_t defaultValue = 0) const {
+		pid_t result = defaultValue;
+		const string *str;
+		if (lookup(name, required, &str)) {
+			result = (pid_t) stringToLL(*str);
+		}
+		return result;
+	}
+	
+	uid_t getUid(const string &name, bool required = true, uid_t defaultValue = 0) const {
+		uid_t result = defaultValue;
+		const string *str;
+		if (lookup(name, required, &str)) {
+			result = (uid_t) stringToLL(*str);
+		}
+		return result;
+	}
+	
+	gid_t getGid(const string &name, bool required = true, gid_t defaultValue = 0) const {
+		gid_t result = defaultValue;
+		const string *str;
+		if (lookup(name, required, &str)) {
+			result = (gid_t) stringToLL(*str);
+		}
+		return result;
+	}
+	
+	bool getBool(const string &name, bool required = true, bool defaultValue = false) const {
+		bool result = defaultValue;
+		const string *str;
+		if (lookup(name, required, &str)) {
+			result = *str == "true";
+		}
+		return result;
+	}
+	
+	bool erase(const string &name) {
+		return store.erase(name) != 0;
+	}
+	
+	/** Checks whether the specified key is in this map. */
+	bool has(const string &name) const {
+		return store.find(name) != store.end();
+	}
+	
+	/** Returns the number of elements in this map. */
+	unsigned int size() const {
+		return store.size();
+	}
+	
+	void writeToFd(int fd) const {
+		MessageChannel channel(fd);
+		writeToChannel(channel);
+	}
+	
+	/**
+	 * Writes a representation of the contents in this VariantMap to
+	 * the given channel. The data can be unserialized with
+	 * <tt>readFrom(MessageChannel &)</tt>.
+	 *
+	 * @throws SystemException
+	 */
+	void writeToChannel(MessageChannel &channel) const {
+		map<string, string>::const_iterator it;
+		map<string, string>::const_iterator end = store.end();
+		vector<string> args;
+		
+		args.reserve(1 + 2 * store.size());
+		args.push_back("VariantMap");
+		for (it = store.begin(); it != end; it++) {
+			args.push_back(it->first);
+			args.push_back(it->second);
+		}
+		channel.write(args);
+	}
+	
+	string inspect() const {
+		map<string, string>::const_iterator it;
+		map<string, string>::const_iterator end = store.end();
+		string result;
+		unsigned int i = 0;
+		
+		result.append("{ ");
+		for (it = store.begin(); it != end; it++, i++) {
+			result.append("'");
+			result.append(it->first);
+			result.append("' => '");
+			result.append(it->second);
+			if (i == store.size() - 1) {
+				result.append("'");
+			} else {
+				result.append("', ");
+			}
+		}
+		result.append(" }");
+		return result;
+	}
+};
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_VARIANT_MAP_H_ */
+_PASSENGER_VARIANT_MAP_H_