1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
#--
# Copyright (c) 2004-2007 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)
controller = nil
if cgi ||= new_cgi(output)
request, response = ActionController::CgiRequest.new(cgi, session_options), ActionController::CgiResponse.new(cgi)
prepare_application
controller = ActionController::Routing::Routes.recognize(request)
controller.process(request, response).out(output)
end
rescue Exception => exception # errors from CGI dispatch
failsafe_response(cgi, output, '500 Internal Server Error', exception) do
controller ||= (ApplicationController rescue ActionController::Base)
controller.process_with_exception(request, response, exception).out(output)
end
ensure
# Do not give a failsafe response here
flush_logger
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!
ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
Dependencies.clear
ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
end
# Add a preparation callback. Preparation callbacks are run before every
# request in development mode, and before the first request in production
# mode.
#
# An optional identifier may be supplied for the callback. If provided,
# to_prepare may be called again with the same identifier to replace the
# existing callback. Passing an identifier is a suggested practice if the
# code adding a preparation block may be reloaded.
def to_prepare(identifier = nil, &block)
unless identifier.nil?
callback = preparation_callbacks.detect { |ident, _| ident == identifier }
if callback # Already registered: update the existing callback
callback[-1] = block
return
end
end
preparation_callbacks << [identifier, block]
return
end
private
attr_accessor_with_default :preparation_callbacks, []
attr_accessor_with_default :preparation_callbacks_run, false
# 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(nil, output, '400 Bad Request') { CGI.new }
end
def prepare_application
if Dependencies.load?
ActionController::Routing::Routes.reload
self.preparation_callbacks_run = false
end
require_dependency 'application' unless Object.const_defined?(:ApplicationController)
ActiveRecord::Base.verify_active_connections! if defined?(ActiveRecord)
run_preparation_callbacks
end
def reset_after_dispatch
reset_application! if Dependencies.load?
end
def run_preparation_callbacks
return if preparation_callbacks_run
preparation_callbacks.each { |_, callback| callback.call }
self.preparation_callbacks_run = true
end
# If the block raises, send status code as a last-ditch response.
def failsafe_response(cgi, fallback_output, status, exception = nil)
yield
rescue Exception
begin
log_failsafe_exception(cgi, status, exception)
body = failsafe_response_body(status)
if cgi
head = { 'status' => status, 'type' => 'text/html' }
# FIXME: using CGI differently than CGIResponse does breaks
# the Mongrel CGI wrapper.
if defined?(Mongrel) && cgi.is_a?(Mongrel::CGIWrapper)
# FIXME: set a dummy cookie so the Mongrel CGI wrapper will
# also consider @output_cookies (used for session cookies.)
head['cookie'] = []
cgi.header(head)
fallback_output << body
else
cgi.out(head) { body }
end
else
fallback_output.write "Status: #{status}\r\nContent-Type: text/html\r\n\r\n#{body}"
end
nil
rescue Exception # Logger or IO errors
end
end
def failsafe_response_body(status)
error_path = "#{RAILS_ROOT}/public/#{status[0..3]}.html"
if File.exists?(error_path)
File.read(error_path)
else
"<html><body><h1>#{status}</h1></body></html>"
end
end
def log_failsafe_exception(cgi, status, exception)
fell_back = cgi ? 'has cgi' : 'no cgi, fallback ouput'
message = "DISPATCHER FAILSAFE RESPONSE (#{fell_back}) #{Time.now}\n Status: #{status}\n"
message << " #{exception}\n #{exception.backtrace.join("\n ")}" if exception
failsafe_logger.fatal message
end
def failsafe_logger
if defined?(RAILS_DEFAULT_LOGGER) && !RAILS_DEFAULT_LOGGER.nil?
RAILS_DEFAULT_LOGGER
else
ActiveSupport::BufferedLogger.new($stderr)
end
end
def flush_logger
RAILS_DEFAULT_LOGGER.flush if defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:flush)
end
end
end
Dispatcher.to_prepare :activerecord_instantiate_observers do
ActiveRecord::Base.instantiate_observers
end if defined?(ActiveRecord)
|
