2
3
4
5
6
7
              

  module ImplicitRender
    def send_action(method, *args)
      ret = super
      default_render unless performed?
      ret
    end

196
197
198
199
200
201
              

      # which is *not* necessarily the same as the action name.
      def process_action(method_name, *args)
        send_action(method_name, *args)
      end

      # Actually call the method associated with the action. Override

8
9
10
11
12
13
              

    def process_action(*) #:nodoc:
      self.formats = request.formats.map(&:ref).compact
      super
    end

    # Check for double render errors and set the content_type after rendering.

18
19
20
21
22
23
              

    def process_action(*args)
      run_callbacks(:process_action) do
        super
      end
    end

115
116
117
118
119
120
              

        def call(env)
          block = env.run_block
          env.value = !env.halted && (!block || block.call)
          env
        end
      end

115
116
117
118
119
120
              

        def call(env)
          block = env.run_block
          env.value = !env.halted && (!block || block.call)
          env
        end
      end

553
554
555
556
557
558
              

      def compile
        @callbacks || @mutex.synchronize do
          final_sequence = CallbackSequence.new { |env| Filters::ENDING.call(env) }
          @callbacks ||= @chain.reverse.inject(final_sequence) do |callback_sequence, callback|
            callback.apply callback_sequence
          end

503
504
505
506
507
508
              

      def call(*args)
        @before.each { |b| b.call(*args) }
        value = @call.call(*args)
        @after.each { |a| a.call(*args) }
        value
      end

503
504
505
506
507
508
              

      def call(*args)
        @before.each { |b| b.call(*args) }
        value = @call.call(*args)
        @after.each { |a| a.call(*args) }
        value
      end

90
91
92
93
94
95
              

        runner = callbacks.compile
        e = Filters::Environment.new(self, false, nil, block)
        runner.call(e).value
      end
    end

776
777
778
779
780
781
              

          module_eval <<-RUBY, __FILE__, __LINE__ + 1
            def _run_#{name}_callbacks(&block)
              __run_callbacks__(_#{name}_callbacks, &block)
            end
          RUBY
        end

79
80
81
82
83
84
              

    #   end
    def run_callbacks(kind, &block)
      send "_run_#{kind}_callbacks", &block
    end

    private

17
18
19
20
21
22
              

    # process_action callbacks around the normal behavior.
    def process_action(*args)
      run_callbacks(:process_action) do
        super
      end
    end

27
28
29
30
31
32
              

    private
      def process_action(*args)
        super
      rescue Exception => exception
        request.env['action_dispatch.show_detailed_exceptions'] ||= show_detailed_exceptions?
        rescue_with_handler(exception) || raise(exception)

30
31
32
33
34
35
              

      ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
        begin
          result = super
          payload[:status] = response.status
          result
        ensure

162
163
164
165
166
167
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

18
19
20
21
22
23
              

        start name, payload
        begin
          yield payload
        rescue Exception => e
          payload[:exception] = [e.class.name, e.message]
          raise e

162
163
164
165
166
167
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

28
29
30
31
32
33
              

      ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)

      ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
        begin
          result = super
          payload[:status] = response.status

248
249
250
251
252
253
              

        request.filtered_parameters.merge! wrapped_filtered_hash
      end
      super
    end

    private

16
17
18
19
20
21
              

        # and it won't be cleaned up by the method below.
        ActiveRecord::LogSubscriber.reset_runtime
        super
      end

      def cleanup_view_runtime

135
136
137
138
139
140
              

      @_response_body = nil

      process_action(action_name, *args)
    end

    # Delegates to the class' #controller_path

28
29
30
31
32
33
              

    def process(*) #:nodoc:
      old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)
      super
    ensure
      I18n.config = old_config
    end

194
195
196
197
198
199
              

      @_env = request.env
      @_env['action_controller.instance'] = self
      process(name)
      to_a
    end

11
12
13
14
15
16
              

    def dispatch(action, request)
      set_response!(request)
      super(action, request)
    end

    def response_body=(body)

235
236
237
238
239
240
              

        end
      else
        lambda { |env| new.dispatch(name, klass.new(env)) }
      end
    end
  end

72
73
74
75
76
77
              

        def dispatch(controller, action, env)
          controller.action(action).call(env)
        end

        def normalize_controller!(params)

72
73
74
75
76
77
              

        def dispatch(controller, action, env)
          controller.action(action).call(env)
        end

        def normalize_controller!(params)

41
42
43
44
45
46
              

          end

          dispatch(controller, params[:action], req.env)
        end

        def prepare_params!(params)

41
42
43
44
45
46
              

          req.path_parameters = set_params.merge parameters

          status, headers, body = route.app.serve(req)

          if 'pass' == headers['X-Cascade']
            req.script_name     = script_name

28
29
30
31
32
33
              

      def serve(req)
        find_routes(req).each do |match, parameters, route|
          set_params  = req.path_parameters
          path_info   = req.path_info
          script_name = req.script_name

28
29
30
31
32
33
              

      def serve(req)
        find_routes(req).each do |match, parameters, route|
          set_params  = req.path_parameters
          path_info   = req.path_info
          script_name = req.script_name

815
816
817
818
819
820
              

        req = request_class.new(env)
        req.path_info = Journey::Router::Utils.normalize_path(req.path_info)
        @router.serve(req)
      end

      def recognize_path(path, environment = {})

22
23
24
25
26
27
              

    def call(env)
      status, headers, body = @app.call(env)

      if etag_status?(status) && etag_body?(body) && !skip_caching?(headers)
        original_body = body

23
24
25
26
27
28
              

      case env[REQUEST_METHOD]
      when "GET", "HEAD"
        status, headers, body = @app.call(env)
        headers = Utils::HeaderHash.new(headers)
        if status == 200 && fresh?(env, headers)
          status = 304

11
12
13
14
15
16
              

  def call(env)
    status, headers, body = @app.call(env)

    if env[REQUEST_METHOD] == HEAD
      [

25
26
27
28
29
30
              

      end

      @app.call(env)
    end

    private

258
259
260
261
262
263
              

    def call(env)
      @app.call(env)
    ensure
      session    = Request::Session.find(env) || {}
      flash_hash = env[KEY]

223
224
225
226
227
228
              

        def context(env, app=@app)
          prepare_session(env)
          status, headers, body = app.call(env)
          commit_session(env, status, headers, body)
        end

218
219
220
221
222
223
              

        def call(env)
          context(env)
        end

        def context(env, app=@app)

558
559
560
561
562
563
              

    def call(env)
      status, headers, body = @app.call(env)

      if cookie_jar = env['action_dispatch.cookies']
        unless cookie_jar.committed?

34
35
36
37
38
39
              

      connection.enable_query_cache!

      response = @app.call(env)
      response[2] = Rack::BodyProxy.new(response[2]) do
        restore_query_cache_settings(connection_id, enabled)
      end

651
652
653
654
655
656
              

        testing = env['rack.test']

        response = @app.call(env)
        response[2] = ::Rack::BodyProxy.new(response[2]) do
          ActiveRecord::Base.clear_active_connections! unless testing
        end

375
376
377
378
379
380
              

          end
        end
        @app.call(env)
      end

      private

27
28
29
30
31
32
              

      result = run_callbacks :call do
        begin
          @app.call(env)
        rescue => error
        end
      end

86
87
88
89
90
91
              

    def __run_callbacks__(callbacks, &block)
      if callbacks.empty?
        yield if block_given?
      else
        runner = callbacks.compile
        e = Filters::Environment.new(self, false, nil, block)

776
777
778
779
780
781
              

          module_eval <<-RUBY, __FILE__, __LINE__ + 1
            def _run_#{name}_callbacks(&block)
              __run_callbacks__(_#{name}_callbacks, &block)
            end
          RUBY
        end

79
80
81
82
83
84
              

    #   end
    def run_callbacks(kind, &block)
      send "_run_#{kind}_callbacks", &block
    end

    private

25
26
27
28
29
30
              

    def call(env)
      error = nil
      result = run_callbacks :call do
        begin
          @app.call(env)
        rescue => error

71
72
73
74
75
76
              

      prepare!

      response = @app.call(env)
      response[2] = ::Rack::BodyProxy.new(response[2]) { cleanup! }

      response

76
77
78
79
80
81
              

    def call(env)
      env["action_dispatch.remote_ip"] = GetIp.new(env, self)
      @app.call(env)
    end

    # The GetIp class exists as a way to defer processing of the request data

15
16
17
18
19
20
              

    def call(env)
      _, headers, body = response = @app.call(env)

      if headers['X-Cascade'] == 'pass'
        body.close if body.respond_to?(:close)

26
27
28
29
30
31
              

        end

        status, headers, body = @app.call(env)

        if exception = env['web_console.exception']
          session = Session.from_exception(exception)

16
17
18
19
20
21
              

    def call(env)
      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return @app.call(env) unless request.from_whitelited_ip?

16
17
18
19
20
21
              

    def call(env)
      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return @app.call(env) unless request.from_whitelited_ip?

28
29
30
31
32
33
              

    def call(env)
      @app.call(env)
    rescue Exception => exception
      if env['action_dispatch.show_exceptions'] == false
        raise exception

36
37
38
39
40
41
              

        instrumenter.start 'request.action_dispatch', request: request
        logger.info { started_request_message(request) }
        resp = @app.call(env)
        resp[2] = ::Rack::BodyProxy.new(resp[2]) { finish(request) }
        resp
      rescue Exception

18
19
20
21
22
23
              

        if logger.respond_to?(:tagged)
          logger.tagged(compute_tags(request)) { call_app(request, env) }
        else
          call_app(request, env)
        end

66
67
68
69
70
71
              

    def tagged(*tags)
      formatter.tagged(*tags) { yield self }
    end

    def flush

24
25
26
27
28
29
              

      def tagged(*tags)
        new_tags = push_tags(*tags)
        yield self
      ensure
        pop_tags(new_tags.size)
      end

66
67
68
69
70
71
              

    def tagged(*tags)
      formatter.tagged(*tags) { yield self }
    end

    def flush

18
19
20
21
22
23
              

        if logger.respond_to?(:tagged)
          logger.tagged(compute_tags(request)) { call_app(request, env) }
        else
          call_app(request, env)
        end

19
20
21
22
23
24
              

    def call(env)
      env["action_dispatch.request_id"] = external_request_id(env) || internal_request_id
      @app.call(env).tap { |_status, headers, _body| headers["X-Request-Id"] = env["action_dispatch.request_id"] }
    end

    private

20
21
22
23
24
25
              

      end

      @app.call(env)
    end

    def method_override(env)

16
17
18
19
20
21
              

    def call(env)
      start_time = clock_time
      status, headers, body = @app.call(env)
      request_time = clock_time - start_time

      if !headers.has_key?(@header_name)

26
27
28
29
30
31
              

          def call(env)
            LocalCacheRegistry.set_cache_for(local_cache_key, LocalStore.new)
            response = @app.call(env)
            response[2] = ::Rack::BodyProxy.new(response[2]) do
              LocalCacheRegistry.set_cache_for(local_cache_key, nil)
            end

15
16
17
18
19
20
              

      old, env[FLAG] = env[FLAG], false
      @mutex.lock
      response = @app.call(env)
      body = BodyProxy.new(response[2]) { @mutex.unlock }
      response[2] = body
      response

118
119
120
121
122
123
              

      end

      @app.call(env)
    end
  end
end

111
112
113
114
115
116
              

    def call(env)
      status, headers, body = @app.call(env)
      if body.respond_to?(:to_path)
        case type = variation(env)
        when 'X-Accel-Redirect'

516
517
518
519
520
521
              

        env["ROUTES_#{routes.object_id}_SCRIPT_NAME"] = env['SCRIPT_NAME'].dup
      end
      app.call(env)
    end

    # Defines additional Rack env configuration that is added on each call.

163
164
165
166
167
168
              

      env["ORIGINAL_FULLPATH"] = build_original_fullpath(env)
      env["ORIGINAL_SCRIPT_NAME"] = env["SCRIPT_NAME"]
      super(env)
    end

    # Reload application routes regardless if they changed or not.

15
16
17
18
19
20
              

      old, env[FLAG] = env[FLAG], false
      @mutex.lock
      response = @app.call(env)
      body = BodyProxy.new(response[2]) { @mutex.unlock }
      response[2] = body
      response

13
14
15
16
17
18
              

    def call(env)
      status, headers, body = @app.call(env)
      headers = HeaderHash.new(headers)

      if !STATUS_WITH_NO_ENTITY_BODY.include?(status.to_i) &&

86
87
88
89
90
91
              

        env["REQUEST_PATH"] ||= [env["SCRIPT_NAME"], env[PATH_INFO]].join

        status, headers, body = @app.call(env)
        begin
          res.status = status.to_i
          headers.each { |k, vs|

136
137
138
139
140
141
              

      si = servlet.get_instance(self, *options)
      @logger.debug(format("%s is invoked.", si.class.name))
      si.service(req, res)
    end

    ##

92
93
94
95
96
97
              

            callback.call(req, res)
          end
          server.service(req, res)
        rescue HTTPStatus::EOFError, HTTPStatus::RequestTimeout => ex
          res.set_error(ex)
        rescue HTTPStatus::Error => ex

292
293
294
295
296
297
              

          end
          call_callback(:AcceptCallback, sock)
          block ? block.call(sock) : run(sock)
        rescue Errno::ENOTCONN
          @logger.debug "Errno::ENOTCONN raised"
        rescue ServerError => ex