rails 1.1.6 → 1.2.0

data/lib/commands/process/spawner.rb

@@ -1,5 +1,7 @@
+require 'active_support'
 require 'optparse'
 require 'socket'
+require 'fileutils'
 
 def daemonize #:nodoc:
   exit if fork                   # Parent exits, child continues.
@@ -12,63 +14,175 @@ def daemonize #:nodoc:
   STDERR.reopen STDOUT           # STDOUT/ERR should better go to a logfile.
 end
 
-def spawn(port)
-  print "Checking if something is already running on port #{port}..."
-  begin
-    srv = TCPServer.new('0.0.0.0', port)
-    srv.close
-    srv = nil
-    print "NO\n "
-    print "Starting FCGI on port: #{port}\n  "
-    system("#{OPTIONS[:spawner]} -f #{OPTIONS[:dispatcher]} -p #{port}")
-  rescue
-    print "YES\n"
+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"
+
+    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
-				    
-def spawn_all
-  OPTIONS[:instances].times { |i| spawn(OPTIONS[:port] + i) }
+
+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/ && !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'),
+  :pids        => File.expand_path(RAILS_ROOT + "/tmp/pids"),
+  :rails_root  => File.expand_path(RAILS_ROOT),
+  :process     => "dispatch",
   :port        => 8000,
+  :address     => '0.0.0.0',
   :instances   => 3,
   :repeat      => 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).
-
-    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.
-
-    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. 
-
-  Examples:
-    spawner               # starts instances on 8000, 8001, and 8002
-    spawner -p 9100 -i 10 # starts 10 instances counting from 9100 to 9109
-    spawner -p 9100 -r 5  # starts 3 instances counting from 9100 to 9102 and attempts start them every 5 seconds
+    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.
+
+    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.
+
+    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]| }
+
+  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("-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) }
 
@@ -84,11 +198,12 @@ ENV["RAILS_ENV"] = OPTIONS[:environment]
 if OPTIONS[:repeat]
   daemonize
   trap("TERM") { exit }
+  spawner_class.record_pid
 
   loop do
-    spawn_all
+    spawner_class.spawn_all
     sleep(OPTIONS[:repeat])
   end
 else
-  spawn_all
-end
+  spawner_class.spawn_all
+end

data/lib/commands/runner.rb

@@ -1,10 +1,11 @@
 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 ""
 
@@ -15,13 +16,33 @@ ARGV.options do |opts|
   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'
-ARGV.empty? ? puts("Usage: runner 'code' [options]") : 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

@@ -7,24 +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/ && !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
 
-FileUtils.mkdir_p(%w( tmp/sessions tmp/cache tmp/sockets ))
+%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,19 @@
+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

data/lib/commands/servers/lighttpd.rb

@@ -1,4 +1,5 @@
 require 'rbconfig'
+require 'commands/servers/base'
 
 unless RUBY_PLATFORM !~ /mswin/ && !silence_stderr { `lighttpd -version` }.blank?
   puts "PROBLEM: Lighttpd is not available on your system (or not in your path)"
@@ -17,8 +18,10 @@ default_config_file = config_file = Pathname.new("#{RAILS_ROOT}/config/lighttpd.
 require 'optparse'
 
 detach = false
+command_line_port = nil
 
 ARGV.options do |opt|
+  opt.on("-p", "--port=port", "Changes the server.port number in the config/lighttpd.conf") { |port| command_line_port = port }
   opt.on('-c', "--config=#{config_file}", 'Specify a different lighttpd config file.') { |path| config_file = path }
   opt.on('-h', '--help', 'Show this message.') { puts opt; exit 0 }
   opt.on('-d', '-d', 'Call with -d to detach') { detach = true; puts "=> Configuration in config/lighttpd.conf" }
@@ -40,11 +43,26 @@ unless File.exist?(config_file)
   FileUtils.cp(source, config_file)
 end
 
+# open the config/lighttpd.conf file and add the current user defined port setting to it
+if command_line_port
+  File.open(config_file, 'r+') do |config|
+    lines = config.readlines
+
+    lines.each do |line|
+      line.gsub!(/^\s*server.port\s*=\s*(\d+)/, "server.port = #{command_line_port}")
+    end
+
+    config.rewind
+    config.print(lines)
+    config.truncate(config.pos)
+  end
+end
+
 config = IO.read(config_file)
 default_port, default_ip = 3000, '0.0.0.0'
 port = config.scan(/^\s*server.port\s*=\s*(\d+)/).first rescue default_port
 ip   = config.scan(/^\s*server.bind\s*=\s*"([^"]+)"/).first rescue default_ip
-puts "=> Rails application started on http://#{ip || default_ip}:#{port || default_port}"
+puts "=> Rails application starting on http://#{ip || default_ip}:#{port || default_port}"
 
 tail_thread = nil
 
@@ -52,23 +70,7 @@ if !detach
   puts "=> Call with -d to detach"
   puts "=> Ctrl-C to shutdown server (see config/lighttpd.conf for options)"
   detach = false
-
-  cursor = File.size(configuration.log_path)
-  last_checked = Time.now
-  tail_thread = Thread.new do
-    File.open(configuration.log_path, '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 = tail(configuration.log_path)
 end
 
 trap(:INT) { exit }

data/lib/commands/servers/mongrel.rb

@@ -0,0 +1,65 @@
+require 'rbconfig'
+require 'commands/servers/base'
+
+unless defined?(Mongrel)
+  puts "PROBLEM: Mongrel is not available on your system (or not in your path)"
+  exit 1
+end
+
+require 'optparse'
+
+OPTIONS = {
+  :port        => 3000,
+  :ip          => "0.0.0.0",
+  :environment => (ENV['RAILS_ENV'] || "development").dup,
+  :detach      => false
+}
+
+ARGV.clone.options do |opts|
+  opts.on("-p", "--port=port", Integer, "Runs Rails on the specified port.", "Default: 3000") { |v| OPTIONS[:port] = v }
+  opts.on("-b", "--binding=ip", String, "Binds Rails to the specified ip.", "Default: 0.0.0.0") { |v| OPTIONS[:ip] = v }
+  opts.on("-d", "--daemon", "Make server run as a Daemon.") { OPTIONS[:detach] = true }
+  opts.on("-e", "--environment=name", String,
+          "Specifies the environment to run this server under (test/development/production).",
+          "Default: development") { |v| OPTIONS[:environment] = v }
+
+  opts.separator ""
+
+  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+puts "=> Rails application starting on http://#{OPTIONS[:ip]}:#{OPTIONS[:port]}"
+
+parameters = [ 
+  "start", 
+  "-p", OPTIONS[:port].to_s, 
+  "-a", OPTIONS[:ip].to_s, 
+  "-e", OPTIONS[:environment],
+  "-P", "#{RAILS_ROOT}/tmp/pids/mongrel.pid"
+]
+
+if OPTIONS[:detach]
+  `mongrel_rails #{parameters.join(" ")} -d`
+else
+  ENV["RAILS_ENV"] = OPTIONS[:environment]
+  RAILS_ENV.replace(OPTIONS[:environment]) if defined?(RAILS_ENV)
+
+  require 'initializer'
+  Rails::Initializer.run(:initialize_logger)
+
+  puts "=> Call with -d to detach"
+  puts "=> Ctrl-C to shutdown server"
+  tail_thread = tail(Pathname.new("#{File.expand_path(RAILS_ROOT)}/log/#{RAILS_ENV}.log").cleanpath)
+
+  trap(:INT) { exit }
+
+  begin
+    silence_warnings { ARGV = parameters }
+    load("mongrel_rails")
+  ensure
+    tail_thread.kill if tail_thread
+    puts 'Exiting'
+  end
+end