passenger 1.0.5 → 2.0.1

data/lib/passenger/cgi_fixed.rb

@@ -1,66 +0,0 @@
-# NOTE: This code is based on cgi_fixed.rb from Zed Shaw's scgi_rails
-# package, version 0.4.3. The license of this single file is as follows:
-#
-#  Copyright (c) 2004 Zed A. Shaw
-#  
-#  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.
-#
-# We also made some small local modifications.
-
-require 'cgi'
-require 'stringio'
-
-module Passenger
-
-# Modifies CGI so that we can use it.  Main thing it does is expose
-# the stdinput and stdoutput so RequestHandler can connect them to
-# the right sources.  It also exposes the env_table so that RequestHandler
-# can hook the request parameters into the environment table.
-#
-# This is partially based on the FastCGI code, but much of the Ruby 1.6 
-# backwards compatibility is removed.
-class CGIFixed < ::CGI
-	public :env_table
-	
-	def initialize(params, input, output, *args)
-		@env_table = params
-		@args = *args
-		@input = input
-		@out = output
-		super(*args)
-	end
-	
-	def args
-		@args
-	end
-	
-	def env_table
-		@env_table
-	end
-	
-	def stdinput
-		@input
-	end
-	
-	def stdoutput
-		@out
-	end
-end
-end # module Passenger

data/lib/passenger/framework_spawner.rb

@@ -1,351 +0,0 @@
-#  Phusion Passenger - http://www.modrails.com/
-#  Copyright (C) 2008  Phusion
-#
-#  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.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  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 'rubygems'
-require 'socket'
-require 'pathname'
-require 'passenger/abstract_server'
-require 'passenger/application_spawner'
-require 'passenger/utils'
-module Passenger
-
-# Raised when FrameworkSpawner or SpawnManager was unable to load a version of
-# the Ruby on Rails framework. The +child_exception+ attribute is guaranteed
-# non-nil.
-class FrameworkInitError < InitializationError
-	attr_reader :vendor
-	attr_reader :version
-	
-	def initialize(message, child_exception, options)
-		super(message, child_exception)
-		if options[:vendor]
-			@vendor = options[:vendor]
-		else
-			@version = options[:version]
-		end
-	end
-end
-
-# This class is capable of spawning Ruby on Rails application instances
-# quickly. This is done by preloading the Ruby on Rails framework into memory,
-# before spawning the application instances.
-#
-# A single FrameworkSpawner instance can only hold a single Ruby on Rails
-# framework version. So be careful when using FrameworkSpawner: the applications
-# that you spawn through it must require the same RoR version. To handle multiple
-# RoR versions, use multiple FrameworkSpawner instances.
-#
-# FrameworkSpawner uses ApplicationSpawner internally.
-#
-# *Note*: FrameworkSpawner may only be started asynchronously with AbstractServer#start.
-# Starting it synchronously with AbstractServer#start_synchronously has not been tested.
-class FrameworkSpawner < AbstractServer
-	APP_SPAWNER_MAX_IDLE_TIME = 120
-	APP_SPAWNER_CLEAN_INTERVAL = APP_SPAWNER_MAX_IDLE_TIME + 5
-
-	include Utils
-	
-	# This exception means that the FrameworkSpawner server process exited unexpectedly.
-	class Error < AbstractServer::ServerError
-	end
-	
-	# An attribute, used internally. This should not be used outside Passenger.
-	attr_accessor :time
-
-	# Creates a new instance of FrameworkSpawner.
-	#
-	# Valid options:
-	# - <tt>:version</tt>: The Ruby on Rails version to use. It is not checked whether
-	#   this version is actually installed.
-	# - <tt>:vendor</tt>: The directory to the vendor Rails framework to use. This is
-	#   usually something like "/webapps/foo/vendor/rails".
-	#
-	# It is not allowed to specify both +version+ and +vendor+.
-	#
-	# Note that the specified Rails framework will be loaded during the entire life time
-	# of the FrameworkSpawner server. If you wish to reload the Rails framework's code,
-	# then restart the server by calling AbstractServer#stop and AbstractServer#start.
-	def initialize(options = {})
-		if !options.respond_to?(:'[]')
-			raise ArgumentError, "The 'options' argument not seem to be an options hash"
-		end
-		@version = options[:version]
-		@vendor = options[:vendor]
-		if !@version && !@vendor
-			raise ArgumentError, "Either the 'version' or the 'vendor' option must specified"
-		elsif @version && @vendor
-			raise ArgumentError, "It is not allowed to specify both the 'version' and the 'vendor' options"
-		end
-		
-		super()
-		define_message_handler(:spawn_application, :handle_spawn_application)
-		define_message_handler(:reload, :handle_reload)
-	end
-	
-	# Overrided from AbstractServer#start.
-	#
-	# May raise these additional exceptions:
-	# - FrameworkInitError: The specified Ruby on Rails framework could not be loaded.
-	# - FrameworkSpawner::Error: The FrameworkSpawner server exited unexpectedly.
-	def start
-		super
-		begin
-			status = server.read[0]
-			if status == 'exception'
-				child_exception = unmarshal_exception(server.read_scalar)
-				stop
-				if @version
-					message = "Could not load Ruby on Rails framework version #{@version}: " <<
-						"#{child_exception.class} (#{child_exception.message})"
-				else
-					message = "Could not load Ruby on Rails framework at '#{@vendor}': " <<
-						"#{child_exception.class} (#{child_exception.message})"
-				end
-				options = { :vendor => @vendor, :version => @version }
-				raise FrameworkInitError.new(message, child_exception, options)
-			end
-		rescue IOError, SystemCallError, SocketError
-			stop
-			raise Error, "The framework spawner server exited unexpectedly"
-		end
-	end
-	
-	# Spawn a RoR application using the Ruby on Rails framework
-	# version associated with this FrameworkSpawner.
-	# When successful, an Application object will be returned, which represents
-	# the spawned RoR application.
-	#
-	# See ApplicationSpawner.new for an explanation of the +lower_privilege+
-	# and +lowest_user+ parameters.
-	#
-	# FrameworkSpawner will internally cache the code of applications, in order to
-	# speed up future spawning attempts. This implies that, if you've changed
-	# the application's code, you must do one of these things:
-	# - Restart this FrameworkSpawner by calling AbstractServer#stop, then AbstractServer#start.
-	# - Reload the application by calling reload with the correct app_root argument.
-	#
-	# Raises:
-	# - AbstractServer::ServerNotStarted: The FrameworkSpawner server hasn't already been started.
-	# - ArgumentError: +app_root+ doesn't appear to be a valid Ruby on Rails application root.
-	# - AppInitError: The application raised an exception or called exit() during startup.
-	# - ApplicationSpawner::Error: The ApplicationSpawner server exited unexpectedly.
-	# - FrameworkSpawner::Error: The FrameworkSpawner server exited unexpectedly.
-	def spawn_application(app_root, lower_privilege = true, lowest_user = "nobody")
-		app_root = normalize_path(app_root)
-		assert_valid_app_root(app_root)
-		exception_to_propagate = nil
-		begin
-			server.write("spawn_application", app_root, lower_privilege, lowest_user)
-			result = server.read
-			if result.nil?
-				raise IOError, "Connection closed"
-			end
-			if result[0] == 'exception'
-				raise unmarshal_exception(server.read_scalar)
-			else
-				pid, listen_socket_name, using_abstract_namespace = server.read
-				if pid.nil?
-					raise IOError, "Connection closed"
-				end
-				owner_pipe = server.recv_io
-				return Application.new(app_root, pid, listen_socket_name,
-					using_abstract_namespace == "true", owner_pipe)
-			end
-		rescue SystemCallError, IOError, SocketError => e
-			raise Error, "The framework spawner server exited unexpectedly"
-		end
-	end
-	
-	# Remove the cached application instances at the given application root.
-	# If nil is specified as application root, then all cached application
-	# instances will be removed, no matter the application root.
-	#
-	# <b>Long description:</b>
-	# Application code might be cached in memory by a FrameworkSpawner. But
-	# once it a while, it will be necessary to reload the code for an
-	# application, such as after deploying a new version of the application.
-	# This method makes sure that any cached application code is removed, so
-	# that the next time an application instance is spawned, the application
-	# code will be freshly loaded into memory.
-	#
-	# Raises:
-	# - ArgumentError: +app_root+ doesn't appear to be a valid Ruby on Rails
-	#   application root.
-	# - FrameworkSpawner::Error: The FrameworkSpawner server exited unexpectedly.
-	def reload(app_root = nil)
-		if app_root.nil?
-			server.write("reload")
-		else
-			server.write("reload", normalize_path(app_root))
-		end
-	rescue SystemCallError, IOError, SocketError
-		raise Error, "The framework spawner server exited unexpectedly"
-	end
-
-protected
-	# Overrided method.
-	def before_fork # :nodoc:
-		if GC.copy_on_write_friendly?
-			# Garbage collect now so that the child process doesn't have to
-			# do that (to prevent making pages dirty).
-			GC.start
-		end
-	end
-
-	# Overrided method.
-	def initialize_server # :nodoc:
-		$0 = "Passenger FrameworkSpawner: #{@version || @vendor}"
-		@spawners = {}
-		@spawners_lock = Mutex.new
-		@spawners_cond = ConditionVariable.new
-		@spawners_cleaner = Thread.new do
-			begin
-				spawners_cleaner_main_loop
-			rescue Exception => e
-				print_exception(self.class.to_s, e)
-			end
-		end
-		begin
-			preload_rails
-		rescue StandardError, ScriptError, NoMemoryError => e
-			client.write('exception')
-			client.write_scalar(marshal_exception(e))
-			return
-		end
-		client.write('success')
-	end
-	
-	# Overrided method.
-	def finalize_server # :nodoc:
-		@spawners_lock.synchronize do
-			@spawners_cond.signal
-		end
-		@spawners_cleaner.join
-		@spawners.each_value do |spawner|
-			spawner.stop
-		end
-	end
-
-private
-	def preload_rails
-		if @version
-			gem 'rails', "=#{@version}"
-			require 'initializer'
-		else
-			$LOAD_PATH.unshift("#{@vendor}/railties/builtin/rails_info")
-			Dir["#{@vendor}/*"].each do |entry|
-				next unless File.directory?(entry)
-				$LOAD_PATH.unshift("#{entry}/lib")
-			end
-			require "#{@vendor}/railties/lib/initializer"
-		end
-		require 'active_support'
-		require 'active_record'
-		require 'action_controller'
-		require 'action_view'
-		require 'action_pack'
-		require 'action_mailer'
-		require 'dispatcher'
-		require 'ruby_version_check'
-		if ::Rails::VERSION::MAJOR >= 2
-			require 'active_resource'
-		else
-			require 'action_web_service'
-		end
-		require 'active_support/whiny_nil'
-	end
-
-	def handle_spawn_application(app_root, lower_privilege, lowest_user)
-		lower_privilege = lower_privilege == "true"
-		@spawners_lock.synchronize do
-			spawner = @spawners[app_root]
-			if spawner.nil?
-				begin
-					spawner = ApplicationSpawner.new(app_root, lower_privilege, lowest_user)
-					spawner.start
-				rescue ArgumentError, AppInitError, ApplicationSpawner::Error => e
-					client.write('exception')
-					client.write_scalar(marshal_exception(e))
-					if e.child_exception.is_a?(LoadError)
-						# A source file failed to load, maybe because of a
-						# missing gem. If that's the case then the sysadmin
-						# will install probably the gem. So we clear RubyGems's
-						# cache so that it can detect new gems.
-						Gem.clear_paths
-					end
-					return
-				end
-				@spawners[app_root] = spawner
-			end
-			spawner.time = Time.now
-			begin
-				app = spawner.spawn_application
-			rescue ApplicationSpawner::Error => e
-				spawner.stop
-				@spawners.delete(app_root)
-				client.write('exception')
-				client.write_scalar(marshal_exception(e))
-				return
-			end
-			client.write('success')
-			client.write(app.pid, app.listen_socket_name, app.using_abstract_namespace?)
-			client.send_io(app.owner_pipe)
-			app.close
-		end
-	end
-	
-	def handle_reload(app_root = nil)
-		@spawners_lock.synchronize do
-			if app_root.nil?
-				@spawners.each_value do |spawner|
-					spawner.stop
-				end
-				@spawners.clear
-			else
-				spawner = @spawners[app_root]
-				if spawner
-					spawner.stop
-					@spawners.delete(app_root)
-				end
-			end
-		end
-	end
-	
-	# The main loop for the spawners cleaner thread.
-	# This thread checks the spawners list every APP_SPAWNER_CLEAN_INTERVAL seconds,
-	# and stops application spawners that have been idle for more than
-	# APP_SPAWNER_MAX_IDLE_TIME seconds.
-	def spawners_cleaner_main_loop
-		@spawners_lock.synchronize do
-			while true
-				if @spawners_cond.timed_wait(@spawners_lock, APP_SPAWNER_CLEAN_INTERVAL)
-					break
-				else
-					current_time = Time.now
-					@spawners.keys.each do |key|
-						spawner = @spawners[key]
-						if current_time - spawner.time > APP_SPAWNER_MAX_IDLE_TIME
-							spawner.stop
-							@spawners.delete(key)
-						end
-					end
-				end
-			end
-		end
-	end
-end
-
-end # module Passenger

data/lib/passenger/request_handler.rb

@@ -1,333 +0,0 @@
-#  Phusion Passenger - http://www.modrails.com/
-#  Copyright (C) 2008  Phusion
-#
-#  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.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  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 'socket'
-require 'base64'
-require 'passenger/message_channel'
-require 'passenger/cgi_fixed'
-require 'passenger/utils'
-module Passenger
-
-# The request handler's job is to process incoming HTTP requests using the
-# currently loaded Ruby on Rails application. HTTP requests are forwarded
-# to the request handler by the web server. HTTP responses generated by the
-# RoR application are forwarded to the web server, which, in turn, sends the
-# response back to the HTTP client.
-#
-#
-# == Design decisions
-#
-# Some design decisions are made because we want to decrease system
-# administrator maintenance overhead. These decisions are documented
-# in this section.
-#
-# === Abstract namespace Unix sockets
-#
-# RequestHandler listens on a Unix socket for incoming requests. If possible,
-# RequestHandler will try to create a Unix socket on the _abstract namespace_,
-# instead of on the filesystem. If the RoR application crashes (segfault),
-# or if it gets killed by SIGKILL, or if the system loses power, then there
-# will be no stale socket files left on the filesystem.
-# Unfortunately, abstract namespace Unix sockets are only supported by Linux.
-# On systems that do not support abstract namespace Unix sockets,
-# RequestHandler will automatically fallback to using regular Unix socket files.
-#
-# It is possible to force RequestHandler to use regular Unix socket files by
-# setting the environment variable PASSENGER_NO_ABSTRACT_NAMESPACE_SOCKETS
-# to 1.
-#
-# === Owner pipes
-#
-# Because only the web server communicates directly with a request handler,
-# we want the request handler to exit if the web server has also exited.
-# This is implemented by using a so-called _owner pipe_. The writable part
-# of the pipe will be owned by the web server. RequestHandler will
-# continuously check whether the other side of the pipe has been closed. If
-# so, then it knows that the web server has exited, and so the request handler
-# will exit as well. This works even if the web server gets killed by SIGKILL.
-#
-#
-# == Request format
-#
-# Incoming "HTTP requests" are not true HTTP requests, i.e. their binary
-# representation do not conform to RFC 2616. Instead, the request format
-# is based on CGI, and is similar to that of SCGI.
-#
-# The format consists of 3 parts:
-# - A 32-bit big-endian integer, containing the size of the transformed
-#   headers.
-# - The transformed HTTP headers.
-# - The verbatim (untransformed) HTTP request body.
-#
-# HTTP headers are transformed to a format that satisfies the following
-# grammar:
-#
-#  headers ::= header*
-#  header ::= name NUL value NUL
-#  name ::= notnull+
-#  value ::= notnull+
-#  notnull ::= "\x01" | "\x02" | "\x02" | ... | "\xFF"
-#  NUL = "\x00"
-#
-# The web server transforms the HTTP request to the aforementioned format,
-# and sends it to the request handler.
-class RequestHandler
-	# Signal which will cause the Rails application to exit immediately.
-	HARD_TERMINATION_SIGNAL = "SIGTERM"
-	# Signal which will cause the Rails application to exit as soon as it's done processing a request.
-	SOFT_TERMINATION_SIGNAL = "SIGUSR1"
-	BACKLOG_SIZE = 50
-	MAX_HEADER_SIZE = 128 * 1024
-	
-	# String constants which exist to relieve Ruby's garbage collector.
-	IGNORE = 'IGNORE' # :nodoc:
-	DEFAULT = 'DEFAULT' # :nodoc:
-	CONTENT_LENGTH = 'CONTENT_LENGTH' # :nodoc:
-	HTTP_CONTENT_LENGTH = 'HTTP_CONTENT_LENGTH' # :nodoc:
-	X_POWERED_BY = 'X-Powered-By'
-	
-	NINJA_PATCHING_LOCK = Mutex.new
-	@@ninja_patched_action_controller = false
-	
-	File.read("#{File.dirname(__FILE__)}/../../Rakefile") =~ /^PACKAGE_VERSION = "(.*)"$/
-	PASSENGER_VERSION = $1
-	PASSENGER_HEADER = "Phusion Passenger (mod_rails) #{PASSENGER_VERSION}"
-	if File.exist?("#{File.dirname(__FILE__)}/../../enterprisey.txt")
-		PASSENGER_HEADER << ", Enterprise Edition"
-	end
-	
-	# The name of the socket on which the request handler accepts
-	# new connections. This is either a Unix socket filename, or
-	# the name for an abstract namespace Unix socket.
-	#
-	# If +socket_name+ refers to an abstract namespace Unix socket,
-	# then the name does _not_ contain a leading null byte.
-	#
-	# See also using_abstract_namespace?
-	attr_reader :socket_name
-
-	# Create a new RequestHandler with the given owner pipe.
-	# +owner_pipe+ must be the readable part of a pipe IO object.
-	def initialize(owner_pipe)
-		if ENV['PASSENGER_NO_ABSTRACT_NAMESPACE_SOCKETS'].blank?
-			@using_abstract_namespace = create_unix_socket_on_abstract_namespace
-		else
-			@using_abstract_namespace = false
-		end
-		if !@using_abstract_namespace
-			create_unix_socket_on_filesystem
-		end
-		@owner_pipe = owner_pipe
-		@previous_signal_handlers = {}
-		
-		NINJA_PATCHING_LOCK.synchronize do
-			if !@@ninja_patched_action_controller && defined?(::ActionController::Base) \
-			&& ::ActionController::Base.private_method_defined?(:perform_action)
-				@@ninja_patched_action_controller = true
-				::ActionController::Base.class_eval do
-					alias passenger_orig_perform_action perform_action
-					
-					def perform_action(*whatever)
-						headers[X_POWERED_BY] = PASSENGER_HEADER
-						passenger_orig_perform_action(*whatever)
-					end
-				end
-			end
-		end
-	end
-	
-	# Clean up temporary stuff created by the request handler.
-	# This method should be called after the main loop has exited.
-	def cleanup
-		@socket.close rescue nil
-		@owner_pipe.close rescue nil
-		if !using_abstract_namespace?
-			File.unlink(@socket_name) rescue nil
-		end
-	end
-	
-	# Returns whether socket_name refers to an abstract namespace Unix socket.
-	def using_abstract_namespace?
-		return @using_abstract_namespace
-	end
-	
-	# Enter the request handler's main loop.
-	def main_loop
-		reset_signal_handlers
-		begin
-			done = false
-			while !done
-				client = accept_connection
-				if client.nil?
-					break
-				end
-				trap SOFT_TERMINATION_SIGNAL do
-					done = true
-				end
-				process_request(client)
-				trap SOFT_TERMINATION_SIGNAL, DEFAULT
-			end
-		rescue EOFError
-			# Exit main loop.
-		rescue Interrupt
-			# Exit main loop.
-		rescue SignalException => signal
-			if signal.message != HARD_TERMINATION_SIGNAL &&
-			   signal.message != SOFT_TERMINATION_SIGNAL
-				raise
-			end
-		ensure
-			revert_signal_handlers
-		end
-	end
-
-private
-	include Utils
-
-	def create_unix_socket_on_abstract_namespace
-		while true
-			begin
-				# I have no idea why, but using base64-encoded IDs
-				# don't pass the unit tests. I couldn't find the cause
-				# of the problem. The system supports base64-encoded
-				# names for abstract namespace unix sockets just fine.
-				@socket_name = generate_random_id(:hex)
-				@socket_name = @socket_name.slice(0, NativeSupport::UNIX_PATH_MAX - 2)
-				fd = NativeSupport.create_unix_socket("\x00#{socket_name}", BACKLOG_SIZE)
-				@socket = IO.new(fd)
-				@socket.instance_eval do
-					def accept
-						fd = NativeSupport.accept(fileno)
-						return IO.new(fd)
-					end
-				end
-				return true
-			rescue Errno::EADDRINUSE
-				# Do nothing, try again with another name.
-			rescue Errno::ENOENT
-				# Abstract namespace sockets not supported on this system.
-				return false
-			end
-		end
-	end
-	
-	def create_unix_socket_on_filesystem
-		done = false
-		while !done
-			begin
-				@socket_name = "/tmp/passenger.#{generate_random_id(:base64)}"
-				@socket_name = @socket_name.slice(0, NativeSupport::UNIX_PATH_MAX - 1)
-				@socket = UNIXServer.new(@socket_name)
-				File.chmod(0600, @socket_name)
-				done = true
-			rescue Errno::EADDRINUSE
-				# Do nothing, try again with another name.
-			end
-		end
-	end
-
-	def reset_signal_handlers
-		Signal.list.each_key do |signal|
-			begin
-				prev_handler = trap(signal, DEFAULT)
-				if prev_handler != DEFAULT
-					@previous_signal_handlers[signal] = prev_handler
-				end
-			rescue ArgumentError
-				# Signal cannot be trapped; ignore it.
-			end
-		end
-		prev_handler = trap('HUP', IGNORE)
-	end
-	
-	def revert_signal_handlers
-		@previous_signal_handlers.each_pair do |signal, handler|
-			trap(signal, handler)
-		end
-	end
-	
-	def accept_connection
-		ios = select([@socket, @owner_pipe])[0]
-		if ios.include?(@socket)
-			return @socket.accept
-		else
-			# The other end of the pipe has been closed.
-			# So we know all owning processes have quit.
-			return nil
-		end
-	end
-	
-	class ResponseSender # :nodoc:
-		def initialize(io)
-			@io = io
-		end
-		
-		def write(block)
-			@io.write(block)
-		end
-		
-		def <<(block)
-			@io.write(block)
-		end
-	end
-	
-	def process_request(socket)
-		channel = MessageChannel.new(socket)
-		headers_data = channel.read_scalar(MAX_HEADER_SIZE)
-		if headers_data.nil?
-			socket.close
-			return
-		end
-		
-		headers = Hash[*headers_data.split("\0")]
-		headers_data = nil
-		headers[CONTENT_LENGTH] = headers[HTTP_CONTENT_LENGTH]
-		
-		# TODO:
-		# Uploaded files are apparently put in /tmp, but not as temp files.
-		# That should be fixed.
-		
-		cgi = CGIFixed.new(headers, socket, ResponseSender.new(socket))
-		::Dispatcher.dispatch(cgi, ::ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS,
-			cgi.stdoutput)
-		socket.close
-	rescue IOError, SocketError, SystemCallError => e
-		print_exception("Passenger RequestHandler", e)
-	rescue SecurityError => e
-		STDERR.puts("*** Passenger RequestHandler: HTTP header size exceeded maximum.")
-		STDERR.flush
-		print_exception("Passenger RequestHandler", e)
-		socket.close rescue nil
-	end
-	
-	# Generate a long, cryptographically secure random ID string, which
-	# is also a valid filename.
-	def generate_random_id(method)
-		case method
-		when :base64
-			data = Base64.encode64(File.read("/dev/urandom", 64))
-			data.gsub!("\n", '')
-			data.gsub!("+", '')
-			data.gsub!("/", '')
-			data.gsub!(/==$/, '')
-		when :hex
-			data = File.read("/dev/urandom", 64).unpack('H*')[0]
-		end
-		return data
-	end
-end
-
-end # module Passenger