mongrel 1.1.2-java

data/lib/mongrel/rails.rb

@@ -0,0 +1,185 @@
+# 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
+
+            @guard.synchronize {
+              @active_request_path = request.params[Mongrel::Const::PATH_INFO] 
+              Dispatcher.dispatch(cgi, ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, response.body)
+              @active_request_path = nil
+            }
+
+            # 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
+    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/
+          # 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,263 @@
+
+# Gem::Specification for Mongrel-1.1.2
+# Originally generated by Echoe
+
+Gem::Specification.new do |s|
+  s.name = %q{mongrel}
+  s.version = "1.1.2"
+  s.platform = %q{java}
+
+  s.specification_version = 2 if s.respond_to? :specification_version=
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Zed A. Shaw"]
+  s.date = %q{2007-12-22}
+  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.has_rdoc = true
+  s.homepage = %q{}
+  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.0.1}
+  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"]
+
+  s.add_dependency(%q<gem_plugin>, [">= 0.2.3"])
+end
+
+
+# # Original Rakefile source (requires the Echoe gem):
+# 
+# 
+# require 'rubygems'
+# gem 'echoe', '>=2.7.5'
+# require 'echoe'
+# 
+# e = Echoe.new("mongrel") do |p|
+#   p.summary = "A small fast HTTP library and server that runs Rails, Camping, Nitro and Iowa apps."
+#   p.author ="Zed A. Shaw"
+#   p.clean_pattern = ['ext/http11/*.{bundle,so,o,obj,pdb,lib,def,exp}', 'lib/*.{bundle,so,o,obj,pdb,lib,def,exp}', 'ext/http11/Makefile', 'pkg', 'lib/*.bundle', '*.gem', 'site/output', '.config', 'lib/http11.jar', 'ext/http11_java/classes', 'coverage']
+#   p.rdoc_pattern = ['README', 'LICENSE', 'CHANGELOG', 'COPYING', 'lib/**/*.rb', 'doc/**/*.rdoc']
+#   p.ignore_pattern = /^(pkg|site|projects|doc|log)|CVS|\.log/
+#   p.ruby_version = '>= 1.8.4'
+#   p.dependencies = ['gem_plugin >=0.2.3']  
+#   p.extension_pattern = nil
+#   
+#   p.need_tar_gz = false
+#   p.need_tgz = true
+# 
+#   case RUBY_PLATFORM
+#     when /mswin/
+#     when /java/
+#     else
+#       p.extension_pattern = ["ext/**/extconf.rb"]
+#   end
+# 
+#   p.eval = proc do
+#     case RUBY_PLATFORM
+#     when /mswin/
+#       self.files += ['lib/http11.so']
+#       self.platform = Gem::Platform::WIN32
+#       add_dependency('cgi_multipart_eof_fix', '>= 2.4')
+#     when /java/
+#       self.files += ['lib/http11.jar']
+#       self.platform = 'jruby'
+#     else
+#       add_dependency('daemons', '>= 1.0.3')
+#       add_dependency('fastthread', '>= 1.0.1')
+#       add_dependency('cgi_multipart_eof_fix', '>= 2.4')
+#     end
+#   end
+# 
+# end
+# 
+# #### Ragel builder
+# 
+# desc "Rebuild the Ragel sources"
+# task :ragel do
+#   Dir.chdir "ext/http11" do
+#     target = "http11_parser.c"
+#     File.unlink target if File.exist? target
+#     sh "ragel http11_parser.rl | rlgen-cd -G2 -o #{target}"
+#     raise "Failed to build C source" unless File.exist? target
+#   end
+#   Dir.chdir "ext/http11" do
+#     target = "../../ext/http11_java/org/jruby/mongrel/Http11Parser.java"
+#     File.unlink target if File.exist? target
+#     sh "ragel -J http11_parser.java.rl | rlgen-java -o #{target}"
+#     raise "Failed to build Java source" unless File.exist? target
+#   end
+# end
+# 
+# #### Pre-compiled extensions for alternative platforms
+# 
+# def move_extensions
+#   Dir["ext/**/*.#{Config::CONFIG['DLEXT']}"].each { |file| mv file, "lib/" }
+# end
+# 
+# def java_classpath_arg
+#   # A myriad of ways to discover the JRuby classpath
+#   classpath = begin
+#     require 'java'
+#     # Already running in a JRuby JVM
+#     Java::java.lang.System.getProperty('java.class.path')
+#   rescue LoadError
+#     ENV['JRUBY_PARENT_CLASSPATH'] || ENV['JRUBY_HOME'] && FileList["#{ENV['JRUBY_HOME']}/lib/*.jar"].join(File::PATH_SEPARATOR)
+#   end
+#   classpath ? "-cp #{classpath}" : ""
+# end
+# 
+# case RUBY_PLATFORM
+# when /mswin/
+#   filename = "lib/http11.so"
+#   file filename do
+#     Dir.chdir("ext/http11") do
+#       ruby "extconf.rb"
+#       system(PLATFORM =~ /mswin/ ? 'nmake' : 'make')
+#     end
+#     move_extensions
+#   end
+#   task :compile => [filename]
+# 
+# when /java/
+# 
+#   # Avoid JRuby in-process launching problem
+#   begin
+#     require 'jruby'
+#     JRuby.runtime.instance_config.run_ruby_in_process = false 
+#   rescue LoadError
+#   end
+# 
+#   filename = "lib/http11.jar"
+#   file filename do
+#     build_dir = "ext/http11_java/classes"
+#     mkdir_p build_dir
+#     sources = FileList['ext/http11_java/**/*.java'].join(' ')
+#     sh "javac -target 1.4 -source 1.4 -d #{build_dir} #{java_classpath_arg} #{sources}"
+#     sh "jar cf lib/http11.jar -C #{build_dir} ."
+#     move_extensions
+#   end
+#   task :compile => [filename]
+# 
+# end
+# 
+# #### Project-wide install and uninstall tasks
+# 
+# def sub_project(project, *targets)
+#   targets.each do |target|
+#     Dir.chdir "projects/#{project}" do
+#       unless RUBY_PLATFORM =~ /mswin/
+#         sh("rake #{target.to_s}") # --trace 
+#       end
+#     end
+#   end
+# end
+# 
+# desc "Package Mongrel and all subprojects"
+# task :package_all => [:package] do
+#   sub_project("gem_plugin", :package)
+#   sub_project("cgi_multipart_eof_fix", :package)
+#   sub_project("fastthread", :package)
+#   sub_project("mongrel_status", :package)
+#   sub_project("mongrel_upload_progress", :package)
+#   sub_project("mongrel_console", :package)
+#   sub_project("mongrel_cluster", :package)
+#   sub_project("mongrel_experimental", :package)
+# 
+#   sh("rake java package") unless RUBY_PLATFORM =~ /java/
+#   
+#   # XXX Broken by RubyGems 0.9.5
+#   # sub_project("mongrel_service", :package) if RUBY_PLATFORM =~ /mswin/
+#   # sh("rake mswin package") unless RUBY_PLATFORM =~ /mswin/
+# end
+# 
+# task :install_requirements do
+#   # These run before Mongrel is installed
+#   sub_project("gem_plugin", :install)
+#   sub_project("cgi_multipart_eof_fix", :install)
+#   sub_project("fastthread", :install)
+# end
+# 
+# desc "for Mongrel and all subprojects"
+# task :install => [:install_requirements] do
+#   # These run after Mongrel is installed
+#   sub_project("mongrel_status", :install)
+#   sub_project("mongrel_upload_progress", :install)
+#   sub_project("mongrel_console", :install)
+#   sub_project("mongrel_cluster", :install)
+#   # sub_project("mongrel_experimental", :install)
+#   sub_project("mongrel_service", :install) if RUBY_PLATFORM =~ /mswin/
+# end
+# 
+# desc "for Mongrel and all its subprojects"
+# task :uninstall => [:clean] do
+#   sub_project("mongrel_status", :uninstall)
+#   sub_project("cgi_multipart_eof_fix", :uninstall)
+#   sub_project("mongrel_upload_progress", :uninstall)
+#   sub_project("mongrel_console", :uninstall)
+#   sub_project("gem_plugin", :uninstall)
+#   sub_project("fastthread", :uninstall)
+#   # sub_project("mongrel_experimental", :uninstall)
+#   sub_project("mongrel_service", :uninstall) if RUBY_PLATFORM =~ /mswin/
+# end
+# 
+# desc "for Mongrel and all its subprojects"
+# task :clean do
+#   sub_project("gem_plugin", :clean)
+#   sub_project("cgi_multipart_eof_fix", :clean)
+#   sub_project("fastthread", :clean)
+#   sub_project("mongrel_status", :clean)
+#   sub_project("mongrel_upload_progress", :clean)
+#   sub_project("mongrel_console", :clean)
+#   sub_project("mongrel_cluster", :clean)
+#   sub_project("mongrel_experimental", :clean)
+#   sub_project("mongrel_service", :clean) if RUBY_PLATFORM =~ /mswin/
+# end
+# 
+# #### Site upload tasks
+# 
+# namespace :site do
+# 
+#   desc "Package and upload .gem files and .tgz files for Mongrel and all subprojects to http://mongrel.rubyforge.org/releases/"
+#   task :source => [:package_all] do
+#     rm_rf "pkg/gems"
+#     rm_rf "pkg/tars"
+#     mkdir_p "pkg/gems"
+#     mkdir_p "pkg/tars"
+# 
+#     FileList["**/*.gem"].each { |gem| mv gem, "pkg/gems" }
+#     FileList["**/*.tgz"].each {|tgz| mv tgz, "pkg/tars" }
+# 
+#     sh "rm -rf pkg/mongrel*"
+#     sh "gem generate_index -d pkg"
+#     sh "scp -r CHANGELOG pkg/* rubyforge.org:/var/www/gforge-projects/mongrel/releases/"
+#     sh "svn log -v > SVN_LOG"
+#     sh "scp -r SVN_LOG pkg/* rubyforge.org:/var/www/gforge-projects/mongrel/releases/"
+#     rm "SVN_LOG"
+#   end
+# 
+#   desc "Upload the website"
+#   task :web do
+#     # Requires the 'webgem' gem
+#     sh "cd site; webgen; webgen; curl 'http://feed43.com/mongrel.xml' > output/rss.xml; rsync -azv --no-perms --no-times output/* rubyforge.org:/var/www/gforge-projects/mongrel/"
+#     puts "\nMake sure to re-run the site update 6 hours later if you updated the news. This delay is required for Feed43 to pick up the site changes."
+#   end
+# 
+#   desc "Upload the rdocs"
+#   task :rdoc => [:doc] do
+#     sh "rsync -azv --no-perms --no-times doc/* rubyforge.org:/var/www/gforge-projects/mongrel/rdoc/"
+#     sh "cd projects/gem_plugin; rake site:rdoc"
+#   end
+# 
+#   desc "Upload the coverage report"
+#   task :coverage => [:rcov] do
+#     sh "rsync -azv --no-perms --no-times test/coverage/* rubyforge.org:/var/www/gforge-projects/mongrel/coverage/" rescue nil
+#   end
+# 
+#   desc "Upload the website, the rdocs, and the coverage report"
+#   task :all => [:clean, :web, :rdoc, :coverage]
+# 
+# end