rails 1.0.0 → 2.0.0

data/lib/commands/servers/lighttpd.rb

@@ -1,3 +1,6 @@
+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)"
   exit 1
@@ -10,51 +13,82 @@ 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
+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" }
+  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
+
+# 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
 
-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
+  tail_thread = tail(configuration.log_path)
+end
 
-  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
+trap(:INT) { exit }
+
+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
-
-trap(:INT) { exit }
-`lighttpd #{!detach ? "-D " : ""}-f #{config_file}`
-tail_thread.kill if tail_thread

data/lib/commands/servers/mongrel.rb

@@ -0,0 +1,69 @@
+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,
+  :debugger    => 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("-u", "--debugger", "Enable ruby-debugging for the server.") { OPTIONS[:debugger] = 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)
+
+  start_debugger if OPTIONS[:debugger]
+
+  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

data/lib/commands/servers/webrick.rb

@@ -1,14 +1,17 @@
 require 'webrick'
 require 'optparse'
+require 'commands/servers/base'
 
 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
+  :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,
+  :debugger     => false
+  
 }
 
 ARGV.options do |opts|
@@ -19,13 +22,13 @@ ARGV.options do |opts|
 
   opts.on("-p", "--port=port", Integer,
           "Runs Rails on the specified port.",
-          "Default: 3000") { |OPTIONS[:port]| }
+          "Default: 3000") { |v| OPTIONS[:port] = v }
   opts.on("-b", "--binding=ip", String,
           "Binds Rails to the specified ip.",
-          "Default: 0.0.0.0") { |OPTIONS[:ip]| }
+          "Default: 0.0.0.0") { |v| OPTIONS[:ip] = v }
   opts.on("-e", "--environment=name", String,
           "Specifies the environment to run this server under (test/development/production).",
-          "Default: development") { |OPTIONS[:environment]| }
+          "Default: development") { |v| OPTIONS[:environment] = v }
   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) }
@@ -34,9 +37,11 @@ ARGV.options do |opts|
           "Make Rails run as a Daemon (only works if fork is available -- meaning on *nix)."
           ) { OPTIONS[:server_type] = WEBrick::Daemon }
 
+  opts.on("-u", "--debugger", "Enable ruby-debugging for the server.") { OPTIONS[:debugger] = true }
+
   opts.on("-c", "--charset=charset", String,
           "Set default charset for output.",
-          "Default: UTF-8") { |OPTIONS[:charset]| }
+          "Default: UTF-8") { |v| OPTIONS[:charset] = v }
 
   opts.separator ""
 
@@ -46,6 +51,8 @@ ARGV.options do |opts|
   opts.parse!
 end
 
+start_debugger if OPTIONS[:debugger]
+
 ENV["RAILS_ENV"] = OPTIONS[:environment]
 RAILS_ENV.replace(OPTIONS[:environment]) if defined?(RAILS_ENV)
 

data/lib/console_app.rb

@@ -0,0 +1,30 @@
+require 'action_controller/integration'
+
+# work around the at_exit hook in test/unit, which kills IRB
+Test::Unit.run = true if Test::Unit.respond_to?(:run=)
+
+# 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 = ActionController::Dispatcher.new($stdout)
+  dispatcher.cleanup_application(true)
+  dispatcher.prepare_application(true)
+  true
+end

data/lib/console_sandbox.rb

@@ -1,6 +1,6 @@
-ActiveRecord::Base.lock_mutex
+ActiveRecord::Base.send :increment_open_transactions
 ActiveRecord::Base.connection.begin_db_transaction
 at_exit do
   ActiveRecord::Base.connection.rollback_db_transaction
-  ActiveRecord::Base.unlock_mutex
+  ActiveRecord::Base.send :decrement_open_transactions
 end

data/lib/console_with_helpers.rb

@@ -0,0 +1,26 @@
+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_names)
+  returning @helper_proxy ||= Object.new do |helper|
+    helper_names.each { |h| helper.extend "#{h}_helper".classify.constantize }
+  end
+end
+
+require 'application'
+
+class << helper 
+  include_all_modules_from ActionView
+end
+
+@controller = ApplicationController.new
+helper :application rescue nil

data/lib/dispatcher.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004 David Heinemeier Hansson
+# Copyright (c) 2004-2007 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -20,80 +20,5 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
-
-# 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.  If you dispatch with your
-    # own CGI object be sure to handle the exceptions it raises on multipart
-    # requests (EOFError and ArgumentError).
-    def dispatch(cgi = nil, session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout)
-      if cgi ||= new_cgi(output)
-        request, response = ActionController::CgiRequest.new(cgi, session_options), ActionController::CgiResponse.new(cgi)
-        prepare_application
-        ActionController::Routing::Routes.recognize!(request).process(request, response).out(output)
-      end
-    rescue Object => exception
-      failsafe_response(output, '500 Internal Server Error') do
-        ActionController::Base.process_with_exception(request, response, exception).out(output)
-      end
-    ensure
-      # Do not give a failsafe response here.
-      reset_after_dispatch
-    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
-
-    private
-      # CGI.new plus exception handling.  CGI#read_multipart raises EOFError
-      # if body.empty? or body.size != Content-Length and raises ArgumentError
-      # if Content-Length is non-integer.
-      def new_cgi(output)
-        failsafe_response(output, '400 Bad Request') { CGI.new }
-      end
-
-      def prepare_application
-        ActionController::Routing::Routes.reload if Dependencies.load?
-        prepare_breakpoint
-        Controllers.const_load!(:ApplicationController, "application") unless Controllers.const_defined?(:ApplicationController)
-      end
-    
-      def reset_after_dispatch
-        reset_application! if Dependencies.load?
-        ActiveRecord::Base.clear_connection_cache!
-        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
-
-      # If the block raises, send status code as a last-ditch response.
-      def failsafe_response(output, status)
-        yield
-      rescue Object
-        begin
-          output.write "Status: #{status}\r\n"
-        rescue Object
-        end
-      end
-  end
-end
+require 'action_controller/dispatcher'
+Dispatcher = ActionController::Dispatcher

data/lib/fcgi_handler.rb

@@ -5,11 +5,13 @@ require 'rbconfig'
 
 class RailsFCGIHandler
   SIGNALS = {
-    'HUP'  => :reload,
-    'TERM' => :exit_now,
-    'USR1' => :exit,
-    'USR2' => :restart
+    'HUP'     => :reload,
+    'INT'     => :exit_now,
+    'TERM'    => :exit_now,
+    'USR1'    => :exit,
+    'USR2'    => :restart
   }
+  GLOBAL_SIGNALS = SIGNALS.keys - %w(USR1)
 
   attr_reader :when_ready
 
@@ -39,53 +41,72 @@ class RailsFCGIHandler
 
     # Start error timestamp at 11 seconds ago.
     @last_error_on = Time.now - 11
-
-    dispatcher_log :info, "starting"
   end
 
   def process!(provider = FCGI)
-    # Make a note of $" so we can safely reload this instance.
-    mark!
-
-    run_gc! if gc_request_period
-
-    provider.each_cgi do |cgi| 
-      process_request(cgi)
-
-      case when_ready
-        when :reload
-          reload!
-        when :restart
-          close_connection(cgi)
-          restart!
-        when :exit
-          close_connection(cgi)
-          break
+    mark_features!
+
+    dispatcher_log :info, 'starting'
+    process_each_request provider
+    dispatcher_log :info, 'stopping gracefully'
+
+  rescue Exception => error
+    case error
+    when SystemExit
+      dispatcher_log :info, 'stopping after explicit exit'
+    when SignalException
+      dispatcher_error error, 'stopping after unhandled signal'
+    else
+      # Retry if exceptions occur more than 10 seconds apart.
+      if Time.now - @last_error_on > 10
+        @last_error_on = Time.now
+        dispatcher_error error, 'retrying after unhandled exception'
+        retry
+      else
+        dispatcher_error error, 'stopping after unhandled exception within 10 seconds of the last'
       end
-
-      gc_countdown
     end
+  end
 
-    GC.enable
-    dispatcher_log :info, "terminated gracefully"
 
-  rescue SystemExit => exit_error
-    dispatcher_log :info, "terminated by explicit exit"
+  protected
+    def process_each_request(provider)
+      cgi = nil
 
-  rescue Object => fcgi_error
-    # retry on errors that would otherwise have terminated the FCGI process,
-    # but only if they occur more than 10 seconds apart.
-    if !(SignalException === fcgi_error) && Time.now - @last_error_on > 10
-      @last_error_on = Time.now
-      dispatcher_error(fcgi_error, "almost killed by this error")
-      retry
-    else
-      dispatcher_error(fcgi_error, "killed by this error")
+      provider.each_cgi do |cgi|
+        process_request(cgi)
+
+        case when_ready
+          when :reload
+            reload!
+          when :restart
+            close_connection(cgi)
+            restart!
+          when :exit
+            close_connection(cgi)
+            break
+        end
+      end
+    rescue SignalException => signal
+      raise unless signal.message == 'SIGUSR1'
+      close_connection(cgi)
     end
-  end
-  
-  
-  private
+
+    def process_request(cgi)
+      @when_ready = nil
+      gc_countdown
+
+      with_signal_handler 'USR1' do
+        begin
+          Dispatcher.dispatch(cgi)
+        rescue SignalException, SystemExit
+          raise
+        rescue Exception => error
+          dispatcher_error error, 'unhandled dispatch error'
+        end
+      end
+    end
+
     def logger
       @logger ||= Logger.new(@log_file_path)
     end
@@ -93,7 +114,7 @@ class RailsFCGIHandler
     def dispatcher_log(level, msg)
       time_str = Time.now.strftime("%d/%b/%Y:%H:%M:%S")
       logger.send(level, "[#{time_str} :: #{$$}] #{msg}")
-    rescue Object => log_error
+    rescue Exception => log_error  # Logger errors
       STDERR << "Couldn't write to #{@log_file_path.inspect}: #{msg}\n"
       STDERR << "  #{log_error.class}: #{log_error.message}\n"
     end
@@ -106,24 +127,37 @@ class RailsFCGIHandler
     end
 
     def install_signal_handlers
-      SIGNALS.each do |signal, handler_name|
-        install_signal_handler(signal, method("#{handler_name}_handler").to_proc)
+      GLOBAL_SIGNALS.each { |signal| install_signal_handler(signal) }
+    end
+
+    def install_signal_handler(signal, handler = nil)
+      if SIGNALS.include?(signal) && self.class.method_defined?(name = "#{SIGNALS[signal]}_handler")
+        handler ||= method(name).to_proc
+
+        begin
+          trap(signal, handler)
+        rescue ArgumentError
+          dispatcher_log :warn, "Ignoring unsupported signal #{signal}."
+        end
+      else
+        dispatcher_log :warn, "Ignoring unsupported signal #{signal}."
       end
     end
 
-    def install_signal_handler(signal, handler)
-      trap(signal, handler)
-    rescue ArgumentError
-      dispatcher_log :warn, "Ignoring unsupported signal #{signal}."
+    def with_signal_handler(signal)
+      install_signal_handler(signal)
+      yield
+    ensure
+      install_signal_handler(signal, 'DEFAULT')
     end
 
     def exit_now_handler(signal)
-      dispatcher_log :info, "asked to terminate immediately"
+      dispatcher_log :info, "asked to stop immediately"
       exit
     end
 
     def exit_handler(signal)
-      dispatcher_log :info, "asked to terminate ASAP"
+      dispatcher_log :info, "asked to stop ASAP"
       @when_ready = :exit
     end
 
@@ -137,20 +171,18 @@ class RailsFCGIHandler
       @when_ready = :restart
     end
 
-    def process_request(cgi)
-      Dispatcher.dispatch(cgi)
-    rescue Object => e
-      raise if SignalException === e
-      dispatcher_error(e)
-    end
-
     def restart!
       config       = ::Config::CONFIG
       ruby         = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
       command_line = [ruby, $0, ARGV].flatten.join(' ')
-      
+
       dispatcher_log :info, "restarted"
 
+      # close resources as they won't be closed by
+      # the OS when using exec
+      logger.close rescue nil
+      RAILS_DEFAULT_LOGGER.close rescue nil
+
       exec(command_line)
     end
 
@@ -161,7 +193,8 @@ class RailsFCGIHandler
       dispatcher_log :info, "reloaded"
     end
 
-    def mark!
+    # Make a note of $" so we can safely reload this instance.
+    def mark_features!
       @features = $".clone
     end
 
@@ -175,15 +208,16 @@ class RailsFCGIHandler
       @gc_request_countdown = gc_request_period
       GC.enable; GC.start; GC.disable
     end
-    
+
     def gc_countdown
       if gc_request_period
+        @gc_request_countdown ||= gc_request_period
         @gc_request_countdown -= 1
         run_gc! if @gc_request_countdown <= 0
       end
     end
-    
+
     def close_connection(cgi)
-      cgi.instance_variable_get("@request").finish
+      cgi.instance_variable_get("@request").finish if cgi
     end
-end
+end