passenger 3.0.7 → 3.0.8

data/ext/boost/src/pthread/thread.cpp

@@ -339,7 +339,7 @@ namespace boost
             if(thread_info)
             {
                 unique_lock<mutex> lk(thread_info->sleep_mutex);
-                while(thread_info->sleep_condition.timed_wait(lk,st));
+                while(thread_info->sleep_condition.timed_wait(lk,st)) {};
             }
             else
             {

data/ext/common/AccountsDatabase.h

@@ -61,7 +61,7 @@ public:
 	
 	unsigned int size() const {
 		lock_guard<boost::mutex> l(lock);
-		return accounts.size();
+		return (unsigned int) accounts.size();
 	}
 	
 	vector<string> listUsernames() const {

data/ext/common/Constants.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - http://www.modrails.com/
- *  Copyright (c) 2010 Phusion
+ *  Copyright (c) 2010, 2011 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -26,7 +26,7 @@
 #define _PASSENGER_CONSTANTS_H_
 
 /* Don't forget to update lib/phusion_passenger.rb too. */
-#define PASSENGER_VERSION "3.0.7"
+#define PASSENGER_VERSION "3.0.8"
 
 #define FEEDBACK_FD 3
 

data/ext/common/Logging.h

@@ -42,6 +42,7 @@
 #include <sstream>
 #include <cstdio>
 #include <ctime>
+#include <cerrno>
 
 #include "RandomGenerator.h"
 #include "FileDescriptor.h"
@@ -149,7 +150,7 @@ void setDebugFile(const char *logFile = NULL);
 #endif
 
 
-/********** Transaction logging facilities *********/
+/********** Analytics logging facilities *********/
 
 struct AnalyticsLoggerSharedData {
 	boost::mutex lock;

data/ext/common/LoggingAgent/FilterSupport.h

@@ -33,7 +33,9 @@
 
 #include <string>
 #include <set>
-#include <regex.h>
+#ifndef _PCREPOSIX_H
+	#include <regex.h>
+#endif
 #include <cstdio>
 #include <cstring>
 
@@ -475,7 +477,11 @@ public:
 	enum FieldIdentifier {
 		URI,
 		CONTROLLER,
-		RESPONSE_TIME
+		RESPONSE_TIME,
+		RESPONSE_TIME_WITHOUT_GC,
+		STATUS,
+		STATUS_CODE,
+		GC_TIME
 	};
 	
 	virtual ~Context() { }
@@ -483,8 +489,15 @@ public:
 	virtual string getURI() const = 0;
 	virtual string getController() const = 0;
 	virtual int getResponseTime() const = 0;
+	virtual string getStatus() const = 0;
+	virtual int getStatusCode() const = 0;
+	virtual int getGcTime() const = 0;
 	virtual bool hasHint(const string &name) const = 0;
 	
+	int getResponseTimeWithoutGc() const {
+		return getResponseTime() - getGcTime();
+	}
+	
 	string queryStringField(FieldIdentifier id) const {
 		switch (id) {
 		case URI:
@@ -493,6 +506,14 @@ public:
 			return getController();
 		case RESPONSE_TIME:
 			return toString(getResponseTime());
+		case RESPONSE_TIME_WITHOUT_GC:
+			return toString(getResponseTimeWithoutGc());
+		case STATUS:
+			return getStatus();
+		case STATUS_CODE:
+			return toString(getStatusCode());
+		case GC_TIME:
+			return toString(getGcTime());
 		default:
 			return "";
 		}
@@ -502,6 +523,12 @@ public:
 		switch (id) {
 		case RESPONSE_TIME:
 			return getResponseTime();
+		case RESPONSE_TIME_WITHOUT_GC:
+			return getResponseTimeWithoutGc();
+		case STATUS_CODE:
+			return getStatusCode();
+		case GC_TIME:
+			return getGcTime();
 		default:
 			return 0;
 		}
@@ -515,6 +542,14 @@ public:
 			return !getController().empty();
 		case RESPONSE_TIME:
 			return getResponseTime() > 0;
+		case RESPONSE_TIME_WITHOUT_GC:
+			return getResponseTimeWithoutGc() > 0;
+		case STATUS:
+			return !getStatus().empty();
+		case STATUS_CODE:
+			return getStatusCode() > 0;
+		case GC_TIME:
+			return getGcTime() > 0;
 		default:
 			return false;
 		}
@@ -524,8 +559,12 @@ public:
 		switch (id) {
 		case URI:
 		case CONTROLLER:
+		case STATUS:
 			return STRING_TYPE;
 		case RESPONSE_TIME:
+		case RESPONSE_TIME_WITHOUT_GC:
+		case STATUS_CODE:
+		case GC_TIME:
 			return INTEGER_TYPE;
 		default:
 			return UNKNOWN_TYPE;
@@ -537,11 +576,16 @@ class SimpleContext: public Context {
 public:
 	string uri;
 	string controller;
+	string status;
 	int responseTime;
+	int statusCode;
+	int gcTime;
 	set<string> hints;
 	
 	SimpleContext() {
 		responseTime = 0;
+		statusCode = 0;
+		gcTime = 0;
 	}
 	
 	virtual string getURI() const {
@@ -556,6 +600,18 @@ public:
 		return responseTime;
 	}
 	
+	virtual string getStatus() const {
+		return status;
+	}
+	
+	virtual int getStatusCode() const {
+		return statusCode;
+	}
+	
+	virtual int getGcTime() const {
+		return gcTime;
+	}
+	
 	virtual bool hasHint(const string &name) const {
 		return hints.find(name) != hints.end();
 	}
@@ -569,6 +625,10 @@ private:
 	struct ParseState {
 		unsigned long long requestProcessingStart;
 		unsigned long long requestProcessingEnd;
+		unsigned long long smallestTimestamp;
+		unsigned long long largestTimestamp;
+		unsigned long long gcTimeStart;
+		unsigned long long gcTimeEnd;
 	};
 	
 	static void parseLine(const StaticString &txnId, unsigned long long timestamp,
@@ -587,15 +647,33 @@ private:
 			if (pos != string::npos) {
 				ctx.controller = value.substr(0, pos);
 			}
+		} else if (startsWith(data, "Status: ")) {
+			StaticString value = data.substr(data.find(':') + 2);
+			ctx.status = value;
+			ctx.statusCode = stringToInt(value);
+		} else if (startsWith(data, "Initial GC time: ")) {
+			StaticString value = data.substr(data.find(':') + 2);
+			state.gcTimeStart = stringToULL(value);
+		} else if (startsWith(data, "Final GC time: ")) {
+			StaticString value = data.substr(data.find(':') + 2);
+			state.gcTimeEnd = stringToULL(value);
+		}
+		
+		if (state.smallestTimestamp == 0 || timestamp < state.smallestTimestamp) {
+			state.smallestTimestamp = timestamp;
+		}
+		if (timestamp > state.largestTimestamp) {
+			state.largestTimestamp = timestamp;
 		}
 	}
 	
 	static void reallyParse(const StaticString &data, SimpleContext &ctx) {
 		const char *current = data.data();
 		const char *end     = data.data() + data.size();
-		ParseState state;
 		
+		ParseState state;
 		memset(&state, 0, sizeof(state));
+		
 		while (current < end) {
 			current = skipNewlines(current, end);
 			if (current < end) {
@@ -622,6 +700,12 @@ private:
 		if (state.requestProcessingEnd != 0) {
 			ctx.responseTime = int(state.requestProcessingEnd -
 				state.requestProcessingStart);
+		} else if (state.smallestTimestamp != 0) {
+			ctx.responseTime = state.largestTimestamp - state.smallestTimestamp;
+		}
+		
+		if (state.gcTimeEnd != 0) {
+			ctx.gcTime = state.gcTimeEnd - state.gcTimeStart;
 		}
 	}
 	
@@ -723,6 +807,18 @@ public:
 		return parse()->getResponseTime();
 	}
 	
+	virtual string getStatus() const {
+		return parse()->getStatus();
+	}
+	
+	virtual int getStatusCode() const {
+		return parse()->getStatusCode();
+	}
+	
+	virtual int getGcTime() const {
+		return parse()->getGcTime();
+	}
+	
 	virtual bool hasHint(const string &name) const {
 		return parse()->hasHint(name);
 	}
@@ -1458,6 +1554,14 @@ private:
 			return Value(Context::CONTROLLER);
 		} else if (token.rawValue == "response_time") {
 			return Value(Context::RESPONSE_TIME);
+		} else if (token.rawValue == "response_time_without_gc") {
+			return Value(Context::RESPONSE_TIME_WITHOUT_GC);
+		} else if (token.rawValue == "status") {
+			return Value(Context::STATUS);
+		} else if (token.rawValue == "status_code") {
+			return Value(Context::STATUS_CODE);
+		} else if (token.rawValue == "gc_time") {
+			return Value(Context::GC_TIME);
 		} else {
 			raiseSyntaxError("unknown field '" + token.rawValue + "'", token);
 			return Value(); // Shut up compiler warning.

data/ext/common/Session.h

@@ -176,7 +176,7 @@ public:
 	 * @throws boost::thread_interrupted
 	 */
 	virtual void sendHeaders(const StaticString &headers) {
-		sendHeaders(headers.c_str(), headers.size());
+		sendHeaders(headers.c_str(), (unsigned int) headers.size());
 	}
 	
 	/**

data/ext/common/Utils.cpp

@@ -49,6 +49,7 @@
 #include <Utils/Base64.h>
 #include <Utils/CachedFileStat.hpp>
 #include <Utils/StrIntUtils.h>
+#include <Utils/HttpHeaderBufferer.h>
 
 #ifndef HOST_NAME_MAX
 	#if defined(_POSIX_HOST_NAME_MAX)
@@ -68,6 +69,7 @@
 namespace Passenger {
 
 static string passengerTempDir;
+HttpHeaderBufferer::StaticData HttpHeaderBufferer::staticData;
 
 namespace {
 	/**

data/ext/common/Utils/Dechunker.h

@@ -0,0 +1,232 @@
+#ifndef _PASSENGER_DECHUNKER_H_
+#define _PASSENGER_DECHUNKER_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+
+#include <StaticString.h>
+#include <Utils/StrIntUtils.h>
+
+namespace Passenger {
+
+using namespace std;
+
+
+/**
+ * Parses data in HTTP/1.1 chunked transfer encoding.
+ *
+ * Feed data into this parser by calling feed(). Do this until acceptingInput()
+ * is false. Any data chunks it has parsed will be emitted through the onData
+ * callback. This parser is zero-copy so the callback arguments point to the
+ * fed data.
+ *
+ * Dechunker parses until the terminating chunk or until a parse error occurs.
+ * After that it will refuse to accept new data until reset() is called.
+ */
+class Dechunker {
+public:
+	typedef void (*Callback)(const char *data, size_t size, void *userData);
+	
+private:
+	static const char CR = '\x0D';
+	static const char LF = '\x0A';
+	
+	char sizeBuffer[10];
+	unsigned int sizeBufferLen;
+	unsigned int remainingDataSize;
+	const char *errorMessage;
+	
+	enum {
+		EXPECTING_SIZE,
+		EXPECTING_CHUNK_EXTENSION,
+		EXPECTING_HEADER_LF,
+		EXPECTING_DATA,
+		EXPECTING_NON_FINAL_CR,
+		EXPECTING_NON_FINAL_LF,
+		EXPECTING_FINAL_CR,
+		EXPECTING_FINAL_LF,
+		DONE,
+		ERROR
+	} state;
+	
+	void setError(const char *message) {
+		errorMessage = message;
+		state = ERROR;
+	}
+	
+	bool isDigit(char ch) const {
+		return (ch >= '0' && ch <= '9')
+			|| (ch >= 'a' && ch <= 'f')
+			|| (ch >= 'A' && ch <= 'Z');
+	}
+	
+	void parseSizeBuffer() {
+		remainingDataSize = hexToUint(StaticString(sizeBuffer, sizeBufferLen));
+	}
+	
+	void emitDataEvent(const char *data, size_t size) const {
+		if (onData != NULL) {
+			onData(data, size, userData);
+		}
+	}
+	
+public:
+	Callback onData;
+	void *userData;
+	
+	Dechunker() {
+		onData = NULL;
+		userData = NULL;
+		reset();
+	}
+	
+	/**
+	 * Resets the internal state so that this Dechunker can be reused
+	 * for parsing new data.
+	 *
+	 * @post acceptingInput()
+	 * @post !hasError()
+	 */
+	void reset() {
+		state = EXPECTING_SIZE;
+		sizeBufferLen = 0;
+		remainingDataSize = 0;
+		errorMessage = NULL;
+	}
+	
+	/**
+	 * Feeds data into this parser. Any data chunks it has parsed will be emitted
+	 * through the onData callback. Returns the number of bytes that have been
+	 * accepted. Any data not recognized as part of the chunked transfer encoding
+	 * stream will be rejected.
+	 */
+	size_t feed(const char *data, size_t size) {
+		const char *current = data;
+		const char *end     = data + size;
+		const char *needle;
+		size_t dataSize;
+		
+		while (current < end && state != DONE && state != ERROR) {
+			switch (state) {
+			case EXPECTING_DATA:
+				dataSize = std::min(size_t(remainingDataSize), size_t(end - current));
+				if (dataSize == 0) {
+					state = EXPECTING_FINAL_CR;
+				} else {
+					emitDataEvent(current, dataSize);
+					current += dataSize;
+					remainingDataSize -= (unsigned int) dataSize;
+					if (remainingDataSize == 0) {
+						state = EXPECTING_NON_FINAL_CR;
+					}
+				}
+				break;
+			
+			case EXPECTING_SIZE:
+				while (current < end
+				    && sizeBufferLen < sizeof(sizeBuffer)
+				    && state == EXPECTING_SIZE)
+				{
+					if (*current == CR) {
+						parseSizeBuffer();
+						state = EXPECTING_HEADER_LF;
+					} else if (*current == ';') {
+						parseSizeBuffer();
+						state = EXPECTING_CHUNK_EXTENSION;
+					} else if (isDigit(*current)) {
+						sizeBuffer[sizeBufferLen] = *current;
+						sizeBufferLen++;
+					} else {
+						setError("Parse error: invalid chunk size character.");
+						current--;
+					}
+					current++;
+				}
+				
+				if (sizeBufferLen == sizeof(sizeBuffer) && state == EXPECTING_SIZE) {
+					setError("The chunk size header is too large.");
+				}
+				break;
+			
+			case EXPECTING_CHUNK_EXTENSION:
+				needle = (const char *) memchr(current, CR, end - current);
+				if (needle == NULL) {
+					current = end;
+				} else {
+					current = needle + 1;
+					state = EXPECTING_HEADER_LF;
+				}
+				break;
+			
+			case EXPECTING_HEADER_LF:
+				if (*current == LF) {
+					state = EXPECTING_DATA;
+					current++;
+				} else {
+					setError("Parse error: expected a chunk header LF.");
+				}
+				break;
+			
+			case EXPECTING_NON_FINAL_CR:
+				if (*current == CR) {
+					state = EXPECTING_NON_FINAL_LF;
+					current++;
+				} else {
+					setError("Parse error: expected a chunk finalizing CR.");
+				}
+				break;
+			
+			case EXPECTING_NON_FINAL_LF:
+				if (*current == LF) {
+					reset();
+					current++;
+				} else {
+					setError("Parse error: expected a chunk finalizing LF.");
+				}
+				break;
+			
+			case EXPECTING_FINAL_CR:
+				if (*current == CR) {
+					state = EXPECTING_FINAL_LF;
+					current++;
+				} else {
+					setError("Parse error: expected a final CR.");
+				}
+				break;
+			
+			case EXPECTING_FINAL_LF:
+				if (*current == LF) {
+					state = DONE;
+					current++;
+				} else {
+					setError("Parse error: expected a final LF.");
+				}
+				break;
+			
+			default:
+				abort();
+			}
+		}
+		
+		return current - data;
+	}
+	
+	bool acceptingInput() const {
+		return state != DONE && state != ERROR;
+	}
+	
+	bool hasError() const {
+		return state == ERROR;
+	}
+	
+	const char *getErrorMessage() const {
+		return errorMessage;
+	}
+};
+
+
+} // namespace Passenger
+
+#endif _PASSENGER_DECHUNKER_H_