passenger 3.0.2 → 3.0.3

data/lib/phusion_passenger.rb

@@ -25,9 +25,9 @@ module PhusionPassenger
 	###### Version numbers ######
 	
 	# Phusion Passenger version number. Don't forget to edit ext/common/Constants.h too.
-	VERSION_STRING = '3.0.2'
+	VERSION_STRING = '3.0.3'
 	
-	PREFERRED_NGINX_VERSION = '0.8.53'
+	PREFERRED_NGINX_VERSION = '0.8.54'
 	PREFERRED_PCRE_VERSION  = '8.10'
 	STANDALONE_INTERFACE_VERSION  = 1
 	

data/lib/phusion_passenger/abstract_request_handler.rb

@@ -704,6 +704,11 @@ private
 				end
 				Thread.current[PASSENGER_ANALYTICS_WEB_LOG] = nil
 			ensure
+				# It is important that the following call receives an ACK
+				# from the logging server and that we don't close the socket
+				# connection until the ACK has been received, otherwise
+				# the helper agent may close the transaction before this
+				# process's openTransaction command is processed.
 				log.close
 			end
 		end

data/lib/phusion_passenger/analytics_logger.rb

@@ -107,8 +107,13 @@ class AnalyticsLogger
 		
 		def close(flush_to_disk = false)
 			@shared_data.synchronize do
+				# We need an ACK here. See abstract_request_handler.rb finalize_request.
 				@shared_data.client.write("closeTransaction", @txn_id,
-					AnalyticsLogger.timestamp_string)
+					AnalyticsLogger.timestamp_string, true)
+				result = @shared_data.client.read
+				if result != ["ok"]
+					raise "Expected logging server to respond with 'ok', but got #{result.inspect} instead"
+				end
 				if flush_to_disk
 					@shared_data.client.write("flush")
 					result = @shared_data.client.read
@@ -152,6 +157,11 @@ class AnalyticsLogger
 			@node_name = `hostname`.strip
 		end
 		@random_dev = File.open("/dev/urandom")
+		
+		# This mutex protects the following instance variables, but
+		# not the contents of @shared_data.
+		@mutex = Mutex.new
+		
 		@shared_data = SharedData.new
 		if @server_address && local_socket_address?(@server_address)
 			@max_connect_tries = 10
@@ -163,18 +173,22 @@ class AnalyticsLogger
 	end
 	
 	def clear_connection
-		@shared_data.synchronize do
-			@random_dev = File.open("/dev/urandom") if @random_dev.closed?
-			@shared_data.unref
-			@shared_data = SharedData.new
+		@mutex.synchronize do
+			@shared_data.synchronize do
+				@random_dev = File.open("/dev/urandom") if @random_dev.closed?
+				@shared_data.unref
+				@shared_data = SharedData.new
+			end
 		end
 	end
 	
 	def close
-		@shared_data.synchronize do
-			@random_dev.close
-			@shared_data.unref
-			@shared_data = nil
+		@mutex.synchronize do
+			@shared_data.synchronize do
+				@random_dev.close
+				@shared_data.unref
+				@shared_data = nil
+			end
 		end
 	end
 	
@@ -187,7 +201,8 @@ class AnalyticsLogger
 		
 		txn_id = (AnalyticsLogger.current_time.to_i / 60).to_s(36)
 		txn_id << "-#{random_token(11)}"
-		@shared_data.synchronize do
+		Lock.new(@mutex).synchronize do |lock|
+		Lock.new(@shared_data.mutex).synchronize do |shared_data_lock|
 			try_count = 0
 			if current_time >= @next_reconnect_time
 				while try_count < @max_connect_tries
@@ -197,12 +212,21 @@ class AnalyticsLogger
 							txn_id, group_name, "", category,
 							AnalyticsLogger.timestamp_string,
 							union_station_key,
+							true,
 							true)
+						result = @shared_data.client.read
+						if result != ["ok"]
+							raise "Expected logging server to respond with 'ok', but got #{result.inspect} instead"
+						end
 						return Log.new(@shared_data, txn_id)
 					rescue Errno::ENOENT, *NETWORK_ERRORS
 						try_count += 1
 						disconnect(true)
+						shared_data_lock.reset(@shared_data.mutex, false)
+						lock.unlock
 						sleep RETRY_SLEEP if try_count < @max_connect_tries
+						lock.lock
+						shared_data_lock.lock
 					rescue Exception => e
 						disconnect
 						raise e
@@ -215,6 +239,7 @@ class AnalyticsLogger
 			end
 			return Log.new
 		end
+		end
 	end
 	
 	def continue_transaction(txn_id, group_name, category = :requests, union_station_key = nil)
@@ -224,7 +249,8 @@ class AnalyticsLogger
 			raise ArgumentError, "Transaction ID may not be empty"
 		end
 		
-		@shared_data.synchronize do
+		Lock.new(@mutex).synchronize do |lock|
+		Lock.new(@shared_data.mutex).synchronize do |shared_data_lock|
 			try_count = 0
 			if current_time >= @next_reconnect_time
 				while try_count < @max_connect_tries
@@ -239,7 +265,11 @@ class AnalyticsLogger
 					rescue Errno::ENOENT, *NETWORK_ERRORS
 						try_count += 1
 						disconnect(true)
+						shared_data_lock.reset(@shared_data.mutex, false)
+						lock.unlock
 						sleep RETRY_SLEEP if try_count < @max_connect_tries
+						lock.lock
+						shared_data_lock.lock
 					rescue Exception => e
 						disconnect
 						raise e
@@ -252,6 +282,7 @@ class AnalyticsLogger
 			end
 			return Log.new
 		end
+		end
 	end
 
 private
@@ -261,7 +292,42 @@ private
 		'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
 		'0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
 	
+	class Lock
+		def initialize(mutex)
+			@mutex = mutex
+			@locked = false
+		end
+		
+		def reset(mutex, lock_now = true)
+			unlock if @locked
+			@mutex = mutex
+			lock if lock_now
+		end
+		
+		def synchronize
+			lock if !@locked
+			begin
+				yield(self)
+			ensure
+				unlock if @locked
+			end
+		end
+		
+		def lock
+			raise if @locked
+			@mutex.lock
+			@locked = true
+		end
+		
+		def unlock
+			raise if !@locked
+			@mutex.unlock
+			@locked = false
+		end
+	end
+	
 	class SharedData
+		attr_reader :mutex
 		attr_accessor :client
 		
 		def initialize

data/lib/phusion_passenger/dependencies.rb

@@ -492,7 +492,17 @@ module Dependencies # :nodoc: all
 					"<b>apt-get install libcurl4-openssl-dev</b> " +
 					"or <b>libcurl4-gnutls-dev</b>, whichever you prefer."
 			elsif tags.include?(:redhat)
-				dep.install_command = "yum install curl-devel"
+				begin
+					release = File.read("/etc/redhat-release")
+				rescue
+					release = nil
+				end
+				if release =~ /release 4/
+					# http://code.google.com/p/phusion-passenger/issues/detail?id=554
+					dep.install_command = "yum install zlib-devel e2fsprogs-devel krb5-devel libidn-devel"
+				else
+					dep.install_command = "yum install curl-devel"
+				end
 			end
 		end
 	end

data/lib/phusion_passenger/platform_info.rb

@@ -145,7 +145,7 @@ public
 	def self.find_command(name)
 		ENV['PATH'].split(File::PATH_SEPARATOR).detect do |directory|
 			path = File.join(directory, name.to_s)
-			if File.executable?(path)
+			if File.file?(path) && File.executable?(path)
 				return path
 			end
 		end

data/lib/phusion_passenger/utils.rb

@@ -57,7 +57,7 @@ protected
 		raise ArgumentError, "The 'path' argument may not be nil" if path.nil?
 		return Pathname.new(path).realpath.to_s
 	rescue Errno::ENOENT => e
-		raise InvalidAPath, e.message
+		raise InvalidPath, e.message
 	end
 	
 	# Assert that +path+ is a directory. Raises +InvalidPath+ if it isn't.
@@ -511,6 +511,10 @@ protected
 	end
 	module_function :process_is_alive?
 	
+	# Wraps another IO object. Everything written to the PseudoIO will
+	# not only be immediately forwarded to the underlying IO object but
+	# will also be captured in a buffer. The contents of the buffer
+	# can be retrieved by calling #done!.
 	class PseudoIO
 		def initialize(sink)
 			@sink = sink || File.open("/dev/null", "w")
@@ -523,6 +527,10 @@ protected
 			return result
 		end
 		
+		def to_io
+			return self
+		end
+		
 		def method_missing(*args, &block)
 			@buffer.send(*args, &block) if @buffer && args.first != :reopen
 			return @sink.send(*args, &block)

data/test/cxx/FilterSupportTest.cpp

@@ -0,0 +1,276 @@
+#include "TestSupport.h"
+#include "LoggingAgent/FilterSupport.h"
+
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
+#include <oxt/thread.hpp>
+#include <set>
+
+using namespace Passenger;
+using namespace Passenger::FilterSupport;
+using namespace std;
+using namespace oxt;
+
+namespace tut {
+	struct FilterSupportTest {
+		SimpleContext ctx;
+	};
+	
+	DEFINE_TEST_GROUP_WITH_LIMIT(FilterSupportTest, 100);
+	
+	/******** Generic tests *******/
+	
+	TEST_METHOD(1) {
+		// Filter source cannot be blank.
+		
+		try {
+			Filter f("");
+			fail("SyntaxError expected for empty filter source");
+		} catch (const SyntaxError &) {
+			// Success.
+		}
+		
+		try {
+			Filter f("    ");
+			fail("SyntaxError expected for blank filter source");
+		} catch (const SyntaxError &) {
+			// Success.
+		}
+	}
+	
+	
+	/******** String tests *******/
+	
+	TEST_METHOD(5) {
+		// Test string comparison
+		Filter f("uri == \"hello world\"");
+		ctx.uri = "hello world";
+		ensure("(1)", f.run(ctx));
+		ctx.uri = "something else";
+		ensure("(2)", !f.run(ctx));
+	}
+	
+	TEST_METHOD(6) {
+		// Test string negative comparison
+		Filter f("uri != \"hello world\"");
+		ctx.uri = "hello world";
+		ensure("(1)", !f.run(ctx));
+		ctx.uri = "something else";
+		ensure("(2)", f.run(ctx));
+	}
+	
+	TEST_METHOD(7) {
+		// Test string regexp matching
+		Filter f("uri =~ /hello world/");
+		ctx.uri = "hello world";
+		ensure("(1)", f.run(ctx));
+		ctx.uri = "hello";
+		ensure("(2)", !f.run(ctx));
+	}
+	
+	TEST_METHOD(8) {
+		// Test advanced string regexp matching
+		Filter f("uri =~ /(hello|world)\\nhi/");
+		ctx.uri = "hello\nhi";
+		ensure("(1)", f.run(ctx));
+		ctx.uri = "world\nhi";
+		ensure("(2)", f.run(ctx));
+		ctx.uri = "hello\n";
+		ensure("(3)", !f.run(ctx));
+	}
+	
+	TEST_METHOD(9) {
+		// Regexp matching is case-sensitive by default.
+		Filter f("uri =~ /Hello World/");
+		ctx.uri = "hello world";
+		ensure(!f.run(ctx));
+	}
+	
+	TEST_METHOD(10) {
+		// Regexp matching can be made case-insensitive.
+		Filter f("uri =~ /Hello World/i");
+		ctx.uri = "hello world";
+		ensure(f.run(ctx));
+	}
+	
+	TEST_METHOD(11) {
+		// Left operand may be a literal.
+		Filter f("\"hello\" == \"hello\"");
+		ensure("(1)", f.run(ctx));
+		
+		f = Filter("\"hello\" == \"world\"");
+		ensure("(2)", !f.run(ctx));
+	}
+	
+	TEST_METHOD(12) {
+		// Right operand may be a field.
+		Filter f("\"hello\" == uri");
+		ctx.uri = "hello";
+		ensure("(1)", f.run(ctx));
+		
+		f = Filter("\"hello\" == uri");
+		ctx.uri = "world";
+		ensure("(2)", !f.run(ctx));
+	}
+	
+	TEST_METHOD(13) {
+		// String syntax supports \n, \r, \t
+		ctx.uri = "hello\r\n\tworld";
+		ensure(Filter("uri == \"hello\\r\\n\\tworld\"").run(ctx));
+	}
+	
+	
+	/******** Integer tests *******/
+	
+	TEST_METHOD(20) {
+		// Test integer equality comparison
+		Filter f("response_time == 10");
+		ctx.responseTime = 10;
+		ensure("(1)", f.run(ctx));
+		ctx.responseTime = 11;
+		ensure("(2)", !f.run(ctx));
+	}
+	
+	TEST_METHOD(21) {
+		// Test integer inequality comparison
+		Filter f("response_time != 10");
+		ctx.responseTime = 10;
+		ensure("(1)", !f.run(ctx));
+		ctx.responseTime = 11;
+		ensure("(2)", f.run(ctx));
+	}
+	
+	TEST_METHOD(22) {
+		// Test integer larger than comparison
+		Filter f("response_time > 10");
+		ctx.responseTime = 11;
+		ensure("(1)", f.run(ctx));
+		ctx.responseTime = 10;
+		ensure("(2)", !f.run(ctx));
+	}
+	
+	TEST_METHOD(23) {
+		// Test integer larger than or equals comparison
+		Filter f("response_time >= 10");
+		ctx.responseTime = 10;
+		ensure("(1)", f.run(ctx));
+		ctx.responseTime = 9;
+		ensure("(2)", !f.run(ctx));
+	}
+	
+	TEST_METHOD(24) {
+		// Test integer smaller than comparison
+		Filter f("response_time < 10");
+		ctx.responseTime = 9;
+		ensure("(1)", f.run(ctx));
+		ctx.responseTime = 10;
+		ensure("(2)", !f.run(ctx));
+	}
+	
+	TEST_METHOD(25) {
+		// Test integer smaller than or equals comparison
+		Filter f("response_time <= 10");
+		ctx.responseTime = 10;
+		ensure("(1)", f.run(ctx));
+		ctx.responseTime = 11;
+		ensure("(2)", !f.run(ctx));
+	}
+	
+	TEST_METHOD(26) {
+		// Negative integers work
+		ctx.responseTime = -23;
+		ensure(Filter("response_time == -23").run(ctx));
+	}
+	
+	TEST_METHOD(27) {
+		// Left operand may be a literal.
+		ensure("(1)", Filter("2 == 2").run(ctx));
+		ensure("(2)", !Filter("2 != 2").run(ctx));
+		ensure("(3)", Filter("1 < 2").run(ctx));
+		ensure("(4)", !Filter("1 < 0").run(ctx));
+		ensure("(5)", Filter("1 <= 1").run(ctx));
+		ensure("(6)", !Filter("1 <= 0").run(ctx));
+		ensure("(7)", Filter("2 > 1").run(ctx));
+		ensure("(8)", !Filter("2 > 2").run(ctx));
+		ensure("(9)", Filter("2 >= 2").run(ctx));
+		ensure("(10)", !Filter("2 >= 3").run(ctx));
+	}
+	
+	TEST_METHOD(28) {
+		// Right operand may be a field.
+		ctx.responseTime = 2;
+		ensure("(1)", Filter("2 == response_time").run(ctx));
+		ensure("(2)", !Filter("2 != 2").run(ctx));
+		
+		ensure("(3)", Filter("1 < response_time").run(ctx));
+		ctx.responseTime = 0;
+		ensure("(4)", !Filter("1 < response_time").run(ctx));
+		
+		ctx.responseTime = 1;
+		ensure("(5)", Filter("1 <= response_time").run(ctx));
+		ctx.responseTime = 0;
+		ensure("(6)", !Filter("1 <= response_time").run(ctx));
+		
+		ctx.responseTime = 1;
+		ensure("(7)", Filter("2 > response_time").run(ctx));
+		ctx.responseTime = 2;
+		ensure("(8)", !Filter("2 > response_time").run(ctx));
+		
+		ensure("(9)", Filter("2 >= response_time").run(ctx));
+		ctx.responseTime = 3;
+		ensure("(10)", !Filter("2 >= response_time").run(ctx));
+	}
+	
+	
+	/******** Error tests *******/
+	
+	TEST_METHOD(40) {
+		// < does not work if left operand is a string
+		// < does not work if right operand is a string
+		// <= does not work if left operand is a string
+		// <= does not work if right operand is a string
+		// > does not work if left operand is a string
+		// < does not work if right operand is a string
+		// >= does not work if left operand is a string
+		// >= does not work if right operand is a string
+		// =~ does not work if left operand is not a string
+		// =~ does not work if right operand is not a regexp
+	}
+	
+	
+	/******** ContextFromLog tests *******/
+	
+	TEST_METHOD(50) {
+		// It extracts information from the logs
+		ContextFromLog ctx(
+			"1234-abcd 1234 0 BEGIN: request processing (1235, 10, 10)\n"
+			"1234-abcd 1240 1 URI: /foo\n"
+			"1234-abcd 1241 2 Controller action: HomeController#index\n"
+			"1234-abcd 2234 3 END: request processing (2234, 10, 10)\n"
+		);
+		ensure_equals(ctx.getURI(), "/foo");
+		ensure_equals(ctx.getController(), "HomeController");
+		ensure_equals(ctx.getResponseTime(), 46655);
+	}
+	
+	TEST_METHOD(51) {
+		// It ignores empty lines and invalid lines
+		ContextFromLog ctx(
+			"\n"
+			"\n"
+			"    \n"
+			"1234-abcd 1234 0 URI: /foo\n"
+			"URI: /bar\n"
+			"\n"
+		);
+		ensure_equals(ctx.getURI(), "/foo");
+	}
+	
+	TEST_METHOD(52) {
+		// It does only extracts the response time if both the begin and end events are available
+		ContextFromLog ctx(
+			"1234-abcd 1234 0 BEGIN: request processing (1235, 10, 10)\n"
+		);
+		ensure_equals(ctx.getResponseTime(), 0);
+	}
+}