Method: Timeout.timeout

Defined in:

lib/timeout.rb

.timeout(sec, klass = nil, message = nil, &block) ⇒ Object

Perform an operation in a block, raising an error if it takes longer than sec seconds to complete.

sec

Number of seconds to wait for the block to terminate. Any non-negative number or nil may be used, including Floats to specify fractional seconds. A value of 0 or nil will execute the block without any timeout. Any negative number will raise an ArgumentError.

klass

Exception Class to raise if the block fails to terminate in sec seconds. Omitting will use the default, Timeout::Error

message

Error message to raise with Exception Class. Omitting will use the default, “execution expired”

Returns the result of the block if the block completed before sec seconds, otherwise throws an exception, based on the value of klass.

The exception thrown to terminate the given block cannot be rescued inside the block unless klass is given explicitly. However, the block can use ensure to prevent the handling of the exception. For that reason, this method cannot be relied on to enforce timeouts for untrusted blocks.

If a scheduler is defined, it will be used to handle the timeout by invoking Scheduler#timeout_after.

Note that this is both a method of module Timeout, so you can include Timeout into your classes so they have a #timeout method, as well as a module method, so you can call it directly as Timeout.timeout().

Raises:

• (ArgumentError)

# File 'lib/timeout.rb', line 202

def self.timeout(sec, klass = nil, message = nil, &block)   #:yield: +sec+
  return yield(sec) if sec == nil or sec.zero?
  raise ArgumentError, "Timeout sec must be a non-negative number" if 0 > sec

  message ||= "execution expired"

  if Fiber.respond_to?(:current_scheduler) && (scheduler = Fiber.current_scheduler)&.respond_to?(:timeout_after)
    return scheduler.timeout_after(sec, klass || Error, message, &block)
  end

  state = State.instance
  state.ensure_timeout_thread_created

  perform = Proc.new do |exc|
    request = Request.new(Thread.current, sec, exc, message)
    state.queue_mutex.synchronize do
      state.queue << request
      state.condvar.signal
    end
    begin
      return yield(sec)
    ensure
      request.finished
    end
  end

  if klass
    perform.call(klass)
  else
    Error.handle_timeout(message, &perform)
  end
end