colouringcode-passenger 0.1 → 0.2

data/NEWS

@@ -1,3 +1,132 @@
+Release 2.2.12
+--------------
+
+ * Improved Bundler support.
+   Previous versions might not be able to correctly load gems bundled
+   by Bundler.
+ * Fixed some Ruby 1.9 tempfile.rb compatibility problems.
+
+
+Release 2.2.11
+--------------
+
+ * This release fixes a regression that appeared in 2.2.10 which only
+   affects Apache. When under high load, Apache might freeze and stop
+   responding to requests. It is caused by a race conditions which is
+   why it escaped our last release testing.
+   
+   This problem does not affect Nginx; you only have to upgrade if
+   you're using Apache.
+   
+   http://groups.google.com/group/phusion-passenger/t/d5bb2f17c8446ea0
+
+
+Release 2.2.10
+--------------
+
+ * Fixed some Bundler compatibility problems.
+ * Fixed some file descriptor passing problems, which previously
+   could lead to mysterious crashes.
+ * Fixed some compilation problems on newer GCC versions. Issue #430.
+ * Support #size method in rack.input.
+
+
+Release 2.2.9
+-------------
+
+ * Fixed compatibility with Rails 3.
+   Actually, previous Phusion Passenger releases were already compatible
+   with Rails 3, depending on the spawn method that would be invoked. Here's
+   the story:
+   
+   Since Phusion Passenger 2.2.8, when the file config.ru exists, Phusion
+   Passenger will treat the app as a Rack app, not as a Rails app. This is
+   in contrast to earlier versions which gave Rails detection more priority
+   than Rack detection. Phusion Passenger loads Rack apps and Rails apps in
+   different ways. The Rails loader was not compatible with Rails 3, which
+   is what we've fixed in this release.
+   
+   That said, a Rails 3 app would have worked out-of-the-box on Phusion
+   Passenger 2.2.8 as well because Rails 3 apps include a config.ru file
+   by default, causing Phusion Passenger 2.2.8 to use the Rack loader.
+   Earlier versions of Phusion Passenger would just completely bail out
+   because they'd use the Rails loader.
+   
+   That said, with 2.2.9 there are still some caveats:
+   - Smart spawning (the mechanism with which REE's 33% memory reduction
+     is implemented) is *not* supported for Rack apps. This means that if
+     you want to utilize smart spawning with Rails 3, then you should
+     remove your config.ru file.
+   - Rails 3 depends on Rack 1.1.0. You must have Rack 1.1.0 installed as
+     a gem, even if you've bundled it with the gem bundler. This is because
+     Phusion Passenger itself depends on Rack.
+   
+   Both of these caveats are temporary. We have plans to solve both of these
+   properly in the future.
+ * What's up with the Gem Bundler?
+   There has been some reports that Phusion Passenger is not compatible with
+   Yehuda Katz's gem bundler (http://github.com/wycats/bundler). This might
+   have been true for an earlier version of the gem bundler, but the latest
+   version seems to work fine. Please note that you need to insert the
+   following snippet in config/preinitializer.rb, as instructed by the gem
+   bundler's README:
+   
+     require "#{RAILS_ROOT}/vendor/gems/environment"
+   
+   The Rails::Boot monkey patching code as posted at
+   http://yehudakatz.com/2009/11/03/using-the-new-gem-bundler-today/
+   does not seem to be required anymore.
+ * Fixed support for ActiveRecord subclasses that connect to another database.
+   ActiveRecord subclasses that connect to a database other than the default
+   one did not have their connection correctly cleared after forking.
+   This can result in weird errors along the lines of "Lost connection to
+   MySQL server during query". Issue #429.
+ * [Nginx] Fixed PCRE URL.
+   passenger-install-nginx-module downloads PCRE 7.8 if PCRE is not already
+   installed. However PCRE 7.8 has been removed from their FTP server,
+   so we've updated the URL to point to the latest version, 8.0.
+
+
+Release 2.2.8
+-------------
+
+ * [Nginx] Fixed some signal handling problems.
+   Restarting Nginx on OS X with SIGHUP can sometimes take a long time or
+   even fail completely. This is because of some signal handling problems,
+   which have now been fixed.
+ * [Nginx] Added OpenSSL as dependency.
+   OpenSSL is required in order to install Nginx, but this was not checked
+   by passenger-install-nginx-module. As a result,
+   passenger-install-nginx-module fails on e.g. out-of-the-box Ubuntu
+   installations until the user manually installs OpenSSL. Issue #422.
+ * [Nginx] Fixed support for internal redirects and subrequests.
+   It is now possible to, for example, point X-Accel-Redirects to Phusion
+   Passenger-served URLs. Patch contributed by W. Andrew Loe III: issue #433.
+ * [Apache] Fixed a GnuTLS compatibility issue.
+   mod_gnutls can cause Phusion Passenger to crash because of an unchecked
+   NULL pointer. This problem has now been fixed: issue #391.
+ * Fixed thread creation issue on Intel Itanium platforms.
+   This fixes issue #427.
+ * Fixed compilation problems on Linux running on the Renesas SH4 CPU.
+   Patch contributed by iwamatsu: issue #428.
+ * The Rack library has been unvendored.
+   The original reason for vendoring was to work around broken Rails
+   applications that explicitly specify Rack as a gem dependency. We've
+   found a better workaround that does not require vendoring Rack.
+   This also fixes a compatibility problem with Rails 3, because Rails
+   3 depends on a newer Rack version than the one we had vendored.
+   Issue #432.
+ * Fixed compatibility with Ruby 1.9.1 patchlevel >= 152
+   Ruby 1.9.1 patchlevel >= 152 has a bug in its tempfile library. If you've
+   seen an error message along the lines of
+
+      *** Exception IOError in Passenger RequestHandler (closed stream)
+   
+   then this is a Ruby bug at work. This bug has been fixed in Ruby 1.9.2,
+   but Ruby 1.9.1 still contains this bug. We've added a workaround so that
+   the bug is not triggered with this Ruby version. Issue #432.
+
+
 Release 2.2.7
 -------------
 

data/Rakefile

@@ -648,7 +648,7 @@ spec = Gem::Specification.new do |s|
 	s.homepage = "http://www.colouringcode.com/"
 	s.summary = "Apache module for Ruby on Rails support, custom template support"
 	s.name = "colouringcode-passenger"
-	s.version = "0.1"
+	s.version = "0.2"
 	s.rubyforge_project = "colouringcode-passenger"
 	s.author = "Colouring Code - http://www.colouringcode.com/"
 	s.email = "techystuff@colouringcode.com"
@@ -656,6 +656,7 @@ spec = Gem::Specification.new do |s|
 	s.require_paths = ["lib", "ext"]
 	s.add_dependency 'rake', '>= 0.8.1'
 	s.add_dependency 'fastthread', '>= 1.0.1'
+	s.add_dependency 'rack'
 	s.extensions << 'ext/phusion_passenger/extconf.rb'
 	s.files = FileList[
 		'Rakefile',
@@ -702,7 +703,6 @@ spec = Gem::Specification.new do |s|
 		'benchmark/*.{cpp,rb}',
 		'misc/*',
 		'misc/*/*',
-		'vendor/**/*',
 		'test/*.{rb,cpp,example}',
 		'test/support/*.{cpp,h,rb}',
 		'test/oxt/*.cpp',

data/bin/passenger-install-apache2-module

@@ -48,6 +48,7 @@ class Installer < PhusionPassenger::AbstractInstaller
 			Dependencies::Ruby_OpenSSL,
 			Dependencies::RubyGems,
 			Dependencies::Rake,
+			Dependencies::Rack,
 			Dependencies::Apache2,
 			Dependencies::Apache2_DevHeaders
 		]

data/bin/passenger-install-nginx-module

@@ -45,6 +45,8 @@ class Installer < PhusionPassenger::AbstractInstaller
 			Dependencies::Ruby_OpenSSL,
 			Dependencies::RubyGems,
 			Dependencies::Rake,
+			Dependencies::Rack,
+			Dependencies::OpenSSL_Dev,
 			Dependencies::Zlib_Dev
 		]
 		if Dependencies.fastthread_required?
@@ -147,8 +149,8 @@ private
 		new_screen
 		color_puts "<banner>PCRE (required by Nginx) not installed, downloading it...</banner>"
 		
-		basename = "pcre-7.8.tar.gz"
-		dirname = "pcre-7.8"
+		basename = "pcre-8.00.tar.gz"
+		dirname = "pcre-8.00"
 		url = "ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/#{basename}"
 		File.unlink("/tmp/#{basename}") rescue nil
 		FileUtils.rm_rf("/tmp/#{dirname}")

data/ext/apache2/Hooks.cpp

@@ -175,8 +175,10 @@ private:
 			env_arr = apr_table_elts(r->subprocess_env);
 			env_entries = (apr_table_entry_t *) env_arr->elts;
 			for (int i = 0; i < env_arr->nelts; ++i) {
-				result->push_back(env_entries[i].key);
-				result->push_back(env_entries[i].val);
+				if (env_entries[i].key != NULL && env_entries[i].val != NULL) {
+					result->push_back(env_entries[i].key);
+					result->push_back(env_entries[i].val);
+				}
 			}
 			return result;
 		}

data/ext/common/ApplicationPoolServer.h

@@ -752,7 +752,7 @@ public:
 			// Write some random data to wake up the server.
 			channel.writeRaw("x", 1);
 			
-			clientConnection = channel.readFileDescriptor();
+			clientConnection = channel.readFileDescriptor(false);
 			return ptr(new Client(clientConnection));
 		} catch (const SystemException &e) {
 			throw SystemException("Could not connect to the ApplicationPool server", e.code());

data/ext/common/ApplicationPoolServerExecutable.cpp

@@ -701,7 +701,7 @@ Server::start() {
 			}
 			
 			UPDATE_TRACE_POINT();
-			MessageChannel(serverSocket).writeFileDescriptor(fds[1]);
+			MessageChannel(serverSocket).writeFileDescriptor(fds[1], false);
 			syscalls::close(fds[1]);
 			
 			UPDATE_TRACE_POINT();

data/ext/common/MessageChannel.h

@@ -319,12 +319,24 @@ public:
 	 * descriptor is a Unix socket.
 	 *
 	 * @param fileDescriptor The file descriptor to pass.
+	 * @param negotiate See Ruby's MessageChannel#send_io method's comments.
 	 * @throws SystemException Something went wrong during file descriptor passing.
 	 * @throws boost::thread_interrupted
 	 * @pre <tt>fileDescriptor >= 0</tt>
 	 * @see readFileDescriptor()
 	 */
-	void writeFileDescriptor(int fileDescriptor) {
+	void writeFileDescriptor(int fileDescriptor, bool negotiate = true) {
+		// See message_channel.rb for more info about negotiation.
+		if (negotiate) {
+			vector<string> args;
+			
+			if (!read(args)) {
+				throw IOException("Unexpected end of stream encountered while pre-negotiating a file descriptor");
+			} else if (args.size() != 1 || args[0] != "pass IO") {
+				throw IOException("FD passing pre-negotiation message expected.");
+			}
+		}
+		
 		struct msghdr msg;
 		struct iovec vec;
 		char dummy[1];
@@ -368,6 +380,16 @@ public:
 		if (ret == -1) {
 			throw SystemException("Cannot send file descriptor with sendmsg()", errno);
 		}
+		
+		if (negotiate) {
+			vector<string> args;
+			
+			if (!read(args)) {
+				throw IOException("Unexpected end of stream encountered while post-negotiating a file descriptor");
+			} else if (args.size() != 1 || args[0] != "got IO") {
+				throw IOException("FD passing post-negotiation message expected.");
+			}
+		}
 	}
 	
 	/**
@@ -492,6 +514,7 @@ public:
 	 * Receive a file descriptor, which had been passed over the underlying
 	 * file descriptor.
 	 *
+	 * @param negotiate See Ruby's MessageChannel#send_io method's comments.
 	 * @return The passed file descriptor.
 	 * @throws SystemException If something went wrong during the
 	 *            receiving of a file descriptor. Perhaps the underlying
@@ -500,7 +523,12 @@ public:
 	 *            file descriptor.
 	 * @throws boost::thread_interrupted
 	 */
-	int readFileDescriptor() {
+	int readFileDescriptor(bool negotiate = true) {
+		// See message_channel.rb for more info about negotiation.
+		if (negotiate) {
+			write("pass IO", NULL);
+		}
+		
 		struct msghdr msg;
 		struct iovec vec;
 		char dummy[1];
@@ -538,16 +566,32 @@ public:
 		}
 		
 		control_header = CMSG_FIRSTHDR(&msg);
+		if (control_header == NULL) {
+			throw IOException("No valid file descriptor received.");
+		}
 		if (control_header->cmsg_len   != EXPECTED_CMSG_LEN
 		 || control_header->cmsg_level != SOL_SOCKET
 		 || control_header->cmsg_type  != SCM_RIGHTS) {
 			throw IOException("No valid file descriptor received.");
 		}
+		
 		#if defined(__APPLE__) || defined(__SOLARIS__) || defined(__arm__)
-			return control_data.fd;
+			int fd = control_data.fd;
 		#else
-			return *((int *) CMSG_DATA(control_header));
+			int fd = *((int *) CMSG_DATA(control_header));
 		#endif
+		
+		if (negotiate) {
+			try {
+				write("got IO", NULL);
+			} catch (...) {
+				this_thread::disable_syscall_interruption dsi;
+				syscalls::close(fd);
+				throw;
+			}
+		}
+		
+		return fd;
 	}
 	
 	/**

data/ext/common/StandardApplicationPool.h

@@ -34,6 +34,7 @@
 
 #include <oxt/system_calls.hpp>
 #include <oxt/backtrace.hpp>
+#include <oxt/thread.hpp>
 
 #include <string>
 #include <sstream>
@@ -242,7 +243,7 @@ private:
 		SpawnManager spawnManager;
 	#endif
 	SharedDataPtr data;
-	boost::thread *cleanerThread;
+	oxt::thread *cleanerThread;
 	bool detached;
 	bool done;
 	unsigned int maxIdleTime;
@@ -632,8 +633,9 @@ public:
 		waitingOnGlobalQueue = 0;
 		maxPerApp = DEFAULT_MAX_INSTANCES_PER_APP;
 		maxIdleTime = DEFAULT_MAX_IDLE_TIME;
-		cleanerThread = new boost::thread(
+		cleanerThread = new oxt::thread(
 			bind(&StandardApplicationPool::cleanerThreadMainLoop, this),
+			"ApplicationPool cleaner",
 			CLEANER_THREAD_STACK_SIZE
 		);
 	}

data/ext/common/Version.h

@@ -26,6 +26,6 @@
 #define _PASSENGER_VERSION_H_
 
 /* Don't forget to update lib/phusion_passenger/constants.rb too. */
-#define PASSENGER_VERSION "2.2.7"
+#define PASSENGER_VERSION "2.2.12"
 
 #endif /* _PASSENGER_VERSION_H */

data/ext/nginx/Configuration.c

@@ -194,7 +194,7 @@ 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",     "$request_uri");
+    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/HttpStatusExtractor.h

@@ -26,6 +26,7 @@
 #include <string>
 #include <cstdio>
 #include <cstdlib>
+#include <cstring>
 
 namespace Passenger {
 

data/ext/nginx/ScgiRequestParser.h

@@ -25,6 +25,7 @@
 
 #include <string>
 #include <map>
+#include <cstdlib>
 
 #include "StaticString.h"
 

data/ext/oxt/system_calls.cpp

@@ -42,8 +42,19 @@ interruption_signal_handler(int sig) {
 void
 oxt::setup_syscall_interruption_support() {
 	struct sigaction action;
+	sigset_t signal_set;
 	int ret;
 	
+	/* Very important! The signal mask is inherited across fork()
+	 * and exec() and we don't know what the parent process did to
+	 * us. At least on OS X, having a signal mask blocking important
+	 * signals can lead to stuff like waitpid() malfunction.
+	 */
+	sigemptyset(&signal_set);
+	do {
+		ret = sigprocmask(SIG_SETMASK, &signal_set, NULL);
+	} while (ret == -1 && errno == EINTR);
+	
 	action.sa_handler = interruption_signal_handler;
 	action.sa_flags   = 0;
 	sigemptyset(&action.sa_mask);

data/ext/oxt/system_calls.hpp

@@ -102,7 +102,8 @@ namespace oxt {
 	 * Setup system call interruption support.
 	 * This function may only be called once. It installs a signal handler
 	 * for INTERRUPTION_SIGNAL, so one should not install a different signal
-	 * handler for that signal after calling this function.
+	 * handler for that signal after calling this function. It also resets
+	 * the process signal mask.
 	 *
 	 * @warning
 	 * After oxt::setup_syscall_interruption_support() is called, sending a signal

data/ext/oxt/thread.hpp

@@ -34,6 +34,9 @@
 #ifdef OXT_BACKTRACE_IS_ENABLED
 	#include <sstream>
 #endif
+#include <string>
+#include <list>
+#include <unistd.h>
 #include <limits.h>  // for PTHREAD_STACK_MIN
 
 namespace oxt {
@@ -132,17 +135,45 @@ public:
 		set_thread_main_function(boost::bind(thread_main, func, data));
 		
 		unsigned long min_stack_size;
+		bool stack_min_size_defined;
+		bool round_stack_size;
+		
 		#ifdef PTHREAD_STACK_MIN
 			// PTHREAD_STACK_MIN may not be a constant macro so we need
 			// to evaluate it dynamically.
 			min_stack_size = PTHREAD_STACK_MIN;
+			stack_min_size_defined = true;
 		#else
 			// Assume minimum stack size is 128 KB.
 			min_stack_size = 128 * 1024;
+			stack_min_size_defined = false;
 		#endif
-		if (stack_size < min_stack_size) {
+		if (stack_size != 0 && stack_size < min_stack_size) {
 			stack_size = min_stack_size;
+			round_stack_size = !stack_min_size_defined;
+		} else {
+			round_stack_size = true;
+		}
+		
+		if (round_stack_size) {
+			// Round stack size up to page boundary.
+			long page_size;
+			#if defined(_SC_PAGESIZE)
+				page_size = sysconf(_SC_PAGESIZE);
+			#elif defined(_SC_PAGE_SIZE)
+				page_size = sysconf(_SC_PAGE_SIZE);
+			#elif defined(PAGESIZE)
+				page_size = sysconf(PAGESIZE);
+			#elif defined(PAGE_SIZE)
+				page_size = sysconf(PAGE_SIZE);
+			#else
+				page_size = getpagesize();
+			#endif
+			if (stack_size % page_size != 0) {
+				stack_size = stack_size - (stack_size % page_size) + page_size;
+			}
 		}
+		
 		start_thread(stack_size);
 	}
 	
@@ -231,6 +262,71 @@ public:
 			done = timed_join(boost::posix_time::millisec(10));
 		}
 	}
+	
+	/**
+	 * Keep interrupting the thread until it's done, then join it.
+	 * This method will keep trying for at most <em>timeout</em> milliseconds.
+	 *
+	 * @param timeout The maximum number of milliseconds that this method
+	 *                should keep trying.
+	 * @return True if the thread was successfully joined, false if the
+	 *         timeout has been reached.
+	 * @throws boost::thread_interrupted The calling thread has been
+	 *    interrupted before we could join this thread.
+	 */
+	bool interrupt_and_join(unsigned int timeout) {
+		bool joined = false, timed_out = false;
+		boost::posix_time::ptime deadline =
+			boost::posix_time::microsec_clock::local_time() +
+			boost::posix_time::millisec(timeout);
+		while (!joined && !timed_out) {
+			interrupt();
+			joined = timed_join(boost::posix_time::millisec(10));
+			timed_out = !joined && boost::posix_time::microsec_clock::local_time() > deadline;
+		}
+		return joined;
+	}
+	
+	/**
+	 * Interrupt and join multiple threads in a way that's more efficient than calling
+	 * interrupt_and_join() on each thread individually. It iterates over all threads,
+	 * interrupts each one without joining it, then waits until at least one thread
+	 * is joinable. This is repeated until all threads are joined.
+	 *
+	 * @param threads An array of threads to join.
+	 * @param size The number of elements in <em>threads</em>.
+	 * @throws boost::thread_interrupted The calling thread has been
+	 *    interrupted before all threads have been joined. Some threads
+	 *    may have been successfully joined while others haven't.
+	 */
+	static void interrupt_and_join_multiple(oxt::thread **threads, unsigned int size) {
+		std::list<oxt::thread *> remaining_threads;
+		std::list<oxt::thread *>::iterator it, current;
+		oxt::thread *thread;
+		unsigned int i;
+		
+		for (i = 0; i < size; i++) {
+			remaining_threads.push_back(threads[i]);
+		}
+		
+		while (!remaining_threads.empty()) {
+			for (it = remaining_threads.begin(); it != remaining_threads.end(); it++) {
+				thread = *it;
+				thread->interrupt();
+			}
+			for (it = remaining_threads.begin(); it != remaining_threads.end(); it++) {
+				thread = *it;
+				if (thread->timed_join(boost::posix_time::millisec(0))) {
+					current = it;
+					it--;
+					remaining_threads.erase(current);
+				}
+			}
+			if (!remaining_threads.empty()) {
+				syscalls::usleep(10000);
+			}
+		}
+	}
 };
 
 } // namespace oxt