mongrel 0.3.11 → 0.3.12

data/examples/builder.rb

@@ -0,0 +1,29 @@
+require 'mongrel'
+
+class TestPlugin < GemPlugin::Plugin "/handlers"
+  include Mongrel::HttpHandlerPlugin
+
+  def process(request, response)
+    STDERR.puts "My options are: #{options.inspect}"
+    STDERR.puts "Request Was:"
+    STDERR.puts request.params.to_yaml
+  end
+end
+
+config = Mongrel::Configurator.new :host => "127.0.0.1" do
+  load_plugins :includes => ["mongrel"], :excludes => ["rails"]
+  daemonize :cwd => Dir.pwd, :log_file => "mongrel.log", :pid_file => "mongrel.pid"
+  
+  listener :port => 3000 do
+    uri "/app", :handler => plugin("/handlers/testplugin", :test => "that")
+    uri "/app", :handler => Mongrel::DirHandler.new(".")
+    load_plugins :includes => ["mongrel", "rails"]
+  end
+
+  trap("INT") { stop }
+  run
+end
+
+config.join
+
+

data/examples/camping/blog.rb

@@ -277,9 +277,18 @@ if __FILE__ == $0
   Blog::Models::Base.logger = Logger.new('camping.log')
   Blog::Models::Base.threaded_connections=false
   Blog.create
+  
+  # Use the Configurator as an example rather than Mongrel::Camping.start
+  config = Mongrel::Configurator.new :host => "0.0.0.0" do
+    listener :port => 3002 do
+      uri "/blog", :handler => CampingHandler.new(Blog)
+      uri "/favicon", :handler => Mongrel::Error404Handler.new("")
+      trap("INT") { stop }
+      run
+    end
+  end
 
-  server = Mongrel::Camping::start("0.0.0.0",3002,"/blog",Blog)
   puts "** Blog example is running at http://localhost:3002/blog"
   puts "** Default username is `admin', password is `camping'"
-  server.acceptor.join
+  config.join
 end

data/examples/simpletest.rb

@@ -19,18 +19,31 @@ class SimpleHandler < Mongrel::HttpHandler
     end
 end
 
+class DumbHandler < Mongrel::HttpHandler
+  def process(request, response)
+    response.start do |head,out|
+      head["Content-Type"] = "text/html"
+      out.write("test")
+    end
+  end
+end
+
+
 if ARGV.length != 3
   STDERR.puts "usage:  simpletest.rb <host> <port> <docroot>"
   exit(1)
 end
 
-h = Mongrel::HttpServer.new(ARGV[0], ARGV[1].to_i)
-h.register("/", SimpleHandler.new)
-h.register("/files", Mongrel::DirHandler.new(ARGV[2]))
-h.run
+config = Mongrel::Configurator.new :host => ARGV[0], :port => ARGV[1] do
+  listener do
+    uri "/", :handler => SimpleHandler.new
+    uri "/dumb", :handler => DumbHandler.new
+    uri "/files", :handler => Mongrel::DirHandler.new(ARGV[2])
+  end
 
-trap("INT") { h.stop }
+  trap("INT") { stop }
+  run
+end
 
 puts "Mongrel running on #{ARGV[0]}:#{ARGV[1]} with docroot #{ARGV[2]}"
-
-h.acceptor.join
+config.join

data/ext/http11/http11.c

@@ -16,7 +16,24 @@ static VALUE global_request_method;
 static VALUE global_request_uri;
 static VALUE global_query_string;
 static VALUE global_http_version;
-
+static VALUE global_content_length;
+static VALUE global_http_content_length;
+static VALUE global_content_type;
+static VALUE global_http_content_type;
+static VALUE global_gateway_interface;
+static VALUE global_gateway_interface_value;
+static VALUE global_interface_value;
+static VALUE global_remote_address;
+static VALUE global_server_name;
+static VALUE global_server_port;
+static VALUE global_server_protocol;
+static VALUE global_server_protocol_value;
+static VALUE global_http_host;
+static VALUE global_mongrel_version;
+static VALUE global_server_software;
+static VALUE global_port_80;
+
+#define DEF_GLOBAL(name, val)   global_##name = rb_obj_freeze(rb_str_new2(val)); rb_global_variable(&global_##name);
 
 void http_field(void *data, const char *field, size_t flen, const char *value, size_t vlen)
 {
@@ -67,8 +84,37 @@ void http_version(void *data, const char *at, size_t length)
   rb_hash_aset(req, global_http_version, val);
 }
 
+/** Finalizes the request header to have a bunch of stuff that's
+    needed. */
 
-
+void header_done(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE temp = Qnil;
+  VALUE host = Qnil;
+  VALUE port = Qnil;
+  char *colon = NULL;
+
+  rb_hash_aset(req, global_content_length, rb_hash_aref(req, global_http_content_length));
+  rb_hash_aset(req, global_content_type, rb_hash_aref(req, global_http_content_type));
+  rb_hash_aset(req, global_gateway_interface, global_gateway_interface_value);
+  if((temp = rb_hash_aref(req, global_http_host)) != Qnil) {
+    // ruby better close strings off with a '\0' dammit
+    colon = strchr(RSTRING(temp)->ptr, ':');
+    if(colon != NULL) {
+      rb_hash_aset(req, global_server_name, rb_str_substr(temp, 0, colon - RSTRING(temp)->ptr));
+      rb_hash_aset(req, global_server_port, 
+		   rb_str_substr(temp, colon - RSTRING(temp)->ptr+1, 
+				 RSTRING(temp)->len));
+    } else {
+      rb_hash_aset(req, global_server_name, temp);
+      rb_hash_aset(req, global_server_port, global_port_80);
+    }
+  }
+  
+  rb_hash_aset(req, global_server_protocol, global_server_protocol_value);
+  rb_hash_aset(req, global_server_software, global_mongrel_version);
+}
 
 
 void HttpParser_free(void *data) {
@@ -90,7 +136,8 @@ VALUE HttpParser_alloc(VALUE klass)
     hp->request_uri = request_uri;
     hp->query_string = query_string;
     hp->http_version = http_version;
-    
+    hp->header_done = header_done;
+
     obj = Data_Wrap_Struct(klass, NULL, HttpParser_free, hp);
 
     return obj;
@@ -413,17 +460,27 @@ void Init_http11()
   mMongrel = rb_define_module("Mongrel");
   id_handler_map = rb_intern("@handler_map");
 
-  global_http_prefix = rb_str_new2("HTTP_");
-  rb_global_variable(&global_http_prefix);
-  global_request_method = rb_str_new2("REQUEST_METHOD");
-  rb_global_variable(&global_request_method);
-  global_request_uri = rb_str_new2("REQUEST_URI");
-  rb_global_variable(&global_request_uri);
-  global_query_string = rb_str_new2("QUERY_STRING");
-  rb_global_variable(&global_query_string);
-  global_http_version = rb_str_new2("HTTP_VERSION");
-  rb_global_variable(&global_http_version);
-  
+  DEF_GLOBAL(http_prefix, "HTTP_");
+  DEF_GLOBAL(request_method, "REQUEST_METHOD");
+  DEF_GLOBAL(request_uri, "REQUEST_URI");
+  DEF_GLOBAL(query_string, "QUERY_STRING");
+  DEF_GLOBAL(http_version, "HTTP_VERSION");
+  DEF_GLOBAL(content_length, "CONTENT_LENGTH");
+  DEF_GLOBAL(http_content_length, "HTTP_CONTENT_LENGTH");
+  DEF_GLOBAL(content_type, "CONTENT_TYPE");
+  DEF_GLOBAL(http_content_type, "HTTP_CONTENT_TYPE");
+  DEF_GLOBAL(gateway_interface, "GATEWAY_INTERFACE");
+  DEF_GLOBAL(gateway_interface_value, "CGI/1.2");
+  DEF_GLOBAL(remote_address, "REMOTE_ADDR");
+  DEF_GLOBAL(server_name, "SERVER_NAME");
+  DEF_GLOBAL(server_port, "SERVER_PORT");
+  DEF_GLOBAL(server_protocol, "SERVER_PROTOCOL");
+  DEF_GLOBAL(server_protocol_value, "HTTP/1.1");
+  DEF_GLOBAL(http_host, "HTTP_HOST");
+  DEF_GLOBAL(mongrel_version, "Mongrel 0.3.12");
+  DEF_GLOBAL(server_software, "SERVER_SOFTWARE");
+  DEF_GLOBAL(port_80, "80");
+
   cHttpParser = rb_define_class_under(mMongrel, "HttpParser", rb_cObject);
   rb_define_alloc_func(cHttpParser, HttpParser_alloc);
   rb_define_method(cHttpParser, "initialize", HttpParser_init,0);

data/ext/http11/http11_parser.c

@@ -9,7 +9,7 @@
 #define MARK(S,F) assert((F) - (S)->mark >= 0); (S)->mark = (F);
 
 /** machine **/
-#line 98 "ext/http11/http11_parser.rl"
+#line 101 "ext/http11/http11_parser.rl"
 
 
 /** Data **/
@@ -21,7 +21,7 @@ static int http_parser_first_final = 53;
 
 static int http_parser_error = 1;
 
-#line 102 "ext/http11/http11_parser.rl"
+#line 105 "ext/http11/http11_parser.rl"
 
 int http_parser_init(http_parser *parser)  {
     int cs = 0;
@@ -30,7 +30,7 @@ int http_parser_init(http_parser *parser)  {
 	{
 	cs = http_parser_start;
 	}
-#line 106 "ext/http11/http11_parser.rl"
+#line 109 "ext/http11/http11_parser.rl"
     parser->cs = cs;
     parser->body_start = NULL;
     parser->content_len = 0;
@@ -305,14 +305,17 @@ case 21:
 tr40:
 #line 46 "ext/http11/http11_parser.rl"
 	{ 
-	       parser->body_start = p+1; goto _out53;
+	       parser->body_start = p+1; 
+	       if(parser->header_done != NULL)
+	       	       parser->header_done(parser->data, p, 0);
+	       goto _out53;
 	}
 	goto st53;
 st53:
 	if ( ++p == pe )
 		goto _out53;
 case 53:
-#line 316 "ext/http11/http11_parser.c"
+#line 319 "ext/http11/http11_parser.c"
 	goto st1;
 tr36:
 #line 16 "ext/http11/http11_parser.rl"
@@ -322,7 +325,7 @@ st22:
 	if ( ++p == pe )
 		goto _out22;
 case 22:
-#line 326 "ext/http11/http11_parser.c"
+#line 329 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 33: goto st22;
 		case 58: goto tr32;
@@ -357,7 +360,7 @@ st23:
 	if ( ++p == pe )
 		goto _out23;
 case 23:
-#line 361 "ext/http11/http11_parser.c"
+#line 364 "ext/http11/http11_parser.c"
 	if ( (*p) == 13 )
 		goto tr49;
 	goto tr52;
@@ -369,7 +372,7 @@ st24:
 	if ( ++p == pe )
 		goto _out24;
 case 24:
-#line 373 "ext/http11/http11_parser.c"
+#line 376 "ext/http11/http11_parser.c"
 	if ( (*p) == 13 )
 		goto tr49;
 	goto st24;
@@ -381,7 +384,7 @@ st25:
 	if ( ++p == pe )
 		goto _out25;
 case 25:
-#line 385 "ext/http11/http11_parser.c"
+#line 388 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 43: goto st25;
 		case 58: goto st26;
@@ -406,7 +409,7 @@ st26:
 	if ( ++p == pe )
 		goto _out26;
 case 26:
-#line 410 "ext/http11/http11_parser.c"
+#line 413 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 32: goto tr34;
 		case 37: goto st27;
@@ -454,7 +457,7 @@ st29:
 	if ( ++p == pe )
 		goto _out29;
 case 29:
-#line 458 "ext/http11/http11_parser.c"
+#line 461 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 32: goto tr34;
 		case 37: goto st31;
@@ -525,7 +528,7 @@ st33:
 	if ( ++p == pe )
 		goto _out33;
 case 33:
-#line 529 "ext/http11/http11_parser.c"
+#line 532 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 32: goto tr46;
 		case 37: goto tr51;
@@ -547,7 +550,7 @@ st34:
 	if ( ++p == pe )
 		goto _out34;
 case 34:
-#line 551 "ext/http11/http11_parser.c"
+#line 554 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 32: goto tr46;
 		case 37: goto st35;
@@ -569,7 +572,7 @@ st35:
 	if ( ++p == pe )
 		goto _out35;
 case 35:
-#line 573 "ext/http11/http11_parser.c"
+#line 576 "ext/http11/http11_parser.c"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto st36;
@@ -600,7 +603,7 @@ st37:
 	if ( ++p == pe )
 		goto _out37;
 case 37:
-#line 604 "ext/http11/http11_parser.c"
+#line 607 "ext/http11/http11_parser.c"
 	if ( (*p) == 69 )
 		goto st38;
 	goto st1;
@@ -619,7 +622,7 @@ st39:
 	if ( ++p == pe )
 		goto _out39;
 case 39:
-#line 623 "ext/http11/http11_parser.c"
+#line 626 "ext/http11/http11_parser.c"
 	if ( (*p) == 69 )
 		goto st40;
 	goto st1;
@@ -645,7 +648,7 @@ st42:
 	if ( ++p == pe )
 		goto _out42;
 case 42:
-#line 649 "ext/http11/http11_parser.c"
+#line 652 "ext/http11/http11_parser.c"
 	if ( (*p) == 80 )
 		goto st43;
 	goto st1;
@@ -692,7 +695,7 @@ st48:
 	if ( ++p == pe )
 		goto _out48;
 case 48:
-#line 696 "ext/http11/http11_parser.c"
+#line 699 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 79: goto st49;
 		case 85: goto st38;
@@ -713,7 +716,7 @@ st50:
 	if ( ++p == pe )
 		goto _out50;
 case 50:
-#line 717 "ext/http11/http11_parser.c"
+#line 720 "ext/http11/http11_parser.c"
 	if ( (*p) == 82 )
 		goto st51;
 	goto st1;
@@ -788,15 +791,15 @@ case 52:
 
 	_out: {}
 	}
-#line 125 "ext/http11/http11_parser.rl"
+#line 128 "ext/http11/http11_parser.rl"
 
     parser->cs = cs;
     parser->nread = p - buffer;
     if(parser->body_start) {
         /* final \r\n combo encountered so stop right here */
 	
-#line 799 "ext/http11/http11_parser.c"
-#line 131 "ext/http11/http11_parser.rl"
+#line 802 "ext/http11/http11_parser.c"
+#line 134 "ext/http11/http11_parser.rl"
 	parser->nread++;
     }
 
@@ -808,8 +811,8 @@ int http_parser_finish(http_parser *parser)
 	int cs = parser->cs;
 
 	
-#line 812 "ext/http11/http11_parser.c"
-#line 142 "ext/http11/http11_parser.rl"
+#line 815 "ext/http11/http11_parser.c"
+#line 145 "ext/http11/http11_parser.rl"
 
 	parser->cs = cs;
 

data/ext/http11/http11_parser.h

@@ -26,7 +26,8 @@ typedef struct http_parser {
   element_cb request_uri;
   element_cb query_string;
   element_cb http_version;
-
+  element_cb header_done;
+  
 } http_parser;
 
 int http_parser_init(http_parser *parser);

data/lib/mongrel.rb

@@ -5,8 +5,8 @@ require 'stringio'
 require 'mongrel/cgi'
 require 'mongrel/handlers'
 require 'mongrel/command'
-require 'timeout'
 require 'mongrel/tcphack'
+require 'yaml'
 
 
 # Mongrel module containing all of the classes (include C extensions) for running
@@ -88,73 +88,52 @@ module Mongrel
   # REMOTE_USER, or REMOTE_HOST parameters since those are either a security problem or 
   # too taxing on performance.
   module Const
-    # This is the part of the path after the SCRIPT_NAME.  URIClassifier will determine this.
-    PATH_INFO="PATH_INFO"
-    # This is the intial part that your handler is identified as by URIClassifier.
-    SCRIPT_NAME="SCRIPT_NAME"
-    # The original URI requested by the client.  Passed to URIClassifier to build PATH_INFO and SCRIPT_NAME.
-    REQUEST_URI='REQUEST_URI'
-
-    # Content length (also available as HTTP_CONTENT_LENGTH).
-    CONTENT_LENGTH='CONTENT_LENGTH'
-
-    # Content length (also available as CONTENT_LENGTH).
-    HTTP_CONTENT_LENGTH='HTTP_CONTENT_LENGTH'
-
-    # Content type (also available as HTTP_CONTENT_TYPE).
-    CONTENT_TYPE='CONTENT_TYPE'
-
-    # Content type (also available as CONTENT_TYPE).
-    HTTP_CONTENT_TYPE='HTTP_CONTENT_TYPE'
-
-    # Gateway interface key in the HttpRequest parameters.
-    GATEWAY_INTERFACE='GATEWAY_INTERFACE'
-    # We claim to support CGI/1.2.
-    GATEWAY_INTERFACE_VALUE='CGI/1.2'
-
-    # Hosts remote IP address.  Mongrel does not do DNS resolves since that slows 
-    # processing down considerably.
-    REMOTE_ADDR='REMOTE_ADDR'
-
-    # This is not given since Mongrel does not do DNS resolves.  It is only here for
-    # completeness for the CGI standard.
-    REMOTE_HOST='REMOTE_HOST'
+    DATE = "Date".freeze
 
-    # The name/host of our server as given by the HttpServer.new(host,port) call.
-    SERVER_NAME='SERVER_NAME'
-
-    # The port of our server as given by the HttpServer.new(host,port) call.
-    SERVER_PORT='SERVER_PORT'
+    # This is the part of the path after the SCRIPT_NAME.  URIClassifier will determine this.
+    PATH_INFO="PATH_INFO".freeze
 
-    # SERVER_NAME and SERVER_PORT come from this.
-    HTTP_HOST='HTTP_HOST'
+    # This is the intial part that your handler is identified as by URIClassifier.
+    SCRIPT_NAME="SCRIPT_NAME".freeze
 
-    # Official server protocol key in the HttpRequest parameters.
-    SERVER_PROTOCOL='SERVER_PROTOCOL'
-    # Mongrel claims to support HTTP/1.1.
-    SERVER_PROTOCOL_VALUE='HTTP/1.1'
+    # The original URI requested by the client.  Passed to URIClassifier to build PATH_INFO and SCRIPT_NAME.
+    REQUEST_URI='REQUEST_URI'.freeze
 
-    # The actual server software being used (it's Mongrel man).
-    SERVER_SOFTWARE='SERVER_SOFTWARE'
-    
-    # Current Mongrel version (used for SERVER_SOFTWARE and other response headers).
-    MONGREL_VERSION='Mongrel 0.3.10'
+    MONGREL_VERSION="0.3.12".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"
+    ERROR_404_RESPONSE="HTTP/1.1 404 Not Found\r\nConnection: close\r\nServer: #{MONGREL_VERSION}\r\n\r\nNOT FOUND".freeze
+
+    CONTENT_LENGTH="CONTENT_LENGTH".freeze
 
     # A common header for indicating the server is too busy.  Not used yet.
-    ERROR_503_RESPONSE="HTTP/1.1 503 Service Unavailable\r\n\r\nBUSY"
+    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=(16 * 1024)
 
+    # Format to generate a correct RFC 1123 date.  rdoc for Time is wrong, there is no httpdate function.
+    RFC_1123_DATE_FORMAT="%a, %d %B %Y %H:%M:%S GMT".freeze
+
+    # 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
+    CONTENT_TYPE = "Content-Type".freeze
+    LAST_MODIFIED = "Last-Modified".freeze
+    ETAG = "ETag".freeze
+    SLASH = "/".freeze
+    REQUEST_METHOD="REQUEST_METHOD".freeze
+    GET="GET".freeze
+    HEAD="HEAD".freeze
+    # ETag is based on the apache standard of hex mtime-size-inode (inode is 0 on win32)
+    ETAG_FORMAT="\"%x-%x-%x\"".freeze
+    HEADER_FORMAT="%s: %s\r\n".freeze
+    LINE_END="\r\n".freeze
   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 
-  # *one* handler processes all requests.  Included in the HttpReqeust is a
+  # *one* handler processes all requests.  Included in the HttpRequest is a
   # HttpRequest.params Hash that matches common CGI params, and a HttpRequest.body
   # which is a string containing the request body (raw for now).
   #
@@ -172,28 +151,49 @@ module Mongrel
       @body = initial_body || ""
       @params = params
       @socket = socket
-      
-      # fix up the CGI requirements
-      params[Const::CONTENT_LENGTH] = params[Const::HTTP_CONTENT_LENGTH] || 0
-      params[Const::CONTENT_TYPE] = params[Const::HTTP_CONTENT_TYPE] if params[Const::HTTP_CONTENT_TYPE]
-      params[Const::GATEWAY_INTERFACE]=Const::GATEWAY_INTERFACE_VALUE
-      params[Const::REMOTE_ADDR]=socket.peeraddr[3]
-      if params.has_key? Const::HTTP_HOST
-        host,port = params[Const::HTTP_HOST].split(":")
-        params[Const::SERVER_NAME]=host
-        params[Const::SERVER_PORT]=port || 80
-      end
-      params[Const::SERVER_PROTOCOL]=Const::SERVER_PROTOCOL_VALUE
-      params[Const::SERVER_SOFTWARE]=Const::MONGREL_VERSION
-
 
       # now, if the initial_body isn't long enough for the content length we have to fill it
       # TODO: adapt for big ass stuff by writing to a temp file
-      clen = params[Const::HTTP_CONTENT_LENGTH].to_i
+      clen = params[Const::CONTENT_LENGTH].to_i
       if @body.length < clen
         @body << @socket.read(clen - @body.length)
       end
+
+    end
+
+    def self.escape(s)
+      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+        '%'+$1.unpack('H2'*$1.size).join('%').upcase
+      }.tr(' ', '+') 
+    end
+
+
+    def self.unescape(s)
+      s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+        [$1.delete('%')].pack('H*')
+      } 
     end
+
+
+    def self.query_parse(qs, d = '&;')
+      params = {}
+      (qs||'').split(/[#{d}] */n).inject(params) { |h,p|
+        k, v=unescape(p).split('=',2)
+        if cur = params[k]
+          if cur.class == Array
+            params[k] << v
+          else
+            params[k] = [cur, v]
+          end
+        else
+          params[k] = v
+        end
+      }
+
+      return params
+    end
+
+    
   end
 
 
@@ -213,11 +213,9 @@ module Mongrel
 
     # Simply writes "#{key}: #{value}" to an output buffer.
     def[]=(key,value)
-      @out.write(key)
-      @out.write(": ")
-      @out.write(value)
-      @out.write("\r\n")
+      @out.write(Const::HEADER_FORMAT % [key, value])
     end
+    
   end
 
   # Writes and controls your response to the client using the HTTP/1.1 specification.
@@ -255,48 +253,79 @@ module Mongrel
     attr_reader :header
     attr_reader :status
     attr_writer :status
+    attr_reader :body_sent
+    attr_reader :header_sent
+    attr_reader :status_sent
     
-    def initialize(socket)
+    def initialize(socket, filter = nil)
       @socket = socket
       @body = StringIO.new
       @status = 404
       @header = HeaderOut.new(StringIO.new)
+      @header[Const::DATE] = HttpServer.httpdate(Time.now)
+      @filter = filter
+      @body_sent = false
+      @header_sent = false
+      @status_sent = false
     end
 
     # Receives a block passing it the header and body for you to work with.
     # When the block is finished it writes everything you've done to 
     # the socket in the proper order.  This lets you intermix header and
-    # body content as needed.
-    def start(status=200)
+    # body content as needed.  Handlers are able to modify pretty much
+    # any part of the request in the chain, and can stop further processing
+    # by simple passing "finalize=true" to the start method.  By default
+    # all handlers run and then mongrel finalizes the request when they're
+    # all done.
+    def start(status=200, finalize=false)
       @status = status.to_i
       yield @header, @body
-      finished
+      finished if finalize
     end
 
     # Primarily used in exception handling to reset the response output in order to write
-    # an alternative response.
+    # an alternative response.  It will abort with an exception if you have already
+    # sent the header or the body.  This is pretty catastrophic actually.
     def reset
-      @header.out.rewind
-      @body.rewind
+      if @body_sent
+        raise "You have already sent the request body."
+      elsif @header_sent
+        raise "You have already sent the request headers."
+      else
+        @header.out.rewind
+        @body.rewind
+      end
     end
 
-    def send_status
-      status = "HTTP/1.1 #{@status} #{HTTP_STATUS_CODES[@status]}\r\nContent-Length: #{@body.length}\r\nConnection: close\r\n"
-      @socket.write(status)
+    def send_status(content_length=nil)
+      if not @status_sent
+	content_length ||= @body.length
+        @socket.write(Const::STATUS_FORMAT % [status, HTTP_STATUS_CODES[@status], content_length])
+        @status_sent = true
+      end
     end
 
     def send_header
-      @header.out.rewind
-      @socket.write(@header.out.read)
-      @socket.write("\r\n")
+      if not @header_sent
+        @header.out.rewind
+        @socket.write(@header.out.read + Const::LINE_END)
+        @header_sent = true
+      end
     end
 
     def send_body
-      @body.rewind
-      # connection: close is also added to ensure that the client does not pipeline.
-      @socket.write(@body.read)
+      if not @body_sent
+        @body.rewind
+        # connection: close is also added to ensure that the client does not pipeline.
+        @socket.write(@body.read)
+        @body_sent = true
+      end
     end 
 
+    def write(data)
+      @socket.write(data)
+    end
+
     # This takes whatever has been done to header and body and then writes it in the
     # proper format to make an HTTP/1.1 response.
     def finished
@@ -304,6 +333,11 @@ module Mongrel
       send_header
       send_body
     end
+
+    def done
+      (@status_sent and @header_sent and @body_sent)
+    end
+
   end
   
 
@@ -327,41 +361,30 @@ module Mongrel
   # hold your breath until Ruby 1.9 is actually finally useful.
   class HttpServer
     attr_reader :acceptor
+    attr_reader :workers
+    attr_reader :classifier
 
     # Creates a working server on host:port (strange things happen if port isn't a Number).
-    # Use HttpServer::run to start the server.
-    #
-    # The num_processors variable has varying affects on how requests are processed.  You'd
-    # think adding more processing threads (processors) would make the server faster, but
-    # that's just not true.  There's actually an effect of how Ruby does threads such that
-    # the more processors waiting on the request queue, the slower the system is to handle
-    # each request.  But, the lower the number of processors the fewer concurrent responses
-    # the server can make.
+    # Use HttpServer::run to start the server and HttpServer.acceptor.join to 
+    # join the thread that's processing incoming requests on the socket.
     #
-    # 20 is the default number of processors and is based on experimentation on a few
-    # systems.  If you find that you overload Mongrel too much
-    # try changing it higher.  If you find that responses are way too slow
-    # try lowering it (after you've tuned your stuff of course).
-    def initialize(host, port, num_processors=20, timeout=120)
+    # 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 timeout 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=(2**30-1), timeout=0)
       @socket = TCPServer.new(host, port) 
-
       @classifier = URIClassifier.new
-      @req_queue = Queue.new
       @host = host
       @port = port
-      @processors = []
-
-      # create the worker threads
-      num_processors.times do |i| 
-        @processors << Thread.new do
-          while client = @req_queue.deq
-            Timeout::timeout(timeout) do
-              process_client(client)
-            end
-          end
-        end
-      end
-
+      @workers = ThreadGroup.new
+      @timeout = timeout
+      @num_processors = num_processors
     end
     
 
@@ -374,19 +397,31 @@ module Mongrel
       begin
         parser = HttpParser.new
         params = {}
+
         data = client.readpartial(Const::CHUNK_SIZE)
 
         while true
           nread = parser.execute(params, data)
+
           if parser.finished?
-            script_name, path_info, handler = @classifier.resolve(params[Const::REQUEST_URI])
+            script_name, path_info, handlers = @classifier.resolve(params[Const::REQUEST_URI])
 
-            if handler
+            if handlers
               params[Const::PATH_INFO] = path_info
               params[Const::SCRIPT_NAME] = script_name
+
               request = HttpRequest.new(params, data[nread ... data.length], client)
               response = HttpResponse.new(client)
-              handler.process(request, response)
+              
+              handlers.each do |handler|
+                handler.process(request, response)
+                break if response.done
+              end
+
+              if not response.done
+                response.finished
+              end
+
             else
               client.write(Const::ERROR_404_RESPONSE)
             end
@@ -399,11 +434,7 @@ module Mongrel
             data << client.readpartial(Const::CHUNK_SIZE)
           end
         end
-      rescue EOFError
-        # ignored
-      rescue Errno::ECONNRESET
-        # ignored
-      rescue Errno::EPIPE
+      rescue EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL
         # ignored
       rescue => details
         STDERR.puts "ERROR(#{details.class}): #{details}"
@@ -413,16 +444,45 @@ module Mongrel
       end
     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.
+    def reap_dead_workers(worker_list)
+      mark = Time.now
+      worker_list.each do |w|
+        if mark - w[:started_on] > 10 * @timeout
+          STDERR.puts "Thread #{w.inspect} is too old, killing."
+          w.raise(StopServer.new("Timed out thread."))
+        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
-      @acceptor = Thread.new do
-        Thread.current[:stopped] = false
 
-        while not Thread.current[:stopped]
+      @acceptor = Thread.new do
+        while true
           begin
-            @req_queue << @socket.accept
+            client = @socket.accept
+            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
+              reap_dead_workers(worker_list)
+            else
+              thread = Thread.new do
+                process_client(client)
+              end
+              
+              thread[:started_on] = Time.now
+              thread.priority=1
+              @workers.add(thread)
+              
+              sleep @timeout/100 if @timeout > 0
+            end
           rescue StopServer
             STDERR.puts "Server stopped.  Exiting."
             @socket.close if not @socket.closed?
@@ -435,17 +495,14 @@ module Mongrel
 
         # now that processing is done we feed enough false onto the request queue to get
         # each processor to exit and stop processing.
-        @processors.length.times { @req_queue << false }
 
         # finally we wait until the queue is empty
-        while @req_queue.length > 0
-          STDERR.puts "Shutdown waiting for #{@req_queue.length} requests" if @req_queue.length > 0
+        while @workers.list.length > 0
+          STDERR.puts "Shutdown waiting for #{@workers.list.length} requests" if @workers.list.length > 0
           sleep 1
         end
       end
 
-      @acceptor.priority = 1
-
       return @acceptor
     end
 
@@ -454,11 +511,22 @@ module Mongrel
     # found in the prefix of a request then your handler's HttpHandler::process method
     # is called.  See Mongrel::URIClassifier#register for more information.
     def register(uri, handler)
-      @classifier.register(uri, handler)
+      script_name, path_info, handlers = @classifier.resolve(uri)
+
+      if not handlers
+        @classifier.register(uri, [handler])
+      else
+        if path_info.length == 0 or (script_name == Const::SLASH and path_info == Const::SLASH)
+          handlers << handler
+        else
+          @classifier.register(uri, [handler])
+        end
+      end
     end
 
-    # Removes any handler registered at the given URI.  See Mongrel::URIClassifier#unregister
-    # for more information.
+    # 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
@@ -467,13 +535,308 @@ module Mongrel
     # off the request queue before finally exiting.
     def stop
       stopper = Thread.new do 
-        @acceptor[:stopped] = true
         exc = StopServer.new
         @acceptor.raise(exc)
       end
       stopper.priority = 10
     end
 
+    # Given the a time object it converts it to GMT and applies the RFC1123 format to it.
+    def HttpServer.httpdate(date)
+      date.gmtime.strftime(Const::RFC_1123_DATE_FORMAT)
+    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.
+  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)
+      @listeners = {}
+      @defaults = defaults
+      @needs_restart = false
+      
+      if blk
+        cloaker(&blk).bind(self).call
+      end
+    end
+    
+    # Do not call this.  You were warned.
+    def cloaker &blk
+      (class << self; self; end).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 not timeout)
+    #
+    def listener(options={},&blk)
+      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 blk
+        cloaker(&blk).bind(self).call
+      end
+      
+      # all done processing this listener setup
+      @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 => Handler to use for this location.
+    def uri(location, options={})
+      ops = resolve_defaults(options)
+      @listener.register(location, ops[:handler])
+    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.
+    # * :pid_file => Where to write the process ID.
+    # 
+    # It is safe to call this on win32 as it will only require daemons
+    # 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])
+        
+        open(ops[:pid_file],"w") {|f| f.write(Process.pid) }
+      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 loading.
+    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
+      log "Loading additional MIME types from #{file}"
+      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
+    
+    
+    # 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| 
+        log "Running #{name} listener." 
+        s.run 
+      }
+      
+    end
+    
+    # Calls .stop on all the configured listeners so they
+    # stop processing requests (gracefully).
+    def stop
+      @listeners.each {|name,s| 
+        log "Stopping #{name} listener." 
+        s.stop 
+      }
+    end
+
+
+    # This method should actually be called *outside* of the
+    # Configurator block so that you can control it.  In otherwords
+    # 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.
+    def debug(location)
+      require 'mongrel/debug'
+      ObjectTracker.configure
+      MongrelDbg.configure
+      MongrelDbg.begin_trace :objects
+      MongrelDbg.begin_trace :rails
+      MongrelDbg.begin_trace :files
+      
+      uri location, :handler => plugin("/handlers/requestlog::files")
+      uri location, :handler => plugin("/handlers/requestlog::objects")
+      uri location, :handler => plugin("/handlers/requestlog::params")
+    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 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)
+      
+      if RUBY_PLATFORM !~ /mswin/
+        # graceful shutdown
+        trap("TERM") { 
+          log "TERM signal received."
+          stop 
+          File.unlink ops[:pid_file] if File.exist?(ops[:pid_file])
+        }
+        
+        # restart
+        trap("USR2") { 
+          log "USR2 signal received."
+          stop
+          File.unlink ops[:pid_file] if File.exist?(ops[:pid_file])
+          @needs_restart = true
+        }
+        
+        trap("INT") {
+          log "INT signal received."
+          stop
+          File.unlink ops[:pid_file] if File.exist?(ops[:pid_file])
+          @needs_restart = false
+        }
+        
+        log "Signals ready.  TERM => stop.  USR2 => restart.  INT => stop (no restart)."
+      else
+        log "WARNING: Win32 does not have signals support."
+      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