rails_csi 2.3.5.p6

data/lib/commands/runner.rb

@@ -0,0 +1,54 @@
+require 'optparse'
+
+options = { :environment => (ENV['RAILS_ENV'] || "development").dup }
+code_or_file = nil
+
+ARGV.clone.options do |opts|
+  script_name = File.basename($0)
+  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") { |v| options[:environment] = v }
+
+  opts.separator ""
+
+  opts.on("-h", "--help",
+          "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'
+
+begin
+  if code_or_file.nil?
+    $stderr.puts "Run '#{$0} -h' for help."
+    exit 1
+  elsif File.exist?(code_or_file)
+    eval(File.read(code_or_file), nil, code_or_file)
+  else
+    eval(code_or_file)
+  end
+ensure
+  if defined? Rails
+    Rails.logger.flush if Rails.logger.respond_to?(:flush)
+  end
+end

data/lib/commands/server.rb

@@ -0,0 +1,114 @@
+require 'active_support'
+require 'action_controller'
+
+require 'fileutils'
+require 'optparse'
+
+# TODO: Push Thin adapter upstream so we don't need worry about requiring it
+begin
+  require_library_or_gem 'thin'
+rescue Exception
+  # Thin not available
+end
+
+options = {
+  :Port        => 3000,
+  :Host        => "0.0.0.0",
+  :environment => (ENV['RAILS_ENV'] || "development").dup,
+  :config      => RAILS_ROOT + "/config.ru",
+  :detach      => false,
+  :debugger    => false,
+  :path        => nil
+}
+
+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[:Host] = v }
+  opts.on("-c", "--config=file", String,
+          "Use custom rackup configuration file") { |v| options[:config] = 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.on("-P", "--path=/path", String, "Runs Rails app mounted at a specific path.", "Default: /") { |v| options[:path] = v }
+
+  opts.separator ""
+
+  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+server = Rack::Handler.get(ARGV.first) rescue nil
+unless server
+  begin
+    server = Rack::Handler::Mongrel
+  rescue LoadError => e
+    server = Rack::Handler::WEBrick
+  end
+end
+
+puts "=> Booting #{ActiveSupport::Inflector.demodulize(server)}"
+puts "=> Rails #{Rails.version} application starting on http://#{options[:Host]}:#{options[:Port]}#{options[:path]}"
+
+%w(cache pids sessions sockets).each do |dir_to_make|
+  FileUtils.mkdir_p(File.join(RAILS_ROOT, 'tmp', dir_to_make))
+end
+
+if options[:detach]
+  Process.daemon
+  pid = "#{RAILS_ROOT}/tmp/pids/server.pid"
+  File.open(pid, 'w'){ |f| f.write(Process.pid) }
+  at_exit { File.delete(pid) if File.exist?(pid) }
+end
+
+ENV["RAILS_ENV"] = options[:environment]
+RAILS_ENV.replace(options[:environment]) if defined?(RAILS_ENV)
+
+if File.exist?(options[:config])
+  config = options[:config]
+  if config =~ /\.ru$/
+    cfgfile = File.read(config)
+    if cfgfile[/^#\\(.*)/]
+      opts.parse!($1.split(/\s+/))
+    end
+    inner_app = eval("Rack::Builder.new {( " + cfgfile + "\n )}.to_app", nil, config)
+  else
+    require config
+    inner_app = Object.const_get(File.basename(config, '.rb').capitalize)
+  end
+else
+  require RAILS_ROOT + "/config/environment"
+  inner_app = ActionController::Dispatcher.new
+end
+
+if options[:path].nil?
+  map_path = "/"
+else
+  ActionController::Base.relative_url_root = options[:path]
+  map_path = options[:path]
+end
+
+app = Rack::Builder.new {
+  use Rails::Rack::LogTailer unless options[:detach]
+  use Rails::Rack::Debugger if options[:debugger]
+  map map_path do
+    use Rails::Rack::Static 
+    run inner_app
+  end
+}.to_app
+
+puts "=> Call with -d to detach"
+
+trap(:INT) { exit }
+
+puts "=> Ctrl-C to shutdown server"
+
+begin
+  server.run(app, options.merge(:AccessLog => []))
+ensure
+  puts 'Exiting'
+end

data/lib/commands/update.rb

@@ -0,0 +1,4 @@
+require "#{RAILS_ROOT}/config/environment"
+require 'rails_generator'
+require 'rails_generator/scripts/update'
+Rails::Generator::Scripts::Update.new.run(ARGV)

data/lib/console_app.rb

@@ -0,0 +1,30 @@
+require 'active_support/test_case'
+require 'action_controller'
+
+# 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.cleanup_application
+  Dispatcher.reload_application
+  true
+end

data/lib/console_sandbox.rb

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

data/lib/console_with_helpers.rb

@@ -0,0 +1,5 @@
+def helper
+  @helper ||= ApplicationController.helpers
+end
+
+@controller = ApplicationController.new

data/lib/dispatcher.rb

@@ -0,0 +1,24 @@
+#--
+# Copyright (c) 2004-2009 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+require 'action_controller/dispatcher'
+Dispatcher = ActionController::Dispatcher

data/lib/fcgi_handler.rb

@@ -0,0 +1,239 @@
+require 'fcgi'
+require 'logger'
+require 'dispatcher'
+require 'rbconfig'
+
+class RailsFCGIHandler
+  SIGNALS = {
+    'HUP'     => :reload,
+    'INT'     => :exit_now,
+    'TERM'    => :exit_now,
+    'USR1'    => :exit,
+    'USR2'    => :restart
+  }
+  GLOBAL_SIGNALS = SIGNALS.keys - %w(USR1)
+
+  attr_reader :when_ready
+
+  attr_accessor :log_file_path
+  attr_accessor :gc_request_period
+
+  # Initialize and run the FastCGI instance, passing arguments through to new.
+  def self.process!(*args, &block)
+    new(*args, &block).process!
+  end
+
+  # Initialize the FastCGI instance with the path to a crash log
+  # detailing unhandled exceptions (default RAILS_ROOT/log/fastcgi.crash.log)
+  # and the number of requests to process between garbage collection runs
+  # (default nil for normal GC behavior.)  Optionally, pass a block which
+  # takes this instance as an argument for further configuration.
+  def initialize(log_file_path = nil, gc_request_period = nil)
+    self.log_file_path = log_file_path || "#{RAILS_ROOT}/log/fastcgi.crash.log"
+    self.gc_request_period = gc_request_period
+
+    # Yield for additional configuration.
+    yield self if block_given?
+
+    # Safely install signal handlers.
+    install_signal_handlers
+
+    @app = Dispatcher.new
+
+    # Start error timestamp at 11 seconds ago.
+    @last_error_on = Time.now - 11
+  end
+
+  def process!(provider = FCGI)
+    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
+    end
+  end
+
+  protected
+    def process_each_request(provider)
+      request = nil
+
+      catch :exit do
+        provider.each do |request|
+          process_request(request)
+
+          case when_ready
+            when :reload
+              reload!
+            when :restart
+              close_connection(request)
+              restart!
+            when :exit
+              close_connection(request)
+              throw :exit
+          end
+        end
+      end
+    rescue SignalException => signal
+      raise unless signal.message == 'SIGUSR1'
+      close_connection(request)
+    end
+
+    def process_request(request)
+      @processing, @when_ready = true, nil
+      gc_countdown
+
+      with_signal_handler 'USR1' do
+        begin
+          ::Rack::Handler::FastCGI.serve(request, @app)
+        rescue SignalException, SystemExit
+          raise
+        rescue Exception => error
+          dispatcher_error error, 'unhandled dispatch error'
+        end
+      end
+    ensure
+      @processing = false
+    end
+
+    def logger
+      @logger ||= Logger.new(@log_file_path)
+    end
+
+    def dispatcher_log(level, msg)
+      time_str = Time.now.strftime("%d/%b/%Y:%H:%M:%S")
+      logger.send(level, "[#{time_str} :: #{$$}] #{msg}")
+    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
+
+    def dispatcher_error(e, msg = "")
+      error_message =
+        "Dispatcher failed to catch: #{e} (#{e.class})\n" +
+        "  #{e.backtrace.join("\n  ")}\n#{msg}"
+      dispatcher_log(:error, error_message)
+    end
+
+    def install_signal_handlers
+      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 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 stop immediately"
+      exit
+    end
+
+    def exit_handler(signal)
+      dispatcher_log :info, "asked to stop ASAP"
+      if @processing
+        @when_ready = :exit
+      else
+        throw :exit
+      end
+    end
+
+    def reload_handler(signal)
+      dispatcher_log :info, "asked to reload ASAP"
+      if @processing
+        @when_ready = :reload
+      else
+        reload!
+      end
+    end
+
+    def restart_handler(signal)
+      dispatcher_log :info, "asked to restart ASAP"
+      if @processing
+        @when_ready = :restart
+      else
+        restart!
+      end
+    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.logger.close rescue nil
+
+      exec(command_line)
+    end
+
+    def reload!
+      run_gc! if gc_request_period
+      restore!
+      @when_ready = nil
+      dispatcher_log :info, "reloaded"
+    end
+
+    # Make a note of $" so we can safely reload this instance.
+    def mark_features!
+      @features = $".clone
+    end
+
+    def restore!
+      $".replace @features
+      Dispatcher.reset_application!
+      ActionController::Routing::Routes.reload
+    end
+
+    def run_gc!
+      @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(request)
+      request.finish if request
+    end
+end