headius-mongrel 1.1.6.1

data/lib/mongrel/rails.rb

@@ -0,0 +1,192 @@
+# 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'
+require 'cgi'
+
+
+module Mongrel
+  module Rails
+    # 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.dispatch 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 a static
+    # server like Apache or Litespeed).
+    class RailsHandler < Mongrel::HttpHandler
+      attr_reader :files
+      attr_reader :guard
+      @@file_only_methods = ["GET","HEAD"]
+
+      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.dispatch to have Rails go.
+      def process(request, response)
+        return if response.socket.closed?
+        
+        path_info = request.params[Mongrel::Const::PATH_INFO]
+        rest_operator = request.params[Mongrel::Const::REQUEST_URI][/^#{Regexp.escape path_info}(;[^\?]+)/, 1].to_s
+        path_info.chomp!("/")
+        
+        page_cached = path_info + rest_operator + ActionController::Base.page_cache_extension
+        get_or_head = @@file_only_methods.include? request.params[Mongrel::Const::REQUEST_METHOD]
+
+        if get_or_head and @files.can_serve(path_info)
+          # File exists as-is so serve it up
+          @files.process(request,response)
+        elsif get_or_head and @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
+            # We don't want the output to be really final until we're out of the lock
+            cgi.default_really_final = false
+
+            if ActionController::Base.allow_concurrency
+              _dispatch_unlocked(cgi, request, response)
+            else
+              @guard.synchronize { _dispatch_unlocked(cgi, request, response) }
+            end
+            # This finalizes the output using the proper HttpResponse way
+            cgi.out("text/html",true) {""}
+          rescue Errno::EPIPE
+            response.socket.close
+          rescue Object => rails_error
+            STDERR.puts "#{Time.now}: 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!
+        begin
+          @guard.synchronize {
+            $".replace $orig_dollar_quote
+            GC.start
+            Dispatcher.reset_application!
+            ActionController::Routing::Routes.reload
+          }
+        end
+      end
+
+      private
+
+      def _dispatch_unlocked(cgi, request, response)
+        @active_request_path = request.params[Mongrel::Const::PATH_INFO] 
+        Dispatcher.dispatch(cgi, ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, response.body)
+        @active_request_path = nil
+      end
+    end
+
+    # 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(s) you want,
+      # but it 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]
+        env_location = "#{ops[:cwd]}/config/environment"
+        require env_location
+        require 'dispatcher'
+        require 'mongrel/rails'
+
+        ActionController::AbstractRequest.relative_url_root = ops[:prefix] if ops[:prefix]
+
+        @rails_handler = RailsHandler.new(ops[:docroot], ops[:mime])
+      end
+
+      # Reloads Rails.  This isn't too reliable really, but it
+      # should work for most minimal reload purposes.  The only reliable
+      # way to reload properly is to stop and 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)
+        setup_signals(options)
+
+        if RUBY_PLATFORM !~ /mswin|mingw/
+          # rails reload
+          trap("HUP") { log "HUP signal received."; reload!          }
+
+          log "Rails signals registered.  HUP => reload (without restart).  It might not work well."
+        end
+      end
+    end
+  end
+end

data/lib/mongrel/stats.rb

@@ -0,0 +1,89 @@
+# 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.
+
+# A very simple little class for doing some basic fast statistics sampling.
+# You feed it either samples of numeric data you want measured or you call
+# Stats.tick to get it to add a time delta between the last time you called it.
+# When you're done either call sum, sumsq, n, min, max, mean or sd to get 
+# the information.  The other option is to just call dump and see everything.
+#
+# It does all of this very fast and doesn't take up any memory since the samples
+# are not stored but instead all the values are calculated on the fly.
+module Mongrel
+  class Stats
+    attr_reader :sum, :sumsq, :n, :min, :max
+
+    def initialize(name)
+      @name = name
+      reset
+    end
+
+    # Resets the internal counters so you can start sampling again.
+    def reset
+      @sum = 0.0
+      @sumsq = 0.0
+      @last_time = Time.new
+      @n = 0.0
+      @min = 0.0
+      @max = 0.0
+    end
+
+    # Adds a sampling to the calculations.
+    def sample(s)
+      @sum += s
+      @sumsq += s * s
+      if @n == 0
+        @min = @max = s
+      else
+        @min = s if @min > s
+        @max = s if @max < s
+      end
+      @n+=1
+    end
+
+    # Dump this Stats object with an optional additional message.
+    def dump(msg = "", out=STDERR)
+      out.puts "#{msg}: #{self.to_s}"
+    end
+
+    # Returns a common display (used by dump)
+    def to_s  
+    "[#{@name}]: SUM=%0.4f, SUMSQ=%0.4f, N=%0.4f, MEAN=%0.4f, SD=%0.4f, MIN=%0.4f, MAX=%0.4f" % [@sum, @sumsq, @n, mean, sd, @min, @max]
+    end
+
+
+    # Calculates and returns the mean for the data passed so far.
+    def mean
+      @sum / @n
+    end
+
+    # Calculates the standard deviation of the data so far.
+    def sd
+      # (sqrt( ((s).sumsq - ( (s).sum * (s).sum / (s).n)) / ((s).n-1) ))
+      begin
+        return Math.sqrt( (@sumsq - ( @sum * @sum / @n)) / (@n-1) )
+      rescue Errno::EDOM
+        return 0.0
+      end
+    end
+
+
+    # Adds a time delta between now and the last time you called this.  This
+    # will give you the average time between two activities.
+    # 
+    # An example is:
+    #
+    #  t = Stats.new("do_stuff")
+    #  10000.times { do_stuff(); t.tick }
+    #  t.dump("time")
+    #
+    def tick
+      now = Time.now
+      sample(now - @last_time)
+      @last_time = now
+    end
+  end
+end

data/lib/mongrel/tcphack.rb

@@ -0,0 +1,18 @@
+# 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.
+
+
+# A modification proposed by Sean Treadway that increases the default accept
+# queue of TCPServer to 1024 so that it handles more concurrent requests.
+class TCPServer
+   def initialize_with_backlog(*args)
+     initialize_without_backlog(*args)
+     listen(1024)
+   end
+
+   alias_method :initialize_without_backlog, :initialize
+   alias_method :initialize, :initialize_with_backlog
+end

data/lib/mongrel/uri_classifier.rb

@@ -0,0 +1,76 @@
+
+module Mongrel
+  class URIClassifier
+  
+    class RegistrationError < RuntimeError
+    end
+    class UsageError < RuntimeError
+    end
+
+    attr_reader :handler_map   
+ 
+    # Returns the URIs that have been registered with this classifier so far.
+    def uris
+      @handler_map.keys
+    end
+
+    def initialize
+      @handler_map = {}
+      @matcher = //
+      @root_handler = nil
+    end
+    
+    # Register a handler object at a particular URI. The handler can be whatever 
+    # you want, including an array. It's up to you what to do with it.
+    #
+    # Registering a handler is not necessarily threadsafe, so be careful if you go
+    # mucking around once the server is running.
+    def register(uri, handler)
+      raise RegistrationError, "#{uri.inspect} is already registered" if @handler_map[uri]
+      raise RegistrationError, "URI is empty" if !uri or uri.empty?
+      raise RegistrationError, "URI must begin with a \"#{Const::SLASH}\"" unless uri[0..0] == Const::SLASH
+      @handler_map[uri.dup] = handler
+      rebuild
+    end
+    
+    # Unregister a particular URI and its handler.
+    def unregister(uri)
+      handler = @handler_map.delete(uri)
+      raise RegistrationError, "#{uri.inspect} was not registered" unless handler
+      rebuild
+      handler
+    end
+    
+    # Resolve a request URI by finding the best partial match in the registered 
+    # handler URIs.
+    def resolve(request_uri)
+      if @root_handler
+        # Optimization for the pathological case of only one handler on "/"; e.g. Rails
+        [Const::SLASH, request_uri, @root_handler]
+      elsif match = @matcher.match(request_uri)
+        uri = match.to_s
+        # A root mounted ("/") handler must resolve such that path info matches the original URI.
+        [uri, (uri == Const::SLASH ? request_uri : match.post_match), @handler_map[uri]]
+      else
+        [nil, nil, nil]
+      end
+    end
+        
+    private
+    
+    def rebuild
+      if @handler_map.size == 1 and @handler_map[Const::SLASH]
+        @root_handler = @handler_map.values.first
+      else
+        @root_handler = nil
+        routes = @handler_map.keys.sort.sort_by do |uri|
+          -uri.length
+        end
+        @matcher = Regexp.new(routes.map do |uri|
+          Regexp.new('^' + Regexp.escape(uri))
+        end.join('|'))
+      end
+    end    
+    
+  end
+end

data/mongrel-public_cert.pem

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDUDCCAjigAwIBAgIBADANBgkqhkiG9w0BAQUFADBOMRwwGgYDVQQDDBNtb25n
+cmVsLWRldmVsb3BtZW50MRkwFwYKCZImiZPyLGQBGRYJcnVieWZvcmdlMRMwEQYK
+CZImiZPyLGQBGRYDb3JnMB4XDTA3MDkxNjEwMzI0OVoXDTA4MDkxNTEwMzI0OVow
+TjEcMBoGA1UEAwwTbW9uZ3JlbC1kZXZlbG9wbWVudDEZMBcGCgmSJomT8ixkARkW
+CXJ1Ynlmb3JnZTETMBEGCgmSJomT8ixkARkWA29yZzCCASIwDQYJKoZIhvcNAQEB
+BQADggEPADCCAQoCggEBAMb9v3B01eOHk3FyypbQgKXzJplUE5P6dXoG+xpPm0Lv
+P7BQmeMncOwqQ7zXpVQU+lTpXtQFTsOE3vL7KnhQFJKGvUAkbh24VFyopu1I0yqF
+mGu4nRqNXGXVj8TvLSj4S1WpSRLAa0acLPNyKhGmoV9+crqQypSjM6XKjBeppifo
+4eBmWGjiJEYMIJBvJZPJ4rAVDDA8C6CM1m3gMBGNh8ELDhU8HI9AP3dMIkTI2Wx9
+9xkJwHdroAaS0IFFtYChrwee4FbCF1FHDgoTosMwa47DrLHg4hZ6ojaKwK5QVWEV
+XGb6ju5UqpktnSWF2W+Lvl/K0tI42OH2CAhebT1gEVUCAwEAAaM5MDcwCQYDVR0T
+BAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFGHChyMSZ16u9WOzKhgJSQ9lqDc5
+MA0GCSqGSIb3DQEBBQUAA4IBAQA/lfeN2WdB1xN+82tT7vNS4HOjRQw6MUh5yktu
+GQjaGqm0UB+aX0Z9y0B0qpfv9rj7nmIvEGiwBmDepNWYCGuW15JyqpN7QVVnG2xS
+Mrame7VqgjM7A+VGDD5In5LtWbM/CHAATvvFlQ5Ph13YE1EdnVbZ65c+KQv+5sFY
+Q+zEop74d878uaC/SAHHXS46TiXneocaLSYw1CEZs/MAIy+9c4Q5ESbGpgnfg1Ad
+6lwl7k3hsNHO/+tZzx4HJtOXDI1yAl3+q6T9J0yI3z97EinwvAKhS1eyOI2Y5eeT
+tbQaNYkU127B3l/VNpd8fQm3Jkl/PqCCmDBQjUszFrJEODug
+-----END CERTIFICATE-----

data/mongrel.gemspec

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mongrel}
+  s.version = "1.1.6.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Zed A. Shaw"]
+  s.date = %q{2009-06-11}
+  s.default_executable = %q{mongrel_rails}
+  s.description = %q{A small fast HTTP library and server that runs Rails, Camping, Nitro and Iowa apps.}
+  s.email = %q{}
+  s.executables = ["mongrel_rails"]
+  s.extensions = ["ext/http11/extconf.rb"]
+  s.extra_rdoc_files = ["CHANGELOG", "COPYING", "lib/mongrel/camping.rb", "lib/mongrel/cgi.rb", "lib/mongrel/command.rb", "lib/mongrel/configurator.rb", "lib/mongrel/const.rb", "lib/mongrel/debug.rb", "lib/mongrel/gems.rb", "lib/mongrel/handlers.rb", "lib/mongrel/header_out.rb", "lib/mongrel/http_request.rb", "lib/mongrel/http_response.rb", "lib/mongrel/init.rb", "lib/mongrel/rails.rb", "lib/mongrel/stats.rb", "lib/mongrel/tcphack.rb", "lib/mongrel/uri_classifier.rb", "lib/mongrel.rb", "LICENSE", "README"]
+  s.files = ["bin/mongrel_rails", "CHANGELOG", "COPYING", "examples/builder.rb", "examples/camping/blog.rb", "examples/camping/README", "examples/camping/tepee.rb", "examples/httpd.conf", "examples/mime.yaml", "examples/mongrel.conf", "examples/mongrel_simple_ctrl.rb", "examples/mongrel_simple_service.rb", "examples/monitrc", "examples/random_thrash.rb", "examples/simpletest.rb", "examples/webrick_compare.rb", "ext/http11/ext_help.h", "ext/http11/extconf.rb", "ext/http11/http11.c", "ext/http11/http11_parser.c", "ext/http11/http11_parser.h", "ext/http11/http11_parser.java.rl", "ext/http11/http11_parser.rl", "ext/http11/http11_parser_common.rl", "ext/http11_java/Http11Service.java", "ext/http11_java/org/jruby/mongrel/Http11.java", "ext/http11_java/org/jruby/mongrel/Http11Parser.java", "lib/mongrel/camping.rb", "lib/mongrel/cgi.rb", "lib/mongrel/command.rb", "lib/mongrel/configurator.rb", "lib/mongrel/const.rb", "lib/mongrel/debug.rb", "lib/mongrel/gems.rb", "lib/mongrel/handlers.rb", "lib/mongrel/header_out.rb", "lib/mongrel/http_request.rb", "lib/mongrel/http_response.rb", "lib/mongrel/init.rb", "lib/mongrel/mime_types.yml", "lib/mongrel/rails.rb", "lib/mongrel/stats.rb", "lib/mongrel/tcphack.rb", "lib/mongrel/uri_classifier.rb", "lib/mongrel.rb", "LICENSE", "Manifest", "mongrel-public_cert.pem", "mongrel.gemspec", "README", "setup.rb", "test/mime.yaml", "test/mongrel.conf", "test/test_cgi_wrapper.rb", "test/test_command.rb", "test/test_conditional.rb", "test/test_configurator.rb", "test/test_debug.rb", "test/test_handlers.rb", "test/test_http11.rb", "test/test_redirect_handler.rb", "test/test_request_progress.rb", "test/test_response.rb", "test/test_stats.rb", "test/test_uriclassifier.rb", "test/test_ws.rb", "test/testhelp.rb", "TODO", "tools/trickletest.rb", "Rakefile"]
+  s.homepage = %q{http://mongrel.rubyforge.org}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Mongrel", "--main", "README"]
+  s.require_paths = ["lib", "ext"]
+  s.required_ruby_version = Gem::Requirement.new(">= 1.8.4")
+  s.rubyforge_project = %q{mongrel}
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{A small fast HTTP library and server that runs Rails, Camping, Nitro and Iowa apps.}
+  s.test_files = ["test/test_cgi_wrapper.rb", "test/test_command.rb", "test/test_conditional.rb", "test/test_configurator.rb", "test/test_debug.rb", "test/test_handlers.rb", "test/test_http11.rb", "test/test_redirect_handler.rb", "test/test_request_progress.rb", "test/test_response.rb", "test/test_stats.rb", "test/test_uriclassifier.rb", "test/test_ws.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<gem_plugin>, [">= 0.2.3"])
+      s.add_runtime_dependency(%q<daemons>, [">= 1.0.3"])
+      s.add_runtime_dependency(%q<fastthread>, [">= 1.0.1"])
+      s.add_runtime_dependency(%q<cgi_multipart_eof_fix>, [">= 2.4"])
+    else
+      s.add_dependency(%q<gem_plugin>, [">= 0.2.3"])
+      s.add_dependency(%q<daemons>, [">= 1.0.3"])
+      s.add_dependency(%q<fastthread>, [">= 1.0.1"])
+      s.add_dependency(%q<cgi_multipart_eof_fix>, [">= 2.4"])
+    end
+  else
+    s.add_dependency(%q<gem_plugin>, [">= 0.2.3"])
+    s.add_dependency(%q<daemons>, [">= 1.0.3"])
+    s.add_dependency(%q<fastthread>, [">= 1.0.1"])
+    s.add_dependency(%q<cgi_multipart_eof_fix>, [">= 2.4"])
+  end
+end