rails 1.0.0 → 7.0.0

data/lib/commands/process/reaper.rb

@@ -1,130 +0,0 @@
-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 =~ /inq|ps axww|grep|spawn-fcgi|spawner|reaper/
-        pid, *command = line.split
-        new(pid, command.join(" "))
-      }.compact
-    end
-
-    private
-      def process_lines_with_keyword(keyword)
-        `ps axww -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

@@ -1,52 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,28 +0,0 @@
-require 'active_support'
-
-begin
-  require_library_or_gem 'fcgi'
-rescue Exception
-  # FCGI not available
-end
-
-server = case ARGV.first
-  when "lighttpd"
-    ARGV.shift
-  when "webrick"
-    ARGV.shift
-  else
-    if 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)"
-end
-
-require "commands/servers/#{server}"

data/lib/commands/servers/lighttpd.rb

@@ -1,60 +0,0 @@
-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
-end
-
-unless defined?(FCGI)
-  puts "PROBLEM: Lighttpd requires that the FCGI Ruby bindings are installed on the system"
-  exit 1
-end
-
-require 'initializer'
-configuration = Rails::Initializer.run(:initialize_logger).configuration
-
-config_file = "#{RAILS_ROOT}/config/lighttpd.conf"
-
-unless File.exist?(config_file)
-  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
-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}"
-
-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)"
-  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
-end
-
-trap(:INT) { exit }
-`lighttpd #{!detach ? "-D " : ""}-f #{config_file}`
-tail_thread.kill if tail_thread

data/lib/commands/servers/webrick.rb

@@ -1,59 +0,0 @@
-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/lib/commands/update.rb

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

data/lib/commands.rb

@@ -1,17 +0,0 @@
-commands = Dir["#{File.dirname(__FILE__)}/commands/*.rb"].collect { |file_path| File.basename(file_path).split(".").first }
-
-if commands.include?(ARGV.first)
-  require "#{File.dirname(__FILE__)}/commands/#{ARGV.shift}"
-else
-  puts <<-USAGE
-The 'run' provides a unified access point for all the default Rails' commands.
-  
-Usage: ./script/run <command> [OPTIONS]
-
-Examples:
-  ./script/run generate controller Admin
-  ./script/run process reaper
-
-USAGE
-  puts "Choose: #{commands.join(", ")}"
-end

data/lib/console_sandbox.rb

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

data/lib/dispatcher.rb

@@ -1,99 +0,0 @@
-#--
-# Copyright (c) 2004 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.
-#++
-
-# 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