thin 0.3.0

data/lib/thin/rails.rb

@@ -0,0 +1,44 @@
+module Thin
+  # Forwards incoming request to Rails dispatcher.
+  class RailsHandler < Handler
+    def initialize(pwd, env='development')
+      @env = env
+      @pwd = pwd
+    end
+    
+    def start
+      ENV['RAILS_ENV'] = @env
+      
+      require "#{@pwd}/config/environment"
+      require 'dispatcher'
+    end
+    
+    def process(request, response)
+      # Rails doesn't serve static files
+      # TODO handle Rails page caching
+      return false if File.file?(File.join(@pwd, 'public', request.path))
+      
+      cgi = CGIWrapper.new(request, response)
+      
+      Dispatcher.dispatch(cgi, ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, response.body)
+      
+      # This finalizes the output using the proper HttpResponse way
+      cgi.out("text/html", true) {""}
+    end
+    
+    def to_s
+      "Rails on #{@pwd} (env=#{@env})"
+    end
+  end
+  
+  # Serve the Rails application in the current directory.
+  class RailsServer < Server
+    def initialize(address, port, environment='development', cwd='.')
+      super address, port,
+            # Let Rails handle his thing and ignore files
+            Thin::RailsHandler.new(cwd, environment),
+            # Serve static files
+            Thin::DirHandler.new(File.join(cwd, 'public'))
+    end
+  end
+end

data/lib/thin/recipes.rb

@@ -0,0 +1,36 @@
+# == Set of Capistrano 2 recipes
+# To use, add on top of your Capfile file:
+#  load 'config/deploy'
+#  # ...
+#  require 'thin'
+#  require 'thin/recipes'
+#
+# === Configurable parameters
+# You can configure some parameters but it should work out of the box.
+# Path to the thin_cluster script, don't need to change this if
+# you installed thin as a gem on the server.
+#  set :thin_cluster, "thin_cluster"
+# Location of the config file:
+#  set :thin_config, "#{release_path}/config/thin.yml"
+
+Capistrano::Configuration.instance.load do
+  set :thin_cluster, "thin_cluster"
+  set :thin_config, "#{current_path}/config/thin.yml"
+
+  namespace :deploy do  
+    desc 'Start Thin processes on the app server.'
+    task :start, :roles => :app do
+      run "#{thin_cluster} start -C #{thin_config}"
+    end
+  
+    desc 'Stop the Thin processes on the app server.'
+    task :stop, :roles => :app do
+      run "#{thin_cluster} stop -C #{thin_config}"
+    end
+
+    desc 'Restart the Thin processes on the app server by starting and stopping the cluster.'
+    task :restart, :roles => :app do
+      run "#{thin_cluster} restart -C #{thin_config}"
+    end
+  end
+end

data/lib/thin/request.rb

@@ -0,0 +1,132 @@
+module Thin
+  # Raised when an incoming request is not valid
+  # and the server can not process it.
+  class InvalidRequest < StandardError; end
+  
+  # A request made to the server.
+  class Request
+    HTTP_LESS_HEADERS = %w(Content-Length Content-Type).freeze
+    BODYFUL_METHODS   = %w(POST PUT).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
+    attr_accessor :trace, :raw # For debugging and trace
+    
+    def initialize
+      @params = {
+        'GATEWAY_INTERFACE' => 'CGI/1.2',
+        'HTTP_VERSION'      => 'HTTP/1.1',
+        'SERVER_PROTOCOL'   => 'HTTP/1.1'
+      }
+      @body = StringIO.new
+      @raw = ''
+      @trace = false
+    end
+    
+    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
+    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
+    
+      # Validation 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
+
+      if matches = uri.match(/^(.*?)(?:\?(.*))?$/)
+        @path, query_string = matches[1,2]
+      else
+        raise InvalidRequest, "No valid path found in #{uri}"
+      end
+    
+      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
+    
+      headers_size = 0
+      until content.eof?
+        line = readline(content)
+        headers_size += line.size
+        if [?\r, ?\n].include?(line[0])
+          break # Reached the end of the headers
+        elsif 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
+    
+    def parse_body!(content)
+      # Parse by chunks
+      length = content_length
+      while @body.size < length
+        chunk = content.readpartial(CHUNK_SIZE)
+        break unless chunk && chunk.size > 0
+        @body << chunk
+      end
+      
+      @body.rewind
+    end
+    
+    def close
+      @body.close
+    end
+    
+    def content_length
+      @params['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

data/lib/thin/response.rb

@@ -0,0 +1,54 @@
+module Thin
+  # A response sent to the client.
+  class Response
+    CONNECTION = 'Connection'.freeze
+    CLOSE = 'close'.freeze
+    
+    attr_accessor :body, :headers, :status
+    
+    def initialize
+      @headers = Headers.new
+      @body = StringIO.new
+      @status = 200
+    end
+    
+    def content_type=(type)
+      @headers[CONTENT_TYPE] = type
+    end
+    
+    def content_type
+      @headers[CONTENT_TYPE]
+    end
+    
+    def headers_output
+      @headers[CONTENT_LENGTH] = @body.size
+      @headers[CONNECTION] = CLOSE
+      @headers.to_s
+    end
+    
+    def head
+      "HTTP/1.1 #{@status} #{HTTP_STATUS_CODES[@status.to_i]}\r\n#{headers_output}\r\n"
+    end
+    
+    def write(socket)
+      socket << head
+      @body.rewind
+      socket << @body.read
+    end
+    
+    def close
+      @body.close
+    end
+    
+    def start(status)
+      @status = status
+      yield @headers, @body
+    end
+    
+    def to_s
+      out = ''
+      write out
+      out
+    end
+  end
+end

data/lib/thin/server.rb

@@ -0,0 +1,141 @@
+require 'socket'
+
+module Thin
+  # The Thin HTTP server used to served request.
+  # It listen for incoming request on a given port
+  # and forward all request to all the handlers in the order
+  # they were registered.
+  # Based on HTTP 1.1 protocol specs
+  # http://www.w3.org/Protocols/rfc2616/rfc2616.html
+  class Server
+    include Logging
+    include Daemonizable
+    
+    # Addresse and port on which the server is listening for connections.
+    attr_accessor :port, :host
+    
+    # List of handlers to process the request in the order they are given.
+    attr_accessor :handlers
+    
+    # Maximum time for a request to be red and parsed.
+    attr_accessor :timeout
+    
+    # Creates a new server binded to <tt>host:port</tt>
+    # that will pass request to +handlers+.
+    def initialize(host, port, *handlers)
+      @host       = host
+      @port       = port
+      @handlers   = handlers
+      @timeout    = 60     # sec, max time to read and parse a request
+      @trace      = false
+
+      @stop       = true   # true is server is stopped
+      @processing = false  # true is processing a request
+
+      @socket     = TCPServer.new(host, port)
+    end
+    
+    # Starts the handlers.
+    def start
+      log   ">> Thin web server (v#{VERSION})"
+      trace ">> Tracing ON"
+
+      @handlers.each do |handler|
+        log ">> Starting #{handler} ..."
+        handler.start
+      end
+    end
+    
+    # Start the server and listen for connections
+    def start!
+      start
+      listen!
+    end
+    
+    # Start listening for connections
+    def listen!
+      @stop = false
+      trap('INT') do
+        log '>> Caught INT signal, stopping ...'
+        stop
+      end
+      
+      log ">> Listening on #{host}:#{port}, CTRL+C to stop"
+      until @stop
+        @processing = false
+        client = @socket.accept rescue nil
+        break if @socket.closed? || client.nil?
+        @processing = true
+        process(client)
+      end
+    ensure
+      @socket.close unless @socket.closed? rescue nil
+    end
+    
+    # Process one request from a client 
+    def process(client)
+      return if client.eof?
+      
+      trace { 'Request started'.center(80, '=') }
+
+      request  = Request.new
+      response = Response.new
+      
+      request.trace = @trace
+      trace { ">> Tracing request parsing ... " }
+
+      # Parse the request checking for timeout to prevent DOS attacks
+      Timeout.timeout(@timeout) { request.parse!(client) }
+      trace { request.raw }
+      
+      # Add client info to the request env
+      request.params['REMOTE_ADDR'] = client.peeraddr.last
+      
+      # Add server info to the request env
+      request.params['SERVER_SOFTWARE'] = SERVER
+      request.params['SERVER_PORT']     = @port.to_s
+      
+      served = false
+      @handlers.each do |handler|
+        served = handler.process(request, response)
+        break if served
+      end
+      
+      if served
+        trace { ">> Sending response:\n" + response.to_s }
+        response.write client
+      else
+        client << ERROR_404_RESPONSE
+      end
+      
+      trace { 'Request finished'.center(80, '=') }
+
+    rescue EOFError, Errno::ECONNRESET, Errno::EPIPE, Errno::EINVAL, Errno::EBADF
+      # Can't do anything sorry, closing the socket in the ensure block
+    rescue InvalidRequest => e
+      log "Invalid request: #{e.message}"
+      trace { e.backtrace.join("\n") }
+      client << ERROR_400_RESPONSE rescue nil
+    rescue Object => e
+      log "Unexpected error while processing request: #{e.message}"
+      log e.backtrace.join("\n")
+    ensure
+      request.close  if request            rescue nil
+      response.close if response           rescue nil
+      client.close   unless client.closed? rescue nil
+    end
+    
+    # Stop the server from accepting new request.
+    # If a request is processing, wait for this to finish
+    # and shutdown the server.
+    def stop
+      @stop = true
+      stop! unless @processing  # Not processing a request, so we can stop now
+    end
+    
+    # Force the server to stop right now!
+    def stop!
+      @socket.close rescue nil # break the accept loop by closing the socket
+    end
+  end
+end

data/lib/thin/statuses.rb

@@ -0,0 +1,43 @@
+module Thin
+  # Every standard HTTP code mapped to the appropriate message.
+  # Stolent from Mongrel.
+  HTTP_STATUS_CODES = {  
+    100  => 'Continue', 
+    101  => 'Switching Protocols', 
+    200  => 'OK', 
+    201  => 'Created', 
+    202  => 'Accepted', 
+    203  => 'Non-Authoritative Information', 
+    204  => 'No Content', 
+    205  => 'Reset Content', 
+    206  => 'Partial Content', 
+    300  => 'Multiple Choices', 
+    301  => 'Moved Permanently', 
+    302  => 'Moved Temporarily', 
+    303  => 'See Other', 
+    304  => 'Not Modified', 
+    305  => 'Use Proxy', 
+    400  => 'Bad Request', 
+    401  => 'Unauthorized', 
+    402  => 'Payment Required', 
+    403  => 'Forbidden', 
+    404  => 'Not Found', 
+    405  => 'Method Not Allowed', 
+    406  => 'Not Acceptable', 
+    407  => 'Proxy Authentication Required', 
+    408  => 'Request Time-out', 
+    409  => 'Conflict', 
+    410  => 'Gone', 
+    411  => 'Length Required', 
+    412  => 'Precondition Failed', 
+    413  => 'Request Entity Too Large', 
+    414  => 'Request-URI Too Large', 
+    415  => 'Unsupported Media Type', 
+    500  => 'Internal Server Error', 
+    501  => 'Not Implemented', 
+    502  => 'Bad Gateway', 
+    503  => 'Service Unavailable', 
+    504  => 'Gateway Time-out', 
+    505  => 'HTTP Version not supported'
+  }
+end