thin 0.7.0-x86-mswin32-60 → 0.7.1-x86-mswin32-60

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 connector
+  # It listen for incoming request through a given backend
   # and forward all request to +app+.
   #
   # == TCP server
@@ -16,12 +16,12 @@ module Thin
   #
   #   Thin::Server.start('/tmp/thin.sock', nil, app)
   #
-  # == Using a custom connector
+  # == Using a custom backend
   # You can implement your own way to connect the server to its client by creating your
-  # own Thin::Connectors::Connector class and pass it as the first argument.
+  # own Backend class and pass it as the first argument.
   #
-  #   connector = Thin::Connectors::MyFancyConnector.new('galaxy://faraway:1345')
-  #   Thin::Server.start(connector, nil, app)
+  #   backend = Thin::Backends::MyFancyBackend.new('galaxy://faraway:1345')
+  #   Thin::Server.start(backend, nil, app)
   #
   # == Rack application (+app+)
   # All requests will be processed through +app+ that must be a valid Rack adapter.
@@ -55,46 +55,48 @@ module Thin
     # Application (Rack adapter) called with the request that produces the response.
     attr_accessor :app
     
-    # 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
+    # Backend handling the connections to the clients.
+    attr_accessor :backend
     
     # Maximum number of seconds for incoming data to arrive before the connection
     # is dropped.
-    def_delegators :@connector, :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=
     
     # 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=
+    def_delegators :@backend, :maximum_persistent_connections, :maximum_persistent_connections=
     
     # Address and port on which the server is listening for connections.
-    def_delegators :@connector, :host, :port
+    def_delegators :@backend, :host, :port
     
     # UNIX domain socket on which the server is listening for connections.
-    def_delegator :@connector, :socket
+    def_delegator :@backend, :socket
     
-    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)
-        host_or_socket_or_connector
-      when host_or_socket_or_connector.include?('/')
-        Connectors::UnixServer.new(host_or_socket_or_connector)
+    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
-        Connectors::TcpServer.new(host_or_socket_or_connector, port.to_i)
+        Backends::TcpServer.new(host_or_socket_or_backend, port.to_i)
       end
+      
+      load_cgi_multipart_eof_fix
 
-      @app              = app
-      @connector.server = self
+      @app            = app
+      @backend.server = self
       
       # Set defaults
-      @maximum_connections                      = DEFAULT_MAXIMUM_CONNECTIONS
-      @connector.maximum_persistent_connections = DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS
-      @connector.timeout                        = DEFAULT_TIMEOUT
+      @backend.maximum_connections            = DEFAULT_MAXIMUM_CONNECTIONS
+      @backend.maximum_persistent_connections = DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS
+      @backend.timeout                        = DEFAULT_TIMEOUT
       
       # Allow using Rack builder as a block
       @app = Rack::Builder.new(&block).to_app if block
@@ -124,17 +126,14 @@ module Thin
       
       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 }
+      log ">> Maximum connections set to #{@backend.maximum_connections}"
+      log ">> Listening on #{@backend}, CTRL+C to stop"
+      
+      @backend.start
     end
     alias :start! :start
     
@@ -144,15 +143,11 @@ module Thin
     # new requests and wait for all current connections to finish.
     # Calling twice is the equivalent of calling <tt>stop!</tt>.
     def stop
-      if @running
-        @running = false
-        
-        # Do not accept anymore connection
-        @connector.disconnect
-        
-        unless wait_for_connections_and_stop
-          # Still some connections running, schedule a check later
-          EventMachine.add_periodic_timer(1) { wait_for_connections_and_stop }
+      if running?
+        @backend.stop
+        unless @backend.empty?
+          log ">> Waiting for #{@backend.size} connection(s) to finish, " +
+                 "can take up to #{timeout} sec, CTRL+C to stop now"
         end
       else
         stop!
@@ -166,14 +161,18 @@ module Thin
     def stop!
       log ">> Stopping ..."
 
-      @connector.close_connections
-      EventMachine.stop
-
-      @connector.close
+      @backend.stop!
+    end
+    
+    # == Configure the server
+    # The process might need to have superuser privilege to set configure
+    # server with optimal options.
+    def config
+      @backend.config
     end
         
     def name
-      "thin server (#{@connector})"
+      "thin server (#{@backend})"
     end
     alias :to_s :name
     
@@ -181,42 +180,28 @@ module Thin
     # Note that the server might still be running and return +false+ when
     # shuting down and waiting for active connections to complete.
     def running?
-      @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
+      @backend.running?
     end
     
     protected            
-      def wait_for_connections_and_stop
-        if @connector.empty?
-          stop!
-          true
-        else
-          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
+      
+      # Taken from Mongrel cgi_multipart_eof_fix
+      def load_cgi_multipart_eof_fix
+        version = RUBY_VERSION.split('.').map { |i| i.to_i }
+        
+        if version[0] <= 1 && version[1] <= 8 && version[2] <= 5 && RUBY_PLATFORM !~ /java/
+          begin
+            require 'cgi_multipart_eof_fix'
+          rescue LoadError
+            log "!! Ruby 1.8.5 is not secure please install cgi_multipart_eof_fix:"
+            log "   gem install cgi_multipart_eof_fix"
+          end
+        end
+      end
   end
 end

data/lib/thin/version.rb

@@ -6,11 +6,13 @@ module Thin
   module VERSION #:nodoc:
     MAJOR    = 0
     MINOR    = 7
-    TINY     = 0
+    TINY     = 1
     
     STRING   = [MAJOR, MINOR, TINY].join('.')
     
-    CODENAME = 'Spherical Cow'
+    CODENAME = 'Fancy Pants'
+    
+    RACK     = [0, 3].freeze # Latest Rack version that was tested
   end
   
   NAME    = 'thin'.freeze

data/spec/{connectors → backends}/swiftiply_client_spec.rb

@@ -1,22 +1,22 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe Connectors::SwiftiplyClient do
+describe Backends::SwiftiplyClient do
   before do
-    @connector = Connectors::SwiftiplyClient.new('0.0.0.0', 3333)
-    @connector.server = mock('server', :null_object => true)
+    @backend = Backends::SwiftiplyClient.new('0.0.0.0', 3333)
+    @backend.server = mock('server', :null_object => true)
   end
   
   it "should connect" do
     EventMachine.run do
-      @connector.connect
+      @backend.connect
       EventMachine.stop
     end
   end
   
   it "should disconnect" do
     EventMachine.run do
-      @connector.connect
-      @connector.disconnect
+      @backend.connect
+      @backend.disconnect
       EventMachine.stop
     end
   end
@@ -25,8 +25,8 @@ 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)
+    @connection.backend = Backends::SwiftiplyClient.new('0.0.0.0', 3333)
+    @connection.backend.server = mock('server', :null_object => true)
   end
   
   it do
@@ -39,7 +39,7 @@ describe SwiftiplyConnection do
   end
   
   it "should reconnect on unbind" do
-    @connection.connector.stub!(:running?).and_return(true)
+    @connection.backend.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)
@@ -51,7 +51,7 @@ describe SwiftiplyConnection do
   end
   
   it "should not reconnect when not running" do
-    @connection.connector.stub!(:running?).and_return(false)
+    @connection.backend.stub!(:running?).and_return(false)
     EventMachine.should_not_receive(:add_timer)
     @connection.unbind
   end

data/spec/{connectors → backends}/tcp_server_spec.rb

@@ -1,21 +1,21 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe Connectors::TcpServer do
+describe Backends::TcpServer do
   before do
-    @connector = Connectors::TcpServer.new('0.0.0.0', 3333)
+    @backend = Backends::TcpServer.new('0.0.0.0', 3333)
   end
   
   it "should connect" do
     EventMachine.run do
-      @connector.connect
+      @backend.connect
       EventMachine.stop
     end
   end
   
   it "should disconnect" do
     EventMachine.run do
-      @connector.connect
-      @connector.disconnect
+      @backend.connect
+      @backend.disconnect
       EventMachine.stop
     end
   end

data/spec/backends/unix_server_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Backends::UnixServer do
+  before do
+    @backend = Backends::UnixServer.new('/tmp/thin-test.sock')
+  end
+  
+  it "should connect" do
+    EventMachine.run do
+      @backend.connect
+      EventMachine.stop
+    end
+  end
+  
+  it "should disconnect" do
+    EventMachine.run do
+      @backend.connect
+      @backend.disconnect
+      EventMachine.stop
+    end
+  end
+  
+  it "should remove socket file on close" do
+    @backend.close
+    File.exist?('/tmp/thin-test.sock').should be_false
+  end
+end
+
+describe UnixConnection do
+  before do
+    @connection = UnixConnection.new(nil)
+  end
+  
+  it "should return 127.0.0.1 as remote_address" do
+    @connection.remote_address.should == '127.0.0.1'
+  end
+end

data/spec/command_spec.rb

@@ -2,6 +2,7 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe Command do
   before do
+    Command.script = 'thin'
     @command = Command.new(:start, :port => 3000, :daemonize => true, :log => 'hi.log')
   end
   

data/spec/connection_spec.rb

@@ -51,7 +51,7 @@ describe Connection do
   end
   
   it "should return remote_address" do
-    @connection.stub!(:get_peername).and_return("\020\002?E\177\000\000\001\000\000\000\000\000\000\000\000")
+    @connection.stub!(:get_peername).and_return(Socket.pack_sockaddr_in(3000, '127.0.0.1'))
     @connection.remote_address.should == '127.0.0.1'
   end
   

data/spec/controllers/controller_spec.rb

@@ -16,6 +16,7 @@ describe Controller, 'start' do
     @adapter = OpenStruct.new
     
     Server.should_receive(:new).with('0.0.0.0', 3000).and_return(@server)
+    @server.should_receive(:config)
     Rack::Adapter::Rails.stub!(:new).and_return(@adapter)
   end
   

data/spec/daemonizing_spec.rb

@@ -8,22 +8,22 @@ class TestServer
   end
   
   def name
-    'thin'
+    'Thin test server'
   end
 end
 
 describe 'Daemonizing' do
-  
-  before(:all) do
+  before :all do
     @logfile = File.dirname(__FILE__) + '/../log/daemonizing_test.log'
+    @pidfile = 'test.pid'
     File.delete(@logfile) if File.exist?(@logfile)
-    @child_processes = []
+    File.delete(@pidfile) if File.exist?(@pidfile)
   end
   
-  before(:each) do
+  before :each do
     @server = TestServer.new
     @server.log_file = @logfile
-    @server.pid_file = 'test.pid'
+    @server.pid_file = @pidfile
     @pid = nil
   end
   
@@ -34,7 +34,6 @@ describe 'Daemonizing' do
   
   it 'should create a pid file' do
     @pid = fork do
-      @child_processes << Process.pid
       @server.daemonize
       sleep 1
     end
@@ -49,7 +48,6 @@ describe 'Daemonizing' do
   
   it 'should redirect stdio to a log file' do
     @pid = fork do
-      @child_processes << Process.pid
       @server.log_file = 'daemon_test.log'
       @server.daemonize
 
@@ -61,6 +59,8 @@ describe 'Daemonizing' do
     # Wait for the file to close and magical stuff to happen
     proc { sleep 0.1 until File.exist?('daemon_test.log') }.should take_less_then(3)
     sleep 0.5
+    
+    @pid = @server.pid
 
     log = File.read('daemon_test.log')
     log.should include('simple puts', 'STDERR.puts', 'STDOUT.puts')
@@ -70,7 +70,6 @@ describe 'Daemonizing' do
   
   it 'should change privilege' do
     @pid = fork do
-      @child_processes << Process.pid
       @server.daemonize
       @server.change_privilege('root', 'admin')
     end
@@ -80,33 +79,37 @@ describe 'Daemonizing' do
   
   it 'should kill process in pid file' do
     @pid = fork do
-      @child_processes << Process.pid
       @server.daemonize
-      loop { sleep 1 }
+      loop { sleep 3 }
     end
   
     server_should_start_in_less_then 3
+    
+    @pid = @server.pid
   
     silence_stream STDOUT do
       TestServer.kill(@server.pid_file, 1)
     end
   
-    File.exist?(@server.pid_file).should_not be_true
+    File.exist?(@server.pid_file).should be_false
   end
   
   it 'should send kill signal if timeout' do
     @pid = fork do
-      @child_processes << Process.pid
       @server.should_receive(:stop) # pretend we cannot handle the INT signal
       @server.daemonize
       sleep 5
     end
   
     server_should_start_in_less_then 10
+    
+    @pid = @server.pid
   
     silence_stream STDOUT do
       TestServer.kill(@server.pid_file, 1)
     end
+    
+    sleep 1
   
     File.exist?(@server.pid_file).should be_false
     Process.running?(@pid).should be_false
@@ -114,13 +117,14 @@ describe 'Daemonizing' do
   
   it "should restart" do
     @pid = fork do
-      @child_processes << Process.pid
       @server.on_restart {}
       @server.daemonize
       sleep 5
     end
     
     server_should_start_in_less_then 10
+    
+    @pid = @server.pid
   
     silence_stream STDOUT do
       TestServer.restart(@server.pid_file)
@@ -129,31 +133,35 @@ describe 'Daemonizing' do
     proc { sleep 0.1 while File.exist?(@server.pid_file) }.should take_less_then(10)
   end
   
-  it "should exit if pid file already exist" do
+  it "should exit and raise if pid file already exist" do
     @pid = fork do
-      @child_processes << Process.pid
       @server.daemonize
       sleep 5
     end
     server_should_start_in_less_then 10
+    
+    @pid = @server.pid
 
     proc { @server.daemonize }.should raise_error(PidFileExist)
     
     File.exist?(@server.pid_file).should be_true
   end
   
-  after(:each) do
+  it "should should delete pid file if stale" do
+    # Create a file w/ a PID that does not exist
+    File.open(@server.pid_file, 'w') { |f| f << 999999999 }
+    
+    @server.send(:remove_stale_pid_file)
+    
+    File.exist?(@server.pid_file).should be_false
+  end
+  
+  after do
     Process.kill(9, @pid.to_i) if @pid && Process.running?(@pid.to_i)
     Process.kill(9, @server.pid) if @server.pid && Process.running?(@server.pid)
     File.delete(@server.pid_file) rescue nil
   end
   
-  after(:all) do
-    @child_processes.each do |pid|
-      Process.kill(9, pid) rescue nil
-    end
-  end
-  
   private
     def server_should_start_in_less_then(sec=10)
       proc { sleep 0.1 until File.exist?(@server.pid_file) }.should take_less_then(10)