Ticket #30: mongrel_patch_20080507.diff

test/test_ws_unix.rb

@@ +1 @@
+# Copyright (c) 2005 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
+# for more information.
+
+require 'test/testhelp'
+
+include Mongrel
+
+class TestHandler < Mongrel::HttpHandler
+  attr_reader :ran_test
+
+  def process(request, response)
+    @ran_test = true
+    response.socket.write("HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nhello!\n")
+  end
+end
+
+
+class WebServerUnixTest < Test::Unit::TestCase
+
+  def setup
+    @port = process_based_port
+    @valid_request = "GET / HTTP/1.1\r\nHost: www.zedshaw.com\r\nContent-Type: text/plain\r\n\r\n"
+    
+    redirect_test_io do
+      # We set num_processors=1 so that we can test the reaping code
+      @server = UnixDispatchServer.new("127.0.0.1", @port, 1)
+    end
+    
+    @tester = TestHandler.new
+    @server.register("/test", @tester)
+    redirect_test_io do
+      @server.run 
+    end
+  end
+
+  def teardown
+    redirect_test_io do
+      @server.stop(true)
+    end
+  end
+
+  def do_test(string, chunk, close_after=nil, shutdown_delay=0)
+    # Do not use instance variables here, because it needs to be thread safe
+    socket = TCPSocket.new("127.0.0.1", @port);
+    request = StringIO.new(string)
+    chunks_out = 0
+
+    while data = request.read(chunk)
+      chunks_out += socket.write(data)
+      socket.flush
+      sleep 0.2
+      if close_after and chunks_out > close_after
+        socket.close
+        sleep 1
+      end
+    end
+    sleep(shutdown_delay)
+    socket.write(" ") # Some platforms only raise the exception on attempted write
+    socket.flush
+  end
+
+  def test_trickle_attack
+    do_test(@valid_request, 3)
+  end
+
+  def test_close_client
+    assert_raises IOError do
+      do_test(@valid_request, 10, 20)
+    end
+  end
+
+  def test_bad_client
+    redirect_test_io do
+      do_test("GET /test HTTP/BAD", 3)
+    end
+  end
+
+  def test_header_is_too_long
+    redirect_test_io do
+      long = "GET /test HTTP/1.1\r\n" + ("X-Big: stuff\r\n" * 15000) + "\r\n"
+      assert_raises Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EINVAL, IOError do
+        do_test(long, long.length/2, 10)
+      end
+    end
+  end
+
+  def test_file_streamed_request
+    body = "a" * (Mongrel::Const::MAX_BODY * 2)
+    long = "GET /test HTTP/1.1\r\nContent-length: #{body.length}\r\n\r\n" + body
+    do_test(long, Mongrel::Const::CHUNK_SIZE * 2 -400)
+  end
+
+end
+

test/test_redirect_handler_unix.rb

@@ +1 @@
+# Copyright (c) 2005 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
+# for more information.
+
+require 'test/testhelp'
+
+class RedirectHandlerUnixTest < Test::Unit::TestCase
+
+  def setup
+    redirect_test_io do
+      @server = Mongrel::UnixDispatchServer.new('127.0.0.1', process_based_port,1)
+    end
+    @server.run
+    @client = Net::HTTP.new('127.0.0.1', process_based_port)
+  end
+
+  def teardown
+    @server.stop(true)
+  end
+
+  def test_simple_redirect
+    tester = Mongrel::RedirectHandler.new('/yo')
+    @server.register("/test", tester)
+
+    sleep(1)
+    res = @client.request_get('/test')
+    assert res != nil, "Didn't get a response"
+    assert_equal ['/yo'], res.get_fields('Location')
+  end
+
+  def test_rewrite
+    tester = Mongrel::RedirectHandler.new(/(\w+)/, '+\1+')
+    @server.register("/test", tester)
+
+    sleep(1)
+    res = @client.request_get('/test/something')
+    assert_equal ['/+test+/+something+'], res.get_fields('Location')
+  end
+
+end
+
+

test/test_conditional_unix.rb

@@ +1 @@
+# Copyright (c) 2005 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
+# for more information.
+
+require 'test/testhelp'
+
+include Mongrel
+
+class ConditionalResponseUnixTest < Test::Unit::TestCase
+  def setup
+    @server = UnixDispatchServer.new('127.0.0.1', process_based_port, 1)
+    @server.register('/', Mongrel::DirHandler.new('.'))
+    @server.run
+    
+    @http = Net::HTTP.new(@server.host, @server.port)
+
+    # get the ETag and Last-Modified headers
+    @path = '/README'
+    res = @http.start { |http| http.get(@path) }
+    assert_not_nil @etag = res['ETag']
+    assert_not_nil @last_modified = res['Last-Modified']
+    assert_not_nil @content_length = res['Content-Length']
+  end
+
+  def teardown
+    @server.stop(true)
+  end
+
+  # status should be 304 Not Modified when If-None-Match is the matching ETag
+  def test_not_modified_via_if_none_match
+    assert_status_for_get_and_head Net::HTTPNotModified, 'If-None-Match' => @etag
+  end
+
+  # status should be 304 Not Modified when If-Modified-Since is the matching Last-Modified date
+  def test_not_modified_via_if_modified_since
+    assert_status_for_get_and_head Net::HTTPNotModified, 'If-Modified-Since' => @last_modified
+  end
+
+  # status should be 304 Not Modified when If-None-Match is the matching ETag
+  # and If-Modified-Since is the matching Last-Modified date
+  def test_not_modified_via_if_none_match_and_if_modified_since
+    assert_status_for_get_and_head Net::HTTPNotModified, 'If-None-Match' => @etag, 'If-Modified-Since' => @last_modified
+  end
+
+  # status should be 200 OK when If-None-Match is invalid
+  def test_invalid_if_none_match
+    assert_status_for_get_and_head Net::HTTPOK, 'If-None-Match' => 'invalid'
+    assert_status_for_get_and_head Net::HTTPOK, 'If-None-Match' => 'invalid', 'If-Modified-Since' => @last_modified
+  end
+
+  # status should be 200 OK when If-Modified-Since is invalid
+  def test_invalid_if_modified_since
+    assert_status_for_get_and_head Net::HTTPOK,                           'If-Modified-Since' => 'invalid'
+    assert_status_for_get_and_head Net::HTTPOK, 'If-None-Match' => @etag, 'If-Modified-Since' => 'invalid'
+  end
+
+  # status should be 304 Not Modified when If-Modified-Since is greater than the Last-Modified header, but less than the system time
+  def test_if_modified_since_greater_than_last_modified
+    sleep 2
+    last_modified_plus_1 = (Time.httpdate(@last_modified) + 1).httpdate
+    assert_status_for_get_and_head Net::HTTPNotModified,                           'If-Modified-Since' => last_modified_plus_1
+    assert_status_for_get_and_head Net::HTTPNotModified, 'If-None-Match' => @etag, 'If-Modified-Since' => last_modified_plus_1
+  end
+
+  # status should be 200 OK when If-Modified-Since is less than the Last-Modified header
+  def test_if_modified_since_less_than_last_modified
+    last_modified_minus_1 = (Time.httpdate(@last_modified) - 1).httpdate
+    assert_status_for_get_and_head Net::HTTPOK,                           'If-Modified-Since' => last_modified_minus_1
+    assert_status_for_get_and_head Net::HTTPOK, 'If-None-Match' => @etag, 'If-Modified-Since' => last_modified_minus_1
+  end
+
+  # status should be 200 OK when If-Modified-Since is a date in the future
+  def test_future_if_modified_since
+    the_future = Time.at(2**31-1).httpdate
+    assert_status_for_get_and_head Net::HTTPOK,                           'If-Modified-Since' => the_future
+    assert_status_for_get_and_head Net::HTTPOK, 'If-None-Match' => @etag, 'If-Modified-Since' => the_future
+  end
+
+  # status should be 200 OK when If-None-Match is a wildcard
+  def test_wildcard_match
+    assert_status_for_get_and_head Net::HTTPOK, 'If-None-Match' => '*'
+    assert_status_for_get_and_head Net::HTTPOK, 'If-None-Match' => '*', 'If-Modified-Since' => @last_modified
+  end
+
+  private
+
+    # assert the response status is correct for GET and HEAD
+    def assert_status_for_get_and_head(response_class, headers = {})
+      %w{ get head }.each do |method|
+        res = @http.send(method, @path, headers)
+        assert_kind_of response_class, res
+        assert_equal @etag, res['ETag']
+        case response_class.to_s
+          when 'Net::HTTPNotModified' then
+            assert_nil res['Last-Modified']
+            assert_nil res['Content-Length']
+          when 'Net::HTTPOK' then
+            assert_equal @last_modified, res['Last-Modified']
+            assert_equal @content_length, res['Content-Length']
+          else
+            fail "Incorrect response class: #{response_class}"
+        end
+      end
+    end
+end

lib/mongrel/configurator.rb

@@ -136 +136 @@
-      opts[:throttle] ||= 0
-      opts[:timeout] ||= 60
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-      @listener_name = "#{opts[:host]}:#{opts[:port]}"
-      @listeners[@listener_name] = @listener
-
@@ -372 +383 @@
-
-      unless RUBY_PLATFORM =~ /djgpp|(cyg|ms|bcc)win|mingw/
-        # graceful shutdown
-
+pid #{$$}: 
-        # debug mode
-
+pid #{$$}: 
-        # restart
-
+pid #{$$}: 
-
-        Mongrel.log(:notice, "Signals ready.  TERM => stop.  USR2 => restart.  INT => stop (no restart).")
-      else
@@ -387 +398 @@
-  end
-
-end
+# vim:shiftwidth=2:tabstop=2:expandtab:ft=ruby

lib/mongrel.rb

@@ +1 @@
+# Copyright (c) 2005 Zed A. Shaw
+# Copyright (c) 2008 Raritan Computer, Inc (Brian Weaver <brian.weaver@raritan.com>)
-# Ruby
-require 'socket'
-require 'tempfile'
@@ -42 +44 @@
-  # Thrown at a thread when it is timed out.
-  class TimeoutError < Exception; end
-
+  class UriChangeEvent < Exception; end
+
-  # A Hash with one extra parameter for the HTTP body, used internally.
-  class HttpParams < Hash
-    attr_accessor :http_body
-  end
-
-
-
-
-
+
+
-  #
-
+
+
+
+
+
+
-  #
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    attr_accessor :logger
+    attr_accessor :classifier
+    attr_reader   :acceptor
+    attr_reader   :domain
+    attr_reader   :host
+    attr_reader   :port
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-      @classifier = URIClassifier.new
-
-
-
-
-
-
-
+
-    end
-    
-    # Does the majority of the IO processing.  It has been written in Ruby using
@@ -117 +86 @@
-        request = nil
-        data = client.readpartial(Const::CHUNK_SIZE)
-        nparsed = 0
-
+
-        # Assumption: nparsed will always be less since data will get filled with more
-        # after each parsing.  If it doesn't get more then there was a problem
-        # with the read operation on the client socket.  Effect is to stop processing when the
@@ -185 +154 @@
-            end
-          end
-        end
-
+
+
-        client.close rescue nil
-      rescue HttpParserError => e
-#{Time.now.httpdate}: 
-#{Time.now.httpdate}: 
+
+
-        # http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4
-        client.write(Const::ERROR_400_RESPONSE)
-
+
+
-        reap_dead_workers('too many files')
-      rescue Object => e
-#{Time.now.httpdate}: 
+
-        Mongrel.log(:error, e.backtrace.join("\n"))
-      ensure
-        begin
-          client.close
-
+
+
-          # Already closed
-        rescue Object => e
-#{Time.now.httpdate}: 
+
-          Mongrel.log(:error, e.backtrace.join("\n"))
-        end
-        request.body.delete if request and request.body.class == Tempfile
-      end
-    end
-
+    def reap_dead_workers(reason=nil)
+      raise RuntimeError, "This method must be overridden in a derived class"
+    end
+
+    def configure_socket_options
+      case RUBY_PLATFORM
+      when /linux/
+        # 9 is currently TCP_DEFER_ACCEPT
+        $tcp_defer_accept_opts = [Socket::SOL_TCP, 9, 1]
+        $tcp_cork_opts = [Socket::SOL_TCP, 3, 1]
+      when /freebsd(([1-4]\..{1,2})|5\.[0-4])/
+        # Do nothing, just closing a bug when freebsd <= 5.4
+      when /freebsd/
+        # Use the HTTP accept filter if available.
+        # The struct made by pack() is defined in /usr/include/sys/socket.h as accept_filter_arg
+        unless `/sbin/sysctl -nq net.inet.accf.http`.empty?
+          $tcp_defer_accept_opts = [Socket::SOL_SOCKET, Socket::SO_ACCEPTFILTER, ['httpready', nil].pack('a16a240')]
+        end
+      end
+    end
+
+    # Runs the thing.  It returns the thread used so you can "join" it.  You can also
+    # access the HttpServer::acceptor attribute to get the thread later.
+    def run
+      raise RuntimeError, "This method must be overridden in a derived class"
+    end
+
+    # Simply registers a handler with the internal URIClassifier.  When the URI is
+    # found in the prefix of a request then your handler's HttpHandler::process method
+    # is called.  See Mongrel::URIClassifier#register for more information.
+    #
+    # If you set in_front=true then the passed in handler will be put in the front of the list
+    # for that particular URI. Otherwise it's placed at the end of the list.
+    def register(uri, handler, in_front=false)
+      begin
+        @classifier.register(uri, [handler])
+      rescue URIClassifier::RegistrationError
+        handlers = @classifier.resolve(uri)[2]
+        method_name = in_front ? 'unshift' : 'push'
+        handlers.send(method_name, handler)
+      end
+      handler.listener = self
+    end
+
+    # Removes any handlers registered at the given URI.  See Mongrel::URIClassifier#unregister
+    # for more information.  Remember this removes them *all* so the entire
+    # processing chain goes away.
+    def unregister(uri)
+      @classifier.unregister(uri)
+    end
+
+    def stop(synchronous=false)
+      #Mongrel.log(:debug, "stop invoked for #{self.inspect}")
+      Mongrel.log(:debug, "stop invoked for #{$$}")
+      #
+      # check for a nil acceptor, guard against stupid errors
+      if @acceptor.nil?
+        Mongrel.log(:error, "unexpected condition, the acceptor thread was nil in the stop method")
+        Mongrel.log(:error, Exception.new.backtrace.join("\n"))
+      else
+        @acceptor.raise(StopServer.new)
+
+        if synchronous
+          sleep(0.5) while @acceptor.alive?
+        end
+      end
+    end
+
+  end
+
+  # This is the main driver of Mongrel, while the Mongrel::HttpParser and Mongrel::URIClassifier
+  # make up the majority of how the server functions.  It's a very simple class that just
+  # has a thread accepting connections and a simple HttpServer.process_client function
+  # to do the heavy lifting with the IO and Ruby.  
+  #
+  # You use it by doing the following:
+  #
+  #   server = 2("0.0.0.0", 3000)
+  #   server.register("/stuff", MyNiftyHandler.new)
+  #   server.run.join
+  #
+  # The last line can be just server.run if you don't want to join the thread used.
+  # If you don't though Ruby will mysteriously just exit on you.
+  #
+  # Ruby's thread implementation is "interesting" to say the least.  Experiments with
+  # *many* different types of IO processing simply cannot make a dent in it.  Future
+  # releases of Mongrel will find other creative ways to make threads faster, but don't
+  # hold your breath until Ruby 1.9 is actually finally useful.
+  # 
+  # Functionality moved to base class by Brian Weaver (cmdrclueless at gmail.com) 2008-05-06
+  #
+  class HttpServer < Server
+    attr_reader :workers
+    attr_reader :throttle
+    attr_reader :timeout
+    attr_reader :num_processors
+
+    # Creates a working server on host:port (strange things happen if port isn't a Number).
+    # Use HttpServer::run to start the server and HttpServer.acceptor.join to 
+    # join the thread that's processing incoming requests on the socket.
+    #
+    # The num_processors optional argument is the maximum number of concurrent
+    # processors to accept, anything over this is closed immediately to maintain
+    # server processing performance.  This may seem mean but it is the most efficient
+    # way to deal with overload.  Other schemes involve still parsing the client's request
+    # which defeats the point of an overload handling system.
+    # 
+    # The throttle parameter is a sleep timeout (in hundredths of a second) that is placed between 
+    # socket.accept calls in order to give the server a cheap throttle time.  It defaults to 0 and
+    # actually if it is 0 then the sleep is not done at all.
+    #
+    def initialize(host, port, num_processors=950, throttle=0, timeout=60, log=nil, log_level=:debug)
+      
+      @host   = host
+      @port   = port
+      @domain = "tcp"
+
+      super(log, log_level)
+
+      @socket   = TCPServer.new(host, port) 
+      @workers  = ThreadGroup.new
+      @throttle = throttle
+      @timeout  = timeout
+      @num_processors = num_processors
+
+    end
+    
-    # Used internally to kill off any worker threads that have taken too long
-    # to complete processing.  Only called if there are too many processors
-    # currently servicing.  It returns the count of workers still active
-    # after the reap is done.  It only runs if there are workers to reap.
+    #
-    def reap_dead_workers(reason='unknown')
+
-      if @workers.list.length > 0
-
-
+
+
+
-        mark = Time.now
-        @workers.list.each do |worker|
-          worker[:started_on] = Time.now if not worker[:started_on]
-
-          if mark - worker[:started_on] > @timeout + @throttle
-#{Time.now.httpdate}: 
+
-            worker.raise(TimeoutError.new(error_msg))
-          end
-        end
+
-      end
-
-return 
+
-    end
-
-    # Performs a wait on all the currently running threads and kills any that take
-    # too long.  It waits by @timeout seconds, which can be set in .initialize or
-    # via mongrel_rails. The @throttle setting does extend this waiting period by
-    # that much longer.
+    #
-    def graceful_shutdown
-      while reap_dead_workers("shutdown") > 0
-#{Time.now.httpdate}: 
+
-        sleep @timeout / 10
-      end
-    end
-
-    def configure_socket_options
-      case RUBY_PLATFORM
-      when /linux/
-        # 9 is currently TCP_DEFER_ACCEPT
-        $tcp_defer_accept_opts = [Socket::SOL_TCP, 9, 1]
-        $tcp_cork_opts = [Socket::SOL_TCP, 3, 1]
-      when /freebsd(([1-4]\..{1,2})|5\.[0-4])/
-        # Do nothing, just closing a bug when freebsd <= 5.4
-      when /freebsd/
-        # Use the HTTP accept filter if available.
-        # The struct made by pack() is defined in /usr/include/sys/socket.h as accept_filter_arg
-        unless `/sbin/sysctl -nq net.inet.accf.http`.empty?
-          $tcp_defer_accept_opts = [Socket::SOL_SOCKET, Socket::SO_ACCEPTFILTER, ['httpready', nil].pack('a16a240')]
-        end
-      end
-    end
-    
-    # Runs the thing.  It returns the thread used so you can "join" it.  You can also
-    # access the HttpServer::acceptor attribute to get the thread later.
+    #
-    def run
-      BasicSocket.do_not_reverse_lookup=true
-
@@ -279 +367 @@
-
-              num_workers = @workers.list.length
-              if num_workers >= @num_processors
-#{Time.now.httpdate}: 
+
-                client.close rescue nil
-                reap_dead_workers("max processors")
-              else
@@ -301 +389 @@
-              # client closed the socket even before accept
-              client.close rescue nil
-            rescue Object => e
-#{Time.now.httpdate}: 
+
-              Mongrel.log(:error, e.backtrace.join("\n"))
-            end
-          end
-          graceful_shutdown
-        ensure
-          @socket.close
-          # Mongrel.log(:error, "#{Time.now.httpdate}: Closed socket.")
-        end
-      end
-
-return 
+
-    end
+  end
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-      end
-
+
+
-    end
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    end
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
+
+
+
+
+
-      end
+
+      if @busy.has_key?(pid)
+        io = @busy.delete(pid)
+        if io.respond_to?(:close)
+          io.close rescue nil
+        end
+      end
+
-    end
-
+    def run
+      BasicSocket.do_not_reverse_lookup = true
+      configure_socket_options
+
+      if defined?($tcp_defer_accept_opts) and $tcp_defer_accept_opts
+          @tcpsocket.setsockopt(*$tcp_defer_accept_opts) rescue nil
+      end
+
+      @acceptor = Thread.new do
+
+        begin
+          Mongrel.log("Server #{$$} ready to accept connections")
+          while not @terminate
+            begin
+              @children.each_key do |pid|
+                begin
+                  do_evict = false
+                  do_evict = true if (@children[pid].closed? or Process.waitpid(pid, Process::WNOHANG) == pid)
+                rescue Errno::ECHILD
+                  Mongrel.log(:debug, "Server #{$$} waitpid returned ECHILD, the server has no children")
+                  do_evict = true
+                rescue StopServer
+                  raise # pass it up the chain, don't ignore it.
+                rescue Object => e
+                  Mongrel.log(:error, "Server #{$$} Unhandled exception #{e.inspect}.")
+                  Mongrel.log(:error, e.backtrace.join("\n"))
+                end
+
+                evict_child(pid) if do_evict
+              end
+
+              if @children.length < @min_children
+                (@children.length .. @min_children).each do
+                  pid, socket = start_child
+                  @children[pid] = socket
+                  @busy[pid]     = true
+                end
+              end
+
+              readfds = [ @tcpsocket ] + @children.values 
+              r,w,e  = Kernel.select(readfds, nil, nil, 60)
+
+              # check to see if anyone wants to talk to us. If no one is talking
+              # and we have more than the necessary number of children then signal
+              # one to terminate.
+              #
+              evict_child(@children.keys.first) if (r.nil? or r.empty?) and @children.length > @min_children
+              next if r.nil?
+
+              # OK, someone is talking. Find out who and process the client.
+              # Delay the processing of the TCP server socket until all the children
+              # are finished. This allows a client to become available before processing
+              # the HTTP connection.
+              #
+              flag_http = false
+              r.each do |io|
+                if io == @tcpsocket # a new connection from apache or the outside world
+                  flag_http = true  # defer
+                else                # one of the children
+                  begin
+                    msg = io.readline
+                    msg.chomp!
+                    Mongrel.log(:debug, "Server #{$$} received message \"#{msg}\"")
+                    if msg =~ /^READY\s+(\d+)$/
+                      pid = $1.to_i
+                      if @busy[pid].respond_to?(:close)
+                        @busy[pid].close rescue nil
+                      end
+                      @busy[pid] = false
+                    elsif msg =~ /CLOSED\s+(\d+)/
+                      evict_child($1.to_i)
+                    end
+                  rescue EOFError => ex
+                    Mongrel.log(:error,ex.message)
+                    @children.each_key do |pid|
+                      evict_child(pid) if @children[pid] == io
+                    end
+                  end
+                end
+              end
+
+              next unless flag_http
+
+              client = nil
+              begin
+                client = @tcpsocket.accept
+              rescue StandardError => e
+                Mongrel.log(:error, "Server #{$$} An error occurred accepting a new client connection, a restart may be necessary.")
+                Mongrel.log(:error, "Server #{$$} #{e.message}")
+                Mongrel.log(:info, e.backtrace.join("\n"))
+              end
+
+              next if client.nil?
+
+              @busy.each_pair do |pid,busy|
+                unless busy
+                  io = @children[pid]
+                  io.send_io(client)
+                  io.flush
+
+                  @busy[pid] = client
+                  client = nil
+                  break
+                end
+              end
+
+              if client and not @max_children.nil? and @max_children == @children.length
+                Mongrel.log(:error, "Server #{$$} Maximum number of child processes exceeded, request aborted")
+                client.close rescue nil
+                client = nil
+              end
+
+              next unless client
+
+              Mongrel.log(:debug, "Server #{$$} No avaialble child found, spinning up a new child")
+
+              # spin up a new one
+              #
+              pid, socket = start_child
+              @children[pid] = socket
+              socket.readline
+              socket.send_io(client)
+              socket.flush
+              @busy[pid] = client
+
+            rescue StopServer
+              @terminate = true
+            rescue UriChangeEvent
+              Mongrel.log("URI Handler Changed, respawing children")
+              @children.keys.each { |pid| evict_child(pid) }
+            rescue Object => e
+              Mongrel.log(:error, "Server #{$$} Unhandled listen loop exception #{e.inspect}.")
+              Mongrel.log(:error, e.backtrace.join("\n"))
+            end
+          end
+        ensure
+          @tcpsocket.close  rescue nil
+          @children.each_key { |pid| evict_child(pid) }
+        end
+      end # end thread
+
+      @acceptor
+    end
+
+    def register(uri, handler, in_front=false)
+      super(uri,handler,in_front)
+      @acceptor.raise(UriChangeEvent.new) if not @acceptor.nil? and @acceptor.alive?
+    end
+
+    def unregister(uri)
+      super(uri)
+      @acceptor.raise(UriChangeEvent.new) if not @acceptor.nil? and @acceptor.alive?
+    end
+
-  end
-end
-
@@ -357 +707 @@
-
-$LOAD_PATH.unshift 'projects/mongrel_experimental/lib/'
-Mongrel::Gems.require 'mongrel_experimental', ">=#{Mongrel::Const::MONGREL_VERSION}"
+
+# vim:expandtab:shiftwidth=2:tabstop=2

bin/mongrel_rails

@@ -1 +1 @@
-# Copyright (c) 2005 Zed A. Shaw