passenger 2.0.6 → 2.1.2

data/test/oxt/backtrace_test.cpp

@@ -0,0 +1,128 @@
+#include "tut.h"
+#include <oxt/backtrace.hpp>
+#include <oxt/tracable_exception.hpp>
+#include <oxt/thread.hpp>
+
+using namespace oxt;
+using namespace std;
+
+namespace tut {
+	struct backtrace_test {
+	};
+	
+	DEFINE_TEST_GROUP(backtrace_test);
+
+	TEST_METHOD(1) {
+		// Test TRACE_POINT() and tracable_exception.
+		struct {
+			void foo() {
+				TRACE_POINT();
+				bar();
+			}
+			
+			void bar() {
+				TRACE_POINT();
+				baz();
+			}
+			
+			void baz() {
+				TRACE_POINT();
+				throw tracable_exception();
+			}
+		} object;
+		
+		try {
+			object.foo();
+			fail("tracable_exception expected.");
+		} catch (const tracable_exception &e) {
+			ensure("Backtrace contains foo()",
+				e.backtrace().find("foo()") != string::npos);
+			ensure("Backtrace contains bar()",
+				e.backtrace().find("bar()") != string::npos);
+			ensure("Backtrace contains baz()",
+				e.backtrace().find("baz()") != string::npos);
+		}
+	}
+	
+	struct QuitEvent {
+		bool is_done;
+		boost::mutex mutex;
+		boost::condition_variable cond;
+		
+		QuitEvent() {
+			is_done = false;
+		}
+		
+		void wait() {
+			boost::unique_lock<boost::mutex> l(mutex);
+			while (!is_done) {
+				cond.wait(l);
+			}
+		}
+		
+		void done() {
+			is_done = true;
+			cond.notify_all();
+		}
+	};
+	
+	struct FooCaller {
+		QuitEvent *quit_event;
+		
+		static void foo(QuitEvent *quit_event) {
+			TRACE_POINT();
+			quit_event->wait();
+		}
+		
+		void operator()() {
+			foo(quit_event);
+		}
+	};
+	
+	struct BarCaller {
+		QuitEvent *quit_event;
+		
+		static void bar(QuitEvent *quit_event) {
+			TRACE_POINT();
+			quit_event->wait();
+		}
+		
+		void operator()() {
+			bar(quit_event);
+		}
+	};
+	
+	TEST_METHOD(2) {
+		// Test whether oxt::thread's backtrace support works.
+		FooCaller foo;
+		QuitEvent foo_quit;
+		foo.quit_event = &foo_quit;
+		
+		BarCaller bar;
+		QuitEvent bar_quit;
+		bar.quit_event = &bar_quit;
+		
+		oxt::thread foo_thread(foo);
+		oxt::thread bar_thread(bar);
+		usleep(20000);
+		
+		ensure("Foo thread's backtrace contains foo()",
+			foo_thread.backtrace().find("foo") != string::npos);
+		ensure("Foo thread's backtrace doesn't contain bar()",
+			foo_thread.backtrace().find("bar") == string::npos);
+		ensure("Bar thread's backtrace contains bar()",
+			bar_thread.backtrace().find("bar") != string::npos);
+		ensure("Bar thread's backtrace doesn't contain foo()",
+			bar_thread.backtrace().find("foo") == string::npos);
+		
+		string all_backtraces(oxt::thread::all_backtraces());
+		ensure(all_backtraces.find("foo") != string::npos);
+		ensure(all_backtraces.find("bar") != string::npos);
+		
+		foo_quit.done();
+		bar_quit.done();
+		foo_thread.join();
+		bar_thread.join();
+	}
+}
+

data/test/oxt/oxt_test_main.cpp

@@ -0,0 +1,25 @@
+#include "tut.h"
+#include "tut_reporter.h"
+#include <oxt/system_calls.hpp>
+#include <signal.h>
+#include <cstdlib>
+
+namespace tut {
+	test_runner_singleton runner;
+}
+
+int main() {
+	tut::reporter reporter;
+	tut::runner.get().set_callback(&reporter);
+	signal(SIGPIPE, SIG_IGN);
+	setenv("RAILS_ENV", "production", 1);
+	setenv("TESTING_PASSENGER", "1", 1);
+	oxt::setup_syscall_interruption_support();
+	try {
+		tut::runner.get().run_tests();
+	} catch (const std::exception &ex) {
+		std::cerr << "Exception raised: " << ex.what() << std::endl;
+		return 1;
+	}
+	return 0;
+}

data/test/oxt/syscall_interruption_test.cpp

@@ -0,0 +1,50 @@
+#include "tut.h"
+#include <boost/bind.hpp>
+#include <oxt/thread.hpp>
+#include <oxt/system_calls.hpp>
+#include <unistd.h>
+#include <ctime>
+
+using namespace oxt;
+using namespace std;
+
+namespace tut {
+	struct SyscallInterruptionTest {
+		SyscallInterruptionTest() {
+			setup_syscall_interruption_support();
+		}
+		
+		~SyscallInterruptionTest() {
+			struct sigaction action;
+			
+			action.sa_handler = SIG_DFL;
+			action.sa_flags   = 0;
+			sigemptyset(&action.sa_mask);
+			sigaction(INTERRUPTION_SIGNAL, &action, NULL);
+		}
+	};
+	
+	DEFINE_TEST_GROUP(SyscallInterruptionTest);
+	
+	struct SleepFunction {
+		void operator()() {
+			syscalls::usleep(6000000);
+		}
+	};
+	
+	TEST_METHOD(1) {
+		// System call interruption works.
+		SleepFunction s;
+		oxt::thread thr(s);
+		usleep(20000);
+		
+		time_t begin, end, time_spent_in_thread;
+		begin = time(NULL);
+		thr.interrupt_and_join();
+		end = time(NULL);
+		time_spent_in_thread = end - begin;
+		
+		ensure(time_spent_in_thread <= 2);
+	}
+}
+

data/test/ruby/abstract_request_handler_spec.rb

@@ -0,0 +1,83 @@
+require 'support/config'
+require 'support/test_helper'
+require 'phusion_passenger/abstract_request_handler'
+
+require 'fileutils'
+
+include PhusionPassenger
+
+describe AbstractRequestHandler do
+	before :each do
+		ENV['PHUSION_PASSENGER_TMP'] = "abstract_request_handler_spec.tmp"
+		@owner_pipe = IO.pipe
+		@request_handler = AbstractRequestHandler.new(@owner_pipe[1])
+		def @request_handler.process_request(*args)
+			# Do nothing.
+		end
+	end
+	
+	after :each do
+		@request_handler.cleanup
+		@owner_pipe[0].close rescue nil
+		ENV.delete('PHUSION_PASSENGER_TMP')
+		FileUtils.rm_rf("abstract_request_handler_spec.tmp")
+	end
+	
+	def prepare
+		# Do nothing. To be overrided by sub describe blocks.
+	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
+		end
+	end
+	
+	it "ignores new connections that don't send any data" do
+		def @request_handler.accept_connection
+			return nil
+		end
+		@request_handler.start_main_loop_thread
+		wait_until 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"
+			Dir["abstract_request_handler_spec.tmp/*"].should_not be_empty
+		end
+	end
+	
+	it "accepts pings" do
+		@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)
+		end
+		begin
+			channel = MessageChannel.new(client)
+			channel.write_scalar("REQUEST_METHOD\0ping\0")
+			client.read.should == "pong"
+		ensure
+			client.close
+		end
+	end
+	
+	def wait_until
+		while !yield
+			sleep 0.01
+		end
+	end
+end

data/test/ruby/abstract_server_collection_spec.rb

@@ -0,0 +1,246 @@
+require 'support/config'
+require 'support/test_helper'
+require 'phusion_passenger/abstract_server'
+require 'phusion_passenger/abstract_server_collection'
+
+include PhusionPassenger
+
+describe AbstractServerCollection do
+	before :each do
+		@collection = AbstractServerCollection.new
+	end
+	
+	after :each do
+		@collection.cleanup
+	end
+	
+	specify "#lookup_or_add adds the server returned by its block" do
+		@collection.synchronize do
+			@collection.lookup_or_add('foo') do
+				AbstractServer.new
+			end
+			@collection.should have_key('foo')
+		end
+	end
+	
+	specify "#lookup_or_add does not execute the block if the key exists" do
+		@collection.synchronize do
+			@collection.lookup_or_add('foo') do
+				AbstractServer.new
+			end
+			@collection.lookup_or_add('foo') do
+				violated
+			end
+		end
+	end
+	
+	specify "#lookup_or_add returns the found server" do
+		@collection.synchronize do
+			server = AbstractServer.new
+			@collection.lookup_or_add('foo') { server }
+			result = @collection.lookup_or_add('foo') { AbstractServer.new }
+			result.should == server
+		end
+	end
+	
+	specify "#lookup_or_add returns the value of the block if server is not already in the collection" do
+		@collection.synchronize do
+			server = AbstractServer.new
+			result = @collection.lookup_or_add('foo') do
+				server
+			end
+			result.should == server
+		end
+	end
+	
+	specify "#delete deletes the server with the given key" do
+		@collection.synchronize do
+			@collection.lookup_or_add('foo') do
+				AbstractServer.new
+			end
+			@collection.delete('foo')
+			@collection.should_not have_key('foo')
+		end
+	end
+	
+	specify "#delete stop the server if it's started" do
+		@collection.synchronize do
+			server = AbstractServer.new
+			@collection.lookup_or_add('foo') do
+				server.start
+				server
+			end
+			@collection.delete('foo')
+			server.should_not be_started
+		end
+	end
+	
+	specify "#clear deletes everything" do
+		@collection.synchronize do
+			@collection.lookup_or_add('foo') do
+				AbstractServer.new
+			end
+			@collection.lookup_or_add('bar') do
+				AbstractServer.new
+			end
+			@collection.clear
+			@collection.should_not have_key('foo')
+			@collection.should_not have_key('bar')
+		end
+	end
+	
+	specify "#cleanup deletes everything" do
+		@collection.synchronize do
+			@collection.lookup_or_add('foo') do
+				AbstractServer.new
+			end
+			@collection.lookup_or_add('bar') do
+				AbstractServer.new
+			end
+		end
+		@collection.cleanup
+		@collection.synchronize do
+			@collection.should_not have_key('foo')
+			@collection.should_not have_key('bar')
+		end
+	end
+	
+	specify "#cleanup stops all servers" do
+		servers = []
+		3.times do
+			server = AbstractServer.new
+			server.start
+			servers << server
+		end
+		@collection.synchronize do
+			@collection.lookup_or_add('foo') { servers[0] }
+			@collection.lookup_or_add('bar') { servers[1] }
+			@collection.lookup_or_add('baz') { servers[2] }
+		end
+		@collection.cleanup
+		servers.each do |server|
+			server.should_not be_started
+		end
+	end
+	
+	specify "idle servers are cleaned up periodically" do
+		foo = AbstractServer.new
+		foo.max_idle_time = 0.05
+		bar = AbstractServer.new
+		bar.max_idle_time = 2
+		
+		@collection.synchronize do
+			@collection.lookup_or_add('foo') { foo }
+			@collection.lookup_or_add('bar') { bar }
+		end
+		sleep 0.3
+		@collection.synchronize do
+			@collection.should_not have_key('foo')
+			@collection.should have_key('bar')
+		end
+	end
+	
+	specify "servers with max_idle_time of 0 are never cleaned up" do
+		@collection.synchronize do
+			@collection.lookup_or_add('foo') { AbstractServer.new }
+		end
+		original_cleaning_time = @collection.next_cleaning_time
+		@collection.check_idle_servers!
+		
+		# Wait until the cleaner thread has run.
+		while original_cleaning_time == @collection.next_cleaning_time
+			sleep 0.01
+		end
+		
+		@collection.synchronize do
+			@collection.should have_key('foo')
+		end
+	end
+	
+	specify "upon adding a new server to an empty collection, the next cleaning will " <<
+	        "be scheduled at that server's next cleaning time" do
+		server = AbstractServer.new
+		server.max_idle_time = 10
+		@collection.synchronize do
+			@collection.lookup_or_add('foo') { server }
+		end
+		@collection.next_cleaning_time.should == server.next_cleaning_time
+	end
+	
+	specify "upon adding a new server to a nonempty collection, and that server's next cleaning " <<
+	        "time is not the smallest of all servers' cleaning times, then the next cleaning schedule " <<
+	        "will not change" do
+		server1 = AbstractServer.new
+		server1.max_idle_time = 10
+		@collection.synchronize do
+			@collection.lookup_or_add('foo') { server1 }
+		end
+		
+		server2 = AbstractServer.new
+		server2.max_idle_time = 11
+		@collection.synchronize do
+			@collection.lookup_or_add('bar') { server2 }
+		end
+		
+		@collection.next_cleaning_time.should == server1.next_cleaning_time
+	end
+	
+	specify "upon deleting server from a nonempty collection, and the deleted server's next cleaning " <<
+	        "time IS the smallest of all servers' cleaning times, then the next cleaning schedule " <<
+	        "will be changed to the smallest cleaning time of all servers" do
+		server1 = AbstractServer.new
+		server1.max_idle_time = 10
+		@collection.synchronize do
+			@collection.lookup_or_add('foo') { server1 }
+		end
+		
+		server2 = AbstractServer.new
+		server2.max_idle_time = 11
+		@collection.synchronize do
+			@collection.lookup_or_add('bar') { server2 }
+		end
+		
+		@collection.synchronize do
+			@collection.delete('foo')
+		end
+		
+		@collection.next_cleaning_time.should == server2.next_cleaning_time
+	end
+	
+	specify "upon deleting server from a nonempty collection, and the deleted server's next cleaning " <<
+	        "time IS NOT the smallest of all servers' cleaning times, then the next cleaning schedule " <<
+	        "will not change" do
+		server1 = AbstractServer.new
+		server1.max_idle_time = 10
+		@collection.synchronize do
+			@collection.lookup_or_add('foo') { server1 }
+		end
+		
+		server2 = AbstractServer.new
+		server2.max_idle_time = 11
+		@collection.synchronize do
+			@collection.lookup_or_add('bar') { server2 }
+		end
+		
+		@collection.synchronize do
+			@collection.delete('bar')
+		end
+		
+		@collection.next_cleaning_time.should == server1.next_cleaning_time
+	end
+	
+	specify "bug check" do
+		block = lambda do
+			@collection.synchronize do
+				@collection.clear
+				@collection.lookup_or_add('foo') do
+					s = AbstractServer.new
+					s.max_idle_time = 0.05
+					s
+				end
+				@collection.lookup_or_add('bar') { AbstractServer.new }
+			end
+		end
+		block.should_not raise_error
+	end
+end