thin 0.6.4 → 0.7.0

data/lib/thin/request.rb

@@ -13,11 +13,16 @@ module Thin
     MAX_BODY          = 1024 * (80 + 32)
     BODY_TMPFILE      = 'thin-body'.freeze
     
-    # Freeze some HTTP header names
+    # Freeze some HTTP header names & values
     SERVER_SOFTWARE   = 'SERVER_SOFTWARE'.freeze
+    HTTP_VERSION      = 'HTTP_VERSION'.freeze
+    HTTP_1_0          = 'HTTP/1.0'.freeze
     REMOTE_ADDR       = 'REMOTE_ADDR'.freeze
     FORWARDED_FOR     = 'HTTP_X_FORWARDED_FOR'.freeze
     CONTENT_LENGTH    = 'CONTENT_LENGTH'.freeze
+    CONNECTION        = 'HTTP_CONNECTION'.freeze
+    KEEP_ALIVE_REGEXP = /keep-alive/i
+    NOT_CLOSE_REGEXP  = /[^(close)]/i
     
     # Freeze some Rack header names
     RACK_INPUT        = 'rack.input'.freeze
@@ -90,7 +95,31 @@ module Thin
       @env[CONTENT_LENGTH].to_i
     end
     
-    # Close any resource used by the response
+    # Returns +true+ if the client expect 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
+      
+      # 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] =~ NOT_CLOSE_REGEXP
+      end
+    end
+    
+    def remote_address=(address)
+      @env[REMOTE_ADDR] = address
+    end
+    
+    def forwarded_for
+      @env[FORWARDED_FOR]
+    end
+    
+    # Close any resource used by the request
     def close
       @body.delete if @body.class == Tempfile
     end    

data/lib/thin/response.rb

@@ -1,9 +1,11 @@
 module Thin
   # A response sent to the client.
   class Response
-    CONNECTION = 'Connection'.freeze
-    SERVER     = 'Server'.freeze
-    CLOSE      = 'close'.freeze
+    CONNECTION     = 'Connection'.freeze
+    CLOSE          = 'close'.freeze
+    KEEP_ALIVE     = 'keep-alive'.freeze
+    SERVER         = 'Server'.freeze
+    CONTENT_LENGTH = 'Content-Length'.freeze
     
     # Status code
     attr_accessor :status
@@ -15,19 +17,21 @@ module Thin
     attr_reader   :headers
     
     def initialize
-      @headers = Headers.new
-      @status  = 200
+      @headers    = Headers.new
+      @status     = 200
+      @persistent = false
     end
     
     # String representation of the headers
     # to be sent in the response.
     def headers_output
-      @headers[CONNECTION] = CLOSE
+      # Set default headers
+      @headers[CONNECTION] = persistent? ? KEEP_ALIVE : CLOSE
       @headers[SERVER]     = Thin::SERVER
       
       @headers.to_s
     end
-    
+        
     # Top header of the response,
     # containing the status code and response headers.
     def head
@@ -77,5 +81,16 @@ module Thin
         yield chunk
       end
     end
+    
+    # Tell the client the connection should stay open
+    def persistent!
+      @persistent = true
+    end
+    
+    # Persistent connection must be requested as keep-alive
+    # from the server and have a Content-Length.
+    def persistent?
+      @persistent && @headers.has_key?(CONTENT_LENGTH)
+    end    
   end
 end

data/lib/thin/runner.rb

@@ -32,13 +32,15 @@ module Thin
       
       # Default options values
       @options = {
-        :chdir       => Dir.pwd,
-        :environment => 'development',
-        :address     => '0.0.0.0',
-        :port        => 3000,
-        :timeout     => 60,
-        :log         => 'log/thin.log',
-        :pid         => 'tmp/pids/thin.pid'
+        :chdir                => Dir.pwd,
+        :environment          => 'development',
+        :address              => '0.0.0.0',
+        :port                 => Server::DEFAULT_PORT,
+        :timeout              => Server::DEFAULT_TIMEOUT,
+        :log                  => 'log/thin.log',
+        :pid                  => 'tmp/pids/thin.pid',
+        :max_conns            => Server::DEFAULT_MAXIMUM_CONNECTIONS,
+        :max_persistent_conns => Server::DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS
       }
       
       parse!
@@ -59,13 +61,12 @@ module Thin
                                         "(default: #{@options[:address]})")             { |host| @options[:address] = host }
         opts.on("-p", "--port PORT", "use PORT (default: #{@options[:port]})")          { |port| @options[:port] = port.to_i }
         opts.on("-S", "--socket FILE", "bind to unix domain socket")                    { |file| @options[:socket] = file }
+        opts.on("-y", "--swiftiply [KEY]", "Run using swiftiply")                       { |key| @options[:swiftiply] = key }
         opts.on("-e", "--environment ENV", "Rails environment " +                       
                                            "(default: #{@options[:environment]})")      { |env| @options[:environment] = env }
         opts.on("-c", "--chdir DIR", "Change to dir before starting")                   { |dir| @options[:chdir] = File.expand_path(dir) }
-        opts.on("-t", "--timeout SEC", "Request or command timeout in sec " +            
-                                       "(default: #{@options[:timeout]})")              { |sec| @options[:timeout] = sec.to_i }
         opts.on("-r", "--rackup FILE", "Load a Rack config file instead of " +
-                                       "the Rails adapter")                             { |file| @options[:rackup] = file }
+                                       "Rails adapter")                                 { |file| @options[:rackup] = file }
         opts.on(      "--prefix PATH", "Mount the app under PATH (start with /)")       { |path| @options[:prefix] = path }
         opts.on(      "--stats PATH", "Mount the Stats adapter under PATH")             { |path| @options[:stats] = path }
         
@@ -90,13 +91,25 @@ module Thin
           opts.on(      "--all [DIR]", "Send command to each config files in DIR")      { |dir| @options[:all] = dir } if Thin.linux?
         end
         
+        opts.separator ""
+        opts.separator "Tuning options:"
+        
+        opts.on("-t", "--timeout SEC", "Request or command timeout in sec " +            
+                                       "(default: #{@options[:timeout]})")              { |sec| @options[:timeout] = sec.to_i }
+        opts.on(      "--max-conns NUM", "Maximum number of connections " +
+                                         "(default: #{@options[:max_conns]})",
+                                         "Might require sudo to set higher then 1024")  { |num| @options[:max_conns] = num.to_i } unless Thin.win?
+        opts.on(      "--max-persistent-conns NUM",
+                                       "Maximum number of persistent connections",
+                                       "(default: #{@options[:max_persistent_conns]})") { |num| @options[:max_persistent_conns] = num.to_i }
+        
         opts.separator ""
         opts.separator "Common options:"
 
-        opts.on_tail("-D", "--debug", "Set debbuging on")       { $DEBUG = true }
-        opts.on_tail("-V", "--trace", "Set tracing on")         { $TRACE = true }
-        opts.on_tail("-h", "--help", "Show this message")       { puts opts; exit }
-        opts.on_tail('-v', '--version', "Show version")         { puts Thin::SERVER; exit }
+        opts.on_tail("-D", "--debug", "Set debbuging on")                               { Logging.debug = true }
+        opts.on_tail("-V", "--trace", "Set tracing on (log raw request/response)")      { Logging.trace = true }
+        opts.on_tail("-h", "--help", "Show this message")                               { puts opts; exit }
+        opts.on_tail('-v', '--version', "Show version")                                 { puts Thin::SERVER; exit }
       end
     end
     

data/lib/thin/server.rb

@@ -45,6 +45,12 @@ module Thin
     include Logging
     include Daemonizable
     extend  Forwardable
+    
+    # Default values
+    DEFAULT_TIMEOUT                        = 30 #sec
+    DEFAULT_PORT                           = 3000
+    DEFAULT_MAXIMUM_CONNECTIONS            = 1024
+    DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS = 512
         
     # Application (Rack adapter) called with the request that produces the response.
     attr_accessor :app
@@ -52,17 +58,26 @@ module Thin
     # Connector handling the connections to the clients.
     attr_accessor :connector
     
+    # Maximum number of file or socket descriptors that the server may open.
+    attr_accessor :maximum_connections
+    
     # Maximum number of seconds for incoming data to arrive before the connection
     # is dropped.
     def_delegators :@connector, :timeout, :timeout=
     
+    # Maximum number of connection that can be persistent at the same time.
+    # Most browser never close the connection so most of the time they are closed
+    # when the timeout occur. If we don't control the number of persistent connection,
+    # if would be very easy to overflow the server for a DoS attack.
+    def_delegators :@connector, :maximum_persistent_connections, :maximum_persistent_connections=
+    
     # Address and port on which the server is listening for connections.
     def_delegators :@connector, :host, :port
     
     # UNIX domain socket on which the server is listening for connections.
     def_delegator :@connector, :socket
     
-    def initialize(host_or_socket_or_connector, port=3000, app=nil, &block)
+    def initialize(host_or_socket_or_connector, port=DEFAULT_PORT, app=nil, &block)
       # Try to intelligently select which connector to use.
       @connector = case
       when host_or_socket_or_connector.is_a?(Connectors::Connector)
@@ -73,11 +88,19 @@ module Thin
         Connectors::TcpServer.new(host_or_socket_or_connector, port.to_i)
       end
 
-      @connector.server = self
       @app              = app
+      @connector.server = self
+      
+      # Set defaults
+      @maximum_connections                      = DEFAULT_MAXIMUM_CONNECTIONS
+      @connector.maximum_persistent_connections = DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS
+      @connector.timeout                        = DEFAULT_TIMEOUT
       
       # Allow using Rack builder as a block
       @app = Rack::Builder.new(&block).to_app if block
+      
+      # If in debug mode, wrap in logger adapter
+      @app = Rack::CommonLogger.new(@app) if Logging.debug?
     end
     
     # Lil' shortcut to turn this:
@@ -91,7 +114,7 @@ module Thin
     def self.start(*args, &block)
       new(*args, &block).start!
     end
-    
+        
     # Start the server and listen for connections.
     # Also register signals:
     # * INT calls +stop+ to shutdown gracefully.
@@ -99,16 +122,17 @@ module Thin
     def start
       raise ArgumentError, 'app required' unless @app
       
-      trap('INT')  { stop }
-      trap('TERM') { stop! }
+      setup_signals
             
       # See http://rubyeventmachine.com/pub/rdoc/files/EPOLL.html
       EventMachine.epoll
       
       log   ">> Thin web server (v#{VERSION::STRING} codename #{VERSION::CODENAME})"
+      debug ">> Debugging ON"
       trace ">> Tracing ON"
-      
+            
       log ">> Listening on #{@connector}, CTRL+C to stop"
+      
       @running = true
       EventMachine.run { @connector.connect }
     end
@@ -160,15 +184,39 @@ module Thin
       @running
     end
     
+    # Set the maximum number of socket descriptors that the server may open.
+    # The process needs to have required privilege to set it higher the 1024 on
+    # some systems.
+    def set_descriptor_table_size!
+      return 0 if Thin.win? # Not supported on Windows
+      
+      requested_maximum_connections = @maximum_connections
+      @maximum_connections = EventMachine.set_descriptor_table_size(requested_maximum_connections)
+
+      log ">> Setting maximum connections to #{@maximum_connections}"
+      if @maximum_connections < requested_maximum_connections
+        log "!! Maximum connections smaller then requested, " +
+            "run with sudo to set higher"
+      end
+
+      @maximum_connections
+    end
+    
     protected            
       def wait_for_connections_and_stop
         if @connector.empty?
           stop!
           true
         else
-          log ">> Waiting for #{@connector.size} connection(s) to finish, CTRL+C to force stop"
+          log ">> Waiting for #{@connector.size} connection(s) to finish, can take up to #{timeout} sec, CTRL+C to stop now"
           false
         end
       end
+      
+      def setup_signals
+        trap('QUIT') { stop }  unless Thin.win?
+        trap('INT')  { stop! }
+        trap('TERM') { stop! }
+      end      
   end
 end

data/lib/thin/version.rb

@@ -5,12 +5,12 @@ module Thin
   
   module VERSION #:nodoc:
     MAJOR    = 0
-    MINOR    = 6
-    TINY     = 4
+    MINOR    = 7
+    TINY     = 0
     
     STRING   = [MAJOR, MINOR, TINY].join('.')
     
-    CODENAME = 'Sexy Lobster'
+    CODENAME = 'Spherical Cow'
   end
   
   NAME    = 'thin'.freeze

data/spec/command_spec.rb

@@ -2,13 +2,12 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe Command do
   before do
-    @command = Command.new(:start, :port => 3000, :daemonize => true, :log => 'hi.log', :pid => nil)
-    @command.silent = true
+    @command = Command.new(:start, :port => 3000, :daemonize => true, :log => 'hi.log')
   end
   
   it 'should shellify command' do
     out = @command.shellify
     out.should include('--port=3000', '--daemonize', '--log="hi.log"', 'thin start --')
-    out.should_not include('--pid=')
+    out.should_not include('--pid')
   end
 end

data/spec/connection_spec.rb

@@ -3,7 +3,6 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe Connection do
   before do
     @connection = Connection.new(mock('EM', :null_object => true))
-    @connection.silent = true
     @connection.post_init
     @connection.app = proc do |env|
       [200, {}, ['']]
@@ -55,4 +54,19 @@ describe Connection do
     @connection.stub!(:get_peername).and_return("\020\002?E\177\000\000\001\000\000\000\000\000\000\000\000")
     @connection.remote_address.should == '127.0.0.1'
   end
+  
+  it "should not be persistent" do
+    @connection.should_not be_persistent
+  end
+
+  it "should be persistent when response is and allowed" do
+    @connection.response.stub!(:persistent?).and_return(true)
+    @connection.can_persist!
+    @connection.should be_persistent
+  end
+
+  it "should not be persistent when response is but not allowed" do
+    @connection.response.persistent!
+    @connection.should_not be_persistent
+  end
 end

data/spec/connectors/swiftiply_client_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Connectors::SwiftiplyClient do
+  before do
+    @connector = Connectors::SwiftiplyClient.new('0.0.0.0', 3333)
+    @connector.server = mock('server', :null_object => true)
+  end
+  
+  it "should connect" do
+    EventMachine.run do
+      @connector.connect
+      EventMachine.stop
+    end
+  end
+  
+  it "should disconnect" do
+    EventMachine.run do
+      @connector.connect
+      @connector.disconnect
+      EventMachine.stop
+    end
+  end
+end
+
+describe SwiftiplyConnection do
+  before do
+    @connection = SwiftiplyConnection.new(nil)
+    @connection.connector = Connectors::SwiftiplyClient.new('0.0.0.0', 3333)
+    @connection.connector.server = mock('server', :null_object => true)
+  end
+  
+  it do
+    @connection.should be_persistent
+  end
+  
+  it "should send handshake on connection_completed" do
+    @connection.should_receive(:send_data).with('swiftclient000000000d0500')
+    @connection.connection_completed
+  end
+  
+  it "should reconnect on unbind" do
+    @connection.connector.stub!(:running?).and_return(true)
+    @connection.stub!(:rand).and_return(0) # Make sure we don't wait
+    
+    @connection.should_receive(:reconnect).with('0.0.0.0', 3333)
+    
+    EventMachine.run do
+      @connection.unbind
+      EventMachine.add_timer(0) { EventMachine.stop }      
+    end
+  end
+  
+  it "should not reconnect when not running" do
+    @connection.connector.stub!(:running?).and_return(false)
+    EventMachine.should_not_receive(:add_timer)
+    @connection.unbind
+  end
+  
+  it "should have a host_ip" do
+    @connection.send(:host_ip).should == [0, 0, 0, 0]
+  end
+  
+  it "should generate swiftiply_handshake based on key" do
+    @connection.send(:swiftiply_handshake, 'key').should == 'swiftclient000000000d0503key'
+  end
+end

data/spec/controllers/cluster_spec.rb

@@ -11,7 +11,6 @@ describe Cluster, "with host and port" do
                            :log => 'thin.log',
                            :pid => 'thin.pid'
                           )
-    @cluster.silent = true
   end
     
   it 'should include port number in file names' do
@@ -19,10 +18,6 @@ describe Cluster, "with host and port" do
     @cluster.send(:include_server_number, 'thin.pid', 3000).should == 'thin.3000.pid'
   end
   
-  it "should exclude :servers option" do
-    @cluster.options.should_not have_key(:servers)
-  end
-    
   it 'should call each server' do
     calls = []
     @cluster.send(:with_each_server) do |port|
@@ -64,7 +59,6 @@ describe Cluster, "with UNIX socket" do
                            :log => 'thin.log',
                            :pid => 'thin.pid'
                           )
-    @cluster.silent = true
   end
   
   it 'should include socket number in file names' do
@@ -119,12 +113,6 @@ describe Cluster, "controlling only one server" do
                            :pid => 'thin.pid',
                            :only => 3001
                           )
-    @cluster.silent = true
-  end
-  
-  it "should exclude :servers and :only options" do
-    @cluster.options.should_not have_key(:servers)
-    @cluster.options.should_not have_key(:only)
   end
   
   it 'should call only specified server' do
@@ -145,4 +133,47 @@ describe Cluster, "controlling only one server" do
     def options_for_port(port)
       { :daemonize => true, :log => "thin.#{port}.log", :timeout => 10, :address => "0.0.0.0", :port => port, :pid => "thin.#{port}.pid", :chdir => "/rails_app" }
     end
+end
+
+describe Cluster, "with Swiftiply" do
+  before do
+    @cluster = Cluster.new(:chdir => '/rails_app',
+                           :address => '0.0.0.0',
+                           :port => 3000, 
+                           :servers => 3,
+                           :timeout => 10,
+                           :log => 'thin.log',
+                           :pid => 'thin.pid',
+                           :swiftiply => true
+                          )
+  end
+  
+  it 'should call each server' do
+    calls = []
+    @cluster.send(:with_each_server) do |n|
+      calls << n
+    end
+    calls.should == [0, 1, 2]
+  end
+  
+  it 'should start each server' do
+    Command.should_receive(:run).with(:start, options_for_swiftiply(0))
+    Command.should_receive(:run).with(:start, options_for_swiftiply(1))
+    Command.should_receive(:run).with(:start, options_for_swiftiply(2))
+
+    @cluster.start
+  end
+
+  it 'should stop each server' do
+    Command.should_receive(:run).with(:stop, options_for_swiftiply(0))
+    Command.should_receive(:run).with(:stop, options_for_swiftiply(1))
+    Command.should_receive(:run).with(:stop, options_for_swiftiply(2))
+
+    @cluster.stop
+  end
+  
+  private
+    def options_for_swiftiply(number)
+      { :address => '0.0.0.0', :port => 3000, :daemonize => true, :log => "thin.#{number}.log", :timeout => 10, :pid => "thin.#{number}.pid", :chdir => "/rails_app", :swiftiply => true }
+    end
 end