mongrel 0.3.12.4 → 0.3.13

data/lib/mongrel/camping.rb

@@ -1,3 +1,21 @@
+# Mongrel Web Server - A Mostly Ruby Webserver and Library
+#
+# Copyright (C) 2005 Zed A. Shaw zedshaw AT zedshaw dot com
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
 require 'mongrel'
 
 
@@ -32,15 +50,39 @@ module Mongrel
       end
 
       def process(request, response)
-        req = StringIO.new(request.body)
-        controller = @klass.run(req, request.params)
-        response.start(controller.status) do |head,out|
-          controller.headers.each do |k, v|
+        controller = @klass.run(request.body, request.params)
+        sendfile, clength = nil
+        response.status = controller.status
+        controller.headers.each do |k, v|
+          if k =~ /^X-SENDFILE$/i
+            sendfile = v
+          elsif k =~ /^CONTENT-LENGTH$/i
+            clength = v.to_i
+          else
             [*v].each do |vi|
-              head[k] = vi
+              response.header[k] = vi
             end
           end
-          out << controller.body
+        end
+
+        if sendfile
+          response.send_status(File.size(sendfile))
+          response.send_header
+          response.send_file(sendfile)
+        elsif controller.body.respond_to? :read
+          response.send_status(clength)
+          response.send_header
+          while chunk = controller.body.read(16384)
+            response.write(chunk)
+          end
+          if controller.body.respond_to? :close
+            controller.body.close
+          end
+        else
+          body = controller.body.to_s
+          response.send_status(body.length)
+          response.send_header
+          response.write(body)
         end
       end
     end

data/lib/mongrel/cgi.rb

@@ -1,3 +1,21 @@
+# Mongrel Web Server - A Mostly Ruby Webserver and Library
+#
+# Copyright (C) 2005 Zed A. Shaw zedshaw AT zedshaw dot com
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
 require 'cgi'
 
 module Mongrel
@@ -10,7 +28,7 @@ module Mongrel
   # The CGIWrapper.handler attribute is normally not set and is available for 
   # frameworks that need to get back to the handler.  Rails uses this to give
   # people access to the RailsHandler#files (DirHandler really) so they can
-  # look-up paths and do other things withthe files managed there.
+  # look-up paths and do other things with the files managed there.
   #
   # In Rails you can get the real file for a request with:
   #
@@ -35,7 +53,7 @@ module Mongrel
       @request = request
       @response = response
       @args = *args
-      @input = StringIO.new(request.body)
+      @input = request.body
       @head = {}
       @out_called = false
       super(*args)

data/lib/mongrel/command.rb

@@ -1,3 +1,21 @@
+# Mongrel Web Server - A Mostly Ruby Webserver and Library
+#
+# Copyright (C) 2005 Zed A. Shaw zedshaw AT zedshaw dot com
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
 require 'rubygems'
 require 'singleton'
 require 'optparse'
@@ -10,11 +28,13 @@ module Mongrel
 
   module Command
 
+    BANNER = "Usage: mongrel_rails <command> [options]"
+
     # A Command pattern implementation used to create the set of command available to the user
     # from Mongrel.  The script uses objects which implement this interface to do the
     # user's bidding.
     module Base
-      
+
       attr_reader :valid, :done_validating, :original_args
 
       # Called by the implemented command to set the options for that command.
@@ -35,6 +55,7 @@ module Mongrel
       def initialize(options={})
         argv = options[:argv] || []
         @opt = OptionParser.new
+        @opt.banner = Mongrel::Command::BANNER
         @valid = true
         # this is retarded, but it has to be done this way because -h and -v exit
         @done_validating = false
@@ -47,35 +68,39 @@ module Mongrel
           @done_validating = true
           puts @opt
         end
-        
-        # I need to add my own -v definition to prevent the -h from exiting by default as well.
+
+        # I need to add my own -v definition to prevent the -v from exiting by default as well.
         @opt.on_tail("--version", "Show version") do
           @done_validating = true
           if VERSION
-            puts "Version #{MONGREL_VERSION}"
+            puts "Version #{Mongrel::Const::MONGREL_VERSION}"
           end
         end
-        
+
         @opt.parse! argv
       end
-      
+
+      def configure
+        options []
+      end
+
       # Returns true/false depending on whether the command is configured properly.
       def validate
         return @valid
       end
-      
+
       # Returns a help message.  Defaults to OptionParser#help which should be good.
       def help
         @opt.help
       end
-      
+
       # Runs the command doing it's job.  You should implement this otherwise it will
       # throw a NotImplementedError as a reminder.
       def run
         raise NotImplementedError
       end
-      
-      
+
+
       # Validates the given expression is true and prints the message if not, exiting.
       def valid?(exp, message)
         if not @done_validating and (not exp)
@@ -89,29 +114,49 @@ module Mongrel
       def valid_exists?(file, message)
         valid?(file != nil && File.exist?(file), message)
       end
-      
-      
+
+
       # Validates that the file is a file and not a directory or something else.
       def valid_file?(file, message)
         valid?(file != nil && File.file?(file), message)
       end
-      
+
       # Validates that the given directory exists
       def valid_dir?(file, message)
         valid?(file != nil && File.directory?(file), message)
       end
 
+      def valid_user?(user)
+        valid?(@group, "You must also specify a group.")
+        begin
+          Etc.getpwnam(user)
+        rescue
+          failure "User does not exist: #{user}"
+          @valid = false
+        end
+      end
+
+      def valid_group?(group)
+        valid?(@user, "You must also specify a user.")
+        begin
+          Etc.getgrnam(group)
+        rescue
+          failure "Group does not exist: #{group}"
+          @valid = false
+        end
+      end
+
       # Just a simple method to display failure until something better is developed.
       def failure(message)
         STDERR.puts "!!! #{message}"
       end
     end
-    
+
     # A Singleton class that manages all of the available commands
     # and handles running them.
     class Registry
       include Singleton
-      
+
       # Builds a list of possible commands from the Command derivates list
       def commands
         pmgr = GemPlugin::Manager.instance
@@ -121,51 +166,55 @@ module Mongrel
 
       # Prints a list of available commands.
       def print_command_list
-        puts "Available commands are:\n\n"
-        
+        puts "#{Mongrel::Command::BANNER}\nAvailable commands are:\n\n"
+
         self.commands.each do |name|
           puts " - #{name[1 .. -1]}\n"
         end
-        
+
         puts "\nEach command takes -h as an option to get help."
-        
+
       end
-      
-      
+
+
       # Runs the args against the first argument as the command name.
       # If it has any errors it returns a false, otherwise it return true.
       def run(args)
         # find the command
         cmd_name = args.shift
-        
+
         if !cmd_name or cmd_name == "?" or cmd_name == "help"
           print_command_list
           return true
+        elsif cmd_name == "--version"
+          STDERR.puts "Mongrel Web Server #{Mongrel::Const::MONGREL_VERSION}"
+          return true
         end
-        
+
         # command exists, set it up and validate it
         begin
           command = GemPlugin::Manager.instance.create("/commands/#{cmd_name}", :argv => args)
         rescue
           STDERR.puts "INVALID COMMAND: #$!"
           print_command_list
-          return
+          return false
         end
-        
+
         # Normally the command is NOT valid right after being created
         # but sometimes (like with -h or -v) there's no further processing
         # needed so the command is already valid so we can skip it.
         if not command.done_validating
           if not command.validate
-            STDERR.puts "#{cmd_name} reported an error. Use -h to get help."
+            STDERR.puts "#{cmd_name} reported an error. Use mongrel_rails #{cmd_name} -h to get help."
             return false
           else
             command.run
           end
         end
+
         return true
       end
-      
+
     end
   end
 end

data/lib/mongrel/debug.rb

@@ -1,3 +1,21 @@
+# Mongrel Web Server - A Mostly Ruby Webserver and Library
+#
+# Copyright (C) 2005 Zed A. Shaw zedshaw AT zedshaw dot com
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
 require 'logger'
 require 'set'
 require 'socket'
@@ -48,7 +66,12 @@ module ObjectTracker
     @active_objects = Set.new
 
     ObjectSpace.each_object do |obj|
-      @active_objects << obj.object_id
+      begin
+        # believe it or not, some idiots actually alter the object_id method
+        @active_objects << obj.object_id
+      rescue Object
+        # skip this one, he's an idiot
+      end
     end
   end
 
@@ -56,12 +79,14 @@ module ObjectTracker
     ospace = Set.new
     counts = {}
     
-    # Strings can't be tracked easily and are so numerous that they drown out all else
-    # so we just ignore them in the counts.
     ObjectSpace.each_object do |obj|
-      ospace << obj.object_id
-      counts[obj.class] ||= 0
-      counts[obj.class] += 1
+      begin
+        ospace << obj.object_id
+        counts[obj.class] ||= 0
+        counts[obj.class] += 1
+      rescue Object
+        # skip since object_id can magically get parameters
+      end
     end
     
     dead_objects = @active_objects - ospace
@@ -171,15 +196,19 @@ module RequestLog
     def process(request, response)
       MongrelDbg::trace(:threads, "#{Time.now} REQUEST #{request.params['PATH_INFO']}")
       ObjectSpace.each_object do |obj|
-        if obj.class == Mongrel::HttpServer
-          worker_list = obj.workers.list
+        begin
+          if obj.class == Mongrel::HttpServer
+            worker_list = obj.workers.list
 
-          if worker_list.length > 0
-            keys = "-----\n\tKEYS:"
-            worker_list.each {|t| keys << "\n\t\t-- #{t}: #{t.keys.inspect}" }
-          end
+            if worker_list.length > 0
+              keys = "-----\n\tKEYS:"
+              worker_list.each {|t| keys << "\n\t\t-- #{t}: #{t.keys.inspect}" }
+            end
 
-          MongrelDbg::trace(:threads, "#{obj.host}:#{obj.port} -- THREADS: #{worker_list.length} #{keys}")
+            MongrelDbg::trace(:threads, "#{obj.host}:#{obj.port} -- THREADS: #{worker_list.length} #{keys}")
+          end
+        rescue Object
+          # ignore since obj.class can sometimes take parameters
         end
       end
     end

data/lib/mongrel/handlers.rb

@@ -1,11 +1,23 @@
-require 'rubygems'
-begin
-  require 'sendfile'
-  $mongrel_has_sendfile = true
-  STDERR.puts "** You have sendfile installed, will use that to serve files."
-rescue Object
-  $mongrel_has_sendfile = false
-end
+require 'mongrel/stats'
+require 'zlib'
+
+# Mongrel Web Server - A Mostly Ruby Webserver and Library
+#
+# Copyright (C) 2005 Zed A. Shaw zedshaw AT zedshaw dot com
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 module Mongrel
 
@@ -19,6 +31,8 @@ module Mongrel
   # should be implemented using the HttpHandlerPlugin mixin.
   #
   class HttpHandler
+    attr_reader :header_only
+    attr_accessor :listener
 
     def process(request, response)
     end
@@ -31,9 +45,12 @@ module Mongrel
   # the process method later.
   module HttpHandlerPlugin
     attr_reader :options
+    attr_reader :header_only
+    attr_accessor :listener
 
     def initialize(options={})
       @options = options
+      @header_only = false
     end
 
     def process(request, response)
@@ -52,7 +69,7 @@ module Mongrel
     def initialize(msg)
       @response = Const::ERROR_404_RESPONSE + msg
     end
-    
+
     # Just kicks back the standard 404 response with your special message.
     def process(request, response)
       response.socket.write(@response)
@@ -104,26 +121,27 @@ module Mongrel
 
     # Checks if the given path can be served and returns the full path (or nil if not).
     def can_serve(path_info)
-      req = File.expand_path(File.join(@path,path_info), @path)
+      # TODO: investigate freezing the path_info to prevent double escaping
+      req_path = File.expand_path(File.join(@path,HttpRequest.unescape(path_info)), @path)
 
-      if req.index(@path) == 0 and File.exist? req
+      if req_path.index(@path) == 0 and File.exist? req_path
         # it exists and it's in the right location
-        if File.directory? req
+        if File.directory? req_path
           # the request is for a directory
-          index = File.join(req, @index_html)
+          index = File.join(req_path, @index_html)
           if File.exist? index
             # serve the index
             return index
           elsif @listing_allowed
             # serve the directory
-            req
+            return req_path
           else
             # do not serve anything
             return nil
           end
         else
           # it's a file and it's there
-          return req
+          return req_path
         end
       else
         # does not exist or isn't in the right spot
@@ -138,6 +156,7 @@ module Mongrel
     # object to send the results on.
     def send_dir_listing(base, dir, response)
       # take off any trailing / so the links come out right
+      base = HttpRequest.unescape(base)
       base.chop! if base[-1] == "/"[-1]
 
       if @listing_allowed
@@ -145,12 +164,13 @@ module Mongrel
           head[Const::CONTENT_TYPE] = "text/html"
           out << "<html><head><title>Directory Listing</title></head><body>"
           Dir.entries(dir).each do |child|
+            child = HttpRequest.unescape(child)
             next if child == "."
 
             if child == ".."
               out << "<a href=\"#{base}/#{child}\">Up to parent..</a><br/>"
             else
-              out << "<a href=\"#{base}/#{child}\">#{child}</a><br/>"
+              out << "<a href=\"#{base}/#{child}/\">#{child}</a><br/>"
             end
           end
           out << "</body></html>"
@@ -162,72 +182,81 @@ module Mongrel
       end
     end
 
-    
+
     # Sends the contents of a file back to the user. Not terribly efficient since it's
     # opening and closing the file for each read.
-    def send_file(req, response, header_only=false)
+    def send_file(req_path, request, response, header_only=false)
 
-      # first we setup the headers and status then we do a very fast send on the socket directly
-      response.status = 200
-      stat = File.stat(req)
-      header = response.header
+      stat = File.stat(req_path)
 
       # Set the last modified times as well and etag for all files
-      header[Const::LAST_MODIFIED] = stat.mtime.httpdate
+      mtime = stat.mtime
       # Calculated the same as apache, not sure how well the works on win32
-      header[Const::ETAG] = Const::ETAG_FORMAT % [stat.mtime.to_i, stat.size, stat.ino]
-      
-      # set the mime type from our map based on the ending
-      dot_at = req.rindex(".")      
-      if dot_at
-        header[Const::CONTENT_TYPE] = MIME_TYPES[req[dot_at .. -1]] || @default_content_type
-      end
+      etag = Const::ETAG_FORMAT % [mtime.to_i, stat.size, stat.ino]
+
+      unmodified_since = request.params[Const::HTTP_IF_UNMODIFIED_SINCE]
+      none_match = request.params[Const::HTTP_IF_NONE_MATCH]
+
+      # test to see if this is a conditional request, and test if
+      # the response would be identical to the last response
+      same_response = case
+                      when unmodified_since && !last_response_time = Time.httpdate(unmodified_since) rescue nil : false
+                      when unmodified_since && last_response_time > Time.now                                    : false
+                      when unmodified_since && mtime > last_response_time                                       : false
+                      when none_match       && none_match == '*'                                                : false
+                      when none_match       && !none_match.strip.split(/\s*,\s*/).include?(etag)                : false
+                      else unmodified_since || none_match  # validation successful if we get this far and at least one of the header exists
+                      end
+
+      header = response.header
+      header[Const::ETAG] = etag
 
-      # send a status with out content length
-      response.send_status(stat.size)
-      response.send_header
-
-      if not header_only
-	begin
-	  if $mongrel_has_sendfile
-	    File.open(req, "rb") { |f| response.socket.sendfile(f) }
-	  else
-	    File.open(req, "rb") { |f| response.socket.write(f.read) }
-	  end
-        rescue EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
-	  # ignore these since it means the client closed off early
-          STDERR.puts "Client closed socket requesting file #{req}: #$!"
-	end
+      if same_response
+        response.start(304) {}
       else
-        response.send_body # should send nothing
+        # first we setup the headers and status then we do a very fast send on the socket directly
+        response.status = 200
+        header[Const::LAST_MODIFIED] = mtime.httpdate
+
+        # set the mime type from our map based on the ending
+        dot_at = req_path.rindex('.')
+        if dot_at
+          header[Const::CONTENT_TYPE] = MIME_TYPES[req_path[dot_at .. -1]] || @default_content_type
+        end
+
+        # send a status with out content length
+        response.send_status(stat.size)
+        response.send_header
+
+        if not header_only
+          response.send_file(req_path)
+        end
       end
     end
 
-
     # Process the request to either serve a file or a directory listing
-    # if allowed (based on the listing_allowed paramter to the constructor).
+    # if allowed (based on the listing_allowed parameter to the constructor).
     def process(request, response)
       req_method = request.params[Const::REQUEST_METHOD] || Const::GET
-      req = can_serve request.params[Const::PATH_INFO]
-      if not req
+      req_path = can_serve request.params[Const::PATH_INFO]
+      if not req_path
         # not found, return a 404
         response.start(404) do |head,out|
           out << "File not found"
         end
       else
         begin
-          if File.directory? req
-            send_dir_listing(request.params[Const::REQUEST_URI],req, response)
+          if File.directory? req_path
+            send_dir_listing(request.params[Const::REQUEST_URI], req_path, response)
           elsif req_method == Const::HEAD
-            send_file(req, response, true)
-	  elsif req_method == Const::GET
-            send_file(req, response, false)
-	  else
-	    response.start(403) {|head,out| out.write(ONLY_HEAD_GET) }
+            send_file(req_path, request, response, true)
+          elsif req_method == Const::GET
+            send_file(req_path, request, response, false)
+          else
+            response.start(403) {|head,out| out.write(ONLY_HEAD_GET) }
           end
         rescue => details
-          STDERR.puts "Error accessing file #{req}: #{details}"
-          STDERR.puts details.backtrace.join("\n")
+          STDERR.puts "Error sending file #{req_path}: #{details}"
         end
       end
     end
@@ -239,4 +268,134 @@ module Mongrel
     end
 
   end
+
+
+  # When added to a config script (-S in mongrel_rails) it will
+  # look at the client's allowed response types and then gzip 
+  # compress anything that is going out.
+  #
+  # Valid option is :always_deflate => false which tells the handler to
+  # deflate everything even if the client can't handle it.
+  class DeflateFilter < HttpHandler
+    HTTP_ACCEPT_ENCODING = "HTTP_ACCEPT_ENCODING" 
+
+    def initialize(ops={})
+      @options = ops
+      @always_deflate = ops[:always_deflate] || false
+    end
+
+    def process(request, response)
+      accepts = request.params[HTTP_ACCEPT_ENCODING]
+      # only process if they support compression
+      if @always_deflate or (accepts and (accepts.include? "deflate" and not response.body_sent))
+        response.header["Content-Encoding"] = "deflate"
+        # we can't just rewind the body and gzip it since the body could be an attached file
+        response.body.rewind
+        gzout = StringIO.new(Zlib::Deflate.deflate(response.body.read))
+        gzout.rewind
+        response.body.close
+        response.body = gzout
+      end
+    end
+  end
+
+
+  # Implements a few basic statistics for a particular URI.  Register it anywhere
+  # you want in the request chain and it'll quickly gather some numbers for you
+  # to analyze.  It is pretty fast, but don't put it out in production.
+  #
+  # You should pass the filter to StatusHandler as StatusHandler.new(:stats_filter => stats).
+  # This lets you then hit the status URI you want and get these stats from a browser.
+  #
+  # StatisticsFilter takes an option of :sample_rate.  This is a number that's passed to
+  # rand and if that number gets hit then a sample is taken.  This helps reduce the load
+  # and keeps the statistics valid (since sampling is a part of how they work).
+  #
+  # The exception to :sample_rate is that inter-request time is sampled on every request.
+  # If this wasn't done then it wouldn't be accurate as a measure of time between requests.
+  class StatisticsFilter < HttpHandler
+    attr_reader :stats
+
+    def initialize(ops={})
+      @sample_rate = ops[:sample_rate] || 300
+
+      @processors = Stats.new("processors")
+      @reqsize = Stats.new("request Kb")
+      @headcount = Stats.new("req param count")
+      @respsize = Stats.new("response Kb")
+      @interreq = Stats.new("inter-request time")
+    end
+
+
+    def process(request, response)
+      if rand(@sample_rate)+1 == @sample_rate
+        @processors.sample(listener.workers.list.length)
+        @headcount.sample(request.params.length)
+        @reqsize.sample(request.body.length / 1024.0)
+        @respsize.sample((response.body.length + response.header.out.length) / 1024.0)
+      end
+      @interreq.tick
+    end
+
+    def dump
+      "#{@processors.to_s}\n#{@reqsize.to_s}\n#{@headcount.to_s}\n#{@respsize.to_s}\n#{@interreq.to_s}"
+    end
+  end
+
+
+  # The :stats_filter is basically any configured stats filter that you've added to this same
+  # URI.  This lets the status handler print out statistics on how Mongrel is doing.
+  class StatusHandler < HttpHandler
+    def initialize(ops={})
+      @stats = ops[:stats_filter]
+    end
+
+    def table(title, rows)
+      results = "<table border=\"1\"><tr><th colspan=\"#{rows[0].length}\">#{title}</th></tr>"
+      rows.each do |cols|
+        results << "<tr>"
+        cols.each {|col| results << "<td>#{col}</td>" }
+        results << "</tr>"
+      end
+      results + "</table>"
+    end
+
+    def describe_listener
+      results = ""
+      results << "<h1>Listener #{listener.host}:#{listener.port}</h1>"
+      results << table("settings", [
+                       ["host",listener.host],
+                       ["port",listener.port],
+                       ["timeout",listener.timeout],
+                       ["workers max",listener.num_processors],
+      ])
+
+      if @stats
+        results << "<h2>Statistics</h2><p>N means the number of samples, pay attention to MEAN, SD, MIN and MAX."
+        results << "<pre>#{@stats.dump}</pre>"
+      end
+
+      results << "<h2>Registered Handlers</h2>"
+      uris = listener.classifier.handler_map
+      results << table("handlers", uris.map {|uri,handlers| 
+        [uri, 
+            "<pre>" + 
+            handlers.map {|h| h.class.to_s }.join("\n") + 
+            "</pre>"
+        ]
+      })
+
+      results
+    end
+
+    def process(request, response)
+      response.start do |head,out|
+        out.write <<-END
+        <html><body><title>Mongrel Server Status</title>
+        #{describe_listener}
+        </body></html>
+        END
+      end
+    end
+  end
 end