passenger 2.0.6 → 2.1.2

data/ext/oxt/thread.cpp

@@ -0,0 +1,32 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 Phusion
+ *
+ * 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.
+ */
+
+#include "thread.hpp"
+
+namespace oxt {
+	boost::mutex _next_thread_number_mutex;
+	unsigned int _next_thread_number = 0;
+}
+

data/ext/oxt/thread.hpp

@@ -0,0 +1,223 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 Phusion
+ *
+ * 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 _OXT_THREAD_HPP_
+#define _OXT_THREAD_HPP_
+
+#include <boost/thread.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include "system_calls.hpp"
+#include "backtrace.hpp"
+#ifdef OXT_BACKTRACE_IS_ENABLED
+	#include <sstream>
+#endif
+
+namespace oxt {
+
+extern boost::mutex _next_thread_number_mutex;
+extern unsigned int _next_thread_number;
+
+/**
+ * Enhanced thread class with support for:
+ * - user-defined stack size.
+ * - system call interruption.
+ * - backtraces.
+ */
+class thread: public boost::thread {
+private:
+	struct thread_data {
+		std::string name;
+		#ifdef OXT_BACKTRACE_IS_ENABLED
+			thread_registration *registration;
+			boost::mutex registration_lock;
+			bool done;
+		#endif
+	};
+	
+	typedef boost::shared_ptr<thread_data> thread_data_ptr;
+	
+	thread_data_ptr data;
+
+	void initialize_data(const std::string &thread_name) {
+		data = thread_data_ptr(new thread_data());
+		if (thread_name.empty()) {
+			boost::mutex::scoped_lock l(_next_thread_number_mutex);
+			std::stringstream str;
+			
+			str << "Thread #" << _next_thread_number;
+			_next_thread_number++;
+			data->name = str.str();
+		} else {
+			data->name = thread_name;
+		}
+		#ifdef OXT_BACKTRACE_IS_ENABLED
+			data->registration = NULL;
+			data->done = false;
+		#endif
+	}
+	
+	static void thread_main(boost::function<void ()> func, thread_data_ptr data) {
+		#ifdef OXT_BACKTRACE_IS_ENABLED
+			initialize_backtrace_support_for_this_thread i(data->name);
+			data->registration = i.registration;
+		#endif
+		
+		#ifdef OXT_BACKTRACE_IS_ENABLED
+			// Put finalization code in a struct destructor,
+			// for exception safety.
+			struct finalization_routines {
+				thread_data_ptr &data;
+				
+				finalization_routines(thread_data_ptr &data_)
+					: data(data_) {}
+				
+				~finalization_routines() {
+					boost::mutex::scoped_lock l(data->registration_lock);
+					data->registration = NULL;
+					data->done = true;
+				}
+			};
+			finalization_routines f(data);
+		#endif
+		
+		func();
+	}
+	
+public:
+	/**
+	 * Create a new thread.
+	 *
+	 * @param func A function object which will be called as the thread's
+	 *     main function. This object must be copyable. <tt>func</tt> is
+	 *     copied into storage managed internally by the thread library,
+	 *     and that copy is invoked on a newly-created thread of execution.
+	 * @param name A name for this thread. If an empty string is given, then
+	 *     a name will be automatically chosen.
+	 * @param stack_size The stack size, in bytes, that the thread should
+	 *     have. If 0 is specified, the operating system's default stack
+	 *     size is used.
+	 * @pre func must be copyable.
+	 * @throws boost::thread_resource_error Something went wrong during
+	 *     creation of the thread.
+	 */
+	explicit thread(boost::function<void ()> func, const std::string &name = "", unsigned int stack_size = 0) {
+		initialize_data(name);
+		
+		set_thread_main_function(boost::bind(thread_main, func, data));
+		start_thread(stack_size);
+	}
+	
+	/**
+	 * Return this thread's name. The name was set during construction.
+	 */
+	std::string name() const throw() {
+		return data->name;
+	}
+	
+	/**
+	 * Return the current backtrace of the thread of execution, as a string.
+	 */
+	std::string backtrace() const throw() {
+		#ifdef OXT_BACKTRACE_IS_ENABLED
+			boost::mutex::scoped_lock l(data->registration_lock);
+			if (data->registration == NULL) {
+				if (data->done) {
+					return "     (no backtrace: thread has quit)";
+				} else {
+					return "     (no backtrace: thread hasn't been started yet)";
+				}
+			} else {
+				spin_lock::scoped_lock l2(*data->registration->backtrace_lock);
+				return _format_backtrace(data->registration->backtrace);
+			}
+		#else
+			return "    (backtrace support disabled during compile time)";
+		#endif
+	}
+	
+	/**
+	 * Return the backtraces of all oxt::thread threads, as well as that of the
+	 * main thread, in a nicely formatted string.
+	 */
+	static std::string all_backtraces() throw() {
+		#ifdef OXT_BACKTRACE_IS_ENABLED
+			boost::mutex::scoped_lock l(_thread_registration_mutex);
+			list<thread_registration *>::const_iterator it;
+			std::stringstream result;
+			
+			for (it = _registered_threads.begin(); it != _registered_threads.end(); it++) {
+				thread_registration *r = *it;
+				result << "Thread '" << r->name << "':" << endl;
+				
+				spin_lock::scoped_lock l(*r->backtrace_lock);
+				result << _format_backtrace(r->backtrace) << endl;
+			}
+			return result.str();
+		#else
+			return "(backtrace support disabled during compile time)";
+		#endif
+	}
+	
+	/**
+	 * Interrupt the thread. This method behaves just like
+	 * boost::thread::interrupt(), but will also respect the interruption
+	 * points defined in oxt::syscalls.
+	 *
+	 * Note that an interruption request may get lost, depending on the
+	 * current execution point of the thread. Thus, one should call this
+	 * method in a loop, until a certain goal condition has been fulfilled.
+	 * interrupt_and_join() is a convenience method that implements this
+	 * pattern.
+	 */
+	void interrupt() {
+		int ret;
+		
+		boost::thread::interrupt();
+		do {
+			ret = pthread_kill(native_handle(),
+				INTERRUPTION_SIGNAL);
+		} while (ret == EINTR);
+	}
+	
+	/**
+	 * Keep interrupting the thread until it's done, then join it.
+	 *
+	 * @throws boost::thread_interrupted The calling thread has been
+	 *    interrupted before we could join this thread.
+	 */
+	void interrupt_and_join() {
+		bool done = false;
+		while (!done) {
+			interrupt();
+			done = timed_join(boost::posix_time::millisec(10));
+		}
+	}
+};
+
+} // namespace oxt
+
+#endif /* _OXT_THREAD_HPP_ */
+

data/ext/oxt/tracable_exception.cpp

@@ -0,0 +1,87 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 Phusion
+ *
+ * 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.
+ */
+#include "tracable_exception.hpp"
+#include "backtrace.hpp"
+
+#ifdef OXT_BACKTRACE_IS_ENABLED
+
+#include <boost/thread/mutex.hpp>
+#include "macros.hpp"
+
+namespace oxt {
+
+using namespace std;
+
+tracable_exception::tracable_exception() {
+	spin_lock *lock = _get_backtrace_lock();
+	if (OXT_LIKELY(lock != NULL)) {
+		spin_lock::scoped_lock l(*lock);
+		vector<trace_point *> *bt = _get_current_backtrace();
+		vector<trace_point *>::const_iterator it;
+		
+		for (it = bt->begin(); it != bt->end(); it++) {
+			trace_point *p = new trace_point(
+				(*it)->function,
+				(*it)->source,
+				(*it)->line,
+				true);
+			backtrace_copy.push_back(p);
+		}
+	}
+}
+
+tracable_exception::tracable_exception(const tracable_exception &other) {
+	list<trace_point *>::const_iterator it;
+	for (it = other.backtrace_copy.begin(); it != other.backtrace_copy.end(); it++) {
+		trace_point *p = new trace_point(
+			(*it)->function,
+			(*it)->source,
+			(*it)->line,
+			true);
+		backtrace_copy.push_back(p);
+	}
+}
+
+tracable_exception::~tracable_exception() throw() {
+	list<trace_point *>::iterator it;
+	for (it = backtrace_copy.begin(); it != backtrace_copy.end(); it++) {
+		delete *it;
+	}
+}
+
+string
+tracable_exception::backtrace() const throw() {
+	return _format_backtrace(&backtrace_copy);
+}
+
+const char *
+tracable_exception::what() const throw() {
+	return "oxt::tracable_exception";
+}
+
+} // namespace oxt
+
+#endif
+

data/ext/oxt/tracable_exception.hpp

@@ -0,0 +1,35 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 Phusion
+ *
+ * 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 _OXT_TRACABLE_EXCEPTION_HPP_
+#define _OXT_TRACABLE_EXCEPTION_HPP_
+
+#if defined(NDEBUG) || defined(OXT_DISABLE_BACKTRACES)
+	#include "detail/tracable_exception_disabled.hpp"
+#else
+	#include "detail/tracable_exception_enabled.hpp"
+#endif
+
+#endif /* _OXT_TRACABLE_EXCEPTION_HPP_ */
+

data/{lib/passenger/constants.rb → ext/phusion_passenger/extconf.rb}

@@ -1,6 +1,8 @@
 #  Phusion Passenger - http://www.modrails.com/
 #  Copyright (C) 2008  Phusion
 #
+#  Phusion Passenger is a trademark of Hongli Lai & Ninh Bui.
+#
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
 #  the Free Software Foundation; version 2 of the License.
@@ -13,14 +15,17 @@
 #  You should have received a copy of the GNU General Public License along
 #  with this program; if not, write to the Free Software Foundation, Inc.,
 #  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+require 'mkmf'
+$LIBS=""
+
+if RUBY_PLATFORM =~ /solaris/
+	have_library('xnet')
+	$CFLAGS << " -D_XPG4_2"
+	if RUBY_PLATFORM =~ /solaris2.9/
+		$CFLAGS << " -D__SOLARIS9__"
+	end
+end
 
-module Passenger
-	FRAMEWORK_SPAWNER_MAX_IDLE_TIME = 30 * 60
-	APP_SPAWNER_MAX_IDLE_TIME       = 10 * 60
-	
-	SPAWNER_CLEAN_INTERVAL = [
-		FRAMEWORK_SPAWNER_MAX_IDLE_TIME,
-		APP_SPAWNER_MAX_IDLE_TIME
-	].min + 5
-	APP_SPAWNER_CLEAN_INTERVAL = APP_SPAWNER_MAX_IDLE_TIME + 5
+with_cflags($CFLAGS) do
+	create_makefile('native_support')
 end

data/ext/{passenger → phusion_passenger}/native_support.c

@@ -21,14 +21,26 @@
 #include <sys/types.h>
 #include <sys/un.h>
 #include <sys/socket.h>
+#include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include <errno.h>
+#ifdef __OpenBSD__
+	// OpenBSD needs this for 'struct iovec'. Apparently it isn't
+	// always included by unistd.h and sys/types.h.
+	#include <sys/uio.h>
+#endif
 
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 #ifndef RARRAY_LEN
 	#define RARRAY_LEN(ary) RARRAY(ary)->len
 #endif
+#ifndef RSTRING_PTR
+	#define RSTRING_PTR(str) RSTRING(str)->ptr
+#endif
+#ifndef RSTRING_LEN
+	#define RSTRING_LEN(str) RSTRING(str)->len
+#endif
 
 static VALUE mPassenger;
 static VALUE mNativeSupport;
@@ -48,7 +60,7 @@ send_fd(VALUE self, VALUE socket_fd, VALUE fd_to_send) {
 	struct msghdr msg;
 	struct iovec vec;
 	char dummy[1];
-	#ifdef __APPLE__
+	#if defined(__APPLE__) || defined(__SOLARIS__)
 		struct {
 			struct cmsghdr header;
 			int fd;
@@ -77,7 +89,7 @@ send_fd(VALUE self, VALUE socket_fd, VALUE fd_to_send) {
 	control_header->cmsg_level = SOL_SOCKET;
 	control_header->cmsg_type  = SCM_RIGHTS;
 	control_payload = NUM2INT(fd_to_send);
-	#ifdef __APPLE__
+	#if defined(__APPLE__) || defined(__SOLARIS__)
 		control_header->cmsg_len = sizeof(control_data);
 		control_data.fd = control_payload;
 	#else
@@ -108,7 +120,7 @@ recv_fd(VALUE self, VALUE socket_fd) {
 	struct msghdr msg;
 	struct iovec vec;
 	char dummy[1];
-	#ifdef __APPLE__
+	#if defined(__APPLE__) || defined(__SOLARIS__)
 		// File descriptor passing macros (CMSG_*) seem to be broken
 		// on 64-bit MacOS X. This structure works around the problem.
 		struct {
@@ -147,7 +159,7 @@ recv_fd(VALUE self, VALUE socket_fd) {
 		rb_sys_fail("No valid file descriptor received.");
 		return Qnil;
 	}
-	#ifdef __APPLE__
+	#if defined(__APPLE__) || defined(__SOLARIS__)
 		return INT2NUM(control_data.fd);
 	#else
 		return INT2NUM(*((int *) CMSG_DATA(control_header)));
@@ -173,7 +185,8 @@ create_unix_socket(VALUE self, VALUE filename, VALUE backlog) {
 	char *filename_str;
 	long filename_length;
 	
-	filename_str = rb_str2cstr(filename, &filename_length);
+	filename_str = RSTRING_PTR(filename);
+	filename_length = RSTRING_LEN(filename);
 	
 	fd = socket(PF_UNIX, SOCK_STREAM, 0);
 	if (fd == -1) {
@@ -251,12 +264,25 @@ close_all_file_descriptors(VALUE self, VALUE exceptions) {
 	return Qnil;
 }
 
+/*
+ * call-seq: disable_stdio_buffering
+ *
+ * Disables any kind of buffering on the C +stdout+ and +stderr+ variables,
+ * so that +fprintf()+ on +stdout+ and +stderr+ have immediate effect.
+ */
+static VALUE
+disable_stdio_buffering() {
+	setvbuf(stdout, NULL, _IONBF, 0);
+	setvbuf(stderr, NULL, _IONBF, 0);
+	return Qnil;
+}
+
 void
 Init_native_support() {
 	struct sockaddr_un addr;
 	
 	/* */
-	mPassenger = rb_define_module("Passenger"); // Do not remove the above comment. We want the Passenger module's rdoc to be empty.
+	mPassenger = rb_define_module("PhusionPassenger"); // Do not remove the above comment. We want the Passenger module's rdoc to be empty.
 	
 	/*
 	 * Utility functions for accessing system functionality.
@@ -268,6 +294,7 @@ Init_native_support() {
 	rb_define_singleton_method(mNativeSupport, "create_unix_socket", create_unix_socket, 2);
 	rb_define_singleton_method(mNativeSupport, "accept", f_accept, 1);
 	rb_define_singleton_method(mNativeSupport, "close_all_file_descriptors", close_all_file_descriptors, 1);
+	rb_define_singleton_method(mNativeSupport, "disable_stdio_buffering", disable_stdio_buffering, 0);
 	
 	/* The maximum length of a Unix socket path, including terminating null. */
 	rb_define_const(mNativeSupport, "UNIX_PATH_MAX", INT2NUM(sizeof(addr.sun_path)));