Functional tests now work properly, bearing in mind whether a user is logged in or...
[depot.git] / vendor / rails / railties / lib / commands / process / reaper.rb
1 require 'optparse'
2 require 'net/http'
3 require 'uri'
4
5 if RUBY_PLATFORM =~ /(:?mswin|mingw)/ then abort("Reaper is only for Unix") end
6
7 class Killer
8 class << self
9 # Searches for all processes matching the given keywords, and then invokes
10 # a specific action on each of them. This is useful for (e.g.) reloading a
11 # set of processes:
12 #
13 # Killer.process(:reload, "/tmp/pids", "dispatcher.*.pid")
14 def process(action, pid_path, pattern, keyword)
15 new(pid_path, pattern, keyword).process(action)
16 end
17
18 # Forces the (rails) application to reload by sending a +HUP+ signal to the
19 # process.
20 def reload(pid)
21 `kill -s HUP #{pid}`
22 end
23
24 # Force the (rails) application to restart by sending a +USR2+ signal to the
25 # process.
26 def restart(pid)
27 `kill -s USR2 #{pid}`
28 end
29
30 # Forces the (rails) application to gracefully terminate by sending a
31 # +TERM+ signal to the process.
32 def graceful(pid)
33 `kill -s TERM #{pid}`
34 end
35
36 # Forces the (rails) application to terminate immediately by sending a -9
37 # signal to the process.
38 def kill(pid)
39 `kill -9 #{pid}`
40 end
41
42 # Send a +USR1+ signal to the process.
43 def usr1(pid)
44 `kill -s USR1 #{pid}`
45 end
46 end
47
48 def initialize(pid_path, pattern, keyword=nil)
49 @pid_path, @pattern, @keyword = pid_path, pattern, keyword
50 end
51
52 def process(action)
53 pids = find_processes
54
55 if pids.empty?
56 warn "Couldn't find any pid file in '#{@pid_path}' matching '#{@pattern}'"
57 warn "(also looked for processes matching #{@keyword.inspect})" if @keyword
58 else
59 pids.each do |pid|
60 puts "#{action.capitalize}ing #{pid}"
61 self.class.send(action, pid)
62 end
63
64 delete_pid_files if terminating?(action)
65 end
66 end
67
68 private
69 def terminating?(action)
70 [ "kill", "graceful" ].include?(action)
71 end
72
73 def find_processes
74 files = pid_files
75 if files.empty?
76 find_processes_via_grep
77 else
78 files.collect { |pid_file| File.read(pid_file).to_i }
79 end
80 end
81
82 def find_processes_via_grep
83 lines = `ps axww -o 'pid command' | grep #{@keyword}`.split(/\n/).
84 reject { |line| line =~ /inq|ps axww|grep|spawn-fcgi|spawner|reaper/ }
85 lines.map { |line| line[/^\s*(\d+)/, 1].to_i }
86 end
87
88 def delete_pid_files
89 pid_files.each { |pid_file| File.delete(pid_file) }
90 end
91
92 def pid_files
93 Dir.glob(@pid_path + "/" + @pattern)
94 end
95 end
96
97
98 OPTIONS = {
99 :action => "restart",
100 :pid_path => File.expand_path(RAILS_ROOT + '/tmp/pids'),
101 :pattern => "dispatch.[0-9]*.pid",
102 :dispatcher => File.expand_path("#{RAILS_ROOT}/public/dispatch.fcgi")
103 }
104
105 ARGV.options do |opts|
106 opts.banner = "Usage: reaper [options]"
107
108 opts.separator ""
109
110 opts.on <<-EOF
111 Description:
112 The reaper is used to restart, reload, gracefully exit, and forcefully exit processes
113 running a Rails Dispatcher (or any other process responding to the same signals). This
114 is commonly done when a new version of the application is available, so the existing
115 processes can be updated to use the latest code.
116
117 It uses pid files to work on the processes and by default assume them to be located
118 in RAILS_ROOT/tmp/pids.
119
120 The reaper actions are:
121
122 * restart : Restarts the application by reloading both application and framework code
123 * reload : Only reloads the application, but not the framework (like the development environment)
124 * graceful: Marks all of the processes for exit after the next request
125 * kill : Forcefully exists all processes regardless of whether they're currently serving a request
126
127 Restart is the most common and default action.
128
129 Examples:
130 reaper # restarts the default dispatchers
131 reaper -a reload # reload the default dispatchers
132 reaper -a kill -r *.pid # kill all processes that keep pids in tmp/pids
133 EOF
134
135 opts.on(" Options:")
136
137 opts.on("-a", "--action=name", "reload|graceful|kill (default: #{OPTIONS[:action]})", String) { |v| OPTIONS[:action] = v }
138 opts.on("-p", "--pidpath=path", "default: #{OPTIONS[:pid_path]}", String) { |v| OPTIONS[:pid_path] = v }
139 opts.on("-r", "--pattern=pattern", "default: #{OPTIONS[:pattern]}", String) { |v| OPTIONS[:pattern] = v }
140 opts.on("-d", "--dispatcher=path", "DEPRECATED. default: #{OPTIONS[:dispatcher]}", String) { |v| OPTIONS[:dispatcher] = v }
141
142 opts.separator ""
143
144 opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
145
146 opts.parse!
147 end
148
149 Killer.process(OPTIONS[:action], OPTIONS[:pid_path], OPTIONS[:pattern], OPTIONS[:dispatcher])