passenger 3.0.2 → 3.0.3

data/ext/common/LoggingAgent/LoggingServer.h

@@ -45,6 +45,7 @@
 #include "DataStoreId.h"
 #include "RemoteSender.h"
 #include "ChangeNotifier.h"
+#include "FilterSupport.h"
 #include "../EventedMessageServer.h"
 #include "../MessageReadersWriters.h"
 #include "../StaticString.h"
@@ -55,6 +56,7 @@
 #include "../Utils/MD5.h"
 #include "../Utils/IOUtils.h"
 #include "../Utils/StrIntUtils.h"
+#include "../Utils/StringMap.h"
 
 
 namespace Passenger {
@@ -299,6 +301,7 @@ private:
 		int refcount;
 		bool crashProtect, discarded;
 		string data;
+		string filters;
 		
 		Transaction(LoggingServer *server) {
 			this->server = server;
@@ -307,7 +310,7 @@ private:
 		
 		~Transaction() {
 			if (logSink != NULL) {
-				if (!discarded) {
+				if (!discarded && passesFilter()) {
 					logSink->append(dataStoreId, data);
 				}
 				server->closeLogSink(logSink);
@@ -338,6 +341,35 @@ private:
 			stream << "      Category: " << getCategory() << "\n";
 			stream << "      Refcount: " << refcount << "\n";
 		}
+	
+	private:
+		bool passesFilter() {
+			if (filters.empty()) {
+				return true;
+			}
+			
+			const char *current = filters.data();
+			const char *end     = filters.data() + filters.size();
+			bool result         = true;
+			FilterSupport::ContextFromLog ctx(data);
+			
+			// 'filters' may contain multiple filter sources, separated
+			// by '\1' characters. Process each.
+			while (current < end && result) {
+				StaticString tmp(current, end - current);
+				size_t pos = tmp.find('\1');
+				if (pos == string::npos) {
+					pos = tmp.size();
+				}
+				
+				StaticString source(current, pos);
+				FilterSupport::Filter &filter = server->compileFilter(source);
+				result = filter.run(ctx);
+				
+				current = tmp.data() + pos + 1;
+			}
+			return result;
+		}
 	};
 	
 	typedef shared_ptr<Transaction> TransactionPtr;
@@ -372,6 +404,8 @@ private:
 	typedef shared_ptr<Client> ClientPtr;
 	typedef map<string, TransactionPtr> TransactionMap;
 	
+	typedef shared_ptr<FilterSupport::Filter> FilterPtr;
+	
 	string dir;
 	gid_t gid;
 	string dirPermissions;
@@ -392,6 +426,7 @@ private:
 	 */
 	list<LogSinkPtr> inactiveLogSinks;
 	int inactiveLogSinksCount;
+	StringMap<FilterPtr> filters;
 	RandomGenerator randomGenerator;
 	bool refuseNewConnections;
 	bool exitRequested;
@@ -412,6 +447,16 @@ private:
 		}
 	}
 	
+	bool expectingMinArgumentsCount(Client *client, const vector<StaticString> &args, unsigned int size) {
+		if (args.size() >= size) {
+			return true;
+		} else {
+			sendErrorToClient(client, "Invalid number of arguments");
+			client->disconnect();
+			return false;
+		}
+	}
+	
 	bool expectingLoggerType(Client *client) {
 		if (client->type == LOGGER) {
 			return true;
@@ -432,6 +477,26 @@ private:
 		}
 	}
 	
+	static bool getBool(const vector<StaticString> &args, unsigned int index,
+		bool defaultValue = false)
+	{
+		if (index < args.size()) {
+			return args[index] == "true";
+		} else {
+			return defaultValue;
+		}
+	}
+	
+	static StaticString getStaticString(const vector<StaticString> &args,
+		unsigned int index, const StaticString &defaultValue = "")
+	{
+		if (index < args.size()) {
+			return args[index];
+		} else {
+			return defaultValue;
+		}
+	}
+	
 	bool validTxnId(const StaticString &txnId) const {
 		// must contain timestamp
 		// must contain separator
@@ -651,6 +716,16 @@ private:
 		}
 	}
 	
+	FilterSupport::Filter &compileFilter(const StaticString &source) {
+		// TODO: garbage collect filters based on time
+		FilterPtr filter = filters.get(source);
+		if (filter == NULL) {
+			filter = make_shared<FilterSupport::Filter>(source);
+			filters.set(source, filter);
+		}
+		return *filter;
+	}
+	
 	bool writeLogEntry(Client *client, const TransactionPtr &transaction,
 		const StaticString &timestamp, const StaticString &data)
 	{
@@ -897,7 +972,7 @@ protected:
 			}
 			
 		} else if (args[0] == "openTransaction") {
-			if (OXT_UNLIKELY( !expectingArgumentsCount(client, args, 8)
+			if (OXT_UNLIKELY( !expectingMinArgumentsCount(client, args, 7)
 			               || !expectingLoggerType(client) )) {
 				return true;
 			}
@@ -908,7 +983,9 @@ protected:
 			StaticString category  = args[4];
 			StaticString timestamp = args[5];
 			StaticString unionStationKey = args[6];
-			bool         crashProtect    = args[7] == "true";
+			bool         crashProtect    = getBool(args, 7, true);
+			bool         ack             = getBool(args, 8, false);
+			StaticString filters         = getStaticString(args, 9);
 			
 			if (OXT_UNLIKELY( !validTxnId(txnId) )) {
 				sendErrorToClient(client, "Invalid transaction ID format");
@@ -980,6 +1057,9 @@ protected:
 				transaction->writeCount   = 0;
 				transaction->refcount     = 0;
 				transaction->crashProtect = crashProtect;
+				if (!filters.empty()) {
+					transaction->filters = filters;
+				}
 				transaction->discarded    = false;
 				transactions.insert(make_pair(txnId, transaction));
 			} else {
@@ -1008,14 +1088,19 @@ protected:
 			transaction->refcount++;
 			writeLogEntry(client, transaction, timestamp, "ATTACH");
 			
+			if (ack) {
+				client->writeArrayMessage("ok", NULL);
+			}
+			
 		} else if (args[0] == "closeTransaction") {
-			if (OXT_UNLIKELY( !expectingArgumentsCount(client, args, 3)
+			if (OXT_UNLIKELY( !expectingMinArgumentsCount(client, args, 3)
 			               || !expectingLoggerType(client) )) {
 				return true;
 			}
 			
 			string txnId = args[1];
 			StaticString timestamp = args[2];
+			bool         ack       = getBool(args, 3, false);
 			
 			TransactionMap::iterator it = transactions.find(txnId);
 			if (OXT_UNLIKELY( it == transactions.end() )) {
@@ -1044,6 +1129,10 @@ protected:
 					transactions.erase(it);
 				}
 			}
+			
+			if (ack) {
+				client->writeArrayMessage("ok", NULL);
+			}
 		
 		} else if (args[0] == "init") {
 			if (OXT_UNLIKELY( client->type != UNINITIALIZED )) {

data/ext/common/LoggingAgent/RemoteSender.h

@@ -102,13 +102,13 @@ private:
 				curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
 			} else {
 				curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1);
-				/* No host name verification because Curl thinks the
-				 * host name is the IP address. Doesn't matter as
-				 * long as we have the certificate.
-				 */
-				curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
 				curl_easy_setopt(curl, CURLOPT_CAINFO, certificate.c_str());
 			}
+			/* No host name verification because Curl thinks the
+			 * host name is the IP address. But if we have the
+			 * certificate then it doesn't matter.
+			 */
+			curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
 			responseBody.clear();
 		}
 		

data/ext/common/Utils/StrIntUtils.cpp

@@ -56,8 +56,9 @@ startsWith(const StaticString &str, const StaticString &substr) {
 	}
 }
 
+template<typename OutputString>
 void
-split(const string &str, char sep, vector<string> &output) {
+_split(const StaticString &str, char sep, vector<OutputString> &output) {
 	string::size_type start, pos;
 	start = 0;
 	output.clear();
@@ -68,6 +69,16 @@ split(const string &str, char sep, vector<string> &output) {
 	output.push_back(str.substr(start));
 }
 
+void
+split(const StaticString &str, char sep, vector<string> &output) {
+	_split(str, sep, output);
+}
+
+void
+split(const StaticString &str, char sep, vector<StaticString> &output) {
+	_split(str, sep, output);
+}
+
 string toString(const vector<string> &vec) {
 	vector<StaticString> vec2;
 	vec2.reserve(vec.size());

data/ext/common/Utils/StrIntUtils.h

@@ -70,7 +70,8 @@ bool startsWith(const StaticString &str, const StaticString &substr);
  * @param sep The separator to use.
  * @param output The vector to write the output to.
  */
-void split(const string &str, char sep, vector<string> &output);
+void split(const StaticString &str, char sep, vector<string> &output);
+void split(const StaticString &str, char sep, vector<StaticString> &output);
 
 /**
  * Convert anything to a string.

data/ext/common/Utils/StringMap.h

@@ -0,0 +1,100 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2011 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_STRING_MAP_H_
+#define _PASSENGER_STRING_MAP_H_
+
+#include <string>
+#include <map>
+#include <utility>
+
+#include <StaticString.h>
+
+namespace Passenger {
+
+using namespace std;
+
+
+/**
+ * An efficient map with string keys. map<string, T> forces one to construct an
+ * std::string object when looking up the map. StringMap interns all keys and
+ * allows lookups without constructing an std::string key.
+ *
+ * StringMap requires the following properties on T:
+ * - T's default constructor must be cheap, otherwise set() can be a bit slow.
+ * - T must support operator=().
+ */
+template<typename T>
+class StringMap {
+private:
+	struct Entry {
+		string key;
+		T value;
+	};
+	
+	typedef map<StaticString, Entry> InternalMap;
+	typedef typename InternalMap::iterator Iterator;
+	typedef typename InternalMap::const_iterator ConstIterator;
+	typedef typename InternalMap::value_type ValueType;
+	InternalMap store;
+	
+public:
+	T get(const StaticString &key) const {
+		ConstIterator it = store.find(key);
+		if (it == store.end()) {
+			return T();
+		} else {
+			return it->second.value;
+		}
+	}
+	
+	bool set(const StaticString &key, const T &value) {
+		pair<Iterator, bool> result = store.insert(make_pair(key, Entry()));
+		if (result.second) {
+			// Key has been inserted. Copy it internally and point key
+			// to the copy.
+			ValueType &node = *result.first;
+			StaticString &originalKey = const_cast<StaticString &>(node.first);
+			Entry &entry = node.second;
+			entry.key = key;
+			entry.value = value;
+			originalKey = entry.key;
+			return true;
+		} else {
+			// Key already exists. Update value.
+			Entry &entry = result.first->second;
+			entry.value = value;
+			return false;
+		}
+	}
+	
+	bool remove(const StaticString &key) {
+		return store.erase(key) > 0;
+	}
+};
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_STRING_MAP_H_ */

data/ext/nginx/Configuration.c

@@ -332,7 +332,6 @@ passenger_create_loc_conf(ngx_conf_t *cf)
     DEFINE_VAR_TO_PASS("SCGI",            "1");
     DEFINE_VAR_TO_PASS("QUERY_STRING",    "$query_string");
     DEFINE_VAR_TO_PASS("REQUEST_METHOD",  "$request_method");
-    DEFINE_VAR_TO_PASS("REQUEST_URI",     "$uri$is_args$args");
     DEFINE_VAR_TO_PASS("SERVER_PROTOCOL", "$server_protocol");
     DEFINE_VAR_TO_PASS("SERVER_SOFTWARE", "nginx/$nginx_version");
     DEFINE_VAR_TO_PASS("REMOTE_ADDR",     "$remote_addr");

data/ext/nginx/ContentHandler.c

@@ -321,6 +321,7 @@ create_request(ngx_http_request_t *r)
     size_t                         len, size, key_len, val_len, content_length;
     const u_char                  *app_type_string;
     size_t                         app_type_string_len;
+    ngx_str_t                      escaped_uri;
     u_char                         min_instances_string[12];
     u_char                         framework_spawner_idle_time_string[12];
     u_char                         app_spawner_idle_time_string[12];
@@ -367,6 +368,19 @@ create_request(ngx_http_request_t *r)
     }
     
     
+    /*
+     * Nginx unescapes URI's before passing them to Phusion Passenger,
+     * but backend processes expect the escaped version.
+     * http://code.google.com/p/phusion-passenger/issues/detail?id=404
+     */
+    escaped_uri.len =
+        2 * ngx_escape_uri(NULL, r->uri.data, r->uri.len, NGX_ESCAPE_URI)
+        + r->uri.len;
+    escaped_uri.data = ngx_pnalloc(r->pool, escaped_uri.len + 1);
+    escaped_uri.data[escaped_uri.len] = '\0';
+    ngx_escape_uri(escaped_uri.data, r->uri.data, r->uri.len, NGX_ESCAPE_URI);
+
+
     /**************************************************
      * Determine the request header length.
      **************************************************/
@@ -381,16 +395,20 @@ create_request(ngx_http_request_t *r)
     /* +1 for trailing null */
     len = sizeof("CONTENT_LENGTH") + ngx_strlen(buf) + 1;
     
-    /* DOCUMENT_ROOT, SCRIPT_NAME, RAILS_RELATIVE_URL_ROOT and PATH_INFO. */
+    /* DOCUMENT_ROOT, SCRIPT_NAME, RAILS_RELATIVE_URL_ROOT, PATH_INFO and REQUEST_URI. */
     len += sizeof("DOCUMENT_ROOT") + context->public_dir.len + 1;
     if (context->base_uri.len > 0) {
         len += sizeof("SCRIPT_NAME") + context->base_uri.len + 1;
         len += sizeof("RAILS_RELATIVE_URL_ROOT") +
                context->base_uri.len + 1;
-        len += sizeof("PATH_INFO") + r->uri.len - context->base_uri.len + 1;
+        len += sizeof("PATH_INFO") + escaped_uri.len - context->base_uri.len + 1;
     } else {
         len += sizeof("SCRIPT_NAME") + sizeof("");
-        len += sizeof("PATH_INFO") + r->uri.len + 1;
+        len += sizeof("PATH_INFO") + escaped_uri.len + 1;
+    }
+    len += sizeof("REQUEST_URI") + escaped_uri.len + 1;
+    if (r->args.len > 0) {
+        len += 1 + r->args.len;
     }
     
     /* Various other HTTP headers. */
@@ -569,7 +587,7 @@ create_request(ngx_http_request_t *r)
     b->last = ngx_snprintf(b->last, 10, "%ui", content_length);
     *b->last++ = (u_char) 0;
     
-    /* Build DOCUMENT_ROOT, SCRIPT_NAME, RAILS_RELATIVE_URL_ROOT and PATH_INFO. */
+    /* Build DOCUMENT_ROOT, SCRIPT_NAME, RAILS_RELATIVE_URL_ROOT, PATH_INFO and REQUEST_URI. */
     b->last = ngx_copy(b->last, "DOCUMENT_ROOT", sizeof("DOCUMENT_ROOT"));
     b->last = ngx_copy(b->last, context->public_dir.data,
                        context->public_dir.len + 1);
@@ -585,18 +603,26 @@ create_request(ngx_http_request_t *r)
                            context->base_uri.len + 1);
         
         b->last = ngx_copy(b->last, "PATH_INFO", sizeof("PATH_INFO"));
-        b->last = ngx_copy(b->last, r->uri.data + context->base_uri.len,
-                           r->uri.len - context->base_uri.len);
+        b->last = ngx_copy(b->last, escaped_uri.data + context->base_uri.len,
+                           escaped_uri.len - context->base_uri.len);
         b->last = ngx_copy(b->last, "", 1);
     } else {
         b->last = ngx_copy(b->last, "SCRIPT_NAME", sizeof("SCRIPT_NAME"));
         b->last = ngx_copy(b->last, "", sizeof(""));
         
         b->last = ngx_copy(b->last, "PATH_INFO", sizeof("PATH_INFO"));
-        b->last = ngx_copy(b->last, r->uri.data, r->uri.len);
+        b->last = ngx_copy(b->last, escaped_uri.data, escaped_uri.len);
         b->last = ngx_copy(b->last, "", 1);
     }
     
+    b->last = ngx_copy(b->last, "REQUEST_URI", sizeof("REQUEST_URI"));
+    b->last = ngx_copy(b->last, escaped_uri.data, escaped_uri.len);
+    if (r->args.len > 0) {
+        b->last = ngx_copy(b->last, "?", 1);
+        b->last = ngx_copy(b->last, r->args.data, r->args.len);
+    }
+    b->last = ngx_copy(b->last, "", 1);
+    
     /* Various other HTTP headers. */
     if (r->headers_in.content_type != NULL
      && r->headers_in.content_type->value.len > 0) {