sequel-replica-failover 0.1.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31cc90d47b9bbe08b846ea3af88bb29a647fe6d3
-  data.tar.gz: 21ccb990de1601f8f49c4523343a92587abdfc62
+  metadata.gz: 4427d0bd15392df069157501d649dc8f1208ca14
+  data.tar.gz: bc0ee4ad2bcad88f2aaf3d724418dea7b5d47c82
 SHA512:
-  metadata.gz: 0bf16b9998f95ac996b20731c872b481c11482d8d00f145d0a19eed7ad5341f8e01e15417615d210a2b73d6f98ff106f57a3e3f34e33550555c837dd95b0a88b
-  data.tar.gz: ddcb1cbb66e57295b5530f8e6a3378152b1b9aaaadf0ad8da7f47169bb39988a62f8f5e9f8956454f485487b391e8442be7ebcbd625db264eb79cd75d88ad8e2
+  metadata.gz: 80086a61fbc3969a6696df41f25d4b97f9306528c502d0cfe9c289dc5e18dbc0a25f69de1863fe18fa1ea161148918d6aae0dc61ccf89b5236735e93ef5e230c
+  data.tar.gz: 473f829e1df49607fc6516fb5b3f583b820b12ba878f7057b08b0e4b43976a7112c1a464d96bffd2b6e5ba49549bba68ec32f386306a9109f6e3fbbb2e52eb7c

data/.travis.yml

@@ -2,6 +2,7 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0-p247
+  - 2.1.2
 script: "bundle exec rspec"
 notifications:
   email: false

data/README.md

@@ -1,6 +1,8 @@
 # Automatic read-only failover for Sequel
 
 [![Gem Version](https://badge.fury.io/rb/sequel-replica-failover.png)](http://badge.fury.io/rb/sequel-replica-failover)
+[![Build
+Status](https://travis-ci.org/wanelo/sequel-replica-failover.svg?branch=master)](https://travis-ci.org/wanelo/sequel-replica-failover)
 [![Code Climate](https://codeclimate.com/github/wanelo/sequel-replica-failover.png)](https://codeclimate.com/github/wanelo/sequel-replica-failover)
 
 This provides a NOT-THREADSAFE sharded connection pool for failing over between configured replicas.

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

@@ -1,5 +1,5 @@
 module Sequel
   module ReplicaFailover
-    VERSION = '0.1.2'
+    VERSION = '1.0.0'
   end
 end

data/lib/sequel/connection_pool/sharded_single_failover.rb

@@ -8,10 +8,30 @@ class Sequel::ShardedSingleFailoverConnectionPool < Sequel::ShardedSingleConnect
     @pool_retry_count   = opts[:pool_retry_count]   || 5
   end
 
+  @on_disconnect = []
+  @on_unstick = []
+
   class << self
-    attr_accessor :on_disconnect
+    attr_accessor :on_disconnect, :on_unstick
+
+    def register_on_disconnect_callback(callback)
+      @on_disconnect << callback
+    end
+
+    def clear_on_disconnect_callbacks
+      @on_disconnect.clear
+    end
+
+    def register_on_unstick_callback(callback)
+      @on_unstick << callback
+    end
+
+    def clear_on_unstick_callbacks
+      @on_unstick.clear
+    end
   end
 
+
   # Yields the connection to the supplied block for the given server.
   # This method simulates the ConnectionPool#hold API.
   def hold(server=:default, &block)
@@ -23,31 +43,33 @@ class Sequel::ShardedSingleFailoverConnectionPool < Sequel::ShardedSingleConnect
 
     super(server, &block)
   rescue Sequel::DatabaseDisconnectError, Sequel::DatabaseConnectionError => e
-    if server == :read_only && !@db.in_transaction?(server: :read_only)
-      self.class.on_disconnect.call(e, self) if self.class.on_disconnect
-      disconnect_server(server)
-      @conns[server] = nil
+    raise if server != :read_only
+    raise if @db.in_transaction?(server: :read_only)
 
-      stick
+    unless self.class.on_disconnect.empty?
+      self.class.on_disconnect.each { |callback| callback.call(e, self) }
+    end
+    disconnect_server(server)
+    @conns[server] = nil
 
-      if @stuck_times >= @pool_retry_count
-        unstick(server)
-        raise
-      end
+    stick
 
-      hold(server, &block)
-    else
+    if @stuck_times >= @pool_retry_count
+      unstick(server)
       raise
     end
+
+    hold(server, &block)
   end
 
   def pool_type
     :sharded_single_failover
   end
 
-  private
-
   def unstick(server)
+    unless self.class.on_unstick.empty?
+      self.class.on_unstick.each { |callback| callback.call(self) }
+    end
     probe(server.to_s) { |p| p.unstick }
     disconnect_server(server)
     @conns[server] = nil
@@ -55,6 +77,8 @@ class Sequel::ShardedSingleFailoverConnectionPool < Sequel::ShardedSingleConnect
     @stuck_times = nil
   end
 
+  private
+
   def stick
     @stuck_times ||= 0
     probe(@stuck_times) { |p| p.stick }

data/spec/sequel-replica-failover/dtrace_provider_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Sequel::ReplicaFailover::DTraceProvider do
   describe 'initialize' do
     it 'creates a new provider' do
-      USDT::Provider.should_receive(:create).with(:ruby, :sequel_replica_failover)
+      expect(USDT::Provider).to receive(:create).with(:ruby, :sequel_replica_failover)
       Sequel::ReplicaFailover::DTraceProvider.new
     end
   end

data/spec/sequel/connection_pool/sharded_single_failover_spec.rb

@@ -1,88 +1,119 @@
 require 'spec_helper'
-CONNECTION_POOL_DEFAULTS = {:pool_retry_count => 3,
-                            :pool_stick_timeout => 15,
-                            :pool_timeout=>5,
-                            :pool_sleep_time=>0.001,
-                            :max_connections=>4,
-                            :pool_class => Sequel::ShardedSingleFailoverConnectionPool,
-                            :servers => { :read_only => {} } }
-
-mock_db = lambda do |*a, &b|
-  db = Sequel.mock
-  (class << db; self end).send(:define_method, :connect){|c| b.arity == 1 ? b.call(c) : b.call} if b
-  if b2 = a.shift
-    (class << db; self end).send(:define_method, :disconnect_connection){|c| b2.arity == 1 ? b2.call(c) : b2.call}
-  end
-  db
-end
 
 describe Sequel::ShardedSingleFailoverConnectionPool do
-  describe '#hold' do
-    before do
-      msp = proc { @max_size=3 }
-      @connection_pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc { |c| msp.call }) { :got_connection }, CONNECTION_POOL_DEFAULTS)
+  CONNECTION_POOL_DEFAULTS = {:pool_retry_count => 3,
+                              :pool_stick_timeout => 15,
+                              :pool_timeout=>5,
+                              :pool_sleep_time=>0.001,
+                              :max_connections=>4,
+                              :pool_class => Sequel::ShardedSingleFailoverConnectionPool,
+                              :servers => { :read_only => {} } }
+
+  mock_db = lambda do |*a, &b|
+    db = Sequel.mock
+    (class << db; self end).send(:define_method, :connect){|c| b.arity == 1 ? b.call(c) : b.call} if b
+    if b2 = a.shift
+      (class << db; self end).send(:define_method, :disconnect_connection){|c| b2.arity == 1 ? b2.call(c) : b2.call}
     end
+    db
+  end
+
+  after do
+    Sequel::ShardedSingleFailoverConnectionPool.clear_on_disconnect_callbacks
+    Sequel::ShardedSingleFailoverConnectionPool.clear_on_unstick_callbacks
+  end
+
+  let(:msp) { proc { @max_size=3 } }
+  let(:connection_pool) { Sequel::ConnectionPool.get_pool(mock_db.call(proc { |c| msp.call }) { :got_connection }, CONNECTION_POOL_DEFAULTS) }
 
+  describe '#hold' do
     context 'with read_only server' do
       context 'when block raises a database connection error' do
         it 'retries until the a successful connection is made' do
           call_count = 0
-          proc { @connection_pool.hold(:read_only) { call_count += 1; raise Sequel::DatabaseDisconnectError if call_count == 1 } }.should_not raise_error
+          expect {
+            connection_pool.hold(:read_only) { call_count += 1; raise Sequel::DatabaseDisconnectError if call_count == 1 }
+          }.not_to raise_error
           expect(call_count).to eq(2)
         end
 
         it 'only retries N number of times before actually raising the error' do
           call_count = 0
-          proc { @connection_pool.hold(:read_only) { call_count += 1; raise Sequel::DatabaseDisconnectError } }.should raise_error(Sequel::DatabaseDisconnectError)
+          expect {
+            connection_pool.hold(:read_only) { call_count += 1; raise Sequel::DatabaseDisconnectError }
+          }.to raise_error(Sequel::DatabaseDisconnectError)
           expect(call_count).to eq(3)
         end
 
         it 'sticks for N number of seconds to a working connection' do
           Timecop.freeze -16 do
             call_count = 0
-            proc { @connection_pool.hold(:read_only) { call_count += 1; raise Sequel::DatabaseDisconnectError if call_count == 1 } }.should_not raise_error
+            expect {
+              connection_pool.hold(:read_only) { call_count += 1; raise Sequel::DatabaseDisconnectError if call_count == 1 }
+            }.not_to raise_error
             expect(call_count).to eq(2)
-            expect(@connection_pool.size).to eq(1)
+            expect(connection_pool.size).to eq(1)
           end
 
-          @connection_pool.should_receive(:make_new).once
-          @connection_pool.hold(:read_only) {}
+          expect(connection_pool).to receive(:make_new).once
+          connection_pool.hold(:read_only) {}
         end
 
         context 'with an on_disconnect callback' do
           it 'calls the callback with the error' do
             callback = double("callback")
-            Sequel::ShardedSingleFailoverConnectionPool.on_disconnect = callback
+            Sequel::ShardedSingleFailoverConnectionPool.register_on_disconnect_callback callback
 
-            expect(callback).to receive(:call).with(an_instance_of(Sequel::DatabaseDisconnectError), @connection_pool)
+            expect(callback).to receive(:call).with(an_instance_of(Sequel::DatabaseDisconnectError), connection_pool)
             call_count = 0
-            @connection_pool.hold(:read_only) { call_count += 1; raise Sequel::DatabaseDisconnectError if call_count == 1 }
+            connection_pool.hold(:read_only) { call_count += 1; raise Sequel::DatabaseDisconnectError if call_count == 1 }
           end
         end
 
         context 'when in a transaction' do
           it 'raises an exception' do
-            Sequel::Mock::Database.any_instance.should_receive(:in_transaction?).and_return(true)
-            proc { @connection_pool.hold(:read_only) { raise Sequel::DatabaseDisconnectError } }.should raise_error(Sequel::DatabaseDisconnectError)
+            allow_any_instance_of(Sequel::Mock::Database).to receive(:in_transaction?).and_return(true)
+            expect {
+              connection_pool.hold(:read_only) { raise Sequel::DatabaseDisconnectError }
+            }.to raise_error(Sequel::DatabaseDisconnectError)
           end
         end
       end
     end
 
-    context 'with default or arbritrary server' do
+    context 'with default or arbitrary server' do
       it 'does no retry logic and raises error' do
         call_count = 0
-        proc { @connection_pool.hold { call_count += 1; raise Sequel::DatabaseDisconnectError if call_count == 1 } }.should raise_error(Sequel::DatabaseDisconnectError)
+        expect {
+          connection_pool.hold { call_count += 1; raise Sequel::DatabaseDisconnectError if call_count == 1 }
+        }.to raise_error(Sequel::DatabaseDisconnectError)
         expect(call_count).to eq(1)
       end
     end
   end
 
-  describe '.on_disconnect' do
-    it 'sets the on_disconnect attribute' do
+  describe '#unstick' do
+    it 'calls on_unstick callbacks' do
+      callback = double(call: true)
+      Sequel::ShardedSingleFailoverConnectionPool.register_on_unstick_callback callback
+      connection_pool.unstick(:read_only)
+      expect(callback).to have_received(:call).with(connection_pool)
+    end
+  end
+
+  describe '.register_on_disconnect_callback' do
+    it 'adds to the on_disconnect attribute' do
+      callback = Proc.new{ puts "woo" }
+      Sequel::ShardedSingleFailoverConnectionPool.register_on_disconnect_callback callback
+      expect(Sequel::ShardedSingleFailoverConnectionPool.on_disconnect).to eq([callback])
+    end
+  end
+
+  describe '.register_on_disconnect_callback' do
+    it 'adds to the on_unstick attribute' do
       callback = Proc.new{ puts "woo" }
-      Sequel::ShardedSingleFailoverConnectionPool.on_disconnect = callback
-      expect(Sequel::ShardedSingleFailoverConnectionPool.on_disconnect).to eq(callback)
+      Sequel::ShardedSingleFailoverConnectionPool.register_on_unstick_callback callback
+      expect(Sequel::ShardedSingleFailoverConnectionPool.on_unstick).to eq([callback])
     end
   end
 end

data/spec/spec_helper.rb

@@ -8,7 +8,6 @@ require 'sequel-replica-failover'
 require 'timecop'
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-replica-failover
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Paul Henry
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-23 00:00:00.000000000 Z
+date: 2014-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -151,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Automatically failover when replicas go down.