freels-mongrel 1.1.2

data/lib/mongrel/const.rb

@@ -0,0 +1,114 @@
+
+module Mongrel
+
+  # Every standard HTTP code mapped to the appropriate message.  These are
+  # used so frequently that they are placed directly in Mongrel for easy
+  # access rather than Mongrel::Const itself.
+  HTTP_STATUS_CODES = {  
+    100  => 'Continue', 
+    101  => 'Switching Protocols', 
+    200  => 'OK', 
+    201  => 'Created', 
+    202  => 'Accepted', 
+    203  => 'Non-Authoritative Information', 
+    204  => 'No Content', 
+    205  => 'Reset Content', 
+    206  => 'Partial Content', 
+    300  => 'Multiple Choices', 
+    301  => 'Moved Permanently', 
+    302  => 'Moved Temporarily', 
+    303  => 'See Other', 
+    304  => 'Not Modified', 
+    305  => 'Use Proxy', 
+    400  => 'Bad Request', 
+    401  => 'Unauthorized', 
+    402  => 'Payment Required', 
+    403  => 'Forbidden', 
+    404  => 'Not Found', 
+    405  => 'Method Not Allowed', 
+    406  => 'Not Acceptable', 
+    407  => 'Proxy Authentication Required', 
+    408  => 'Request Time-out', 
+    409  => 'Conflict', 
+    410  => 'Gone', 
+    411  => 'Length Required', 
+    412  => 'Precondition Failed', 
+    413  => 'Request Entity Too Large', 
+    414  => 'Request-URI Too Large', 
+    415  => 'Unsupported Media Type', 
+    500  => 'Internal Server Error', 
+    501  => 'Not Implemented', 
+    502  => 'Bad Gateway', 
+    503  => 'Service Unavailable', 
+    504  => 'Gateway Time-out', 
+    505  => 'HTTP Version not supported'
+  }
+
+  # Frequently used constants when constructing requests or responses.  Many times
+  # the constant just refers to a string with the same contents.  Using these constants
+  # gave about a 3% to 10% performance improvement over using the strings directly.
+  # Symbols did not really improve things much compared to constants.
+  #
+  # While Mongrel does try to emulate the CGI/1.2 protocol, it does not use the REMOTE_IDENT,
+  # REMOTE_USER, or REMOTE_HOST parameters since those are either a security problem or 
+  # too taxing on performance.
+  module Const
+    DATE = "Date".freeze
+
+    # This is the part of the path after the SCRIPT_NAME.  URIClassifier will determine this.
+    PATH_INFO="PATH_INFO".freeze
+
+    # This is the initial part that your handler is identified as by URIClassifier.
+    SCRIPT_NAME="SCRIPT_NAME".freeze
+
+    # 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="1.2".freeze
+
+    MONGREL_TMP_BASE="mongrel".freeze
+
+    # A standard 400 response for a request which generates a http parse exception
+    ERROR_400_RESPONSE="HTTP/1.1 400 Bad Request\r\nConnection: close\r\nServer: Mongrel #{MONGREL_VERSION}\r\n\r\nBAD REQUEST".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 #{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".freeze
+
+    # The basic max request size we'll try to read.
+    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.
+    MAX_HEADER=1024 * (80 + 32)
+
+    # Maximum request body size before it is moved out of memory and into a tempfile for reading.
+    MAX_BODY=MAX_HEADER
+
+    # A frozen format for this is about 15% faster
+    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
+    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
+    REMOTE_ADDR="REMOTE_ADDR".freeze
+    HTTP_X_FORWARDED_FOR="HTTP_X_FORWARDED_FOR".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
+    HOST = "HOST".freeze
+  end
+
+end

data/lib/mongrel/debug.rb

@@ -0,0 +1,203 @@
+# Copyright (c) 2005 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
+# for more information.
+
+require 'logger'
+require 'set'
+require 'socket'
+require 'fileutils'
+
+module MongrelDbg
+  SETTINGS = { :tracing => {}}
+  LOGGING = { }
+
+  def MongrelDbg::configure(log_dir = File.join("log","mongrel_debug"))
+    FileUtils.mkdir_p(log_dir)
+    @log_dir = log_dir
+    $objects_out = open(File.join("log","mongrel_debug","objects.log"),"w")
+    $objects_out.puts "run,classname,last,count,delta,lenmean,lensd,lenmax"
+    $objects_out.sync = true
+    $last_stat = nil
+    $run_count = 0
+  end
+
+  
+  def MongrelDbg::trace(target, message)
+    if SETTINGS[:tracing][target] and LOGGING[target]
+      LOGGING[target].log(Logger::DEBUG, message)
+    end
+  end
+
+  def MongrelDbg::begin_trace(target)
+    SETTINGS[:tracing][target] = true
+    if not LOGGING[target]
+      LOGGING[target] = Logger.new(File.join(@log_dir, "#{target.to_s}.log"))
+    end                          
+    MongrelDbg::trace(target, "#{Time.now.httpdate}: TRACING ON")
+  end
+
+  def MongrelDbg::end_trace(target)
+    SETTINGS[:tracing][target] = false
+    MongrelDbg::trace(target, "#{Time.now.httpdate}: TRACING OFF")
+    LOGGING[target].close
+    LOGGING[target] = nil
+  end
+
+  def MongrelDbg::tracing?(target)
+    SETTINGS[:tracing][target]
+  end
+end
+
+
+
+$open_files = {}
+
+class IO
+  alias_method :orig_open, :open
+  alias_method :orig_close, :close
+
+  def open(*arg, &blk)
+    $open_files[self] = args.inspect
+    orig_open(*arg,&blk)
+  end
+
+  def close(*arg,&blk)
+    $open_files.delete self
+    orig_close(*arg,&blk)
+  end
+end
+
+
+module Kernel
+  alias_method :orig_open, :open
+
+  def open(*arg, &blk)
+    $open_files[self] = arg[0]
+    orig_open(*arg,&blk)
+  end
+
+  def log_open_files
+    open_counts = {}
+    $open_files.each do |f,args|
+      open_counts[args] ||= 0
+      open_counts[args] += 1
+    end
+    MongrelDbg::trace(:files, open_counts.to_yaml)
+  end
+end
+
+
+module RequestLog
+
+  class Access < GemPlugin::Plugin "/handlers"
+    include Mongrel::HttpHandlerPlugin
+    
+    def process(request,response)
+      p = request.params
+      Mongrel.log("#{p['REMOTE_ADDR']} \"#{p['REQUEST_METHOD']} #{p["REQUEST_URI"]} HTTP/1.1\"")
+    end
+  end
+  
+
+  class Files < GemPlugin::Plugin "/handlers"
+    include Mongrel::HttpHandlerPlugin
+    
+    def process(request, response)
+      MongrelDbg::trace(:files, "#{Time.now.httpdate}: FILES OPEN BEFORE REQUEST #{request.params['PATH_INFO']}")
+      log_open_files
+    end
+    
+  end
+
+
+  # stolen from Robert Klemme
+  class Objects < GemPlugin::Plugin "/handlers"
+    include Mongrel::HttpHandlerPlugin
+
+    def process(request,response)
+      begin
+        stats = Hash.new(0)
+        lengths = {}
+        begin
+          ObjectSpace.each_object do |o| 
+            begin
+              if o.respond_to?(:length)
+                len = o.length
+                lengths[o.class] ||= Mongrel::Stats.new(o.class)
+                lengths[o.class].sample(len)
+              end
+            rescue Object
+            end
+  
+            stats[o.class] += 1
+          end
+        rescue Object # Ignore since ObjectSpace might not be loaded on JRuby
+        end
+
+        stats.sort {|(k1,v1),(k2,v2)| v2 <=> v1}.each do |k,v|
+          if $last_stat
+            delta = v - $last_stat[k]
+            if v > 10 and delta != 0
+              if lengths[k]
+                $objects_out.printf "%d,%s,%d,%d,%d,%f,%f,%f\n", $run_count, k, $last_stat[k], v, delta,lengths[k].mean,lengths[k].sd,lengths[k].max
+              else
+                $objects_out.printf "%d,%s,%d,%d,%d,,,\n", $run_count, k, $last_stat[k], v, delta
+              end
+            end
+          end
+        end
+
+        $run_count += 1
+        $last_stat = stats
+      rescue Object
+        STDERR.puts "#{Time.now.httpdate}: object.log ERROR: #$!"
+      end
+    end
+  end
+
+
+  class Params < GemPlugin::Plugin "/handlers"
+    include Mongrel::HttpHandlerPlugin
+
+    def process(request, response)
+      MongrelDbg::trace(:rails, "#{Time.now.httpdate}: REQUEST #{request.params['PATH_INFO']}")
+      MongrelDbg::trace(:rails, request.params.to_yaml)
+    end
+
+  end
+
+
+  class Threads < GemPlugin::Plugin "/handlers"
+    include Mongrel::HttpHandlerPlugin
+
+    def process(request, response)
+      MongrelDbg::trace(:threads, "#{Time.now.httpdate}: REQUEST #{request.params['PATH_INFO']}")
+      begin
+        ObjectSpace.each_object do |obj|
+          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
+  
+              MongrelDbg::trace(:threads, "#{Time.now.httpdate}: #{obj.host}:#{obj.port} -- THREADS: #{worker_list.length} #{keys}")
+            end
+          rescue Object # Ignore since obj.class can sometimes take parameters            
+          end
+        end
+      rescue Object # Ignore since ObjectSpace might not be loaded on JRuby
+      end
+    end
+  end
+end
+
+
+END {
+  MongrelDbg::trace(:files, "#{Time.now.httpdate}: FILES OPEN AT EXIT")
+  log_open_files
+}

data/lib/mongrel/gems.rb

@@ -0,0 +1,22 @@
+module Mongrel
+  module Gems
+    class << self
+    
+      def require(library, version = nil)
+        begin
+          Kernel.require library
+        rescue LoadError, RuntimeError => e
+          begin 
+            # ActiveSupport breaks 'require' by making it always return a true value
+            Kernel.require 'rubygems'
+            version ? gem(library, version) : gem(library)
+            retry
+          rescue Gem::LoadError, LoadError, RuntimeError
+            # puts "** #{library.inspect} could not be loaded" unless library == "mongrel_experimental"
+          end
+        end  
+      end
+      
+    end    
+  end
+end

data/lib/mongrel/handlers.rb

@@ -0,0 +1,472 @@
+# Copyright (c) 2005 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
+# for more information.
+
+require 'mongrel/stats'
+require 'zlib'
+require 'yaml'
+
+
+module Mongrel
+
+  # You implement your application handler with this.  It's very light giving
+  # just the minimum necessary for you to handle a request and shoot back 
+  # a response.  Look at the HttpRequest and HttpResponse objects for how
+  # to use them.
+  #
+  # This is used for very simple handlers that don't require much to operate.
+  # More extensive plugins or those you intend to distribute as GemPlugins 
+  # should be implemented using the HttpHandlerPlugin mixin.
+  #
+  class HttpHandler
+    attr_reader :request_notify
+    attr_accessor :listener
+
+    # This will be called by Mongrel if HttpHandler.request_notify set to *true*.
+    # You only get the parameters for the request, with the idea that you'd "bound"
+    # the beginning of the request processing and the first call to process.
+    def request_begins(params)
+    end
+
+    # Called by Mongrel for each IO chunk that is received on the request socket
+    # from the client, allowing you to track the progress of the IO and monitor
+    # the input.  This will be called by Mongrel only if HttpHandler.request_notify
+    # set to *true*.
+    def request_progress(params, clen, total)
+    end
+
+    def process(request, response)
+    end
+
+  end
+
+
+  # This is used when your handler is implemented as a GemPlugin.
+  # The plugin always takes an options hash which you can modify
+  # and then access later.  They are stored by default for 
+  # the process method later.
+  module HttpHandlerPlugin
+    attr_reader :options
+    attr_reader :request_notify
+    attr_accessor :listener
+
+    def request_begins(params)
+    end
+
+    def request_progress(params, clen, total)
+    end
+
+    def initialize(options={})
+      @options = options
+      @header_only = false
+    end
+
+    def process(request, response)
+    end
+
+  end
+
+
+  #
+  # The server normally returns a 404 response if an unknown URI is requested, but it
+  # also returns a lame empty message.  This lets you do a 404 response
+  # with a custom message for special URIs.
+  #
+  class Error404Handler < HttpHandler
+
+    # Sets the message to return.  This is constructed once for the handler
+    # so it's pretty efficient.
+    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)
+    end
+
+  end
+
+  #
+  # Serves the contents of a directory.  You give it the path to the root
+  # where the files are located, and it tries to find the files based on 
+  # the PATH_INFO inside the directory.  If the requested path is a
+  # directory then it returns a simple directory listing.
+  #
+  # It does a simple protection against going outside it's root path by
+  # converting all paths to an absolute expanded path, and then making 
+  # sure that the final expanded path includes the root path.  If it doesn't
+  # than it simply gives a 404.
+  #
+  # If you pass nil as the root path, it will not check any locations or
+  # expand any paths. This lets you serve files from multiple drives
+  # on win32.
+  #
+  # The default content type is "text/plain; charset=ISO-8859-1" but you
+  # can change it anything you want using the DirHandler.default_content_type
+  # attribute.
+  #
+  class DirHandler < HttpHandler
+    attr_accessor :default_content_type
+    attr_reader :path
+
+    MIME_TYPES_FILE = "mime_types.yml"
+    MIME_TYPES = YAML.load_file(File.join(File.dirname(__FILE__), MIME_TYPES_FILE))
+
+    ONLY_HEAD_GET="Only HEAD and GET allowed.".freeze
+
+    # You give it the path to the directory root and and optional listing_allowed and index_html
+    def initialize(path, listing_allowed=true, index_html="index.html")
+      @path = File.expand_path(path) if path
+      @listing_allowed=listing_allowed
+      @index_html = index_html
+      @default_content_type = "application/octet-stream".freeze
+    end
+
+    # Checks if the given path can be served and returns the full path (or nil if not).
+    def can_serve(path_info)
+
+      req_path = HttpRequest.unescape(path_info)
+      # Add the drive letter or root path
+      req_path = File.join(@path, req_path) if @path
+      req_path = File.expand_path req_path
+     
+      # do not remove the check for @path at the beginning, it's what prevents
+      # the serving of arbitrary files (and good programmer Rule #1 Says: If
+      # you don't understand something, it's not because I'm stupid, it's
+      # because you are).
+      if req_path.index(@path) == 0 and File.exist? req_path
+        # It exists and it's in the right location
+        if File.directory? req_path
+          # The request is for a directory
+          index = File.join(req_path, @index_html)
+          if File.exist? index
+            # Serve the index
+            return index
+          elsif @listing_allowed
+            # Serve the directory
+            return req_path
+          else
+            # Do not serve anything
+            return nil
+          end
+        else
+          # It's a file and it's there
+          return req_path
+        end
+      else
+        # does not exist or isn't in the right spot or isn't valid because not start with @path
+        return nil
+      end
+    end
+
+
+    # Returns a simplistic directory listing if they're enabled, otherwise a 403.
+    # Base is the base URI from the REQUEST_URI, dir is the directory to serve 
+    # on the file system (comes from can_serve()), and response is the HttpResponse
+    # 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
+        response.start(200) do |head,out|
+          head[Const::CONTENT_TYPE] = "text/html"
+          out << "<html><head><title>Directory Listing</title></head><body>"
+          Dir.entries(dir).each do |child|
+            next if child == "."
+            out << "<a href=\"#{base}/#{ HttpRequest.escape(child)}\">"
+            out << (child == ".." ? "Up to parent.." : child)
+            out << "</a><br/>"
+          end
+          out << "</body></html>"
+        end
+      else
+        response.start(403) do |head,out|
+          out.write("Directory listings not allowed")
+        end
+      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_path, request, response, header_only=false)
+
+      stat = File.stat(req_path)
+
+      # Set the last modified times as well and etag for all files
+      mtime = stat.mtime
+      # Calculated the same as apache, not sure how well the works on win32
+      etag = Const::ETAG_FORMAT % [mtime.to_i, stat.size, stat.ino]
+
+      modified_since = request.params[Const::HTTP_IF_MODIFIED_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 modified_since && !last_response_time = Time.httpdate(modified_since) rescue nil then false
+                      when modified_since && last_response_time > Time.now                                  then false
+                      when modified_since && mtime > last_response_time                                     then false
+                      when none_match     && none_match == '*'                                              then false
+                      when none_match     && !none_match.strip.split(/\s*,\s*/).include?(etag)              then false
+                      else modified_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
+
+      if same_response
+        response.start(304) {}
+      else
+        
+        # First we setup the headers and status then we do a very fast send on the socket directly
+        
+        # Support custom responses except 404, which is the default. A little awkward. 
+        response.status = 200 if response.status == 404        
+        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
+        else
+          header[Const::CONTENT_TYPE] = @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, stat.size < Const::CHUNK_SIZE * 2)
+        end
+      end
+    end
+
+    # Process the request to either serve a file or a directory listing
+    # 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_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_path
+            send_dir_listing(request.params[Const::REQUEST_URI], req_path, response)
+          elsif req_method == Const::HEAD
+            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 "#{Time.now.httpdate}: Error sending file #{req_path}: #{details}"
+        end
+      end
+    end
+
+    # There is a small number of default mime types for extensions, but
+    # this lets you add any others you'll need when serving content.
+    def DirHandler::add_mime_type(extension, type)
+      MIME_TYPES[extension] = type
+    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
+    include Zlib
+    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"
+        response.body = deflate(response.body)
+      end
+    end
+
+    private
+      def deflate(stream)
+        deflater = Deflate.new(
+          DEFAULT_COMPRESSION,
+          # drop the zlib header which causes both Safari and IE to choke
+          -MAX_WBITS, 
+          DEF_MEM_LEVEL,
+          DEFAULT_STRATEGY)
+
+        stream.rewind
+        gzout = StringIO.new(deflater.deflate(stream.read, FINISH))
+        stream.close
+        gzout.rewind
+        gzout
+      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 = Mongrel::Stats.new("processors")
+      @reqsize = Mongrel::Stats.new("request Kb")
+      @headcount = Mongrel::Stats.new("req param count")
+      @respsize = Mongrel::Stats.new("response Kb")
+      @interreq = Mongrel::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],
+                       ["throttle",listener.throttle],
+                       ["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>"
+      handler_map = listener.classifier.handler_map
+      results << table("handlers", handler_map.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
+
+  # This handler allows you to redirect one url to another.
+  # You can use it like String#gsub, where the string is the REQUEST_URI.
+  # REQUEST_URI is the full path with GET parameters.
+  #
+  # Eg. /test/something?help=true&disclaimer=false
+  #
+  # == Examples
+  #
+  #   h = Mongrel::HttpServer.new('0.0.0.0')
+  #   h.register '/test', Mongrel::RedirectHandler.new('/to/there') # simple
+  #   h.register '/to',   Mongrel::RedirectHandler.new(/t/, 'w') # regexp
+  #   # and with a block
+  #   h.register '/hey',  Mongrel::RedirectHandler.new(/(\w+)/) { |match| ... }
+  # 
+  class RedirectHandler < Mongrel::HttpHandler
+    # You set the rewrite rules when building the object.
+    #
+    # pattern            => What to look for or replacement if used alone
+    #
+    # replacement, block => One of them is used to replace the found text
+
+    def initialize(pattern, replacement = nil, &block)
+      unless replacement or block
+        @pattern, @replacement = nil, pattern
+      else
+        @pattern, @replacement, @block = pattern, replacement, block
+      end
+    end
+
+    # Process the request and return a redirect response
+    def process(request, response)
+      unless @pattern
+        response.socket.write(Mongrel::Const::REDIRECT % @replacement)
+      else
+        if @block
+          new_path = request.params['REQUEST_URI'].gsub(@pattern, &@block)
+        else
+          new_path = request.params['REQUEST_URI'].gsub(@pattern, @replacement)
+        end
+        response.socket.write(Mongrel::Const::REDIRECT % new_path)
+      end
+    end
+  end
+end