thin 1.2.4-x86-mswin32 → 1.2.6-x86-mswin32

data/ext/thin_parser/thin.c

@@ -207,6 +207,9 @@ static void header_done(void *data, const char *at, size_t length)
   if (rb_hash_aref(req, global_query_string) == Qnil) {
     rb_hash_aset(req, global_query_string, global_empty);
   }
+  if (rb_hash_aref(req, global_path_info) == Qnil) {
+    rb_hash_aset(req, global_path_info, global_empty);
+  }
   
   /* set some constants */
   rb_hash_aset(req, global_server_protocol, global_server_protocol_value);

data/lib/rack/adapter/loader.rb

@@ -8,6 +8,7 @@ module Rack
   # NOTE: If a framework has a file that is not unique, make sure to place
   # it at the end.
   ADAPTERS = [
+    [:rack,    'config.ru'],
     [:rails,   'config/environment.rb'],
     [:ramaze,  'start.rb'],
     [:halcyon, 'runner.ru'],
@@ -29,9 +30,20 @@ module Rack
       raise AdapterNotFound, "No adapter found for #{dir}"
     end
     
+    # Load a Rack application from a Rack config file (.ru).
+    def self.load(config)
+      rackup_code = ::File.read(config)
+      eval("Rack::Builder.new {( #{rackup_code}\n )}.to_app", TOPLEVEL_BINDING, config)
+    end
+    
     # Loads an adapter identified by +name+ using +options+ hash.
     def self.for(name, options={})
+      ENV['RACK_ENV'] = options[:environment]
+      
       case name.to_sym
+      when :rack
+        return load(::File.join(options[:chdir], "config.ru"))
+        
       when :rails
         return Rails.new(options.merge(:root => options[:chdir]))
       

data/lib/rack/adapter/rails.rb

@@ -32,9 +32,8 @@ module Rack
       end
       
       def rack_based?
-        ActionController.const_defined?(:Dispatcher) &&
-          (ActionController::Dispatcher.instance_methods.include?(:call) ||
-           ActionController::Dispatcher.instance_methods.include?("call"))
+        rails_version = ::Rails::VERSION
+        rails_version::MAJOR >= 2 && rails_version::MINOR >= 2 && rails_version::TINY >= 3
       end
       
       def load_application

data/lib/thin.rb

@@ -3,44 +3,44 @@ require 'timeout'
 require 'stringio'
 require 'time'
 require 'forwardable'
-
 require 'openssl'
 require 'eventmachine'
-
-require 'thin/version'
-require 'thin/statuses'
+require 'rack'
 
 module Thin
-  autoload :Command,            'thin/command'
-  autoload :Connection,         'thin/connection'
-  autoload :Daemonizable,       'thin/daemonizing'
-  autoload :Logging,            'thin/logging'
-  autoload :Headers,            'thin/headers'
-  autoload :Request,            'thin/request'
-  autoload :Response,           'thin/response'
-  autoload :Runner,             'thin/runner'
-  autoload :Server,             'thin/server'
-  autoload :Stats,              'thin/stats'
+  ROOT = File.expand_path(File.dirname(__FILE__))
+  
+  autoload :Command,            "#{ROOT}/thin/command"
+  autoload :Connection,         "#{ROOT}/thin/connection"
+  autoload :Daemonizable,       "#{ROOT}/thin/daemonizing"
+  autoload :Logging,            "#{ROOT}/thin/logging"
+  autoload :Headers,            "#{ROOT}/thin/headers"
+  autoload :Request,            "#{ROOT}/thin/request"
+  autoload :Response,           "#{ROOT}/thin/response"
+  autoload :Runner,             "#{ROOT}/thin/runner"
+  autoload :Server,             "#{ROOT}/thin/server"
+  autoload :Stats,              "#{ROOT}/thin/stats"
   
   module Backends
-    autoload :Base,             'thin/backends/base'
-    autoload :SwiftiplyClient,  'thin/backends/swiftiply_client'
-    autoload :TcpServer,        'thin/backends/tcp_server'
-    autoload :UnixServer,       'thin/backends/unix_server'
+    autoload :Base,             "#{ROOT}/thin/backends/base"
+    autoload :SwiftiplyClient,  "#{ROOT}/thin/backends/swiftiply_client"
+    autoload :TcpServer,        "#{ROOT}/thin/backends/tcp_server"
+    autoload :UnixServer,       "#{ROOT}/thin/backends/unix_server"
   end
   
   module Controllers
-    autoload :Cluster,          'thin/controllers/cluster'
-    autoload :Controller,       'thin/controllers/controller'
-    autoload :Service,          'thin/controllers/service'
+    autoload :Cluster,          "#{ROOT}/thin/controllers/cluster"
+    autoload :Controller,       "#{ROOT}/thin/controllers/controller"
+    autoload :Service,          "#{ROOT}/thin/controllers/service"
   end
 end
 
-require 'rack'
-require 'rack/adapter/loader'
+require "#{Thin::ROOT}/thin/version"
+require "#{Thin::ROOT}/thin/statuses"
+require "#{Thin::ROOT}/rack/adapter/loader"
 
 module Rack
   module Adapter
-    autoload :Rails, 'rack/adapter/rails'
+    autoload :Rails, "#{Thin::ROOT}/rack/adapter/rails"
   end
 end

data/lib/thin/controllers/cluster.rb

@@ -1,4 +1,9 @@
+require 'socket'
+
 module Thin
+  # An exception class to handle the event that server didn't start on time
+  class RestartTimeout < RuntimeError; end
+  
   module Controllers
     # Control a set of servers.
     # * Generate start and stop commands and run them.
@@ -7,7 +12,10 @@ module Thin
     class Cluster < Controller
       # Cluster only options that should not be passed in the command sent
       # to the indiviual servers.
-      CLUSTER_OPTIONS = [:servers, :only]
+      CLUSTER_OPTIONS = [:servers, :only, :onebyone, :wait]
+      
+      # Maximum wait time for the server to be restarted
+      DEFAULT_WAIT_TIME = 30    # seconds
       
       # Create a new cluster of servers launched using +options+.
       def initialize(options)
@@ -15,7 +23,7 @@ module Thin
         # Cluster can only contain daemonized servers
         @options.merge!(:daemonize => true)
       end
-    
+      
       def first_port; @options[:port]     end
       def address;    @options[:address]  end
       def socket;     @options[:socket]   end
@@ -23,7 +31,9 @@ module Thin
       def log_file;   @options[:log]      end
       def size;       @options[:servers]  end
       def only;       @options[:only]     end
-
+      def onebyone;   @options[:onebyone] end
+      def wait;       @options[:wait]     end
+      
       def swiftiply?
         @options.has_key?(:swiftiply)
       end
@@ -54,9 +64,50 @@ module Thin
     
       # Stop and start the servers.
       def restart
-        stop
-        sleep 0.1 # Let's breath a bit shall we ?
-        start
+        unless onebyone
+          # Let's do a normal restart by defaults
+          stop
+          sleep 0.1 # Let's breath a bit shall we ?
+          start
+        else
+          with_each_server do |n| 
+            stop_server(n)
+            sleep 0.1 # Let's breath a bit shall we ?
+            start_server(n)
+            wait_until_server_started(n)
+          end
+        end
+      end
+      
+      def test_socket(number)
+        if socket
+          UNIXSocket.new(socket_for(number))
+        else
+          TCPSocket.new(address, number)
+        end
+      rescue
+        nil
+      end
+      
+      # Make sure the server is running before moving on to the next one.
+      def wait_until_server_started(number)
+        log "Waiting for server to start ..."
+        STDOUT.flush # Need this to make sure user got the message
+        
+        tries = 0
+        loop do
+          if test_socket = test_socket(number)
+            test_socket.close
+            break
+          elsif tries < wait
+            sleep 1
+            tries += 1
+          else
+            raise RestartTimeout, "The server didn't start in time. Please look at server's log file " +
+                                  "for more information, or set the value of 'wait' in your config " +
+                                  "file to be higher (defaults: 30)."
+          end
+        end
       end
     
       def server_id(number)

data/lib/thin/controllers/controller.rb

@@ -172,8 +172,7 @@ module Thin
             Kernel.load(@options[:rackup])
             Object.const_get(File.basename(@options[:rackup], '.rb').capitalize.to_sym)
           when /\.ru$/
-            rackup_code = File.read(@options[:rackup])
-            eval("Rack::Builder.new {( #{rackup_code}\n )}.to_app", TOPLEVEL_BINDING, @options[:rackup])
+            Rack::Adapter.load(@options[:rackup])
           else
             raise "Invalid rackup file.  please specify either a .ru or .rb file"
           end

data/lib/thin/daemonizing.rb

@@ -36,18 +36,21 @@ module Thin
     def daemonize
       raise PlatformNotSupported, 'Daemonizing is not supported on Windows'     if Thin.win?
       raise ArgumentError,        'You must specify a pid_file to daemonize' unless @pid_file
-
+      
       remove_stale_pid_file
       
       pwd = Dir.pwd # Current directory is changed during daemonization, so store it
       
+      # HACK we need to create the directory before daemonization to prevent a bug under 1.9
+      #      ignoring all signals when the directory is created after daemonization.
+      FileUtils.mkdir_p File.dirname(@pid_file)
+      
       Daemonize.daemonize(File.expand_path(@log_file), name)
       
       Dir.chdir(pwd)
       
       write_pid_file
       
-      trap('HUP') { restart }
       at_exit do
         log ">> Exiting!"
         remove_pid_file
@@ -153,7 +156,6 @@ module Thin
     
       def write_pid_file
         log ">> Writing PID to #{@pid_file}"
-        FileUtils.mkdir_p File.dirname(@pid_file)
         open(@pid_file,"w") { |f| f.write(Process.pid) }
         File.chmod(0644, @pid_file)
       end

data/lib/thin/request.rb

@@ -1,4 +1,4 @@
-require 'thin_parser'
+require "#{Thin::ROOT}/thin_parser"
 require 'tempfile'
 
 module Thin
@@ -13,7 +13,11 @@ module Thin
     MAX_BODY          = 1024 * (80 + 32)
     BODY_TMPFILE      = 'thin-body'.freeze
     MAX_HEADER        = 1024 * (80 + 32)
-
+    
+    INITIAL_BODY      = ''
+    # Force external_encoding of request's body to ASCII_8BIT
+    INITIAL_BODY.encode!(Encoding::ASCII_8BIT) if INITIAL_BODY.respond_to?(:encode!)
+    
     # Freeze some HTTP header names & values
     SERVER_SOFTWARE   = 'SERVER_SOFTWARE'.freeze
     SERVER_NAME       = 'SERVER_NAME'.freeze
@@ -49,7 +53,7 @@ module Thin
       @parser   = Thin::HttpParser.new
       @data     = ''
       @nparsed  = 0
-      @body     = StringIO.new
+      @body     = StringIO.new(INITIAL_BODY.dup)
       @env      = {
         SERVER_SOFTWARE   => SERVER,
         SERVER_NAME       => LOCALHOST,

data/lib/thin/runner.rb

@@ -41,7 +41,8 @@ module Thin
         :pid                  => 'tmp/pids/thin.pid',
         :max_conns            => Server::DEFAULT_MAXIMUM_CONNECTIONS,
         :max_persistent_conns => Server::DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS,
-        :require              => []
+        :require              => [],
+        :wait                 => Controllers::Cluster::DEFAULT_WAIT_TIME
       }
       
       parse!
@@ -96,6 +97,8 @@ module Thin
           opts.on("-o", "--only NUM", "Send command to only one server of the cluster") { |only| @options[:only] = only.to_i }
           opts.on("-C", "--config FILE", "Load options from config file")               { |file| @options[:config] = file }
           opts.on(      "--all [DIR]", "Send command to each config files in DIR")      { |dir| @options[:all] = dir } if Thin.linux?
+          opts.on("-O", "--onebyone", "Restart the cluster one by one (only works with restart command)") { @options[:onebyone] = true }
+          opts.on("-w", "--wait NUM", "Maximum wait time for server to be started in seconds (use with -O)") { |time| @options[:wait] = time.to_i }
         end
         
         opts.separator ""
@@ -105,7 +108,7 @@ module Thin
         opts.on("-t", "--timeout SEC", "Request or command timeout in sec " +            
                                        "(default: #{@options[:timeout]})")              { |sec| @options[:timeout] = sec.to_i }
         opts.on("-f", "--force", "Force the execution of the command")                  { @options[:force] = true }
-        opts.on(      "--max-conns NUM", "Maximum number of connections " +
+        opts.on(      "--max-conns NUM", "Maximum number of open file descriptors " +
                                          "(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",

data/lib/thin/server.rb

@@ -208,11 +208,12 @@ module Thin
     protected
       # Register signals:
       # * INT calls +stop+ to shutdown gracefully.
-      # * TERM calls <tt>stop!</tt> to force shutdown.    
+      # * TERM calls <tt>stop!</tt> to force shutdown.
       def setup_signals
         trap('QUIT') { stop }  unless Thin.win?
         trap('INT')  { stop! }
         trap('TERM') { stop! }
+        trap('HUP')  { restart }
       end
       
       def select_backend(host, port, options)

data/lib/thin/version.rb

@@ -6,11 +6,11 @@ module Thin
   module VERSION #:nodoc:
     MAJOR    = 1
     MINOR    = 2
-    TINY     = 4
+    TINY     = 6
     
     STRING   = [MAJOR, MINOR, TINY].join('.')
     
-    CODENAME = "Flaming Astroboy".freeze
+    CODENAME = "Crazy Delicious".freeze
     
     RACK     = [1, 0].freeze # Rack protocol version
   end

data/spec/controllers/cluster_spec.rb

@@ -232,4 +232,36 @@ describe Cluster, "with Swiftiply" do
     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
+
+describe Cluster, "rolling restart" do
+  before do
+    @cluster = Cluster.new(:chdir => '/rails_app',
+                           :address => '0.0.0.0',
+                           :port => 3000, 
+                           :servers => 2,
+                           :timeout => 10,
+                           :log => 'thin.log',
+                           :pid => 'thin.pid',
+                           :onebyone => true,
+                           :wait => 30
+                          )
+  end
+  
+  it "should restart servers one by one" do
+    Command.should_receive(:run).with(:stop, options_for_port(3000))
+    Command.should_receive(:run).with(:start, options_for_port(3000))
+    @cluster.should_receive(:wait_until_server_started).with(3000)
+    
+    Command.should_receive(:run).with(:stop, options_for_port(3001))
+    Command.should_receive(:run).with(:start, options_for_port(3001))
+    @cluster.should_receive(:wait_until_server_started).with(3001)
+    
+    @cluster.restart
+  end
+  
+  private
+    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

data/spec/rack/loader_spec.rb

@@ -2,9 +2,18 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Rack::Adapter do
   before do
+    @config_ru_path = File.dirname(__FILE__) + '/../../example'
     @rails_path = File.dirname(__FILE__) + '/../rails_app'
   end
   
+  it "should load Rack app from config" do
+    Rack::Adapter.load(@config_ru_path + '/config.ru').class.should == Proc
+  end
+  
+  it "should guess Rack app from dir" do
+    Rack::Adapter.guess(@config_ru_path).should == :rack
+  end
+  
   it "should guess rails app from dir" do
     Rack::Adapter.guess(@rails_path).should == :rails
   end
@@ -13,6 +22,10 @@ describe Rack::Adapter do
     proc { Rack::Adapter.guess('.') }.should raise_error(Rack::AdapterNotFound)
   end
   
+  it "should load Rack adapter" do
+    Rack::Adapter.for(:rack, :chdir => @config_ru_path).class.should == Proc
+  end
+  
   it "should load Rails adapter" do
     Rack::Adapter::Rails.should_receive(:new)
     Rack::Adapter.for(:rails, :chdir => @rails_path)

data/spec/request/parser_spec.rb

@@ -209,7 +209,35 @@ EOS
       parser     = HttpParser.new
       req        = {}
       nread      = parser.execute(req, req_str, 0)
-      req.should be_has_key('HTTP_HOS_T')
+      req.should have_key('HTTP_HOS_T')
     }
   end
+  
+  it "should parse PATH_INFO with semicolon" do
+    qs = "QUERY_STRING"
+    pi = "PATH_INFO"
+    {
+      "/1;a=b?c=d&e=f" => { qs => "c=d&e=f", pi => "/1;a=b" },
+      "/1?c=d&e=f" => { qs => "c=d&e=f", pi => "/1" },
+      "/1;a=b" => { qs => "", pi => "/1;a=b" },
+      "/1;a=b?" => { qs => "", pi => "/1;a=b" },
+      "/1?a=b;c=d&e=f" => { qs => "a=b;c=d&e=f", pi => "/1" },
+      "*" => { qs => "", pi => "" },
+    }.each do |uri, expect|
+      parser     = HttpParser.new
+      env        = {}
+      nread      = parser.execute(env, "GET #{uri} HTTP/1.1\r\nHost: www.example.com\r\n\r\n", 0)
+
+      env[pi].should == expect[pi]
+      env[qs].should == expect[qs]
+      env["REQUEST_URI"].should == uri
+
+      next if uri == "*"
+      
+      # Validate w/ Ruby's URI.parse
+      uri = URI.parse("http://example.com#{uri}")
+      env[qs].should == uri.query.to_s
+      env[pi].should == uri.path
+    end
+  end
 end