thin 0.5.4-x86-mswin32-60 → 0.6.0-x86-mswin32-60

data/ext/thin_parser/parser.rl

@@ -29,34 +29,50 @@
 
   action start_value { MARK(mark, fpc); }
   action write_value { 
-    parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, fpc));
+    if (parser->http_field != NULL) {
+      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, fpc));
+    }
   }
   action request_method { 
-    parser->request_method(parser->data, PTR_TO(mark), LEN(mark, fpc));
+    if (parser->request_method != NULL) {
+      parser->request_method(parser->data, PTR_TO(mark), LEN(mark, fpc));
+    }
   }
-  action request_uri { 
-    parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, fpc));
+  action request_uri {
+    if (parser->request_uri != NULL) {
+      parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, fpc));
+    }
   }
   action fragment { 
-    parser->fragment(parser->data, PTR_TO(mark), LEN(mark, fpc));
+    if (parser->fragment != NULL) {
+      parser->fragment(parser->data, PTR_TO(mark), LEN(mark, fpc));
+    }
   }
 
   action start_query {MARK(query_start, fpc); }
   action query_string { 
-    parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, fpc));
+    if (parser->query_string != NULL) {
+      parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, fpc));
+    }
   }
 
   action http_version {	
-    parser->http_version(parser->data, PTR_TO(mark), LEN(mark, fpc));
+    if (parser->http_version != NULL) {
+      parser->http_version(parser->data, PTR_TO(mark), LEN(mark, fpc));
+    }
   }
 
   action request_path {
-    parser->request_path(parser->data, PTR_TO(mark), LEN(mark,fpc));
+    if (parser->request_path != NULL) {
+      parser->request_path(parser->data, PTR_TO(mark), LEN(mark,fpc));
+    }
   }
 
   action done { 
     parser->body_start = fpc - buffer + 1; 
-    parser->header_done(parser->data, fpc + 1, pe - fpc - 1);
+    if (parser->header_done != NULL) {
+      parser->header_done(parser->data, fpc + 1, pe - fpc - 1);
+    }
     fbreak;
   }
 

data/lib/thin.rb

@@ -22,6 +22,7 @@ module Thin
   autoload :Request,      'thin/request'
   autoload :Response,     'thin/response'
   autoload :Server,       'thin/server'
+  autoload :Stats,        'thin/stats'
 end
 
 require 'rack'

data/lib/thin/cluster.rb

@@ -20,36 +20,42 @@ module Thin
     def initialize(options)
       @options = options.merge(:daemonize => true)
       @size    = @options.delete(:servers)
-      @script  = 'thin'
+      @script  = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'thin')
+      
+      if socket
+        @options.delete(:address)
+        @options.delete(:port)
+      end
     end
     
     def first_port; @options[:port]     end
-    def address;    @options[:address]  end    
+    def address;    @options[:address]  end
+    def socket;     @options[:socket]   end
     def pid_file;   File.expand_path File.join(@options[:chdir], @options[:pid]) end
     def log_file;   File.expand_path File.join(@options[:chdir], @options[:log]) end
     
     # Start the servers
     def start
-      with_each_server { |port| start_on_port port }
+      with_each_server { |port| start_server port }
     end
     
-    # Start the server on a single port
-    def start_on_port(port)
-      log "Starting #{address}:#{port} ... "
+    # Start a single server
+    def start_server(number)
+      log "Starting server on #{server_id(number)} ... "
       
-      run :start, @options, port
+      run :start, @options, number
     end
   
     # Stop the servers
     def stop
-      with_each_server { |port| stop_on_port port }
+      with_each_server { |n| stop_server n }
     end
     
-    # Stop the server running on +port+
-    def stop_on_port(port)
-      log "Stopping #{address}:#{port} ... "
+    # Stop a single server
+    def stop_server(number)
+      log "Stopping server on #{server_id(number)} ... "
       
-      run :stop, @options, port
+      run :stop, @options, number
     end
     
     # Stop and start the servers.
@@ -59,25 +65,44 @@ module Thin
       start
     end
     
-    def log_file_for(port)
-      include_port_number log_file, port
+    def server_id(number)
+      if socket
+        socket_for(number)
+      else
+        [address, number].join(':')
+      end
+    end
+    
+    def log_file_for(number)
+      include_server_number log_file, number
     end
     
-    def pid_file_for(port)
-      include_port_number pid_file, port
+    def pid_file_for(number)
+      include_server_number pid_file, number
     end
     
-    def pid_for(port)
-      File.read(pid_file_for(port)).chomp.to_i
+    def socket_for(number)
+      include_server_number socket, number
+    end
+    
+    def pid_for(number)
+      File.read(pid_file_for(number)).chomp.to_i
     end
     
     private
       # Send the command to the +thin+ script
-      def run(cmd, options, port)
-        shell_cmd = shellify(cmd, options.merge(:port => port, :pid => pid_file_for(port), :log => log_file_for(port)))
+      def run(cmd, options, number)
+        cmd_options = options.dup
+        cmd_options.merge!(:pid => pid_file_for(number), :log => log_file_for(number))
+        if socket
+          cmd_options.merge!(:socket => socket_for(number))
+        else
+          cmd_options.merge!(:port => number)
+        end
+        shell_cmd = shellify(cmd, cmd_options)
         trace shell_cmd
         ouput = `#{shell_cmd}`.chomp
-        log ouput unless ouput.empty?
+        log "  " + ouput.gsub("\n", "  \n") unless ouput.empty?
       end
       
       # Turn into a runnable shell command
@@ -93,14 +118,16 @@ module Thin
       end
       
       def with_each_server
-        @size.times { |n| yield first_port + n }
+        @size.times do |n|
+          yield socket ? n : (first_port + n)
+        end
       end
       
-      # Add the port numbers in the filename
+      # Add the server port or number in the filename
       # so each instance get its own file
-      def include_port_number(path, port)
-        raise ArgumentError, "filename '#{path}' must include an extension" unless path =~ /\./
-        path.gsub(/\.(.+)$/) { ".#{port}.#{$1}" }
+      def include_server_number(path, number)
+        ext = File.extname(path)
+        path.gsub(/#{ext}$/, ".#{number}#{ext}")
       end
   end
 end

data/lib/thin/connection.rb

@@ -4,8 +4,12 @@ module Thin
   class Connection < EventMachine::Connection
     include Logging
     
+    # Rack application served by this connection.
     attr_accessor :app
     
+    # +true+ if the connection is on a UNIX domain socket.
+    attr_accessor :unix_socket
+    
     def post_init
       @request  = Request.new
       @response = Response.new
@@ -13,7 +17,7 @@ module Thin
     
     def receive_data(data)
       trace { data }
-			process if @request.parse(data)
+      process if @request.parse(data)
     rescue InvalidRequest => e
       log "Invalid request"
       log_error e
@@ -24,8 +28,8 @@ module Thin
       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]
-
+      env[Request::REMOTE_ADDR] = remote_address(env)
+      
       # Process the request
       @response.status, @response.headers, @response.body = @app.call(env)
       
@@ -42,7 +46,20 @@ module Thin
       log_error e
       close_connection rescue nil
     ensure
+      @request.close rescue nil
       @response.close rescue nil
     end
+    
+    protected
+      def remote_address(env)
+        if remote_addr = env[Request::FORWARDED_FOR]
+          remote_addr
+        elsif @unix_socket
+          # FIXME not sure about this, does it even make sense on a UNIX socket?
+          Socket.unpack_sockaddr_un(get_peername)
+        else
+          Socket.unpack_sockaddr_in(get_peername)[1]
+        end
+      end
   end
 end

data/lib/thin/daemonizing.rb

@@ -26,7 +26,7 @@ module Thin
     end
     
     def pid
-      File.exist?(pid_file) ? open(pid_file).read : nil
+      File.exist?(pid_file) ? open(pid_file).read.to_i : nil
     end
     
     # Turns the current script into a daemon process that detaches from the console.

data/lib/thin/headers.rb

@@ -1,37 +1,24 @@
 module Thin
-  # Acts like a Hash, but allows duplicated keys
+  # 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 = {}
-      @items = []
+      @out = ''
     end
-
+    
     def []=(key, value)
-      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
-      else
+      if !@sent[key] || ALLOWED_DUPLICATES.include?(key)
         @sent[key] = true
-        @items << [key, value]
-      end
-    end
-    
-    def [](key)
-      if item = @items.assoc(key)
-        item[1]
+        @out << HEADER_FORMAT % [key, value]
       end
     end
     
-    def size
-      @items.size
-    end
-    
     def to_s
-      @items.inject('') { |out, (name, value)| out << HEADER_FORMAT % [name, value] }
+      @out
     end
   end
 end

data/lib/thin/logging.rb

@@ -13,7 +13,7 @@ module Thin
       
       # Log a message to the console if tracing is activated
       def trace(msg=nil)
-        puts msg || yield if $DEBUG && !@silent
+        puts msg || yield if ($DEBUG || $TRACE) && !@silent
       end
       
       def log_error(e)

data/lib/thin/request.rb

@@ -1,4 +1,5 @@
 require 'thin_parser'
+require 'tempfile'
 
 module Thin
   # Raised when an incoming request is not valid
@@ -7,15 +8,18 @@ module Thin
   
   # A request sent by the client to the server.
   class Request
-    MAX_HEADER        = 1024 * (80 + 32)
-    MAX_HEADER_MSG    = 'Header longer than allowed'.freeze
-
+    # 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
+    
+    # Freeze some HTTP header names
     SERVER_SOFTWARE   = 'SERVER_SOFTWARE'.freeze
     REMOTE_ADDR       = 'REMOTE_ADDR'.freeze
     FORWARDED_FOR     = 'HTTP_X_FORWARDED_FOR'.freeze
-
     CONTENT_LENGTH    = 'CONTENT_LENGTH'.freeze
-
+    
+    # Freeze some Rack header names
     RACK_INPUT        = 'rack.input'.freeze
     RACK_VERSION      = 'rack.version'.freeze
     RACK_ERRORS       = 'rack.errors'.freeze
@@ -23,7 +27,14 @@ module Thin
     RACK_MULTIPROCESS = 'rack.multiprocess'.freeze
     RACK_RUN_ONCE     = 'rack.run_once'.freeze
     
-    attr_reader :env, :data, :body
+    # CGI-like request environment variables
+    attr_reader :env
+    
+    # Unparsed data of the request
+    attr_reader :data
+    
+    # Request body
+    attr_reader :body
     
     def initialize
       @parser   = HttpParser.new
@@ -45,28 +56,46 @@ module Thin
       }
     end
     
+    # Parse a chunk of data into the request environment
+    # Raises a +InvalidRequest+ if invalid.
+    # Returns +true+ if the parsing is complete.
     def parse(data)
       @data << data
-			
-			if @parser.finished?                    # Header finished, can only be some more body
+      
+      if @parser.finished?                    # Header finished, can only be some more body
         body << data
-			elsif @data.size > MAX_HEADER           # Oho! very big header, must be a mean person
-			  raise InvalidRequest, MAX_HEADER_MSG
-			else                                    # Parse more header using the super parser
-			  @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 # Request is fully parsed
-		  end
-			
-			false # Not finished, need more data
+      else                                    # Parse more header using the super parser
+        @nparsed = @parser.execute(@env, @data, @nparsed)
+        # Transfert to a tempfile if body is very big
+        move_body_to_tempfile if @parser.finished? && content_length > MAX_BODY
+      end
+      
+      # Check if header and body are complete
+      if @parser.finished? && @body.size >= content_length
+        @body.rewind
+        return true # Request is fully parsed
+      end
+      
+      false # Not finished, need more data
     end
     
+    # Expected size of the body
     def content_length
       @env[CONTENT_LENGTH].to_i
     end
+    
+    def close
+      @body.close if @body === Tempfile
+    end
+    
+    
+    private
+      def move_body_to_tempfile
+        current_body = @body
+        @body = Tempfile.new(BODY_TMPFILE)
+        @body.binmode
+        @body << current_body unless current_body.size.zero?
+        @env[RACK_INPUT] = @body
+      end
   end  
 end

data/lib/thin/response.rb

@@ -36,7 +36,7 @@ module Thin
     
     def headers=(key_value_pairs)
       key_value_pairs.each do |k, vs|
-        vs.each { |v| @headers[k] = v.chomp }
+        vs.each_line { |v| @headers[k] = v.chomp }
       end
     end
     
@@ -45,7 +45,9 @@ module Thin
       @body.close if @body.respond_to?(:close)
     end
     
-    # Yields each chunk of the response
+    # Yields each chunk of the response.
+    # To control the size of each chunk
+    # define your own +each+ method on +body+.
     def each
       yield head
       @body.each do |chunk|

data/lib/thin/server.rb

@@ -12,69 +12,110 @@ module Thin
     include Logging
     include Daemonizable
     
-    # Addresse and port on which the server is listening for connections.
+    # Address and port on which the server is listening for connections.
     attr_accessor :port, :host
     
-    # App called with the request that produce the response.
+    # UNIX domain socket on which the server is listening for connections.
+    attr_accessor :socket
+    
+    # App called with the request that produces the response.
     attr_accessor :app
     
     # Maximum time for incoming data to arrive
     attr_accessor :timeout
     
-    # Creates a new server binded to <tt>host:port</tt>
-    # that will pass request to +app+.
-    def initialize(host, port, app=nil)
-      @host       = host
-      @port       = port.to_i
+    # Creates a new server bound to <tt>host:port</tt>
+    # or to +socket+ that will pass request to +app+.
+    # If +host_or_socket+ contains a <tt>/</tt> it is assumed
+    # to be a UNIX domain socket filename.
+    # If a block is passed, a <tt>Rack::Builder</tt> instance
+    # will be passed to build the +app+.
+    # 
+    #   Server.new '0.0.0.0', 3000 do
+    #     use Rack::CommonLogger
+    #     use Rack::ShowExceptions
+    #     map "/lobster" do
+    #       use Rack::Lint
+    #       run Rack::Lobster.new
+    #     end
+    #   end.start
+    #
+    def initialize(host_or_socket, port=3000, app=nil, &block)
+      if host_or_socket.include?('/')
+        @socket = host_or_socket
+      else
+        @host     = host_or_socket
+        @port     = port.to_i
+      end
       @app        = app
       @timeout    = 60 # sec
-    end
-    
-    # Starts the handlers.
-    def start
-      raise ArgumentError, "app required" unless @app
       
-      log   ">> Thin web server (v#{VERSION::STRING} codename #{VERSION::CODENAME})"
-      trace ">> Tracing ON"
+      @app = Rack::Builder.new(&block).to_app if block
     end
     
-    # Start the server and listen for connections
-    def start!
-      start
-      listen!
+    def self.start(*args, &block)
+      new(*args, &block).start!
     end
     
-    # Start listening for connections
-    def listen!
-      trap('INT')  { stop }
-			trap('TERM') { stop! }
+    # Start the server and listen for connections
+    def start
+      raise ArgumentError, "app required" unless @app
       
+      trap('INT')  { stop }
+      trap('TERM') { stop! }
+            
       # See http://rubyeventmachine.com/pub/rdoc/files/EPOLL.html
       EventMachine.epoll
-
-			EventMachine.run do
-				begin
-				  log ">> Listening on #{@host}:#{@port}, CTRL+C to stop"
-					EventMachine.start_server(@host, @port, Connection) do |connection|
-					  connection.comm_inactivity_timeout = @timeout
-					  connection.app                     = @app
-					  connection.silent                  = @silent
-					end
-				rescue StopServer
-					EventMachine.stop_event_loop
-				end
-			end
+      
+      log   ">> Thin web server (v#{VERSION::STRING} codename #{VERSION::CODENAME})"
+      trace ">> Tracing ON"
+      
+      EventMachine.run do
+        begin
+          start_server
+        rescue StopServer
+          stop
+        end
+      end
     end
+    alias :start! :start
     
-    
+    # Stops the server by stopping the listening loop.
     def stop
       EventMachine.stop_event_loop
     rescue
       warn "Error stopping : #{$!}"
     end
     
+    # Stops the server by raising an error.
     def stop!
       raise StopServer
     end
+    
+    protected
+      def start_server
+        if @socket
+          start_server_on_socket
+        else
+          start_server_on_host
+        end
+      end
+      
+      def start_server_on_host
+        log ">> Listening on #{@host}:#{@port}, CTRL+C to stop"
+        EventMachine.start_server(@host, @port, Connection, &method(:initialize_connection))
+      end
+      
+      def start_server_on_socket
+        log ">> Listening on #{@socket}, CTRL+C to stop"
+        EventMachine.start_unix_domain_server(@socket, Connection, &method(:initialize_connection))
+      end
+      
+      def initialize_connection(connection)
+        connection.comm_inactivity_timeout = @timeout
+        connection.app                     = @app
+        connection.silent                  = @silent
+        connection.unix_socket             = !@socket.nil?
+      end
   end
 end