passenger 2.2.15 → 3.0.0.pre1

data/test/oxt/dynamic_thread_group_test.cpp

@@ -0,0 +1,131 @@
+#include "../tut/tut.h"
+#include "counter.hpp"
+#include <boost/bind.hpp>
+#include <boost/thread/thread_time.hpp>
+#include <oxt/dynamic_thread_group.hpp>
+#include <oxt/system_calls.hpp>
+#include <unistd.h>
+
+using namespace boost;
+using namespace oxt;
+
+namespace tut {
+	struct dynamic_thread_group_test {
+		dynamic_thread_group group;
+	};
+	
+	DEFINE_TEST_GROUP(dynamic_thread_group_test);
+	
+	TEST_METHOD(1) {
+		// It has 0 threads in the beginning.
+		ensure_equals(group.num_threads(), 0u);
+	}
+	
+	static void wait_until_done(CounterPtr parent_counter, CounterPtr child_counter) {
+		// Tell parent thread that this thread has started.
+		parent_counter->increment();
+		
+		// Wait until parent says that we can quit.
+		child_counter->wait_until(1);
+	}
+	
+	TEST_METHOD(2) {
+		// Test whether newly created threads are added to the thread
+		// group, and whether they are automatically removed from the
+		// thread group upon termination.
+		
+		// Start 3 'f' threads.
+		CounterPtr f_parent_counter = Counter::create_ptr();
+		CounterPtr f_child_counter  = Counter::create_ptr();
+		boost::function<void()> f(boost::bind(wait_until_done, f_parent_counter, f_child_counter));
+		group.create_thread(f);
+		group.create_thread(f);
+		group.create_thread(f);
+		
+		// Start 1 'g' thread.
+		CounterPtr g_parent_counter = Counter::create_ptr();
+		CounterPtr g_child_counter  = Counter::create_ptr();
+		boost::function<void()> g(boost::bind(wait_until_done, g_parent_counter, g_child_counter));
+		group.create_thread(g);
+		
+		f_parent_counter->wait_until(3); // Wait until all 'f' threads have started.
+		g_parent_counter->wait_until(1); // Wait until the 'g' thread has started.
+		
+		ensure_equals("There are 4 threads in the group", group.num_threads(), 4u);
+		
+		// Tell all 'f' threads that they can quit now.
+		f_child_counter->increment();
+		usleep(25000); // Sleep time must be large enough for Valgrind.
+		ensure_equals(group.num_threads(), 1u);
+		
+		// Tell the 'g' thread that it can quit now.
+		g_child_counter->increment();
+		usleep(25000); // Sleep time must be large enough for Valgrind.
+		ensure_equals(group.num_threads(), 0u);
+	}
+	
+	static void sleep_and_set_true(CounterPtr counter, volatile bool *flag) {
+		// Tell parent thread that this thread has started.
+		counter->increment();
+		try {
+			syscalls::usleep(5000000);
+		} catch (thread_interrupted &) {
+			*flag = true;
+		}
+	}
+	
+	TEST_METHOD(3) {
+		// interrupt_and_join_all() works.
+		
+		// Create two threads.
+		CounterPtr counter = Counter::create_ptr();
+		volatile bool flag1 = false;
+		volatile bool flag2 = false;
+		boost::function<void ()> f(boost::bind(sleep_and_set_true, counter, &flag1));
+		boost::function<void ()> g(boost::bind(sleep_and_set_true, counter, &flag2));
+		group.create_thread(f);
+		group.create_thread(g);
+		// Wait until both threads have started.
+		counter->wait_until(2);
+		
+		// Now interrupt and join them.
+		group.interrupt_and_join_all();
+		// Both threads should have received a thread interruption
+		// request and terminated as a result.
+		ensure_equals(flag1, true);
+		ensure_equals(flag2, true);
+		ensure_equals(group.num_threads(), 0u);
+	}
+	
+	static void do_nothing(unsigned int max) {
+		unsigned int i;
+		for (i = 0; i < max; i++) { }
+	}
+	
+	static void create_threads(dynamic_thread_group *group) {
+		for (int i = 1000; i >= 0; i--) {
+			boost::function<void ()> f(boost::bind(do_nothing, i * 1000));
+			group->create_thread(f, "", 256 * 1024);
+		}
+	}
+	
+	static void interrupt_group(dynamic_thread_group *group) {
+		for (int i = 0; i < 1000; i++) {
+			group->interrupt_and_join_all();
+		}
+	}
+	
+	TEST_METHOD(4) {
+		// Stress test.
+		oxt::thread thr1(boost::bind(create_threads, &group));
+		oxt::thread thr2(boost::bind(interrupt_group, &group));
+		thr1.join();
+		thr2.join();
+		group.interrupt_and_join_all();
+		ensure_equals(group.num_threads(), 0u);
+	}
+	
+	TEST_METHOD(5) {
+		// If the thread function crashes then it will still be correctly removed from the pool.
+	}
+}

data/test/oxt/oxt_test_main.cpp

@@ -1,5 +1,5 @@
-#include "tut.h"
-#include "tut_reporter.h"
+#include "../tut/tut.h"
+#include "../tut/tut_reporter.h"
 #include <oxt/system_calls.hpp>
 #include <signal.h>
 #include <cstdlib>

data/test/oxt/spin_lock_test.cpp

@@ -0,0 +1,59 @@
+#include "../tut/tut.h"
+#include <boost/bind.hpp>
+#include <boost/thread.hpp>
+#include <oxt/spin_lock.hpp>
+
+using namespace boost;
+using namespace oxt;
+
+namespace tut {
+	struct spin_lock_test {
+		boost::mutex continue_mutex;
+		boost::condition_variable continue_cond;
+		bool continue_ok;
+		spin_lock lock;
+		volatile unsigned int counter;
+		
+		spin_lock_test() {
+			counter = 0;
+			continue_ok = false;
+		}
+		
+		void loop_increment(unsigned int inc) {
+			{
+				boost::mutex::scoped_lock l1(continue_mutex);
+				while (!continue_ok) {
+					continue_cond.wait(l1);
+				}
+			}
+			
+			for (unsigned int i = 0; i < inc; i++) {
+				spin_lock::scoped_lock l2(lock);
+				counter++;
+			}
+		}
+	};
+	
+	DEFINE_TEST_GROUP(spin_lock_test);
+
+	TEST_METHOD(1) {
+		boost::thread thr1(boost::bind(&spin_lock_test::loop_increment, this, 100000));
+		boost::thread thr2(boost::bind(&spin_lock_test::loop_increment, this, 100000));
+		boost::thread thr3(boost::bind(&spin_lock_test::loop_increment, this, 100000));
+		boost::thread thr4(boost::bind(&spin_lock_test::loop_increment, this, 100000));
+		
+		{
+			boost::mutex::scoped_lock l(continue_mutex);
+			continue_ok = true;
+			continue_cond.notify_all();
+		}
+		
+		thr1.join();
+		thr2.join();
+		thr3.join();
+		thr4.join();
+		
+		ensure_equals(counter, 400000u);
+	}
+}
+

data/test/oxt/syscall_interruption_test.cpp

@@ -1,4 +1,4 @@
-#include "tut.h"
+#include "../tut/tut.h"
 #include <boost/bind.hpp>
 #include <oxt/thread.hpp>
 #include <oxt/system_calls.hpp>

data/test/ruby/abstract_request_handler_spec.rb

@@ -1,17 +1,18 @@
-require 'support/config'
-require 'support/test_helper'
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'phusion_passenger/abstract_request_handler'
+require 'phusion_passenger/analytics_logger'
 
 require 'fileutils'
 
-include PhusionPassenger
+module PhusionPassenger
 
 describe AbstractRequestHandler do
 	before :each do
+		preinitialize if respond_to?(:preinitialize)
 		@old_passenger_tmpdir = Utils.passenger_tmpdir
 		Utils.passenger_tmpdir = "abstract_request_handler_spec.tmp"
 		@owner_pipe = IO.pipe
-		@request_handler = AbstractRequestHandler.new(@owner_pipe[1])
+		@request_handler = AbstractRequestHandler.new(@owner_pipe[1], @options || {})
 		def @request_handler.process_request(*args)
 			# Do nothing.
 		end
@@ -21,24 +22,34 @@ describe AbstractRequestHandler do
 		@request_handler.cleanup
 		@owner_pipe[0].close rescue nil
 		Utils.passenger_tmpdir = @old_passenger_tmpdir
+		FileUtils.chmod_R(0777, "abstract_request_handler_spec.tmp")
 		FileUtils.rm_rf("abstract_request_handler_spec.tmp")
 	end
 	
-	def prepare
-		# Do nothing. To be overrided by sub describe blocks.
+	def connect(socket_name = :main)
+		if @request_handler.server_sockets[socket_name][1] == "unix"
+			return UNIXSocket.new(@request_handler.server_sockets[socket_name][0])
+		else
+			addr, port = @request_handler.server_sockets[socket_name][0].split(/:/)
+			return TCPSocket.new(addr, port.to_i)
+		end
+	end
+	
+	def send_binary_request(socket, env)
+		channel = MessageChannel.new(socket)
+		data = ""
+		env.each_pair do |key, value|
+			data << key << "\0"
+			data << value << "\0"
+		end
+		channel.write_scalar(data)
 	end
 	
 	it "exits if the owner pipe is closed" do
 		@request_handler.start_main_loop_thread
 		@owner_pipe[0].close
-		begin
-			Timeout.timeout(5) do
-				wait_until do
-					!@request_handler.main_loop_running?
-				end
-			end
-		rescue Timeout::Error
-			violated
+		eventually do
+			!@request_handler.main_loop_running?
 		end
 	end
 	
@@ -47,39 +58,349 @@ describe AbstractRequestHandler do
 			return nil
 		end
 		@request_handler.start_main_loop_thread
-		wait_until do
+		eventually do
 			@request_handler.iterations != 0
 		end
 		@request_handler.processed_requests.should == 0
 	end
 	
 	it "creates a socket file in the Phusion Passenger temp folder, unless when using TCP sockets" do
-		if @request_handler.socket_type == "unix"
+		if @request_handler.server_sockets[:main][1] == "unix"
 			File.chmod(0700, "abstract_request_handler_spec.tmp/backends")
 			Dir["abstract_request_handler_spec.tmp/backends/*"].should_not be_empty
 		end
 	end
 	
-	it "accepts pings" do
+	specify "the main socket rejects headers that are too large" do
+		stderr = StringIO.new
+		DebugLogging.log_level = 0
+		DebugLogging.stderr_evaluator = lambda { stderr }
 		@request_handler.start_main_loop_thread
-		if @request_handler.socket_type == "unix"
-			client = UNIXSocket.new(@request_handler.socket_name)
-		else
-			addr, port = @request_handler.socket_name.split(/:/)
-			client = TCPSocket.new(addr, port.to_i)
+		begin
+			client = connect
+			client.sync = true
+			block = lambda do
+				data = "REQUEST_METHOD\0/"
+				data << "x" * (AbstractRequestHandler::MAX_HEADER_SIZE * 2)
+				data << "\0"
+				MessageChannel.new(client).write_scalar(data)
+			end
+			block.should raise_error(Errno::EPIPE)
+			stderr.string.should_not be_empty
+		ensure
+			client.close rescue nil
+		end
+	end
+	
+	specify "the main socket rejects unauthenticated connections, if a connect password is supplied" do
+		@request_handler.connect_password = "1234"
+		@request_handler.start_main_loop_thread
+		begin
+			client = connect
+			channel = MessageChannel.new(client)
+			channel.write_scalar("REQUEST_METHOD\0PING\0")
+			client.read.should == ""
+		ensure
+			client.close rescue nil
 		end
 		begin
+			client = connect
 			channel = MessageChannel.new(client)
-			channel.write_scalar("REQUEST_METHOD\0ping\0")
+			channel.write_scalar("REQUEST_METHOD\0PING\0PASSENGER_CONNECT_PASSWORD\0001234\0")
+			client.read.should == "pong"
+		ensure
+			client.close rescue nil
+		end
+	end
+	
+	it "accepts pings on the main server socket" do
+		@request_handler.start_main_loop_thread
+		client = connect
+		begin
+			channel = MessageChannel.new(client)
+			channel.write_scalar("REQUEST_METHOD\0PING\0")
+			client.read.should == "pong"
+		ensure
+			client.close
+		end
+	end
+	
+	it "accepts pings on the HTTP server socket" do
+		@request_handler.start_main_loop_thread
+		addr, port = @request_handler.server_sockets[:http][0].split(/:/)
+		client = TCPSocket.new(addr, port.to_i)
+		begin
+			client.write("PING / HTTP/1.1\r\n")
+			client.write("Host: foo.com\r\n\r\n")
+			client.close_write
 			client.read.should == "pong"
 		ensure
 			client.close
 		end
 	end
 	
-	def wait_until
-		while !yield
+	specify "the HTTP socket rejects headers that are too large" do
+		stderr = StringIO.new
+		DebugLogging.log_level = 0
+		DebugLogging.stderr_evaluator = lambda { stderr }
+		@request_handler.start_main_loop_thread
+		begin
+			client = connect(:http)
+			client.sync = true
+			block = lambda do
+				client.write("GET /")
+				client.write("x" * AbstractRequestHandler::MAX_HEADER_SIZE)
+				sleep 0.01 # Context switch
+				client.write("x" * AbstractRequestHandler::MAX_HEADER_SIZE)
+				client.write(" HTTP/1.1\r\n")
+			end
+			block.should raise_error(SystemCallError)
+			stderr.string.should_not be_empty
+		ensure
+			client.close rescue nil
+		end
+	end
+	
+	specify "the HTTP socket rejects unauthenticated connections, if a connect password is supplied" do
+		DebugLogging.log_level = -1
+		@request_handler.connect_password = "1234"
+		@request_handler.start_main_loop_thread
+		begin
+			client = connect(:http)
+			client.write("PING / HTTP/1.1\r\n")
+			client.write("\r\n")
+			client.read.should == ""
+		ensure
+			client.close rescue nil
+		end
+		begin
+			client = connect(:http)
+			client.write("PING / HTTP/1.1\r\n")
+			client.write("X-Passenger-Connect-Password: 1234\r\n")
+			client.write("\r\n")
+			client.read.should == "pong"
+		ensure
+			client.close rescue nil
+		end
+	end
+	
+	describe "if analytics logger is given" do
+		def preinitialize
+			if @agent_pid
+				Process.kill('KILL', @agent_pid)
+				Process.waitpid(@agent_pid)
+			end
+			@log_dir = Utils.passenger_tmpdir
+			@logging_agent_password = "1234"
+			@agent_pid, @socket_filename, @socket_address = spawn_logging_agent(@log_dir,
+				@logging_agent_password)
+			
+			@logger = AnalyticsLogger.new(@socket_address, "logging",
+				"1234", "localhost")
+			@options = { "analytics_logger" => @logger }
+		end
+		
+		after :each do
+			if @agent_pid
+				Process.kill('KILL', @agent_pid)
+				Process.waitpid(@agent_pid)
+			end
+		end
+		
+		def base64(data)
+			return [data].pack('m').gsub("\n", "")
+		end
+		
+		it "makes the analytics log object available through the request env and a thread-local variable" do
+			header_value = nil
+			thread_value = nil
+			@request_handler.should_receive(:process_request).and_return do |headers, input, output, status_line_desired|
+				header_value = headers[PASSENGER_ANALYTICS_WEB_LOG]
+				thread_value = Thread.current[PASSENGER_ANALYTICS_WEB_LOG]
+			end
+			@request_handler.start_main_loop_thread
+			client = connect
+			begin
+				send_binary_request(client,
+					"REQUEST_METHOD" => "GET",
+					"PASSENGER_TXN_ID" => "1234-abcd",
+					"PASSENGER_GROUP_NAME" => "foobar")
+				client.read
+			ensure
+				client.close
+			end
+			header_value.should be_kind_of(AnalyticsLogger::Log)
+			thread_value.should be_kind_of(AnalyticsLogger::Log)
+			header_value.should == thread_value
+		end
+		
+		it "logs uncaught exceptions for requests that have a transaction ID" do
+			@request_handler.should_receive(:process_request).and_return do |headers, input, output, status_line_desired|
+				raise "something went wrong"
+			end
+			@request_handler.start_main_loop_thread
+			client = connect
+			begin
+				DebugLogging.log_level = -2
+				send_binary_request(client,
+					"REQUEST_METHOD" => "GET",
+					"PASSENGER_TXN_ID" => "1234-abcd",
+					"PASSENGER_GROUP_NAME" => "foobar")
+			ensure
+				client.close
+			end
+			eventually(5) do
+				flush_logging_agent(@logging_agent_password, @socket_address)
+				log_file = Dir["#{@log_dir}/1/*/*/exceptions/**/log.txt"].first
+				if log_file
+					log_data = File.read(log_file)
+				else
+					log_data = ""
+				end
+				log_data.include?("Request transaction ID: 1234-abcd\n") &&
+					log_data.include?("Message: " + base64("something went wrong")) &&
+					log_data.include?("Class: RuntimeError") &&
+					log_data.include?("Backtrace: ")
+			end
+		end
+	end
+	
+	describe "HTTP parsing" do
+		before :each do
+			@request_handler.start_main_loop_thread
+			addr, port = @request_handler.server_sockets[:http][0].split(/:/)
+			port = port.to_i
+			@client = TCPSocket.new(addr, port)
+			@client.sync = true
+		end
+		
+		after :each do
+			@client.close
+		end
+		
+		it "correctly parses HTTP requests without query string" do
+			@request_handler.should_receive(:process_request).and_return do |headers, input, output, status_line_desired|
+				headers["REQUEST_METHOD"].should == "POST"
+				headers["SERVER_PROTOCOL"].should == "HTTP/1.1"
+				headers["HTTP_HOST"].should == "foo.com"
+				headers["HTTP_X_FOO_BAR"].should == "baz"
+				headers["PATH_INFO"].should == "/foo/bar"
+				headers["SCRIPT_NAME"].should == ""
+				headers["QUERY_STRING"].should == ""
+				headers["REQUEST_URI"].should == "/foo/bar"
+				headers["HTTP_CONTENT_LENGTH"].should be_nil
+				headers["HTTP_CONTENT_TYPE"].should be_nil
+				headers["CONTENT_LENGTH"].should == "10"
+				headers["CONTENT_TYPE"].should == "text/plain"
+			end
+			
+			@client.write("POST /foo/bar HTTP/1.1\r\n")
+			@client.write("Host: foo.com\r\n")
+			@client.write("X-Foo-Bar: baz\r\n")
+			@client.write("Content-Length: 10\r\n")
+			@client.write("Content-Type: text/plain\r\n")
+			@client.write("\r\n")
+			@client.close_write
+			@client.read
+		end
+		
+		it "correctly parses HTTP requests with query string" do
+			@request_handler.should_receive(:process_request).and_return do |headers, input, output, status_line_desired|
+				headers["REQUEST_METHOD"].should == "POST"
+				headers["SERVER_PROTOCOL"].should == "HTTP/1.1"
+				headers["HTTP_HOST"].should == "foo.com"
+				headers["HTTP_X_FOO_BAR"].should == "baz"
+				headers["PATH_INFO"].should == "/foo/bar"
+				headers["SCRIPT_NAME"].should == ""
+				headers["QUERY_STRING"].should == "hello=world&a=b+c"
+				headers["REQUEST_URI"].should == "/foo/bar?hello=world&a=b+c"
+				headers["HTTP_CONTENT_LENGTH"].should be_nil
+				headers["HTTP_CONTENT_TYPE"].should be_nil
+				headers["CONTENT_LENGTH"].should == "10"
+				headers["CONTENT_TYPE"].should == "text/plain"
+			end
+			
+			@client.write("POST /foo/bar?hello=world&a=b+c HTTP/1.1\r\n")
+			@client.write("Host: foo.com\r\n")
+			@client.write("X-Foo-Bar: baz\r\n")
+			@client.write("Content-Length: 10\r\n")
+			@client.write("Content-Type: text/plain\r\n")
+			@client.write("\r\n")
+			@client.close_write
+			@client.read
+		end
+		
+		it "correct parses HTTP requests that come in arbitrary chunks" do
+			@request_handler.should_receive(:process_request).and_return do |headers, input, output, status_line_desired|
+				headers["REQUEST_METHOD"].should == "POST"
+				headers["SERVER_PROTOCOL"].should == "HTTP/1.1"
+				headers["HTTP_HOST"].should == "foo.com"
+				headers["HTTP_X_FOO_BAR"].should == "baz"
+				headers["PATH_INFO"].should == "/foo/bar"
+				headers["SCRIPT_NAME"].should == ""
+				headers["QUERY_STRING"].should == "hello=world&a=b+c"
+				headers["REQUEST_URI"].should == "/foo/bar?hello=world&a=b+c"
+				headers["HTTP_CONTENT_LENGTH"].should be_nil
+				headers["HTTP_CONTENT_TYPE"].should be_nil
+				headers["CONTENT_LENGTH"].should == "10"
+				headers["CONTENT_TYPE"].should == "text/plain"
+				headers["HTTP_PLUS_SOME"].should be_nil
+			end
+			
+			@client.write("POST /fo")
+			sleep 0.001
+			@client.write("o/bar?hello=world&a=b+c HT")
+			sleep 0.001
+			@client.write("TP/1.1\r")
+			sleep 0.001
+			@client.write("\nHost: foo.com")
+			sleep 0.001
+			@client.write("\r\n")
+			sleep 0.001
+			@client.write("X-Foo-Bar: baz\r\n")
+			sleep 0.001
+			@client.write("Content-Len")
+			sleep 0.001
+			@client.write("gth: 10\r\nContent-Type: text/pla")
+			sleep 0.001
+			@client.write("in\r\n\r")
+			sleep 0.001
+			@client.write("\nPlus-Some: garbage data that should be ignored.")
+			@client.close_write
+			@client.read
+		end
+	end
+	
+	specify "upon receiving a soft shutdown signal, the main loop quits a while after the last connection was accepted" do
+		@request_handler.soft_termination_linger_time = 0.2
+		@request_handler.start_main_loop_thread
+		@request_handler.soft_shutdown
+		
+		# Each time we ping the server it should reset the exit time.
+		deadline = Time.now + 0.6
+		while Time.now < deadline
+			@request_handler.should be_main_loop_running
+			client = connect
+			begin
+				channel = MessageChannel.new(client)
+				channel.write_scalar("REQUEST_METHOD\0PING\0")
+				client.read
+				sleep 0.02
+			ensure
+				client.close
+			end
+		end
+		@request_handler.should be_main_loop_running
+		
+		# After we're done pinging it should quit within a short period of time.
+		deadline = Time.now + 0.6
+		while Time.now < deadline && @request_handler.main_loop_running?
 			sleep 0.01
 		end
+		@request_handler.should_not be_main_loop_running
 	end
+	
+	############################
 end
+
+end # module PhusionPassenger