405 error

[yondaimeorg]

The captcha seems to be working properly - if don't do it, a comment is not submitted. If I do, it proceeds, and even if I check the g-captcha-response with my secret key, it gives success: true. However, I am getting this error, and the comment never is saved.

405 "Method Not Allowed" Extracted source (around line #119): 117 118 119 120 121 122

def error! #:nodoc: raise error_type().new(@code + ' ' + @message.dump, self) end

def error_type #:nodoc:

Extracted source (around line #128): 126 127 128 129 130 131

Raises an HTTP error if the response is not 2xx (success).

def value error! unless self.kind_of?(Net::HTTPSuccess) end

def uri= uri # :nodoc:

What is causing this?

[grosser]

does not look like a recaptcha related error ... 405 means that there is a request coming in with a unexpected http verb ... so check your logs / your routes

[yondaimeorg]

The logs say:

Recaptcha::RecaptchaError (405 "Method Not Allowed"): app/controllers/comments_controller.rb:10:in `create'

So I thought it was a Recaptcha error.

[grosser]

ahhh line 10 is the verify_recaptcha ?

[grosser]

can you post more of the backtrace ? open-source project ?

[yondaimeorg]

What do you mean by backtrace?

This is not an open source project, so I cannot post too much of the code.

[grosser]

backtrace from the error so I can see what line/backtrace it is coming from ... ... ideally can you reproduce with the example app ?

On Mon, Aug 29, 2016 at 1:26 PM, narutoniue notifications@github.com wrote:

What do you mean by backtrace?

This is not an open source project, so I cannot post too much of the code.

— You are receiving this because you modified the open/close state. Reply to this email directly, view it on GitHub https://github.com/ambethia/recaptcha/issues/196#issuecomment-243244810, or mute the thread https://github.com/notifications/unsubscribe-auth/AAAsZ0RZn_mLO-U1S7IwJR8uCpVndFzkks5qk0CDgaJpZM4JvxoP .

[yondaimeorg]

So in short, there is a pop up modal that has the contact form and recaptcha in it. It properly does not submit the form if the user fails to answer the reCaptcha or answer it correctly. Upon hitting submit, the form is lined to the controller for the create function, which includes the reCaptcha verify step.

Upon hitting submit, I see this error in the console:

POST http://.../comments  500 Internal Server Error  375ms

Expansion of the error in the console provides this:

405 "Method Not Allowed" Extracted source (around line #119):

117 118 119 120 121 122

def error! #:nodoc: raise error_type().new(@code + ' ' + @message.dump, self) end

def error_type #:nodoc:

Extracted source (around line #128):

126 127 128 129 130 131

Raises an HTTP error if the response is not 2xx (success).

def value error! unless self.kind_of?(Net::HTTPSuccess) end

def uri= uri # :nodoc:

Extracted source (around line #915):

913 914 915 916 917 918

        buf << "\r\n"
        @socket.write(buf)
        HTTPResponse.read_new(@socket).value
      end
      # Server Name Indication (SNI) RFC 3546
      s.hostname = @address if s.respond_to? :hostname=

Extracted source (around line #863):

861 862 863 864 865 866

def do_start
  connect
  @started = true
end
private :do_start

Extracted source (around line #852):

850 851 852 853 854 855

  if block_given?
    begin
      do_start
      return yield(self)
    ensure
      do_finish

Extracted source (around line #1375):

1373 1374 1375 1376 1377 1378

def request(req, body = nil, &block)  # :yield: +response+
  unless started?
    start {
      req['connection'] ||= 'close'
      return request(req, body, &block)
    }

Extracted source (around line #59):

57 58 59 60 61 62

http_instance.use_ssl = true if uri.port == 443
request = Net::HTTP::Get.new(uri.request_uri)
http_instance.request(request).body

end

def self.i18n(key, default)

Extracted source (around line #74):

72 73 74 75 76 77

  }

  reply = JSON.parse(Recaptcha.get(verify_hash, options))
  reply['success'].to_s == "true" &&
    recaptcha_hostname_valid?(reply['hostname'], options[:hostname])
end

Extracted source (around line #19):

17 18 19 20 21 22

      false
    else
      recaptcha_verify_via_api_call(request, recaptcha_response, options

) end

    if verified

Extracted source (around line #10):

8 9 10 11 12 13

def create @comment = Comment.new(comment_params) if verify_recaptcha(model: @comment) @comment.save redirect_to :back else

Extracted source (around line #4):

2 3 4 5 6 7

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

Extracted source (around line #198):

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

Extracted source (around line #10):

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

.

Extracted source (around line #20):

18 19 20 21 22 23

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

Extracted source (around line #117):

115 116 117 118 119 120

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

Extracted source (around line #117):

115 116 117 118 119 120

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

Extracted source (around line #555):

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

Extracted source (around line #505):

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

Extracted source (around line #505):

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

Extracted source (around line #92):

90 91 92 93 94 95

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

Extracted source (around line #776):

774 775 776 777 778 779

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

Extracted source (around line #81):

79 80 81 82 83 84

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

private

Extracted source (around line #19):

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

Extracted source (around line #29):

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)

Extracted source (around line #32):

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

Extracted source (around line #164):

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

Extracted source (around line #20):

18 19 20 21 22 23

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

Extracted source (around line #164):

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

Extracted source (around line #30):

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

Extracted source (around line #250):

248 249 250 251 252 253

    request.filtered_parameters.merge! wrapped_filtered_hash
  end
  super
end

private

Extracted source (around line #18):

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

Extracted source (around line #137):

135 136 137 138 139 140

  @_response_body = nil

  process_action(action_name, *args)
end

# Delegates to the class' #controller_path

Extracted source (around line #30):

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

Extracted source (around line #196):

194 195 196 197 198 199

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

Extracted source (around line #13):

11 12 13 14 15 16

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

def response_body=(body)

Extracted source (around line #237):

235 236 237 238 239 240

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

end

Extracted source (around line #74):

72 73 74 75 76 77

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

    def normalize_controller!(params)

Extracted source (around line #74):

72 73 74 75 76 77

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

    def normalize_controller!(params)

Extracted source (around line #43):

41 42 43 44 45 46

      end

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

    def prepare_params!(params)

Extracted source (around line #43):

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

Extracted source (around line #30):

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

Extracted source (around line #30):

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

Extracted source (around line #819):

817 818 819 820 821 822

    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 = {})

Extracted source (around line #35):

33 34 35 36 37 38

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

  result ||= {}

Extracted source (around line #34):

32 33 34 35 36 37

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

Extracted source (around line #34):

32 33 34 35 36 37

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

Extracted source (around line #24):

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

Extracted source (around line #38):

36 37 38 39 40 41

    [status, headers, body]
  else
    @app.call(env)
  end
end

Extracted source (around line #13):

11 12 13 14 15 16

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

if env[REQUEST_METHOD] == HEAD
  [

Extracted source (around line #27):

25 26 27 28 29 30

  end

  @app.call(env)
end

private

Extracted source (around line #260):

258 259 260 261 262 263

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

Extracted source (around line #225):

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

Extracted source (around line #220):

218 219 220 221 222 223

    def call(env)
      context(env)
    end

    def context(env, app=@app)

Extracted source (around line #560):

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?

Extracted source (around line #36):

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

Extracted source (around line #649):

647 648 649 650 651 652

    testing = env['rack.test']

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

Extracted source (around line #378):

376 377 378 379 380 381

      end
    end
    @app.call(env)
  end

  private

Extracted source (around line #29):

27 28 29 30 31 32

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

Extracted source (around line #88):

86 87 88 89 90 91

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

Extracted source (around line #88):

86 87 88 89 90 91

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

Extracted source (around line #776):

774 775 776 777 778 779

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

Extracted source (around line #81):

79 80 81 82 83 84

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

private

Extracted source (around line #27):

25 26 27 28 29 30

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

Extracted source (around line #73):

71 72 73 74 75 76

  prepare!

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

  response

Extracted source (around line #78):

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

Extracted source (around line #59):

57 58 59 60 61 62

    better_errors_call env
  else
    @app.call env
  end
end

Extracted source (around line #17):

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)

Extracted source (around line #31):

29 30 31 32 33 34

def call(env)
  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)

Extracted source (around line #30):

28 29 30 31 32 33

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

Extracted source (around line #38):

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

Extracted source (around line #20):

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

Extracted source (around line #68):

66 67 68 69 70 71

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

def flush

Extracted source (around line #26):

24 25 26 27 28 29

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

Extracted source (around line #68):

66 67 68 69 70 71

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

def flush

Extracted source (around line #20):

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

Extracted source (around line #21):

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

Extracted source (around line #22):

20 21 22 23 24 25

  end

  @app.call(env)
end

def method_override(env)

Extracted source (around line #18):

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)

Extracted source (around line #28):

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

Extracted source (around line #17):

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

Extracted source (around line #113):

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'

Extracted source (around line #518):

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.

Extracted source (around line #164):

162 163 164 165 166 167

  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.

Extracted source (around line #97):

95 96 97 98 99 100

      begin
        status, headers, body = @app.call(env)
      rescue => e
        if !should_swallow_app_error?(e, socket_wrapper)
          # It's a good idea to catch application exceptions here because

Extracted source (around line #160):

158 159 160 161 162 163

          false
        else
          process_request(headers, connection, socket_wrapper, @protocol

== :http) end rescue Exception has_error = true

Extracted source (around line #113):

111 112 113 114 115 116

      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

Extracted source (around line #416):

414 415 416 417 418 419

          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

Extracted source (around line #113):

111 112 113 114 115 116

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

I hope this is what you were looking for.

[grosser]

request goes to google and somehow does not result in an success ... I'd guess the token is wrong ... otherwise maybe some connection trouble ...

see if the example app works with your token ...

dump what response gets back (add some code before the raise unless success) ... maybe it says why its not working

[stevenm111]

I am experiencing this same issue , code was working fine,nothing changed that I'm aware of , now throws this error,

rails 4.2.6 ruby 2.3.8

happens when call verify_recaptcha

I have a response from google in my params, but error is

 118 119 120 121 122 123 | 

 def error!   #:nodoc:     
      raise error_type().new(@code + ' ' + @message.dump, self)   
  end  

 def error_type   #:nodoc:

-- | --