rails 1.0.0 → 1.1.0

data/lib/commands/process/reaper.rb

@@ -127,4 +127,4 @@ ARGV.options do |opts|
   opts.parse!
 end
 
-ProgramProcess.process_keywords(OPTIONS[:action], OPTIONS[:dispatcher])
+ProgramProcess.process_keywords(OPTIONS[:action], OPTIONS[:dispatcher])

data/lib/commands/process/spawner.rb

@@ -1,8 +1,22 @@
 require 'optparse'
+require 'socket'
 
 def spawn(port)
-  print "Starting FCGI on port: #{port}\n  "
-  system("#{OPTIONS[:spawner]} -f #{OPTIONS[:dispatcher]} -p #{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"
+  end
+end
+				    
+def spawn_all
+  OPTIONS[:instances].times { |i| spawn(OPTIONS[:port] + i) }
 end
 
 OPTIONS = {
@@ -10,7 +24,8 @@ OPTIONS = {
   :spawner     => '/usr/bin/env spawn-fcgi',
   :dispatcher  => File.expand_path(RAILS_ROOT + '/public/dispatch.fcgi'),
   :port        => 8000,
-  :instances   => 3
+  :instances   => 3,
+  :repeat      => nil
 }
 
 ARGV.options do |opts|
@@ -28,15 +43,20 @@ ARGV.options do |opts|
     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
   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("-r", "--repeat=seconds", Integer, "Repeat spawn attempts every n seconds (default: off)")          { |OPTIONS[:repeat]| }
   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) }
@@ -49,4 +69,13 @@ ARGV.options do |opts|
 end
 
 ENV["RAILS_ENV"] = OPTIONS[:environment]
-OPTIONS[:instances].times { |i| spawn(OPTIONS[:port] + i) }
+
+if OPTIONS[:repeat]
+  loop do
+    spawn_all
+    puts "Sleeping for #{OPTIONS[:repeat]} seconds"
+    sleep OPTIONS[:repeat]
+  end
+else
+  spawn_all
+end

data/lib/commands/runner.rb

@@ -24,4 +24,4 @@ ENV["RAILS_ENV"] = options[:environment]
 RAILS_ENV.replace(options[:environment]) if defined?(RAILS_ENV)
 
 require RAILS_ROOT + '/config/environment'
-eval(ARGV.first)
+ARGV.empty? ? puts("Usage: runner 'code' [options]") : eval(ARGV.first)

data/lib/commands/server.rb

@@ -1,4 +1,5 @@
 require 'active_support'
+require 'fileutils'
 
 begin
   require_library_or_gem 'fcgi'
@@ -25,4 +26,5 @@ else
   puts "=> Booting lighttpd (use 'script/server webrick' to force WEBrick)"
 end
 
-require "commands/servers/#{server}"
+FileUtils.mkdir_p(%w( tmp/sessions tmp/cache tmp/sockets ))
+require "commands/servers/#{server}"

data/lib/commands/servers/lighttpd.rb

@@ -1,3 +1,5 @@
+require 'rbconfig'
+
 unless RUBY_PLATFORM !~ /mswin/ && !silence_stderr { `lighttpd -version` }.blank?
   puts "PROBLEM: Lighttpd is not available on your system (or not in your path)"
   exit 1
@@ -10,15 +12,32 @@ end
 
 require 'initializer'
 configuration = Rails::Initializer.run(:initialize_logger).configuration
+default_config_file = config_file = Pathname.new("#{RAILS_ROOT}/config/lighttpd.conf").cleanpath
+
+require 'optparse'
 
-config_file = "#{RAILS_ROOT}/config/lighttpd.conf"
+detach = false
+
+ARGV.options do |opt|
+  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" }
+  opt.parse!
+end
 
 unless File.exist?(config_file)
+  if config_file != default_config_file
+    puts "=> #{config_file} not found."
+    exit 1
+  end
+
   require 'fileutils'
+
   source = File.expand_path(File.join(File.dirname(__FILE__),
      "..", "..", "..", "configs", "lighttpd.conf"))
   puts "=> #{config_file} not found, copying from #{source}"
-  FileUtils.cp source, config_file
+
+  FileUtils.cp(source, config_file)
 end
 
 config = IO.read(config_file)
@@ -29,11 +48,8 @@ puts "=> Rails application started on http://#{ip || default_ip}:#{port || defau
 
 tail_thread = nil
 
-if ARGV.first == "-d"
-  puts "=> Configure in config/lighttpd.conf"
-  detach = true
-else
-  puts "=> Call with -d to detach (requires absolute paths in config/lighttpd.conf)"
+if !detach
+  puts "=> Call with -d to detach"
   puts "=> Ctrl-C to shutdown server (see config/lighttpd.conf for options)"
   detach = false
 
@@ -56,5 +72,21 @@ else
 end
 
 trap(:INT) { exit }
-`lighttpd #{!detach ? "-D " : ""}-f #{config_file}`
-tail_thread.kill if tail_thread
+
+begin
+  `rake tmp:sockets:clear` # Needed if lighttpd crashes or otherwise leaves FCGI sockets around
+  `lighttpd #{!detach ? "-D " : ""}-f #{config_file}`
+ensure
+  unless detach
+    tail_thread.kill if tail_thread
+    puts 'Exiting'
+  
+    # Ensure FCGI processes are reaped
+    silence_stream(STDOUT) do
+      ARGV.replace ['-a', 'kill']
+      require 'commands/process/reaper'
+    end
+
+    `rake tmp:sockets:clear` # Remove sockets on clean shutdown
+  end
+end

data/lib/console_app.rb

@@ -0,0 +1,27 @@
+require 'action_controller/integration'
+
+# work around the at_exit hook in test/unit, which kills IRB
+Test::Unit.run = true
+
+# reference the global "app" instance, created on demand. To recreate the
+# instance, pass a non-false value as the parameter.
+def app(create=false)
+  @app_integration_instance = nil if create
+  @app_integration_instance ||= new_session do |sess|
+    sess.host! "www.example.com"
+  end
+end
+
+# create a new session. If a block is given, the new session will be yielded
+# to the block before being returned.
+def new_session
+  session = ActionController::Integration::Session.new
+  yield session if block_given?
+  session
+end
+
+#reloads the environment
+def reload!
+  puts "Reloading..."
+  Dispatcher.reset_application!
+end

data/lib/console_with_helpers.rb

@@ -0,0 +1,23 @@
+class Module
+  def include_all_modules_from(parent_module)
+    parent_module.constants.each do |const|
+      mod = parent_module.const_get(const)
+      if mod.class == Module
+        send(:include, mod)
+        include_all_modules_from(mod)
+      end
+    end
+  end
+end
+
+def helper
+  @helper_proxy ||= Object.new 
+end
+
+require 'application'
+
+class << helper 
+  include_all_modules_from ActionView
+end
+
+@controller = ApplicationController.new

data/lib/dispatcher.rb

@@ -38,7 +38,7 @@ class Dispatcher
         ActionController::Routing::Routes.recognize!(request).process(request, response).out(output)
       end
     rescue Object => exception
-      failsafe_response(output, '500 Internal Server Error') do
+      failsafe_response(output, '500 Internal Server Error', exception) do
         ActionController::Base.process_with_exception(request, response, exception).out(output)
       end
     ensure
@@ -50,11 +50,9 @@ class Dispatcher
     # 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)
+      Class.remove_class(*Reloadable.reloadable_classes)
     end
 
     private
@@ -68,12 +66,12 @@ class Dispatcher
       def prepare_application
         ActionController::Routing::Routes.reload if Dependencies.load?
         prepare_breakpoint
-        Controllers.const_load!(:ApplicationController, "application") unless Controllers.const_defined?(:ApplicationController)
+        require_dependency('application.rb') unless Object.const_defined?(:ApplicationController)
+        ActiveRecord::Base.verify_active_connections!
       end
-    
+
       def reset_after_dispatch
         reset_application! if Dependencies.load?
-        ActiveRecord::Base.clear_connection_cache!
         Breakpoint.deactivate_drb if defined?(BREAKPOINT_SERVER_PORT)
       end
 
@@ -87,11 +85,13 @@ class Dispatcher
       end
 
       # If the block raises, send status code as a last-ditch response.
-      def failsafe_response(output, status)
+      def failsafe_response(output, status, exception = nil)
         yield
       rescue Object
         begin
           output.write "Status: #{status}\r\n"
+          output.write "Content-Type: text/plain\r\n\r\n"
+          output.write exception.to_s + "\r\n" + exception.backtrace.join("\r\n") if exception
         rescue Object
         end
       end

data/lib/fcgi_handler.rb

@@ -5,10 +5,11 @@ require 'rbconfig'
 
 class RailsFCGIHandler
   SIGNALS = {
-    'HUP'  => :reload,
-    'TERM' => :exit_now,
-    'USR1' => :exit,
-    'USR2' => :restart
+    'HUP'     => :reload,
+    'TERM'    => :exit_now,
+    'USR1'    => :exit,
+    'USR2'    => :restart,
+    'SIGTRAP' => :breakpoint
   }
 
   attr_reader :when_ready
@@ -61,6 +62,9 @@ class RailsFCGIHandler
         when :exit
           close_connection(cgi)
           break
+        when :breakpoint
+          close_connection(cgi)
+          breakpoint!
       end
 
       gc_countdown
@@ -137,6 +141,11 @@ class RailsFCGIHandler
       @when_ready = :restart
     end
 
+    def breakpoint_handler(signal)
+      dispatcher_log :info, "asked to breakpoint ASAP"
+      @when_ready = :breakpoint
+    end
+
     def process_request(cgi)
       Dispatcher.dispatch(cgi)
     rescue Object => e
@@ -170,6 +179,15 @@ class RailsFCGIHandler
       Dispatcher.reset_application!
       ActionController::Routing::Routes.reload
     end
+    
+    def breakpoint!
+      require 'breakpoint'
+      port = defined?(BREAKPOINT_SERVER_PORT) ? BREAKPOINT_SERVER_PORT : 42531
+      Breakpoint.activate_drb("druby://localhost:#{port}", nil, !defined?(FastCGI))
+      dispatcher_log :info, "breakpointing"
+      breakpoint
+      @when_ready = nil
+    end
 
     def run_gc!
       @gc_request_countdown = gc_request_period

data/lib/initializer.rb

@@ -61,19 +61,20 @@ module Rails
     # * #initialize_logger
     # * #initialize_framework_logging
     # * #initialize_framework_views
-    # * #initialize_routing
     # * #initialize_dependency_mechanism
     # * #initialize_breakpoints
     # * #initialize_whiny_nils
     # * #initialize_framework_settings
     # * #load_environment
     # * #load_plugins
+    # * #initialize_routing
     #
     # (Note that #load_environment is invoked twice, once at the start and
     # once at the end, to support the legacy configuration style where the
     # environment could overwrite the defaults directly, instead of via the
     # Configuration instance. 
     def process
+      check_ruby_version
       set_load_path
       set_connection_adapters
 
@@ -87,7 +88,8 @@ module Rails
       initialize_dependency_mechanism
       initialize_breakpoints
       initialize_whiny_nils
-      
+      initialize_temporary_directories
+
       initialize_framework_settings
       
       # Support for legacy configuration style where the environment
@@ -95,14 +97,24 @@ module Rails
       # the individual base class configurations.
       load_environment
       
-      load_framework_info
+      add_support_load_paths
 
       load_plugins
 
       # Routing must be initialized after plugins to allow the former to extend the routes
       initialize_routing
+      
+      # the framework is now fully initialized
+      after_initialize
     end
-    
+
+    # Check for valid Ruby version
+    # This is done in an external file, so we can use it
+    # from the `rails` program as well without duplication.
+    def check_ruby_version    
+      require 'ruby_version_check'
+    end
+
     # Set the <tt>$LOAD_PATH</tt> based on the value of
     # Configuration#load_paths. Duplicates are removed.
     def set_load_path
@@ -125,10 +137,10 @@ module Rails
       configuration.frameworks.each { |framework| require(framework.to_s) }
     end
     
-    # Loads Rails::VERSION and Rails::Info.
-    # TODO: Make this work via dependencies.rb/const_missing instead.
-    def load_framework_info
-      require 'rails_info'
+    # Add the load paths used by support functions such as the info controller
+    def add_support_load_paths
+      builtins = File.join(File.dirname(File.dirname(__FILE__)), 'builtin', '*')
+      $LOAD_PATH.concat(Dir[builtins])
     end
 
     # Loads all plugins in <tt>config.plugin_paths</tt>.  <tt>plugin_paths</tt>
@@ -141,8 +153,9 @@ module Rails
     # * evaluate <tt>init.rb</tt> if present
     #
     # After all plugins are loaded, duplicates are removed from the load path.
+    # Plugins are loaded in alphabetical order.
     def load_plugins
-      find_plugins(configuration.plugin_paths).each { |path| load_plugin path }
+      find_plugins(configuration.plugin_paths).sort.each { |path| load_plugin path }
       $LOAD_PATH.uniq!
     end
 
@@ -224,7 +237,6 @@ module Rails
     def initialize_routing
       return unless configuration.frameworks.include?(:action_controller)
       ActionController::Routing::Routes.reload
-      Object.const_set "Controllers", Dependencies::LoadingModule.root(*configuration.controller_paths)
     end
     
     # Sets the dependency loading mechanism based on the value of
@@ -245,7 +257,19 @@ module Rails
       require('active_support/whiny_nil') if configuration.whiny_nils
     end
 
-    # Initialize framework-specific settings for each of the loaded frameworks
+    def initialize_temporary_directories
+      if configuration.frameworks.include?(:action_controller)
+        session_path = "#{RAILS_ROOT}/tmp/sessions/"
+        ActionController::Base.session_options[:tmpdir] = File.exist?(session_path) ? session_path : Dir::tmpdir
+        
+        cache_path = "#{RAILS_ROOT}/tmp/cache/"
+        if File.exist?(cache_path)
+          ActionController::Base.fragment_cache_store = :file_store, cache_path
+        end
+      end
+    end
+
+    # Initializes framework-specific settings for each of the loaded frameworks
     # (Configuration#frameworks). The available settings map to the accessors
     # on each of the corresponding Base classes.
     def initialize_framework_settings
@@ -257,12 +281,18 @@ module Rails
         end
       end
     end
+    
+    # Fires the user-supplied after_initialize block (Configuration#after_initialize) 
+    def after_initialize
+      configuration.after_initialize_block.call if configuration.after_initialize_block
+    end
+    
 
     protected
       # Return a list of plugin paths within base_path.  A plugin path is
       # a directory that contains either a lib directory or an init.rb file.
       # This recurses into directories which are not plugin paths, so you
-      # may organize your plugins which the plugin path.
+      # may organize your plugins within the plugin path.
       def find_plugins(*base_paths)
         base_paths.flatten.inject([]) do |plugins, base_path|
           Dir.glob(File.join(base_path, '*')).each do |path|
@@ -301,17 +331,22 @@ module Rails
         has_lib   = File.directory?(lib_path)
         has_init  = File.file?(init_path)
 
-        # Add lib to load path.
-        $LOAD_PATH.unshift(lib_path) if has_lib
-        
+        # Add lib to load path *after* the application lib, to allow
+        # application libraries to override plugin libraries.
+        if has_lib
+          application_lib_index = $LOAD_PATH.index(File.join(RAILS_ROOT, "lib")) || 0  
+          $LOAD_PATH.insert(application_lib_index + 1, lib_path)
+        end
+
         # Allow plugins to reference the current configuration object
         config = configuration 
+	
+        # Add to set of loaded plugins before 'name' collapsed in eval.
+        loaded_plugins << name
 
         # Evaluate init.rb.
         silence_warnings { eval(IO.read(init_path), binding, init_path) } if has_init
 
-        # Add to set of loaded plugins.
-        loaded_plugins << name
         true
       end
   end
@@ -435,18 +470,37 @@ module Rails
     def environment
       ::RAILS_ENV
     end
-
+    
+    # Sets a block which will be executed after rails has been fully initialized.
+    # Useful for per-environment configuration which depends on the framework being 
+    # fully initialized.
+    def after_initialize(&after_initialize_block)
+      @after_initialize_block = after_initialize_block
+    end
+    
+    # Returns the block set in Configuration#after_initialize
+    def after_initialize_block
+      @after_initialize_block
+    end
+    
     private
       def root_path
         ::RAILS_ROOT
       end
 
+      def framework_root_path
+        defined?(::RAILS_FRAMEWORK_ROOT) ? ::RAILS_FRAMEWORK_ROOT : "#{root_path}/vendor/rails"
+      end
+
       def default_frameworks
         [ :active_record, :action_controller, :action_view, :action_mailer, :action_web_service ]
       end
     
       def default_load_paths
         paths = ["#{root_path}/test/mocks/#{environment}"]
+        
+        # Add the app's controller directory
+        paths.concat(Dir["#{root_path}/app/controllers/"])
 
         # Then model subdirectories.
         # TODO: Don't include .rb models as load paths
@@ -454,7 +508,6 @@ module Rails
         paths.concat(Dir["#{root_path}/components/[_a-z]*"])
 
         # Followed by the standard includes.
-        # TODO: Don't include dirs for frameworks that are not used
         paths.concat %w(
           app 
           app/models 
@@ -466,14 +519,18 @@ module Rails
           config 
           lib 
           vendor 
-          vendor/rails/railties
-          vendor/rails/railties/lib
-          vendor/rails/actionpack/lib
-          vendor/rails/activesupport/lib
-          vendor/rails/activerecord/lib
-          vendor/rails/actionmailer/lib
-          vendor/rails/actionwebservice/lib
         ).map { |dir| "#{root_path}/#{dir}" }.select { |dir| File.directory?(dir) }
+
+        # TODO: Don't include dirs for frameworks that are not used
+        paths.concat %w(
+          railties
+          railties/lib
+          actionpack/lib
+          activesupport/lib
+          activerecord/lib
+          actionmailer/lib
+          actionwebservice/lib
+        ).map { |dir| "#{framework_root_path}/#{dir}" }.select { |dir| File.directory?(dir) }
       end
 
       def default_log_path
@@ -520,10 +577,8 @@ end
 
 # Needs to be duplicated from Active Support since its needed before Active
 # Support is available.
-class OrderedOptions < Array # :nodoc:
-  def []=(key, value)
-    key = key.to_sym
-
+class OrderedHash < Array #:nodoc:
+  def []=(key, value)    
     if pair = find_pair(key)
       pair.pop
       pair << value
@@ -531,18 +586,14 @@ class OrderedOptions < Array # :nodoc:
       self << [key, value]
     end
   end
-
+  
   def [](key)
-    pair = find_pair(key.to_sym)
+    pair = find_pair(key)
     pair ? pair.last : nil
   end
 
-  def method_missing(name, *args)
-    if name.to_s =~ /(.*)=$/
-      self[$1.to_sym] = args.first
-    else
-      self[name]
-    end
+  def keys
+    self.collect { |i| i.first }
   end
 
   private
@@ -551,3 +602,21 @@ class OrderedOptions < Array # :nodoc:
       return false
     end
 end
+
+class OrderedOptions < OrderedHash #:nodoc:
+  def []=(key, value)
+    super(key.to_sym, value)
+  end
+  
+  def [](key)
+    super(key.to_sym)
+  end
+
+  def method_missing(name, *args)
+    if name.to_s =~ /(.*)=$/
+      self[$1.to_sym] = args.first
+    else
+      self[name]
+    end
+  end
+end