thin 0.7.1 → 0.8.0

data/lib/thin/server.rb

@@ -1,6 +1,6 @@
 module Thin
   # The uterly famous Thin HTTP server.
-  # It listen for incoming request through a given backend
+  # It listen for incoming request through a given +backend+
   # and forward all request to +app+.
   #
   # == TCP server
@@ -14,14 +14,13 @@ module Thin
   # as the first argument. Eg.: /tmp/thin.sock. If the first argument contains a <tt>/</tt>
   # it will be assumed to be a UNIX socket. 
   #
-  #   Thin::Server.start('/tmp/thin.sock', nil, app)
+  #   Thin::Server.start('/tmp/thin.sock', app)
   #
   # == Using a custom backend
   # You can implement your own way to connect the server to its client by creating your
-  # own Backend class and pass it as the first argument.
+  # own Backend class and pass it as the :backend option.
   #
-  #   backend = Thin::Backends::MyFancyBackend.new('galaxy://faraway:1345')
-  #   Thin::Server.start(backend, nil, app)
+  #   Thin::Server.start('galaxy://faraway', 1345, app, :backend => Thin::Backends::MyFancyBackend)
   #
   # == Rack application (+app+)
   # All requests will be processed through +app+ that must be a valid Rack adapter.
@@ -41,6 +40,11 @@ module Thin
   #     end
   #   end
   #
+  # == Controlling with signals
+  # * QUIT: Gracefull shutdown (see Server#stop)
+  # * INT and TERM: Force shutdown (see Server#stop!)
+  # Disable signals by passing <tt>:signals => false</tt>
+  # 
   class Server
     include Logging
     include Daemonizable
@@ -48,6 +52,7 @@ module Thin
     
     # Default values
     DEFAULT_TIMEOUT                        = 30 #sec
+    DEFAULT_HOST                           = '0.0.0.0'
     DEFAULT_PORT                           = 3000
     DEFAULT_MAXIMUM_CONNECTIONS            = 1024
     DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS = 512
@@ -60,37 +65,44 @@ module Thin
     
     # Maximum number of seconds for incoming data to arrive before the connection
     # is dropped.
-    def_delegators :@backend, :timeout, :timeout=
+    def_delegators :backend, :timeout, :timeout=
     
     # Maximum number of file or socket descriptors that the server may open.
-    def_delegators :@backend, :maximum_connections, :maximum_connections=
+    def_delegators :backend, :maximum_connections, :maximum_connections=
     
     # 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 :@backend, :maximum_persistent_connections, :maximum_persistent_connections=
+    def_delegators :backend, :maximum_persistent_connections, :maximum_persistent_connections=
+    
+    # Allow using threads in the backend.
+    def_delegators :backend, :threaded?, :threaded=
     
     # Address and port on which the server is listening for connections.
-    def_delegators :@backend, :host, :port
+    def_delegators :backend, :host, :port
     
     # UNIX domain socket on which the server is listening for connections.
-    def_delegator :@backend, :socket
+    def_delegator :backend, :socket
     
-    def initialize(host_or_socket_or_backend, port=DEFAULT_PORT, app=nil, &block)
-      # Try to intelligently select which backend to use.
-      @backend = case
-      when host_or_socket_or_backend.is_a?(Backends::Base)
-        host_or_socket_or_backend
-      when host_or_socket_or_backend.include?('/')
-        Backends::UnixServer.new(host_or_socket_or_backend)
-      else
-        Backends::TcpServer.new(host_or_socket_or_backend, port.to_i)
+    def initialize(*args, &block)
+      host, port, options = DEFAULT_HOST, DEFAULT_PORT, {}
+      
+      args.each do |arg|
+        case arg
+        when String then host    = arg
+        when Fixnum then port    = arg
+        when Hash   then options = arg
+        else
+          @app = arg if arg.respond_to?(:call)
+        end
       end
       
+      # Try to intelligently select which backend to use.
+      @backend = select_backend(host, port, options)
+      
       load_cgi_multipart_eof_fix
 
-      @app            = app
       @backend.server = self
       
       # Set defaults
@@ -103,6 +115,8 @@ module Thin
       
       # If in debug mode, wrap in logger adapter
       @app = Rack::CommonLogger.new(@app) if Logging.debug?
+      
+      setup_signals unless options[:signals].class == FalseClass
     end
     
     # Lil' shortcut to turn this:
@@ -118,18 +132,14 @@ module Thin
     end
         
     # Start the server and listen for connections.
-    # Also register signals:
-    # * INT calls +stop+ to shutdown gracefully.
-    # * TERM calls <tt>stop!</tt> to force shutdown.
     def start
       raise ArgumentError, 'app required' unless @app
       
-      setup_signals
-            
       log   ">> Thin web server (v#{VERSION::STRING} codename #{VERSION::CODENAME})"
       debug ">> Debugging ON"
       trace ">> Tracing ON"
       
+      log ">> Threaded mode #{@backend.threaded? ? 'ON' : 'OFF'}"
       log ">> Maximum connections set to #{@backend.maximum_connections}"
       log ">> Listening on #{@backend}, CTRL+C to stop"
       
@@ -165,12 +175,14 @@ module Thin
     end
     
     # == Configure the server
-    # The process might need to have superuser privilege to set configure
+    # The process might need to have superuser privilege to configure
     # server with optimal options.
     def config
       @backend.config
     end
-        
+    
+    # Name of the server and type of backend used.
+    # This is also the name of the process in which Thin is running as a daemon.
     def name
       "thin server (#{@backend})"
     end
@@ -183,14 +195,32 @@ module Thin
       @backend.running?
     end
     
-    protected            
+    protected
+      # Register signals:
+      # * INT calls +stop+ to shutdown gracefully.
+      # * TERM calls <tt>stop!</tt> to force shutdown.    
       def setup_signals
         trap('QUIT') { stop }  unless Thin.win?
         trap('INT')  { stop! }
         trap('TERM') { stop! }
       end
       
+      def select_backend(host, port, options)
+        case
+        when options.has_key?(:backend)
+          raise ArgumentError, ":backend must be a class" unless options[:backend].is_a?(Class)
+          options[:backend].new(host, port, options)
+        when options.has_key?(:swiftiply)
+          Backends::SwiftiplyClient.new(host, port, options)
+        when host.include?('/')
+          Backends::UnixServer.new(host)
+        else
+          Backends::TcpServer.new(host, port)
+        end
+      end
+      
       # Taken from Mongrel cgi_multipart_eof_fix
+      # Ruby 1.8.5 has a security bug in cgi.rb, we need to patch it.
       def load_cgi_multipart_eof_fix
         version = RUBY_VERSION.split('.').map { |i| i.to_i }
         

data/lib/thin/version.rb

@@ -5,12 +5,12 @@ module Thin
   
   module VERSION #:nodoc:
     MAJOR    = 0
-    MINOR    = 7
-    TINY     = 1
+    MINOR    = 8
+    TINY     = 0
     
     STRING   = [MAJOR, MINOR, TINY].join('.')
     
-    CODENAME = 'Fancy Pants'
+    CODENAME = 'Dodgy Dentist'
     
     RACK     = [0, 3].freeze # Latest Rack version that was tested
   end

data/spec/connection_spec.rb

@@ -69,4 +69,11 @@ describe Connection do
     @connection.response.persistent!
     @connection.should_not be_persistent
   end
+  
+  it "should set request env as rack.multithread" do
+    @connection.threaded = true
+    @connection.post_init
+    
+    @connection.request.env["rack.multithread"].should == true
+  end
 end

data/spec/controllers/controller_spec.rb

@@ -10,7 +10,8 @@ describe Controller, 'start' do
                                  :log                  => 'thin.log',
                                  :timeout              => 60,
                                  :max_conns            => 2000,
-                                 :max_persistent_conns => 1000)
+                                 :max_persistent_conns => 1000,
+                                 :adapter              => 'rails')
     
     @server = OpenStruct.new
     @adapter = OpenStruct.new
@@ -67,6 +68,13 @@ describe Controller, 'start' do
     
     @server.app.class.should == Proc
   end
+  
+  it "should set server as threaded" do
+    @controller.options[:threaded] = true
+    @controller.start
+    
+    @server.threaded.should be_true
+  end
 end
 
 describe Controller do

data/spec/rack/loader_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Rack::Adapter do
+  before do
+    @rails_path = File.dirname(__FILE__) + '/../rails_app'
+  end
+  
+  it "should guess rails app from dir" do
+    Rack::Adapter.guess(@rails_path).should == :rails
+  end
+  
+  it "should return nil when can't guess from dir" do
+    proc { Rack::Adapter.guess('.') }.should raise_error(Rack::AdapterNotFound)
+  end
+  
+  it "should load Rails adapter" do
+    Rack::Adapter::Rails.should_receive(:new)
+    Rack::Adapter.for(:rails, :chdir => @rails_path)
+  end
+  
+  it "should load File adapter" do
+    Rack::File.should_receive(:new)
+    Rack::Adapter.for(:file)
+  end
+  
+  it "should raise error when adapter can't be found" do
+    proc { Rack::Adapter.for(:fart, {}) }.should raise_error(Rack::AdapterNotFound)
+  end
+end

data/spec/{rack_rails_spec.rb → rack/rails_adapter_spec.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../spec_helper'
 require 'rack/mock'
 
 begin
@@ -6,7 +6,7 @@ begin
 
   describe Rack::Adapter::Rails do
     before do
-      @rails_app_path = File.dirname(__FILE__) + '/rails_app'
+      @rails_app_path = File.dirname(__FILE__) + '/../rails_app'
       @request = Rack::MockRequest.new(Rack::Adapter::Rails.new(:root => @rails_app_path))
     end
   
@@ -56,6 +56,18 @@ begin
       res.body.should == 'cached'
     end
     
+    it "should not serve page cache on POST request" do
+      res = @request.get("/simple/cached?value=cached")
+
+      res.should be_ok
+      res.body.should == 'cached'
+      
+      res = @request.post("/simple/cached?value=notcached")
+      
+      res.should be_ok
+      res.body.should == 'notcached'
+    end
+    
     it "handles multiple cookies" do
       res = @request.get('/simple/set_cookie?name=a&value=1')
     
@@ -70,7 +82,7 @@ begin
   
   describe Rack::Adapter::Rails, 'with prefix' do
     before do
-      @rails_app_path = File.dirname(__FILE__) + '/rails_app'
+      @rails_app_path = File.dirname(__FILE__) + '/../rails_app'
       @prefix = '/nowhere'
       @request = Rack::MockRequest.new(
         Rack::URLMap.new(

data/spec/request/parser_spec.rb

@@ -154,4 +154,26 @@ EOS
     request.body.read.should == 'aye'
   end
   
+  it "should parse ie6 urls" do
+    %w(/some/random/path"
+       /some/random/path>
+       /some/random/path<
+       /we/love/you/ie6?q=<"">
+       /url?<="&>="
+       /mal"formed"?
+    ).each do |path|
+      parser     = HttpParser.new
+      req        = {}
+      sorta_safe = %(GET #{path} HTTP/1.1\r\n\r\n)
+      nread      = parser.execute(req, sorta_safe, 0)
+
+      sorta_safe.size.should == nread
+      parser.should be_finished
+      parser.should_not have_error
+    end
+  end
+  
+  it "should fails on heders larger then MAX_HEADER" do
+    proc { R("GET / HTTP/1.1\r\nFoo: #{'X' * Request::MAX_HEADER}\r\n\r\n") }.should raise_error(InvalidRequest)
+  end
 end

data/spec/request/processing_spec.rb

@@ -15,24 +15,23 @@ describe Request, 'processing' do
   end
 
   it "should move body to tempfile when too big" do
+    len = Request::MAX_BODY + 2
     request = Request.new
-    request.parse("POST /postit HTTP/1.1\r\nContent-Length: #{Request::MAX_BODY*2}\r\n\r\n#{'X' * Request::MAX_BODY}")
-    request.parse('X' * Request::MAX_BODY)
+    request.parse("POST /postit HTTP/1.1\r\nContent-Length: #{len}\r\n\r\n#{'X' * (len/2)}")
+    request.parse('X' * (len/2))
 
-    request.body.size.should == Request::MAX_BODY * 2
+    request.body.size.should == len
     request.should be_finished
     request.body.class.should == Tempfile
   end
 
   it "should delete body tempfile when closing" do
     body = 'X' * (Request::MAX_BODY + 1)
-
-    request = R(<<-EOS.chomp, true)
-POST /postit HTTP/1.1
-Content-Length: #{body.size}
-
-#{body}
-EOS
+    
+    request = Request.new
+    request.parse("POST /postit HTTP/1.1\r\n")
+    request.parse("Content-Length: #{body.size}\r\n\r\n")
+    request.parse(body)
 
     request.body.path.should_not be_nil
     request.close

data/spec/runner_spec.rb

@@ -61,7 +61,20 @@ describe Runner do
   
   it "should consider as a cluster with :only option" do
     Runner.new(%w(start --only 3000)).should be_a_cluster
-  end  
+  end
+  
+  it "should warn when require a rack config file" do
+    STDERR.stub!(:write)
+    STDERR.should_receive(:write).with(/WARNING:/)
+
+    runner = Runner.new(%w(start -r config.ru))
+    
+    runner.options[:rackup].should == 'config.ru'
+  end
+  
+  it "should require file" do
+    proc { Runner.new(%w(start -r unexisting)) }.should raise_error(LoadError)
+  end
 end
 
 describe Runner, 'with config file' do

data/spec/server/builder_spec.rb

@@ -2,9 +2,10 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Server, 'app builder' do
   it "should build app from constructor" do
-    server = Server.new('0.0.0.0', 3000, :works)
+    app = proc {}
+    server = Server.new('0.0.0.0', 3000, app)
     
-    server.app.should == :works
+    server.app.should == app
   end
   
   it "should build app from builder block" do