passenger-jmazzi 2.2.9

data/lib/phusion_passenger/events.rb

@@ -0,0 +1,50 @@
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2008, 2009 Phusion
+#
+#  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+#
+#  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.
+
+module PhusionPassenger
+	@@event_starting_worker_process = []
+	@@event_stopping_worker_process = []
+	
+	def self.on_event(name, &block)
+		callback_list_for_event(name) << block
+	end
+	
+	def self.call_event(name, *args)
+		callback_list_for_event(name).each do |callback|
+			callback.call(*args)
+		end
+	end
+
+private
+	def self.callback_list_for_event(name)
+		return case name
+		when :starting_worker_process
+			@@event_starting_worker_process
+		when :stopping_worker_process
+			@@event_stopping_worker_process
+		else
+			raise ArgumentError, "Unknown event name '#{name}'"
+		end
+	end
+
+end # module PhusionPassenger

data/lib/phusion_passenger/exceptions.rb

@@ -0,0 +1,103 @@
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2008, 2009 Phusion
+#
+#  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+#
+#  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.
+
+module PhusionPassenger
+
+# Indicates that there is no Ruby on Rails version installed that satisfies
+# a given Ruby on Rails Gem version specification.
+class VersionNotFound < StandardError
+	attr_reader :gem_version_spec
+	
+	# - +message+: The exception message.
+	# - +gem_version_spec+: The Ruby on Rails Gem version specification that caused this error.
+	def initialize(message, gem_version_spec)
+		super(message)
+		@gem_version_spec = gem_version_spec
+	end
+end
+
+# An abstract base class for AppInitError and FrameworkInitError. This represents
+# the failure when initializing something.
+class InitializationError < StandardError
+	# The exception that caused initialization to fail. This may be nil.
+	attr_accessor :child_exception
+
+	# Create a new InitializationError. +message+ is the error message,
+	# and +child_exception+ is the exception that caused initialization
+	# to fail.
+	def initialize(message, child_exception = nil)
+		super(message)
+		@child_exception = child_exception
+	end
+end
+
+# Raised when Rack::ApplicationSpawner, Railz::ApplicationSpawner,
+# Railz::FrameworkSpawner or SpawnManager was unable to spawn an application,
+# because the application either threw an exception or called exit.
+#
+# If the application called exit, then +child_exception+ is an instance of
+# +SystemExit+.
+class AppInitError < InitializationError
+	# The application type, e.g. "rails" or "rack".
+	attr_accessor :app_type
+	# Any messages printed to stderr before the failure. May be nil.
+	attr_accessor :stderr
+	
+	def initialize(message, child_exception = nil, app_type = "rails", stderr = nil)
+		super(message, child_exception)
+		@app_type = app_type
+		@stderr = stderr
+	end
+end
+
+# Raised when Railz::FrameworkSpawner or Railz::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
+
+class UnknownError < StandardError
+	attr_accessor :real_class_name
+	
+	def initialize(message, class_name, backtrace)
+		super("#{message} (#{class_name})")
+		set_backtrace(backtrace)
+		@real_class_name = class_name
+	end
+end
+
+class InvalidPath < StandardError
+end
+
+end # module PhusionPassenger

data/lib/phusion_passenger/html_template.rb

@@ -0,0 +1,109 @@
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2008, 2009 Phusion
+#
+#  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+#
+#  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.
+
+require 'erb'
+
+module PhusionPassenger
+
+# A convenience utility class for rendering our error pages.
+class HTMLTemplate
+	PASSENGER_FILE_PREFIX = File.dirname(__FILE__)
+	TEMPLATE_DIR = "#{PASSENGER_FILE_PREFIX}/templates"
+
+	def initialize(template_name, options = {})
+		@buffer = ''
+		@template = ERB.new(File.read("#{TEMPLATE_DIR}/#{template_name}.html.erb"),
+			nil, nil, '@buffer')
+		options.each_pair do |name, value|
+			self[name] = value
+		end
+	end
+	
+	def []=(name, value)
+		instance_variable_set("@#{name}".to_sym, value)
+		return self
+	end
+	
+	def result
+		return @template.result(binding)
+	end
+
+private
+	include ERB::Util
+	
+	def get_binding
+		return binding
+	end
+	
+	def layout(template_name, options = {})
+		options.each_pair do |name, value|
+			self[name] = value
+		end
+		layout_template = ERB.new(File.read("#{TEMPLATE_DIR}/#{template_name}.html.erb"))
+		b = get_binding do
+			old_size = @buffer.size
+			yield
+			@buffer.slice!(old_size .. @buffer.size)
+		end
+		@buffer << layout_template.result(b)
+	end
+	
+	def include(filename)
+		return File.read("#{TEMPLATE_DIR}/#{filename}")
+	end
+	
+	def backtrace_html_for(error)
+		html = %Q{
+			<table class="backtrace">
+			<tr class="headers">
+				<th>#</th>
+				<th>File</th>
+				<th>Line</th>
+				<th>Location</th>
+			</tr>
+		}
+		in_passenger = false
+		error.backtrace.each_with_index do |item, i|
+			filename, line, location = item.split(':', 3)
+			in_passenger ||= starts_with(filename, PASSENGER_FILE_PREFIX)
+			class_names = in_passenger ? "passenger" : "framework"
+			class_names << ((i & 1 == 0) ? " uneven" : " even")
+			html << %Q{
+				<tr class="backtrace_line #{class_names}">
+					<td class="index">#{i}</td>
+					<td class="filename">#{filename}</td>
+					<td class="line">#{line}</td>
+					<td class="location">#{location}</td>
+				</tr>
+			}
+		end
+		html << "</table>\n"
+		return html
+	end
+	
+	def starts_with(str, substr)
+		return str[0 .. substr.size - 1] == substr
+	end
+end
+
+end # module PhusionPassenger

data/lib/phusion_passenger/message_channel.rb

@@ -0,0 +1,229 @@
+# encoding: binary
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2008, 2009 Phusion
+#
+#  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+#
+#  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.
+
+module PhusionPassenger
+
+# This class provides convenience methods for:
+# - sending and receiving raw data over an IO channel.
+# - sending and receiving messages over an IO channel.
+# - file descriptor (IO object) passing over a Unix socket.
+# All of these methods use exceptions for error reporting.
+#
+# There are two kinds of messages:
+# [ Array messages ]
+#   These are just a list of strings, and the message
+#   itself has a specific length. The contained strings may not
+#   contain NUL characters (<tt>'\\0'</tt>). Note that an array message
+#   must have at least one element.
+# [ Scalar messages ]
+#   These are byte strings which may contain arbitrary
+#   binary data. Scalar messages also have a specific length.
+#
+# The protocol is designed to be low overhead, easy to implement and
+# easy to parse.
+#
+# MessageChannel is to be wrapped around an IO object. For example:
+#
+#  a, b = IO.pipe
+#  channel1 = MessageChannel.new(a)
+#  channel2 = MessageChannel.new(b)
+#  
+#  # Send an array message.
+#  channel2.write("hello", "world !!")
+#  channel1.read    # => ["hello", "world !!"]
+#  
+#  # Send a scalar message.
+#  channel2.write_scalar("some long string which can contain arbitrary binary data")
+#  channel1.read_scalar
+#
+# The life time of a MessageChannel is independent from that of the
+# wrapped IO object. If a MessageChannel object is destroyed,
+# the underlying IO object is not automatically closed. Call close()
+# if you want to close the underlying IO object.
+#
+# Note:
+# Be careful with mixing the sending/receiving of array messages,
+# scalar messages and IO objects. If you send a collection of any
+# of these in a specific order, then the receiving side must receive them
+# in the exact some order. So suppose you first send a message, then an
+# IO object, then a scalar, then the receiving side must first
+# receive a message, then an IO object, then a scalar. If the
+# receiving side does things in the wrong order then bad things will
+# happen.
+class MessageChannel
+	HEADER_SIZE = 2                  # :nodoc:
+	DELIMITER = "\0"                 # :nodoc:
+	DELIMITER_NAME = "null byte"     # :nodoc:
+	
+	# The wrapped IO object.
+	attr_reader :io
+
+	# Create a new MessageChannel by wrapping the given IO object.
+	def initialize(io)
+		@io = io
+	end
+	
+	# Read an array message from the underlying file descriptor.
+	# Returns the array message as an array, or nil when end-of-stream has
+	# been reached.
+	#
+	# Might raise SystemCallError, IOError or SocketError when something
+	# goes wrong.
+	def read
+		buffer = ''
+		while buffer.size < HEADER_SIZE
+			buffer << @io.readpartial(HEADER_SIZE - buffer.size)
+		end
+		
+		chunk_size = buffer.unpack('n')[0]
+		buffer = ''
+		while buffer.size < chunk_size
+			buffer << @io.readpartial(chunk_size - buffer.size)
+		end
+		
+		message = []
+		offset = 0
+		delimiter_pos = buffer.index(DELIMITER, offset)
+		while !delimiter_pos.nil?
+			if delimiter_pos == 0
+				message << ""
+			else
+				message << buffer[offset .. delimiter_pos - 1]
+			end
+			offset = delimiter_pos + 1
+			delimiter_pos = buffer.index(DELIMITER, offset)
+		end
+		return message
+	rescue Errno::ECONNRESET
+		return nil
+	rescue EOFError
+		return nil
+	end
+
+	# Read a scalar message from the underlying IO object. Returns the
+	# read message, or nil on end-of-stream.
+	#
+	# Might raise SystemCallError, IOError or SocketError when something
+	# goes wrong.
+	#
+	# The +max_size+ argument allows one to specify the maximum allowed
+	# size for the scalar message. If the received scalar message's size
+	# is larger than +max_size+, then a SecurityError will be raised.
+	def read_scalar(max_size = nil)
+		buffer = ''
+		temp = ''
+		while buffer.size < 4
+			buffer << @io.readpartial(4 - buffer.size, temp)
+		end
+		size = buffer.unpack('N')[0]
+		if size == 0
+			return ''
+		else
+			if !max_size.nil? && size > max_size
+				raise SecurityError, "Scalar message size (#{size}) " <<
+					"exceeds maximum allowed size (#{max_size})."
+			end
+			buffer = ''
+			while buffer.size < size
+				temp = '' # JRuby doesn't clear the buffer. TODO: remove this when JRuby has been fixed.
+				buffer << @io.readpartial(size - buffer.size, temp)
+			end
+			return buffer
+		end
+	rescue Errno::ECONNRESET
+		return nil
+	rescue EOFError
+		return nil
+	end
+	
+	# Send an array message, which consists of the given elements, over the underlying
+	# file descriptor. _name_ is the first element in the message, and _args_ are the
+	# other elements. These arguments will internally be converted to strings by calling
+	# to_s().
+	#
+	# Might raise SystemCallError, IOError or SocketError when something
+	# goes wrong.
+	def write(name, *args)
+		check_argument(name)
+		args.each do |arg|
+			check_argument(arg)
+		end
+		
+		message = "#{name}#{DELIMITER}"
+		args.each do |arg|
+			message << arg.to_s << DELIMITER
+		end
+		@io.write([message.size].pack('n') << message)
+		@io.flush
+	end
+	
+	# Send a scalar message over the underlying IO object.
+	#
+	# Might raise SystemCallError, IOError or SocketError when something
+	# goes wrong.
+	def write_scalar(data)
+		@io.write([data.size].pack('N') << data)
+		@io.flush
+	end
+	
+	# Receive an IO object (a file descriptor) from the channel. The other
+	# side must have sent an IO object by calling send_io(). Note that
+	# this only works on Unix sockets.
+	#
+	# Might raise SystemCallError, IOError or SocketError when something
+	# goes wrong.
+	def recv_io
+		return @io.recv_io
+	end
+	
+	# Send an IO object (a file descriptor) over the channel. The other
+	# side must receive the IO object by calling recv_io(). Note that
+	# this only works on Unix sockets.
+	#
+	# Might raise SystemCallError, IOError or SocketError when something
+	# goes wrong.
+	def send_io(io)
+		@io.send_io(io)
+	end
+	
+	# Return the file descriptor of the underlying IO object.
+	def fileno
+		return @io.fileno
+	end
+	
+	# Close the underlying IO stream. Might raise SystemCallError or
+	# IOError when something goes wrong.
+	def close
+		@io.close
+	end
+
+private
+	def check_argument(arg)
+		if arg.to_s.index(DELIMITER)
+			raise ArgumentError, "Message name and arguments may not contain #{DELIMITER_NAME}."
+		end
+	end
+end
+
+end # module PhusionPassenger