mongrel 0.3.6 → 0.3.7

data/lib/mongrel.rb

@@ -4,16 +4,38 @@ require 'thread'
 require 'stringio'
 require 'mongrel/cgi'
 require 'mongrel/handlers'
+require 'mongrel/command'
+require 'mongrel/plugins'
+require 'timeout'
 
 # Mongrel module containing all of the classes (include C extensions) for running
 # a Mongrel web server.  It contains a minimalist HTTP server with just enough
 # functionality to service web application requests fast as possible.
 module Mongrel
 
+  class URIClassifier
+    # Returns the URIs that have been registered with this classifier so far.
+    # The URIs returned should not be modified as this will cause a memory leak.
+    # You can use this to inspect the contents of the URIClassifier.
+    def uris
+      @handler_map.keys
+    end
+
+    # Simply does an inspect that looks like a Hash inspect.
+    def inspect
+      @handler_map.inspect
+    end
+  end
+
+
   # Used to stop the HttpServer via Thread.raise.
   class StopServer < Exception
   end
 
+  # Used to timeout worker threads that have taken too long
+  class TimeoutWorker < Exception
+  end
+
   # 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.
@@ -118,7 +140,7 @@ module Mongrel
     SERVER_SOFTWARE='SERVER_SOFTWARE'
     
     # Current Mongrel version (used for SERVER_SOFTWARE and other response headers).
-    MONGREL_VERSION='Mongrel 0.3.6'
+    MONGREL_VERSION='Mongrel 0.3.7'
 
     # The standard empty 404 response for bad requests.  Use Error4040Handler for custom stuff.
     ERROR_404_RESPONSE="HTTP/1.1 404 Not Found\r\nConnection: close\r\nServer: #{MONGREL_VERSION}\r\n\r\nNOT FOUND"
@@ -320,24 +342,26 @@ module Mongrel
     # systems.  If you find that you overload Mongrel too much
     # try changing it higher.  If you find that responses are way too slow
     # try lowering it (after you've tuned your stuff of course).
-    # Future versions of Mongrel will make this more dynamic (hopefully).
     def initialize(host, port, num_processors=20, timeout=120)
-      @socket = TCPServer.new(host, port)
+      @socket = TCPServer.new(host, port) 
 
       @classifier = URIClassifier.new
       @req_queue = Queue.new
       @host = host
       @port = port
       @processors = []
-      @timeout = timeout
 
-      num_processors.times {|i| 
+      # create the worker threads
+      num_processors.times do |i| 
         @processors << Thread.new do
           while client = @req_queue.deq
-            process_client(client)
+            Timeout::timeout(timeout) do
+              process_client(client)
+            end
           end
         end
-      }
+      end
+
     end
     
 
@@ -440,8 +464,12 @@ module Mongrel
     # Stops the acceptor thread and then causes the worker threads to finish
     # off the request queue before finally exiting.
     def stop
-      @acceptor[:stopped] = true
-      @acceptor.raise(StopServer.new)
+      stopper = Thread.new do 
+        @acceptor[:stopped] = true
+        exc = StopServer.new
+        @acceptor.raise(exc)
+      end
+      stopper.priority = 10
     end
 
   end

data/lib/mongrel/command.rb

@@ -1,7 +1,6 @@
 require 'singleton'
 require 'optparse'
-require 'pluginfactory'
-
+require 'mongrel/plugins'
 
 module Mongrel
 
@@ -10,17 +9,10 @@ module Mongrel
 
   module Command
 
-
     # 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.
-    #
-    # Creating a new command is very easy, and you can do it without modifying the source
-    # of Mongrel thanks to PluginFactory.  What you do is the following:
-    #
-    # 1.  
-    class Command
-      include PluginFactory
+    module Base
       
       attr_reader :valid, :done_validating
 
@@ -39,11 +31,13 @@ module Mongrel
 
       # Called by the subclass to setup the command and parse the argv arguments.
       # The call is destructive on argv since it uses the OptionParser#parse! function.
-      def initialize(argv)
+      def initialize(options={})
+        argv = options[:argv]
         @opt = OptionParser.new
         @valid = true
         # this is retarded, but it has to be done this way because -h and -v exit
         @done_validating = false
+        @original_args = argv.dup
 
         configure
 
@@ -61,13 +55,7 @@ module Mongrel
           end
         end
         
-        @opt.parse! argv
-      end
-      
-      # Tells the PluginFactory where to look for additional commands.  By default
-      # it's just a "plugins" directory wherever we are located.
-      def self.derivativeDirs
-        return ["plugins"]
+        @opt.parse! options[:argv]
       end
       
       # Returns true/false depending on whether the command is configured properly.
@@ -118,8 +106,6 @@ module Mongrel
       end
     end
     
-    
-    
     # A Singleton class that manages all of the available commands
     # and handles running them.
     class Registry
@@ -127,15 +113,9 @@ module Mongrel
       
       # Builds a list of possible commands from the Command derivates list
       def commands
-        list = Command.derivatives()
-        match = Regexp.new("(.*::.*)|(.*command.*)", Regexp::IGNORECASE)
-        
-        results = []
-        list.keys.each do |key|
-          results << key.to_s unless match.match(key.to_s)
-        end
-        
-        return results.sort
+        pmgr = PluginManager.instance
+        list = pmgr.available["/commands"]
+        return list.sort
       end
 
       # Prints a list of available commands.
@@ -143,7 +123,7 @@ module Mongrel
         puts "Available commands are:\n\n"
         
         self.commands.each do |name|
-          puts " - #{name}\n"
+          puts " - #{name[1 .. -1]}\n"
         end
         
         puts "\nEach command takes -h as an option to get help."
@@ -154,9 +134,8 @@ module Mongrel
       # 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 and change the program's name to reflect it
+        # find the command
         cmd_name = args.shift
-        $0 = "#{cmd_name}"
         
         if !cmd_name or cmd_name == "?" or cmd_name == "help"
           print_command_list
@@ -165,8 +144,8 @@ module Mongrel
         
         # command exists, set it up and validate it
         begin
-          command = Command.create(cmd_name, args)
-        rescue FactoryError
+          command = PluginManager.instance.create("/commands/#{cmd_name}", :argv => args)
+        rescue
           STDERR.puts "INVALID COMMAND: #$!"
           print_command_list
           return

data/lib/mongrel/plugins.rb

@@ -0,0 +1,156 @@
+require 'singleton'
+
+module Mongrel
+
+  # Implements the main method of managing plugins for Mongrel.
+  # "Plugins" in this sense are any classes which get registered
+  # with Mongrel for possible use when it's operating.  These can
+  # be Handlers, Commands, or other classes.  When you create a 
+  # Plugin you register it into a URI-like namespace that makes
+  # it easy for you (and others) to reference it later during
+  # configuration.
+  #
+  # PluginManager is used as nothing more than a holder of all the
+  # plugins that have registered themselves.  Let's say you have:
+  #
+  #  class StopNow < Plugin "/commands"
+  #   ...
+  #  end
+  #
+  # Then you can get at this plugin with:
+  #
+  #  cmd = PluginManager.create("/commands/stopnow")
+  #
+  # The funky syntax for StopNow is a weird trick borrowed from
+  # the Camping framework. See the Mongrel::Plugin *function* (yes,
+  # function).  What this basically does is register it 
+  # into the namespace for plugins at /commands.  You could go
+  # as arbitrarily nested as you like.
+  #
+  # Why this strange almost second namespace?  Why not just use
+  # the ObjectSpace and/or Modules?  The main reason is speed and
+  # to avoid cluttering the Ruby namespace with what is really a 
+  # configuration statement.  This lets implementors put code 
+  # into the Ruby structuring they need, and still have Plugins
+  # available to Mongrel via simple URI-like names.
+  #
+  # The alternative (as pluginfactory does it) is to troll through
+  # ObjectSpace looking for stuff that *might* be plugins every time
+  # one is needed.  This alternative also means that you are stuck
+  # naming your commands in specific ways and putting them in specific
+  # modules in order to configure how Mongrel should use them.
+  #
+  # One downside to this is that you need to subclass plugin to 
+  # make it work.  In this case use mixins to add other functionality.
+  class PluginManager
+    include Singleton
+    
+    def initialize
+      @plugins = URIClassifier.new
+    end
+    
+    # Tell the PluginManager to scan the given path (recursively)
+    # and load the *.rb files found there.  This is how you'd 
+    # setup your own plugin directory.
+    def load(path)
+      Dir.chdir(path) do
+        Dir["**/*.rb"].each do |rbfile|
+          STDERR.puts "Loading plugins from #{rbfile}"
+          require rbfile
+        end
+      end
+    end
+    
+    # Not necessary for you to call directly, but this is
+    # how Mongrel::PluginBase.inherited actually adds a 
+    # plugin to a category.
+    def register(category, name, klass)
+      cat, ignored, map = @plugins.resolve(category)
+      
+      if not cat or ignored.length > 0
+        map = {name => klass}
+        @plugins.register(category, map)
+      elsif not map
+        raise "Unknown category #{category}"
+      else
+        map[name] = klass
+      end
+    end
+    
+    # Resolves the given name (should include /category/name) to
+    # find the plugin class and create an instance.  It uses
+    # the same URIClassifier that the rest of Mongrel does so it
+    # is fast.
+    def create(name, options = {})
+      category, plugin, map = @plugins.resolve(name)
+
+      if category and plugin and plugin.length > 0
+        map[plugin].new(options)
+      else
+        raise "Plugin #{name} does not exist"
+      end
+    end
+    
+    # Returns a map of URIs->[handlers] that you can
+    # use to investigate available handlers.
+    def available
+      map = {}
+      @plugins.uris.each do |u| 
+        cat, name, plugins = @plugins.resolve(u)
+        map[cat] ||= []
+        map[cat] += plugins.keys
+      end
+
+      return map
+    end
+    
+  end
+
+  # This base class for plugins reallys does nothing
+  # more than wire up the new class into the right category.
+  # It is not thread-safe yet but will be soon.
+  class PluginBase
+    
+    attr_reader :options
+
+
+    # See Mongrel::Plugin for an explanation.
+    def PluginBase.inherited(klass)
+      name = "/" + klass.to_s.downcase
+      PluginManager.instance.register(@@category, name, klass)
+      @@category = nil
+    end
+    
+    # See Mongrel::Plugin for an explanation.
+    def PluginBase.category=(category)
+      @@category = category
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+
+  end
+  
+  # This nifty function works with the PluginBase to give you
+  # the syntax:
+  #
+  #  class MyThing < Plugin "/things"
+  #    ...
+  #  end
+  #
+  # What it does is temporarily sets the PluginBase.category, and then
+  # returns PluginBase.  Since the next immediate thing Ruby does is
+  # use this returned class to create the new class, PluginBase.inherited
+  # gets called.  PluginBase.inherited then uses the set category, class name,
+  # and class to register the plugin in the right way.
+  def Mongrel::Plugin(c)
+    PluginBase.category = c
+    PluginBase
+  end
+  
+end
+
+
+
+

data/lib/mongrel/rails.rb

@@ -0,0 +1,70 @@
+require 'mongrel'
+
+
+# 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).
+class RailsHandler < Mongrel::HttpHandler
+  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["PATH_INFO"]
+    page_cached = request.params["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["PATH_INFO"] = page_cached
+      @files.process(request,response)
+    else
+      cgi = Mongrel::CGIWrapper.new(request, response)
+
+      begin
+        @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
+
+end

data/test/plugins/commands/test1.rb

@@ -0,0 +1,19 @@
+
+class First < Mongrel::Plugin "/commands"
+  def initialize(options = {})
+    puts "First with options: #{options.inspect}"
+  end
+end
+
+class Second < Mongrel::Plugin "/commands"
+  def initialize(options = {})
+    puts "Second with options: #{options.inspect}"
+  end
+end
+
+class Last < Mongrel::Plugin "/commands"
+  def initialize(options = {})
+    puts "Last with options: #{options.inspect}"
+  end
+end
+