' 106 | ``` 107 | 108 | ### First-time success: 109 | 110 | ``` 111 | % ruby example.rb http://www.google.com/ 112 | Response status: 200 113 | ``` 114 | 115 | ### First fail, second success: 116 | 117 | ``` 118 | % ruby example.rb http://www.google.com/ 119 | Failed (Simulated random failure). Retrying in 0.01 seconds... 120 | Response status: 200 121 | ``` 122 | 123 | ### Try multiple database hosts 124 | 125 | This one tries a shuffled list of database hosts. 126 | 127 | ``` 128 | % ruby example-sequel.rb 129 | Failed (PG::Error: could not translate host name "pg-replica-b" to address: Name or service not known 130 | ). Retrying in 0.01 seconds... 131 | Failed (PG::Error: could not translate host name "pg-replica-c" to address: Name or service not known 132 | ). Retrying in 0.02 seconds... 133 | Failed (PG::Error: could not translate host name "pg-replica-a" to address: Name or service not known 134 | ). Retrying in 0.04 seconds... 135 | /home/jls/projects/software-patterns/retry-on-failure/ruby/lib/try.rb:75:in `try': PG::Error: could not translate host name "pg-replica-a" to address: Name or service not known (Sequel::DatabaseConnectionError) 136 | from example-sequel.rb:9:in `

' 137 | ``` 138 | -------------------------------------------------------------------------------- /retry-on-failure/ruby/example-sequel.rb: -------------------------------------------------------------------------------- 1 | require "sequel" 2 | require "./lib/try" 3 | 4 | pg_hosts = ["pg-replica-a", "pg-replica-b", "pg-replica-c"] 5 | 6 | # Try connecting to any database host. 7 | # Also, shuffle the list before attempting so that we get a more balanced 8 | # connection load. 9 | database = try(pg_hosts.shuffle) do |host| 10 | db = Sequel.connect("postgres://#{host}/example") 11 | # Sequel::Database#test_connection returns true if successful. 12 | # So return the db if we succeed, otherwise raises an error 13 | # in which case we will retry. 14 | db if db.test_connection 15 | end 16 | -------------------------------------------------------------------------------- /retry-on-failure/ruby/example.rb: -------------------------------------------------------------------------------- 1 | # A simple example that does a HTTP fetch and retries a few times on failure. 2 | require "./lib/http" # implements the HTTP.get method 3 | require "./lib/try" # actually implements the begin/rescue/retry code. 4 | 5 | if ARGV.length != 1 6 | puts "Usage: #{$0} " 7 | puts "Example: #{$0} http://www.google.com/" 8 | exit 1 9 | end 10 | 11 | url = ARGV[0] 12 | 13 | response = try(5.times) do 14 | # Simulate failure 70% of the time. 15 | raise HTTP::Error, "Simulated random failure" if rand < 0.70 16 | HTTP.get(url) 17 | end 18 | 19 | puts "Response status: #{response.status}" 20 | 21 | -------------------------------------------------------------------------------- /retry-on-failure/ruby/lib/http.rb: -------------------------------------------------------------------------------- 1 | require "ftw" # gem install 'ftw' 2 | 3 | module HTTP 4 | class Error < StandardError; end 5 | def self.get(url) 6 | response = agent.get!(url) 7 | 8 | # Raise an exception on server errors. 9 | if (500..599).include?(response.status) 10 | raise Error, "Status code #{response.status} from GET #{url}" 11 | end 12 | 13 | return response 14 | end # def self.get 15 | 16 | def self.agent 17 | @agent ||= FTW::Agent.new 18 | end # def self.agent 19 | end # module HTTP 20 | -------------------------------------------------------------------------------- /retry-on-failure/ruby/lib/try.rb: -------------------------------------------------------------------------------- 1 | # Public: try a block of code until either it succeeds or we give up. 2 | # 3 | # enumerable - an Enumerable or omitted, #each is invoked and is tried that 4 | # number of times. If this value is omitted or nil, we will try until 5 | # success with no limit on the number of tries. 6 | # 7 | # Returns the return value of the block once the block succeeds. 8 | # Raises the last seen exception if we run out of tries. 9 | # 10 | # Examples 11 | # 12 | # # Try 10 times 13 | # response = try(10.times) { Net::HTTP.get_response("google.com", "/") } 14 | # 15 | # # Try many times, yielding the value of the enumeration to the block. 16 | # # This allows you to try different inputs. 17 | # response = try([0, 2, 4, 6]) { |val| 50 / val } 18 | # 19 | # Output: 20 | # Failed (divided by 0). Retrying in 0.01 seconds... 21 | # => 25 22 | # 23 | # 24 | # # Try forever 25 | # return_value = try { ... } 26 | # 27 | # The above will try fetching http://google.com/ at most 10 times, breaking 28 | # after the first non-exception return. 29 | def try(enumerable=nil, &block) 30 | if block.arity == 0 31 | # If the block takes no arguments, give none 32 | procedure = lambda { |val| block.call } 33 | else 34 | # Otherwise, pass the current 'enumerable' value to the block. 35 | procedure = lambda { |val| block.call(val) } 36 | end 37 | 38 | last_exception = nil 39 | 40 | # Retry after a sleep to be nice. 41 | backoff = 0.01 42 | backoff_max = 2.0 43 | 44 | # Try forever if enumerable is nil. 45 | if enumerable.nil? 46 | enumerable = Enumerator.new do |y| 47 | a = 0 48 | while true 49 | a += 1 50 | y << a 51 | end 52 | end 53 | end 54 | 55 | # When 'enumerable' runs out of things, if we still haven't succeeded, we'll 56 | # reraise 57 | enumerable.each do |val| 58 | begin 59 | # If the 'procedure' (the block, really) succeeds, we'll break 60 | # and return the return value of the block. Win! 61 | return procedure.call(val) 62 | rescue => e 63 | puts "Failed (#{e}). Retrying in #{backoff} seconds..." 64 | last_exception = e 65 | 66 | # Exponential backoff 67 | sleep(backoff) 68 | backoff = [backoff * 2, backoff_max].min unless backoff == backoff_max 69 | end 70 | end 71 | 72 | # generally make the exception appear from the 'try' method itself, not from 73 | # any deeply nested enumeration/begin/etc 74 | last_exception.set_backtrace(StandardError.new.backtrace) 75 | raise last_exception 76 | end # def try 77 | -------------------------------------------------------------------------------- /supervising-threads/ruby/lib/supervise.rb: -------------------------------------------------------------------------------- 1 | require "thread" 2 | 3 | class Supervisor 4 | def initialize(*args, &block) 5 | @args = args 6 | @block = block 7 | 8 | run 9 | end # def initialize 10 | 11 | def run 12 | while true 13 | task = Task.new(*@args, &@block) 14 | begin 15 | puts :result => task.wait 16 | rescue => e 17 | puts e 18 | puts e.backtrace 19 | end 20 | end 21 | end # def run 22 | 23 | class Task 24 | def initialize(*args, &block) 25 | # A queue to receive the result of the block 26 | @queue = Queue.new 27 | @thread = Thread.new(@queue, *args) do |queue, *args| 28 | begin 29 | result = block.call(*args) 30 | queue << [:return, result] 31 | rescue => e 32 | queue << [:exception, e] 33 | end 34 | end # thread 35 | end # def initialize 36 | 37 | def wait 38 | @thread.join 39 | reason, result = @queue.pop 40 | 41 | if reason == :exception 42 | #raise StandardError.new(result) 43 | raise result 44 | else 45 | return result 46 | end 47 | end # def wait 48 | end # class Supervisor::Task 49 | end # class Supervisor 50 | 51 | def supervise(&block) 52 | Supervisor.new(&block) 53 | end # def supervise 54 | -------------------------------------------------------------------------------- /supervising-threads/ruby/test.rb: -------------------------------------------------------------------------------- 1 | require "./lib/supervise" 2 | 3 | supervise do 4 | puts "OK" 5 | sleep 0.2 6 | if rand > 0.5 7 | raise "Failure" 8 | else 9 | "Success" 10 | end 11 | end 12 | --------------------------------------------------------------------------------