passenger 5.0.0.beta3 → 5.0.0.rc1

data/lib/phusion_passenger/utils/unseekable_socket.rb

@@ -24,276 +24,276 @@
 PhusionPassenger.require_passenger_lib 'utils'   # So that we can know whether #writev is supported.
 
 module PhusionPassenger
-module Utils
-
-# Some frameworks (e.g. Merb) call `seek` and `rewind` on the input stream
-# if it responds to these methods. In case of Phusion Passenger, the input
-# stream is a socket, and altough socket objects respond to `seek` and
-# `rewind`, calling these methods will raise an exception. We don't want
-# this to happen so in AbstractRequestHandler we wrap the client socket
-# into an UnseekableSocket wrapper, which doesn't respond to these methods.
-#
-# We used to dynamically undef `seek` and `rewind` on sockets, but this
-# blows the Ruby interpreter's method cache and made things slower.
-# Wrapping a socket is faster despite extra method calls.
-#
-# Furthermore, all exceptions originating from the wrapped socket will
-# be annotated. One can check whether a certain exception originates
-# from the wrapped socket by calling #source_of_exception?
-class UnseekableSocket
-	def self.wrap(socket)
-		return new.wrap(socket)
-	end
-	
-	def wrap(socket)
-		# Some people report that sometimes their Ruby (MRI/REE)
-		# processes get stuck with 100% CPU usage. Upon further
-		# inspection with strace, it turns out that these Ruby
-		# processes are continuously calling lseek() on a socket,
-		# which of course returns ESPIPE as error. gdb reveals
-		# lseek() is called by fwrite(), which in turn is called
-		# by rb_fwrite(). The affected socket is the
-		# AbstractRequestHandler client socket.
-		#
-		# I inspected the MRI source code and didn't find
-		# anything that would explain this behavior. This makes
-		# me think that it's a glibc bug, but that's very
-		# unlikely.
-		#
-		# The rb_fwrite() implementation takes an entirely
-		# different code path if I set 'sync' to true: it will
-		# skip fwrite() and use write() instead. So here we set
-		# 'sync' to true in the hope that this will work around
-		# the problem.
-		socket.sync = true
-		
-		# There's no need to set the encoding for Ruby 1.9 because
-		# abstract_request_handler.rb is tagged with 'encoding: binary'.
-		
-		@socket = socket
-		
-		return self
-	end
-	
-	# Don't allow disabling of sync.
-	def sync=(value)
-	end
-	
-	# Socket is sync'ed so flushing shouldn't do anything.
-	def flush
-	end
-	
-	# Already set to binary mode.
-	def binmode
-	end
-	
-	# This makes select() work.
-	def to_io
-		@socket
-	end
-
-	def simulate_eof!
-		@simulate_eof = true
-	end
-
-	def stop_simulating_eof!
-		@simulate_eof = false
-	end
-
-	def fileno
-		@socket.fileno
-	end
-	
-	def addr
-		@socket.addr
-	rescue => e
-		raise annotate(e)
-	end
-	
-	def write(string)
-		@socket.write(string)
-	rescue => e
-		raise annotate(e)
-	end
-
-	def write_nonblock(string)
-		@socket.write_nonblock(string)
-	rescue => e
-		raise annotate(e)
-	end
-	
-	def writev(components)
-		@socket.writev(components)
-	rescue => e
-		raise annotate(e)
-	end if IO.method_defined?(:writev)
-	
-	def writev2(components, components2)
-		@socket.writev2(components, components2)
-	rescue => e
-		raise annotate(e)
-	end if IO.method_defined?(:writev2)
-	
-	def writev3(components, components2, components3)
-		@socket.writev3(components, components2, components3)
-	rescue => e
-		raise annotate(e)
-	end if IO.method_defined?(:writev3)
-	
-	def send(*args)
-		@socket.send(*args)
-	rescue => e
-		raise annotate(e)
-	end
-
-	def sendmsg(*args)
-		@socket.sendmsg(*args)
-	rescue => e
-		raise annotate(e)
-	end
-
-	def sendmsg_nonblock(*args)
-		@socket.sendmsg_nonblock(*args)
-	rescue => e
-		raise annotate(e)
-	end
-
-	def puts(*args)
-		@socket.puts(*args)
-	rescue => e
-		raise annotate(e)
-	end
-	
-	def gets
-		return nil if @simulate_eof
-		@socket.gets
-	rescue => e
-		raise annotate(e)
-	end
-	
-	def read(*args)
-		if @simulate_eof
-			length, buffer = args
-			if buffer
-				buffer.replace(binary_string(""))
-			else
-				buffer = binary_string("")
-			end
-			if length
-				return nil
-			else
-				return buffer
-			end
-		end
-		@socket.read(*args)
-	rescue => e
-		raise annotate(e)
-	end
-
-	def read_nonblock(*args)
-		raise EOFError, "end of file reached" if @simulate_eof
-		@socket.read_nonblock(*args)
-	rescue => e
-		raise annotate(e)
-	end
-	
-	def readpartial(*args)
-		raise EOFError, "end of file reached" if @simulate_eof
-		@socket.readpartial(*args)
-	rescue => e
-		raise annotate(e)
-	end
-	
-	def readline
-		raise EOFError, "end of file reached" if @simulate_eof
-		@socket.readline
-	rescue => e
-		raise annotate(e)
-	end
-
-	def recv(*args)
-		raise EOFError, "end of file reached" if @simulate_eof
-		@socket.recv(*args)
-	rescue => e
-		raise annotate(e)
-	end
-
-	def recvfrom(*args)
-		raise EOFError, "end of file reached" if @simulate_eof
-		@socket.recvfrom(*args)
-	rescue => e
-		raise annotate(e)
-	end
-
-	def recvfrom_nonblock(*args)
-		raise EOFError, "end of file reached" if @simulate_eof
-		@socket.recvfrom_nonblock(*args)
-	rescue => e
-		raise annotate(e)
-	end
-	
-	def each(&block)
-		return if @simulate_eof
-		@socket.each(&block)
-	rescue => e
-		raise annotate(e)
-	end
-
-	def eof?
-		return true if @simulate_eof
-		@socket.eof?
-	rescue => e
-		raise annotate(e)
-	end
-	
-	def closed?
-		@socket.closed?
-	rescue => e
-		raise annotate(e)
-	end
-	
-	def close
-		@socket.close
-	rescue => e
-		raise annotate(e)
-	end
-	
-	def close_read
-		@socket.close_read
-	rescue => e
-		raise annotate(e)
-	end
-	
-	def close_write
-		@socket.close_write
-	rescue => e
-		raise annotate(e)
-	end
-	
-	def source_of_exception?(exception)
-		return exception.instance_variable_get(:"@from_unseekable_socket") == @socket.object_id
-	end
-
-private
-	def annotate(exception)
-		exception.instance_variable_set(:"@from_unseekable_socket", @socket.object_id)
-		return exception
-	end
-
-	def raise_error_because_activity_disallowed!
-		raise IOError, "It is not possible to read or write from the client socket because the current."
-	end
-
-	if ''.respond_to?(:force_encoding)
-		def binary_string(str)
-			return ''.force_encoding('binary')
-		end
-	else
-		def binary_string(str)
-			return ''
-		end
-	end
-end
-
-end # module Utils
+  module Utils
+
+    # Some frameworks (e.g. Merb) call `seek` and `rewind` on the input stream
+    # if it responds to these methods. In case of Phusion Passenger, the input
+    # stream is a socket, and altough socket objects respond to `seek` and
+    # `rewind`, calling these methods will raise an exception. We don't want
+    # this to happen so in AbstractRequestHandler we wrap the client socket
+    # into an UnseekableSocket wrapper, which doesn't respond to these methods.
+    #
+    # We used to dynamically undef `seek` and `rewind` on sockets, but this
+    # blows the Ruby interpreter's method cache and made things slower.
+    # Wrapping a socket is faster despite extra method calls.
+    #
+    # Furthermore, all exceptions originating from the wrapped socket will
+    # be annotated. One can check whether a certain exception originates
+    # from the wrapped socket by calling #source_of_exception?
+    class UnseekableSocket
+      def self.wrap(socket)
+        return new.wrap(socket)
+      end
+
+      def wrap(socket)
+        # Some people report that sometimes their Ruby (MRI/REE)
+        # processes get stuck with 100% CPU usage. Upon further
+        # inspection with strace, it turns out that these Ruby
+        # processes are continuously calling lseek() on a socket,
+        # which of course returns ESPIPE as error. gdb reveals
+        # lseek() is called by fwrite(), which in turn is called
+        # by rb_fwrite(). The affected socket is the
+        # AbstractRequestHandler client socket.
+        #
+        # I inspected the MRI source code and didn't find
+        # anything that would explain this behavior. This makes
+        # me think that it's a glibc bug, but that's very
+        # unlikely.
+        #
+        # The rb_fwrite() implementation takes an entirely
+        # different code path if I set 'sync' to true: it will
+        # skip fwrite() and use write() instead. So here we set
+        # 'sync' to true in the hope that this will work around
+        # the problem.
+        socket.sync = true
+
+        # There's no need to set the encoding for Ruby 1.9 because
+        # abstract_request_handler.rb is tagged with 'encoding: binary'.
+
+        @socket = socket
+
+        return self
+      end
+
+      # Don't allow disabling of sync.
+      def sync=(value)
+      end
+
+      # Socket is sync'ed so flushing shouldn't do anything.
+      def flush
+      end
+
+      # Already set to binary mode.
+      def binmode
+      end
+
+      # This makes select() work.
+      def to_io
+        @socket
+      end
+
+      def simulate_eof!
+        @simulate_eof = true
+      end
+
+      def stop_simulating_eof!
+        @simulate_eof = false
+      end
+
+      def fileno
+        @socket.fileno
+      end
+
+      def addr
+        @socket.addr
+      rescue => e
+        raise annotate(e)
+      end
+
+      def write(string)
+        @socket.write(string)
+      rescue => e
+        raise annotate(e)
+      end
+
+      def write_nonblock(string)
+        @socket.write_nonblock(string)
+      rescue => e
+        raise annotate(e)
+      end
+
+      def writev(components)
+        @socket.writev(components)
+      rescue => e
+        raise annotate(e)
+      end if IO.method_defined?(:writev)
+
+      def writev2(components, components2)
+        @socket.writev2(components, components2)
+      rescue => e
+        raise annotate(e)
+      end if IO.method_defined?(:writev2)
+
+      def writev3(components, components2, components3)
+        @socket.writev3(components, components2, components3)
+      rescue => e
+        raise annotate(e)
+      end if IO.method_defined?(:writev3)
+
+      def send(*args)
+        @socket.send(*args)
+      rescue => e
+        raise annotate(e)
+      end
+
+      def sendmsg(*args)
+        @socket.sendmsg(*args)
+      rescue => e
+        raise annotate(e)
+      end
+
+      def sendmsg_nonblock(*args)
+        @socket.sendmsg_nonblock(*args)
+      rescue => e
+        raise annotate(e)
+      end
+
+      def puts(*args)
+        @socket.puts(*args)
+      rescue => e
+        raise annotate(e)
+      end
+
+      def gets
+        return nil if @simulate_eof
+        @socket.gets
+      rescue => e
+        raise annotate(e)
+      end
+
+      def read(*args)
+        if @simulate_eof
+          length, buffer = args
+          if buffer
+            buffer.replace(binary_string(""))
+          else
+            buffer = binary_string("")
+          end
+          if length
+            return nil
+          else
+            return buffer
+          end
+        end
+        @socket.read(*args)
+      rescue => e
+        raise annotate(e)
+      end
+
+      def read_nonblock(*args)
+        raise EOFError, "end of file reached" if @simulate_eof
+        @socket.read_nonblock(*args)
+      rescue => e
+        raise annotate(e)
+      end
+
+      def readpartial(*args)
+        raise EOFError, "end of file reached" if @simulate_eof
+        @socket.readpartial(*args)
+      rescue => e
+        raise annotate(e)
+      end
+
+      def readline
+        raise EOFError, "end of file reached" if @simulate_eof
+        @socket.readline
+      rescue => e
+        raise annotate(e)
+      end
+
+      def recv(*args)
+        raise EOFError, "end of file reached" if @simulate_eof
+        @socket.recv(*args)
+      rescue => e
+        raise annotate(e)
+      end
+
+      def recvfrom(*args)
+        raise EOFError, "end of file reached" if @simulate_eof
+        @socket.recvfrom(*args)
+      rescue => e
+        raise annotate(e)
+      end
+
+      def recvfrom_nonblock(*args)
+        raise EOFError, "end of file reached" if @simulate_eof
+        @socket.recvfrom_nonblock(*args)
+      rescue => e
+        raise annotate(e)
+      end
+
+      def each(&block)
+        return if @simulate_eof
+        @socket.each(&block)
+      rescue => e
+        raise annotate(e)
+      end
+
+      def eof?
+        return true if @simulate_eof
+        @socket.eof?
+      rescue => e
+        raise annotate(e)
+      end
+
+      def closed?
+        @socket.closed?
+      rescue => e
+        raise annotate(e)
+      end
+
+      def close
+        @socket.close
+      rescue => e
+        raise annotate(e)
+      end
+
+      def close_read
+        @socket.close_read
+      rescue => e
+        raise annotate(e)
+      end
+
+      def close_write
+        @socket.close_write
+      rescue => e
+        raise annotate(e)
+      end
+
+      def source_of_exception?(exception)
+        return exception.instance_variable_get(:"@from_unseekable_socket") == @socket.object_id
+      end
+
+    private
+      def annotate(exception)
+        exception.instance_variable_set(:"@from_unseekable_socket", @socket.object_id)
+        return exception
+      end
+
+      def raise_error_because_activity_disallowed!
+        raise IOError, "It is not possible to read or write from the client socket because the current."
+      end
+
+      if ''.respond_to?(:force_encoding)
+        def binary_string(str)
+          return ''.force_encoding('binary')
+        end
+      else
+        def binary_string(str)
+          return ''
+        end
+      end
+    end
+
+  end # module Utils
 end # module PhusionPassenger