← Back to branch summary

~michaelforrest/use-case-mapper/trunk

« back to all changes in this revision

Viewing changes to vendor/rails/railties/lib/fcgi_handler.rb

  • Committer: Richard Lee (Canonical)
  • Date: 2010-10-15 15:17:58 UTC
  • mfrom: (190.1.3 use-case-mapper)
  • Revision ID: richard.lee@canonical.com-20101015151758-wcvmfxrexsongf9d
Merge

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/rails/railties/lib/fcgi_handler.rb
1
 
require 'fcgi'
2
 
require 'logger'
3
 
require 'dispatcher'
4
 
require 'rbconfig'
5
 
 
6
 
class RailsFCGIHandler
7
 
  SIGNALS = {
8
 
    'HUP'     => :reload,
9
 
    'INT'     => :exit_now,
10
 
    'TERM'    => :exit_now,
11
 
    'USR1'    => :exit,
12
 
    'USR2'    => :restart
13
 
  }
14
 
  GLOBAL_SIGNALS = SIGNALS.keys - %w(USR1)
15
 
 
16
 
  attr_reader :when_ready
17
 
 
18
 
  attr_accessor :log_file_path
19
 
  attr_accessor :gc_request_period
20
 
 
21
 
  # Initialize and run the FastCGI instance, passing arguments through to new.
22
 
  def self.process!(*args, &block)
23
 
    new(*args, &block).process!
24
 
  end
25
 
 
26
 
  # Initialize the FastCGI instance with the path to a crash log
27
 
  # detailing unhandled exceptions (default RAILS_ROOT/log/fastcgi.crash.log)
28
 
  # and the number of requests to process between garbage collection runs
29
 
  # (default nil for normal GC behavior.)  Optionally, pass a block which
30
 
  # takes this instance as an argument for further configuration.
31
 
  def initialize(log_file_path = nil, gc_request_period = nil)
32
 
    self.log_file_path = log_file_path || "#{RAILS_ROOT}/log/fastcgi.crash.log"
33
 
    self.gc_request_period = gc_request_period
34
 
 
35
 
    # Yield for additional configuration.
36
 
    yield self if block_given?
37
 
 
38
 
    # Safely install signal handlers.
39
 
    install_signal_handlers
40
 
 
41
 
    @app = Dispatcher.new
42
 
 
43
 
    # Start error timestamp at 11 seconds ago.
44
 
    @last_error_on = Time.now - 11
45
 
  end
46
 
 
47
 
  def process!(provider = FCGI)
48
 
    mark_features!
49
 
 
50
 
    dispatcher_log :info, 'starting'
51
 
    process_each_request provider
52
 
    dispatcher_log :info, 'stopping gracefully'
53
 
 
54
 
  rescue Exception => error
55
 
    case error
56
 
    when SystemExit
57
 
      dispatcher_log :info, 'stopping after explicit exit'
58
 
    when SignalException
59
 
      dispatcher_error error, 'stopping after unhandled signal'
60
 
    else
61
 
      # Retry if exceptions occur more than 10 seconds apart.
62
 
      if Time.now - @last_error_on > 10
63
 
        @last_error_on = Time.now
64
 
        dispatcher_error error, 'retrying after unhandled exception'
65
 
        retry
66
 
      else
67
 
        dispatcher_error error, 'stopping after unhandled exception within 10 seconds of the last'
68
 
      end
69
 
    end
70
 
  end
71
 
 
72
 
  protected
73
 
    def process_each_request(provider)
74
 
      request = nil
75
 
 
76
 
      catch :exit do
77
 
        provider.each do |request|
78
 
          process_request(request)
79
 
 
80
 
          case when_ready
81
 
            when :reload
82
 
              reload!
83
 
            when :restart
84
 
              close_connection(request)
85
 
              restart!
86
 
            when :exit
87
 
              close_connection(request)
88
 
              throw :exit
89
 
          end
90
 
        end
91
 
      end
92
 
    rescue SignalException => signal
93
 
      raise unless signal.message == 'SIGUSR1'
94
 
      close_connection(request)
95
 
    end
96
 
 
97
 
    def process_request(request)
98
 
      @processing, @when_ready = true, nil
99
 
      gc_countdown
100
 
 
101
 
      with_signal_handler 'USR1' do
102
 
        begin
103
 
          ::Rack::Handler::FastCGI.serve(request, @app)
104
 
        rescue SignalException, SystemExit
105
 
          raise
106
 
        rescue Exception => error
107
 
          dispatcher_error error, 'unhandled dispatch error'
108
 
        end
109
 
      end
110
 
    ensure
111
 
      @processing = false
112
 
    end
113
 
 
114
 
    def logger
115
 
      @logger ||= Logger.new(@log_file_path)
116
 
    end
117
 
 
118
 
    def dispatcher_log(level, msg)
119
 
      time_str = Time.now.strftime("%d/%b/%Y:%H:%M:%S")
120
 
      logger.send(level, "[#{time_str} :: #{$$}] #{msg}")
121
 
    rescue Exception => log_error  # Logger errors
122
 
      STDERR << "Couldn't write to #{@log_file_path.inspect}: #{msg}\n"
123
 
      STDERR << "  #{log_error.class}: #{log_error.message}\n"
124
 
    end
125
 
 
126
 
    def dispatcher_error(e, msg = "")
127
 
      error_message =
128
 
        "Dispatcher failed to catch: #{e} (#{e.class})\n" +
129
 
        "  #{e.backtrace.join("\n  ")}\n#{msg}"
130
 
      dispatcher_log(:error, error_message)
131
 
    end
132
 
 
133
 
    def install_signal_handlers
134
 
      GLOBAL_SIGNALS.each { |signal| install_signal_handler(signal) }
135
 
    end
136
 
 
137
 
    def install_signal_handler(signal, handler = nil)
138
 
      if SIGNALS.include?(signal) && self.class.method_defined?(name = "#{SIGNALS[signal]}_handler")
139
 
        handler ||= method(name).to_proc
140
 
 
141
 
        begin
142
 
          trap(signal, handler)
143
 
        rescue ArgumentError
144
 
          dispatcher_log :warn, "Ignoring unsupported signal #{signal}."
145
 
        end
146
 
      else
147
 
        dispatcher_log :warn, "Ignoring unsupported signal #{signal}."
148
 
      end
149
 
    end
150
 
 
151
 
    def with_signal_handler(signal)
152
 
      install_signal_handler(signal)
153
 
      yield
154
 
    ensure
155
 
      install_signal_handler(signal, 'DEFAULT')
156
 
    end
157
 
 
158
 
    def exit_now_handler(signal)
159
 
      dispatcher_log :info, "asked to stop immediately"
160
 
      exit
161
 
    end
162
 
 
163
 
    def exit_handler(signal)
164
 
      dispatcher_log :info, "asked to stop ASAP"
165
 
      if @processing
166
 
        @when_ready = :exit
167
 
      else
168
 
        throw :exit
169
 
      end
170
 
    end
171
 
 
172
 
    def reload_handler(signal)
173
 
      dispatcher_log :info, "asked to reload ASAP"
174
 
      if @processing
175
 
        @when_ready = :reload
176
 
      else
177
 
        reload!
178
 
      end
179
 
    end
180
 
 
181
 
    def restart_handler(signal)
182
 
      dispatcher_log :info, "asked to restart ASAP"
183
 
      if @processing
184
 
        @when_ready = :restart
185
 
      else
186
 
        restart!
187
 
      end
188
 
    end
189
 
 
190
 
    def restart!
191
 
      config       = ::Config::CONFIG
192
 
      ruby         = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
193
 
      command_line = [ruby, $0, ARGV].flatten.join(' ')
194
 
 
195
 
      dispatcher_log :info, "restarted"
196
 
 
197
 
      # close resources as they won't be closed by
198
 
      # the OS when using exec
199
 
      logger.close rescue nil
200
 
      Rails.logger.close rescue nil
201
 
 
202
 
      exec(command_line)
203
 
    end
204
 
 
205
 
    def reload!
206
 
      run_gc! if gc_request_period
207
 
      restore!
208
 
      @when_ready = nil
209
 
      dispatcher_log :info, "reloaded"
210
 
    end
211
 
 
212
 
    # Make a note of $" so we can safely reload this instance.
213
 
    def mark_features!
214
 
      @features = $".clone
215
 
    end
216
 
 
217
 
    def restore!
218
 
      $".replace @features
219
 
      Dispatcher.reset_application!
220
 
      ActionController::Routing::Routes.reload
221
 
    end
222
 
 
223
 
    def run_gc!
224
 
      @gc_request_countdown = gc_request_period
225
 
      GC.enable; GC.start; GC.disable
226
 
    end
227
 
 
228
 
    def gc_countdown
229
 
      if gc_request_period
230
 
        @gc_request_countdown ||= gc_request_period
231
 
        @gc_request_countdown -= 1
232
 
        run_gc! if @gc_request_countdown <= 0
233
 
      end
234
 
    end
235
 
 
236
 
    def close_connection(request)
237
 
      request.finish if request
238
 
    end
239
 
end