Instiki 0.16.3: Rails 2.3.0
Instiki now runs on the Rails 2.3.0 Candidate Release.
Among other improvements, this means that it now
automagically selects between WEBrick and Mongrel.
Just run
./instiki --daemon
This commit is contained in:
Jacques Distler
parent
43aadecc99
commit
4e14ccc74d
893 changed files with 71965 additions and 28511 deletions
2
vendor/rails/railties/lib/commands/about.rb
vendored
2
vendor/rails/railties/lib/commands/about.rb
vendored
|
|
@ -1,3 +1,3 @@
|
|||
require 'environment'
|
||||
require "#{RAILS_ROOT}/config/environment"
|
||||
require 'rails/info'
|
||||
puts Rails::Info
|
||||
|
|
|
|||
20
vendor/rails/railties/lib/commands/dbconsole.rb
vendored
20
vendor/rails/railties/lib/commands/dbconsole.rb
vendored
|
|
@ -3,12 +3,23 @@ require 'yaml'
|
|||
require 'optparse'
|
||||
|
||||
include_password = false
|
||||
options = {}
|
||||
|
||||
OptionParser.new do |opt|
|
||||
opt.banner = "Usage: dbconsole [options] [environment]"
|
||||
opt.on("-p", "--include-password", "Automatically provide the password from database.yml") do |v|
|
||||
include_password = true
|
||||
end
|
||||
|
||||
opt.on("--mode [MODE]", ['html', 'list', 'line', 'column'],
|
||||
"Automatically put the sqlite3 database in the specified mode (html, list, line, column).") do |mode|
|
||||
options['mode'] = mode
|
||||
end
|
||||
|
||||
opt.on("-h", "--header") do |h|
|
||||
options['header'] = h
|
||||
end
|
||||
|
||||
opt.parse!(ARGV)
|
||||
abort opt.to_s unless (0..1).include?(ARGV.size)
|
||||
end
|
||||
|
|
@ -41,7 +52,7 @@ when "mysql"
|
|||
|
||||
if config['password'] && include_password
|
||||
args << "--password=#{config['password']}"
|
||||
elsif config['password'] && !config['password'].empty?
|
||||
elsif config['password'] && !config['password'].to_s.empty?
|
||||
args << "-p"
|
||||
end
|
||||
|
||||
|
|
@ -60,8 +71,13 @@ when "sqlite"
|
|||
exec(find_cmd('sqlite'), config["database"])
|
||||
|
||||
when "sqlite3"
|
||||
exec(find_cmd('sqlite3'), config["database"])
|
||||
args = []
|
||||
|
||||
args << "-#{options['mode']}" if options['mode']
|
||||
args << "-header" if options['header']
|
||||
args << config['database']
|
||||
|
||||
exec(find_cmd('sqlite3'), *args)
|
||||
else
|
||||
abort "Unknown command-line client for #{config['database']}. Submit a Rails patch to add support!"
|
||||
end
|
||||
|
|
|
|||
|
|
@ -1,6 +0,0 @@
|
|||
#!/usr/bin/env ruby
|
||||
require 'config/environment'
|
||||
require 'application'
|
||||
require 'action_controller/request_profiler'
|
||||
|
||||
ActionController::RequestProfiler.run(ARGV)
|
||||
|
|
@ -1,68 +0,0 @@
|
|||
require 'optparse'
|
||||
|
||||
if RUBY_PLATFORM =~ /(:?mswin|mingw)/ then abort("Inspector is only for Unix") end
|
||||
|
||||
OPTIONS = {
|
||||
:pid_path => File.expand_path(RAILS_ROOT + '/tmp/pids'),
|
||||
:pattern => "dispatch.*.pid",
|
||||
:ps => "ps -o pid,state,user,start,time,pcpu,vsz,majflt,command -p %s"
|
||||
}
|
||||
|
||||
class Inspector
|
||||
def self.inspect(pid_path, pattern)
|
||||
new(pid_path, pattern).inspect
|
||||
end
|
||||
|
||||
def initialize(pid_path, pattern)
|
||||
@pid_path, @pattern = pid_path, pattern
|
||||
end
|
||||
|
||||
def inspect
|
||||
header = `#{OPTIONS[:ps] % 1}`.split("\n")[0] + "\n"
|
||||
lines = pids.collect { |pid| `#{OPTIONS[:ps] % pid}`.split("\n")[1] }
|
||||
|
||||
puts(header + lines.join("\n"))
|
||||
end
|
||||
|
||||
private
|
||||
def pids
|
||||
pid_files.collect do |pid_file|
|
||||
File.read(pid_file).to_i
|
||||
end
|
||||
end
|
||||
|
||||
def pid_files
|
||||
Dir.glob(@pid_path + "/" + @pattern)
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
ARGV.options do |opts|
|
||||
opts.banner = "Usage: inspector [options]"
|
||||
|
||||
opts.separator ""
|
||||
|
||||
opts.on <<-EOF
|
||||
Description:
|
||||
Displays system information about Rails dispatchers (or other processes that use pid files) through
|
||||
the ps command.
|
||||
|
||||
Examples:
|
||||
inspector # default ps on all tmp/pids/dispatch.*.pid files
|
||||
inspector -s 'ps -o user,start,majflt,pcpu,vsz -p %s' # custom ps, %s is where the pid is interleaved
|
||||
EOF
|
||||
|
||||
opts.on(" Options:")
|
||||
|
||||
opts.on("-s", "--ps=command", "default: #{OPTIONS[:ps]}", String) { |v| OPTIONS[:ps] = v }
|
||||
opts.on("-p", "--pidpath=path", "default: #{OPTIONS[:pid_path]}", String) { |v| OPTIONS[:pid_path] = v }
|
||||
opts.on("-r", "--pattern=pattern", "default: #{OPTIONS[:pattern]}", String) { |v| OPTIONS[:pattern] = v }
|
||||
|
||||
opts.separator ""
|
||||
|
||||
opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
|
||||
|
||||
opts.parse!
|
||||
end
|
||||
|
||||
Inspector.inspect(OPTIONS[:pid_path], OPTIONS[:pattern])
|
||||
149
vendor/rails/railties/lib/commands/process/reaper.rb
vendored
149
vendor/rails/railties/lib/commands/process/reaper.rb
vendored
|
|
@ -1,149 +0,0 @@
|
|||
require 'optparse'
|
||||
require 'net/http'
|
||||
require 'uri'
|
||||
|
||||
if RUBY_PLATFORM =~ /(:?mswin|mingw)/ then abort("Reaper is only for Unix") end
|
||||
|
||||
class Killer
|
||||
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:
|
||||
#
|
||||
# Killer.process(:reload, "/tmp/pids", "dispatcher.*.pid")
|
||||
def process(action, pid_path, pattern, keyword)
|
||||
new(pid_path, pattern, keyword).process(action)
|
||||
end
|
||||
|
||||
# Forces the (rails) application to reload by sending a +HUP+ signal to the
|
||||
# process.
|
||||
def reload(pid)
|
||||
`kill -s HUP #{pid}`
|
||||
end
|
||||
|
||||
# Force the (rails) application to restart by sending a +USR2+ signal to the
|
||||
# process.
|
||||
def restart(pid)
|
||||
`kill -s USR2 #{pid}`
|
||||
end
|
||||
|
||||
# Forces the (rails) application to gracefully terminate by sending a
|
||||
# +TERM+ signal to the process.
|
||||
def graceful(pid)
|
||||
`kill -s TERM #{pid}`
|
||||
end
|
||||
|
||||
# Forces the (rails) application to terminate immediately by sending a -9
|
||||
# signal to the process.
|
||||
def kill(pid)
|
||||
`kill -9 #{pid}`
|
||||
end
|
||||
|
||||
# Send a +USR1+ signal to the process.
|
||||
def usr1(pid)
|
||||
`kill -s USR1 #{pid}`
|
||||
end
|
||||
end
|
||||
|
||||
def initialize(pid_path, pattern, keyword=nil)
|
||||
@pid_path, @pattern, @keyword = pid_path, pattern, keyword
|
||||
end
|
||||
|
||||
def process(action)
|
||||
pids = find_processes
|
||||
|
||||
if pids.empty?
|
||||
warn "Couldn't find any pid file in '#{@pid_path}' matching '#{@pattern}'"
|
||||
warn "(also looked for processes matching #{@keyword.inspect})" if @keyword
|
||||
else
|
||||
pids.each do |pid|
|
||||
puts "#{action.capitalize}ing #{pid}"
|
||||
self.class.send(action, pid)
|
||||
end
|
||||
|
||||
delete_pid_files if terminating?(action)
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
def terminating?(action)
|
||||
[ "kill", "graceful" ].include?(action)
|
||||
end
|
||||
|
||||
def find_processes
|
||||
files = pid_files
|
||||
if files.empty?
|
||||
find_processes_via_grep
|
||||
else
|
||||
files.collect { |pid_file| File.read(pid_file).to_i }
|
||||
end
|
||||
end
|
||||
|
||||
def find_processes_via_grep
|
||||
lines = `ps axww -o 'pid command' | grep #{@keyword}`.split(/\n/).
|
||||
reject { |line| line =~ /inq|ps axww|grep|spawn-fcgi|spawner|reaper/ }
|
||||
lines.map { |line| line[/^\s*(\d+)/, 1].to_i }
|
||||
end
|
||||
|
||||
def delete_pid_files
|
||||
pid_files.each { |pid_file| File.delete(pid_file) }
|
||||
end
|
||||
|
||||
def pid_files
|
||||
Dir.glob(@pid_path + "/" + @pattern)
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
OPTIONS = {
|
||||
:action => "restart",
|
||||
:pid_path => File.expand_path(RAILS_ROOT + '/tmp/pids'),
|
||||
:pattern => "dispatch.[0-9]*.pid",
|
||||
: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 processes
|
||||
running a Rails Dispatcher (or any other process responding to the same signals). 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.
|
||||
|
||||
It uses pid files to work on the processes and by default assume them to be located
|
||||
in RAILS_ROOT/tmp/pids.
|
||||
|
||||
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 dispatchers
|
||||
reaper -a reload # reload the default dispatchers
|
||||
reaper -a kill -r *.pid # kill all processes that keep pids in tmp/pids
|
||||
EOF
|
||||
|
||||
opts.on(" Options:")
|
||||
|
||||
opts.on("-a", "--action=name", "reload|graceful|kill (default: #{OPTIONS[:action]})", String) { |v| OPTIONS[:action] = v }
|
||||
opts.on("-p", "--pidpath=path", "default: #{OPTIONS[:pid_path]}", String) { |v| OPTIONS[:pid_path] = v }
|
||||
opts.on("-r", "--pattern=pattern", "default: #{OPTIONS[:pattern]}", String) { |v| OPTIONS[:pattern] = v }
|
||||
opts.on("-d", "--dispatcher=path", "DEPRECATED. default: #{OPTIONS[:dispatcher]}", String) { |v| OPTIONS[:dispatcher] = v }
|
||||
|
||||
opts.separator ""
|
||||
|
||||
opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
|
||||
|
||||
opts.parse!
|
||||
end
|
||||
|
||||
Killer.process(OPTIONS[:action], OPTIONS[:pid_path], OPTIONS[:pattern], OPTIONS[:dispatcher])
|
||||
|
|
@ -1,219 +0,0 @@
|
|||
require 'active_support'
|
||||
require 'optparse'
|
||||
require 'socket'
|
||||
require 'fileutils'
|
||||
|
||||
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
|
||||
|
||||
class Spawner
|
||||
def self.record_pid(name = "#{OPTIONS[:process]}.spawner", id = Process.pid)
|
||||
FileUtils.mkdir_p(OPTIONS[:pids])
|
||||
File.open(File.expand_path(OPTIONS[:pids] + "/#{name}.pid"), "w+") { |f| f.write(id) }
|
||||
end
|
||||
|
||||
def self.spawn_all
|
||||
OPTIONS[:instances].times do |i|
|
||||
port = OPTIONS[:port] + i
|
||||
print "Checking if something is already running on #{OPTIONS[:address]}:#{port}..."
|
||||
|
||||
begin
|
||||
srv = TCPServer.new(OPTIONS[:address], port)
|
||||
srv.close
|
||||
srv = nil
|
||||
|
||||
puts "NO"
|
||||
puts "Starting dispatcher on port: #{OPTIONS[:address]}:#{port}"
|
||||
|
||||
FileUtils.mkdir_p(OPTIONS[:pids])
|
||||
spawn(port)
|
||||
rescue
|
||||
puts "YES"
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class FcgiSpawner < Spawner
|
||||
def self.spawn(port)
|
||||
cmd = "#{OPTIONS[:spawner]} -f #{OPTIONS[:dispatcher]} -p #{port} -P #{OPTIONS[:pids]}/#{OPTIONS[:process]}.#{port}.pid"
|
||||
cmd << " -a #{OPTIONS[:address]}" if can_bind_to_custom_address?
|
||||
system(cmd)
|
||||
end
|
||||
|
||||
def self.can_bind_to_custom_address?
|
||||
@@can_bind_to_custom_address ||= /^\s-a\s/.match `#{OPTIONS[:spawner]} -h`
|
||||
end
|
||||
end
|
||||
|
||||
class MongrelSpawner < Spawner
|
||||
def self.spawn(port)
|
||||
cmd =
|
||||
"mongrel_rails start -d " +
|
||||
"-a #{OPTIONS[:address]} " +
|
||||
"-p #{port} " +
|
||||
"-P #{OPTIONS[:pids]}/#{OPTIONS[:process]}.#{port}.pid " +
|
||||
"-e #{OPTIONS[:environment]} " +
|
||||
"-c #{OPTIONS[:rails_root]} " +
|
||||
"-l #{OPTIONS[:rails_root]}/log/mongrel.log"
|
||||
|
||||
# Add prefix functionality to spawner's call to mongrel_rails
|
||||
# Digging through mongrel's project subversion server, the earliest
|
||||
# Tag that has prefix implemented in the bin/mongrel_rails file
|
||||
# is 0.3.15 which also happens to be the earliest tag listed.
|
||||
# References: http://mongrel.rubyforge.org/svn/tags
|
||||
if Mongrel::Const::MONGREL_VERSION.to_f >=0.3 && !OPTIONS[:prefix].nil?
|
||||
cmd = cmd + " --prefix #{OPTIONS[:prefix]}"
|
||||
end
|
||||
system(cmd)
|
||||
end
|
||||
|
||||
def self.can_bind_to_custom_address?
|
||||
true
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
begin
|
||||
require_library_or_gem 'fcgi'
|
||||
rescue Exception
|
||||
# FCGI not available
|
||||
end
|
||||
|
||||
begin
|
||||
require_library_or_gem 'mongrel'
|
||||
rescue Exception
|
||||
# Mongrel not available
|
||||
end
|
||||
|
||||
server = case ARGV.first
|
||||
when "fcgi", "mongrel"
|
||||
ARGV.shift
|
||||
else
|
||||
if defined?(Mongrel)
|
||||
"mongrel"
|
||||
elsif RUBY_PLATFORM !~ /(:?mswin|mingw)/ && !silence_stderr { `spawn-fcgi -version` }.blank? && defined?(FCGI)
|
||||
"fcgi"
|
||||
end
|
||||
end
|
||||
|
||||
case server
|
||||
when "fcgi"
|
||||
puts "=> Starting FCGI dispatchers"
|
||||
spawner_class = FcgiSpawner
|
||||
when "mongrel"
|
||||
puts "=> Starting mongrel dispatchers"
|
||||
spawner_class = MongrelSpawner
|
||||
else
|
||||
puts "Neither FCGI (spawn-fcgi) nor Mongrel was installed and available!"
|
||||
exit(0)
|
||||
end
|
||||
|
||||
|
||||
|
||||
OPTIONS = {
|
||||
:environment => "production",
|
||||
:spawner => '/usr/bin/env spawn-fcgi',
|
||||
:dispatcher => File.expand_path(RELATIVE_RAILS_ROOT + '/public/dispatch.fcgi'),
|
||||
:pids => File.expand_path(RELATIVE_RAILS_ROOT + "/tmp/pids"),
|
||||
:rails_root => File.expand_path(RELATIVE_RAILS_ROOT),
|
||||
:process => "dispatch",
|
||||
:port => 8000,
|
||||
:address => '0.0.0.0',
|
||||
:instances => 3,
|
||||
:repeat => nil,
|
||||
:prefix => nil
|
||||
}
|
||||
|
||||
ARGV.options do |opts|
|
||||
opts.banner = "Usage: spawner [platform] [options]"
|
||||
|
||||
opts.separator ""
|
||||
|
||||
opts.on <<-EOF
|
||||
Description:
|
||||
The spawner is a wrapper for spawn-fcgi and mongrel that makes it
|
||||
easier to start multiple 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). Mongrel automatically
|
||||
ships with with mongrel_rails for starting dispatchers.
|
||||
|
||||
The first choice you need to make is whether to spawn the Rails
|
||||
dispatchers as FCGI or Mongrel. By default, this spawner will prefer
|
||||
Mongrel, so if that's installed, and no platform choice is made,
|
||||
Mongrel is used.
|
||||
|
||||
Then 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.
|
||||
|
||||
You can select bind address for started processes. By default these
|
||||
listen on every interface. For single machine installations you would
|
||||
probably want to use 127.0.0.1, hiding them form the outside world.
|
||||
|
||||
Examples:
|
||||
spawner # starts instances on 8000, 8001, and 8002
|
||||
# using Mongrel if available.
|
||||
spawner fcgi # starts instances on 8000, 8001, and 8002
|
||||
# using FCGI.
|
||||
spawner mongrel -i 5 # starts instances on 8000, 8001, 8002,
|
||||
# 8003, and 8004 using Mongrel.
|
||||
spawner -p 9100 -i 10 # starts 10 instances counting from 9100 to
|
||||
# 9109 using Mongrel if available.
|
||||
spawner -p 9100 -r 5 # starts 3 instances counting from 9100 to
|
||||
# 9102 and attempts start them every 5
|
||||
# seconds.
|
||||
spawner -a 127.0.0.1 # starts 3 instances binding to localhost
|
||||
EOF
|
||||
|
||||
opts.on(" Options:")
|
||||
|
||||
opts.on("-p", "--port=number", Integer, "Starting port number (default: #{OPTIONS[:port]})") { |v| OPTIONS[:port] = v }
|
||||
|
||||
if spawner_class.can_bind_to_custom_address?
|
||||
opts.on("-a", "--address=ip", String, "Bind to IP address (default: #{OPTIONS[:address]})") { |v| OPTIONS[:address] = v }
|
||||
end
|
||||
|
||||
opts.on("-p", "--port=number", Integer, "Starting port number (default: #{OPTIONS[:port]})") { |v| OPTIONS[:port] = v }
|
||||
opts.on("-i", "--instances=number", Integer, "Number of instances (default: #{OPTIONS[:instances]})") { |v| OPTIONS[:instances] = v }
|
||||
opts.on("-r", "--repeat=seconds", Integer, "Repeat spawn attempts every n seconds (default: off)") { |v| OPTIONS[:repeat] = v }
|
||||
opts.on("-e", "--environment=name", String, "test|development|production (default: #{OPTIONS[:environment]})") { |v| OPTIONS[:environment] = v }
|
||||
opts.on("-P", "--prefix=path", String, "URL prefix for Rails app. [Used only with Mongrel > v0.3.15]: (default: #{OPTIONS[:prefix]})") { |v| OPTIONS[:prefix] = v }
|
||||
opts.on("-n", "--process=name", String, "default: #{OPTIONS[:process]}") { |v| OPTIONS[:process] = v }
|
||||
opts.on("-s", "--spawner=path", String, "default: #{OPTIONS[:spawner]}") { |v| OPTIONS[:spawner] = v }
|
||||
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]
|
||||
|
||||
if OPTIONS[:repeat]
|
||||
daemonize
|
||||
trap("TERM") { exit }
|
||||
spawner_class.record_pid
|
||||
|
||||
loop do
|
||||
spawner_class.spawn_all
|
||||
sleep(OPTIONS[:repeat])
|
||||
end
|
||||
else
|
||||
spawner_class.spawn_all
|
||||
end
|
||||
|
|
@ -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) { |v| OPTIONS[:command] = v }
|
||||
opts.on("-i", "--interval=seconds", Float) { |v| OPTIONS[:interval] = v }
|
||||
opts.on("-d", "--daemon") { |v| OPTIONS[:daemon] = v }
|
||||
|
||||
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
|
||||
20
vendor/rails/railties/lib/commands/runner.rb
vendored
20
vendor/rails/railties/lib/commands/runner.rb
vendored
|
|
@ -38,11 +38,17 @@ RAILS_ENV.replace(options[:environment]) if defined?(RAILS_ENV)
|
|||
|
||||
require RAILS_ROOT + '/config/environment'
|
||||
|
||||
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)
|
||||
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
|
||||
|
|
|
|||
126
vendor/rails/railties/lib/commands/server.rb
vendored
126
vendor/rails/railties/lib/commands/server.rb
vendored
|
|
@ -1,49 +1,103 @@
|
|||
require 'active_support'
|
||||
require 'action_controller'
|
||||
|
||||
require 'fileutils'
|
||||
require 'optparse'
|
||||
|
||||
begin
|
||||
require_library_or_gem 'fcgi'
|
||||
rescue Exception
|
||||
# FCGI not available
|
||||
end
|
||||
|
||||
begin
|
||||
require_library_or_gem 'mongrel'
|
||||
rescue Exception
|
||||
# Mongrel not available
|
||||
end
|
||||
|
||||
# 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
|
||||
|
||||
server = case ARGV.first
|
||||
when "lighttpd", "mongrel", "new_mongrel", "webrick", "thin"
|
||||
ARGV.shift
|
||||
else
|
||||
if defined?(Mongrel)
|
||||
"mongrel"
|
||||
elsif defined?(Thin)
|
||||
"thin"
|
||||
elsif RUBY_PLATFORM !~ /(:?mswin|mingw)/ && !silence_stderr { `lighttpd -version` }.blank? && defined?(FCGI)
|
||||
"lighttpd"
|
||||
else
|
||||
"webrick"
|
||||
options = {
|
||||
:Port => 3000,
|
||||
:Host => "0.0.0.0",
|
||||
:environment => (ENV['RAILS_ENV'] || "development").dup,
|
||||
:config => RAILS_ROOT + "/config.ru",
|
||||
: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[: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.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]}"
|
||||
|
||||
%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
|
||||
|
||||
case server
|
||||
when "webrick"
|
||||
puts "=> Booting WEBrick..."
|
||||
when "lighttpd"
|
||||
puts "=> Booting lighttpd (use 'script/server webrick' to force WEBrick)"
|
||||
when "mongrel", "new_mongrel"
|
||||
puts "=> Booting Mongrel (use 'script/server webrick' to force WEBrick)"
|
||||
when "thin"
|
||||
puts "=> Booting Thin (use 'script/server webrick' to force WEBrick)"
|
||||
end
|
||||
app = Rack::Builder.new {
|
||||
use Rails::Rack::LogTailer unless options[:detach]
|
||||
use Rails::Rack::Static
|
||||
use Rails::Rack::Debugger if options[:debugger]
|
||||
run inner_app
|
||||
}.to_app
|
||||
|
||||
%w(cache pids sessions sockets).each { |dir_to_make| FileUtils.mkdir_p(File.join(RAILS_ROOT, 'tmp', dir_to_make)) }
|
||||
require "commands/servers/#{server}"
|
||||
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
|
||||
|
|
|
|||
|
|
@ -1,31 +0,0 @@
|
|||
def tail(log_file)
|
||||
cursor = File.size(log_file)
|
||||
last_checked = Time.now
|
||||
tail_thread = Thread.new do
|
||||
File.open(log_file, '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
|
||||
tail_thread
|
||||
end
|
||||
|
||||
def start_debugger
|
||||
begin
|
||||
require_library_or_gem 'ruby-debug'
|
||||
Debugger.start
|
||||
Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
|
||||
puts "=> Debugger enabled"
|
||||
rescue Exception
|
||||
puts "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
|
||||
exit
|
||||
end
|
||||
end
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
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
|
||||
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
|
||||
default_config_file = config_file = Pathname.new("#{RAILS_ROOT}/config/lighttpd.conf").cleanpath
|
||||
|
||||
require 'optparse'
|
||||
|
||||
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)
|
||||
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 #{Rails.version} application starting on http://#{ip || default_ip}:#{port || default_port}"
|
||||
|
||||
tail_thread = nil
|
||||
|
||||
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
|
||||
|
||||
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
|
||||
|
|
@ -1,69 +0,0 @@
|
|||
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 #{Rails.version} 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]
|
||||
|
||||
puts "=> Call with -d to detach"
|
||||
puts "=> Ctrl-C to shutdown server"
|
||||
|
||||
log = Pathname.new("#{File.expand_path(RAILS_ROOT)}/log/#{RAILS_ENV}.log").cleanpath
|
||||
open(log, (File::WRONLY | File::APPEND | File::CREAT)) unless File.exist? log
|
||||
tail_thread = tail(log)
|
||||
|
||||
trap(:INT) { exit }
|
||||
|
||||
begin
|
||||
silence_warnings { ARGV = parameters }
|
||||
load("mongrel_rails")
|
||||
ensure
|
||||
tail_thread.kill if tail_thread
|
||||
puts 'Exiting'
|
||||
end
|
||||
end
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
unless defined?(Mongrel)
|
||||
abort "PROBLEM: Mongrel is not available on your system (or not in your path)"
|
||||
end
|
||||
|
||||
require 'rails/mongrel_server/commands'
|
||||
|
||||
GemPlugin::Manager.instance.load "rails::mongrel" => GemPlugin::INCLUDE, "rails" => GemPlugin::EXCLUDE
|
||||
|
||||
case ARGV[0] ||= 'start'
|
||||
when 'start', 'stop', 'restart'
|
||||
ARGV[0] = "rails::mongrelserver::#{ARGV[0]}"
|
||||
end
|
||||
|
||||
if not Mongrel::Command::Registry.instance.run ARGV
|
||||
exit 1
|
||||
end
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
require 'rbconfig'
|
||||
require 'commands/servers/base'
|
||||
require 'thin'
|
||||
|
||||
|
||||
options = ARGV.clone
|
||||
options.insert(0,'start') unless Thin::Runner.commands.include?(options[0])
|
||||
|
||||
thin = Thin::Runner.new(options)
|
||||
|
||||
puts "=> Rails #{Rails.version} application starting on http://#{thin.options[:address]}:#{thin.options[:port]}"
|
||||
puts "=> Ctrl-C to shutdown server"
|
||||
|
||||
log = Pathname.new("#{File.expand_path(RAILS_ROOT)}/log/#{RAILS_ENV}.log").cleanpath
|
||||
open(log, (File::WRONLY | File::APPEND | File::CREAT)) unless File.exist? log
|
||||
tail_thread = tail(log)
|
||||
trap(:INT) { exit }
|
||||
|
||||
begin
|
||||
thin.run!
|
||||
ensure
|
||||
tail_thread.kill if tail_thread
|
||||
puts 'Exiting'
|
||||
end
|
||||
|
||||
|
|
@ -1,66 +0,0 @@
|
|||
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,
|
||||
:debugger => false
|
||||
|
||||
}
|
||||
|
||||
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") { |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("-e", "--environment=name", String,
|
||||
"Specifies the environment to run this server under (test/development/production).",
|
||||
"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) }
|
||||
|
||||
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("-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") { |v| OPTIONS[:charset] = v }
|
||||
|
||||
opts.separator ""
|
||||
|
||||
opts.on("-h", "--help",
|
||||
"Show this help message.") { puts opts; exit }
|
||||
|
||||
opts.parse!
|
||||
end
|
||||
|
||||
start_debugger if OPTIONS[:debugger]
|
||||
|
||||
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 #{Rails.version} 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)
|
||||
Loading…
Add table
Add a link
Reference in a new issue