about summary refs log tree commit homepage
path: root/lib
diff options
context:
space:
mode:
authorEvan Weaver <eweaver@twitter.com>2009-01-31 13:56:50 -0800
committerEvan Weaver <eweaver@twitter.com>2009-01-31 13:56:50 -0800
commitb842c004dc0155cb9ea974367c92371fee8841d8 (patch)
treecc9b20d7d4730dee1f43e671d8e19f1a5ee67c78 /lib
parent9c76c4a37280610be74948176e78924479f7d94d (diff)
downloadunicorn-b842c004dc0155cb9ea974367c92371fee8841d8.tar.gz
Remove all non-abstract handlers in favor of Rack.

Conflicts:

	lib/mongrel/command.rb
	lib/mongrel/configurator.rb
	lib/mongrel/debug.rb
	lib/mongrel/handlers.rb
	lib/mongrel/rails.rb
	test/unit/test_configurator.rb
Diffstat (limited to 'lib')
-rw-r--r--lib/mongrel.rb36
-rw-r--r--lib/mongrel/cgi.rb5
-rw-r--r--lib/mongrel/handlers.rb199
-rw-r--r--lib/mongrel/http_request.rb4
-rw-r--r--lib/mongrel/stats.rb89
5 files changed, 29 insertions, 304 deletions
diff --git a/lib/mongrel.rb b/lib/mongrel.rb
index 990a8eb..a97972b 100644
--- a/lib/mongrel.rb
+++ b/lib/mongrel.rb
@@ -8,6 +8,7 @@ require 'etc'
 require 'uri'
 require 'stringio'
 require 'fcntl'
+require 'logger'
 
 # Compiled Mongrel extension
 require 'http11'
@@ -30,6 +31,15 @@ require 'mongrel/http_response'
 # 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 << self
+    # A logger instance that conforms to the API of stdlib's Logger.
+    attr_accessor :logger
+    
+    # By default, will return an instance of stdlib's Logger logging to STDERR
+    def logger
+      @logger ||= Logger.new STDERR
+    end
+  end
 
   # Used to stop the HttpServer via Thread.raise.
   class StopServer < Exception; end
@@ -162,21 +172,21 @@ module Mongrel
       rescue EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
         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"
+        Mongrel.logger.error "#{Time.now}: HTTP parse error, malformed request (#{params[Const::HTTP_X_FORWARDED_FOR] || client.peeraddr.last}): #{e.inspect}"
+        Mongrel.logger.error "#{Time.now}: REQUEST DATA: #{data.inspect}\n---\nPARAMS: #{params.inspect}\n---\n"
       rescue Errno::EMFILE
         reap_dead_workers('too many files')
       rescue Object => e
-        STDERR.puts "#{Time.now}: Read error: #{e.inspect}"
-        STDERR.puts e.backtrace.join("\n")
+        Mongrel.logger.error "#{Time.now}: Read error: #{e.inspect}"
+        Mongrel.logger.error e.backtrace.join("\n")
       ensure
         begin
           client.close
         rescue IOError
           # Already closed
         rescue Object => e
-          STDERR.puts "#{Time.now}: Client error: #{e.inspect}"
-          STDERR.puts e.backtrace.join("\n")
+          Mongrel.logger.error "#{Time.now}: Client error: #{e.inspect}"
+          Mongrel.logger.error e.backtrace.join("\n")
         end
         request.body.close! if request and request.body.class == Tempfile
       end
@@ -188,14 +198,14 @@ module Mongrel
     # after the reap is done.  It only runs if there are workers to reap.
     def reap_dead_workers(reason='unknown')
       if @workers.list.length > 0
-        STDERR.puts "#{Time.now}: Reaping #{@workers.list.length} threads for slow workers because of '#{reason}'"
+        Mongrel.logger.info "#{Time.now}: Reaping #{@workers.list.length} threads for slow workers because of '#{reason}'"
         error_msg = "Mongrel timed out this thread: #{reason}"
         mark = Time.now
         @workers.list.each do |worker|
           worker[:started_on] = Time.now if not worker[:started_on]
 
           if mark - worker[:started_on] > @timeout + @throttle
-            STDERR.puts "Thread #{worker.inspect} is too old, killing."
+            Mongrel.logger.info "Thread #{worker.inspect} is too old, killing."
             worker.raise(TimeoutError.new(error_msg))
           end
         end
@@ -210,7 +220,7 @@ module Mongrel
     # that much longer.
     def graceful_shutdown
       while reap_dead_workers("shutdown") > 0
-        STDERR.puts "Waiting for #{@workers.list.length} requests to finish, could take #{@timeout + @throttle} seconds."
+        Mongrel.logger.info "Waiting for #{@workers.list.length} requests to finish, could take #{@timeout + @throttle} seconds."
         sleep @timeout / 10
       end
     end
@@ -255,7 +265,7 @@ module Mongrel
   
               worker_list = @workers.list
               if worker_list.length >= @num_processors
-                STDERR.puts "Server overloaded with #{worker_list.length} processors (#@num_processors max). Dropping connection."
+                Mongrel.logger.error "Server overloaded with #{worker_list.length} processors (#@num_processors max). Dropping connection."
                 client.close rescue nil
                 reap_dead_workers("max processors")
               else
@@ -274,14 +284,14 @@ module Mongrel
               # client closed the socket even before accept
               client.close rescue nil
             rescue Object => e
-              STDERR.puts "#{Time.now}: Unhandled listen loop exception #{e.inspect}."
-              STDERR.puts e.backtrace.join("\n")
+              Mongrel.logger.error "#{Time.now}: Unhandled listen loop exception #{e.inspect}."
+              Mongrel.logger.error e.backtrace.join("\n")
             end
           end
           graceful_shutdown
         ensure
           @socket.close
-          # STDERR.puts "#{Time.now}: Closed socket."
+          # Mongrel.logger.info "#{Time.now}: Closed socket."
         end
       end
 
diff --git a/lib/mongrel/cgi.rb b/lib/mongrel/cgi.rb
index 3957611..ed6fcf0 100644
--- a/lib/mongrel/cgi.rb
+++ b/lib/mongrel/cgi.rb
@@ -173,9 +173,8 @@ module Mongrel
     
     # The stdoutput should be completely bypassed but we'll drop a warning just in case
     def stdoutput
-      STDERR.puts "WARNING: Your program is doing something not expected.  Please tell Zed that stdoutput was used and what software you are running.  Thanks."
+      Mongrel.logger.warn "WARNING: Your program is doing something not expected.  Please tell Zed that stdoutput was used and what software you are running.  Thanks."
       @response.body
-    end    
-
+    end
   end
 end
diff --git a/lib/mongrel/handlers.rb b/lib/mongrel/handlers.rb
index ce24628..0ae3af6 100644
--- a/lib/mongrel/handlers.rb
+++ b/lib/mongrel/handlers.rb
@@ -4,21 +4,16 @@
 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html
 # for more information.
 
-require 'mongrel/stats'
 require 'zlib'
 require 'yaml'
 
 module Mongrel
-
+  #
   # You implement your application handler with this.  It's very light giving
   # 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
     attr_reader :request_notify
     attr_accessor :listener
@@ -38,195 +33,5 @@ module Mongrel
 
     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
-    attr_reader :request_notify
-    attr_accessor :listener
-
-    def request_begins(params)
-    end
-
-    def request_progress(params, clen, total)
-    end
-
-    def initialize(options={})
-      @options = options
-      @header_only = false
-    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.
-  #
-  class Error404Handler < HttpHandler
-
-    # Sets the message to return.  This is constructed once for the handler
-    # so it's pretty efficient.
-    def initialize(msg)
-      @response = Const::ERROR_404_RESPONSE + msg
-    end
-
-    # Just kicks back the standard 404 response with your special message.
-    def process(request, response)
-      response.socket.write(@response)
-    end
-
-  end
-
-  # When added to a config script (-S in mongrel_rails) it will
-  # look at the client's allowed response types and then gzip
-  # compress anything that is going out.
-  #
-  # Valid option is :always_deflate => false which tells the handler to
-  # deflate everything even if the client can't handle it.
-  class DeflateFilter < HttpHandler
-    include Zlib
-    HTTP_ACCEPT_ENCODING = "HTTP_ACCEPT_ENCODING"
-
-    def initialize(ops={})
-      @options = ops
-      @always_deflate = ops[:always_deflate] || false
-    end
-
-    def process(request, response)
-      accepts = request.params[HTTP_ACCEPT_ENCODING]
-      # only process if they support compression
-      if @always_deflate or (accepts and (accepts.include? "deflate" and not response.body_sent))
-        response.header["Content-Encoding"] = "deflate"
-        response.body = deflate(response.body)
-      end
-    end
-
-    private
-      def deflate(stream)
-        deflater = Deflate.new(
-          DEFAULT_COMPRESSION,
-          # drop the zlib header which causes both Safari and IE to choke
-          -MAX_WBITS,
-          DEF_MEM_LEVEL,
-          DEFAULT_STRATEGY)
-
-        stream.rewind
-        gzout = StringIO.new(deflater.deflate(stream.read, FINISH))
-        stream.close
-        gzout.rewind
-        gzout
-      end
-  end
-
-
-  # Implements a few basic statistics for a particular URI.  Register it anywhere
-  # you want in the request chain and it'll quickly gather some numbers for you
-  # to analyze.  It is pretty fast, but don't put it out in production.
-  #
-  # You should pass the filter to StatusHandler as StatusHandler.new(:stats_filter => stats).
-  # This lets you then hit the status URI you want and get these stats from a browser.
-  #
-  # StatisticsFilter takes an option of :sample_rate.  This is a number that's passed to
-  # rand and if that number gets hit then a sample is taken.  This helps reduce the load
-  # and keeps the statistics valid (since sampling is a part of how they work).
-  #
-  # The exception to :sample_rate is that inter-request time is sampled on every request.
-  # If this wasn't done then it wouldn't be accurate as a measure of time between requests.
-  class StatisticsFilter < HttpHandler
-    attr_reader :stats
-
-    def initialize(ops={})
-      @sample_rate = ops[:sample_rate] || 300
-
-      @processors = Mongrel::Stats.new("processors")
-      @reqsize = Mongrel::Stats.new("request Kb")
-      @headcount = Mongrel::Stats.new("req param count")
-      @respsize = Mongrel::Stats.new("response Kb")
-      @interreq = Mongrel::Stats.new("inter-request time")
-    end
-
-
-    def process(request, response)
-      if rand(@sample_rate)+1 == @sample_rate
-        @processors.sample(listener.workers.list.length)
-        @headcount.sample(request.params.length)
-        @reqsize.sample(request.body.length / 1024.0)
-        @respsize.sample((response.body.length + response.header.out.length) / 1024.0)
-      end
-      @interreq.tick
-    end
-
-    def dump
-      "#{@processors.to_s}\n#{@reqsize.to_s}\n#{@headcount.to_s}\n#{@respsize.to_s}\n#{@interreq.to_s}"
-    end
-  end
-
-
-  # The :stats_filter is basically any configured stats filter that you've added to this same
-  # URI.  This lets the status handler print out statistics on how Mongrel is doing.
-  class StatusHandler < HttpHandler
-    def initialize(ops={})
-      @stats = ops[:stats_filter]
-    end
-
-    def table(title, rows)
-      results = "<table border=\"1\"><tr><th colspan=\"#{rows[0].length}\">#{title}</th></tr>"
-      rows.each do |cols|
-        results << "<tr>"
-        cols.each {|col| results << "<td>#{col}</td>" }
-        results << "</tr>"
-      end
-      results + "</table>"
-    end
-
-    def describe_listener
-      results = ""
-      results << "<h1>Listener #{listener.host}:#{listener.port}</h1>"
-      results << table("settings", [
-                       ["host",listener.host],
-                       ["port",listener.port],
-                       ["throttle",listener.throttle],
-                       ["timeout",listener.timeout],
-                       ["workers max",listener.num_processors],
-      ])
-
-      if @stats
-        results << "<h2>Statistics</h2><p>N means the number of samples, pay attention to MEAN, SD, MIN and MAX."
-        results << "<pre>#{@stats.dump}</pre>"
-      end
-
-      results << "<h2>Registered Handlers</h2>"
-      handler_map = listener.classifier.handler_map
-      results << table("handlers", handler_map.map {|uri,handlers|
-        [uri,
-            "<pre>" +
-            handlers.map {|h| h.class.to_s }.join("\n") +
-            "</pre>"
-        ]
-      })
-
-      results
-    end
-
-    def process(request, response)
-      response.start do |head,out|
-        out.write <<-END
-        <html><body><title>Mongrel Server Status</title>
-        #{describe_listener}
-        </body></html>
-        END
-      end
-    end
-  end
+  end  
 end
diff --git a/lib/mongrel/http_request.rb b/lib/mongrel/http_request.rb
index 2416b04..70f236f 100644
--- a/lib/mongrel/http_request.rb
+++ b/lib/mongrel/http_request.rb
@@ -78,8 +78,8 @@ module Mongrel
           remain -= @body.write(@params.http_body)
         end
       rescue Object => e
-        STDERR.puts "#{Time.now}: Error reading HTTP body: #{e.inspect}"
-        STDERR.puts e.backtrace.join("\n")
+        Mongrel.logger.error "#{Time.now}: Error reading HTTP body: #{e.inspect}"
+        Mongrel.logger.error e.backtrace.join("\n")
         # any errors means we should delete the file, including if the file is dumped
         @socket.close rescue nil
         @body.close! if @body.class == Tempfile
diff --git a/lib/mongrel/stats.rb b/lib/mongrel/stats.rb
deleted file mode 100644
index f6cf5ab..0000000
--- a/lib/mongrel/stats.rb
+++ /dev/null
@@ -1,89 +0,0 @@
-# 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