mongrel 0.3.11 → 0.3.12

data/lib/mongrel/command.rb

@@ -15,7 +15,7 @@ module Mongrel
     # user's bidding.
     module Base
       
-      attr_reader :valid, :done_validating
+      attr_reader :valid, :done_validating, :original_args
 
       # Called by the implemented command to set the options for that command.
       # Every option has a short and long version, a description, a variable to

data/lib/mongrel/debug.rb

@@ -0,0 +1,259 @@
+require 'logger'
+require 'set'
+require 'socket'
+
+$mongrel_debugging=true
+
+module MongrelDbg
+  SETTINGS = { :tracing => {}}
+  LOGGING = { }
+
+  def MongrelDbg::configure(log_dir = "log/mongrel_debug")
+    Dir.mkdir(log_dir) if not File.exist?(log_dir)
+    @log_dir = log_dir
+  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, "TRACING ON #{Time.now}")
+  end
+
+  def MongrelDbg::end_trace(target)
+    SETTINGS[:tracing][target] = false
+    MongrelDbg::trace(target, "TRACING OFF #{Time.now}")
+    LOGGING[target].close
+    LOGGING[target] = nil
+  end
+
+  def MongrelDbg::tracing?(target)
+    SETTINGS[:tracing][target]
+  end
+end
+
+
+module ObjectTracker
+  @active_objects = nil
+  @live_object_tracking = true
+
+  def ObjectTracker.configure
+    @active_objects = Set.new
+
+    ObjectSpace.each_object do |obj|
+      @active_objects << obj.object_id
+    end
+  end
+
+
+  def ObjectTracker.start
+    @live_object_tracking = true
+  end
+
+  def ObjectTracker.stop
+    @live_object_tracking = false
+  end
+
+  def ObjectTracker.sample
+    Class.stopit do
+      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|
+        if not obj.kind_of? String
+          ospace << obj.object_id
+          counts[obj.class] ||= 0
+          counts[obj.class] += 1
+        end
+      end
+      
+      dead_objects = @active_objects - ospace
+      new_objects = ospace - @active_objects
+      live_objects = ospace & @active_objects
+      
+      MongrelDbg::trace(:objects, "COUNTS: #{dead_objects.length},#{new_objects.length},#{live_objects.length}")
+      
+      if MongrelDbg::tracing? :objects
+        top_20 = counts.sort{|a,b| b[1] <=> a[1]}[0..20]
+        MongrelDbg::trace(:objects,"TOP 20: #{top_20.inspect}")
+      end
+      
+      @active_objects = live_objects + new_objects
+
+      [@active_objects, top_20]
+    end
+  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
+    Class.stopit do
+      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
+end  
+
+
+
+class Class
+  alias_method :orig_new, :new
+  
+  @@count = 0
+  @@stopit = false
+  @@class_caller_count = Hash.new{|hash,key| hash[key] = Hash.new(0)}
+  
+  def new(*arg,&blk)
+    unless @@stopit
+      @@stopit = true
+      @@count += 1
+      @@class_caller_count[self][caller.join("\n\t")] += 1
+      @@stopit = false
+    end
+    orig_new(*arg,&blk)
+  end
+
+
+  def Class.report_object_creations(out=$stderr, more_than=20)
+    Class.stopit do
+      out.puts "Number of objects created = #{@@count}"
+      
+      total = Hash.new(0)
+      
+      @@class_caller_count.each_key do |klass|
+        caller_count = @@class_caller_count[klass]
+        caller_count.each_value do |count|
+          total[klass] += count
+        end
+      end
+      
+      klass_list = total.keys.sort{|klass_a, klass_b| 
+        a = total[klass_a]
+        b = total[klass_b]
+        if a != b
+          -1* (a <=> b)
+        else
+          klass_a.to_s <=> klass_b.to_s
+        end
+      }
+
+      below_count = 0
+
+      klass_list.each do |klass|
+        below_calls = 0
+        if total[klass] > more_than
+          out.puts "#{total[klass]}\t#{klass} objects created."
+          caller_count = @@class_caller_count[ klass]
+          caller_count.keys.sort_by{|call| -1*caller_count[call]}.each do |call|
+            if caller_count[call] > more_than
+              out.puts "\t** #{caller_count[call]} #{klass} objects AT:"
+              out.puts "\t#{call}\n\n"
+            else
+              below_calls += 1
+            end
+          end
+          out.puts "\t#{below_calls} more objects had calls less that #{more_than} limit.\n\n" if below_calls > 0
+        else
+          below_count += 1
+        end
+      end
+
+      out.puts "\t** #{below_count} More objects were created but the count was below the #{more_than} limit." if below_count > 0
+    end
+  end
+
+  def Class.reset_object_creations
+    Class.stopit do
+      @@count = 0
+      @@class_caller_count = Hash.new{|hash,key| hash[key] = Hash.new(0)} 
+    end
+  end
+
+  def Class.stopit
+    @@stopit = true
+    yield
+    @@stopit = false
+  end
+
+end
+
+
+module RequestLog
+  class Files < GemPlugin::Plugin "/handlers"
+    include Mongrel::HttpHandlerPlugin
+    
+    def process(request, response)
+      MongrelDbg::trace(:files, "#{Time.now} FILES OPEN BEFORE REQUEST #{request.params['PATH_INFO']}")
+      log_open_files
+    end
+    
+  end
+
+  class Objects < GemPlugin::Plugin "/handlers"
+    include Mongrel::HttpHandlerPlugin
+    
+    def process(request, response)
+      MongrelDbg::trace(:objects, "#{Time.now} OBJECT STATS BEFORE REQUEST #{request.params['PATH_INFO']}")
+      ObjectTracker.sample
+    end
+    
+  end
+  
+
+  class Params < GemPlugin::Plugin "/handlers"
+    include Mongrel::HttpHandlerPlugin
+    
+    def process(request, response)
+      MongrelDbg::trace(:rails, "#{Time.now} REQUEST #{request.params['PATH_INFO']}")
+      MongrelDbg::trace(:rails, request.params.to_yaml)
+    end
+
+  end
+end
+
+
+END {
+open("log/mongrel_debug/object_tracking.log", "w") {|f| Class.report_object_creations(f) }
+MongrelDbg::trace(:files, "FILES OPEN AT EXIT")
+log_open_files
+}

data/lib/mongrel/handlers.rb

@@ -1,3 +1,11 @@
+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
 
 module Mongrel
 
@@ -5,12 +13,35 @@ module Mongrel
   # 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
+
     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
+
+    def initialize(options={})
+      @options = options
+    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.
@@ -53,6 +84,7 @@ module Mongrel
       ".txt"        =>  "text/plain"
     }
 
+    ONLY_HEAD_GET="Only HEAD and GET allowed.".freeze
 
     attr_reader :path
 
@@ -103,7 +135,7 @@ module Mongrel
 
       if @listing_allowed
         response.start(200) do |head,out|
-          head['Content-Type'] = "text/html"
+          head[Const::CONTENT_TYPE] = "text/html"
           out << "<html><head><title>Directory Listing</title></head><body>"
           Dir.entries(dir).each do |child|
             next if child == "."
@@ -126,20 +158,40 @@ module Mongrel
     
     # 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)
-      response.start(200) do |head,out|
-        # set the mime type from our map based on the ending
-        dot_at = req.rindex(".")
-        if dot_at
-          ext = req[dot_at .. -1]
-          if MIME_TYPES[ext]
-            head['Content-Type'] = MIME_TYPES[ext]
-          end
+    def send_file(req, 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
+      
+      # set the mime type from our map based on the ending
+      dot_at = req.rindex(".")
+      if dot_at
+        ext = req[dot_at .. -1]
+        if MIME_TYPES[ext]
+          stat = File.stat(req)
+          response.header[Const::CONTENT_TYPE] = MIME_TYPES[ext]
+          # TODO: Confirm this works for rfc 1123
+          response.header[Const::LAST_MODIFIED] = HttpServer.httpdate(stat.mtime)
+          # TODO that this is a valid way to calculate an etag
+          response.header[Const::ETAG] = Const::ETAG_FORMAT % [stat.mtime.to_i, stat.size, stat.ino]
         end
+      end
 
-        open(req, "rb") do |f|
-          out.write(f.read)
-        end
+      response.send_status(File.size(req))
+      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
+	  # ignore these since it means the client closed off early
+	end
+      else
+        response.send_body # should send nothing
       end
     end
 
@@ -147,7 +199,8 @@ module Mongrel
     # Process the request to either serve a file or a directory listing
     # if allowed (based on the listing_allowed paramter to the constructor).
     def process(request, response)
-      req = can_serve request.params['PATH_INFO']
+      req_method = request.params[Const::REQUEST_METHOD] || Const::GET
+      req = can_serve request.params[Const::PATH_INFO]
       if not req
         # not found, return a 404
         response.start(404) do |head,out|
@@ -156,16 +209,17 @@ module Mongrel
       else
         begin
           if File.directory? req
-            send_dir_listing(request.params["REQUEST_URI"],req, response)
-          else
-            send_file(req, response)
+            send_dir_listing(request.params[Const::REQUEST_URI],req, 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) }
           end
         rescue => details
-          response.reset
-          response.start(403) do |head,out|
-            out << "Error accessing file: #{details}"
-            out << details.backtrace.join("\n")
-          end
+          STDERR.puts "Error accessing file #{req}: #{details}"
+          STDERR.puts details.backtrace.join("\n")
         end
       end
     end

data/lib/mongrel/rails.rb

@@ -1,85 +1,178 @@
 require 'mongrel'
 require 'cgi'
 
-# Implements a handler that can run Rails and serve files out of the
-# Rails application's public directory.  This lets you run your Rails
-# application with Mongrel during development and testing, then use it
-# also in production behind a server that's better at serving the 
-# static files.
-#
-# The RailsHandler takes a mime_map parameter which is a simple suffix=mimetype
-# mapping that it should add to the list of valid mime types.
-#
-# It also supports page caching directly and will try to resolve a request
-# in the following order:
-#
-# * If the requested exact PATH_INFO exists as a file then serve it.
-# * If it exists at PATH_INFO+".html" exists then serve that.
-# * Finally, construct a Mongrel::CGIWrapper and run Dispatcher.dispath to have Rails go.
-#
-# This means that if you are using page caching it will actually work with Mongrel
-# and you should see a decent speed boost (but not as fast as if you use lighttpd).
-#
-# An additional feature you can use is 
-class RailsHandler < Mongrel::HttpHandler
-  attr_reader :files
-  attr_reader :guard
-  
-  def initialize(dir, mime_map = {})
-    @files = Mongrel::DirHandler.new(dir,false)
-    @guard = Mutex.new
+module Mongrel
+  module Rails
 
-    # register the requested mime types
-    mime_map.each {|k,v| Mongrel::DirHandler::add_mime_type(k,v) }
-  end
-  
-  # Attempts to resolve the request as follows:
-  #
-  #
-  # * If the requested exact PATH_INFO exists as a file then serve it.
-  # * If it exists at PATH_INFO+".html" exists then serve that.
-  # * Finally, construct a Mongrel::CGIWrapper and run Dispatcher.dispath to have Rails go.
-  def process(request, response)
-    return if response.socket.closed?
-
-    path_info = request.params[Mongrel::Const::PATH_INFO]
-    page_cached = request.params[Mongrel::Const::PATH_INFO] + ".html"
-
-    if @files.can_serve(path_info)
-      # File exists as-is so serve it up
-      @files.process(request,response)
-    elsif @files.can_serve(page_cached)
-      # possible cached page, serve it up      
-      request.params[Mongrel::Const::PATH_INFO] = page_cached
-      @files.process(request,response)
-    else
-      begin
-        cgi = Mongrel::CGIWrapper.new(request, response)
-        cgi.handler = self
 
+    # Implements a handler that can run Rails and serve files out of the
+    # Rails application's public directory.  This lets you run your Rails
+    # application with Mongrel during development and testing, then use it
+    # also in production behind a server that's better at serving the 
+    # static files.
+    #
+    # The RailsHandler takes a mime_map parameter which is a simple suffix=mimetype
+    # mapping that it should add to the list of valid mime types.
+    #
+    # It also supports page caching directly and will try to resolve a request
+    # in the following order:
+    #
+    # * If the requested exact PATH_INFO exists as a file then serve it.
+    # * If it exists at PATH_INFO+".html" exists then serve that.
+    # * Finally, construct a Mongrel::CGIWrapper and run Dispatcher.dispath to have Rails go.
+    #
+    # This means that if you are using page caching it will actually work with Mongrel
+    # and you should see a decent speed boost (but not as fast as if you use lighttpd).
+    #
+    # An additional feature you can use is 
+    class RailsHandler < Mongrel::HttpHandler
+      attr_reader :files
+      attr_reader :guard
+      
+      def initialize(dir, mime_map = {})
+        @files = Mongrel::DirHandler.new(dir,false)
+        @guard = Mutex.new
+        
+        # register the requested mime types
+        mime_map.each {|k,v| Mongrel::DirHandler::add_mime_type(k,v) }
+      end
+      
+      # Attempts to resolve the request as follows:
+      #
+      #
+      # * If the requested exact PATH_INFO exists as a file then serve it.
+      # * If it exists at PATH_INFO+".html" exists then serve that.
+      # * Finally, construct a Mongrel::CGIWrapper and run Dispatcher.dispath to have Rails go.
+      def process(request, response)
+        return if response.socket.closed?
+        
+        path_info = request.params[Mongrel::Const::PATH_INFO]
+        page_cached = request.params[Mongrel::Const::PATH_INFO] + ".html"
+        
+        if @files.can_serve(path_info)
+            # File exists as-is so serve it up
+          @files.process(request,response)
+        elsif @files.can_serve(page_cached)
+          # possible cached page, serve it up      
+          request.params[Mongrel::Const::PATH_INFO] = page_cached
+          @files.process(request,response)
+        else
+          begin
+            cgi = Mongrel::CGIWrapper.new(request, response)
+            cgi.handler = self
+            
+            @guard.synchronize do
+              # Rails is not thread safe so must be run entirely within synchronize 
+              Dispatcher.dispatch(cgi, ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, response.body)
+            end
+            
+            # This finalizes the output using the proper HttpResponse way
+            cgi.out {""}
+          rescue Errno::EPIPE
+            # ignored
+          rescue Object => rails_error
+            STDERR.puts "Error calling Dispatcher.dispatch #{rails_error.inspect}"
+            STDERR.puts rails_error.backtrace.join("\n")
+          end
+        end
+      end
+      
+      
+      # Does the internal reload for Rails.  It might work for most cases, but
+      # sometimes you get exceptions.  In that case just do a real restart.
+      def reload!
         @guard.synchronize do
-          # Rails is not thread safe so must be run entirely within synchronize 
-          Dispatcher.dispatch(cgi, ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, response.body)
+          $".replace $orig_dollar_quote
+          GC.start
+          Dispatcher.reset_application!
+          ActionController::Routing::Routes.reload
         end
-
-        # This finalizes the output using the proper HttpResponse way
-        cgi.out {""}
-      rescue Errno::EPIPE
-        # ignored
-      rescue Object => rails_error
-        STDERR.puts "Error calling Dispatcher.dispatch #{rails_error.inspect}"
-        STDERR.puts rails_error.backtrace.join("\n")
       end
     end
-  end
-
 
-  def reload!
-    @guard.synchronize do
-      $".replace $orig_dollar_quote
-      GC.start
-      Dispatcher.reset_application!
-      ActionController::Routing::Routes.reload
+    # Creates Rails specific configuration options for people to use 
+    # instead of the base Configurator.
+    class RailsConfigurator < Mongrel::Configurator
+      
+      # Creates a single rails handler and returns it so you
+      # can add it to a uri. You can actually attach it to 
+      # as many URIs as you want, but this returns the 
+      # same RailsHandler for each call.
+      #
+      # Requires the following options:
+      #
+      # * :docroot => The public dir to serve from.
+      # * :environment => Rails environment to use.
+      # * :cwd => The change to working directory
+      #
+      # And understands the following optional settings:
+      #
+      # * :mime => A map of mime types.
+      #
+      # Because of how Rails is designed you can only have
+      # one installed per Ruby interpreter (talk to them 
+      # about thread safety).  Because of this the first
+      # time you call this function it does all the config
+      # needed to get your rails working.  After that
+      # it returns the one handler you've configured.
+      # This lets you attach Rails to any URI (and mulitple)
+      # you want, but still protects you from threads destroying
+      # your handler.
+      def rails(options={})
+        
+        return @rails_handler if @rails_handler
+        
+        ops = resolve_defaults(options)
+        
+        # fix up some defaults
+        ops[:environment] ||= "development"
+        ops[:docroot] ||= "public"
+        ops[:mime] ||= {}
+        
+        
+        $orig_dollar_quote = $".clone
+        ENV['RAILS_ENV'] = ops[:environment]
+        require "#{ops[:cwd]}/config/environment"
+        require 'dispatcher'
+        require 'mongrel/rails'
+        
+        @rails_handler = RailsHandler.new(ops[:docroot], ops[:mime])
+      end
+      
+      
+      # Reloads rails.  This isn't too reliable really, but
+      # should work for most minimal reload purposes.  Only reliable
+      # way it so stop then start the process.
+      def reload!
+        if not @rails_handler
+          raise "Rails was not configured.  Read the docs for RailsConfigurator."
+        end
+        
+        log "Reloading rails..."
+        @rails_handler.reload!
+        log "Done reloading rails."
+        
+      end
+      
+      # Takes the exact same configuration as Mongrel::Configurator (and actually calls that)
+      # but sets up the additional HUP handler to call reload!.
+      def setup_rails_signals(options={})
+        ops = resolve_defaults(options)
+        
+        if RUBY_PLATFORM !~ /mswin/
+          setup_signals(options)
+          
+          # rails reload
+          trap("HUP") { 
+            log "HUP signal received."
+            reload!
+          }
+          
+          log "Rails signals registered.  HUP => reload (without restart).  It might not work well."
+        else
+          log "WARNING:  Rails does not support signals on Win32."
+        end
+      end
     end
   end
 end