sequel-replica-failover 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d6591f26230c08ccc58cecb7b05646362451251
-  data.tar.gz: e708c054f4068721c8478a6e0e25cc8da79621ed
+  metadata.gz: a4e500a26ca783691cec34ed9d48921bf2261348
+  data.tar.gz: 19ad51a3a2bcbfb02dea42034ccb902ceeeb6c77
 SHA512:
-  metadata.gz: 35432ccbcda3fa45526c08b308234f755335a912a0d5d80215be7d60c822a97af66e46871c3eea23319c0210d772df80329c49075ae8612b178f548df17690ff
-  data.tar.gz: 3d022a85dc1f8deaea5683bf28fd193c35ed47b5037526750f7363bd2eb976a5db25d628a1884cb316f7edfcf2df22f9034699976e225cfd0d8d3a8743ffee59
+  metadata.gz: 8653ca08e58c4c55de95b139932d084eb4090c03f262261cd4753c964234afecb13cf5ab4149fe2b09519ee0d0c9834dcf8d43e44a40ce2670dc8364165158ba
+  data.tar.gz: 2ef5acbe7cc1d8c060ca0c1923203740b66b5f36b75fe220da0ad17ea4436dc99317ca08d2a86c3a38c53c21334e025196bf0a124ec845a1b1b097d1fb798d56

data/README.md

@@ -48,7 +48,34 @@ DB = Sequel.connect({
                     })
 ```
 
+Please note that if you were to open a transaction on a `:read_only` connection,
+queries could be retried on a different connection. Why one would open a transaction
+on a `:read_only` connection is unclear to us, but it is possible and a concern to
+be aware of.
 
+## Callbacks
+
+The connection pool allows for user-defined callbacks when a query is retried as well
+as when the retry logic is reset (on timeout or on retry count). Callbacks should be
+a `Proc`, or something that ducktypes to one.
+
+Callbacks to retry take an `error` object and a `pool`, as follows:
+
+```ruby
+Sequel::ShardedSingleFailoverConnectionPool.register_on_retry_callback ->(error, pool) {
+  ReportingTool.notify(error)
+  puts pool.inspect
+  puts pool.failing_over?
+}
+```
+
+Callbacks on reset take a `pool` object, as follows:
+
+```ruby
+Sequel::ShardedSingleFailoverConnectionPool.register_on_reset_callback ->(pool) {
+  puts pool.inspect
+}
+```
 
 ## Contributing
 

data/lib/sequel-replica-failover/version.rb

@@ -1,5 +1,5 @@
 module Sequel
   module ReplicaFailover
-    VERSION = '1.0.1'
+    VERSION = '2.0.0'
   end
 end

data/lib/sequel/connection_pool/sharded_single_failover.rb

@@ -5,29 +5,30 @@ class Sequel::ShardedSingleFailoverConnectionPool < Sequel::ShardedSingleConnect
   def initialize(db, opts = OPTS)
     super
     @pool_stick_timeout = opts[:pool_stick_timeout] || 15
-    @pool_retry_count   = opts[:pool_retry_count]   || 5
+    @pool_retry_count = opts[:pool_retry_count] || 5
+    @failing_over = false
   end
 
-  @on_disconnect = []
-  @on_unstick = []
+  @on_retry = []
+  @on_reset = []
 
   class << self
-    attr_accessor :on_disconnect, :on_unstick
+    attr_accessor :on_retry, :on_reset
 
-    def register_on_disconnect_callback(callback)
-      @on_disconnect << callback
+    def register_on_retry_callback(callback)
+      @on_retry << callback
     end
 
-    def clear_on_disconnect_callbacks
-      @on_disconnect.clear
+    def clear_on_retry_callbacks
+      @on_retry.clear
     end
 
-    def register_on_unstick_callback(callback)
-      @on_unstick << callback
+    def register_on_reset_callback(callback)
+      @on_reset << callback
     end
 
-    def clear_on_unstick_callbacks
-      @on_unstick.clear
+    def clear_on_reset_callbacks
+      @on_reset.clear
     end
   end
 
@@ -35,56 +36,69 @@ class Sequel::ShardedSingleFailoverConnectionPool < Sequel::ShardedSingleConnect
   # Yields the connection to the supplied block for the given server.
   # This method simulates the ConnectionPool#hold API.
   def hold(server=:default, &block)
-    if server == :read_only &&
-       @stuck_at &&
-       Time.now.to_i - @stuck_at.to_i >= @pool_stick_timeout
-      unstick(:read_only)
+    reset_retries(:read_only) if failover_timed_out?(server)
+
+    loop do
+      begin
+        @response = super(server, &block)
+        break
+      rescue Sequel::DatabaseDisconnectError, Sequel::DatabaseConnectionError => e
+        raise if server != :read_only
+
+        increment_retries
+
+        unless self.class.on_retry.empty?
+          self.class.on_retry.each { |callback| callback.call(e, self) }
+        end
+
+        if @retry_count >= @pool_retry_count
+          reset_retries(server)
+          raise
+        end
+      end
     end
 
-    server = pick_server(server)
-    block.call(@conns[server] ||= make_new(server))
-  rescue Sequel::DatabaseDisconnectError, Sequel::DatabaseConnectionError => e
-    raise if server != :read_only
-    raise if @db.in_transaction?(server: :read_only)
-
-    unless self.class.on_disconnect.empty?
-      self.class.on_disconnect.each { |callback| callback.call(e, self) }
-    end
-    disconnect_server(server)
-    @conns[server] = nil
-
-    stick
-
-    if @stuck_times >= @pool_retry_count
-      unstick(server)
-      raise
-    end
-
-    hold(server, &block)
+    @response
   end
 
   def pool_type
     :sharded_single_failover
   end
 
-  def unstick(server)
-    unless self.class.on_unstick.empty?
-      self.class.on_unstick.each { |callback| callback.call(self) }
+  def failover!
+    @failing_over = true
+  end
+
+  def failing_over?
+    !!@failing_over
+  end
+
+  def reset_retries(server)
+    unless self.class.on_reset.empty?
+      self.class.on_reset.each { |callback| callback.call(self) }
     end
     probe(server.to_s) { |p| p.unstick }
     disconnect_server(server)
     @conns[server] = nil
-    @stuck_at = nil
-    @stuck_times = nil
+    @failing_over = false
+    @failed_at = nil
+    @retry_count = nil
   end
 
   private
 
-  def stick
-    @stuck_times ||= 0
-    probe(@stuck_times) { |p| p.stick }
-    @stuck_at ||= Time.now
-    @stuck_times += 1
+  def failover_timed_out?(server)
+    server == :read_only &&
+      @failed_at &&
+      Time.now.to_i - @failed_at.to_i >= @pool_stick_timeout
+  end
+
+  def increment_retries
+    failover!
+    @retry_count ||= 0
+    probe(@retry_count) { |p| p.stick }
+    @failed_at ||= Time.now
+    @retry_count += 1
   end
 
   def probe(*args)

data/spec/sequel/connection_pool/sharded_single_failover_spec.rb

@@ -19,8 +19,8 @@ describe Sequel::ShardedSingleFailoverConnectionPool do
   end
 
   after do
-    Sequel::ShardedSingleFailoverConnectionPool.clear_on_disconnect_callbacks
-    Sequel::ShardedSingleFailoverConnectionPool.clear_on_unstick_callbacks
+    Sequel::ShardedSingleFailoverConnectionPool.clear_on_retry_callbacks
+    Sequel::ShardedSingleFailoverConnectionPool.clear_on_reset_callbacks
   end
 
   let(:msp) { proc { @max_size=3 } }
@@ -29,6 +29,13 @@ describe Sequel::ShardedSingleFailoverConnectionPool do
   describe '#hold' do
     context 'with read_only server' do
       context 'when block raises a database connection error' do
+        it 'fails over' do
+          call_count = 0
+          allow(connection_pool).to receive(:failover!)
+          connection_pool.hold(:read_only) { call_count += 1; raise Sequel::DatabaseDisconnectError if call_count == 1 }
+          expect(connection_pool).to have_received(:failover!)
+        end
+
         it 'retries until the a successful connection is made' do
           call_count = 0
           expect {
@@ -59,10 +66,10 @@ describe Sequel::ShardedSingleFailoverConnectionPool do
           connection_pool.hold(:read_only) {}
         end
 
-        context 'with an on_disconnect callback' do
+        context 'with an on_retry callback' do
           it 'calls the callback with the error' do
             callback = double("callback")
-            Sequel::ShardedSingleFailoverConnectionPool.register_on_disconnect_callback callback
+            Sequel::ShardedSingleFailoverConnectionPool.register_on_retry_callback callback
 
             expect(callback).to receive(:call).with(an_instance_of(Sequel::DatabaseDisconnectError), connection_pool)
             call_count = 0
@@ -92,28 +99,47 @@ describe Sequel::ShardedSingleFailoverConnectionPool do
     end
   end
 
-  describe '#unstick' do
-    it 'calls on_unstick callbacks' do
+  describe '#failover!' do
+    it 'changes failing_over? to true' do
+      expect {
+        connection_pool.failover!
+      }.to change {
+        connection_pool.failing_over?
+      }.from(false).to(true)
+    end
+  end
+
+  describe '#reset_retries' do
+    it 'calls on_reset callbacks' do
       callback = double(call: true)
-      Sequel::ShardedSingleFailoverConnectionPool.register_on_unstick_callback callback
-      connection_pool.unstick(:read_only)
+      Sequel::ShardedSingleFailoverConnectionPool.register_on_reset_callback callback
+      connection_pool.reset_retries(:read_only)
       expect(callback).to have_received(:call).with(connection_pool)
     end
+
+    it 'changes failing_over? to false' do
+      connection_pool.failover!
+      expect {
+        connection_pool.reset_retries(:read_only)
+      }.to change {
+        connection_pool.failing_over?
+      }.from(true).to(false)
+    end
   end
 
-  describe '.register_on_disconnect_callback' do
-    it 'adds to the on_disconnect attribute' do
+  describe '.register_on_retry_callback' do
+    it 'adds to the on_retry attribute' do
       callback = Proc.new{ puts "woo" }
-      Sequel::ShardedSingleFailoverConnectionPool.register_on_disconnect_callback callback
-      expect(Sequel::ShardedSingleFailoverConnectionPool.on_disconnect).to eq([callback])
+      Sequel::ShardedSingleFailoverConnectionPool.register_on_retry_callback callback
+      expect(Sequel::ShardedSingleFailoverConnectionPool.on_retry).to eq([callback])
     end
   end
 
-  describe '.register_on_disconnect_callback' do
-    it 'adds to the on_unstick attribute' do
+  describe '.register_on_retry_callback' do
+    it 'adds to the on_reset attribute' do
       callback = Proc.new{ puts "woo" }
-      Sequel::ShardedSingleFailoverConnectionPool.register_on_unstick_callback callback
-      expect(Sequel::ShardedSingleFailoverConnectionPool.on_unstick).to eq([callback])
+      Sequel::ShardedSingleFailoverConnectionPool.register_on_reset_callback callback
+      expect(Sequel::ShardedSingleFailoverConnectionPool.on_reset).to eq([callback])
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequel-replica-failover
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Paul Henry