thin 1.8.0 → 2.0.0.pre

data/lib/thin/connection.rb

@@ -1,215 +1,289 @@
-require 'socket'
+require "rack"
+require "http/parser"
 
-module Thin
-  # Connection between the server and client.
-  # This class is instanciated by EventMachine on each new connection
-  # that is opened.
-  class Connection < EventMachine::Connection
-    include Logging
-
-    # This is a template async response. N.B. Can't use string for body on 1.9
-    AsyncResponse = [-1, {}, []].freeze
-
-    # Rack application (adapter) served by this connection.
-    attr_accessor :app
-
-    # Backend to the server
-    attr_accessor :backend
-
-    # Current request served by the connection
-    attr_accessor :request
+require "thin/request"
+require "thin/response"
+require "thin/chunked_body"
 
-    # Next response sent through the connection
-    attr_accessor :response
+module Thin
+  # EventMachine connection.
+  # Supports:
+  # * Rack specifications v1.1: http://rack.rubyforge.org/doc/SPEC.html
+  # * Asynchronous responses with chunked encoding, via the <tt>env['async.callback']</tt> or <tt>throw :async</tt>.
+  # * Keep-alive.
+  # * File streaming.
+  # * Calling the Rack app from pooled threads.
+  class Connection < EM::Connection
+    attr_accessor :server
+    attr_accessor :listener
+    attr_accessor :can_keep_alive
+  
+    # For tests
+    attr_reader :request, :response
+
+
+    def on_close(&block)
+      @on_close = block
+    end
+  
 
-    # Calling the application in a threaded allowing
-    # concurrent processing of requests.
-    attr_writer :threaded
+    # == EM callback methods
 
     # Get the connection ready to process a request.
     def post_init
-      @request  = Request.new
-      @response = Response.new
+      @parser = HTTP::Parser.new(self)
     end
 
     # Called when data is received from the client.
     def receive_data(data)
-      @idle = false
-      trace data
-      process if @request.parse(data)
-    rescue InvalidRequest => e
-      log_error("Invalid request", e)
-      post_process Response::BAD_REQUEST
-    end
-
-    # Called when all data was received and the request
-    # is ready to be processed.
-    def process
-      if threaded?
-        @request.threaded = true
-        EventMachine.defer { post_process(pre_process) }
-      else
-        @request.threaded = false
-        post_process(pre_process)
-      end
+      puts data if $DEBUG
+      @parser << data
+    rescue HTTP::Parser::Error => e
+      $stderr.puts "Parse error: #{e}"
+      send_response_and_reset Response.error(400) # Bad Request
     end
 
-    def ssl_verify_peer(cert)
-      # In order to make the cert available later we have to have made at least
-      # a show of verifying it.
-      true
+    # Called when the connection is unbinded from the socket
+    # and can no longer be used to process requests.
+    def unbind
+      close_request_and_response
+      @on_close.call if @on_close
     end
 
-    def pre_process
-      # Add client info to the request env
-      @request.remote_address = remote_address
 
-      # Connection may be closed unless the App#call response was a [-1, ...]
-      # It should be noted that connection objects will linger until this
-      # callback is no longer referenced, so be tidy!
-      @request.async_callback = method(:post_process)
-
-      if @backend.ssl?
-        @request.env["rack.url_scheme"] = "https"
+    # == Parser callback methods
 
-        if cert = get_peer_cert
-          @request.env['rack.peer_cert'] = cert
-        end
-      end
-
-      # When we're under a non-async framework like rails, we can still spawn
-      # off async responses using the callback info, so there's little point
-      # in removing this.
-      response = AsyncResponse
-      catch(:async) do
-        # Process the request calling the Rack adapter
-        response = @app.call(@request.env)
-      end
-      response
-    rescue Exception => e
-      unexpected_error(e)
-      # Pass through error response
-      can_persist? && @request.persistent? ? Response::PERSISTENT_ERROR : Response::ERROR
+    def on_message_begin
+      @request = Request.new
     end
 
-    def post_process(result)
-      return unless result
-      result = result.to_a
-
-      # Status code -1 indicates that we're going to respond later (async).
-      return if result.first == AsyncResponse.first
-
-      @response.status, @response.headers, @response.body = *result
-
-      log_error("Rack application returned nil body. " \
-                "Probably you wanted it to be an empty string?") if @response.body.nil?
+    def on_headers_complete(headers)
+      @request.multithread = server.threaded?
+      @request.multiprocess = server.prefork?
+      @request.remote_address = socket_address
+      @request.http_version = "HTTP/%d.%d" % @parser.http_version
+      @request.method = @parser.http_method
+      @request.path = @parser.request_path
+      @request.fragment = @parser.fragment
+      @request.query_string = @parser.query_string
+      @request.keep_alive = @parser.keep_alive?
+      @request.headers = headers
+    end
 
-      # HEAD requests should not return a body.
-      @response.skip_body! if @request.head?
+    def on_body(chunk)
+      @request << chunk
+    end
 
-      # Make the response persistent if requested by the client
-      @response.persistent! if @request.persistent?
+    def on_message_complete
+      @request.finish
+      process
+    end
 
-      # Send the response
-      @response.each do |chunk|
-        trace chunk
-        send_data chunk
-      end
 
-    rescue Exception => e
-      unexpected_error(e)
-      # Close connection since we can't handle response gracefully
-      close_connection
-    ensure
-      # If the body is being deferred, then terminate afterward.
-      if @response.body.respond_to?(:callback) && @response.body.respond_to?(:errback)
-        @response.body.callback { terminate_request }
-        @response.body.errback  { terminate_request }
+    # == Request processing methods
+  
+    # Starts the processing of the current request in <tt>@request</tt>.
+    def process
+      if server.threaded?
+        EM.defer(method(:call_app), method(:process_response))
       else
-        # Don't terminate the response if we're going async.
-        terminate_request unless result && result.first == AsyncResponse.first
+        if response = call_app
+          process_response(response)
+        end
       end
     end
 
-    # Logs information about an unexpected exceptional condition
-    def unexpected_error(e)
-      log_error("Unexpected error while processing request", e)
-    end
-
-    def close_request_response
-      @request.async_close.succeed if @request.async_close
-      @request.close  rescue nil
-      @response.close rescue nil
-    end
+    # Calls the Rack app in <tt>server.app</tt>.
+    # Returns a Rack response: <tt>[status, {headers}, [body]]</tt>
+    # or +nil+ if there was an error.
+    # The app can return [-1, ...] or throw :async to short-circuit request processing.
+    def call_app
+      # Connection may be closed unless the App#call response was a [-1, ...]
+      # It should be noted that connection objects will linger until this 
+      # callback is no longer referenced, so be tidy!
+      @request.async_callback = method(:process_async_response)
 
-    # Does request and response cleanup (closes open IO streams and
-    # deletes created temporary files).
-    # Re-initializes response and request if client supports persistent
-    # connection.
-    def terminate_request
-      unless persistent?
-        close_connection_after_writing rescue nil
-        close_request_response
-      else
-        close_request_response
-        # Connection become idle but it's still open
-        @idle = true
-        # Prepare the connection for another request if the client
-        # supports HTTP pipelining (persistent connection).
-        post_init
+      # Call the Rack application
+      response = Response::ASYNC # `throw :async` will result in this response
+      catch(:async) do
+        response = @server.app.call(@request.env)
       end
-    end
 
-    # Called when the connection is unbinded from the socket
-    # and can no longer be used to process requests.
-    def unbind
-      @request.async_close.succeed if @request.async_close
-      @response.body.fail if @response.body.respond_to?(:fail)
-      @backend.connection_finished(self)
-    end
+      response
 
-    # Allows this connection to be persistent.
-    def can_persist!
-      @can_persist = true
+    rescue Exception
+      handle_error
+      nil # Signals that the request could not be processed
     end
-
-    # Return +true+ if this connection is allowed to stay open and be persistent.
-    def can_persist?
-      @can_persist
+  
+    def prepare_response(response)
+      return unless response
+    
+      Response.new(*response)
     end
 
-    # Return +true+ if the connection must be left open
-    # and ready to be reused for another request.
-    def persistent?
-      @can_persist && @response.persistent?
+    # Process the response returns by +call_app+.
+    def process_response(response)
+      @response = prepare_response(response)
+    
+      # We're going to respond later (async).
+      return if @response.async?
+    
+      # Close the resources used by the request as soon as possible.
+      @request.close
+    
+      # Send the response.
+      send_response_and_reset
+
+    rescue Exception
+      handle_error
     end
-
-    # Return +true+ if the connection is open but is not
-    # processing any user requests
-    def idle?
-      @idle
+  
+    # Process the response sent asynchronously via <tt>body.call</tt>.
+    # The response will automatically be send using chunked encoding under
+    # HTTP 1.1 protocol.
+    def process_async_response(response)
+      @response = prepare_response(response)
+    
+      # Terminate the connection on callback from the response's body.
+      @response.body_callback = method(:terminate_async_response)
+    
+      # Use chunked encoding if available.
+      if @request.support_encoding_chunked?
+        @response.chunked_encoding!
+        @response.body = ChunkedBody.new(@response.body)
+      end
+    
+      # Send the response.
+      send_response
+    
+    rescue Exception
+      handle_error
     end
-
-    # +true+ if <tt>app.call</tt> will be called inside a thread.
-    # You can set all requests as threaded setting <tt>Connection#threaded=true</tt>
-    # or on a per-request case returning +true+ in <tt>app.deferred?</tt>.
-    def threaded?
-      @threaded || (@app.respond_to?(:deferred?) && @app.deferred?(@request.env))
+  
+    # Called after an asynchronous response is done sending the body.
+    def terminate_async_response
+      if @request.support_encoding_chunked?
+        # Send tail chunk. 0 length signals we're done w/ HTTP chunked encoding.
+        send_chunk ChunkedBody::TAIL
+      end
+    
+      reset
+    
+    rescue Exception
+      handle_error
     end
-
-    # IP Address of the remote client.
-    def remote_address
-      socket_address
+  
+    # Reset the connection and prepare for another request if keep-alive is
+    # requested.
+    # Else, closes the connection.
+    def reset
+      if @response && @response.keep_alive?
+        # Prepare the connection for another request if the client
+        # requested a persistent connection (keep-alive).
+        post_init
+      else
+        close_connection_after_writing
+      end
+    
+      close_request_and_response
+    end
+  
+  
+    # == Response sending methods
+  
+    # Send the HTTP response back to the client.
+    def send_response(response=@response)
+      @response = response
+    
+      if @request
+        # Keep connection alive if requested by the client.
+        @response.keep_alive! if @can_keep_alive && @request.keep_alive?
+        @response.http_version = @request.http_version
+      end
+  
+      # Prepare the response for sending.
+      @response.finish
+    
+      if @response.file?
+        send_file
+        return
+      end
+    
+      @response.each(&method(:send_chunk))
+      puts if $DEBUG
+    
     rescue Exception => e
-      log_error('Could not infer remote address', e)
-      nil
+      # In case there's an error sending the response, we give up and just
+      # close the connection to prevent recursion and consuming too much
+      # resources.
+      $stderr.puts "Error sending response: #{e}"
+      close_connection
     end
-
-    protected
+  
+    def send_response_and_reset(response=@response)
+      send_response(response)
+      reset
+    end
+  
+    # Sending a file using EM streaming and HTTP 1.1 style chunked-encoding if
+    # supported by the client.
+    def send_file
+      # Use HTTP 1.1 style chunked-encoding to send the file if supported
+      if @request.support_encoding_chunked?
+        @response.chunked_encoding!
+        send_chunk @response.head
+        deferrable = stream_file_data @response.filename, :http_chunks => true
+      else
+        send_chunk @response.head
+        deferrable = stream_file_data @response.filename
+      end
+      
+      if $DEBUG
+        puts "<Serving file #{@response.filename} with streaming ...>"
+        puts
+      end
+    
+      deferrable.callback(&method(:reset))
+      deferrable.errback(&method(:reset))
+    end
+  
+    def send_chunk(data)
+      print data if $DEBUG
+      send_data data
+    end
+  
+    private
+      # == Support methods
+    
+      def close_request_and_response
+        if @request
+          @request.close
+          @request = nil
+        end
+        if @response
+          @response.close
+          @response = nil
+        end
+      end
+  
       # Returns IP address of peer as a string.
       def socket_address
-        peer = get_peername
-        Socket.unpack_sockaddr_in(peer)[1] if peer
+        if listener.unix?
+          ""
+        else
+          Socket.unpack_sockaddr_in(get_peername)[1]
+        end
+      rescue Exception => e
+        $stderr.puts "Can't get socket address: #{e}"
+        ""
+      end
+  
+      # Output the error to stderr and sends back a 500 error.
+      def handle_error(e=$!)
+        $stderr.puts "[ERROR] #{e}"
+        $stderr.puts "\t" + e.backtrace.join("\n\t") if $DEBUG
+        send_response_and_reset Response.error(500) # Internal Server Error
       end
   end
 end