passenger 3.0.21 → 3.9.1.beta

data/lib/phusion_passenger/utils/ansi_colors.rb

@@ -0,0 +1,59 @@
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2010 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
+module Utils
+
+module AnsiColors
+	RESET    = "\e[0m".freeze
+	BOLD     = "\e[1m".freeze
+	RED      = "\e[31m".freeze
+	GREEN    = "\e[32m".freeze
+	YELLOW   = "\e[33m".freeze
+	WHITE    = "\e[37m".freeze
+	BLACK_BG = "\e[40m".freeze
+	BLUE_BG  = "\e[44m".freeze
+	DEFAULT_TERMINAL_COLOR = "#{RESET}#{WHITE}#{BLACK_BG}".freeze
+	
+	extend self  # Make methods available as class methods.
+	
+	def self.included(klass)
+		# When included into another class, make sure that Utils
+		# methods are made private.
+		public_instance_methods(false).each do |method_name|
+			klass.send(:private, method_name)
+		end
+	end
+	
+	def ansi_colorize(text)
+		text = text.gsub(%r{<b>(.*?)</b>}m, "#{BOLD}\\1#{DEFAULT_TERMINAL_COLOR}")
+		text.gsub!(%r{<red>(.*?)</red>}m, "#{BOLD}#{RED}\\1#{DEFAULT_TERMINAL_COLOR}")
+		text.gsub!(%r{<green>(.*?)</green>}m, "#{BOLD}#{GREEN}\\1#{DEFAULT_TERMINAL_COLOR}")
+		text.gsub!(%r{<yellow>(.*?)</yellow>}m, "#{BOLD}#{YELLOW}\\1#{DEFAULT_TERMINAL_COLOR}")
+		text.gsub!(%r{<banner>(.*?)</banner>}m, "#{BOLD}#{BLUE_BG}#{YELLOW}\\1#{DEFAULT_TERMINAL_COLOR}")
+		return text
+	end
+end
+
+end # module Utils
+end # module PhusionPassenger

data/lib/phusion_passenger/utils/file_system_watcher.rb

@@ -39,7 +39,7 @@ module Utils
 #   This will cause +nil+ to be returned.
 # - The thread is interrupted. This will cause +nil+ to be returned.
 # 
-# The constructor will attempt to stat and possible also open all specified
+# The constructor will attempt to stat and possibly also open all specified
 # files/directories. If one of them cannot be statted or opened, then
 # +false+ will be returned by #wait_for_change.
 #

data/lib/phusion_passenger/utils/robust_interruption.rb

@@ -0,0 +1,134 @@
+require 'thread'
+
+module PhusionPassenger
+module Utils
+
+module RobustInterruption
+	class Interrupted < StandardError
+	end
+
+	class Data
+		attr_reader :interruption_flags
+		attr_accessor :interrupted
+		alias interrupted? interrupted
+
+		def initialize
+			@mutex = Mutex.new
+			@interruption_flags = [true]
+			@interrupted = false
+		end
+
+		def lock
+			@mutex.lock
+		end
+
+		def try_lock
+			return @mutex.try_lock
+		end
+
+		def unlock
+			@mutex.unlock
+		end
+
+		def interruptable?
+			return @interruption_flags.last
+		end
+
+		def push_interruption_flag(value)
+			@interruption_flags.push(value)
+		end
+
+		def pop_interruption_flag
+			raise "BUG - cannot pop interruption flag in this state" if @interruption_flags.size <= 1
+			@interruption_flags.pop
+		end
+	end
+
+	def self.install(thread = Thread.current)
+		thread[:robust_interruption] = Data.new
+	end
+
+	def install_robust_interruption
+		RobustInterruption.install
+	end
+
+	def interrupted?(thread = Thread.current)
+		data = thread[:robust_interruption]
+		return data && data.interrupted?
+	end
+	module_function :interrupted?
+
+	def self.raise(thread, exception = Interrupted)
+		RobustInterruption.disable_interruptions do
+			data = thread[:robust_interruption]
+			data.interrupted = true
+			if data.try_lock
+				begin
+					thread.raise(exception)
+				ensure
+					data.unlock
+				end
+			end
+		end
+	end
+
+	def disable_interruptions(thread = Thread.current)
+		data = thread[:robust_interruption]
+		if data
+			was_interruptable = data.interruptable?
+			data.lock if was_interruptable
+			data.push_interruption_flag(false)
+			begin
+				yield
+			ensure
+				data.pop_interruption_flag
+				data.unlock if was_interruptable
+			end
+		else
+			yield
+		end
+	end
+	module_function :disable_interruptions
+
+	def enable_interruptions(thread = Thread.current)
+		data = thread[:robust_interruption]
+		if data
+			was_interruptable = data.interruptable?
+			data.push_interruption_flag(true)
+			data.unlock if !was_interruptable
+			begin
+				yield
+			ensure
+				data.lock if !was_interruptable
+				data.pop_interruption_flag
+			end
+		else
+			yield
+		end
+	end
+	module_function :enable_interruptions
+
+	def restore_interruptions(thread = Thread.current)
+		data = thread[:robust_interruption]
+		if data
+			if data.interruption_flags.size < 2
+				Kernel.raise "Cannot restore interruptions state to previous value - no previous value exists"
+			end
+			if data.interruption_flags[-2]
+				enable_interruptions do
+					yield
+				end
+			else
+				disable_interruptions do
+					yield
+				end
+			end
+		else
+			yield
+		end
+	end
+	module_function :restore_interruptions
+end
+
+end # module Utils
+end # module PhusionPassenger

data/lib/phusion_passenger/utils/tee_input.rb

@@ -0,0 +1,174 @@
+# encoding: binary
+#
+# This file is taken from Unicorn. The following license applies to this file
+# (and this file only, not to the rest of Phusion Passenger):
+#
+# 1. You may make and give away verbatim copies of the source form of the
+#    software without restriction, provided that you duplicate all of the
+#    original copyright notices and associated disclaimers.
+#
+# 2. You may modify your copy of the software in any way, provided that
+#    you do at least ONE of the following:
+#
+#      a) place your modifications in the Public Domain or otherwise make them
+#      Freely Available, such as by posting said modifications to Usenet or an
+#      equivalent medium, or by allowing the author to include your
+#      modifications in the software.
+#
+#      b) use the modified software only within your corporation or
+#         organization.
+#
+#      c) rename any non-standard executables so the names do not conflict with
+#      standard executables, which must also be provided.
+#
+#      d) make other distribution arrangements with the author.
+#
+# 3. You may distribute the software in object code or executable
+#    form, provided that you do at least ONE of the following:
+#
+#      a) distribute the executables and library files of the software,
+#      together with instructions (in the manual page or equivalent) on where
+#      to get the original distribution.
+#
+#      b) accompany the distribution with the machine-readable source of the
+#      software.
+#
+#      c) give non-standard executables non-standard names, with
+#         instructions on where to get the original software distribution.
+#
+#      d) make other distribution arrangements with the author.
+#
+# 4. You may modify and include the part of the software into any other
+#    software (possibly commercial).  But some files in the distribution
+#    are not written by the author, so that they are not under this terms.
+#
+# 5. The scripts and library files supplied as input to or produced as
+#    output from the software do not automatically fall under the
+#    copyright of the software, but belong to whomever generated them,
+#    and may be sold commercially, and may be aggregated with this
+#    software.
+#
+# 6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+#    IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+#    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+#    PURPOSE.
+
+require 'stringio'
+require 'phusion_passenger/utils/tmpio'
+
+module PhusionPassenger
+module Utils
+
+# acts like tee(1) on an input input to provide a input-like stream
+# while providing rewindable semantics through a File/StringIO backing
+# store.  On the first pass, the input is only read on demand so your
+# Rack application can use input notification (upload progress and
+# like).  This should fully conform to the Rack::Lint::InputWrapper
+# specification on the public API.  This class is intended to be a
+# strict interpretation of Rack::Lint::InputWrapper functionality and
+# will not support any deviations from it.
+#
+# When processing uploads, Unicorn exposes a TeeInput object under
+# "rack.input" of the Rack environment.
+class TeeInput
+  CONTENT_LENGTH = "CONTENT_LENGTH".freeze
+
+  # The maximum size (in +bytes+) to buffer in memory before
+  # resorting to a temporary file.  Default is 112 kilobytes.
+  @@client_body_buffer_size = 112 * 1024
+
+  # sets the maximum size of request bodies to buffer in memory,
+  # amounts larger than this are buffered to the filesystem
+  def self.client_body_buffer_size=(bytes)
+    @@client_body_buffer_size = bytes
+  end
+
+  # returns the maximum size of request bodies to buffer in memory,
+  # amounts larger than this are buffered to the filesystem
+  def self.client_body_buffer_size
+    @@client_body_buffer_size
+  end
+
+  # Initializes a new TeeInput object.  You normally do not have to call
+  # this unless you are writing an HTTP server.
+  def initialize(socket, env)
+    @len = env[CONTENT_LENGTH]
+    @len = @len.to_i if @len
+    @socket = socket
+    @tmp = @len && @len <= @@client_body_buffer_size ?
+           StringIO.new("") : TmpIO.new("PassengerTeeInput")
+  end
+
+  def close
+    @tmp.close
+  end
+
+  def size
+    @len and return @len
+    pos = @tmp.pos
+    consume!
+    @tmp.pos = pos
+    @len = @tmp.size
+  end
+
+  def read(*args)
+    if socket_drained?
+      @tmp.read(*args)
+    else
+      tee(@socket.read(*args))
+    end
+  end
+
+  def gets
+    if socket_drained?
+      @tmp.gets
+    else
+      tee(@socket.gets)
+    end
+  end
+
+  def rewind
+    return 0 if 0 == @tmp.size
+    consume! if !socket_drained?
+    @tmp.rewind # Rack does not specify what the return value is here
+  end
+
+  def each
+    while line = gets
+      yield line
+    end
+
+    self # Rack does not specify what the return value is here
+  end
+
+private
+  
+  def socket_drained?
+    if @socket
+      if @socket.eof?
+        @socket = nil
+        true
+      else
+        false
+      end
+    else
+      true
+    end
+  end
+
+  # consumes the stream of the socket
+  def consume!
+    junk = ""
+    nil while read(16 * 1024, junk)
+  end
+
+  def tee(buffer)
+    if buffer && buffer.size > 0
+      @tmp.write(buffer)
+    end
+    buffer
+  end
+end
+
+end # module Utils
+end # module PhusionPassenger

data/lib/phusion_passenger/utils/tmpio.rb

@@ -0,0 +1,33 @@
+require 'tmpdir'
+
+module PhusionPassenger
+module Utils
+
+# some versions of Ruby had a broken Tempfile which didn't work
+# well with unlinked files.  This one is much shorter, easier
+# to understand, and slightly faster.
+class TmpIO < File
+
+  # creates and returns a new File object.  The File is unlinked
+  # immediately, switched to binary mode, and userspace output
+  # buffering is disabled
+  def self.new(namespace)
+    fp = begin
+      super("#{Dir::tmpdir}/#{namespace}-#{rand}", RDWR|CREAT|EXCL, 0600)
+    rescue Errno::EEXIST
+      retry
+    end
+    unlink(fp.path)
+    fp.binmode
+    fp.sync = true
+    fp
+  end
+
+  # for easier env["rack.input"] compatibility with Rack <= 1.1
+  def size
+    stat.size
+  end unless File.method_defined?(:size)
+end
+
+end # module Utils
+end # module PhusionPassenger

data/lib/phusion_passenger/utils/unseekable_socket.rb

@@ -156,6 +156,12 @@ class UnseekableSocket
 	rescue => e
 		raise annotate(e)
 	end
+
+	def eof?
+		@socket.eof?
+	rescue => e
+		raise annotate(e)
+	end
 	
 	def closed?
 		@socket.closed?

data/resources/mime.types

@@ -24,6 +24,11 @@ types {
     image/x-ms-bmp                        bmp;
     image/svg+xml                         svg;
 
+    application/x-font-ttf                ttf;
+    font/opentype                         otf;
+    font/x-woff                           woff;
+    application/vnd.ms-fontobject         eot;
+
     application/java-archive              jar war ear;
     application/mac-binhex40              hqx;
     application/msword                    doc;
@@ -55,7 +60,6 @@ types {
     application/octet-stream              bin exe dll;
     application/octet-stream              deb;
     application/octet-stream              dmg;
-    application/octet-stream              eot;
     application/octet-stream              iso img;
     application/octet-stream              msi msp msm;
     application/octet-stream              gem;