vendor/rails/actionpack/lib/action_controller/dispatcher.rb

   1 module ActionController
   2   # Dispatches requests to the appropriate controller and takes care of
   3   # reloading the app after each request when Dependencies.load? is true.
   4   class Dispatcher
   5     class << self
   6       def define_dispatcher_callbacks(cache_classes)
   7         unless cache_classes
   8           unless self.middleware.include?(Reloader)
   9             self.middleware.insert_after(Failsafe, Reloader)
  10           end
  11
  12           ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
  13         end
  14
  15         if defined?(ActiveRecord)
  16           to_prepare(:activerecord_instantiate_observers) { ActiveRecord::Base.instantiate_observers }
  17         end
  18
  19         after_dispatch :flush_logger if Base.logger && Base.logger.respond_to?(:flush)
  20
  21         to_prepare do
  22           I18n.reload!
  23         end
  24       end
  25
  26       # DEPRECATE: Remove CGI support
  27       def dispatch(cgi = nil, session_options = CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout)
  28         new(output).dispatch_cgi(cgi, session_options)
  29       end
  30
  31       # Add a preparation callback. Preparation callbacks are run before every
  32       # request in development mode, and before the first request in production
  33       # mode.
  34       #
  35       # An optional identifier may be supplied for the callback. If provided,
  36       # to_prepare may be called again with the same identifier to replace the
  37       # existing callback. Passing an identifier is a suggested practice if the
  38       # code adding a preparation block may be reloaded.
  39       def to_prepare(identifier = nil, &block)
  40         @prepare_dispatch_callbacks ||= ActiveSupport::Callbacks::CallbackChain.new
  41         callback = ActiveSupport::Callbacks::Callback.new(:prepare_dispatch, block, :identifier => identifier)
  42         @prepare_dispatch_callbacks.replace_or_append!(callback)
  43       end
  44
  45       def run_prepare_callbacks
  46         if defined?(Rails) && Rails.logger
  47           logger = Rails.logger
  48         else
  49           logger = Logger.new($stderr)
  50         end
  51
  52         new(logger).send :run_callbacks, :prepare_dispatch
  53       end
  54
  55       def reload_application
  56         # Run prepare callbacks before every request in development mode
  57         run_prepare_callbacks
  58
  59         Routing::Routes.reload
  60       end
  61
  62       def cleanup_application
  63         # Cleanup the application before processing the current request.
  64         ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
  65         ActiveSupport::Dependencies.clear
  66         ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
  67       end
  68     end
  69
  70     cattr_accessor :middleware
  71     self.middleware = MiddlewareStack.new do |middleware|
  72       middlewares = File.join(File.dirname(__FILE__), "middlewares.rb")
  73       middleware.instance_eval(File.read(middlewares))
  74     end
  75
  76     include ActiveSupport::Callbacks
  77     define_callbacks :prepare_dispatch, :before_dispatch, :after_dispatch
  78
  79     # DEPRECATE: Remove arguments, since they are only used by CGI
  80     def initialize(output = $stdout, request = nil, response = nil)
  81       @output = output
  82       @app = @@middleware.build(lambda { |env| self.dup._call(env) })
  83     end
  84
  85     def dispatch
  86       begin
  87         run_callbacks :before_dispatch
  88         Routing::Routes.call(@env)
  89       rescue Exception => exception
  90         if controller ||= (::ApplicationController rescue Base)
  91           controller.call_with_exception(@env, exception).to_a
  92         else
  93           raise exception
  94         end
  95       ensure
  96         run_callbacks :after_dispatch, :enumerator => :reverse_each
  97       end
  98     end
  99
 100     # DEPRECATE: Remove CGI support
 101     def dispatch_cgi(cgi, session_options)
 102       CGIHandler.dispatch_cgi(self, cgi, @output)
 103     end
 104
 105     def call(env)
 106       @app.call(env)
 107     end
 108
 109     def _call(env)
 110       @env = env
 111       dispatch
 112     end
 113
 114     def flush_logger
 115       Base.logger.flush
 116     end
 117   end
 118 end