thin 0.4.1 → 0.5.0

data/lib/rack/adapter/rails.rb

@@ -0,0 +1,136 @@
+# This as been submitted to Rack as a patch, tested and everything.
+# Bug Christian Neukirchen at chneukirchen@gmail.com to apply the patch!
+
+require 'cgi'
+
+# Adapter to run a Rails app with any supported Rack handler.
+# By default it will try to load the Rails application in the
+# current directory in the development environment.
+# Options:
+#  root: Root directory of the Rails app
+#  env: Rails environment to run in (development, production or test)
+# Based on http://fuzed.rubyforge.org/ Rails adapter
+module Rack
+  module Adapter 
+    class Rails
+      def initialize(options={})
+        @root = options[:root] || Dir.pwd
+        @env  = options[:env]  || 'development'
+        
+        load_application
+        
+        @file_server = Rack::File.new(::File.join(RAILS_ROOT, "public"))
+      end
+      
+      def load_application
+        ENV['RAILS_ENV'] = @env
+
+        require "#{@root}/config/environment"
+        require 'dispatcher'
+      end
+      
+      # TODO refactor this in File#can_serve?(path) ??
+      def file?(path)
+        full_path = ::File.join(@file_server.root, Utils.unescape(path))
+        ::File.file?(full_path) && ::File.readable?(full_path)
+      end
+      
+      def call(env)
+        # Serve the file if it's there
+        return @file_server.call(env) if file?(env['PATH_INFO'])
+        
+        request         = Request.new(env)
+        response        = Response.new
+        
+        session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS
+        cgi             = CGIWrapper.new(request, response)
+    
+        Dispatcher.dispatch(cgi, session_options, response)
+
+        response.finish
+      end
+    
+      protected
+        
+        class CGIWrapper < ::CGI
+          def initialize(request, response, *args)
+            @request  = request
+            @response = response
+            @args     = *args
+            @input    = request.body
+
+            super *args
+          end
+        
+          def header(options = "text/html")
+            if options.is_a?(String)
+              @response['Content-Type']     = options unless @response['Content-Type']
+            else
+              @response['Content-Length']   = options.delete('Content-Length').to_s if options['Content-Length']
+            
+              @response['Content-Type']     = options.delete('type') || "text/html"
+              @response['Content-Type']    += "; charset=" + options.delete('charset') if options['charset']
+                        
+              @response['Content-Language'] = options.delete('language') if options['language']
+              @response['Expires']          = options.delete('expires') if options['expires']
+
+              @response.status              = options.delete('Status') if options['Status']
+        
+              options.each { |k,v| @response[k] = v }
+            
+              # Convert 'cookie' header to 'Set-Cookie' headers.
+              # According to http://www.faqs.org/rfcs/rfc2109.html:
+              #   the Set-Cookie response header comprises the token
+              #   Set-Cookie:, followed by a comma-separated list of
+              #   one or more cookies.
+              if cookie = @response.header.delete('Cookie')
+                cookies = case cookie
+                  when Array then cookie.collect { |c| c.to_s }.join(', ')
+                  when Hash  then cookie.collect { |_, c| c.to_s }.join(', ')
+                  else            cookie.to_s
+                end
+        
+                cookies << ', ' + @output_cookies.each { |c| c.to_s }.join(', ') if @output_cookies
+                
+                @response['Set-Cookie'] = cookies
+              end
+            end
+        
+            ""
+          end
+                        
+          def params
+            @params ||= @request.params
+          end
+        
+          def cookies
+            @request.cookies
+          end
+        
+          def query_string
+            @request.query_string
+          end
+          
+          # Used to wrap the normal args variable used inside CGI.
+          def args
+            @args
+          end
+    
+          # Used to wrap the normal env_table variable used inside CGI.
+          def env_table
+            @request.env
+          end
+    
+          # Used to wrap the normal stdinput variable used inside CGI.
+          def stdinput
+            @input
+          end
+        
+          def stdoutput
+            STDERR.puts "stdoutput should not be used."
+            @response.body
+          end
+      end
+    end
+  end
+end

data/lib/rack/handler/thin.rb

@@ -0,0 +1,13 @@
+module Rack
+  module Handler
+    class Thin
+      def self.run(app, options={})
+        server = ::Thin::Server.new(options[:Host] || '0.0.0.0',
+                                    options[:Port] || 8080,
+                                    app)
+        yield server if block_given?
+        server.start!
+      end
+    end
+  end
+end

data/lib/thin.rb

@@ -1,19 +1,35 @@
-$:.unshift File.dirname(__FILE__)
+$: << File.expand_path(File.dirname(__FILE__))
 
 require 'fileutils'
 require 'timeout'
 require 'stringio'
 
+require 'rubygems'
+require 'eventmachine'
+
 require 'thin/version'
-require 'thin/consts'
 require 'thin/statuses'
-require 'thin/mime_types'
-require 'thin/logging'
-require 'thin/daemonizing'
-require 'thin/server'
-require 'thin/request'
-require 'thin/headers'
-require 'thin/response'
-require 'thin/handler'
-require 'thin/cgi'
-require 'thin/rails'
+
+module Thin
+  NAME    = 'thin'.freeze
+  SERVER  = "#{NAME} #{VERSION::STRING}".freeze  
+  
+  autoload :Connection,   'thin/connection'
+  autoload :Daemonizable, 'thin/daemonizing'
+  autoload :Logging,      'thin/logging'
+  autoload :Headers,      'thin/headers'
+  autoload :Request,      'thin/request'
+  autoload :Response,     'thin/response'
+  autoload :Server,       'thin/server'
+end
+
+require 'rack'
+
+module Rack
+  module Handler
+    autoload :Thin, 'rack/handler/thin'
+  end
+  module Adapter
+    autoload :Rails, 'rack/adapter/rails'
+  end
+end

data/lib/thin/connection.rb

@@ -0,0 +1,47 @@
+require 'socket'
+
+module Thin
+  class Connection < EventMachine::Connection
+    include Logging
+    
+    attr_accessor :app
+    
+    def post_init
+      @request  = Request.new
+      @response = Response.new
+    end
+    
+    def receive_data(data)
+			process if @request.parse(data)
+    rescue InvalidRequest => e
+      log "Invalid request"
+      log_error e
+      trace { data }
+      close_connection
+    end
+    
+    def process
+      env = @request.env
+      
+      # Add client info to the request env
+      env[Request::REMOTE_ADDR] = env[Request::FORWARDED_FOR] || Socket.unpack_sockaddr_in(get_peername)[1]
+
+      # Process the request
+      @response.status, @response.headers, @response.body = @app.call(env)
+      
+      # Send the response
+      send_data @response.head
+      @response.body.rewind
+      send_data @response.body.read
+      
+      close_connection_after_writing
+      
+    rescue Object => e
+      log "Unexpected error while processing request: #{e.message}"
+      log_error e
+      close_connection rescue nil
+    ensure
+      @response.close rescue nil
+    end
+  end
+end

data/lib/thin/daemonizing.rb

@@ -42,6 +42,10 @@ module Thin
       base.extend ClassMethods
     end
     
+    def pid
+      File.exist?(pid_file) ? open(pid_file).read : nil
+    end
+    
     # Turns the current script into a daemon process that detaches from the console.
     def daemonize
       raise ArgumentError, 'You must specify a pid_file to deamonize' unless @pid_file
@@ -84,7 +88,7 @@ module Thin
     module ClassMethods
       # Kill the process which PID is stored in +pid_file+.
       def kill(pid_file, timeout=60)
-        if File.exist?(pid_file) && pid = open(pid_file).read
+        if pid = open(pid_file).read
           pid = pid.to_i
           print "Sending INT signal to process #{pid} ... "
           begin

data/lib/thin/headers.rb

@@ -1,7 +1,8 @@
 module Thin
   # Acts like a Hash, but allows duplicated keys
   class Headers
-    @@allowed_duplicates = %w(Set-Cookie Set-Cookie2 Warning WWW-Authenticate)
+    HEADER_FORMAT      = "%s: %s\r\n".freeze
+    ALLOWED_DUPLICATES = %w(Set-Cookie Set-Cookie2 Warning WWW-Authenticate).freeze
     
     def initialize
       @sent = {}
@@ -9,7 +10,7 @@ module Thin
     end
 
     def []=(key, value)
-      if @sent.has_key?(key) && !@@allowed_duplicates.include?(key)
+      if @sent.has_key?(key) && !ALLOWED_DUPLICATES.include?(key)
         # If we don't allow duplicate for that field
         # we overwrite the one that is already there
         @items.assoc(key)[1] = value

data/lib/thin/logging.rb

@@ -1,10 +1,7 @@
 module Thin
   # To be included into classes to allow some basic logging
-  # that can be silented (+silent+) or made more verbose (+trace+).
+  # that can be silented (+silent+) or made more verbose ($DEBUG=true).
   module Logging
-    # Output extra info about the request, response, errors and stuff like that.
-    attr_writer :trace
-    
     # Don't output any message if +true+.
     attr_accessor :silent
     
@@ -14,17 +11,13 @@ module Thin
         puts msg unless @silent
       end
       
-      # Log a message to the console (no line feed)
-      def logc(msg)
-        unless @silent
-          print msg
-          STDOUT.flush # Make sure the msg is shown right away
-        end
-      end
-  
       # Log a message to the console if tracing is activated
       def trace(msg=nil)
-        puts msg || yield if @trace && !@silent
+        puts msg || yield if $DEBUG && !@silent
+      end
+      
+      def log_error(e)
+        trace { "#{e}\n\t" + e.backtrace.join("\n\t") }
       end
   end
 end

data/lib/thin/request.rb

@@ -1,151 +1,71 @@
+require 'thin_parser'
+
 module Thin
   # Raised when an incoming request is not valid
   # and the server can not process it.
-  class InvalidRequest < StandardError; end
+  class InvalidRequest < IOError; end
   
-  # A request made to the server.
   class Request
-    # HTTP headers that should not have a +HTTP_+ prefixed to the CGI variable name
-    HTTP_LESS_HEADERS = %w(Content-Length Content-Type).freeze
-    # Methods that might contain a body.
-    BODYFUL_METHODS   = %w(POST PUT).freeze
+    MAX_HEADER        = 1024 * (80 + 32)
+    MAX_HEADER_MSG    = 'Header longer than allowed'.freeze
 
-    # We control max length of different part of the request
-    # to prevent attack and resource overflow.
-    MAX_FIELD_NAME_LENGTH   = 256
-    MAX_FIELD_VALUE_LENGTH  = 80 * 1024
-    MAX_REQUEST_URI_LENGTH  = 1024 * 12
-    MAX_FRAGMENT_LENGTH     = 1024
-    MAX_REQUEST_PATH_LENGTH = 1024
-    MAX_QUERY_STRING_LENGTH = 1024 * 10
-    MAX_HEADER_LENGTH       = 1024 * (80 + 32)
-    
-    attr_reader   :body, :params, :verb, :path
+    SERVER_SOFTWARE   = 'SERVER_SOFTWARE'.freeze
+    REMOTE_ADDR       = 'REMOTE_ADDR'.freeze
+    FORWARDED_FOR     = 'HTTP_X_FORWARDED_FOR'.freeze
 
-    # For debugging and trace.
-    # When +trace+ is set to true, +raw+ will be populated with
-    # the raw request.
-    attr_accessor :trace, :raw
-    
-    def initialize
-      @params = {
-        'GATEWAY_INTERFACE' => CGI_VERSION,
-        'HTTP_VERSION'      => HTTP_VERSION,
-        'SERVER_PROTOCOL'   => HTTP_VERSION
-      }
-      @body = StringIO.new
-      @raw = ''
-      @trace = false
-    end
-    
-    # Parse the headers and body from the +content+ buffer.
-    def parse!(content)      
-      parse_headers! content
-      parse_body!    content if BODYFUL_METHODS.include?(verb)
-    rescue InvalidRequest => e
-      raise
-    rescue Object => e
-      raise InvalidRequest, e.message
-    end
-        
-    # Parse the request headers from the socket into CGI like variables.
-    # Parse the request according to http://www.w3.org/Protocols/rfc2616/rfc2616.html.
-    # Parse env variables according to http://www.ietf.org/rfc/rfc3875.
-    # Raises an InvalidRequest error when the request is not valid, because:
-    # * no valid request line
-    # * uri, path or header is too long
-    def parse_headers!(content)
-      if matches = readline(content).match(/^([A-Z]+) (.*?)(?:#(.*))? HTTP/)
-        @verb, uri, fragment = matches[1,3]
-      else
-        raise InvalidRequest, 'No valid request line found'
-      end
-    
-      raise InvalidRequest, 'No method specified' unless @verb
-      raise InvalidRequest, 'No URI specified'    unless uri
-    
-      # Validate various length for security
-      raise InvalidRequest, 'URI too long'        if uri.size > MAX_REQUEST_URI_LENGTH
-      raise InvalidRequest, 'Fragment too long'   if fragment && fragment.size > MAX_FRAGMENT_LENGTH
+    CONTENT_LENGTH    = 'CONTENT_LENGTH'.freeze
 
-      if matches = uri.match(/^(.*?)(?:\?(.*))?$/)
-        @path, query_string = matches[1,2]
-      else
-        raise InvalidRequest, "No valid path found in #{uri}"
-      end
+    RACK_INPUT        = 'rack.input'.freeze
+    RACK_VERSION      = 'rack.version'.freeze
+    RACK_ERRORS       = 'rack.errors'.freeze
+    RACK_MULTITHREAD  = 'rack.multithread'.freeze
+    RACK_MULTIPROCESS = 'rack.multiprocess'.freeze
+    RACK_RUN_ONCE     = 'rack.run_once'.freeze
     
-      raise InvalidRequest, 'Request path too long' if @path.size > MAX_REQUEST_PATH_LENGTH
-      raise InvalidRequest, 'Query string path too long' if query_string && query_string.size > MAX_QUERY_STRING_LENGTH
-
-      @params['REQUEST_URI']    = uri
-      @params['FRAGMENT']       = fragment if fragment
-      @params['REQUEST_PATH']   =
-      @params['PATH_INFO']      = @path
-      @params['SCRIPT_NAME']    = '/'
-      @params['REQUEST_METHOD'] = @verb
-      @params['QUERY_STRING']   = query_string if query_string
+    attr_reader :env, :data, :body
     
-      # Parse all headers from 'Something-Weird' into @params['HTTP_SOMETHING_WEIRD']
-      headers_size = 0
-      until content.eof?
-        line = readline(content)
-        headers_size += line.size
+    def initialize
+      @parser   = HttpParser.new
+      @data     = ''
+      @nparsed  = 0
+      @body     = StringIO.new
+      @env      = {
+        SERVER_SOFTWARE   => SERVER,
         
-        break if ?\r == line[0] # Reached the end of the headers
-        if matches = line.match(/^([\w\-]+): (.*)$/)
-          name, value = matches[1,2]
-          raise InvalidRequest, 'Header name too long' if name.size > MAX_FIELD_NAME_LENGTH
-          raise InvalidRequest, 'Header value too long' if value.size > MAX_FIELD_VALUE_LENGTH
-          # Transform headers into a HTTP_NAME => value hash
-          prefix = HTTP_LESS_HEADERS.include?(name) ? '' : 'HTTP_'
-          params["#{prefix}#{name.upcase.gsub('-', '_')}"] = value.chomp
-        else
-          raise InvalidRequest, "Expected header : #{line}"
-        end
-      end  
-
-      raise InvalidRequest, 'Headers too long' if headers_size > MAX_HEADER_LENGTH
-    
-      @params['SERVER_NAME'] = @params['HTTP_HOST'].split(':')[0] if @params['HTTP_HOST']      
-    end
-    
-    # Parse the request body by chunks.
-    # We assume the Content-Length is valid and is the actual size of the body.
-    # This is garanteed when used behind a proxy server like Nginx:
-    #   Note that when using the HTTP Proxy Module (or even when using FastCGI), the entire client
-    #   request will be buffered in nginx before being passed on to the backend proxied servers.
-    #   As a result, upload progress meters will not function correctly if they work by measuring
-    #   the data received by the backend servers.
-    #   - http://wiki.codemongers.com/NginxHttpProxyModule
-    # On Apache w/ mod_proxy, you need to install mod_accel : http://sysoev.ru/en/
-    def parse_body!(content)
-      length = content_length
-      while @body.size < length
-        chunk = content.readpartial(CHUNK_SIZE)
-        break unless chunk && chunk.size > 0
-        @body << chunk
-      end
-      
-      @body.rewind
+        # Rack stuff
+        RACK_INPUT        => @body,
+        
+        RACK_VERSION      => [0, 1],
+        RACK_ERRORS       => STDERR,
+        
+        RACK_MULTITHREAD  => false,
+        RACK_MULTIPROCESS => false,
+        RACK_RUN_ONCE     => false
+      }
     end
     
-    def close
-      @body.close
+    def parse(data)
+      @data << data
+			
+			if @parser.finished?  # Header finished, can only be some more body
+        body << data
+			elsif @data.size > MAX_HEADER
+			  raise InvalidRequest, MAX_HEADER_MSG
+			else                  # Parse more header
+			  @nparsed = @parser.execute(@env, @data, @nparsed)
+			end
+			
+			# Check if header and body are complete
+			if @parser.finished? && body.size >= content_length
+		    body.rewind
+		    return true
+		  end
+			
+			false # Not finished, need more data
     end
     
     def content_length
-      @params['CONTENT_LENGTH'].to_i
+      @env[CONTENT_LENGTH].to_i
     end
-    
-    def to_s
-      "#{@params['REQUEST_METHOD']} #{@params['REQUEST_URI']}"
-    end
-    
-    private
-      def readline(io)
-        out = io.gets(LF)
-        @raw << out if @trace # Build a gigantic string to later print trace for the request
-        out
-      end
-  end
+  end  
 end