serverside 0.3.1 → 0.4.1

data/lib/serverside/application.rb

@@ -1,26 +0,0 @@
-require 'rubygems'
-require 'metaid'
-require File.join(File.dirname(__FILE__), 'connection')
-
-module ServerSide
-  module Application
-    @@config = nil
-  
-    def self.config=(c)
-      @@config = c
-    end
-  
-    def self.daemonize(config, cmd)
-      config = @@config.merge(config) if @@config
-      daemon_class = Class.new(Daemon::Cluster) do
-        meta_def(:pid_fn) {Daemon::WorkingDirectory/'serverside.pid'}
-        meta_def(:server_loop) do |port|
-          ServerSide::HTTP::Server.new(
-            config[:host], port, ServerSide::Router).start
-        end
-        meta_def(:ports) {config[:ports]}
-      end
-      Daemon.control(daemon_class, cmd)
-    end
-  end
-end

data/lib/serverside/caching.rb

@@ -1,91 +0,0 @@
-require 'time'
-
-module ServerSide
-  module HTTP
-    # This module implements HTTP cache negotiation with a client.
-    module Caching
-      # HTTP headers
-      ETAG = 'ETag'.freeze
-      LAST_MODIFIED = 'Last-Modified'.freeze
-      EXPIRES = 'Expires'.freeze
-      CACHE_CONTROL = 'Cache-Control'.freeze
-      VARY = 'Vary'.freeze
-      
-      IF_NONE_MATCH = 'If-None-Match'.freeze
-      IF_MODIFIED_SINCE = 'If-Modified-Since'.freeze
-      WILDCARD = '*'.freeze
-      
-      # Header values
-      NO_CACHE = 'no-cache'.freeze
-      IF_NONE_MATCH_REGEXP = /^"?([^"]+)"?$/.freeze
-  
-      # etags
-      EXPIRY_ETAG_REGEXP = /(\d+)-(\d+)/.freeze
-      EXPIRY_ETAG_FORMAT = "%d-%d".freeze
-      ETAG_QUOTE_FORMAT = '"%s"'.freeze
-    
-      # 304 formats
-      NOT_MODIFIED_CLOSE = "HTTP/1.1 304 Not Modified\r\nDate: %s\r\nConnection: close\r\nContent-Length: 0\r\n\r\n".freeze
-      NOT_MODIFIED_PERSIST = "HTTP/1.1 304 Not Modified\r\nDate: %s\r\nContent-Length: 0\r\n\r\n".freeze
-      
-      def disable_caching
-        @response_headers[CACHE_CONTROL] = NO_CACHE
-        @response_headers.delete(ETAG)
-        @response_headers.delete(LAST_MODIFIED)
-        @response_headers.delete(EXPIRES)
-        @response_headers.delete(VARY)
-      end
-    
-      def etag_validators
-        h = @headers[IF_NONE_MATCH]
-        return [] unless h
-        h.split(',').inject([]) do |m, i|
-          i.strip =~ IF_NONE_MATCH_REGEXP ? (m << $1) : m
-        end
-      end
-      
-      def valid_etag?(etag = nil)
-        if etag
-          etag_validators.each {|e| return true if e == etag || e == WILDCARD}
-        else
-          etag_validators.each do |e|
-            return true if e == WILDCARD ||
-              ((e =~ EXPIRY_ETAG_REGEXP) && (Time.at($2.to_i) > Time.now))
-          end
-        end
-        nil
-      end
-      
-      def expiry_etag(stamp, max_age)
-        EXPIRY_ETAG_FORMAT % [stamp.to_i, (stamp + max_age).to_i]
-      end
-      
-      def valid_stamp?(stamp)
-        return true if (modified_since = @headers[IF_MODIFIED_SINCE]) &&
-          (modified_since == stamp.httpdate)
-      end
-      
-      def validate_cache(stamp, max_age, etag = nil, 
-        cache_control = nil, vary = nil, &block)
-        
-        if valid_etag?(etag) || valid_stamp?(stamp)
-          send_not_modified_response
-          true
-        else
-          @response_headers[ETAG] = ETAG_QUOTE_FORMAT %
-            [etag || expiry_etag(stamp, max_age)]
-          @response_headers[LAST_MODIFIED] = stamp.httpdate
-          @response_headers[EXPIRES] = (Time.now + max_age).httpdate
-          @response_headers[CACHE_CONTROL] = cache_control if cache_control
-          @response_headers[VARY] = vary if vary
-          block ? block.call : nil
-        end
-      end
-      
-      def send_not_modified_response
-        @socket << ((@persistent ? NOT_MODIFIED_PERSIST : NOT_MODIFIED_CLOSE) %
-          Time.now.httpdate)
-      end
-    end
-  end
-end

data/lib/serverside/connection.rb

@@ -1,34 +0,0 @@
-require File.join(File.dirname(__FILE__), 'static')
-
-module ServerSide
-  module HTTP
-    # The Connection class represents HTTP connections. Each connection
-    # instance creates a separate thread for execution and processes
-    # incoming requests in a loop until the connection is closed by
-    # either server or client, thus implementing HTTP 1.1 persistent
-    # connections.
-    class Connection
-      # Initializes the request instance. A new thread is created for
-      # processing requests.
-      def initialize(socket, request_class)
-        @socket, @request_class = socket, request_class
-        @thread = Thread.new {process}
-      end
-      
-      # Processes incoming requests by parsing them and then responding. If
-      # any error occurs, or the connection is not persistent, the connection 
-      # is closed.
-      def process
-        while true
-          # the process function is expected to return true or a non-nil value
-          # if the connection is to persist.
-          break unless @request_class.new(@socket).process
-        end
-      rescue => e
-        # We don't care. Just close the connection.
-      ensure
-        @socket.close
-      end
-    end
-  end
-end

data/lib/serverside/controllers.rb

@@ -1,91 +0,0 @@
-require File.join(File.dirname(__FILE__), 'routing')
-require 'rubygems'
-require 'metaid'
-
-module ServerSide
-  # Implements a basic controller class for handling requests. Controllers can
-  # be mounted by using the Controller.mount  
-  class Controller
-    # Creates a subclass of Controller which adds a routing rule when 
-    # subclassed. For example:
-    #
-    #   class MyController < ServerSide::Controller.mount('/ohmy')
-    #     def response
-    #       render('Hi there!', 'text/plain')
-    #     end
-    #   end
-    #
-    # You can of course route according to any rule as specified in
-    # ServerSide::Router.route, including passing a block as a rule, e.g.:
-    #
-    #   class MyController < ServerSide::Controller.mount {@headers['Accept'] =~ /wap/}
-    #     ...
-    #   end
-    def self.mount(rule = nil, &block)
-      rule ||= block
-      raise ArgumentError, "No routing rule specified." if rule.nil?
-      Class.new(self) do
-        meta_def(:inherited) do |sub_class|
-          ServerSide::Router.route(rule) {sub_class.new(self)}
-        end
-      end
-    end
-    
-    # Initialize a new controller instance. Sets @request to the request object
-    # and copies both the request path and parameters to instance variables.
-    # After calling response, this method checks whether a response has been sent
-    # (rendered), and if not, invokes the render_default method. 
-    def initialize(request)
-      @request = request
-      @path = request.path
-      @parameters = request.parameters
-      response
-      render_default if not @rendered
-    end
-    
-    # Renders the response. This method should be overriden.
-    def response
-    end
-    
-    # Sends a default response.
-    def render_default
-      @request.send_response(200, 'text/plain', 'no response.')
-    end
-    
-    # Sends a response and sets @rendered to true.
-    def render(body, content_type)
-      @request.send_response(200, content_type, body)
-      @rendered = true
-    end
-  end
-end
-
-__END__
-
-class ServerSide::ActionController < ServerSide::Controller
-  def self.default_routing_rule
-    if name.split('::').last =~ /(.+)Controller$/
-      controller = Inflector.underscore($1) 
-      {:path => ["/#{controller}", "/#{controller}/:action", "/#{controller}/:action/:id"]}
-    end
-  end
-
-  def self.inherited(c)
-    routing_rule = c.respond_to?(:routing_rule) ?
-      c.routing_rule : c.default_routing_rule
-    if routing_rule
-      ServerSide::Router.route(routing_rule) {c.new(self)}
-    end
-  end
-  
-  def self.route(arg = nil, &block)
-    rule = arg || block
-    meta_def(:get_route) {rule}
-  end
-end
-
-class MyController < ActionController
-  route "hello"
-end
-
-p MyController.get_route

data/lib/serverside/request.rb

@@ -1,210 +0,0 @@
-require File.join(File.dirname(__FILE__), 'static')
-require 'time'
-
-module ServerSide
-  module HTTP
-    # The Request class encapsulates HTTP requests. The request class 
-    # contains methods for parsing the request and rendering a response.
-    # HTTP requests are created by the connection. Descendants of HTTPRequest
-    # can be created
-    # When a connection is created, it creates new requests in a loop until
-    # the connection is closed.
-    class Request
-      
-      LINE_BREAK = "\r\n".freeze
-      # Here's a nice one - parses the first line of a request.
-      # The expected format is as follows:
-      # <method> </path>[/][?<query>] HTTP/<version>
-      REQUEST_REGEXP = /([A-Za-z0-9]+)\s(\/[^\/\?]*(?:\/[^\/\?]+)*)\/?(?:\?(.*))?\sHTTP\/(.+)\r/.freeze
-      # Regexp for parsing headers.
-      HEADER_REGEXP = /([^:]+):\s?(.*)\r\n/.freeze
-      CONTENT_LENGTH = 'Content-Length'.freeze
-      VERSION_1_1 = '1.1'.freeze
-      CONNECTION = 'Connection'.freeze
-      CLOSE = 'close'.freeze
-      AMPERSAND = '&'.freeze
-      # Regexp for parsing URI parameters.
-      PARAMETER_REGEXP = /(.+)=(.*)/.freeze
-      EQUAL_SIGN = '='.freeze
-      STATUS_CLOSE = "HTTP/1.1 %d\r\nDate: %s\r\nConnection: close\r\nContent-Type: %s\r\n%s%sContent-Length: %d\r\n\r\n".freeze
-      STATUS_STREAM = "HTTP/1.1 %d\r\nDate: %s\r\nConnection: close\r\nContent-Type: %s\r\n%s%s\r\n".freeze
-      STATUS_PERSIST = "HTTP/1.1 %d\r\nDate: %s\r\nContent-Type: %s\r\n%s%sContent-Length: %d\r\n\r\n".freeze
-      STATUS_REDIRECT = "HTTP/1.1 %d\r\nDate: %s\r\nConnection: close\r\nLocation: %s\r\n\r\n".freeze
-      HEADER = "%s: %s\r\n".freeze
-      EMPTY_STRING = ''.freeze
-      EMPTY_HASH = {}.freeze
-      SLASH = '/'.freeze
-      LOCATION = 'Location'.freeze
-      COOKIE = 'Cookie'
-      SET_COOKIE = "Set-Cookie: %s=%s; path=/; expires=%s\r\n".freeze
-      COOKIE_SPLIT = /[;,] */n.freeze
-      COOKIE_REGEXP = /\s*(.+)=(.*)\s*/.freeze
-      COOKIE_EXPIRED_TIME  = Time.at(0).freeze
-      CONTENT_TYPE = "Content-Type".freeze
-      CONTENT_TYPE_URL_ENCODED = 'application/x-www-form-urlencoded'.freeze
-      
-      include Static
-      
-      attr_reader :socket, :method, :path, :query, :version, :parameters,
-        :headers, :persistent, :cookies, :response_cookies, :body,
-        :content_length, :content_type, :response_headers
-      
-      # Initializes the request instance. Any descendants of HTTP::Request
-      # which override the initialize method must receive socket as the
-      # single argument, and copy it to @socket.
-      def initialize(socket)
-        @socket = socket
-        @response_headers = {}
-      end
-
-      # Processes the request by parsing it and then responding.      
-      def process
-        parse && ((respond || true) && @persistent)
-      end
-      
-      # Parses an HTTP request. If the request is not valid, nil is returned.
-      # Otherwise, the HTTP headers are returned. Also determines whether the
-      # connection is persistent (by checking the HTTP version and the 
-      # 'Connection' header).
-      def parse
-        return nil unless @socket.gets =~ REQUEST_REGEXP
-        @method, @path, @query, @version = $1.downcase.to_sym, $2, $3, $4
-        @parameters = @query ? parse_parameters(@query) : {}
-        @headers = {}
-        while (line = @socket.gets)
-          break if line.nil? || (line == LINE_BREAK)
-          if line =~ HEADER_REGEXP
-            @headers[$1.freeze] = $2.freeze
-          end
-        end
-        @persistent = (@version == VERSION_1_1) && 
-          (@headers[CONNECTION] != CLOSE)
-        @cookies = @headers[COOKIE] ? parse_cookies : EMPTY_HASH
-        @response_cookies = nil
-        
-        if @content_length = @headers[CONTENT_LENGTH].to_i
-          @content_type = @headers[CONTENT_TYPE] || CONTENT_TYPE_URL_ENCODED
-          @body = @socket.read(@content_length) rescue nil
-          parse_body
-        end
-        
-        @headers
-      end
-      
-      # Parses query parameters by splitting the query string and unescaping
-      # parameter values.
-      def parse_parameters(query)
-        query.split(AMPERSAND).inject({}) do |m, i|
-          if i =~ PARAMETER_REGEXP
-            m[$1.to_sym] = $2.uri_unescape
-          end
-          m
-        end
-      end
-      
-      # Parses cookie values passed in the request
-      def parse_cookies
-        @headers[COOKIE].split(COOKIE_SPLIT).inject({}) do |m, i|
-          if i =~ COOKIE_REGEXP
-            m[$1.to_sym] = $2.uri_unescape
-          end
-          m
-        end
-      end
-      
-      MULTIPART_REGEXP = /multipart\/form-data.*boundary=\"?([^\";,]+)/n.freeze
-      CONTENT_DISPOSITION_REGEXP = /^Content-Disposition: form-data;([^\r]*)/m.freeze
-      FIELD_ATTRIBUTE_REGEXP = /\s*(\w+)=\"([^\"]*)/.freeze
-      CONTENT_TYPE_REGEXP = /^Content-Type: ([^\r]*)/m.freeze
-
-      # parses the body, either by using
-      def parse_body
-        if @content_type == CONTENT_TYPE_URL_ENCODED
-          @parameters.merge! parse_parameters(@body)
-        elsif @content_type =~ MULTIPART_REGEXP
-          boundary = "--#$1"
-          r = /(?:\r?\n|\A)#{Regexp::quote("--#$1")}(?:--)?\r\n/m
-          @body.split(r).each do |pt|
-            headers, payload = pt.split("\r\n\r\n", 2)
-            atts = {}
-            if headers =~ CONTENT_DISPOSITION_REGEXP
-              $1.split(';').map do |part|
-                if part =~ FIELD_ATTRIBUTE_REGEXP
-                  atts[$1.to_sym] = $2
-                end
-              end
-            end
-            if headers =~ CONTENT_TYPE_REGEXP
-              atts[:type] = $1
-            end
-            if name = atts[:name]
-              atts[:content] = payload
-              @parameters[name.to_sym] = atts[:filename] ? atts : atts[:content]
-            end
-          end
-        end
-      end
-    
-      # Sends an HTTP response.
-      def send_response(status, content_type, body = nil, content_length = nil, 
-        headers = nil)
-        @response_headers.merge!(headers) if headers
-        h = @response_headers.inject('') {|m, kv| m << (HEADER % kv)}
-        
-        # calculate content_length if needed. if we dont have the 
-        # content_length, we consider the response as a streaming response, 
-        # and so the connection will not be persistent.
-        content_length = body.length if content_length.nil? && body
-        @persistent = false if content_length.nil?
-        
-        # Select the right format to use according to circumstances.
-        @socket << ((@persistent ? STATUS_PERSIST : 
-          (body ? STATUS_CLOSE : STATUS_STREAM)) % 
-          [status, Time.now.httpdate, content_type, h, @response_cookies, 
-            content_length])
-        @socket << body if body
-      rescue
-        @persistent = false
-      end
-      
-      CONTENT_DISPOSITION = 'Content-Disposition'.freeze
-      CONTENT_DESCRIPTION = 'Content-Description'.freeze
-
-      def send_file(content, content_type, disposition = :inline, 
-        filename = nil, description = nil)
-        disposition = filename ?
-          "#{disposition}; filename=#{filename}" : disposition
-        @response_headers[CONTENT_DISPOSITION] = disposition
-        @response_headers[CONTENT_DESCRIPTION] = description if description
-        send_response(200, content_type, content)
-      end
-      
-      # Send a redirect response.
-      def redirect(location, permanent = false)
-        @socket << (STATUS_REDIRECT % 
-          [permanent ? 301 : 302, Time.now.httpdate, location])
-      rescue
-      ensure
-        @persistent = false
-      end
-      
-      # Streams additional data to the client.
-      def stream(body)
-        (@socket << body if body) rescue (@persistent = false)
-      end
-      
-      # Sets a cookie to be included in the response.
-      def set_cookie(name, value, expires)
-        @response_cookies ||= ""
-        @response_cookies <<
-          (SET_COOKIE % [name, value.to_s.uri_escape, expires.rfc2822])
-      end
-      
-      # Marks a cookie as deleted. The cookie is given an expires stamp in 
-      # the past.
-      def delete_cookie(name)
-        set_cookie(name, nil, COOKIE_EXPIRED_TIME)
-      end
-    end
-  end
-end

data/lib/serverside/routing.rb

@@ -1,133 +0,0 @@
-require File.join(File.dirname(__FILE__), 'request')
-
-module ServerSide
-  # The Router class is a subclass of HTTP::Request that can invoke
-  # different handlers based on rules that can be specified either by
-  # lambdas or by hashes that contain variable names corresponding to patterns.
-  #
-  # The simplest form of a routing rule specifies a path pattern:
-  #
-  #   ServerSide.route('/static') {serve_static('.'/@path)}
-  # 
-  # But you can also check for other attributes of the request:
-  #
-  #   ServerSide.route(:path => '/static', :host => '^:subdomain\.mydomain') {
-  #     serve_static(@parameters[:subdomain]/@path)
-  #   }
-  # 
-  # It also possible to pass a lambda as a rule:
-  #
-  #   ServerSide.route(lambda {@headers['Agent'] =~ /Moz/}) {serve_static('moz'/@path)}
-  #
-  # Routing rules are evaluated backwards, so the rules should be ordered
-  # from the general to the specific.
-  class Router < HTTP::Request
-    @@rules = []
-    @@default_route = nil
-  
-    # Returns true if routes were defined.
-    def self.routes_defined?
-      !@@rules.empty? || @@default_route
-    end
-    
-    # Adds a routing rule. The normalized rule is a hash containing keys (acting
-    # as instance variable names) with patterns as values. If the rule is not a
-    # hash, it is normalized into a pattern checked against the request path.
-    # Pattern values can also be arrays, any member of which is checked as a
-    # pattern. The rule can also be a Proc or lambda which is run with the
-    # connection object's binding. A contrived example:
-    #
-    #   ServerSide.route(lambda{path = 'mypage'}) {serve_static('mypage.html')}
-    def self.route(rule, &block)
-      rule = {:path => rule} unless (Hash === rule) || (Proc === rule)
-      @@rules.unshift [rule, block]
-      compile_rules
-    end
-    
-    # Compiles all rules into a respond method that is invoked when a request
-    # is received.
-    def self.compile_rules
-      code = @@rules.inject('lambda {') {|m, r| m << rule_to_statement(r[0], r[1])}
-      code << 'default_handler}'
-      define_method(:respond, &eval(code))
-    end
-    
-    # Converts a rule into an if statement. All keys in the rule are matched
-    # against their respective values.
-    def self.rule_to_statement(rule, block)
-      proc_tag = define_proc(&block)
-      if Proc === rule
-        cond = define_proc(&rule).to_s
-      else
-        cond = rule.to_a.map {|kv|
-          if Array === kv[1]
-            '(' + kv[1].map {|v| condition_part(kv[0], v)}.join('||') + ')'
-          else
-            condition_part(kv[0], kv[1])
-          end
-        }.join('&&')
-      end
-      "if #{cond} && (r = #{proc_tag}); return r; end\n"
-    end
-
-    # Pattern for finding parameters inside patterns. Parameters are parts 
-    # of the pattern, which the routing pre-processor turns into sub-regexp 
-    # that are used to extract parameter values from the pattern.
-    #
-    # For example, matching '/controller/show' against '/controller/:action'
-    # will give us @parameters[:action] #=> "show"
-    ParamRegexp = /(?::([a-z]+))/
-
-    # Returns the condition part for the key and value specified. The key is the
-    # name of an instance variable and the value is a pattern to match against.
-    # If the pattern contains parameters (for example, /controller/:action,) the
-    # method creates a lambda for extracting the parameter values.
-    def self.condition_part(key, value)
-      p_parse, p_count = '', 0
-      while (String === value) && (value =~ ParamRegexp)
-        value = value.dup
-        p_name = $1
-        p_count += 1
-        value.sub!(ParamRegexp, '(.+)')
-        p_parse << "@parameters[:#{p_name}] = $#{p_count}\n"
-      end
-      cond = "(@#{key} =~ #{cache_constant(Regexp.new(value))})"
-      if p_count == 0
-        cond
-      else
-        tag = define_proc(&eval(
-          "lambda {if #{cond}\n#{p_parse}true\nelse\nfalse\nend}"))
-        "(#{tag})"
-      end
-    end
-
-    # Converts a proc into a method, returning the method's name (as a symbol)
-    def self.define_proc(&block)
-      tag = block.proc_tag
-      define_method(tag.to_sym, &block) unless instance_methods.include?(tag)
-      tag.to_sym
-    end
-
-    # Converts a value into a local constant and freezes it. Returns the 
-    # constant's tag name
-    def self.cache_constant(value)
-      tag = value.const_tag
-      class_eval "#{tag} = #{value.inspect}.freeze" rescue nil
-      tag
-    end
-
-    # Sets the default handler for incoming requests.
-    def self.default_route(&block)
-      @@default_route = block
-      define_method(:default_handler, &block)
-      compile_rules
-    end
-
-    # Generic responder for unhandled requests.
-    def unhandled
-      send_response(403, 'text', 'No handler found.')
-    end
-
-    alias_method :default_handler, :unhandled
-  end
-end

data/lib/serverside/server.rb

@@ -1,27 +0,0 @@
-require 'socket'
-
-module ServerSide
-  module HTTP
-    # The ServerSide HTTP server is designed to be fast and simple. It is also
-    # designed to support both HTTP 1.1 persistent connections, and HTTP streaming
-    # for applications which use Comet techniques.
-    class Server
-      attr_reader :listener
-
-      # Creates a new server by opening a listening socket.
-      def initialize(host, port, request_class)
-        @request_class = request_class
-        @listener = TCPServer.new(host, port)
-      end
-      
-      # starts an accept loop. When a new connection is accepted, a new 
-      # instance of the supplied connection class is instantiated and passed 
-      # the connection for processing.
-      def start
-        while true
-          Connection.new(@listener.accept, @request_class)
-        end
-      end
-    end
-  end
-end

data/lib/serverside/static.rb

@@ -1,82 +0,0 @@
-require File.join(File.dirname(__FILE__), 'caching')
-
-module ServerSide
-  # This module provides functionality for serving files and directory listings
-  # over HTTP.
-  module Static
-    include HTTP::Caching
-    
-    ETAG_FORMAT = '%x:%x:%x'.freeze
-    TEXT_PLAIN = 'text/plain'.freeze
-    TEXT_HTML = 'text/html'.freeze
-    MAX_CACHE_FILE_SIZE = 100000.freeze # 100KB for the moment
-    MAX_AGE = 86400 # one day
-    
-    DIR_LISTING_START = '<html><head><title>Directory Listing for %s</title></head><body><h2>Directory listing for %s:</h2>'.freeze
-    DIR_LISTING = '<a href="%s">%s</a><br/>'.freeze
-    DIR_LISTING_STOP = '</body></html>'.freeze
-    FILE_NOT_FOUND = 'File not found.'.freeze
-    RHTML = /\.rhtml$/.freeze
-    
-    @@mime_types = Hash.new {|h, k| TEXT_PLAIN}
-    @@mime_types.merge!({
-      '.html'.freeze => 'text/html'.freeze,
-      '.css'.freeze => 'text/css'.freeze,
-      '.js'.freeze => 'text/javascript'.freeze,
-
-      '.gif'.freeze => 'image/gif'.freeze,
-      '.jpg'.freeze => 'image/jpeg'.freeze,
-      '.jpeg'.freeze => 'image/jpeg'.freeze,
-      '.png'.freeze => 'image/png'.freeze
-    })
-    
-    # Serves a file over HTTP. The file is cached in memory for later retrieval.
-    # If the If-None-Match header is included with an ETag, it is checked
-    # against the file's current ETag. If there's a match, a 304 response is
-    # rendered.
-    def serve_file(fn)
-      stat = File.stat(fn)
-      etag = (ETAG_FORMAT % [stat.mtime.to_i, stat.size, stat.ino]).freeze
-      validate_cache(stat.mtime, MAX_AGE, etag) do
-        send_response(200, @@mime_types[File.extname(fn)], IO.read(fn), 
-          stat.size)
-      end
-    rescue => e
-      send_response(404, TEXT_PLAIN, 'Error reading file.')
-    end
-    
-    # Serves a directory listing over HTTP in the form of an HTML page.
-    def serve_dir(dir)
-      entries = Dir.entries(dir)
-      entries.reject! {|fn| fn =~ /^\./}
-      entries.unshift('..') if dir != './'
-      html = (DIR_LISTING_START % [@path, @path]) +
-        entries.inject('') {|m, fn| m << DIR_LISTING % [@path/fn, fn]} +
-        DIR_LISTING_STOP
-      send_response(200, 'text/html', html)
-    end
-    
-    def serve_template(fn, b = nil)
-      send_response(200, TEXT_HTML, Template.render(fn, b || binding))
-    end
-    
-    # Serves static files and directory listings.
-    def serve_static(path)
-      if File.file?(path)
-        path =~ RHTML ? serve_template(path) : serve_file(path)
-      elsif File.directory?(path)
-        if File.file?(path/'index.html')
-          serve_file(path/'index.html')
-        elsif File.file?(path/'index.rhtml')
-          serve_template(path/'index.rhtml')
-        else
-          serve_dir(path)
-        end
-      else
-        send_response(404, 'text', FILE_NOT_FOUND)
-      end
-    rescue => e
-      send_response(500, 'text', e.message)
-    end
-  end
-end