Module: Retryable

Defined in:
lib/retryable.rb,
lib/retryable/version.rb,
lib/retryable/configuration.rb

Defined Under Namespace

Classes: Configuration, Version

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.configuration ⇒ Object

The configuration object.

See Also:



28
29
30
 
# File 'lib/retryable.rb', line 28

def configuration
  @configuration ||= Configuration.new
end

Class Method Details

.configure {|configuration| ... } ⇒ Object

Call this method to modify defaults in your initializers.

Examples:

Retryable.configure do |config|
  config.ensure       = Proc.new {}
  config.exception_cb = Proc.new {}
  config.matching     = /.*/
  config.on           = StandardError
  config.sleep        = 1
  config.tries        = 2
  config.not          = []
end

Yields:



22
23
24
 
# File 'lib/retryable.rb', line 22

def configure
  yield(configuration)
end

.disable ⇒ Object 



40
41
42
 
# File 'lib/retryable.rb', line 40

def disable
  configuration.disable
end

.enable ⇒ Object 



36
37
38
 
# File 'lib/retryable.rb', line 36

def enable
  configuration.enable
end

.enabled? ⇒ Boolean

Returns:

  • (Boolean) 


32
33
34
 
# File 'lib/retryable.rb', line 32

def enabled?
  configuration.enabled?
end

.retryable(options = {}, &block) ⇒ Object 



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/retryable.rb', line 44

def retryable(options = {}, &block)
  opts = {
    :tries        => self.configuration.tries,
    :sleep        => self.configuration.sleep,
    :on           => self.configuration.on,
    :matching     => self.configuration.matching,
    :ensure       => self.configuration.ensure,
    :exception_cb => self.configuration.exception_cb,
    :not          => self.configuration.not,
    :sleep_method => self.configuration.sleep_method
  }

  check_for_invalid_options(options, opts)
  opts.merge!(options)

  return if opts[:tries] == 0

  on_exception = [ opts[:on] ].flatten
  not_exception = [ opts[:not] ].flatten
  tries = opts[:tries]
  retries = 0
  retry_exception = nil

  begin
    return yield retries, retry_exception
  rescue *not_exception
    raise
  rescue *on_exception => exception
    raise unless configuration.enabled?
    raise unless exception.message =~ opts[:matching]
    raise if tries != :infinite && retries+1 >= tries

    # Interrupt Exception could be raised while sleeping
    begin
      seconds = opts[:sleep].respond_to?(:call) ? opts[:sleep].call(retries) : opts[:sleep]
      opts[:sleep_method].call(seconds)
    rescue *not_exception
      raise
    rescue *on_exception
    end

    retries += 1
    retry_exception = exception
    opts[:exception_cb].call(retry_exception)
    retry
  ensure
    opts[:ensure].call(retries)
  end
end