NoMethodError in ApiInternal::MailerController#publish

32
33
34
35
36
37
              

    # to compare weak, short secrets to user input.
    def secure_compare(a, b)
      a.bytesize == b.bytesize && fixed_length_secure_compare(a, b)
    end
    module_function :secure_compare
  end

359
360
361
362
363
364
              

          def make_lambda
            lambda do |target, value, &block|
              target.send(@method_name, &block)
            end
          end

176
177
178
179
180
181
              

            if !halted && user_conditions.all? { |c| c.call(target, value) }
              result_lambda = -> { user_callback.call target, value }
              env.halted = halted_lambda.call(target, result_lambda)
              if env.halted
                target.send :halted_callback_hook, filter, name

32
33
34
35
36
37
              

    included do
      define_callbacks :process_action,
                       terminator: ->(controller, result_lambda) { result_lambda.call; controller.performed? },
                       skip_after_callbacks_if_terminated: true
      mattr_accessor :raise_on_missing_callback_actions, default: false
    end

177
178
179
180
181
182
              

            if !halted && user_conditions.all? { |c| c.call(target, value) }
              result_lambda = -> { user_callback.call target, value }
              env.halted = halted_lambda.call(target, result_lambda)
              if env.halted
                target.send :halted_callback_hook, filter, name
              end

557
558
559
560
561
562
              

        def invoke_before(arg)
          @before&.each { |b| b.call(arg) }
        end

        def invoke_after(arg)

557
558
559
560
561
562
              

        def invoke_before(arg)
          @before&.each { |b| b.call(arg) }
        end

        def invoke_after(arg)

557
558
559
560
561
562
              

        def invoke_before(arg)
          @before&.each { |b| b.call(arg) }
        end

        def invoke_after(arg)

116
117
118
119
120
121
              

            while true
              current = next_sequence
              current.invoke_before(env)
              if current.final?
                env.value = !env.halted && (!block_given? || yield)
              elsif current.skip?(env)

22
23
24
25
26
27
              

    def with_request_id(request_id)
      old_request_id, self.current_request_id = self.current_request_id, request_id
      yield
    ensure
      self.current_request_id = old_request_id
    end

8
9
10
11
12
              

  private
    def turbo_tracking_request_id(&block)
      Turbo.with_request_id(request.headers["X-Turbo-Request-Id"], &block)
    end
end

127
128
129
130
131
132
              

                begin
                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
                  target.send(method, *arguments, &block)
                ensure
                  next_sequence = current
                end

138
139
140
141
142
143
              

          end

          invoke_sequence.call
        end
      end
    end

258
259
260
261
262
263
              

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

25
26
27
28
29
30
              

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

74
75
76
77
78
79
              

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

208
209
210
211
212
213
              

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

56
57
58
59
60
61
              

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

208
209
210
211
212
213
              

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

73
74
75
76
77
78
              

        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

257
258
259
260
261
262
              

      def process_action(*)
        _perform_parameter_wrapping if _wrapper_enabled?
        super
      end

      # Returns the wrapper key which will be used to store wrapped parameters.

37
38
39
40
41
42
              

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

        def cleanup_view_runtime

161
162
163
164
165
166
              

      @_response_body = nil

      process_action(action_name, ...)
    end

    # Delegates to the class's ::controller_path.

38
39
40
41
42
43
              

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

250
251
252
253
254
255
              

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

333
334
335
336
337
338
              

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

65
66
67
68
69
70
              

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

48
49
50
51
52
53
              

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

51
52
53
54
55
56
              

          req.route_uri_pattern = route.path.spec.to_s

          _, headers, _ = response = route.app.serve(req)

          if "pass" == headers[Constants::X_CASCADE]
            req.script_name     = script_name

131
132
133
134
135
136
              

              path_parameters[name.to_sym] = Utils.unescape_uri(val) if val
            }
            yield [match_data, path_parameters, r]
          }
        end

124
125
126
127
128
129
              

          routes.sort_by!(&:precedence)

          routes.each { |r|
            match_data = r.path.match(path_info)
            path_parameters = {}
            match_data.names.each_with_index { |name, i|

124
125
126
127
128
129
              

          routes.sort_by!(&:precedence)

          routes.each { |r|
            match_data = r.path.match(path_info)
            path_parameters = {}
            match_data.names.each_with_index { |name, i|

32
33
34
35
36
37
              

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

906
907
908
909
910
911
              

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

      def recognize_path(path, environment = {})

66
67
68
69
70
71
              

      def call(req)
        Rails.application&.reload_routes_unless_loaded
        super
      end

      def draw(&block)

47
48
49
50
51
52
              

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

      if !@ignore_cascade_pass && headers["X-Cascade"] == "pass"
        msg = "This exception means that the preceding Rack middleware set the 'X-Cascade' header to 'pass' -- in " \

18
19
20
21
22
23
              

      begin
        _, _, body = response = @app.call(env)
      rescue Exception
        env[RACK_TEMPFILES]&.each(&:close!)
        raise

27
28
29
30
31
32
              

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

      if etag_status?(status) && body.respond_to?(:to_ary) && !skip_caching?(headers)
        body = body.to_ary

41
42
43
44
45
46
              

        response
      else
        @app.call(env)
      end
    end

13
14
15
16
17
18
              

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

      if env[REQUEST_METHOD] == HEAD
        response[2] = Rack::BodyProxy.new([]) do

36
37
38
39
40
41
              

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

        return response if policy_present?(headers)

36
37
38
39
40
41
              

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

        # Returning CSP headers with a 304 Not Modified is harmful, since nonces in the
        # new CSP headers might not match nonces in the cached HTML.

272
273
274
275
276
277
              

          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]

266
267
268
269
270
271
              

        def call(env)
          context(env)
        end

        def context(env, app = @app)

704
705
706
707
708
709
              

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

      if request.have_cookie_jar?
        cookie_jar = request.cookie_jar

669
670
671
672
673
674
              

        end

        @app.call(env)
      end

      private

29
30
31
32
33
34
              

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

98
99
100
101
102
103
              

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

28
29
30
31
32
33
              

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

14
15
16
17
18
19
              

      state = @executor.run!(reset: true)
      begin
        response = @app.call(env)

        if env["action_dispatch.report_exception"]
          error = env["action_dispatch.exception"]

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])

9
10
11
12
13
14
              

      def call(env)
        return @app.call(env) unless Sentry.initialized?

        begin
          @app.call(env)

29
30
31
32
33
34
              

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

      if headers[Constants::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

26
27
28
29
30
31
              

        status, headers, body = call_app(env)

        if (session = Session.from(Thread.current)) && acceptable_content_type?(headers)
          headers["x-web-console-session-id"] = session.id

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?

13
14
15
16
17
18
              

      def call(env)
        return @app.call(env) unless Sentry.initialized?

        # make sure the current thread has a clean hub
        Sentry.clone_hub_to_current_thread

30
31
32
33
34
35
              

    def call(env)
      @app.call(env)
    rescue Exception => exception
      request = ActionDispatch::Request.new env
      backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")

39
40
41
42
43
44
              

          logger.info { started_request_message(request) }
          status, headers, body = response = @app.call(env)
          body = ::Rack::BodyProxy.new(body) { finish_request_instrumentation(handle, logger_tag_pop_count) }

          if response.frozen?

27
28
29
30
31
32
              

        end

        call_app(request, env)
      end

      private

94
95
96
97
98
99
              

      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 into

26
27
28
29
30
31
              

      end

      @app.call(env)
    end

    def method_override(env)

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

59
60
61
62
63
64
              

      response = nil
      events = @subscriber.collect_events do
        response = @app.call(env)
      end

      headers = response[1]

24
25
26
27
28
29
              

        events = []
        ActiveSupport::IsolatedExecutionState[KEY] = events
        yield
        events
      ensure
        ActiveSupport::IsolatedExecutionState.delete(KEY)

58
59
60
61
62
63
              

    def call(env)
      response = nil
      events = @subscriber.collect_events do
        response = @app.call(env)
      end

14
15
16
17
18
19
              

      state = @executor.run!(reset: true)
      begin
        response = @app.call(env)

        if env["action_dispatch.report_exception"]
          error = env["action_dispatch.exception"]

25
26
27
28
29
30
              

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

112
113
114
115
116
117
              

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

      if body.respond_to?(:to_path)
        case type = variation(env)

91
92
93
94
95
96
              

        end

        @app.call(env)
    end

    def real_ip(env)

533
534
535
536
537
538
              

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

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

277
278
279
280
281
282
              

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

97
98
99
100
101
102
              

        if @supported_http_methods == :any || @supported_http_methods.key?(env[REQUEST_METHOD])
          status, headers, app_body = @thread_pool.with_force_shutdown do
            @app.call(env)
          end
        else
          @log_writer.log "Unsupported HTTP method used: #{env[REQUEST_METHOD]}"

388
389
390
391
392
393
              

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

96
97
98
99
100
101
              

      begin
        if @supported_http_methods == :any || @supported_http_methods.key?(env[REQUEST_METHOD])
          status, headers, app_body = @thread_pool.with_force_shutdown do
            @app.call(env)
          end
        else

470
471
472
473
474
475
              

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

252
253
254
255
256
257
              

      @status = :run

      @thread_pool = ThreadPool.new(thread_name, options) { |client| process_client client }

      if @queue_requests
        @reactor = Reactor.new(@io_selector_backend) { |c| reactor_wakeup c }

165
166
167
168
169
170
              

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