rails 1.0.0 → 2.0.0

data/lib/commands/process/inspector.rb

@@ -0,0 +1,68 @@
+require 'optparse'
+
+if RUBY_PLATFORM =~ /(:?mswin|mingw)/ then abort("Inspector is only for Unix") end
+
+OPTIONS = {
+  :pid_path => File.expand_path(RAILS_ROOT + '/tmp/pids'),
+  :pattern  => "dispatch.*.pid",
+  :ps       => "ps -o pid,state,user,start,time,pcpu,vsz,majflt,command -p %s"
+}
+
+class Inspector
+  def self.inspect(pid_path, pattern)
+    new(pid_path, pattern).inspect
+  end
+
+  def initialize(pid_path, pattern)
+    @pid_path, @pattern = pid_path, pattern
+  end
+
+  def inspect
+    header = `#{OPTIONS[:ps] % 1}`.split("\n")[0] + "\n"
+    lines  = pids.collect { |pid| `#{OPTIONS[:ps] % pid}`.split("\n")[1] }
+    
+    puts(header + lines.join("\n"))
+  end
+
+  private
+    def pids
+      pid_files.collect do |pid_file|
+        File.read(pid_file).to_i
+      end
+    end
+
+    def pid_files
+      Dir.glob(@pid_path + "/" + @pattern)
+    end
+end
+
+
+ARGV.options do |opts|
+  opts.banner = "Usage: inspector [options]"
+
+  opts.separator ""
+
+  opts.on <<-EOF
+  Description:
+    Displays system information about Rails dispatchers (or other processes that use pid files) through
+    the ps command.
+
+  Examples:
+    inspector                                             # default ps on all tmp/pids/dispatch.*.pid files
+    inspector -s 'ps -o user,start,majflt,pcpu,vsz -p %s' # custom ps, %s is where the pid is interleaved
+  EOF
+
+  opts.on("  Options:")
+
+  opts.on("-s", "--ps=command", "default: #{OPTIONS[:ps]}", String)           { |v| OPTIONS[:ps] = v }
+  opts.on("-p", "--pidpath=path", "default: #{OPTIONS[:pid_path]}", String)   { |v| OPTIONS[:pid_path] = v }
+  opts.on("-r", "--pattern=pattern", "default: #{OPTIONS[:pattern]}", String) { |v| OPTIONS[:pattern] = v }
+
+  opts.separator ""
+
+  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+Inspector.inspect(OPTIONS[:pid_path], OPTIONS[:pattern])

data/lib/commands/process/reaper.rb

@@ -2,91 +2,104 @@ require 'optparse'
 require 'net/http'
 require 'uri'
 
-if RUBY_PLATFORM =~ /mswin32/ then abort("Reaper is only for Unix") end
+if RUBY_PLATFORM =~ /(:?mswin|mingw)/ then abort("Reaper is only for Unix") end
 
-# Instances of this class represent a single running process. Processes may
-# be queried by "keyword" to find those that meet a specific set of criteria.
-class ProgramProcess
+class Killer
   class << self
-    
     # Searches for all processes matching the given keywords, and then invokes
     # a specific action on each of them. This is useful for (e.g.) reloading a
     # set of processes:
     #
-    #   ProgramProcess.process_keywords(:reload, "basecamp")
-    def process_keywords(action, *keywords)
-      processes = keywords.collect { |keyword| find_by_keyword(keyword) }.flatten
-
-      if processes.empty?
-        puts "Couldn't find any process matching: #{keywords.join(" or ")}"
-      else
-        processes.each do |process|
-          puts "#{action.capitalize}ing #{process}"
-          process.send(action)
-        end
-      end      
+    #   Killer.process(:reload, "/tmp/pids", "dispatcher.*.pid")
+    def process(action, pid_path, pattern, keyword)
+      new(pid_path, pattern, keyword).process(action)
     end
 
-    # Searches for all processes matching the given keyword:
-    #
-    #   ProgramProcess.find_by_keyword("basecamp")
-    def find_by_keyword(keyword)
-      process_lines_with_keyword(keyword).split("\n").collect { |line|
-        next if line =~ /inq|ps axww|grep|spawn-fcgi|spawner|reaper/
-        pid, *command = line.split
-        new(pid, command.join(" "))
-      }.compact
+    # Forces the (rails) application to reload by sending a +HUP+ signal to the
+    # process.
+    def reload(pid)
+      `kill -s HUP #{pid}`
     end
 
-    private
-      def process_lines_with_keyword(keyword)
-        `ps axww -o 'pid command' | grep #{keyword}`
-      end
-  end
+    # Force the (rails) application to restart by sending a +USR2+ signal to the
+    # process.
+    def restart(pid)
+      `kill -s USR2 #{pid}`
+    end
 
-  # Create a new ProgramProcess instance that represents the process with the
-  # given pid, running the given command.
-  def initialize(pid, command)
-    @pid, @command = pid, command
-  end
+    # Forces the (rails) application to gracefully terminate by sending a
+    # +TERM+ signal to the process.
+    def graceful(pid)
+      `kill -s TERM #{pid}`
+    end
 
-  # Forces the (rails) application to reload by sending a +HUP+ signal to the
-  # process.
-  def reload
-    `kill -s HUP #{@pid}`
-  end
+    # Forces the (rails) application to terminate immediately by sending a -9
+    # signal to the process.
+    def kill(pid)
+      `kill -9 #{pid}`
+    end
 
-  # Forces the (rails) application to gracefully terminate by sending a
-  # +TERM+ signal to the process.
-  def graceful
-    `kill -s TERM #{@pid}`
+    # Send a +USR1+ signal to the process.
+    def usr1(pid)
+      `kill -s USR1 #{pid}`
+    end
   end
 
-  # Forces the (rails) application to terminate immediately by sending a -9
-  # signal to the process.
-  def kill
-    `kill -9 #{@pid}`
+  def initialize(pid_path, pattern, keyword=nil)
+    @pid_path, @pattern, @keyword = pid_path, pattern, keyword
   end
 
-  # Send a +USR1+ signal to the process.
-  def usr1
-    `kill -s USR1 #{@pid}`
-  end
+  def process(action)
+    pids = find_processes
 
-  # Force the (rails) application to restart by sending a +USR2+ signal to the
-  # process.
-  def restart
-    `kill -s USR2 #{@pid}`
+    if pids.empty?
+      warn "Couldn't find any pid file in '#{@pid_path}' matching '#{@pattern}'"
+      warn "(also looked for processes matching #{@keyword.inspect})" if @keyword
+    else
+      pids.each do |pid|
+        puts "#{action.capitalize}ing #{pid}"
+        self.class.send(action, pid)
+      end
+      
+      delete_pid_files if terminating?(action)
+    end      
   end
+  
+  private
+    def terminating?(action)
+      [ "kill", "graceful" ].include?(action)
+    end
+  
+    def find_processes
+      files = pid_files
+      if files.empty?
+        find_processes_via_grep
+      else
+        files.collect { |pid_file| File.read(pid_file).to_i }
+      end
+    end
 
-  def to_s #:nodoc:
-    "[#{@pid}] #{@command}"
-  end
+    def find_processes_via_grep
+      lines = `ps axww -o 'pid command' | grep #{@keyword}`.split(/\n/).
+        reject { |line| line =~ /inq|ps axww|grep|spawn-fcgi|spawner|reaper/ }
+      lines.map { |line| line[/^\s*(\d+)/, 1].to_i }
+    end
+    
+    def delete_pid_files
+      pid_files.each { |pid_file| File.delete(pid_file) }
+    end
+    
+    def pid_files
+      Dir.glob(@pid_path + "/" + @pattern)
+    end
 end
 
+
 OPTIONS = {
-  :action      => "restart",
-  :dispatcher  => File.expand_path(RAILS_ROOT + '/public/dispatch.fcgi')
+  :action     => "restart",
+  :pid_path   => File.expand_path(RAILS_ROOT + '/tmp/pids'),
+  :pattern    => "dispatch.[0-9]*.pid",
+  :dispatcher => File.expand_path("#{RAILS_ROOT}/public/dispatch.fcgi")
 }
 
 ARGV.options do |opts|
@@ -96,9 +109,13 @@ ARGV.options do |opts|
 
   opts.on <<-EOF
   Description:
-    The reaper is used to restart, reload, gracefully exit, and forcefully exit FCGI processes
-    running a Rails Dispatcher. This is commonly done when a new version of the application
-    is available, so the existing processes can be updated to use the latest code.
+    The reaper is used to restart, reload, gracefully exit, and forcefully exit processes
+    running a Rails Dispatcher (or any other process responding to the same signals). This
+    is commonly done when a new version of the application is available, so the existing
+    processes can be updated to use the latest code.
+
+    It uses pid files to work on the processes and by default assume them to be located
+    in RAILS_ROOT/tmp/pids. 
 
     The reaper actions are:
 
@@ -110,15 +127,17 @@ ARGV.options do |opts|
     Restart is the most common and default action.
 
   Examples:
-    reaper # restarts the default dispatcher
-    reaper -a reload
-    reaper -a exit -d /my/special/dispatcher.fcgi
+    reaper                  # restarts the default dispatchers
+    reaper -a reload        # reload the default dispatchers
+    reaper -a kill -r *.pid # kill all processes that keep pids in tmp/pids
   EOF
 
   opts.on("  Options:")
 
-  opts.on("-a", "--action=name", "reload|graceful|kill (default: #{OPTIONS[:action]})", String)  { |OPTIONS[:action]| }
-  opts.on("-d", "--dispatcher=path", "default: #{OPTIONS[:dispatcher]}", String)                 { |OPTIONS[:dispatcher]| }
+  opts.on("-a", "--action=name", "reload|graceful|kill (default: #{OPTIONS[:action]})", String)  { |v| OPTIONS[:action] = v }
+  opts.on("-p", "--pidpath=path", "default: #{OPTIONS[:pid_path]}", String)                      { |v| OPTIONS[:pid_path] = v }
+  opts.on("-r", "--pattern=pattern", "default: #{OPTIONS[:pattern]}", String)                    { |v| OPTIONS[:pattern] = v }
+  opts.on("-d", "--dispatcher=path", "DEPRECATED. default: #{OPTIONS[:dispatcher]}", String)     { |v| OPTIONS[:dispatcher] = v }
 
   opts.separator ""
 
@@ -127,4 +146,4 @@ ARGV.options do |opts|
   opts.parse!
 end
 
-ProgramProcess.process_keywords(OPTIONS[:action], OPTIONS[:dispatcher])
+Killer.process(OPTIONS[:action], OPTIONS[:pid_path], OPTIONS[:pattern], OPTIONS[:dispatcher])

data/lib/commands/process/spawner.rb

@@ -1,45 +1,200 @@
+require 'active_support'
 require 'optparse'
+require 'socket'
+require 'fileutils'
 
-def spawn(port)
-  print "Starting FCGI on port: #{port}\n  "
-  system("#{OPTIONS[:spawner]} -f #{OPTIONS[:dispatcher]} -p #{port}")
+def daemonize #:nodoc:
+  exit if fork                   # Parent exits, child continues.
+  Process.setsid                 # Become session leader.
+  exit if fork                   # Zap session leader. See [1].
+  Dir.chdir "/"                  # Release old working directory.
+  File.umask 0000                # Ensure sensible umask. Adjust as needed.
+  STDIN.reopen "/dev/null"       # Free file descriptors and
+  STDOUT.reopen "/dev/null", "a" # point them somewhere sensible.
+  STDERR.reopen STDOUT           # STDOUT/ERR should better go to a logfile.
 end
 
+class Spawner
+  def self.record_pid(name = "#{OPTIONS[:process]}.spawner", id = Process.pid)
+    FileUtils.mkdir_p(OPTIONS[:pids])
+    File.open(File.expand_path(OPTIONS[:pids] + "/#{name}.pid"), "w+") { |f| f.write(id) }
+  end
+
+  def self.spawn_all
+    OPTIONS[:instances].times do |i|
+      port = OPTIONS[:port] + i
+      print "Checking if something is already running on #{OPTIONS[:address]}:#{port}..."
+
+      begin
+        srv = TCPServer.new(OPTIONS[:address], port)
+        srv.close
+        srv = nil
+
+        puts "NO"
+        puts "Starting dispatcher on port: #{OPTIONS[:address]}:#{port}"
+
+        FileUtils.mkdir_p(OPTIONS[:pids])
+        spawn(port)
+      rescue
+        puts "YES"
+      end
+    end
+  end
+end
+
+class FcgiSpawner < Spawner
+  def self.spawn(port)
+    cmd = "#{OPTIONS[:spawner]} -f #{OPTIONS[:dispatcher]} -p #{port} -P #{OPTIONS[:pids]}/#{OPTIONS[:process]}.#{port}.pid"
+    cmd << " -a #{OPTIONS[:address]}" if can_bind_to_custom_address?
+    system(cmd)
+  end
+
+  def self.can_bind_to_custom_address?
+    @@can_bind_to_custom_address ||= /^\s-a\s/.match `#{OPTIONS[:spawner]} -h`
+  end
+end
+
+class MongrelSpawner < Spawner
+  def self.spawn(port)
+    cmd =
+      "mongrel_rails start -d " +
+      "-a #{OPTIONS[:address]} " +
+      "-p #{port} " +
+      "-P #{OPTIONS[:pids]}/#{OPTIONS[:process]}.#{port}.pid " +
+      "-e #{OPTIONS[:environment]} " +
+      "-c #{OPTIONS[:rails_root]} " +
+      "-l #{OPTIONS[:rails_root]}/log/mongrel.log"
+
+    # Add prefix functionality to spawner's call to mongrel_rails
+    # Digging through monrel's project subversion server, the earliest
+    # Tag that has prefix implemented in the bin/mongrel_rails file
+    # is 0.3.15 which also happens to be the earilest tag listed.
+    # References: http://mongrel.rubyforge.org/svn/tags
+    if Mongrel::Const::MONGREL_VERSION.to_f >=0.3 && !OPTIONS[:prefix].nil?
+      cmd = cmd + " --prefix #{OPTIONS[:prefix]}"
+    end
+    system(cmd)
+  end
+  
+  def self.can_bind_to_custom_address?
+    true
+  end
+end
+
+
+begin
+  require_library_or_gem 'fcgi'
+rescue Exception
+  # FCGI not available
+end
+
+begin
+  require_library_or_gem 'mongrel'
+rescue Exception
+  # Mongrel not available
+end
+
+server = case ARGV.first
+  when "fcgi", "mongrel"
+    ARGV.shift
+  else
+    if defined?(Mongrel)
+      "mongrel"
+    elsif RUBY_PLATFORM !~ /(:?mswin|mingw)/ && !silence_stderr { `spawn-fcgi -version` }.blank? && defined?(FCGI)
+      "fcgi"
+    end
+end
+
+case server
+  when "fcgi"
+    puts "=> Starting FCGI dispatchers"
+    spawner_class = FcgiSpawner
+  when "mongrel"
+    puts "=> Starting mongrel dispatchers"
+    spawner_class = MongrelSpawner
+  else
+    puts "Neither FCGI (spawn-fcgi) nor Mongrel was installed and available!"
+    exit(0)
+end
+
+
+
 OPTIONS = {
   :environment => "production",
   :spawner     => '/usr/bin/env spawn-fcgi',
-  :dispatcher  => File.expand_path(RAILS_ROOT + '/public/dispatch.fcgi'),
+  :dispatcher  => File.expand_path(RELATIVE_RAILS_ROOT + '/public/dispatch.fcgi'),
+  :pids        => File.expand_path(RELATIVE_RAILS_ROOT + "/tmp/pids"),
+  :rails_root  => File.expand_path(RELATIVE_RAILS_ROOT),
+  :process     => "dispatch",
   :port        => 8000,
-  :instances   => 3
+  :address     => '0.0.0.0',
+  :instances   => 3,
+  :repeat      => nil,
+  :prefix      => nil
 }
 
 ARGV.options do |opts|
-  opts.banner = "Usage: spawner [options]"
+  opts.banner = "Usage: spawner [platform] [options]"
 
   opts.separator ""
 
   opts.on <<-EOF
   Description:
-    The spawner is a wrapper for spawn-fcgi that makes it easier to start multiple FCGI
-    processes running the Rails dispatcher. The spawn-fcgi command is included with the lighttpd 
-    web server, but can be used with both Apache and lighttpd (and any other web server supporting
-    externally managed FCGI processes).
+    The spawner is a wrapper for spawn-fcgi and mongrel that makes it
+    easier to start multiple processes running the Rails dispatcher. The
+    spawn-fcgi command is included with the lighttpd web server, but can
+    be used with both Apache and lighttpd (and any other web server
+    supporting externally managed FCGI processes). Mongrel automatically
+    ships with with mongrel_rails for starting dispatchers.
+
+    The first choice you need to make is whether to spawn the Rails
+    dispatchers as FCGI or Mongrel. By default, this spawner will prefer
+    Mongrel, so if that's installed, and no platform choice is made,
+    Mongrel is used.
 
-    You decide a starting port (default is 8000) and the number of FCGI process instances you'd 
-    like to run. So if you pick 9100 and 3 instances, you'll start processes on 9100, 9101, and 9102.
+    Then decide a starting port (default is 8000) and the number of FCGI
+    process instances you'd like to run. So if you pick 9100 and 3
+    instances, you'll start processes on 9100, 9101, and 9102.
 
-  Examples:
-    spawner               # starts instances on 8000, 8001, and 8002
-    spawner -p 9100 -i 10 # starts 10 instances counting from 9100 to 9109
+    By setting the repeat option, you get a protection loop, which will
+    attempt to restart any FCGI processes that might have been exited or
+    outright crashed.
+
+    You can select bind address for started processes. By default these
+    listen on every interface. For single machine installations you would
+    probably want to use 127.0.0.1, hiding them form the outside world.
+
+     Examples:
+       spawner               # starts instances on 8000, 8001, and 8002
+                             # using Mongrel if available.
+       spawner fcgi          # starts instances on 8000, 8001, and 8002
+                             # using FCGI.
+       spawner mongrel -i 5  # starts instances on 8000, 8001, 8002,
+                             # 8003, and 8004 using Mongrel.
+       spawner -p 9100 -i 10 # starts 10 instances counting from 9100 to
+                             # 9109 using Mongrel if available.
+       spawner -p 9100 -r 5  # starts 3 instances counting from 9100 to
+                             # 9102 and attempts start them every 5
+                             # seconds.
+       spawner -a 127.0.0.1  # starts 3 instances binding to localhost
   EOF
 
   opts.on("  Options:")
 
-  opts.on("-p", "--port=number", Integer, "Starting port number (default: #{OPTIONS[:port]})")                   { |OPTIONS[:port]| }
-  opts.on("-i", "--instances=number", Integer, "Number of instances (default: #{OPTIONS[:instances]})")          { |OPTIONS[:instances]| }
-  opts.on("-e", "--environment=name", String, "test|development|production (default: #{OPTIONS[:environment]})") { |OPTIONS[:environment]| }
-  opts.on("-s", "--spawner=path",    String, "default: #{OPTIONS[:spawner]}")                                    { |OPTIONS[:spawner]| }
-  opts.on("-d", "--dispatcher=path", String, "default: #{OPTIONS[:dispatcher]}") { |dispatcher| OPTIONS[:dispatcher] = File.expand_path(dispatcher) }
+  opts.on("-p", "--port=number",      Integer, "Starting port number (default: #{OPTIONS[:port]})")                { |OPTIONS[:port]| }
+
+  if spawner_class.can_bind_to_custom_address?
+    opts.on("-a", "--address=ip",     String,  "Bind to IP address (default: #{OPTIONS[:address]})")                { |OPTIONS[:address]| }
+  end
+
+  opts.on("-p", "--port=number",      Integer, "Starting port number (default: #{OPTIONS[:port]})")                { |v| OPTIONS[:port] = v }
+  opts.on("-i", "--instances=number", Integer, "Number of instances (default: #{OPTIONS[:instances]})")            { |v| OPTIONS[:instances] = v }
+  opts.on("-r", "--repeat=seconds",   Integer, "Repeat spawn attempts every n seconds (default: off)")             { |v| OPTIONS[:repeat] = v }
+  opts.on("-e", "--environment=name", String,  "test|development|production (default: #{OPTIONS[:environment]})")  { |v| OPTIONS[:environment] = v }
+  opts.on("-P", "--prefix=path",      String,  "URL prefix for Rails app. [Used only with Mongrel > v0.3.15]: (default: #{OPTIONS[:prefix]})")         { |v| OPTIONS[:prefix] = v }
+  opts.on("-n", "--process=name",     String,  "default: #{OPTIONS[:process]}")                                    { |v| OPTIONS[:process] = v }
+  opts.on("-s", "--spawner=path",     String,  "default: #{OPTIONS[:spawner]}")                                    { |v| OPTIONS[:spawner] = v }
+  opts.on("-d", "--dispatcher=path",  String,  "default: #{OPTIONS[:dispatcher]}") { |dispatcher| OPTIONS[:dispatcher] = File.expand_path(dispatcher) }
 
   opts.separator ""
 
@@ -49,4 +204,16 @@ ARGV.options do |opts|
 end
 
 ENV["RAILS_ENV"] = OPTIONS[:environment]
-OPTIONS[:instances].times { |i| spawn(OPTIONS[:port] + i) }
+
+if OPTIONS[:repeat]
+  daemonize
+  trap("TERM") { exit }
+  spawner_class.record_pid
+
+  loop do
+    spawner_class.spawn_all
+    sleep(OPTIONS[:repeat])
+  end
+else
+  spawner_class.spawn_all
+end

data/lib/commands/process/spinner.rb

@@ -36,9 +36,9 @@ ARGV.options do |opts|
 
   opts.on("  Options:")
 
-  opts.on("-c", "--command=path",    String) { |OPTIONS[:command]| }
-  opts.on("-i", "--interval=seconds", Float) { |OPTIONS[:interval]| }
-  opts.on("-d", "--daemon")                  { |OPTIONS[:daemon]| }
+  opts.on("-c", "--command=path",    String) { |v| OPTIONS[:command] = v }
+  opts.on("-i", "--interval=seconds", Float) { |v| OPTIONS[:interval] = v }
+  opts.on("-d", "--daemon")                  { |v| OPTIONS[:daemon] = v }
 
   opts.separator ""
 

data/lib/commands/runner.rb

@@ -1,27 +1,48 @@
 require 'optparse'
 
 options = { :environment => (ENV['RAILS_ENV'] || "development").dup }
+code_or_file = nil
 
-ARGV.options do |opts|
+ARGV.clone.options do |opts|
   script_name = File.basename($0)
-  opts.banner = "Usage: runner 'puts Person.find(1).name' [options]"
+  opts.banner = "Usage: #{$0} [options] ('Some.ruby(code)' or a filename)"
 
   opts.separator ""
 
   opts.on("-e", "--environment=name", String,
           "Specifies the environment for the runner to operate under (test/development/production).",
-          "Default: development") { |options[:environment]| }
+          "Default: development") { |v| options[:environment] = v }
 
   opts.separator ""
 
   opts.on("-h", "--help",
-          "Show this help message.") { puts opts; exit }
-
-  opts.parse!
+          "Show this help message.") { $stderr.puts opts; exit }
+
+  if RUBY_PLATFORM !~ /mswin/
+    opts.separator ""
+    opts.separator "You can also use runner as a shebang line for your scripts like this:"
+    opts.separator "-------------------------------------------------------------"
+    opts.separator "#!/usr/bin/env #{File.expand_path($0)}"
+    opts.separator ""
+    opts.separator "Product.find(:all).each { |p| p.price *= 2 ; p.save! }"
+    opts.separator "-------------------------------------------------------------"
+  end
+
+  opts.order! { |o| code_or_file ||= o } rescue retry
 end
 
+ARGV.delete(code_or_file)
+
 ENV["RAILS_ENV"] = options[:environment]
 RAILS_ENV.replace(options[:environment]) if defined?(RAILS_ENV)
 
 require RAILS_ROOT + '/config/environment'
-eval(ARGV.first)
+
+if code_or_file.nil?
+  $stderr.puts "Run '#{$0} -h' for help."
+  exit 1
+elsif File.exists?(code_or_file)
+  eval(File.read(code_or_file))
+else
+  eval(code_or_file)
+end

data/lib/commands/server.rb

@@ -1,4 +1,5 @@
 require 'active_support'
+require 'fileutils'
 
 begin
   require_library_or_gem 'fcgi'
@@ -6,23 +7,33 @@ rescue Exception
   # FCGI not available
 end
 
+begin
+  require_library_or_gem 'mongrel'
+rescue Exception
+  # Mongrel not available
+end
+
 server = case ARGV.first
-  when "lighttpd"
-    ARGV.shift
-  when "webrick"
+  when "lighttpd", "mongrel", "webrick"
     ARGV.shift
   else
-    if RUBY_PLATFORM !~ /mswin/ && !silence_stderr { `lighttpd -version` }.blank? && defined?(FCGI)
+    if defined?(Mongrel)
+      "mongrel"
+    elsif RUBY_PLATFORM !~ /(:?mswin|mingw)/ && !silence_stderr { `lighttpd -version` }.blank? && defined?(FCGI)
       "lighttpd"
     else
       "webrick"
     end
 end
 
-if server == "webrick"
-  puts "=> Booting WEBrick..."
-else
-  puts "=> Booting lighttpd (use 'script/server webrick' to force WEBrick)"
+case server
+  when "webrick"
+    puts "=> Booting WEBrick..."
+  when "lighttpd"
+    puts "=> Booting lighttpd (use 'script/server webrick' to force WEBrick)"
+  when "mongrel"
+    puts "=> Booting Mongrel (use 'script/server webrick' to force WEBrick)"
 end
 
-require "commands/servers/#{server}"
+%w(cache pids sessions sockets).each { |dir_to_make| FileUtils.mkdir_p(File.join(RAILS_ROOT, 'tmp', dir_to_make)) }
+require "commands/servers/#{server}"

data/lib/commands/servers/base.rb

@@ -0,0 +1,31 @@
+def tail(log_file)
+  cursor = File.size(log_file)
+  last_checked = Time.now
+  tail_thread = Thread.new do
+    File.open(log_file, 'r') do |f|
+      loop do
+        f.seek cursor
+        if f.mtime > last_checked
+          last_checked = f.mtime
+          contents = f.read
+          cursor += contents.length
+          print contents
+        end
+        sleep 1
+      end
+    end
+  end
+  tail_thread
+end
+
+def start_debugger
+  begin
+    require_library_or_gem 'ruby-debug'
+    Debugger.start
+    Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
+    puts "=> Debugger enabled"
+  rescue Exception
+    puts "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
+    exit
+  end
+end