mongrel 0.3.13.3 → 0.3.13.4

data/ext/http11/http11_parser.h

@@ -23,12 +23,14 @@ typedef struct http_parser {
   size_t mark;
   size_t field_start;
   size_t field_len;
+  size_t query_start;
 
   void *data;
 
   field_cb http_field;
   element_cb request_method;
   element_cb request_uri;
+  element_cb request_path;
   element_cb query_string;
   element_cb http_version;
   element_cb header_done;

data/ext/http11/http11_parser.rl

@@ -0,0 +1,192 @@
+/**
+ * Copyright (c) 2005 Zed A. Shaw
+ * You can redistribute it and/or modify it under the same terms as Ruby.
+ */
+#include "http11_parser.h"
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+
+#define LEN(AT, FPC) (FPC - buffer - parser->AT)
+#define MARK(M,FPC) (parser->M = (FPC) - buffer)
+#define PTR_TO(F) (buffer + parser->F)
+
+/** machine **/
+%%{
+  machine http_parser;
+
+  action mark {MARK(mark, fpc); }
+
+
+  action start_field { MARK(field_start, fpc); }
+  action write_field { 
+    parser->field_len = LEN(field_start, fpc);
+  }
+
+  action start_value { MARK(mark, fpc); }
+  action write_value { 
+    if(parser->http_field != NULL) {
+      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, fpc));
+    }
+  }
+  action request_method { 
+    if(parser->request_method != NULL) 
+      parser->request_method(parser->data, PTR_TO(mark), LEN(mark, fpc));
+  }
+  action request_uri { 
+    if(parser->request_uri != NULL)
+      parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, fpc));
+  }
+
+  action start_query {MARK(query_start, fpc); }
+  action query_string { 
+    if(parser->query_string != NULL)
+      parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, fpc));
+  }
+
+  action http_version {	
+    if(parser->http_version != NULL)
+      parser->http_version(parser->data, PTR_TO(mark), LEN(mark, fpc));
+  }
+
+  action request_path {
+    if(parser->request_path != NULL)
+      parser->request_path(parser->data, PTR_TO(mark), LEN(mark,fpc));
+  }
+
+  action done { 
+    parser->body_start = fpc - buffer + 1; 
+    if(parser->header_done != NULL)
+      parser->header_done(parser->data, fpc + 1, pe - fpc - 1);
+    fbreak;
+  }
+
+
+#### HTTP PROTOCOL GRAMMAR
+# line endings
+  CRLF = "\r\n";
+
+# character types
+  CTL = (cntrl | 127);
+  safe = ("$" | "-" | "_" | ".");
+  extra = ("!" | "*" | "'" | "(" | ")" | ",");
+  reserved = (";" | "/" | "?" | ":" | "@" | "&" | "=" | "+");
+  unsafe = (CTL | " " | "\"" | "#" | "%" | "<" | ">");
+  national = any -- (alpha | digit | reserved | extra | safe | unsafe);
+  unreserved = (alpha | digit | safe | extra | national);
+  escape = ("%" xdigit xdigit);
+  uchar = (unreserved | escape);
+  pchar = (uchar | ":" | "@" | "&" | "=" | "+");
+  tspecials = ("(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\\" | "\"" | "/" | "[" | "]" | "?" | "=" | "{" | "}" | " " | "\t");
+
+# elements
+  token = (ascii -- (CTL | tspecials));
+
+# URI schemes and absolute paths
+  scheme = ( alpha | digit | "+" | "-" | "." )* ;
+  absolute_uri = (scheme ":" (uchar | reserved )*);
+
+  path = (pchar+ ( "/" pchar* )*) ;
+  query = ( uchar | reserved )* %query_string ;
+  param = ( pchar | "/" )* ;
+  params = (param ( ";" param )*) ;
+  rel_path = (path? %request_path (";" params)?) ("?" %start_query query)?;
+  absolute_path = ("/"+ rel_path);
+
+  Request_URI = ("*" | absolute_uri | absolute_path) >mark %request_uri;
+  Method = (upper | digit | safe){1,20} >mark %request_method;
+
+  http_number = (digit+ "." digit+) ;
+  HTTP_Version = ("HTTP/" http_number) >mark %http_version ;
+  Request_Line = (Method " " Request_URI " " HTTP_Version CRLF) ;
+
+  field_name = (token -- ":")+ >start_field %write_field;
+
+  field_value = any* >start_value %write_value;
+
+  message_header = field_name ":" " "* field_value :> CRLF;
+
+  Request = Request_Line (message_header)* ( CRLF @done);
+
+main := Request;
+}%%
+
+/** Data **/
+%% write data;
+
+int http_parser_init(http_parser *parser)  {
+  int cs = 0;
+  %% write init;
+  parser->cs = cs;
+  parser->body_start = 0;
+  parser->content_len = 0;
+  parser->mark = 0;
+  parser->nread = 0;
+  parser->field_len = 0;
+  parser->field_start = 0;    
+
+  return(1);
+}
+
+
+/** exec **/
+size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off)  {
+  const char *p, *pe;
+  int cs = parser->cs;
+
+  assert(off <= len && "offset past end of buffer");
+
+  p = buffer+off;
+  pe = buffer+len;
+
+  assert(*pe == '\0' && "pointer does not end on NUL");
+  assert(pe - p == len - off && "pointers aren't same distance");
+
+
+  %% write exec;
+
+  parser->cs = cs;
+  parser->nread += p - (buffer + off);
+
+  assert(p <= pe && "buffer overflow after parsing execute");
+  assert(parser->nread <= len && "nread longer than length");
+  assert(parser->body_start <= len && "body starts after buffer end");
+  assert(parser->mark < len && "mark is after buffer end");
+  assert(parser->field_len <= len && "field has length longer than whole buffer");
+  assert(parser->field_start < len && "field starts after buffer end");
+
+  if(parser->body_start) {
+    /* final \r\n combo encountered so stop right here */
+    %%write eof;
+    parser->nread++;
+  }
+
+  return(parser->nread);
+}
+
+int http_parser_finish(http_parser *parser)
+{
+  int cs = parser->cs;
+
+  %%write eof;
+
+  parser->cs = cs;
+
+  if (http_parser_has_error(parser) ) {
+    return -1;
+  } else if (http_parser_is_finished(parser) ) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int http_parser_has_error(http_parser *parser) {
+  return parser->cs == http_parser_error;
+}
+
+int http_parser_is_finished(http_parser *parser) {
+  return parser->cs == http_parser_first_final;
+}

data/lib/mongrel.rb

@@ -4,6 +4,8 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
 # for more information.
 
+$mongrel_debug_client = false
+
 require 'socket'
 require 'http11'
 require 'tempfile'
@@ -14,17 +16,11 @@ require 'mongrel/handlers'
 require 'mongrel/command'
 require 'mongrel/tcphack'
 require 'yaml'
+require 'mongrel/configurator'
 require 'time'
 require 'rubygems'
 require 'etc'
 
-begin
-  require 'sendfile'
-  STDERR.puts "** You have sendfile installed, will use that to serve files."
-rescue Object
-  # do nothing
-end
-
 
 # Mongrel module containing all of the classes (include C extensions) for running
 # a Mongrel web server.  It contains a minimalist HTTP server with just enough
@@ -33,7 +29,7 @@ module Mongrel
 
   class URIClassifier
     attr_reader :handler_map
-  
+
     # Returns the URIs that have been registered with this classifier so far.
     # The URIs returned should not be modified as this will cause a memory leak.
     # You can use this to inspect the contents of the URIClassifier.
@@ -119,14 +115,15 @@ module Mongrel
 
     # The original URI requested by the client.  Passed to URIClassifier to build PATH_INFO and SCRIPT_NAME.
     REQUEST_URI='REQUEST_URI'.freeze
+    REQUEST_PATH='REQUEST_PATH'.freeze
 
-    MONGREL_VERSION="0.3.13.3".freeze
+    MONGREL_VERSION="0.3.13.4".freeze
 
     # TODO: this use of a base for tempfiles needs to be looked at for security problems
     MONGREL_TMP_BASE="mongrel".freeze
 
     # The standard empty 404 response for bad requests.  Use Error4040Handler for custom stuff.
-    ERROR_404_RESPONSE="HTTP/1.1 404 Not Found\r\nConnection: close\r\nServer: #{MONGREL_VERSION}\r\n\r\nNOT FOUND".freeze
+    ERROR_404_RESPONSE="HTTP/1.1 404 Not Found\r\nConnection: close\r\nServer: Mongrel #{MONGREL_VERSION}\r\n\r\nNOT FOUND".freeze
 
     CONTENT_LENGTH="CONTENT_LENGTH".freeze
 
@@ -134,7 +131,7 @@ module Mongrel
     ERROR_503_RESPONSE="HTTP/1.1 503 Service Unavailable\r\n\r\nBUSY".freeze
 
     # The basic max request size we'll try to read.
-    CHUNK_SIZE=(4 * 1024)
+    CHUNK_SIZE=(16 * 1024)
 
     # This is the maximum header that is allowed before a client is booted.  The parser detects
     # this, but we'd also like to do this as well.
@@ -144,7 +141,7 @@ module Mongrel
     MAX_BODY=MAX_HEADER
 
     # A frozen format for this is about 15% faster
-    STATUS_FORMAT = "HTTP/1.1 %d %s\r\nContent-Length: %d\r\nConnection: close\r\n".freeze
+    STATUS_FORMAT = "HTTP/1.1 %d %s\r\nConnection: close\r\n".freeze
     CONTENT_TYPE = "Content-Type".freeze
     LAST_MODIFIED = "Last-Modified".freeze
     ETAG = "ETag".freeze
@@ -158,11 +155,15 @@ module Mongrel
     LINE_END="\r\n".freeze
     REMOTE_ADDR="REMOTE_ADDR".freeze
     HTTP_X_FORWARDED_FOR="HTTP_X_FORWARDED_FOR".freeze
-    HTTP_IF_UNMODIFIED_SINCE="HTTP_IF_UNMODIFIED_SINCE".freeze
+    HTTP_IF_MODIFIED_SINCE="HTTP_IF_MODIFIED_SINCE".freeze
     HTTP_IF_NONE_MATCH="HTTP_IF_NONE_MATCH".freeze
     REDIRECT = "HTTP/1.1 302 Found\r\nLocation: %s\r\nConnection: close\r\n\r\n".freeze
   end
 
+  # Basically a Hash with one extra parameter for the HTTP body, mostly used internally.
+  class HttpParams < Hash
+    attr_accessor :http_body
+  end
 
   # When a handler is found for a registered URI then this class is constructed
   # and passed to your HttpHandler::process method.  You should assume that 
@@ -186,48 +187,82 @@ module Mongrel
     # body data into the HttpRequest.body attribute.
     #
     # TODO: Implement tempfile removal when the request is done.
-    def initialize(params, initial_body, socket, notifier)
+    def initialize(params, socket, dispatcher)
       @params = params
       @socket = socket
+      content_length = params[Const::CONTENT_LENGTH].to_i
+      remain = content_length - params.http_body.length
+      
 
-      clen = params[Const::CONTENT_LENGTH].to_i - initial_body.length
-      total = clen
+      dispatcher.request_begins(params) if dispatcher
 
-      if clen > Const::MAX_BODY
-        @body = Tempfile.new(Const::MONGREL_TMP_BASE)
-        @body.binmode
-      else
+      # Some clients (like FF1.0) report 0 for body and then send a body.  This will probably truncate them but at least the request goes through usually.
+      if remain <= 0
+        # we've got everything, pack it up
         @body = StringIO.new
+        @body.write params.http_body
+        dispatcher.request_progress(params, 0, content_length) if dispatcher
+      elsif remain > 0
+        # must read more data to complete body
+        if remain > Const::MAX_BODY
+          # huge body, put it in a tempfile
+          @body = Tempfile.new(Const::MONGREL_TMP_BASE)
+          @body.binmode
+        else
+          # small body, just use that
+          @body = StringIO.new 
+        end
+
+        @body.write params.http_body
+        read_body(remain, content_length, dispatcher)
       end
 
-      begin
-        @body.write(initial_body)
-        notifier.request_begins(params) if notifier
+      @body.rewind if body
+    end
+
 
+    # Does the heavy lifting of properly reading the larger body requests in 
+    # small chunks.  It expects @body to be an IO object, @socket to be valid,
+    # and will set @body = nil if the request fails.  It also expects any initial
+    # part of the body that has been read to be in the @body already.
+    def read_body(remain, total, dispatcher)
+      begin
         # write the odd sized chunk first
-        clen -= @body.write(@socket.read(clen % Const::CHUNK_SIZE))
-        notifier.request_progress(params, clen, total) if notifier
+
+        remain -= @body.write(read_socket(remain % Const::CHUNK_SIZE))
+        dispatcher.request_progress(params, remain, total) if dispatcher
 
         # then stream out nothing but perfectly sized chunks
-        while clen > 0 and !@socket.closed?
-          data = @socket.read(Const::CHUNK_SIZE)
-          # have to do it this way since @socket.eof? causes it to block
-          raise "Socket closed or read failure" if not data or data.length != Const::CHUNK_SIZE
-          clen -= @body.write(data)
+        until remain <= 0 or @socket.closed?
+          remain -= @body.write(read_socket(Const::CHUNK_SIZE))
           # ASSUME: we are writing to a disk and these writes always write the requested amount
-          notifier.request_progress(params, clen, total) if notifier
+          dispatcher.request_progress(params, remain, total) if dispatcher
         end
-
-        # rewind to keep the world happy
-        @body.rewind
       rescue Object
+        STDERR.puts "ERROR reading http body: #$!"
+        $!.backtrace.join("\n")
         # any errors means we should delete the file, including if the file is dumped
-        @socket.close unless @socket.closed?
+        @socket.close rescue Object
         @body.delete if @body.class == Tempfile
         @body = nil # signals that there was a problem
       end
     end
 
+    def read_socket(len)
+      if !@socket.closed?
+        data = @socket.read(len)
+        if !data
+          raise "Socket read return nil"
+        elsif data.length != len
+          raise "Socket read returned insufficient data: #{data.length}"
+        else
+          data
+        end
+      else
+        raise "Socket already closed when reading."
+      end
+    end
+
     # Performs URI escaping so that you can construct proper
     # query strings faster.  Use this rather than the cgi.rb
     # version since it's faster.  (Stolen from Camping).
@@ -363,15 +398,16 @@ module Mongrel
       elsif @header_sent
         raise "You have already sent the request headers."
       else
-        @header.out.rewind
-        @body.rewind
+        @header.out.truncate(0)
+        @body.close
+        @body = StringIO.new
       end
     end
 
-    def send_status(content_length=nil)
+    def send_status(content_length=@body.length)
       if not @status_sent
-        content_length ||= @body.length
-        write(Const::STATUS_FORMAT % [status, HTTP_STATUS_CODES[@status], content_length])
+        @header['Content-Length'] = content_length unless @status == 304
+        write(Const::STATUS_FORMAT % [@status, HTTP_STATUS_CODES[@status]])
         @status_sent = true
       end
     end
@@ -393,33 +429,29 @@ module Mongrel
     end 
 
     # Appends the contents of +path+ to the response stream.  The file is opened for binary
-    # reading and written in chunks to the socket.  If the 
-    # <a href="http://rubyforge.org/projects/ruby-sendfile">sendfile</a> library is found,
-    # it is used to send the file, often with greater speed and less memory/cpu usage.
+    # reading and written in chunks to the socket.
     #
-    # The presence of ruby-sendfile is determined by @socket.response_to? :sendfile, which means
-    # that if you have your own sendfile implementation you can use it without changing this function,
-    # just make sure it follows the ruby-sendfile signature.
-    def send_file(path)
-      File.open(path, "rb") do |f|
-        if @socket.respond_to? :sendfile
-          begin
-            @socket.sendfile(f)
-          rescue => details
-            socket_error(details)
-          end
-        else
+    # Sendfile API support has been removed in 0.3.13.4 due to stability problems.
+    def send_file(path, small_file = false)
+      if small_file
+        File.open(path, "rb") {|f| @socket << f.read }
+      else
+        File.open(path, "rb") do |f|
           while chunk = f.read(Const::CHUNK_SIZE) and chunk.length > 0
-            write(chunk)
+            begin
+              write(chunk)
+            rescue Object => exc
+              break
+            end
           end
         end
-        @body_sent = true
       end
+      @body_sent = true
     end
 
     def socket_error(details)
       # ignore these since it means the client closed off early
-      @socket.close unless @socket.closed?
+      @socket.close rescue Object
       done = true
       raise details
     end
@@ -514,7 +546,7 @@ module Mongrel
     def process_client(client)
       begin
         parser = HttpParser.new
-        params = {}
+        params = HttpParams.new
         request = nil
         data = client.readpartial(Const::CHUNK_SIZE)
         nparsed = 0
@@ -527,7 +559,7 @@ module Mongrel
           nparsed = parser.execute(params, data, nparsed)
 
           if parser.finished?
-            script_name, path_info, handlers = @classifier.resolve(params[Const::REQUEST_URI])
+            script_name, path_info, handlers = @classifier.resolve(params[Const::REQUEST_PATH])
 
             if handlers
               params[Const::PATH_INFO] = path_info
@@ -535,10 +567,7 @@ module Mongrel
               params[Const::REMOTE_ADDR] = params[Const::HTTP_X_FORWARDED_FOR] || client.peeraddr.last
               notifier = handlers[0].request_notify ? handlers[0] : nil
 
-              # TODO: Find a faster/better way to carve out the range, preferably without copying.
-              data = data[nparsed ... data.length] || ""
-
-              request = HttpRequest.new(params, data, client, notifier)
+              request = HttpRequest.new(params, client, notifier)
 
               # in the case of large file uploads the user could close the socket, so skip those requests
               break if request.body == nil  # nil signals from HttpRequest::initialize that the request was aborted
@@ -564,22 +593,29 @@ module Mongrel
             break #done
           else
             # Parser is not done, queue up more data to read and continue parsing
-            data << client.readpartial(Const::CHUNK_SIZE)
+            chunk = client.readpartial(Const::CHUNK_SIZE)
+            break if !chunk or chunk.length == 0  # read failed, stop processing
+
+            data << chunk
             if data.length >= Const::MAX_HEADER
               raise HttpParserError.new("HEADER is longer than allowed, aborting client early.")
             end
           end
         end
       rescue EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
-        # ignored
+        client.close rescue Object
       rescue HttpParserError
-        STDERR.puts "#{Time.now}: BAD CLIENT (#{params[Const::HTTP_X_FORWARDED_FOR] || client.peeraddr.last}): #$!"
+        if $mongrel_debug_client
+          STDERR.puts "#{Time.now}: BAD CLIENT (#{params[Const::HTTP_X_FORWARDED_FOR] || client.peeraddr.last}): #$!"
+          STDERR.puts "#{Time.now}: REQUEST DATA: #{data.inspect}\n---\nPARAMS: #{params.inspect}\n---\n"
+        end
       rescue Errno::EMFILE
         reap_dead_workers('too many files')
       rescue Object
         STDERR.puts "#{Time.now}: ERROR: #$!"
+        STDERR.puts $!.backtrace.join("\n") if $mongrel_debug_client
       ensure
-        client.close unless client.closed?
+        client.close rescue Object
         request.body.delete if request and request.body.class == Tempfile
       end
     end
@@ -591,13 +627,14 @@ module Mongrel
     def reap_dead_workers(reason='unknown')
       if @workers.list.length > 0
         STDERR.puts "#{Time.now}: Reaping #{@workers.list.length} threads for slow workers because of '#{reason}'"
+        error_msg = "Mongrel timed out this thread: #{reason}"
         mark = Time.now
         @workers.list.each do |w|
           w[:started_on] = Time.now if not w[:started_on]
 
           if mark - w[:started_on] > @death_time + @timeout
             STDERR.puts "Thread #{w.inspect} is too old, killing."
-            w.raise(TimeoutError.new("Timed out thread."))
+            w.raise(TimeoutError.new(error_msg))
           end
         end
       end
@@ -616,21 +653,34 @@ module Mongrel
       end
     end
 
+    def configure_socket_options
+      if /linux/ === RUBY_PLATFORM
+        # 9 is currently TCP_DEFER_ACCEPT
+        $tcp_defer_accept_opts = [9,1]
+        $tcp_cork_opts = [3,1]
+      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
 
+      configure_socket_options
+
+      @socket.setsockopt(Socket::SOL_TCP, $tcp_defer_accept_opts[0], $tcp_defer_accept_opts[1]) if $tcp_defer_accept_opts
+
       @acceptor = Thread.new do
         while true
           begin
             client = @socket.accept
+            client.setsockopt(Socket::SOL_TCP, $tcp_cork_opts[0], $tcp_cork_opts[1]) if $tcp_cork_opts
+
             worker_list = @workers.list
 
             if worker_list.length >= @num_processors
               STDERR.puts "Server overloaded with #{worker_list.length} processors (#@num_processors max). Dropping connection."
-              client.close
+              client.close rescue Object
               reap_dead_workers("max processors")
             else
               thread = Thread.new { process_client(client) }
@@ -641,11 +691,17 @@ module Mongrel
               sleep @timeout/100 if @timeout > 0
             end
           rescue StopServer
-            @socket.close if not @socket.closed?
+            @socket.close rescue Object
             break
           rescue Errno::EMFILE
             reap_dead_workers("too many open files")
             sleep 0.5
+          rescue Errno::ECONNABORTED
+            # client closed the socket even before accept
+            client.close rescue Object
+          rescue Object => exc
+            STDERR.puts "!!!!!! UNHANDLED EXCEPTION! #{exc}.  TELL ZED HE'S A MORON."
+            STDERR.puts $!.backtrace.join("\n") if $mongrel_debug_client
           end
         end
 
@@ -700,366 +756,4 @@ module Mongrel
     end
 
   end
-
-
-  # Implements a simple DSL for configuring a Mongrel server for your 
-  # purposes.  More used by framework implementers to setup Mongrel
-  # how they like, but could be used by regular folks to add more things
-  # to an existing mongrel configuration.
-  #
-  # It is used like this:
-  #
-  #   require 'mongrel'
-  #   config = Mongrel::Configurator.new :host => "127.0.0.1" do
-  #     listener :port => 3000 do
-  #       uri "/app", :handler => Mongrel::DirHandler.new(".", load_mime_map("mime.yaml"))
-  #     end
-  #     run
-  #   end
-  # 
-  # This will setup a simple DirHandler at the current directory and load additional
-  # mime types from mimy.yaml.  The :host => "127.0.0.1" is actually not 
-  # specific to the servers but just a hash of default parameters that all 
-  # server or uri calls receive.
-  #
-  # When you are inside the block after Mongrel::Configurator.new you can simply
-  # call functions that are part of Configurator (like server, uri, daemonize, etc)
-  # without having to refer to anything else.  You can also call these functions on 
-  # the resulting object directly for additional configuration.
-  #
-  # A major thing about Configurator is that it actually lets you configure 
-  # multiple listeners for any hosts and ports you want.  These are kept in a
-  # map config.listeners so you can get to them.
-  #
-  # * :pid_file => Where to write the process ID.
-  class Configurator
-    attr_reader :listeners
-    attr_reader :defaults
-    attr_reader :needs_restart
-
-    # You pass in initial defaults and then a block to continue configuring.
-    def initialize(defaults={}, &blk)
-      @listener = nil
-      @listener_name = nil
-      @listeners = {}
-      @defaults = defaults
-      @needs_restart = false
-      @pid_file = defaults[:pid_file]
-
-      if blk
-        cloaker(&blk).bind(self).call
-      end
-    end
-    
-    # Change privilege of the process to specified user and group.
-    def change_privilege(user, group)
-      begin
-        if group
-          log "Changing group to #{group}."
-          Process::GID.change_privilege(Etc.getgrnam(group).gid)
-        end
-
-        if user
-          log "Changing user to #{user}." 
-          Process::UID.change_privilege(Etc.getpwnam(user).uid)
-        end
-      rescue Errno::EPERM
-        log "FAILED to change user:group #{user}:#{group}: #$!"
-        exit 1
-      end
-    end
-
-    # Writes the PID file but only if we're on windows.
-    def write_pid_file
-      if RUBY_PLATFORM !~ /mswin/
-        open(@pid_file,"w") {|f| f.write(Process.pid) }
-      end
-    end
-
-    # generates a class for cloaking the current self and making the DSL nicer
-    def cloaking_class
-      class << self
-        self
-      end
-    end
-
-    # Do not call this.  You were warned.
-    def cloaker(&blk)
-      cloaking_class.class_eval do
-        define_method :cloaker_, &blk
-        meth = instance_method( :cloaker_ )
-        remove_method :cloaker_
-        meth
-      end
-    end
-
-    # This will resolve the given options against the defaults.
-    # Normally just used internally.
-    def resolve_defaults(options)
-      options.merge(@defaults)
-    end
-
-    # Starts a listener block.  This is the only one that actually takes
-    # a block and then you make Configurator.uri calls in order to setup
-    # your URIs and handlers.  If you write your Handlers as GemPlugins
-    # then you can use load_plugins and plugin to load them.
-    # 
-    # It expects the following options (or defaults):
-    # 
-    # * :host => Host name to bind.
-    # * :port => Port to bind.
-    # * :num_processors => The maximum number of concurrent threads allowed.  (950 default)
-    # * :timeout => 1/100th of a second timeout between requests. (10 is 1/10th, 0 is timeout)
-    # * :user => User to change to, must have :group as well.
-    # * :group => Group to change to, must have :user as well.
-    #
-    def listener(options={},&blk)
-      raise "Cannot call listener inside another listener block." if (@listener or @listener_name)
-      ops = resolve_defaults(options)
-      ops[:num_processors] ||= 950
-      ops[:timeout] ||= 0
-
-      @listener = Mongrel::HttpServer.new(ops[:host], ops[:port].to_i, ops[:num_processors].to_i, ops[:timeout].to_i)
-      @listener_name = "#{ops[:host]}:#{ops[:port]}"
-      @listeners[@listener_name] = @listener
-
-      if ops[:user] and ops[:group]
-        change_privilege(ops[:user], ops[:group])
-      end
-
-      # Does the actual cloaking operation to give the new implicit self.
-      if blk
-        cloaker(&blk).bind(self).call
-      end
-
-      # all done processing this listener setup, reset implicit variables
-      @listener = nil
-      @listener_name = nil
-    end
-
-
-    # Called inside a Configurator.listener block in order to 
-    # add URI->handler mappings for that listener.  Use this as
-    # many times as you like.  It expects the following options
-    # or defaults:
-    #
-    # * :handler => HttpHandler -- Handler to use for this location.
-    # * :in_front => true/false -- Rather than appending, it prepends this handler.
-    def uri(location, options={})
-      ops = resolve_defaults(options)
-      @listener.register(location, ops[:handler], in_front=ops[:in_front])
-    end
-
-
-    # Daemonizes the current Ruby script turning all the
-    # listeners into an actual "server" or detached process.
-    # You must call this *before* frameworks that open files
-    # as otherwise the files will be closed by this function.
-    #
-    # Does not work for Win32 systems (the call is silently ignored).
-    #
-    # Requires the following options or defaults:
-    #
-    # * :cwd => Directory to change to.
-    # * :log_file => Where to write STDOUT and STDERR.
-    # 
-    # It is safe to call this on win32 as it will only require the daemons
-    # gem/library if NOT win32.
-    def daemonize(options={})
-      ops = resolve_defaults(options)
-      # save this for later since daemonize will hose it
-      if RUBY_PLATFORM !~ /mswin/
-        require 'daemons/daemonize'
-
-        Daemonize.daemonize(log_file=File.join(ops[:cwd], ops[:log_file]))
-
-        # change back to the original starting directory
-        Dir.chdir(ops[:cwd])
-
-      else
-        log "WARNING: Win32 does not support daemon mode."
-      end
-    end
-
-
-    # Uses the GemPlugin system to easily load plugins based on their
-    # gem dependencies.  You pass in either an :includes => [] or 
-    # :excludes => [] setting listing the names of plugins to include
-    # or exclude from the when determining the dependencies.
-    def load_plugins(options={})
-      ops = resolve_defaults(options)
-
-      load_settings = {}
-      if ops[:includes]
-        ops[:includes].each do |plugin|
-          load_settings[plugin] = GemPlugin::INCLUDE
-        end
-      end
-
-      if ops[:excludes]
-        ops[:excludes].each do |plugin|
-          load_settings[plugin] = GemPlugin::EXCLUDE
-        end
-      end
-
-      GemPlugin::Manager.instance.load(load_settings)
-    end
-
-
-    # Easy way to load a YAML file and apply default settings.
-    def load_yaml(file, default={})
-      default.merge(YAML.load_file(file))
-    end
-
-
-    # Loads the MIME map file and checks that it is correct
-    # on loading.  This is commonly passed to Mongrel::DirHandler
-    # or any framework handler that uses DirHandler to serve files.
-    # You can also include a set of default MIME types as additional
-    # settings.  See Mongrel::DirHandler for how the MIME types map
-    # is organized.
-    def load_mime_map(file, mime={})
-      # configure any requested mime map
-      mime = load_yaml(file, mime)
-
-      # check all the mime types to make sure they are the right format
-      mime.each {|k,v| log "WARNING: MIME type #{k} must start with '.'" if k.index(".") != 0 }
-
-      return mime
-    end
-
-
-    # Loads and creates a plugin for you based on the given
-    # name and configured with the selected options.  The options
-    # are merged with the defaults prior to passing them in.
-    def plugin(name, options={})
-      ops = resolve_defaults(options)
-      GemPlugin::Manager.instance.create(name, ops)
-    end
-
-    # Let's you do redirects easily as described in Mongrel::RedirectHandler.
-    # You use it inside the configurator like this:
-    #
-    #   redirect("/test", "/to/there") # simple
-    #   redirect("/to", /t/, 'w') # regexp
-    #   redirect("/hey", /(w+)/) {|match| ...}  # block
-    #
-    def redirect(from, pattern, replacement = nil, &block)
-      uri from, :handler => Mongrel::RedirectHandler.new(pattern, replacement, &block)
-    end
-
-    # Works like a meta run method which goes through all the 
-    # configured listeners.  Use the Configurator.join method
-    # to prevent Ruby from exiting until each one is done.
-    def run
-      @listeners.each {|name,s| 
-        s.run 
-      }
-
-      $mongrel_sleeper_thread = Thread.new { loop { sleep 1 } }
-    end
-
-    # Calls .stop on all the configured listeners so they
-    # stop processing requests (gracefully).  By default it
-    # assumes that you don't want to restart and that the pid file
-    # should be unlinked on exit.
-    def stop(needs_restart=false, unlink_pid_file=true)
-      @listeners.each {|name,s| 
-        s.stop 
-      }
-
-      @needs_restart = needs_restart
-      if unlink_pid_file
-        File.unlink @pid_file if (@pid_file and File.exist?(@pid_file))
-      end 
-    end
-
-
-    # This method should actually be called *outside* of the
-    # Configurator block so that you can control it.  In other words
-    # do it like:  config.join.
-    def join
-      @listeners.values.each {|s| s.acceptor.join }
-    end
-
-
-    # Calling this before you register your URIs to the given location
-    # will setup a set of handlers that log open files, objects, and the
-    # parameters for each request.  This helps you track common problems
-    # found in Rails applications that are either slow or become unresponsive
-    # after a little while.
-    #
-    # You can pass an extra parameter *what* to indicate what you want to 
-    # debug.  For example, if you just want to dump rails stuff then do:
-    #
-    #   debug "/", what = [:rails]
-    # 
-    # And it will only produce the log/mongrel_debug/rails.log file.
-    # Available options are:  :objects, :rails, :files, :threads, :params
-    # 
-    # NOTE: Use [:files] to get accesses dumped to stderr like with WEBrick.
-    def debug(location, what = [:objects, :rails, :files, :threads, :params])
-      require 'mongrel/debug'
-      handlers = {
-        :files => "/handlers/requestlog::access", 
-        :rails => "/handlers/requestlog::files", 
-        :objects => "/handlers/requestlog::objects", 
-        :threads => "/handlers/requestlog::threads",
-        :params => "/handlers/requestlog::params"
-      }
-
-      # turn on the debugging infrastructure, and ObjectTracker is a pig
-      ObjectTracker.configure if what.include? :objects
-      MongrelDbg.configure
-
-      # now we roll through each requested debug type, turn it on and load that plugin
-      what.each do |type| 
-        MongrelDbg.begin_trace type 
-        uri location, :handler => plugin(handlers[type])
-      end
-    end
-
-    # Used to allow you to let users specify their own configurations
-    # inside your Configurator setup.  You pass it a script name and
-    # it reads it in and does an eval on the contents passing in the right
-    # binding so they can put their own Configurator statements.
-    def run_config(script)
-      open(script) {|f| eval(f.read, proc {self}) }
-    end
-
-    # Sets up the standard signal handlers that are used on most Ruby
-    # It only configures if the platform is not win32 and doesn't do
-    # a HUP signal since this is typically framework specific.
-    #
-    # Requires a :pid_file option given to Configurator.new to indicate a file to delete.  
-    # It sets the MongrelConfig.needs_restart attribute if 
-    # the start command should reload.  It's up to you to detect this
-    # and do whatever is needed for a "restart".
-    #
-    # This command is safely ignored if the platform is win32 (with a warning)
-    def setup_signals(options={})
-      ops = resolve_defaults(options)
-
-      # forced shutdown, even if previously restarted (actually just like TERM but for CTRL-C)
-      trap("INT") { log "INT signal received."; stop(need_restart=false) }
-
-      if RUBY_PLATFORM !~ /mswin/
-        # graceful shutdown
-        trap("TERM") { log "TERM signal received."; stop }
-
-        # restart
-        trap("USR2") { log "USR2 signal received."; stop(need_restart=true) }
-
-        log "Signals ready.  TERM => stop.  USR2 => restart.  INT => stop (no restart)."
-      else
-        log "Signals ready.  INT => stop (no restart)."
-      end
-    end
-
-    # Logs a simple message to STDERR (or the mongrel log if in daemon mode).
-    def log(msg)
-      STDERR.print "** ", msg, "\n"
-    end
-
-  end
 end