ruby-style 1.0.2 → 1.1.0

data/README

@@ -28,7 +28,8 @@ Subversion access is available at svn://code.jeremyevans.net/ruby-style/.
   the fly
 * Supports both command line and yaml config file configuration
 * Is easily extensible to support running other frameworks and protocols other
-  than the included ones (RailsMongrel and RailsSCGI)
+  than the included ones (Rails and Ramaze; SCGI, Mongrel, and Evented
+  Mongrel)
 
 == Running and configuration
 
@@ -37,16 +38,18 @@ just run the program without any arguments:
 
 style [option value, ...] (decrement|halt|increment|restart|start|stop)
  Options:
+  -a, --adapter       Adapter/Framework to use [rails]
   -b, --bind          IP address to bind to [127.0.0.1]
   -c, --config        Location of config file [config/style.yaml]
   -d, --directory     Working directory [.]
+  -D, --debug         Run the program in the foreground without forking [No]
   -f, --fork          Number of listners on each port [1]
+  -h, --handler       Handler/Server to use [mongrel]
   -k, --killtime      Number of seconds to wait when killing each child [2]
   -l, --logfile       Where to redirect STDOUT and STDERR [log/style.log]
   -n, --number        Number of ports to which to bind [1]
   -p, --port          Starting port to which to bind [9999]
   -P, --pidfile       Location of pid file [log/style.pid]
-  -s, --style         Type of style to use [RailsMongrel]
   -u, --unsupervised  Whether to run unsupervised [No]
 
 Here's what the various commands do:
@@ -66,9 +69,15 @@ process, so the -c, -l, and -P options are relative to that.
 
 Here's a longer explanation of the options:
 
+  -a, --adapter       Adapter/Framework to use [rails]
+
+  This is the adapter/framework to use.  Support for Rails and Ramaze is
+  included in the distribution, support for other frameworks should be fairly
+  easy to add.
+
   -b, --bind          IP address to bind to [127.0.0.1]
 
-  This is the TCP/IP networking sockets to bind to.  It defaults to the
+  This is the TCP/IP networking socket to bind to.  It defaults to the
   loopback address because generally the web application runs on the same
   physical server as the web server.  If this is not the case, change it to an
   externally available IP, and make sure to lock down access to the port via a
@@ -89,6 +98,11 @@ Here's a longer explanation of the options:
   root of the application before hand and then not use this option. This option
   is not configurable from the configuration file.
 
+  -D, --debug         Run the program in the foreground without forking [No]
+
+  This runs the program in the program without forking, aiding in debugging a
+  problematic configuration.
+
   -f, --fork          Number of listners on each port [1]
 
   This enables multiple child processes listening on each port.  It is
@@ -100,6 +114,13 @@ Here's a longer explanation of the options:
   are killed, so it is possibly to have multiple processes listening on a port
   even if this is left at one.
 
+  -h, --handler       Handler/Server to use [mongrel]
+
+  This is the handler/server to use.  Support for Mongrel, Evented Mongrel,
+  and SCGI is included in the distribution.  Support for other servers is
+  easy to add as long as the servers can be modified to use the socket
+  created by style ($STYLE_SOCKET).
+
   -k, --killtime      Number of seconds to wait when killing each child [2]
 
   This sets the time that style between sending shutdown signals to child
@@ -134,15 +155,6 @@ Here's a longer explanation of the options:
   they should be, and you will probably won't be able to start new processes
   (because the ports will still be in use).
 
-  -s, --style         Type of style to use [RailsMongrel]
-
-  This is the type of style to use.  It defaults to RailsMongrel, as that is
-  most common configuration these days.  The other style included with style is
-  RailsSCGI.  Adding other styles is fairly easy, just make the style is in a
-  file named XXXXXStyle.rb (where XXXXX is in the name of the style), and that
-  file is located in ruby's library path ($:, e.g. via the RUBYLIB environment
-  variable).  See the included styles for an example.
-
   -u, --unsupervised  Whether to run unsupervised [No]
   
   This starts child processes without using a supervisor process.  It is not
@@ -152,24 +164,15 @@ Here's a longer explanation of the options:
   restarted when they die, and you may lose connections during restarts.
 
 Every one of the long options can also be specified in the config file.  Also,
-the  config file if you want to specify any settings specific to the style
-being used (such as modifying the Rails environment setting).  
-
-== Included styles and config files
-
-style current comes with support for the following styles: RailsMongrelStyle
-(the default, which requires rails and mongrel), and RailsSCGIStyle (which
-requires rails and ruby-scgi).
+the config file must be used if you want to specify any settings specific to
+adapter being used (such as modifying the Rails environment setting).  See
+below for information on the adapter_config config file variable.
 
-The RailsMongrel style supports running Rails on Mongrel, which would usually
-be deployed behind a front end webserver, such as Apache, Lighttpd, or Nginx.
-The RailsSCGI style supports running Rails over SCGI, which is supported by
-both Apache and Lighttpd.  Both default to running Rails in production mode,
-as style is designed as a production tool.
+== The config file
 
-Example RailsMongrel style.yaml that listens on ports 8912 and 8192 on any
-interface, with three listeners per port.  Note how the :style_config entry is
-used to set up settings specific to the RailsMongrel style, such as placing
+Example Rails+Mongrel style.yaml that listens on ports 8912 and 8193 on any
+interface, with three listeners per port.  Note how the :adapter_config entry 
+is used to set up settings specific to the Rails adapter, such as placing
 Rails in development mode.
 
 ---
@@ -178,32 +181,36 @@ Rails in development mode.
 :fork: 3
 :number: 2
 :killtime: 1
-:style: RailsMongrel
-:style_config:
+:adapter: rails
+:handler: mongrel
+:adapter_config:
   :environment: development
   :log_file: log/rails-mongrel.log
   :docroot: public
   :num_processors: 99
   :timeout: 100
 
-Example RailsSCGI style.yaml that has four listeners on port 8912:
+Example Rails+SCGI style.yaml that has four listeners on port 8912:
 
 ---
 :port: 8912
 :fork: 4
 :number: 1 
-:style: RailsSCGI
-:style_config:
+:adapter: rails
+:handler: scgi
+:adapter_config:
   :logfile: log/railsscgi.log
   :maxconns: 10
   :environment: production
 
-Very simple configuration that runs RailsMongrel style in unsupervised mode on
-port 3000.
+Very simple configuration that runs Ramaze+Evented Mongrel in unsupervised
+mode on port 3000.
 
 ---
 :port: 3000
 :unsupervised: 1
+:adapter: ramaze
+:handler: evented_mongrel
 
 == How restarting works
 
@@ -261,25 +268,20 @@ Thu Sep  6 12:01:59 PDT 2007
 Result, three brand new listening processes, total time to restart is about 12
 seconds (2 * (2 killtime * 1 number * 3 fork)).
 
-== Other frameworks and protocols
+== Other handlers and adapter
 
-style can support any ruby server program that supports the following
-interface (which is called a style):
+To add support for another handler, make sure the instead of creating a socket,
+it uses the socket provided by style, available in the global variable
+$STYLE_SOCKET.  See existing handler code to see how Mongrel, SCGI, and Event
+Machine were modified to support this.
 
-# in file XXXXXStyle.rb, which must be in ruby's path ($:)
-# XXXXX is the name of the style (e.g. RubySCGI)
-  class XXXXXStyle
-    def initialize(options)
-      #options is a Hash
-    end
-    
-    def listen(socket)
-      # socket is a TCPServer
-    end
-  end
+Support for other adapters is easily added by adding the run method to the
+Style class.  This can be easy (as it is with Ramaze), or more difficult (as it
+is with Rails).  If the adapter uses Rack, it should be fairly simple.
 
-Just specify the style with -s or --style on the command line, or :style in the
-config file.
+Style loads adapters and handlers from style/{adapter,handler} relative to the
+load path, so you can add your own adapters and handlers without modifying the
+program, as long as you place the files somewhere in the load path.
 
 == FAQ
 
@@ -289,4 +291,4 @@ A: No.  Among other things, style uses fork, which is not available on Windows.
 
 Q: Does it work with Capistrano yet?
 
-A: I haven't tried.  If you have luck, let me know.
+A: I haven't tried.  It probably can, but it will take a little custom work.

data/lib/style/adapter/rails.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+
+# This hooks the HTTP request into Ruby on Rails and Mongrel.
+class Style
+  # Initialzes Rails and Mongrel with the appropriate environment and settings.
+  def run
+    config[:handler] == 'scgi' ? run_rails_scgi : run_rails_mongrel
+  end
+  
+  def run_rails_scgi
+    RailsSCGIProcessor.new(config[:adapter_config]).listen
+  end
+  
+  def run_rails_mongrel
+    require 'mongrel/rails'
+    settings = {:cwd => Dir.pwd, :log_file => 'log/rails-mongrel.log', 
+                :environment => 'production', :docroot => 'public',
+                :mime_map => nil, :debug => false, :includes => ["mongrel"],
+                :config_script => nil, :num_processors => 1024, :timeout => 0,
+                :user => nil, :group => nil, :prefix => nil}.merge(config[:adapter_config])
+    ENV['RAILS_ENV'] = settings[:environment]
+    $0 += " environment:#{ENV['RAILS_ENV']}"
+    mongrel = Mongrel::Rails::RailsConfigurator.new(settings) do
+      listener do
+        mime = defaults[:mime_map] ? load_mime_map(defaults[:mime_map], mime) : {}
+        debug "/" if defaults[:debug]
+        uri defaults[:prefix] || "/", :handler => rails(:mime => mime, :prefix => defaults[:prefix])
+        load_plugins
+        run_config(defaults[:config_script]) if defaults[:config_script]
+        trap("INT") { @log.info("SIGTERM, forced shutdown."); shutdown(force=true) }
+        setup_rails_signals
+      end
+    end
+    mongrel.run
+    mongrel.join
+  end
+end

data/lib/style/adapter/ramaze.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'ramaze'
+
+class Style
+  # Run Ramaze with the mongrel adapter and start.rb runner
+  def run
+    settings = {:adapter=>config[:handler].to_sym, :test_connections=>false, 
+                :force=>true, :runner =>'start.rb', :host=>config[:bind],
+                :port=>config[:sockets][$STYLE_SOCKET]}.merge(config[:adapter_config])
+    require settings[:runner].to_s
+    Ramaze.start(settings)
+  end
+end
+

data/lib/style/handler/evented_mongrel.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'style/handler/eventmachine'
+require 'swiftcore/evented_mongrel'

data/lib/style/handler/eventmachine.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+$eventmachine_library = :pure_ruby
+require 'eventmachine'
+
+module EventMachine
+  class StreamObject < Selectable
+    # Delete this when EventMachine fixes typo bug (Rubyforge bug #17461), see
+    # https://rubyforge.org/tracker/index.php?func=detail&aid=17461&group_id=1555&atid=6060
+    def eventable_write
+      # coalesce the outbound array here, perhaps
+      @last_activity = Reactor.instance.current_loop_time
+      while data = @outbound_q.shift do
+        begin
+          data = data.to_s
+          w = if io.respond_to?(:write_nonblock)
+            io.write_nonblock data
+          else
+            io.syswrite data
+          end
+
+          if w < data.length
+            @outbound_q.unshift data[w..-1]
+            break
+          end
+        rescue Errno::EAGAIN
+          @outbound_q.unshift data
+        rescue EOFError, Errno::ECONNRESET, Errno::ECONNREFUSED
+          @close_scheduled = true
+          @outbound_q.clear
+        end
+      end
+    end
+  end
+  
+  class EvmaTCPServer < Selectable
+    class << self
+      # Use $STYLE_SOCKET instead of creating a socket with the host and port
+      def start_server(host, port)
+        EvmaTCPServer.new $STYLE_SOCKET
+      end
+    end
+  end
+end

data/lib/style/handler/mongrel.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'mongrel'
+
+module Mongrel
+  class HttpServer
+    # Keep the interface the same, but ignore the host and port and use the
+    # socket provided by style
+    def initialize(host, port, num_processors=950, throttle=0, timeout=60)
+      tries = 0
+      @socket = $STYLE_SOCKET
+      @classifier = URIClassifier.new
+      @host = host
+      @port = port
+      @workers = ThreadGroup.new
+      @throttle = throttle
+      @num_processors = num_processors
+      @timeout = timeout
+    end
+  end
+end

data/lib/{RailsSCGIStyle.rb → style/handler/scgi.rb}

@@ -1,13 +1,34 @@
-#!/usr/bin/env ruby
+require 'rubygems'
 require 'scgi'
 
+class SCGI::Processor
+  # Use the standard error as the output logger, and use $STYLE_SOCKET as the
+  # socket on which to listen
+  def initialize(settings = {})
+    @socket ||= $STYLE_SOCKET
+    @total_conns ||= 0
+    @shutdown ||= false
+    @dead ||= false
+    @threads ||= Queue.new
+    @log = Object.new
+    def @log.info(msg)
+      STDERR.puts("[INF][#{@pid ||= Process.pid}] #{msg}")
+    end
+    def @log.error(msg, exc=nil)
+      STDERR.puts("[ERR][#{@pid ||= Process.pid}] #{msg}#{": #{exc}\n#{exc.backtrace.join("\n")}" if exc}")
+    end
+    @maxconns ||= settings[:maxconns] || 2**30-1
+    super()
+    setup_signals
+  end
+end
+
 # This SCGI::Processor subclass hooks the SCGI request into Ruby on Rails.
-class RailsSCGIStyle < SCGI::Processor
+class RailsSCGIProcessor < SCGI::Processor
   # Initialzes Rails with the appropriate environment and settings
   def initialize(settings)
-    ENV['RAILS_ENV'] = settings[:environment] || 'production'
-    $0 += " environment:#{ENV['RAILS_ENV']}"
-    require "config/environment"
+    $0 += " environment:#{ENV['RAILS_ENV'] = settings[:environment] || 'production'}"
+    require 'config/environment'
     ActiveRecord::Base.allow_concurrency = false
     require 'dispatcher'
     super(settings)

data/lib/style.rb

@@ -16,16 +16,15 @@ require 'yaml'
 # trees.
 class Style
   attr_reader :config, :mutex
-  VALID_STYLE_RE = /\A[A-Z][A-ZA-z0-9]*\z/
   
   # Configure style
   def initialize
-    super
     @config = {:pidfile=>'log/style.pid', :number=>1, :port=>9999,
                :style=>'RailsMongrel', :fork=>1, :bind=>'127.0.0.1',
                :cliconfig=>{}, :killtime=>2, :config=>'config/style.yaml',
                :logfile=>'log/style.log', :children=>{},:sockets=>{},
-               :style_config=>{}, :directory=>'.'}
+               :adapter_config=>{}, :directory=>'.', :debug=>false, 
+               :unsupervised=> false, :adapter=>'rails', :handler=>'mongrel'}
     @mutex = Mutex.new
     begin
       parse_options
@@ -58,6 +57,12 @@ class Style
     conf
   end
   
+  def create_socket(bind, port)
+    socket = TCPServer.new(bind, port)
+    socket.listen(50)
+    socket
+  end
+  
   # Detach the process from the controlling terminal, exit otherwise
   def detach
     unless Process.setsid
@@ -66,13 +71,12 @@ class Style
     end
     trap(:HUP, 'IGNORE')
   end
-
-  # Load the revelent style
-  def get_style(string)
-    raise NameError, "#{string} is not a valid style!" unless VALID_STYLE_RE.match(string)
-    style= "#{string}Style"
-    require style
-    eval(style)
+  
+  # Print the error message and the usage, then exit
+  def exit_with_error(error_message)
+    puts error_message
+    puts usage
+    exit(1)
   end
   
   # Kill each of the given pids in order
@@ -92,6 +96,16 @@ class Style
       return nil
     end
   end
+  
+  # Load the revelent style adapter/framework
+  def load_adapter
+    require "style/adapter/#{config[:adapter]}"
+  end
+  
+  # Load the revelent style handler/server
+  def load_handler
+    require "style/handler/#{config[:handler]}"
+  end
 
   # Parse the command line options, and merge them with the default options and
   # the config file options.  Config file options take precendence over the
@@ -99,27 +113,35 @@ class Style
   def parse_options
     cliconfig = config[:cliconfig]
     GetoptLong.new(
+      [ '--adapter', '-a', GetoptLong::REQUIRED_ARGUMENT ],
       [ '--bind', '-b', GetoptLong::REQUIRED_ARGUMENT ],
       [ '--config', '-c', GetoptLong::REQUIRED_ARGUMENT ],
       [ '--directory', '-d', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--debug', '-D', GetoptLong::NO_ARGUMENT],
       [ '--fork', '-f', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--handler', '-h', GetoptLong::REQUIRED_ARGUMENT ],
       [ '--killtime', '-k', GetoptLong::REQUIRED_ARGUMENT ],
       [ '--logfile', '-l', GetoptLong::REQUIRED_ARGUMENT ],
       [ '--number', '-n', GetoptLong::REQUIRED_ARGUMENT ],
       [ '--port', '-p', GetoptLong::REQUIRED_ARGUMENT ],
       [ '--pidfile', '-P', GetoptLong::REQUIRED_ARGUMENT ],
-      [ '--style', '-s', GetoptLong::REQUIRED_ARGUMENT ],
       [ '--unsupervised', '-u', GetoptLong::NO_ARGUMENT]
     ).each do |opt, arg|
       case opt
+        when '--adapter'
+          cliconfig[:adapter] = arg
         when '--bind'
           cliconfig[:bind] = arg
         when '--config'
           config[:config] = cliconfig[:config] = arg
         when '--directory'
           config[:directory] = arg
+        when '--debug'
+          cliconfig[:debug] = true
         when '--fork'
           cliconfig[:fork] = arg.to_i
+        when '--handler'
+          cliconfig[:handler] = arg
         when '--killtime'
           cliconfig[:killtime] = arg.to_i
         when '--logfile'
@@ -130,8 +152,6 @@ class Style
           cliconfig[:port] = arg.to_i
         when '--pidfile'
           cliconfig[:pidfile] = arg
-        when '--style'
-          cliconfig[:style] = arg
         when '--unsupervised'
           cliconfig[:unsupervised] = true
       end
@@ -144,24 +164,24 @@ class Style
     config[:config] = File.expand_path(config[:config])
     reload_config
     
-    [:logfile, :pidfile].each do |opt|
-      cliconfig[opt] = File.expand_path(cliconfig[opt]) if cliconfig[opt]
-      config[opt] = File.expand_path(config[opt])
-      config[opt] = check_dir(config[opt])
+    unless config[:debug]
+      [:logfile, :pidfile].each do |opt|
+        cliconfig[opt] = File.expand_path(cliconfig[opt]) if cliconfig[opt]
+        config[opt] = File.expand_path(config[opt])
+        config[opt] = check_dir(config[opt])
+      end
     end
-    exit_with_error("#{config[:style]} is not a valid style!") unless VALID_STYLE_RE.match(config[:style])
-  end
-  
-  # Print the error message and the usage, then exit
-  def exit_with_error(error_message)
-    puts error_message
-    puts usage
-    exit(1)
   end
 
   # Process the command given 
   def process(command)
-    config[:unsupervised] ? process_unsupervised_command(command) : process_supervised_command(command) 
+    if config[:debug]
+      run_in_foreground
+    elsif config[:unsupervised]
+      process_unsupervised_command(command)
+    else
+      process_supervised_command(command)
+    end
   end
 
   # Process the command given in supervised mode.  All commands except start just send
@@ -220,7 +240,8 @@ class Style
   end
 
   # Reload the configuration, used when restarting.  Only the following options
-  # take effect when reloading: config, killtime, pidfile, style, and style_config.  
+  # take effect when reloading: config, killtime, pidfile, adapter, handler,
+  # and adapter_config.  
   def reload_config
     config.merge!(config_file_options(config[:config]))
     config.merge!(config[:cliconfig])
@@ -241,6 +262,21 @@ class Style
     end rescue nil
   end
   
+  # Load the relevant handler and adapter and run the server
+  def run_child
+    load_handler
+    load_adapter
+    run
+  end
+  
+  # Run the program in the foreground instead of daemonizing.  Only runs on one
+  # port, and obviously doesn't fork.
+  def run_in_foreground
+    $STYLE_SOCKET = create_socket(config[:bind], config[:port])
+    config[:sockets][$STYLE_SOCKET] = config[:port]
+    run_child
+  end
+  
   # Setup the necessary signals used in supervisory mode:
   #
   #  * CLD - Restart any dead children
@@ -318,10 +354,11 @@ class Style
   def start_child(socket)
     return if config[:shutdown]
     pid = fork do
+      $STYLE_SOCKET = socket
       [:HUP, :INT, :TERM, :USR1, :USR2].each{|signal| trap(signal, 'DEFAULT')}
       config[:sockets].keys.each{|sock| sock.close unless sock == socket}
-      $0 = "#{config[:style]}Style dir:#{Dir.pwd} port:#{config[:sockets][socket]}"
-      get_style(config[:style]).new(config[:style_config]).listen(socket)
+      $0 = "#{process_name} port:#{config[:sockets][socket]}"
+      run_child
     end
     #puts "started pid #{pid}"
     config[:children][pid] = socket
@@ -334,7 +371,7 @@ class Style
       redirect_io
       config[:number].times do |i|
         port = config[:port]+i
-        socket = TCPServer.new(config[:bind], port)
+        socket = create_socket(config[:bind], port)
         config[:sockets][socket] = port
         config[:fork].times{start_child(socket)}
       end
@@ -354,11 +391,17 @@ class Style
     end
   end
   
+  # Name of the Style
+  def process_name
+    "style-#{config[:adapter]}-#{config[:handler]} #{Dir.pwd}"
+  end
+  
+  
   # Start all necessary children of the supervisor process (number * fork)
   def supervisor_children_start
     config[:number].times do |i|
       port = config[:port]+i
-      socket = TCPServer.new(config[:bind], port)
+      socket = create_socket(config[:bind], port)
       config[:sockets][socket] = port
       config[:fork].times{start_child(socket)}
     end
@@ -372,7 +415,7 @@ class Style
 
   # Do the final setup of the supervisor process, and then loop indefinitely
   def supervisor_loop
-    $0 = "#{config[:style]}Style dir:#{Dir.pwd} supervisor"
+    $0 = "#{process_name} supervisor"
     redirect_io
     supervisor_children_start
     setup_supervisor_signals
@@ -407,16 +450,18 @@ class Style
     <<-END
   style [option value, ...] (decrement|halt|increment|restart|start|stop)
    Options:
+    -a, --adapter       Adapter/Framework to use [rails]
     -b, --bind          IP address to bind to [127.0.0.1]
     -c, --config        Location of config file [config/style.yaml]
     -d, --directory     Working directory [.]
+    -D, --debug         Run the program in the foreground without forking [No]
     -f, --fork          Number of listners on each port [1]
+    -h, --handler       Handler/Server to use [mongrel]
     -k, --killtime      Number of seconds to wait when killing each child [2]
     -l, --logfile       Where to redirect STDOUT and STDERR [log/style.log]
     -n, --number        Number of ports to which to bind [1]
     -p, --port          Starting port to which to bind [9999]
     -P, --pidfile       Location of pid file [log/style.pid]
-    -s, --style         Type of style to use [RailsMongrel]
     -u, --unsupervised  Whether to run unsupervised [No]
     END
   end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: ruby-style
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
-date: 2008-01-06 00:00:00 -08:00
+  version: 1.1.0
+date: 2008-01-27 00:00:00 -08:00
 summary: Supervised TCPServer, Yielding Listeners Easily
 require_paths: 
 - lib
@@ -32,8 +32,12 @@ files:
 - LICENSE
 - README
 - lib/style.rb
-- lib/RailsSCGIStyle.rb
-- lib/RailsMongrelStyle.rb
+- lib/style/handler/mongrel.rb
+- lib/style/handler/scgi.rb
+- lib/style/handler/eventmachine.rb
+- lib/style/handler/evented_mongrel.rb
+- lib/style/adapter/ramaze.rb
+- lib/style/adapter/rails.rb
 test_files: []
 
 rdoc_options: 

data/lib/RailsMongrelStyle.rb

@@ -1,61 +0,0 @@
-require 'rubygems'
-require 'yaml'
-require 'mongrel'
-require 'mongrel/rails'
-require 'etc'
-require 'cgi_multipart_eof_fix' rescue nil
-
-module Mongrel
-  # Patch the Mongrel HttpServer to add a socket= method
-  class HttpServer
-    attr_writer :socket
-    
-    # Keep the interface the same, but ignore the host and port and don't
-    # create a socket (one will be provided later)
-    def initialize(host, port, num_processors=950, throttle=0, timeout=60)
-      tries = 0
-      @classifier = URIClassifier.new
-      @host = host
-      @port = port
-      @workers = ThreadGroup.new
-      @throttle = throttle
-      @num_processors = num_processors
-      @timeout = timeout
-    end
-  end
-end
-
-# This hooks the HTTP request into Ruby on Rails and Mongrel.
-class RailsMongrelStyle
-  attr_reader :mongrel
-  
-  # Initialzes Rails and Mongrel with the appropriate environment and settings.
-  def initialize(settings)
-    settings = {:cwd => Dir.pwd, :log_file => 'log/rails-mongrel.log', 
-                :environment => 'production', :docroot => 'public',
-                :mime_map => nil, :debug => false, :includes => ["mongrel"],
-                :config_script => nil, :num_processors => 1024, :timeout => 0,
-                :user => nil, :group => nil, :prefix => nil}.merge(settings)
-    ENV['RAILS_ENV'] = settings[:environment]
-    $0 += " environment:#{ENV['RAILS_ENV']}"
-    @mongrel = Mongrel::Rails::RailsConfigurator.new(settings) do
-      listener do
-        mime = defaults[:mime_map] ? load_mime_map(defaults[:mime_map], mime) : {}
-        debug "/" if defaults[:debug]
-        uri defaults[:prefix] || "/", :handler => rails(:mime => mime, :prefix => defaults[:prefix])
-        load_plugins
-        run_config(defaults[:config_script]) if defaults[:config_script]
-        setup_rails_signals
-      end
-    end
-  end
-  
-  # Set the HttpServer to the correct socket and start running the mongrel event loop.
-  def listen(socket)
-    mongrel.instance_variable_get('@rails_handler').instance_variable_get('@listener').socket = socket
-    mongrel.run
-    mongrel.join
-  end
-end
-
-GemPlugin::Manager.instance.load "mongrel" => GemPlugin::INCLUDE, "rails" => GemPlugin::EXCLUDE