OAuth::Unauthorized

153
154
155
156
157
158
              

        *arguments, &block)
      else
        response = token_request(http_method, (request_token_url? ? request_token_url : request_token_path), nil, request_options, *arguments)
      end
      OAuth::RequestToken.from_hash(self, response)
    end

26
27
28
29
30
31
              

      def request_phase # rubocop:disable MethodLength
        request_token = consumer.get_request_token({:oauth_callback => callback_url}, options.request_params)
        session["oauth"] ||= {}
        session["oauth"][name.to_s] = {"callback_confirmed" => request_token.callback_confirmed?, "request_token" => request_token.token, "request_secret" => request_token.secret}

59
60
61
62
63
64
              

        end

        old_request_phase
      end

      alias :old_callback_url :callback_url

224
225
226
227
228
229
              

        end

        request_phase
      end
    end

186
187
188
189
190
191
              

      return mock_call!(env) if OmniAuth.config.test_mode
      return options_call if on_auth_path? && options_request?
      return request_call if on_request_path? && OmniAuth.config.allowed_request_methods.include?(request.request_method.downcase.to_sym)
      return callback_call if on_callback_path?
      return other_phase if respond_to?(:other_phase)

167
168
169
170
171
172
              

    # @param [Hash] The Rack environment.
    def call(env)
      dup.call!(env)
    end

    # The logic for dispatching any additional actions that need

190
191
192
193
194
195
              

      return other_phase if respond_to?(:other_phase)

      @app.call(env)
    end

    # Responds to an OPTIONS request.

167
168
169
170
171
172
              

    # @param [Hash] The Rack environment.
    def call(env)
      dup.call!(env)
    end

    # The logic for dispatching any additional actions that need

34
35
36
37
38
39
              

      result = catch(:warden) do
        env['warden'].on_request
        @app.call(env)
      end

      result ||= {}

32
33
34
35
36
37
              

      env['warden'] = Proxy.new(env, self)
      result = catch(:warden) do
        env['warden'].on_request
        @app.call(env)
      end

32
33
34
35
36
37
              

      env['warden'] = Proxy.new(env, self)
      result = catch(:warden) do
        env['warden'].on_request
        @app.call(env)
      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
        [

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)

611
612
613
614
615
616
              

      request = ActionDispatch::Request.new env

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

      if request.have_cookie_jar?
        cookie_jar = request.cookie_jar

551
552
553
554
555
556
              

          end
        end
        @app.call(env)
      end

      private

36
37
38
39
40
41
              

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

95
96
97
98
99
100
              

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

748
749
750
751
752
753
              

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

88
89
90
91
92
93
              

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

    private

34
35
36
37
38
39
              

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

10
11
12
13
14
15
              

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

77
78
79
80
81
82
              

      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

57
58
59
60
61
62
              

        better_errors_call env
      else
        @app.call env
      end
    end

47
48
49
50
51
52
              

    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)

18
19
20
21
22
23
              

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

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

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?

29
30
31
32
33
34
              

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

34
35
36
37
38
39
              

        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

22
23
24
25
26
27
              

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

67
68
69
70
71
72
              

    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

67
68
69
70
71
72
              

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

    def flush

22
23
24
25
26
27
              

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

17
18
19
20
21
22
              

      RequestStore.begin!

      response = @app.call(env)

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

22
23
24
25
26
27
              

      req = ActionDispatch::Request.new env
      req.request_id = make_request_id(req.x_request_id)
      @app.call(env).tap { |_status, headers, _body| headers[X_REQUEST_ID] = 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

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

10
11
12
13
14
15
              

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

134
135
136
137
138
139
              

      end

      @app.call(req.env)
    end
  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'

520
521
522
523
524
525
              

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

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

105
106
107
108
109
110
              

          begin
            status, headers, body = @app.call(env)
          rescue => e
            if e.is_a?(Errno::ENOBUFS)
              raise e

147
148
149
150
151
152
              

          begin
            if headers[REQUEST_METHOD] == GET
              process_request(headers, connection, socket_wrapper, @protocol == :http)
            elsif headers[REQUEST_METHOD] == PING
              process_ping(headers, connection)
              false

108
109
110
111
112
113
              

          finish_callback.call
          while true
            hijacked = accept_and_process_next_request(socket_wrapper, channel, buffer)
            socket_wrapper = Utils::UnseekableSocket.new if hijacked
          end
        rescue Interrupted

417
418
419
420
421
422
              

              handler = thread_handler.new(self, main_socket_options)
              handler.install
              handler.main_loop(set_initialization_state_to_true)
            ensure
              set_initialization_state.call(false)
              unregister_current_thread

111
112
113
114
115
116
              

        Thread.current.abort_on_exception = true
        begin
          yield(*args)
        rescue SystemExit
          raise
        rescue Exception => e