thin 1.7.2 → 2.0.0.pre

data/lib/thin/listener.rb

@@ -0,0 +1,114 @@
+require "socket"
+
+module Thin
+  # A listener holding a socket and its configuration.
+  class Listener
+    # Hostname the socket will bind to in case of IPv4/6 addresses.
+    attr_reader :host
+
+    # Port the socket will bind to in case of IPv4/6 addresses.
+    attr_reader :port
+
+    # UNIX domain socket the socket will bind to.
+    attr_reader :socket_file
+
+    def initialize(address, options={})
+      case address
+      when Integer
+        @host = ""
+        @port = address
+      when /\A(\/.*)\z/, /\Aunix:(.*)\z/ # /file.sock or unix:file.sock
+        @socket_file = $1
+      when /\A(?:\*:)?(\d+)\z/ # *:port or "port"
+        @host = ""
+        @port = $1.to_i
+      when /\A((?:\d{1,3}\.){3}\d{1,3}):(\d+)\z/ # 0.0.0.0:port
+        @host = $1
+        @port = $2.to_i
+      when /\A\[([a-fA-F0-9:]+)\]:(\d+)\z/ # IPV6 address: [::]:port
+        @host = $1
+        @port = $2.to_i
+      else
+        raise ArgumentError, "Invalid address #{address.inspect}. " +
+                             "Accepted formats are: 3000, *:3000, 0.0.0.0:3000, [::]:3000, /file.sock or unix:file.sock"
+      end
+      
+      # Default values
+      options = {
+        # Same defaults as Unicorn
+        :tcp_no_delay => true,
+        :tcp_no_push => false,
+        :ipv6_only => false,
+        :backlog => 1024
+      }.merge(options)
+      
+      @backlog = options[:backlog]
+      self.tcp_no_delay = options[:tcp_nodelay] || options[:tcp_no_delay]
+      self.tcp_no_push = options[:tcp_nopush] || options[:tcp_no_push]
+      self.ipv6_only = options[:ipv6_only]
+    end
+
+    # Creates the socket and binds it to the address.
+    def socket
+      return @socket if @socket
+
+      @socket = Socket.new(socket_family, Socket::SOCK_STREAM, 0)
+      @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+
+      @socket
+    end
+
+    # Returns the socket family: Socket::AF_*
+    def socket_family
+      return Socket::AF_UNIX if @socket_file
+      return Socket::AF_INET6 if @host.include?(":")
+      return Socket::AF_INET
+    end
+
+    # Returns +true+ if the socket is a UNIX domain one.
+    def unix?
+      socket_family == Socket::AF_UNIX
+    end
+
+    def ipv6_only=(value)
+      socket.ipv6only! if value && !unix?
+    end
+
+    def tcp_no_delay=(value)
+      socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, value) unless unix?
+    end
+
+    def tcp_no_push=(value)
+      # Taken from Unicorn
+      if defined?(TCP_CORK) # Linux
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_CORK, value)
+      elsif defined?(TCP_NOPUSH) # TCP_NOPUSH is untested (FreeBSD)
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NOPUSH, value)
+      end
+    end
+
+    def listen
+      delete_socket_file!
+
+      socket.bind unix? ? Socket.pack_sockaddr_un(@socket_file) : # UNIX domain
+                          Socket.pack_sockaddr_in(@port, @host) # IPv4/6
+
+      socket.listen(@backlog)
+    end
+
+    def close
+      socket.close if @socket
+      delete_socket_file!
+    end
+
+    def to_s
+      unix? ? @socket_file : "#{@host}:#{@port}"
+    end
+    
+    private
+      def delete_socket_file!
+        File.delete(@socket_file) if @socket_file && File.socket?(@socket_file)
+      end
+      
+  end
+end

data/lib/thin/request.rb

@@ -1,105 +1,94 @@
-require 'tempfile'
+require "stringio"
+require "tempfile"
 
 module Thin
-  # Raised when an incoming request is not valid
-  # and the server can not process it.
-  class InvalidRequest < IOError; end
-
   # A request sent by the client to the server.
   class Request
     # Maximum request body size before it is moved out of memory
     # and into a tempfile for reading.
     MAX_BODY          = 1024 * (80 + 32)
     BODY_TMPFILE      = 'thin-body'.freeze
-    MAX_HEADER        = 1024 * (80 + 32)
 
-    INITIAL_BODY      = String.new
+    INITIAL_BODY = ''
     # Force external_encoding of request's body to ASCII_8BIT
-    INITIAL_BODY.encode!(Encoding::ASCII_8BIT) if INITIAL_BODY.respond_to?(:encode!) && defined?(Encoding::ASCII_8BIT)
+    INITIAL_BODY.encode!(Encoding::ASCII_8BIT) if INITIAL_BODY.respond_to?(:encode!)
 
     # Freeze some HTTP header names & values
     SERVER_SOFTWARE   = 'SERVER_SOFTWARE'.freeze
     SERVER_NAME       = 'SERVER_NAME'.freeze
-    REQUEST_METHOD    = 'REQUEST_METHOD'.freeze
+    SERVER_PORT       = 'SERVER_PORT'.freeze
+    DEFAULT_PORT      = '80'.freeze
+    HTTP_HOST         = 'HTTP_HOST'.freeze
     LOCALHOST         = 'localhost'.freeze
     HTTP_VERSION      = 'HTTP_VERSION'.freeze
+    SERVER_PROTOCOL   = 'SERVER_PROTOCOL'.freeze
     HTTP_1_0          = 'HTTP/1.0'.freeze
     REMOTE_ADDR       = 'REMOTE_ADDR'.freeze
+    CONTENT_TYPE      = 'CONTENT_TYPE'.freeze
+    CONTENT_TYPE_L    = 'Content-Type'.freeze
     CONTENT_LENGTH    = 'CONTENT_LENGTH'.freeze
-    CONNECTION        = 'HTTP_CONNECTION'.freeze
+    CONTENT_LENGTH_L  = 'Content-Length'.freeze
+    SCRIPT_NAME       = 'SCRIPT_NAME'.freeze
+    QUERY_STRING      = 'QUERY_STRING'.freeze
+    PATH_INFO         = 'PATH_INFO'.freeze
+    REQUEST_METHOD    = 'REQUEST_METHOD'.freeze
+    FRAGMENT          = 'FRAGMENT'.freeze
+    HTTP              = 'http'.freeze
+    EMPTY             = ''.freeze
     KEEP_ALIVE_REGEXP = /\bkeep-alive\b/i.freeze
     CLOSE_REGEXP      = /\bclose\b/i.freeze
-    HEAD              = 'HEAD'.freeze
 
     # Freeze some Rack header names
     RACK_INPUT        = 'rack.input'.freeze
     RACK_VERSION      = 'rack.version'.freeze
     RACK_ERRORS       = 'rack.errors'.freeze
+    RACK_URL_SCHEME   = 'rack.url_scheme'.freeze
     RACK_MULTITHREAD  = 'rack.multithread'.freeze
     RACK_MULTIPROCESS = 'rack.multiprocess'.freeze
     RACK_RUN_ONCE     = 'rack.run_once'.freeze
     ASYNC_CALLBACK    = 'async.callback'.freeze
-    ASYNC_CLOSE       = 'async.close'.freeze
 
     # CGI-like request environment variables
     attr_reader :env
 
-    # Unparsed data of the request
-    attr_reader :data
-
     # Request body
     attr_reader :body
 
     def initialize
-      @parser   = Thin::HttpParser.new
-      @data     = String.new
-      @nparsed  = 0
-      @body     = StringIO.new(INITIAL_BODY.dup)
-      @env      = {
+      @body = StringIO.new(INITIAL_BODY)
+      @env = {
         SERVER_SOFTWARE   => SERVER,
         SERVER_NAME       => LOCALHOST,
+        SCRIPT_NAME       => EMPTY,
 
         # Rack stuff
         RACK_INPUT        => @body,
+        RACK_URL_SCHEME   => HTTP,
 
         RACK_VERSION      => VERSION::RACK,
-        RACK_ERRORS       => STDERR,
+        RACK_ERRORS       => $stderr,
 
-        RACK_MULTITHREAD  => false,
-        RACK_MULTIPROCESS => false,
         RACK_RUN_ONCE     => false
       }
+      @keep_alive = false
     end
 
-    # Parse a chunk of data into the request environment
-    # Raises an +InvalidRequest+ if invalid.
-    # Returns +true+ if the parsing is complete.
-    def parse(data)
-      if @parser.finished?  # Header finished, can only be some more body
-        @body << data
-      else                  # Parse more header using the super parser
-        @data << data
-        raise InvalidRequest, 'Header longer than allowed' if @data.size > MAX_HEADER
-
-        @nparsed = @parser.execute(@env, @data, @nparsed)
-
-        # Transfer to a tempfile if body is very big
-        move_body_to_tempfile if @parser.finished? && content_length > MAX_BODY
+    def headers=(headers)
+      # TODO benchmark & optimize
+      headers.each_pair do |k, v|
+        # Convert to Rack headers
+        if k == CONTENT_TYPE_L
+          @env[CONTENT_TYPE] = v
+        elsif k == CONTENT_LENGTH_L
+          @env[CONTENT_LENGTH] = v
+        else
+          @env["HTTP_" + k.upcase.tr("-", "_")] = v
+        end
       end
 
-
-      if finished?   # Check if header and body are complete
-        @data = nil
-        @body.rewind
-        true         # Request is fully parsed
-      else
-        false        # Not finished, need more data
-      end
-    end
-
-    # +true+ if headers and body are finished parsing
-    def finished?
-      @parser.finished? && @body.size >= content_length
+      host, port = @env[HTTP_HOST].split(":") if @env.key?(HTTP_HOST)
+      @env[SERVER_NAME] = host || LOCALHOST
+      @env[SERVER_PORT] = port || DEFAULT_PORT
     end
 
     # Expected size of the body
@@ -107,46 +96,77 @@ module Thin
       @env[CONTENT_LENGTH].to_i
     end
 
-    # Returns +true+ if the client expects the connection to be persistent.
-    def persistent?
-      # Clients and servers SHOULD NOT assume that a persistent connection
-      # is maintained for HTTP versions less than 1.1 unless it is explicitly
-      # signaled. (http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html)
-      if @env[HTTP_VERSION] == HTTP_1_0
-        @env[CONNECTION] =~ KEEP_ALIVE_REGEXP
+    def remote_address=(address)
+      @env[REMOTE_ADDR] = address
+    end
 
-      # HTTP/1.1 client intends to maintain a persistent connection unless
-      # a Connection header including the connection-token "close" was sent
-      # in the request
-      else
-        @env[CONNECTION].nil? || @env[CONNECTION] !~ CLOSE_REGEXP
-      end
+    def method=(method)
+      @env[REQUEST_METHOD] = method
     end
 
-    def remote_address=(address)
-      @env[REMOTE_ADDR] = address
+    def http_version=(string)
+      @env[HTTP_VERSION] = string
+      @env[SERVER_PROTOCOL] = string
+    end
+    
+    def http_version
+      @env[HTTP_VERSION]
+    end
+
+    def path=(path)
+      @env[PATH_INFO] = path
     end
 
-    def threaded=(value)
-      @env[RACK_MULTITHREAD] = value
+    def query_string=(string)
+      @env[QUERY_STRING] = string
+    end
+
+    def fragment=(string)
+      @env[FRAGMENT] = string
+    end
+    
+    def keep_alive=(bool)
+      @keep_alive = bool
+    end
+    
+    def multithread=(bool)
+      @env[RACK_MULTITHREAD] = bool
+    end
+    
+    def multiprocess=(bool)
+      @env[RACK_MULTIPROCESS] = bool
+    end
+    
+    # Returns +true+ if the client expect the connection to be kept alive.
+    def keep_alive?
+      @keep_alive
+    end
+
+    def <<(data)
+      @body << data
+
+      # Transfert to a tempfile if body is very big.
+      move_body_to_tempfile if content_length > MAX_BODY
+
+      @body
     end
 
     def async_callback=(callback)
       @env[ASYNC_CALLBACK] = callback
-      @env[ASYNC_CLOSE] = EventMachine::DefaultDeferrable.new
     end
-
-    def async_close
-      @async_close ||= @env[ASYNC_CLOSE]
+    
+    def support_encoding_chunked?
+      @env[HTTP_VERSION] != HTTP_1_0
     end
 
-    def head?
-      @env[REQUEST_METHOD] == HEAD
+    # Called when we're done processing the request.
+    def finish
+      @body.rewind
     end
 
     # Close any resource used by the request
     def close
-      @body.close! if @body.class == Tempfile
+      @body.delete if @body.class == Tempfile
     end
 
     private

data/lib/thin/response.rb

@@ -1,18 +1,56 @@
+require "rack"
+
 module Thin
   # A response sent to the client.
   class Response
+    # Template async response.
+    ASYNC = [-1, {}, []].freeze
+    
+    # Store HTTP header name-value pairs direcly to a string
+    # and allow duplicated entries on some names.
+    class Headers
+      HEADER_FORMAT      = "%s: %s\r\n".freeze
+      ALLOWED_DUPLICATES = %w(Set-Cookie Set-Cookie2 Warning WWW-Authenticate).freeze
+
+      def initialize
+        @sent = {}
+        @out = []
+      end
+
+      # Add <tt>key: value</tt> pair to the headers.
+      # Ignore if already sent and no duplicates are allowed
+      # for this +key+.
+      def []=(key, value)
+        if !@sent.has_key?(key) || ALLOWED_DUPLICATES.include?(key)
+          @sent[key] = true
+          value = case value
+                  when Time
+                    value.httpdate
+                  when NilClass
+                    return
+                  else
+                    value.to_s
+                  end
+          @out << HEADER_FORMAT % [key, value]
+        end
+      end
+
+      def has_key?(key)
+        @sent[key]
+      end
+
+      def to_s
+        @out.join
+      end
+    end
+
     CONNECTION     = 'Connection'.freeze
     CLOSE          = 'close'.freeze
     KEEP_ALIVE     = 'keep-alive'.freeze
     SERVER         = 'Server'.freeze
     CONTENT_LENGTH = 'Content-Length'.freeze
-
-    PERSISTENT_STATUSES  = [100, 101].freeze
-
-    #Error Responses
-    ERROR            = [500, {'Content-Type' => 'text/plain'}, ['Internal server error']].freeze
-    PERSISTENT_ERROR = [500, {'Content-Type' => 'text/plain', 'Connection' => 'keep-alive', 'Content-Length' => "21"}, ['Internal server error']].freeze
-    BAD_REQUEST      = [400, {'Content-Type' => 'text/plain'}, ['Bad Request']].freeze
+    
+    KEEP_ALIVE_STATUSES = [100, 101].freeze
 
     # Status code
     attr_accessor :status
@@ -21,32 +59,21 @@ module Thin
     attr_accessor :body
 
     # Headers key-value hash
-    attr_reader   :headers
-
-    def initialize
-      @headers    = Headers.new
-      @status     = 200
-      @persistent = false
-      @skip_body  = false
+    attr_reader :headers
+    
+    attr_reader :http_version
+
+    def initialize(status=200, headers=nil, body=nil)
+      @headers = Headers.new
+      @status = status
+      @keep_alive = false
+      @body = body
+      @http_version = "HTTP/1.1"
+
+      self.headers = headers if headers
     end
 
-    # String representation of the headers
-    # to be sent in the response.
-    def headers_output
-      # Set default headers
-      @headers[CONNECTION] = persistent? ? KEEP_ALIVE : CLOSE unless @headers.has_key?(CONNECTION)
-      @headers[SERVER]     = Thin::NAME unless @headers.has_key?(SERVER)
-
-      @headers.to_s
-    end
-
-    # Top header of the response,
-    # containing the status code and response headers.
-    def head
-      "HTTP/1.1 #{@status} #{HTTP_STATUS_CODES[@status.to_i]}\r\n#{headers_output}\r\n"
-    end
-
-    if Thin.ruby_18?
+    if System.ruby_18?
 
       # Ruby 1.8 implementation.
       # Respects Rack specs.
@@ -78,8 +105,22 @@ module Thin
 
     end
 
+    # Finish preparing the response.
+    def finish
+      @headers[CONNECTION] = keep_alive? ? KEEP_ALIVE : CLOSE
+      @headers[SERVER] = Thin::SERVER
+    end
+
+    # Top header of the response,
+    # containing the status code and response headers.
+    def head
+      status_message = Rack::Utils::HTTP_STATUS_CODES[@status.to_i]
+      "#{@http_version} #{@status} #{status_message}\r\n#{@headers.to_s}\r\n"
+    end
+
     # Close any resource used by the response
     def close
+      @body.fail if @body.respond_to?(:fail)
       @body.close if @body.respond_to?(:close)
     end
 
@@ -88,30 +129,56 @@ module Thin
     # define your own +each+ method on +body+.
     def each
       yield head
-
-      unless @skip_body
-        if @body.is_a?(String)
-          yield @body
-        else
-          @body.each { |chunk| yield chunk }
-        end
+      if @body.is_a?(String)
+        yield @body
+      else
+        @body.each { |chunk| yield chunk }
       end
     end
-
+    
     # Tell the client the connection should stay open
-    def persistent!
-      @persistent = true
+    def keep_alive!
+      @keep_alive = true
     end
 
     # Persistent connection must be requested as keep-alive
     # from the server and have a Content-Length, or the response
     # status must require that the connection remain open.
-    def persistent?
-      (@persistent && @headers.has_key?(CONTENT_LENGTH)) || PERSISTENT_STATUSES.include?(@status)
+    def keep_alive?
+      (@keep_alive && @headers.has_key?(CONTENT_LENGTH)) || KEEP_ALIVE_STATUSES.include?(@status)
+    end
+
+    def async?
+      @status == ASYNC.first
+    end
+    
+    def file?
+      @body.respond_to?(:to_path)
+    end
+    
+    def filename
+      @body.to_path
+    end
+    
+    def body_callback=(proc)
+      @body.callback(&proc) if @body.respond_to?(:callback)
+      @body.errback(&proc) if @body.respond_to?(:errback)
+    end
+    
+    def chunked_encoding!
+      @headers['Transfer-Encoding'] = 'chunked'
+    end
+    
+    def http_version=(string)
+      return unless string && string == "HTTP/1.1" || string == "HTTP/1.0"
+      @http_version = string
     end
 
-    def skip_body!
-      @skip_body = true
+    def self.error(status=500, message=Rack::Utils::HTTP_STATUS_CODES[status])
+      new status,
+          { "Content-Type" => "text/plain",
+            "Content-Length" => Rack::Utils.bytesize(message).to_s },
+          [message]
     end
   end
 end