Class: ActionController::Dispatcher
- Includes:
- ActiveSupport::Callbacks
- Defined in:
- lib/action_controller/dispatcher.rb
Overview
Dispatches requests to the appropriate controller and takes care of reloading the app after each request when Dependencies.load? is true.
Constant Summary collapse
- @@guard =
Mutex.new
Class Method Summary collapse
- .define_dispatcher_callbacks(cache_classes) ⇒ Object
-
.dispatch(cgi = nil, session_options = CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout) ⇒ Object
Backward-compatible class method takes CGI-specific args.
-
.failsafe_response(fallback_output, status, originating_exception = nil) ⇒ Object
If the block raises, send status code as a last-ditch response.
-
.to_prepare(identifier = nil, &block) ⇒ Object
Add a preparation callback.
Instance Method Summary collapse
-
#cleanup_application ⇒ Object
Cleanup the application by clearing out loaded classes so they can be reloaded on the next request without restarting the server.
- #dispatch ⇒ Object
- #dispatch_cgi(cgi, session_options) ⇒ Object
- #flush_logger ⇒ Object
-
#initialize(output, request = nil, response = nil) ⇒ Dispatcher
constructor
A new instance of Dispatcher.
- #reload_application ⇒ Object
Constructor Details
#initialize(output, request = nil, response = nil) ⇒ Dispatcher
Returns a new instance of Dispatcher.
99 100 101 |
# File 'lib/action_controller/dispatcher.rb', line 99 def initialize(output, request = nil, response = nil) @output, @request, @response = output, request, response end |
Class Method Details
.define_dispatcher_callbacks(cache_classes) ⇒ Object
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
# File 'lib/action_controller/dispatcher.rb', line 8 def define_dispatcher_callbacks(cache_classes) unless cache_classes # Development mode callbacks before_dispatch :reload_application after_dispatch :cleanup_application end # Common callbacks to_prepare :load_application_controller do begin require_dependency 'application' unless defined?(::ApplicationController) rescue LoadError => error raise unless error. =~ /application\.rb/ end end if defined?(ActiveRecord) before_dispatch { ActiveRecord::Base.verify_active_connections! } to_prepare(:activerecord_instantiate_observers) { ActiveRecord::Base.instantiate_observers } end after_dispatch :flush_logger if defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:flush) end |
.dispatch(cgi = nil, session_options = CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout) ⇒ Object
Backward-compatible class method takes CGI-specific args. Deprecated in favor of Dispatcher.new(output, request, response).dispatch.
34 35 36 |
# File 'lib/action_controller/dispatcher.rb', line 34 def dispatch(cgi = nil, = CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout) new(output).dispatch_cgi(cgi, ) end |
.failsafe_response(fallback_output, status, originating_exception = nil) ⇒ Object
If the block raises, send status code as a last-ditch response.
53 54 55 56 57 58 59 60 61 62 63 64 65 |
# File 'lib/action_controller/dispatcher.rb', line 53 def failsafe_response(fallback_output, status, originating_exception = nil) yield rescue Exception => exception begin log_failsafe_exception(status, originating_exception || exception) body = failsafe_response_body(status) fallback_output.write "Status: #{status}\r\nContent-Type: text/html\r\n\r\n#{body}" nil rescue Exception => failsafe_error # Logger or IO errors $stderr.puts "Error during failsafe response: #{failsafe_error}" $stderr.puts "(originally #{originating_exception})" if originating_exception end end |
.to_prepare(identifier = nil, &block) ⇒ Object
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.
46 47 48 49 50 |
# File 'lib/action_controller/dispatcher.rb', line 46 def to_prepare(identifier = nil, &block) @prepare_dispatch_callbacks ||= ActiveSupport::Callbacks::CallbackChain.new callback = ActiveSupport::Callbacks::Callback.new(:prepare_dispatch, block, :identifier => identifier) @prepare_dispatch_callbacks | callback end |
Instance Method Details
#cleanup_application ⇒ Object
Cleanup the application by clearing out loaded classes so they can be reloaded on the next request without restarting the server.
136 137 138 139 140 |
# File 'lib/action_controller/dispatcher.rb', line 136 def cleanup_application ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord) ActiveSupport::Dependencies.clear ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord) end |
#dispatch ⇒ Object
103 104 105 106 107 108 109 110 111 112 113 114 |
# File 'lib/action_controller/dispatcher.rb', line 103 def dispatch @@guard.synchronize do begin run_callbacks :before_dispatch handle_request rescue Exception => exception failsafe_rescue exception ensure run_callbacks :after_dispatch, :enumerator => :reverse_each end end end |
#dispatch_cgi(cgi, session_options) ⇒ Object
116 117 118 119 120 121 122 123 124 |
# File 'lib/action_controller/dispatcher.rb', line 116 def dispatch_cgi(cgi, ) if cgi ||= self.class.failsafe_response(@output, '400 Bad Request') { CGI.new } @request = CgiRequest.new(cgi, ) @response = CgiResponse.new(cgi) dispatch end rescue Exception => exception failsafe_rescue exception end |
#flush_logger ⇒ Object
142 143 144 |
# File 'lib/action_controller/dispatcher.rb', line 142 def flush_logger RAILS_DEFAULT_LOGGER.flush end |
#reload_application ⇒ Object
126 127 128 129 130 131 132 |
# File 'lib/action_controller/dispatcher.rb', line 126 def reload_application # Run prepare callbacks before every request in development mode run_callbacks :prepare_dispatch Routing::Routes.reload ActionView::TemplateFinder.reload! unless ActionView::Base.cache_template_loading end |