Ticket #30: mongrel_patch_stable_1-1.20080624-rev_1028.patch

branches/stable_1-1/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 = 9998
+    @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
+

branches/stable_1-1/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', 9998, 1)
+    end
+    @server.run
+    @client = Net::HTTP.new('127.0.0.1', 9998)
+  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
+
+

branches/stable_1-1/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', 3501, 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

branches/stable_1-1/lib/mongrel/configurator.rb

@@ -136 +136 @@
-      ops[:throttle] ||= 0
-      ops[:timeout] ||= 60
-
-
+
+
-      @listener_name = "#{ops[:host]}:#{ops[:port]}"
-      @listeners[@listener_name] = @listener
-
@@ -386 +387 @@
-
-  end
-end
+# vim:shiftwidth=2:tabstop=2:expandtab:ft=ruby

branches/stable_1-1/lib/mongrel.rb

@@ -40 +40 @@
-  # 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
-
+  class Server
+    attr_accessor :classifier
+    attr_reader   :acceptor
+    attr_reader   :domain
+    attr_reader   :host
+    attr_reader   :port
-
-  # 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 = HttpServer.new("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.
-  class HttpServer
-    attr_reader :acceptor
-    attr_reader :workers
-    attr_reader :classifier
-    attr_reader :host
-    attr_reader :port
-    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.
@@ -87 +67 @@
-    # 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.
-
-
-
-
-
+
-      @classifier = URIClassifier.new
-      @host = host
-      @port = port
-      @workers = ThreadGroup.new
-      @throttle = throttle / 100.0
-      @num_processors = num_processors
-      @timeout = timeout
-    end
-
-    # Does the majority of the IO processing.  It has been written in Ruby using
@@ -204 +174 @@
-      end
-    end
-
+    def read_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
+
+    # Stops the acceptor thread and then causes the worker threads to finish
+    # off the request queue before finally exiting.
+    def stop(synchronous=false)
+      unless @acceptor.nil?
+        @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 = HttpServer.new("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.
+  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)
+      @host = host
+      @port = port
+      @domain = "tcp"
+      super()
+
+      @socket = TCPServer.new(host, port) 
+      @workers = ThreadGroup.new
+      @throttle = throttle / 100.0
+      @num_processors = num_processors
+      @timeout = timeout
+    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
@@ -236 +320 @@
-        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.
@@ -310 +377 @@
-
-      return @acceptor
-    end
+  end
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-      end
-handler.listener = self
+return @acceptor
-    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
+          @serversock.setsockopt(*$tcp_defer_accept_opts) rescue nil
+      end
+
+      @acceptor = Thread.new do
+
+        begin
+          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
+                  do_evict = true
+                rescue StopServer
+                  raise # pass it up the chain, don't ignore it.
+                rescue Object => e
+                  STDERR.puts "Server #{$$} Unhandled exception #{e.inspect}."
+                  STDERR.puts 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 = [ @serversock ] + @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 == @serversock # a new connection from apache or the outside world
+                  flag_http = true  # defer
+                else                # one of the children
+                  begin
+                    msg = io.readline
+                    msg.chomp!
+                    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
+                    @children.each_key do |pid|
+                      evict_child(pid) if @children[pid] == io
+                    end
+                  end
+                end
+              end
+
+              next unless flag_http
+
+              client = nil
+              begin
+                client = @serversock.accept
+              rescue StandardError => e
+                STDERR.puts "Server #{$$} An error occurred accepting a new client connection, a restart may be necessary."
+                STDERR.puts "Server #{$$} #{e.message}"
+              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
+                STDERR.puts "Server #{$$} Maximum number of child processes exceeded, request aborted"
+                client.close rescue nil
+                client = nil
+              end
+
+              next unless client
+
+              # 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
+              @children.keys.each { |pid| evict_child(pid) }
+            rescue Object => e
+              STDERR.puts "Server #{$$} Unhandled listen loop exception #{e.inspect}."
+              STDERR.puts e.backtrace.join("\n")
+            end
+          end
+        ensure
+          @serversock.close  rescue nil
+          @children.each_key { |pid| evict_child(pid) }
+        end
+      end # end thread
+
+      return @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
-
@@ -353 +662 @@
-
-$LOAD_PATH.unshift 'projects/mongrel_experimental/lib/'
-Mongrel::Gems.require 'mongrel_experimental', ">=#{Mongrel::Const::MONGREL_VERSION}"
+
+# vim:expandtab:shiftwidth=2:tabstop=2

branches/stable_1-1/bin/mongrel_rails

@@ -1 +1 @@
-# Copyright (c) 2005 Zed A. Shaw
+# Copyright (c) 2008 Raritan Computer, Inc (Brian Weaver <brian.weaver@raritan.com>)
-# 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
@@ -27 +28 @@
-        ['-p', '--port PORT', "Which port to bind to", :@port, 3000],
-        ['-a', '--address ADDR', "Address to bind to", :@address, "0.0.0.0"],
-        ['-l', '--log FILE', "Where to write log messages", :@log_file, "log/mongrel.log"],
+        ['-L', '--log-level (debug|notice|warn|info|error)', "The logging level", :@log_level, 'debug'],
-        ['-P', '--pid FILE', "Where to write the PID", :@pid_file, "log/mongrel.pid"],
-        ['-n', '--num-processors INT', "Number of processors active before clients denied", :@num_processors, 1024],
-        ['-o', '--timeout TIME', "Time to wait (in seconds) before killing a stalled thread", :@timeout, 60],
@@ -38 +40 @@
-        ['-C', '--config PATH', "Use a config file", :@config_file, nil],
-        ['-S', '--script PATH', "Load the given file as an extra config script", :@config_script, nil],
-        ['-G', '--generate PATH', "Generate a config file for use with -C", :@generate, nil],
+        ['-U', '--unixmaster', "Run the rails as a master-slave server", :@unixmaster, false],
+        ['-N', '--children COUNT', "The default number of unix slaves to start", :@min_children, 5],
+        ['-M', '--max-children COUNT', "The maximum number of unix slaves to start", :@max_children, nil],
-        ['', '--user USER', "User to run as", :@user, nil],
-        ['', '--group GROUP', "Group to run as", :@group, nil],
-        ['', '--prefix PATH', "URL prefix for Rails app", :@prefix, nil]
@@ -69 +74 @@
-      valid_user? @user if @user
-      valid_group? @group if @group
-
+      @log_level = @log_level.to_sym unless @log_level.nil? or @log_level.is_a?(Symbol)
+
-      return @valid
-    end
-
@@ -92 +99 @@
-          daemonize
-          log "Daemonized, any open files are closed.  Look at #{defaults[:pid_file]} and #{defaults[:log_file]} for info."
-          log "Settings loaded from #{@config_file} (they override command line)." if @config_file
+
+          write_pid_file
-        end
-
-        log "Starting Mongrel listening at #{defaults[:host]}:#{defaults[:port]}"
@@ -128 +137 @@
-      config.run
-      config.log "Mongrel #{Mongrel::Const::MONGREL_VERSION} available at #{@address}:#{@port}"
-
-
-
-
+
-        config.log "Use CTRL-C to stop." 
-      end
-
@@ -180 +187 @@
-
-    def config_keys
-      @config_keys ||=
-
+ unixmaster min_children max_children
-    end
-
-    def settings
@@ -281 +288 @@
-if not Mongrel::Command::Registry.instance.run ARGV
-  exit 1
-end
+
+# vim:shiftwidth=2:tabstop=2:expandtab:ft=ruby