245
246
247
248
249
250
              

      @current_template = template if add_to_stack
      @output_buffer = buffer
      public_send(method, locals, buffer, &block)
    ensure
      @output_buffer, @virtual_path, @current_template = _old_output_buffer, _old_virtual_path, _old_template
    end

245
246
247
248
249
250
              

      @current_template = template if add_to_stack
      @output_buffer = buffer
      public_send(method, locals, buffer, &block)
    ensure
      @output_buffer, @virtual_path, @current_template = _old_output_buffer, _old_virtual_path, _old_template
    end

152
153
154
155
156
157
              

      instrument_render_template do
        compile!(view)
        view._run(method_name, self, locals, buffer, add_to_stack: add_to_stack, &block)
      end
    rescue => e
      handle_render_error(view, e)

203
204
205
206
207
208
              

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

343
344
345
346
347
348
              

      def instrument_render_template(&block)
        ActiveSupport::Notifications.instrument("!render_template.action_view", instrument_payload, &block)
      end

      def instrument_payload

150
151
152
153
154
155
              

    # consume this in production. This is only slow if it's being listened to.
    def render(view, locals, buffer = ActionView::OutputBuffer.new, add_to_stack: true, &block)
      instrument_render_template do
        compile!(view)
        view._run(method_name, self, locals, buffer, add_to_stack: add_to_stack, &block)
      end

283
284
285
286
287
288
              

          layout: layout && layout.virtual_path
        ) do |payload|
          content = template.render(view, locals, add_to_stack: !block) do |*name|
            view._layout_for(*name, &block)
          end

201
202
203
204
205
206
              

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

22
23
24
25
26
27
              

        listeners_state = start name, payload
        begin
          yield payload if block_given?
        rescue Exception => e
          payload[:exception] = [e.class.name, e.message]
          payload[:exception_object] = e

201
202
203
204
205
206
              

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

278
279
280
281
282
283
              

      def render_partial_template(view, locals, template, layout, block)
        ActiveSupport::Notifications.instrument(
          "render_partial.action_view",
          identifier: template.identifier,
          layout: layout && layout.virtual_path

269
270
271
272
273
274
              

      end

      render_partial_template(context, @locals, template, layout, block)
    end

    private

79
80
81
82
83
84
              

            # Partial
            renderer = PartialRenderer.new(@lookup_context, options)
            renderer.render(partial, context, block)
          end
        end
      else

25
26
27
28
29
30
              

    def render_to_object(context, options) # :nodoc:
      if options.key?(:partial)
        render_partial_to_object(context, options)
      else
        render_template_to_object(context, options)
      end

115
116
117
118
119
120
              

        rendered_template = context.in_rendering_context(options) do |renderer|
          renderer.render_to_object(context, options)
        end

        rendered_format = rendered_template.format || lookup_context.formats.first

271
272
273
274
275
276
              

      end

      yield @view_renderer
    ensure
      @view_renderer = old_view_renderer
      @lookup_context = old_lookup_context

114
115
116
117
118
119
              

        lookup_context.variants = variant if variant

        rendered_template = context.in_rendering_context(options) do |renderer|
          renderer.render_to_object(context, options)
        end

216
217
218
219
220
221
              

          Rack::Chunked::Body.new view_renderer.render_body(view_context, options)
        else
          super
        end
      end
  end

101
102
103
104
105
106
              

    def render_to_body(options = {})
      _process_options(options)
      _render_template(options)
    end

    private

50
51
52
53
54
55
              

    def render_to_body(options = {})
      super || _render_in_priorities(options) || " "
    end

    private

140
141
142
143
144
145
              

    # <tt>ActionView::Rendering.render_to_body</tt>, if present.
    def render_to_body(options)
      _render_to_body_with_renderer(options) || super
    end

    def _render_to_body_with_renderer(options)

23
24
25
26
27
28
              

    def render(*args, &block)
      options = _normalize_render(*args, &block)
      rendered_body = render_to_body(options)
      if options[:html]
        _set_html_content_type
      else

34
35
36
37
38
39
              

    def render(*args) #:nodoc:
      raise ::AbstractController::DoubleRenderError if response_body
      super
    end

    # Overwrite render_to_string because body can now be set to a Rack body.

44
45
46
47
48
49
              

      render_output = nil
      self.view_runtime = cleanup_view_runtime do
        Benchmark.ms { render_output = super }
      end
      render_output
    end

306
307
308
309
310
311
              

  def realtime # :yield:
    r0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
    yield
    Process.clock_gettime(Process::CLOCK_MONOTONIC) - r0
  end

12
13
14
15
16
              

  #   # => 0.074
  def ms(&block)
    1000 * realtime(&block)
  end
end

44
45
46
47
48
49
              

      render_output = nil
      self.view_runtime = cleanup_view_runtime do
        Benchmark.ms { render_output = super }
      end
      render_output
    end

84
85
86
87
88
89
              

    #   end
    def cleanup_view_runtime # :doc:
      yield
    end

    # Every time after an action is processed, this method is invoked

32
33
34
35
36
37
              

            db_rt_before_render = ActiveRecord::LogSubscriber.reset_runtime
            self.db_runtime = (db_runtime || 0) + db_rt_before_render
            runtime = super
            db_rt_after_render = ActiveRecord::LogSubscriber.reset_runtime
            self.db_runtime += db_rt_after_render
            runtime - db_rt_after_render

43
44
45
46
47
48
              

    def render(*)
      render_output = nil
      self.view_runtime = cleanup_view_runtime do
        Benchmark.ms { render_output = super }
      end
      render_output

4
5
6
7
8
9
              

  module BasicImplicitRender # :nodoc:
    def send_action(method, *args)
      super.tap { default_render unless performed? }
    end

    def default_render

226
227
228
229
230
231
              

      # 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

28
29
30
31
32
33
              

    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.

40
41
42
43
44
45
              

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

104
105
106
107
108
109
              

        if next_sequence.final?
          next_sequence.invoke_before(env)
          env.value = !env.halted && (!block_given? || yield)
          next_sequence.invoke_after(env)
          env.value
        else

39
40
41
42
43
44
              

    # <tt>process_action</tt> callbacks around the normal behavior.
    def process_action(*)
      run_callbacks(:process_action) do
        super
      end
    end

20
21
22
23
24
25
              

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

32
33
34
35
36
37
              

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

201
202
203
204
205
206
              

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

22
23
24
25
26
27
              

        listeners_state = start name, payload
        begin
          yield payload if block_given?
        rescue Exception => e
          payload[:exception] = [e.class.name, e.message]
          payload[:exception_object] = e

201
202
203
204
205
206
              

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

31
32
33
34
35
36
              

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

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

247
248
249
250
251
252
              

    def process_action(*)
      _perform_parameter_wrapping if _wrapper_enabled?
      super
    end

    private

25
26
27
28
29
30
              

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

        def cleanup_view_runtime

163
164
165
166
167
168
              

      @_response_body = nil

      process_action(action_name, *args)
    end

    # Delegates to the class' ::controller_path

37
38
39
40
41
42
              

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

188
189
190
191
192
193
              

      set_request!(request)
      set_response!(response)
      process(name)
      request.commit_flash
      to_a
    end

252
253
254
255
256
257
              

        middleware_stack.build(name) { |env| new.dispatch(name, req, res) }.call req.env
      else
        new.dispatch(name, req, res)
      end
    end
  end

48
49
50
51
52
53
              

        def dispatch(controller, action, req, res)
          controller.dispatch(action, req, res)
        end
      end

31
32
33
34
35
36
              

          controller = controller req
          res        = controller.make_response! req
          dispatch(controller, params[:action], req, res)
        rescue ActionController::RoutingError
          if @raise_on_name_error
            raise

48
49
50
51
52
53
              

          req.path_parameters = tmp_params

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

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

30
31
32
33
34
35
              

      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

30
31
32
33
34
35
              

      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

840
841
842
843
844
845
              

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

      def recognize_path(path, environment = {})

13
14
15
16
17
18
              

    def call(env)
      env[RACK_TEMPFILES] ||= []
      status, headers, body = @app.call(env)
      body_proxy = BodyProxy.new(body) do
        env[RACK_TEMPFILES].each(&:close!) unless env[RACK_TEMPFILES].nil?
      end

25
26
27
28
29
30
              

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

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

25
26
27
28
29
30
              

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

10
11
12
13
14
15
              

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

      if env[REQUEST_METHOD] == HEAD
        [

20
21
22
23
24
25
              

      def call(env)
        request = ActionDispatch::Request.new(env)
        _, headers, _ = response = @app.call(env)

        return response unless html_response?(headers)
        return response if policy_present?(headers)

16
17
18
19
20
21
              

      def call(env)
        request = ActionDispatch::Request.new env
        _, headers, _ = response = @app.call(env)

        return response unless html_response?(headers)
        return response if policy_present?(headers)

264
265
266
267
268
269
              

          req = make_request env
          prepare_session(req)
          status, headers, body = app.call(req.env)
          res = Rack::Response::Raw.new status, headers
          commit_session(req, res)
          [status, headers, body]

258
259
260
261
262
263
              

        def call(env)
          context(env)
        end

        def context(env, app = @app)

687
688
689
690
691
692
              

      request = ActionDispatch::Request.new env

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

      if request.have_cookie_jar?
        cookie_jar = request.cookie_jar

599
600
601
602
603
604
              

        end

        @app.call(env)
      end

      private

25
26
27
28
29
30
              

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

96
97
98
99
100
101
              

      if callbacks.empty?
        yield if block_given?
      else
        env = Filters::Environment.new(self, false, nil)
        next_sequence = callbacks.compile

24
25
26
27
28
29
              

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

12
13
14
15
16
17
              

      state = @executor.run!
      begin
        response = @app.call(env)
        returned = response << ::Rack::BodyProxy.new(response.pop) { state.complete! }
      ensure
        state.complete! unless returned

16
17
18
19
20
21
              

    def call(env)
      request = ActionDispatch::Request.new(env)
      return @app.call(env) unless actionable_request?(request)

      ActiveSupport::ActionableError.dispatch(request.params[:error].to_s.safe_constantize, request.params[:action])

27
28
29
30
31
32
              

    def call(env)
      request = ActionDispatch::Request.new env
      _, headers, body = response = @app.call(env)

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

130
131
132
133
134
135
              

      def call_app(env)
        @app.call(env)
      rescue => e
        throw :app_exception, e
      end

17
18
19
20
21
22
              

      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return call_app(env) unless request.permitted?

        if id = id_for_repl_session_update(request)
          return update_repl_session(id, request)

15
16
17
18
19
20
              

    def call(env)
      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return call_app(env) unless request.permitted?

15
16
17
18
19
20
              

    def call(env)
      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return call_app(env) unless request.permitted?

31
32
33
34
35
36
              

    def call(env)
      request = ActionDispatch::Request.new env
      @app.call(env)
    rescue Exception => exception
      if request.show_exceptions?
        render_exception(request, exception)

35
36
37
38
39
40
              

          instrumenter.start "request.action_dispatch", request: request
          logger.info { started_request_message(request) }
          status, headers, body = @app.call(env)
          body = ::Rack::BodyProxy.new(body) { finish(request) }
          [status, headers, body]
        rescue Exception

24
25
26
27
28
29
              

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

97
98
99
100
101
102
              

    def tagged(*tags)
      if block_given?
        formatter.tagged(*tags) { yield self }
      else
        logger = ActiveSupport::TaggedLogging.new(self)
        logger.formatter.extend LocalTagStorage

35
36
37
38
39
40
              

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

97
98
99
100
101
102
              

    def tagged(*tags)
      if block_given?
        formatter.tagged(*tags) { yield self }
      else
        logger = ActiveSupport::TaggedLogging.new(self)
        logger.formatter.extend LocalTagStorage

24
25
26
27
28
29
              

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

11
12
13
14
15
16
              

          ::Rails.logger.silence { @app.call(env) }
        else
          @app.call(env)
        end
      end
    end

79
80
81
82
83
84
              

      req = ActionDispatch::Request.new env
      req.remote_ip = GetIp.new(req, check_ip, proxies)
      @app.call(req.env)
    end

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

17
18
19
20
21
22
              

      RequestStore.begin!

      response = @app.call(env)

      returned = response << Rack::BodyProxy.new(response.pop) do
        RequestStore.end!

24
25
26
27
28
29
              

      req = ActionDispatch::Request.new env
      req.request_id = make_request_id(req.headers[@header])
      @app.call(env).tap { |_status, headers, _body| headers[@header] = req.request_id }
    end

    private

22
23
24
25
26
27
              

      end

      @app.call(env)
    end

    def method_override(env)

20
21
22
23
24
25
              

    def call(env)
      start_time = Utils.clock_time
      status, headers, body = @app.call(env)
      headers = Utils::HeaderHash[headers]

      request_time = Utils.clock_time - start_time

27
28
29
30
31
32
              

          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

12
13
14
15
16
17
              

      state = @executor.run!
      begin
        response = @app.call(env)
        returned = response << ::Rack::BodyProxy.new(response.pop) { state.complete! }
      ensure
        state.complete! unless returned

22
23
24
25
26
27
              

    def call(env)
      @file_handler.attempt(env) || @app.call(env)
    end
  end

108
109
110
111
112
113
              

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

96
97
98
99
100
101
              

      if authorized?(request) || excluded?(request)
        mark_as_authorized(request)
        @app.call(env)
      else
        @response_app.call(env)
      end

382
383
384
385
386
387
              

          status, headers, body = [200, { 'Content-Type' => 'text/html' }, [blank_page_html.dup]]
        else
          status, headers, body = @app.call(env)
        end
      ensure
        trace.disable if trace

23
24
25
26
27
28
              

      super(env)
    else
      @app.call(env)
    end
  end

55
56
57
58
59
60
              

    def call(env)
      rewrite_response(perform_request(rewrite_env(env)))
    end

    # Return modified env

537
538
539
540
541
542
              

    def call(env)
      req = build_request env
      app.call req.env
    end

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

246
247
248
249
250
251
              

      def call(env)
        env[Const::PUMA_CONFIG] = @config
        @app.call(env)
      end
    end

74
75
76
77
78
79
              

        begin
          status, headers, res_body = @thread_pool.with_force_shutdown do
            @app.call(env)
          end

          return :async if client.hijacked

335
336
337
338
339
340
              

        t[:with_force_shutdown] = true
      end
      yield
    ensure
      t[:with_force_shutdown] = false
    end

73
74
75
76
77
78
              

      begin
        begin
          status, headers, res_body = @thread_pool.with_force_shutdown do
            @app.call(env)
          end

429
430
431
432
433
434
              

        while true
          @requests_count += 1
          case handle_request(client, buffer)
          when false
            break
          when :async

143
144
145
146
147
148
              

          begin
            @out_of_band_pending = true if block.call(work, *extra)
          rescue Exception => e
            STDERR.puts "Error reached top of thread-pool: #{e.message} (#{e.class})"
          end