Class: CMDx::Retriers

Inherits:
Object
  • Object
show all
Defined in:
lib/cmdx/retriers.rb,
lib/cmdx/retriers/linear.rb,
lib/cmdx/retriers/fibonacci.rb,
lib/cmdx/retriers/exponential.rb,
lib/cmdx/retriers/full_random.rb,
lib/cmdx/retriers/half_random.rb,
lib/cmdx/retriers/bounded_random.rb,
lib/cmdx/retriers/decorrelated_jitter.rb

Overview

Registry of named retry/jitter strategies used by Retry to compute the sleep duration between attempts. Ships with built-ins for :exponential, :half_random, :full_random, :bounded_random, :linear, :fibonacci, and :decorrelated_jitter. A retrier is any callable accepting call(attempt, delay, prev_delay) that returns the next delay in seconds.

Defined Under Namespace

Modules: BoundedRandom, DecorrelatedJitter, Exponential, Fibonacci, FullRandom, HalfRandom, Linear

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Retriers

Returns a new instance of Retriers.



13
14
15
16
17
18
19
20
21
22
23
 
# File 'lib/cmdx/retriers.rb', line 13

def initialize
  @registry = {
    exponential: Retriers::Exponential,
    half_random: Retriers::HalfRandom,
    full_random: Retriers::FullRandom,
    bounded_random: Retriers::BoundedRandom,
    linear: Retriers::Linear,
    fibonacci: Retriers::Fibonacci,
    decorrelated_jitter: Retriers::DecorrelatedJitter
  }
end

Instance Attribute Details

#registry ⇒ Object (readonly)

Returns the value of attribute registry.



11
12
13
 
# File 'lib/cmdx/retriers.rb', line 11

def registry
  @registry
end

Instance Method Details

#deregister(name) ⇒ Retriers

Returns self for chaining.

Parameters:

  • name (Symbol)

Returns:



55
56
57
58
 
# File 'lib/cmdx/retriers.rb', line 55

def deregister(name)
  registry.delete(name.to_sym)
  self
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


96
97
98
 
# File 'lib/cmdx/retriers.rb', line 96

def empty?
  registry.empty?
end

#initialize_copy(source) ⇒ void

This method returns an undefined value.

Parameters:

  • source (Retriers) —

    registry to duplicate



27
28
29
 
# File 'lib/cmdx/retriers.rb', line 27

def initialize_copy(source)
  @registry = source.registry.dup
end

#key?(name) ⇒ Boolean

Returns whether a retrier is registered under name.

Parameters:

  • name (Symbol)

Returns:

  • (Boolean) —

    whether a retrier is registered under name



62
63
64
 
# File 'lib/cmdx/retriers.rb', line 62

def key?(name)
  registry.key?(name.to_sym)
end

#lookup(name) ⇒ #call

Returns the registered retrier.

Parameters:

  • name (Symbol)

Returns:

  • (#call) —

    the registered retrier

Raises:

  • (ArgumentError) —

    when name isn't registered



69
70
71
72
73
 
# File 'lib/cmdx/retriers.rb', line 69

def lookup(name)
  registry[name] || begin
    raise ArgumentError, "unknown retrier: #{name.inspect}"
  end
end

#register(name, callable = nil, &block) { ... } ⇒ Retriers

Registers a named retrier, overwriting any existing entry.

Parameters:

  • name (Symbol)
  • callable (#call, nil) (defaults to: nil) —

    pass either this or a block

  • block (#call, nil) —

    retrier callable when callable is omitted

Yields:

  • retrier body — call(attempt, delay, prev_delay)

Returns:

Raises:

  • (ArgumentError) —

    when both callable and a block are given, or when the resolved retrier isn't callable



40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/cmdx/retriers.rb', line 40

def register(name, callable = nil, &block)
  retrier = callable || block

  if callable && block
    raise ArgumentError, "provide either a callable or a block, not both"
  elsif !retrier.respond_to?(:call)
    raise ArgumentError, "retrier must respond to #call"
  end

  registry[name.to_sym] = retrier
  self
end

#resolve(spec) ⇒ #call?

Resolves a :jitter spec to a concrete callable. Accepts a Symbol (registry lookup) or any object responding to #call. nil resolves to nil so callers can fall back to the unjittered base delay.

Parameters:

  • spec (Symbol, #call, nil)

Returns:

  • (#call, nil)

Raises:

  • (ArgumentError) —

    when spec is an unknown symbol or not callable



82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/cmdx/retriers.rb', line 82

def resolve(spec)
  case spec
  when NilClass
    nil
  when Symbol
    lookup(spec)
  else
    return spec if spec.respond_to?(:call)

    raise ArgumentError, "unknown retrier: #{spec.inspect}"
  end
end

#size ⇒ Integer

Returns:

  • (Integer) 


101
102
103
 
# File 'lib/cmdx/retriers.rb', line 101

def size
  registry.size
end