mongrel 1.0.1 → 1.0.2

data/lib/mongrel.rb

@@ -4,12 +4,10 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
 # for more information.
 
-$mongrel_debug_client = false
-
-require 'rubygems'
 require 'socket'
 require 'http11'
 require 'tempfile'
+
 begin
   require 'fastthread'
 rescue RuntimeError => e
@@ -18,6 +16,9 @@ rescue LoadError
 ensure
   require 'thread'
 end
+
+require 'cgi_multipart_eof_fix'
+
 require 'stringio'
 require 'mongrel/cgi'
 require 'mongrel/handlers'
@@ -36,30 +37,27 @@ require 'uri'
 module Mongrel
 
   class URIClassifier
-    attr_reader :handler_map
-
+    attr_reader :handler_map   
+ 
     # 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
 
+  end
 
   # Used to stop the HttpServer via Thread.raise.
   class StopServer < Exception; end
 
-
   # Thrown at a thread when it is timed out.
   class TimeoutError < 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.
@@ -125,7 +123,7 @@ module Mongrel
     REQUEST_URI='REQUEST_URI'.freeze
     REQUEST_PATH='REQUEST_PATH'.freeze
 
-    MONGREL_VERSION="1.0.1".freeze
+    MONGREL_VERSION="1.0.2".freeze
 
     MONGREL_TMP_BASE="mongrel".freeze
 
@@ -261,11 +259,11 @@ module Mongrel
 
           update_request_progress(remain, total)
         end
-      rescue Object
-        STDERR.puts "ERROR reading http body: #$!"
-        $!.backtrace.join("\n")
+      rescue Object => e
+        STDERR.puts "#{Time.now}: Error reading HTTP body: #{e.inspect}"
+        STDERR.puts e.backtrace.join("\n")
         # any errors means we should delete the file, including if the file is dumped
-        @socket.close rescue Object
+        @socket.close rescue nil
         @body.delete if @body.class == Tempfile
         @body = nil # signals that there was a problem
       end
@@ -399,6 +397,7 @@ module Mongrel
       @socket = socket
       @body = StringIO.new
       @status = 404
+      @reason = HTTP_STATUS_CODES[@status]
       @header = HeaderOut.new(StringIO.new)
       @header[Const::DATE] = Time.now.httpdate
       @body_sent = false
@@ -414,8 +413,9 @@ module Mongrel
     # by simple passing "finalize=true" to the start method.  By default
     # all handlers run and then mongrel finalizes the request when they're
     # all done.
-    def start(status=200, finalize=false)
+    def start(status=200, finalize=false, reason=HTTP_STATUS_CODES[status])
       @status = status.to_i
+      @reason = reason
       yield @header, @body
       finished if finalize
     end
@@ -437,8 +437,8 @@ module Mongrel
 
     def send_status(content_length=@body.length)
       if not @status_sent
-        @header['Content-Length'] = content_length unless @status == 304
-        write(Const::STATUS_FORMAT % [@status, HTTP_STATUS_CODES[@status]])
+        @header['Content-Length'] = content_length if content_length and @status != 304
+        write(Const::STATUS_FORMAT % [@status, @reason])
         @status_sent = true
       end
     end
@@ -482,7 +482,7 @@ module Mongrel
 
     def socket_error(details)
       # ignore these since it means the client closed off early
-      @socket.close rescue Object
+      @socket.close rescue nil
       done = true
       raise details
     end
@@ -540,6 +540,7 @@ module Mongrel
     attr_reader :classifier
     attr_reader :host
     attr_reader :port
+    attr_reader :throttle
     attr_reader :timeout
     attr_reader :num_processors
 
@@ -553,18 +554,18 @@ module Mongrel
     # way to deal with overload.  Other schemes involve still parsing the client's request
     # which defeats the point of an overload handling system.
     # 
-    # The timeout parameter is a sleep timeout (in hundredths of a second) that is placed between 
+    # The throttle parameter is a sleep timeout (in hundredths of a second) that is placed between 
     # socket.accept calls in order to give the server a cheap throttle time.  It defaults to 0 and
     # actually if it is 0 then the sleep is not done at all.
-    def initialize(host, port, num_processors=(2**30-1), timeout=0)
+    def initialize(host, port, num_processors=950, throttle=0, timeout=60)
       @socket = TCPServer.new(host, port) 
       @classifier = URIClassifier.new
       @host = host
       @port = port
       @workers = ThreadGroup.new
-      @timeout = timeout
+      @throttle = throttle
       @num_processors = num_processors
-      @death_time = 60
+      @timeout = timeout
     end
 
     # Does the majority of the IO processing.  It has been written in Ruby using
@@ -591,7 +592,7 @@ module Mongrel
             if not params[Const::REQUEST_PATH]
               # it might be a dumbass full host request header
               uri = URI.parse(params[Const::REQUEST_URI])
-              params[Const::REQUEST_PATH] = uri.request_uri
+              params[Const::REQUEST_PATH] = uri.path
             end
 
             raise "No REQUEST PATH" if not params[Const::REQUEST_PATH]
@@ -601,7 +602,14 @@ module Mongrel
             if handlers
               params[Const::PATH_INFO] = path_info
               params[Const::SCRIPT_NAME] = script_name
-              params[Const::REMOTE_ADDR] = params[Const::HTTP_X_FORWARDED_FOR] || client.peeraddr.last
+
+              # From http://www.ietf.org/rfc/rfc3875 :
+              # "Script authors should be aware that the REMOTE_ADDR and REMOTE_HOST
+              #  meta-variables (see sections 4.1.8 and 4.1.9) may not identify the
+              #  ultimate source of the request.  They identify the client for the
+              #  immediate request to the server; that client may be a proxy, gateway,
+              #  or other intermediary acting on behalf of the actual source client."
+              params[Const::REMOTE_ADDR] = client.peeraddr.last
 
               # select handlers that want more detailed request notification
               notifiers = handlers.select { |h| h.request_notify }
@@ -641,19 +649,24 @@ module Mongrel
           end
         end
       rescue EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
-        client.close rescue Object
-      rescue HttpParserError
-        if $mongrel_debug_client
-          STDERR.puts "#{Time.now}: BAD CLIENT (#{params[Const::HTTP_X_FORWARDED_FOR] || client.peeraddr.last}): #$!"
-          STDERR.puts "#{Time.now}: REQUEST DATA: #{data.inspect}\n---\nPARAMS: #{params.inspect}\n---\n"
-        end
+        client.close rescue nil
+      rescue HttpParserError => e
+        STDERR.puts "#{Time.now}: HTTP parse error, malformed request (#{params[Const::HTTP_X_FORWARDED_FOR] || client.peeraddr.last}): #{e.inspect}"
+        STDERR.puts "#{Time.now}: REQUEST DATA: #{data.inspect}\n---\nPARAMS: #{params.inspect}\n---\n"
       rescue Errno::EMFILE
         reap_dead_workers('too many files')
-      rescue Object
-        STDERR.puts "#{Time.now}: ERROR: #$!"
-        STDERR.puts $!.backtrace.join("\n") if $mongrel_debug_client
+      rescue Object => e
+        STDERR.puts "#{Time.now}: Read error: #{e.inspect}"
+        STDERR.puts e.backtrace.join("\n")
       ensure
-        client.close rescue Object
+        begin
+          client.close
+        rescue IOError
+          # Already closed
+        rescue Object => e
+          STDERR.puts "#{Time.now}: Client error: #{e.inspect}"
+          STDERR.puts e.backtrace.join("\n")
+        end
         request.body.delete if request and request.body.class == Tempfile
       end
     end
@@ -670,7 +683,7 @@ module Mongrel
         @workers.list.each do |w|
           w[:started_on] = Time.now if not w[:started_on]
 
-          if mark - w[:started_on] > @death_time + @timeout
+          if mark - w[:started_on] > @timeout + @throttle
             STDERR.puts "Thread #{w.inspect} is too old, killing."
             w.raise(TimeoutError.new(error_msg))
           end
@@ -681,13 +694,13 @@ module Mongrel
     end
 
     # Performs a wait on all the currently running threads and kills any that take
-    # too long.  Right now it just waits 60 seconds, but will expand this to
-    # allow setting.  The @timeout setting does extend this waiting period by
+    # too long.  It waits by @timeout seconds, which can be set in .initialize or
+    # via mongrel_rails. The @throttle setting does extend this waiting period by
     # that much longer.
     def graceful_shutdown
       while reap_dead_workers("shutdown") > 0
-        STDERR.print "Waiting for #{@workers.list.length} requests to finish, could take #{@death_time + @timeout} seconds."
-        sleep @death_time / 10
+        STDERR.print "Waiting for #{@workers.list.length} requests to finish, could take #{@timeout + @throttle} seconds."
+        sleep @timeout / 10
       end
     end
 
@@ -697,6 +710,8 @@ module Mongrel
         # 9 is currently TCP_DEFER_ACCEPT
         $tcp_defer_accept_opts = [Socket::SOL_TCP, 9, 1]
         $tcp_cork_opts = [Socket::SOL_TCP, 3, 1]
+      when /freebsd(([1-4]\..{1,2})|5\.[0-4])/
+        # Do nothing, just closing a bug when freebsd <= 5.4
       when /freebsd/
         # Use the HTTP accept filter if available.
         # The struct made by pack() is defined in /usr/include/sys/socket.h as accept_filter_arg
@@ -713,7 +728,7 @@ module Mongrel
 
       configure_socket_options
 
-      if $tcp_defer_accept_opts
+      if defined?($tcp_defer_accept_opts) and $tcp_defer_accept_opts
         @socket.setsockopt(*$tcp_defer_accept_opts) rescue nil
       end
 
@@ -722,7 +737,7 @@ module Mongrel
           begin
             client = @socket.accept
 
-            if $tcp_cork_opts
+            if defined?($tcp_cork_opts) and $tcp_cork_opts
               client.setsockopt(*$tcp_cork_opts) rescue nil
             end
 
@@ -730,27 +745,27 @@ module Mongrel
 
             if worker_list.length >= @num_processors
               STDERR.puts "Server overloaded with #{worker_list.length} processors (#@num_processors max). Dropping connection."
-              client.close rescue Object
+              client.close rescue nil
               reap_dead_workers("max processors")
             else
               thread = Thread.new(client) {|c| process_client(c) }
               thread[:started_on] = Time.now
               @workers.add(thread)
 
-              sleep @timeout/100 if @timeout > 0
+              sleep @throttle/100.0 if @throttle > 0
             end
           rescue StopServer
-            @socket.close rescue Object
+            @socket.close
             break
           rescue Errno::EMFILE
             reap_dead_workers("too many open files")
             sleep 0.5
           rescue Errno::ECONNABORTED
             # client closed the socket even before accept
-            client.close rescue Object
-          rescue Object => exc
-            STDERR.puts "!!!!!! UNHANDLED EXCEPTION! #{exc}.  TELL ZED HE'S A MORON."
-            STDERR.puts $!.backtrace.join("\n") if $mongrel_debug_client
+            client.close rescue nil
+          rescue Object => e
+            STDERR.puts "#{Time.now}: Unhandled listen loop exception #{e.inspect}."
+            STDERR.puts e.backtrace.join("\n")
           end
         end
         graceful_shutdown
@@ -794,12 +809,12 @@ module Mongrel
 
     # Stops the acceptor thread and then causes the worker threads to finish
     # off the request queue before finally exiting.
-    def stop
-      stopper = Thread.new do 
-        exc = StopServer.new
-        @acceptor.raise(exc)
+    def stop(synchronous=false)
+      @acceptor.raise(StopServer.new)
+
+      if synchronous        
+        sleep(0.5) while @acceptor.alive?
       end
-      stopper.priority = 10
     end
 
   end

data/lib/mongrel/cgi.rb

@@ -109,10 +109,10 @@ module Mongrel
         end
         
         @head.delete('cookie')
-
-        # @output_cookies seems to never be used, but we'll process it just in case
-        @output_cookies.each {|c| to['Set-Cookie'] = c.to_s } if @output_cookies
       end
+      
+      # @output_cookies seems to never be used, but we'll process it just in case
+      @output_cookies.each {|c| to['Set-Cookie'] = c.to_s } if @output_cookies
     end
     
     # The dumb thing is people can call header or this or both and in any order.

data/lib/mongrel/command.rb

@@ -179,7 +179,7 @@ module Mongrel
           print_command_list
           return true
         elsif cmd_name == "--version"
-          STDERR.puts "Mongrel Web Server #{Mongrel::Const::MONGREL_VERSION}"
+          puts "Mongrel Web Server #{Mongrel::Const::MONGREL_VERSION}"
           return true
         end
 

data/lib/mongrel/configurator.rb

@@ -1,7 +1,6 @@
 require 'yaml'
 require 'etc'
 
-
 module Mongrel
   # Implements a simple DSL for configuring a Mongrel server for your 
   # purposes.  More used by framework implementers to setup Mongrel
@@ -39,7 +38,7 @@ module Mongrel
     attr_reader :needs_restart
 
     # You pass in initial defaults and then a block to continue configuring.
-    def initialize(defaults={}, &blk)
+    def initialize(defaults={}, &block)
       @listener = nil
       @listener_name = nil
       @listeners = {}
@@ -47,25 +46,31 @@ module Mongrel
       @needs_restart = false
       @pid_file = defaults[:pid_file]
 
-      if blk
-        cloaker(&blk).bind(self).call
+      if block
+        cloaker(&block).bind(self).call
       end
     end
 
-    # Change privilege of the process to specified user and group.
+    # Change privileges of the process to specified user and group.
     def change_privilege(user, group)
       begin
-        if group
-          log "Changing group to #{group}."
-          Process::GID.change_privilege(Etc.getgrnam(group).gid)
-        end
-
-        if user
-          log "Changing user to #{user}." 
-          Process::UID.change_privilege(Etc.getpwnam(user).uid)
+        uid, gid = Process.euid, Process.egid
+        target_uid = Etc.getpwnam(user).uid if user
+        target_gid = Etc.getgrnam(group).gid if group
+
+        if uid != target_uid or gid != target_gid
+          log "Initiating groups for #{user.inspect}:#{group.inspect}."
+          Process.initgroups(user, target_id)
+        
+          log "Changing group to #{group.inspect}."
+          Process::GID.change_privilege(target_gid)
+
+          log "Changing user to #{user.inspect}." 
+          Process::UID.change_privilege(target_uid)
         end
-      rescue Errno::EPERM
-        log "FAILED to change user:group #{user}:#{group}: #$!"
+      rescue Errno::EPERM => e
+        log "Couldn't change user and group to #{user.inspect}:#{group.inspect}: #{e.to_s}."
+        log "Mongrel failed to start."
         exit 1
       end
     end
@@ -74,15 +79,19 @@ module Mongrel
       File.unlink(@pid_file) if @pid_file and File.exists?(@pid_file)
     end
 
-    # Writes the PID file but only if we're on windows.
+    # Writes the PID file if we're not on Windows.
     def write_pid_file
       if RUBY_PLATFORM !~ /mswin/
         log "Writing PID file to #{@pid_file}"
         open(@pid_file,"w") {|f| f.write(Process.pid) }
+        open(@pid_file,"w") do |f|
+          f.write(Process.pid)
+          File.chmod(0644, @pid_file)
+        end      
       end
     end
 
-    # generates a class for cloaking the current self and making the DSL nicer
+    # Generates a class for cloaking the current self and making the DSL nicer.
     def cloaking_class
       class << self
         self
@@ -90,9 +99,9 @@ module Mongrel
     end
 
     # Do not call this.  You were warned.
-    def cloaker(&blk)
+    def cloaker(&block)
       cloaking_class.class_eval do
-        define_method :cloaker_, &blk
+        define_method :cloaker_, &block
         meth = instance_method( :cloaker_ )
         remove_method :cloaker_
         meth
@@ -114,18 +123,20 @@ module Mongrel
     # 
     # * :host => Host name to bind.
     # * :port => Port to bind.
-    # * :num_processors => The maximum number of concurrent threads allowed.  (950 default)
-    # * :timeout => 1/100th of a second timeout between requests. (10 is 1/10th, 0 is timeout)
+    # * :num_processors => The maximum number of concurrent threads allowed.
+    # * :throttle => Time to pause (in hundredths of a second) between accepting clients. 
+    # * :timeout => Time to wait (in seconds) before killing a stalled thread.
     # * :user => User to change to, must have :group as well.
     # * :group => Group to change to, must have :user as well.
     #
-    def listener(options={},&blk)
+    def listener(options={},&block)
       raise "Cannot call listener inside another listener block." if (@listener or @listener_name)
       ops = resolve_defaults(options)
       ops[:num_processors] ||= 950
-      ops[:timeout] ||= 0
+      ops[:throttle] ||= 0
+      ops[:timeout] ||= 60
 
-      @listener = Mongrel::HttpServer.new(ops[:host], ops[:port].to_i, ops[:num_processors].to_i, ops[:timeout].to_i)
+      @listener = Mongrel::HttpServer.new(ops[:host], ops[:port].to_i, ops[:num_processors].to_i, ops[:throttle].to_i, ops[:timeout].to_i)
       @listener_name = "#{ops[:host]}:#{ops[:port]}"
       @listeners[@listener_name] = @listener
 
@@ -134,8 +145,8 @@ module Mongrel
       end
 
       # Does the actual cloaking operation to give the new implicit self.
-      if blk
-        cloaker(&blk).bind(self).call
+      if block
+        cloaker(&block).bind(self).call
       end
 
       # all done processing this listener setup, reset implicit variables
@@ -277,11 +288,10 @@ module Mongrel
     # Calls .stop on all the configured listeners so they
     # stop processing requests (gracefully).  By default it
     # assumes that you don't want to restart.
-    def stop(needs_restart=false)
-      @listeners.each {|name,s| 
-        s.stop 
-      }
-
+    def stop(needs_restart=false, synchronous=false)   
+      @listeners.each do |name,s| 
+        s.stop(synchronous)      
+      end      
       @needs_restart = needs_restart
     end