rails 0.13.1 → 0.14.1

data/lib/commands/generate.rb

@@ -0,0 +1,6 @@
+require "#{RAILS_ROOT}/config/environment"
+require 'rails_generator'
+require 'rails_generator/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+Rails::Generator::Scripts::Generate.new.run(ARGV)

data/lib/commands/performance/benchmarker.rb

@@ -0,0 +1,26 @@
+#!/usr/local/bin/ruby
+
+if ARGV.empty?
+  puts "Usage: ./script/perform benchmarker [times] 'Person.expensive_way' 'Person.another_expensive_way' ..."
+  exit 1
+end
+
+begin
+  N = Integer(ARGV.first)
+  ARGV.shift
+rescue ArgumentError
+  N = 1
+end
+
+require RAILS_ROOT + '/config/environment'
+require 'benchmark'
+include Benchmark
+
+# Don't include compilation in the benchmark
+ARGV.each { |expression| eval(expression) }
+
+bm(6) do |x|
+  ARGV.each_with_index do |expression, idx|
+    x.report("##{idx + 1}") { N.times { eval(expression) } }
+  end
+end 

data/{bin/profiler → lib/commands/performance/profiler.rb}

@@ -1,12 +1,12 @@
 #!/usr/local/bin/ruby
 if ARGV.empty?
-  $stderr.puts "Usage: profiler 'Person.expensive_method(10)' [times]"
+  $stderr.puts "Usage: ./script/perform profiler 'Person.expensive_method(10)' [times]"
   exit(1)
 end
 
 # Keep the expensive require out of the profile.
 $stderr.puts 'Loading Rails...'
-require File.dirname(__FILE__) + '/../config/environment'
+require RAILS_ROOT + '/config/environment'
 
 # Define a method to profile.
 if ARGV[1] and ARGV[1].to_i > 1
@@ -26,6 +26,7 @@ begin
   require 'rubyprof_ext'
   Prof.print_profile(results, $stderr)
 rescue LoadError
+  require 'profiler'
   $stderr.puts 'Using the standard Ruby profiler.'
   Profiler__.start_profile
   profile_me

data/lib/commands/process/reaper.rb

@@ -0,0 +1,130 @@
+require 'optparse'
+require 'net/http'
+require 'uri'
+
+if RUBY_PLATFORM =~ /mswin32/ 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 << 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      
+    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.include?("inq") || line.include?("ps -ax") || line.include?("grep")
+        pid, *command = line.split
+        new(pid, command.join(" "))
+      }.compact
+    end
+
+    private
+      def process_lines_with_keyword(keyword)
+        `ps -ax -o 'pid command' | grep #{keyword}`
+      end
+  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 reload by sending a +HUP+ signal to the
+  # process.
+  def reload
+    `kill -s HUP #{@pid}`
+  end
+
+  # Forces the (rails) application to gracefully terminate by sending a
+  # +TERM+ signal to the process.
+  def graceful
+    `kill -s TERM #{@pid}`
+  end
+
+  # Forces the (rails) application to terminate immediately by sending a -9
+  # signal to the process.
+  def kill
+    `kill -9 #{@pid}`
+  end
+
+  # Send a +USR1+ signal to the process.
+  def usr1
+    `kill -s USR1 #{@pid}`
+  end
+
+  # Force the (rails) application to restart by sending a +USR2+ signal to the
+  # process.
+  def restart
+    `kill -s USR2 #{@pid}`
+  end
+
+  def to_s #:nodoc:
+    "[#{@pid}] #{@command}"
+  end
+end
+
+OPTIONS = {
+  :action      => "restart",
+  :dispatcher  => File.expand_path(RAILS_ROOT + '/public/dispatch.fcgi')
+}
+
+ARGV.options do |opts|
+  opts.banner = "Usage: reaper [options]"
+
+  opts.separator ""
+
+  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 actions are:
+
+    * restart : Restarts the application by reloading both application and framework code
+    * reload  : Only reloads the application, but not the framework (like the development environment)
+    * graceful: Marks all of the processes for exit after the next request
+    * kill    : Forcefully exists all processes regardless of whether they're currently serving a request
+
+    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
+  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.separator ""
+
+  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+ProgramProcess.process_keywords(OPTIONS[:action], OPTIONS[:dispatcher])

data/lib/commands/process/spawner.rb

@@ -0,0 +1,52 @@
+require 'optparse'
+
+def spawn(port)
+  print "Starting FCGI on port: #{port}\n  "
+  system("#{OPTIONS[:spawner]} -f #{OPTIONS[:dispatcher]} -p #{port}")
+end
+
+OPTIONS = {
+  :environment => "production",
+  :spawner     => '/usr/bin/env spawn-fcgi',
+  :dispatcher  => File.expand_path(RAILS_ROOT + '/public/dispatch.fcgi'),
+  :port        => 8000,
+  :instances   => 3
+}
+
+ARGV.options do |opts|
+  opts.banner = "Usage: spawner [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.
+
+  Examples:
+    spawner               # starts instances on 8000, 8001, and 8002
+    spawner -p 9100 -i 10 # starts 10 instances counting from 9100 to 9109
+  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.separator ""
+
+  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+ENV["RAILS_ENV"] = OPTIONS[:environment]
+OPTIONS[:instances].times { |i| spawn(OPTIONS[:port] + i) }

data/lib/commands/process/spinner.rb

@@ -0,0 +1,57 @@
+require 'optparse'
+
+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
+
+OPTIONS = {
+  :interval => 5.0,
+  :command  => File.expand_path(RAILS_ROOT + '/script/process/spawner'),
+  :daemon   => false
+}
+
+ARGV.options do |opts|
+  opts.banner = "Usage: spinner [options]"
+
+  opts.separator ""
+
+  opts.on <<-EOF
+  Description:
+    The spinner is a protection loop for the spawner, which will attempt to restart any FCGI processes
+    that might have been exited or outright crashed. It's a brute-force attempt that'll just try
+    to run the spawner every X number of seconds, so it does pose a light load on the server.
+
+  Examples:
+    spinner # attempts to run the spawner with default settings every second with output on the terminal
+    spinner -i 3 -d # only run the spawner every 3 seconds and detach from the terminal to become a daemon
+    spinner -c '/path/to/app/script/process/spawner -p 9000 -i 10' -d # using custom spawner
+  EOF
+
+  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.separator ""
+
+  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+daemonize if OPTIONS[:daemon]
+
+trap(OPTIONS[:daemon] ? "TERM" : "INT") { exit }
+
+loop do
+  system(OPTIONS[:command])
+  sleep(OPTIONS[:interval])
+end

data/lib/commands/runner.rb

@@ -0,0 +1,27 @@
+require 'optparse'
+
+options = { :environment => (ENV['RAILS_ENV'] || "development").dup }
+
+ARGV.options do |opts|
+  script_name = File.basename($0)
+  opts.banner = "Usage: runner 'puts Person.find(1).name' [options]"
+
+  opts.separator ""
+
+  opts.on("-e", "--environment=name", String,
+          "Specifies the environment for the runner to operate under (test/development/production).",
+          "Default: development") { |options[:environment]| }
+
+  opts.separator ""
+
+  opts.on("-h", "--help",
+          "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+ENV["RAILS_ENV"] = options[:environment]
+RAILS_ENV.replace(options[:environment]) if defined?(RAILS_ENV)
+
+require RAILS_ROOT + '/config/environment'
+eval(ARGV.first)

data/lib/commands/server.rb

@@ -0,0 +1,59 @@
+require 'webrick'
+require 'optparse'
+
+OPTIONS = {
+  :port            => 3000,
+  :ip              => "0.0.0.0",
+  :environment     => (ENV['RAILS_ENV'] || "development").dup,
+  :server_root     => File.expand_path(RAILS_ROOT + "/public/"),
+  :server_type     => WEBrick::SimpleServer,
+  :charset         => "UTF-8",
+  :mime_types      => WEBrick::HTTPUtils::DefaultMimeTypes
+}
+
+ARGV.options do |opts|
+  script_name = File.basename($0)
+  opts.banner = "Usage: ruby #{script_name} [options]"
+
+  opts.separator ""
+
+  opts.on("-p", "--port=port", Integer,
+          "Runs Rails on the specified port.",
+          "Default: 3000") { |OPTIONS[:port]| }
+  opts.on("-b", "--binding=ip", String,
+          "Binds Rails to the specified ip.",
+          "Default: 0.0.0.0") { |OPTIONS[:ip]| }
+  opts.on("-e", "--environment=name", String,
+          "Specifies the environment to run this server under (test/development/production).",
+          "Default: development") { |OPTIONS[:environment]| }
+  opts.on("-m", "--mime-types=filename", String,
+                  "Specifies an Apache style mime.types configuration file to be used for mime types",
+                  "Default: none") { |mime_types_file| OPTIONS[:mime_types] = WEBrick::HTTPUtils::load_mime_types(mime_types_file) }
+
+  opts.on("-d", "--daemon",
+          "Make Rails run as a Daemon (only works if fork is available -- meaning on *nix)."
+          ) { OPTIONS[:server_type] = WEBrick::Daemon }
+
+  opts.on("-c", "--charset=charset", String,
+          "Set default charset for output.",
+          "Default: UTF-8") { |OPTIONS[:charset]| }
+
+  opts.separator ""
+
+  opts.on("-h", "--help",
+          "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+ENV["RAILS_ENV"] = OPTIONS[:environment]
+RAILS_ENV.replace(OPTIONS[:environment]) if defined?(RAILS_ENV)
+
+require RAILS_ROOT + "/config/environment"
+require 'webrick_server'
+
+OPTIONS['working_directory'] = File.expand_path(RAILS_ROOT)
+
+puts "=> Rails application started on http://#{OPTIONS[:ip]}:#{OPTIONS[:port]}"
+puts "=> Ctrl-C to shutdown server; call with --help for options" if OPTIONS[:server_type] == WEBrick::SimpleServer
+DispatchServlet.dispatch(OPTIONS)

data/{bin/update → lib/commands/update.rb}

@@ -1,5 +1,4 @@
-#!/usr/local/bin/ruby
-require File.dirname(__FILE__) + '/../config/environment'
+require "#{RAILS_ROOT}/config/environment"
 require 'rails_generator'
 require 'rails_generator/scripts/update'
 Rails::Generator::Scripts::Update.new.run(ARGV)

data/lib/dispatcher.rb

@@ -21,10 +21,14 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-require 'breakpoint'
-
+# This class provides an interface for dispatching a CGI (or CGI-like) request
+# to the appropriate controller and action. It also takes care of resetting
+# the environment (when Dependencies.load? is true) after each request.
 class Dispatcher
   class << self
+    
+    # Dispatch the given CGI request, using the given session options, and
+    # emitting the output via the given output.
     def dispatch(cgi = CGI.new, session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout)
       begin
         request, response = ActionController::CgiRequest.new(cgi, session_options), ActionController::CgiResponse.new(cgi)
@@ -37,9 +41,13 @@ class Dispatcher
       end
     end
 
+    # Reset the application by clearing out loaded controllers, views, actions,
+    # mailers, and so forth. This allows them to be loaded again without having
+    # to restart the server (WEBrick, FastCGI, etc.).
     def reset_application!
       Controllers.clear!
       Dependencies.clear
+      ActiveRecord::Base.reset_subclasses
       Dependencies.remove_subclasses_for(ActiveRecord::Base, ActiveRecord::Observer, ActionController::Base)
       Dependencies.remove_subclasses_for(ActionMailer::Base) if defined?(ActionMailer::Base)
     end
@@ -47,7 +55,7 @@ class Dispatcher
     private
       def prepare_application
         ActionController::Routing::Routes.reload if Dependencies.load?
-        Breakpoint.activate_drb("druby://localhost:#{BREAKPOINT_SERVER_PORT}", nil, !defined?(FastCGI)) if defined?(BREAKPOINT_SERVER_PORT) rescue nil
+        prepare_breakpoint
         Controllers.const_load!(:ApplicationController, "application") unless Controllers.const_defined?(:ApplicationController)
       end
     
@@ -55,5 +63,14 @@ class Dispatcher
         reset_application! if Dependencies.load?
         Breakpoint.deactivate_drb if defined?(BREAKPOINT_SERVER_PORT)
       end
+
+      def prepare_breakpoint
+        return unless defined?(BREAKPOINT_SERVER_PORT)
+        require 'breakpoint'
+        Breakpoint.activate_drb("druby://localhost:#{BREAKPOINT_SERVER_PORT}", nil, !defined?(FastCGI))
+        true
+      rescue
+        nil
+      end
   end
 end