redis-sentinel 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13e25cdba4cbb9a679bc1510df3733769f269084
-  data.tar.gz: d73c7b49c1056871ec68faa8eb49d6cc6c201eb4
+  metadata.gz: 0abad2c1cbcc6e342c7f362b9d6c6ad6ebca6a81
+  data.tar.gz: e300689d63cec3fec3f9d2ace82d61d828baf4b3
 SHA512:
-  metadata.gz: 733ae6b08e7176b1ae8009ef6c70a7ec0a02ccfecdae4dc5973912e6fd937a73040e297c4155ff2b9248bcd369b93dedba35b58f87934f8bb34ffa63b2d82cae
-  data.tar.gz: afbcb2c666c307aa7851b1db2b01abfbcf8f1dbabd9f7d9a76805297d450ddbb5657a3ca0723537043bd2c05e6ed5f7ca3c7e8d5f5d3091a1ab6915f25a7c80b
+  metadata.gz: 5472ab6c41d452eb5550ed58698871956a57deb51d354c95e154d768b4390871f3f302170ac03987029ad02a5973a471864e4034d2e0195385b9f4f6839d667f
+  data.tar.gz: 4c781a86527902cfc4a9fee13b7b0139b39245eadb894f98647e2f3e0a158c5d5128d2218577830b1b1d0d22df963126a7c1f376522952eb1c1501e0f960eb59

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 1.4.0
+
+* Rewrite sentinel client to follow http://redis.io/topics/sentinel
+* Parse uri string in sentinels array
+
 ## 1.3.0
 
 * Add ability to reconnect all redis sentinel clients

data/README.md

@@ -13,6 +13,11 @@ Add this line to your application's Gemfile:
 
     gem 'redis-sentinel'
 
+If you are using redis-server less than 2.6.10, please use
+redis-sentinel 1.3.0
+
+    gem 'redis-sentinel', '~> 1.3.0'
+
 And then execute:
 
     $ bundle
@@ -27,6 +32,11 @@ Specify the sentinel servers and master name
 
     Redis.new(master_name: "master1", sentinels: [{host: "localhost", port: 26379}, {host: "localhost", port: 26380}])
 
+Sentinels can also be specified using a URI. This URI syntax is required when using Rails.config.cache_store:
+
+    config.cache_store = :redis_store, { master_name: "master1",
+                                         sentinels: ['sentinel://localhost:26379', 'sentinel://localhost:26380'] }
+
 There are two additional options:
 
 1. `:failover_reconnect_timeout` (seconds) will block for that long when
@@ -55,6 +65,7 @@ Start 2 sentinel servers
 ```
 $ redis-server example/redis-sentinel1.conf --sentinel
 $ redis-server example/redis-sentinel2.conf --sentinel
+$ redis-server example/redis-sentinel3.conf --sentinel
 ```
 
 Run example/test.rb, which will query value of key "foo" every second.
@@ -84,19 +95,7 @@ takes less than 30 seconds.
 
 ## Authors and Contributors
 
-* [Richard Huang](https://github.com/flyerhzm) - Creator of the project
-* [Donald Plummer](https://github.com/dplummer) - Add wait / timeout for
-  redis connection
-* [Rafał Michalski](https://github.com/royaltm) - Ensure promoted slave
-  become master / Add redis synchrony support
-* [Zachary Anker](https://github.com/zanker) - Add redis authentication
-  support
-* [Nick Deteffen](https://github.com/nick-desteffen) - Add ability to
-  reconnect all redis sentinel clients
-* [Carlos Paramio](https://github.com/carlosparamio) - Avoid the config
-  gets modified
-* [Michael Gee](https://github.com/mikegee) - Reconnect if redis suddenly
-  becomes read-only.
+[https://github.com/flyerhzm/redis-sentinel/graphs/contributors](https://github.com/flyerhzm/redis-sentinel/graphs/contributors)
 
 Please fork and contribute, any help in making this project better is appreciated!
 

data/example/redis-sentinel1.conf

@@ -2,5 +2,4 @@ port 26379
 sentinel monitor example-test 127.0.0.1 16379 2
 sentinel down-after-milliseconds example-test 5000
 sentinel failover-timeout example-test 900000
-sentinel can-failover example-test yes
 sentinel parallel-syncs example-test 1

data/example/redis-sentinel2.conf

@@ -2,5 +2,4 @@ port 26380
 sentinel monitor example-test 127.0.0.1 16379 2
 sentinel down-after-milliseconds example-test 5000
 sentinel failover-timeout example-test 900000
-sentinel can-failover example-test yes
 sentinel parallel-syncs example-test 1

data/example/redis-sentinel3.conf

@@ -0,0 +1,5 @@
+port 26381
+sentinel monitor example-test 127.0.0.1 16379 2
+sentinel down-after-milliseconds example-test 5000
+sentinel failover-timeout example-test 900000
+sentinel parallel-syncs example-test 1

data/lib/redis-sentinel/client.rb

@@ -4,11 +4,14 @@ class Redis::Client
   DEFAULT_FAILOVER_RECONNECT_WAIT_SECONDS = 0.1
 
   class_eval do
+    attr_reader :current_sentinel
+    attr_reader :current_sentinel_options
+
     def initialize_with_sentinel(options={})
       options = options.dup # Don't touch my options
       @master_name = fetch_option(options, :master_name)
       @master_password = fetch_option(options, :master_password)
-      @sentinels = fetch_option(options, :sentinels)
+      @sentinels_options = _parse_sentinel_options(fetch_option(options, :sentinels))
       @failover_reconnect_timeout = fetch_option(options, :failover_reconnect_timeout)
       @failover_reconnect_wait = fetch_option(options, :failover_reconnect_wait) ||
                                  DEFAULT_FAILOVER_RECONNECT_WAIT_SECONDS
@@ -34,7 +37,7 @@ class Redis::Client
     alias connect connect_with_sentinel
 
     def sentinel?
-      @master_name && @sentinels
+      @master_name && @sentinels_options
     end
 
     def auto_retry_with_timeout(&block)
@@ -49,45 +52,52 @@ class Redis::Client
     end
 
     def try_next_sentinel
-      @sentinels << @sentinels.shift
-      if @logger && @logger.debug?
-        @logger.debug "Trying next sentinel: #{@sentinels[0][:host]}:#{@sentinels[0][:port]}"
+      sentinel_options = @sentinels_options.shift
+      if sentinel_options
+        @logger.debug "Trying next sentinel: #{sentinel_options[:host]}:#{sentinel_options[:port]}" if @logger && @logger.debug?
+        @current_sentinel_options = sentinel_options
+        @current_sentinel = Redis.new sentinel_options
+      else
+        raise Redis::CannotConnectError
       end
-      return @sentinels[0]
+    end
+
+    def refresh_sentinels_list
+      responses = current_sentinel.sentinel("sentinels", @master_name)
+      @sentinels_options = responses.map do |response|
+        {:host => response[3], :port => response[5]}
+      end.unshift(:host => current_sentinel_options[:host], :port => current_sentinel_options[:port])
     end
 
     def discover_master
       while true
-        sentinel = redis_sentinels[@sentinels[0]]
+        try_next_sentinel
 
         begin
-          host, port = sentinel.sentinel("get-master-addr-by-name", @master_name)
-          if !host && !port
-            raise Redis::ConnectionError.new("No master named: #{@master_name}")
+          master_host, master_port = current_sentinel.sentinel("get-master-addr-by-name", @master_name)
+          if master_host && master_port
+            # An ip:port pair
+            @options.merge!(:host => master_host, :port => master_port.to_i, :password => @master_password)
+            refresh_sentinels_list
+            break
+          else
+            # A null reply
           end
-          is_down, runid = sentinel.sentinel("is-master-down-by-addr", host, port)
-          break
+        rescue Redis::CommandError
+          # An -IDONTKNOWN reply
         rescue Redis::CannotConnectError
-          try_next_sentinel
+          # faile to connect to current sentinel server
         end
       end
-
-      if is_down.to_s == "1" || runid == '?'
-        raise Redis::CannotConnectError.new("The master: #{@master_name} is currently not available.")
-      else
-        @options.merge!(:host => host, :port => port.to_i, :password => @master_password)
-      end
     end
 
-    def reconnect_with_sentinels
-      redis_sentinels.each do |config, sentinel|
-        sentinel.client.reconnect
-      end
-      reconnect_without_sentinels
+    def disconnect_with_sentinels
+      current_sentinel.client.disconnect if current_sentinel
+      disconnect_without_sentinels
     end
 
-    alias reconnect_without_sentinels reconnect
-    alias reconnect reconnect_with_sentinels
+    alias disconnect_without_sentinels disconnect
+    alias disconnect disconnect_with_sentinels
 
     def call_with_readonly_protection(*args, &block)
       tries = 0
@@ -110,10 +120,22 @@ class Redis::Client
       options.delete(key) || options.delete(key.to_s)
     end
 
-    def redis_sentinels
-      @redis_sentinels ||= Hash.new do |hash, config|
-        hash[config] = Redis.new(config)
+    def _parse_sentinel_options(options)
+      return if options.nil?
+
+      sentinel_options = []
+      options.each do |sentinel_option|
+        if sentinel_option.is_a?(Hash)
+          sentinel_options << sentinel_option
+        else
+          uri = URI.parse(sentinel_option)
+          sentinel_options << {
+              host: uri.host,
+              port: uri.port
+          }
+        end
       end
+      sentinel_options
     end
   end
 end

data/lib/redis-sentinel/version.rb

@@ -1,5 +1,5 @@
 class Redis
   module Sentinel
-    VERSION = "1.3.0"
+    VERSION = "1.4.0"
   end
 end

data/spec/redis-sentinel/client_spec.rb

@@ -4,105 +4,107 @@ describe Redis::Client do
   let(:client) { double("Client", :reconnect => true) }
   let(:redis)  { double("Redis", :sentinel => ["remote.server", 8888], :client => client) }
 
+  let(:sentinels) do
+    [
+      { :host => "localhost", :port => 26379 },
+      'sentinel://localhost:26380'
+    ]
+  end
+
   subject { Redis::Client.new(:master_name => "master", :master_password => "foobar",
-                              :sentinels => [{:host => "localhost", :port => 26379},
-                                             {:host => "localhost", :port => 26380}]) }
+                              :sentinels => sentinels) }
 
-  before { Redis.stub(:new).and_return(redis) }
+  before do
+    allow(Redis).to receive(:new).and_return(redis)
+  end
 
   context "#sentinel?" do
     it "should be true if passing sentiels and master_name options" do
-      expect(Redis::Client.new(:master_name => "master", :sentinels => [{:host => "localhost", :port => 26379}, {:host => "localhost", :port => 26380}])).to be_sentinel
+      expect(subject).to be_sentinel
     end
 
-    it "should not be true if not passing sentinels and maser_name options" do
+    it "should not be true if not passing sentinels and master_name options" do
       expect(Redis::Client.new).not_to be_sentinel
     end
 
     it "should not be true if passing sentinels option but not master_name option" do
-      expect(Redis::Client.new(:sentinels => [{:host => "localhost", :port => 26379}, {:host => "localhost", :port => 26380}])).not_to be_sentinel
+      client = Redis::Client.new(
+        :sentinels => [
+          {:host => "localhost", :port => 26379},
+          {:host => "localhost", :port => 26380}
+        ])
+      expect(client).not_to be_sentinel
     end
 
     it "should not be true if passing master_name option but not sentinels option" do
-      expect(Redis::Client.new(:master_name => "master")).not_to be_sentinel
+      client = Redis::Client.new(:master_name => "master")
+      expect(client).not_to be_sentinel
     end
-  end
 
-  context "#try_next_sentinel" do
-    it "should return next sentinel server" do
-      expect(subject.try_next_sentinel).to eq({:host => "localhost", :port => 26380})
+    it "should be true if passing master_name, and sentinels as uri" do
+      client = Redis::Client.new(:master_name => "master",
+        :sentinels => %w(sentinel://localhost:26379 sentinel://localhost:26380))
+      expect(client).to be_sentinel
     end
   end
 
-  context "#discover_master" do
-    it "gets the current master" do
-      redis.should_receive(:sentinel).
-            with("get-master-addr-by-name", "master")
-      redis.should_receive(:sentinel).
-            with("is-master-down-by-addr", "remote.server", 8888)
-      subject.discover_master
+  context "#try_next_sentinel" do
+    it "returns next sentinel server" do
+      expect(Redis).to receive(:new).with(:host => "localhost", :port => 26379).and_return(redis)
+      subject.try_next_sentinel
     end
 
-    it "should update options" do
-      redis.should_receive(:sentinel).
-            with("is-master-down-by-addr", "remote.server", 8888).once.
-            and_return([0, "abc"])
-      subject.discover_master
-      expect(subject.host).to eq "remote.server"
-      expect(subject.port).to eq 8888
-      expect(subject.password).to eq "foobar"
+    it "raises an error if no available sentinel server" do
+      client = Redis::Client.new(
+        :master_name => "master",
+        :sentinels => []
+      )
+      expect { client.try_next_sentinel }.to raise_error(Redis::CannotConnectError)
     end
+  end
 
-    it "should not update options" do
-      redis.should_receive(:sentinel).
-            with("is-master-down-by-addr", "remote.server", 8888).twice.
-            and_return([1, "abc"], [0, "?"])
-      2.times do
-        expect do
-          subject.discover_master
-        end.to raise_error(Redis::CannotConnectError, /currently not available/)
-        expect(subject.host).not_to eq "remote.server"
-        expect(subject.port).not_to eq 8888
-        expect(subject.password).not_to eq "foobar"
-      end
+  context "#refresh_sentinels_list" do
+    it "gets all sentinels list" do
+      sentinel = double('sentinel')
+      allow(subject).to receive(:current_sentinel_options).and_return(:host => "localhost", :port => 26379)
+      expect(subject).to receive(:current_sentinel).and_return(sentinel)
+      expect(sentinel).to receive(:sentinel).with("sentinels", "master").and_return([
+        ["name", "localhost:26381", "ip", "localhost", "port", 26380],
+        ["name", "localhost:26381", "ip", "localhost", "port", 26381]
+      ])
+      subject.refresh_sentinels_list
+      expect(subject.instance_variable_get(:@sentinels_options)).to eq [
+        {:host => "localhost", :port => 26379},
+        {:host => "localhost", :port => 26380},
+        {:host => "localhost", :port => 26381}
+      ]
     end
+  end
 
-    it "should not use a password" do
-      Redis.should_receive(:new).with({:host => "localhost", :port => 26379})
-      redis.should_receive(:sentinel).with("get-master-addr-by-name", "master")
-      redis.should_receive(:sentinel).with("is-master-down-by-addr", "remote.server", 8888)
-
-      redis = Redis::Client.new(:master_name => "master", :sentinels => [{:host => "localhost", :port => 26379}])
-      redis.discover_master
-
-      expect(redis.host).to eq "remote.server"
-      expect(redis.port).to eq 8888
-      expect(redis.password).to eq nil
+  context "#discover_master" do
+    it "updates master config options" do
+      expect(redis).to receive(:sentinel).with("get-master-addr-by-name", "master").and_return(["master", 8888])
+      expect(redis).to receive(:sentinel).with("sentinels", "master").and_return([{:host => "sentinel", :port => 8888}])
+      subject.discover_master
+      expect(subject.host).to eq "master"
+      expect(subject.port).to eq 8888
     end
 
-    it "should select next sentinel" do
-      Redis.should_receive(:new).with({:host => "localhost", :port => 26379})
-      redis.should_receive(:sentinel).
-            with("get-master-addr-by-name", "master").
-            and_raise(Redis::CannotConnectError)
-      Redis.should_receive(:new).with({:host => "localhost", :port => 26380})
-      redis.should_receive(:sentinel).
-            with("get-master-addr-by-name", "master")
-      redis.should_receive(:sentinel).
-            with("is-master-down-by-addr", "remote.server", 8888)
+    it "selects next sentinel if failed to connect to current_sentinel" do
+      expect(subject).to receive(:current_sentinel).and_return(redis)
+      expect(redis).to receive(:sentinel).with("get-master-addr-by-name", "master").and_raise(Redis::CannotConnectError)
+      sentinel = double('sentinel')
+      expect(subject).to receive(:current_sentinel).and_return(sentinel)
+      expect(sentinel).to receive(:sentinel).with("get-master-addr-by-name", "master").and_return(["master", 8888])
+      allow(subject).to receive(:refresh_sentinels_list)
       subject.discover_master
-      expect(subject.host).to eq "remote.server"
+      expect(subject.host).to eq "master"
       expect(subject.port).to eq 8888
-      expect(subject.password).to eq "foobar"
     end
 
-    describe "memoizing sentinel connections" do
-      it "does not reconnect to the sentinels" do
-        Redis.should_receive(:new).once
-
-        subject.discover_master
-        subject.discover_master
-      end
+    it "raises error if try_next_sentinel raises error" do
+      expect(subject).to receive(:try_next_sentinel).and_raise(Redis::CannotConnectError)
+      expect { subject.discover_master }.to raise_error(Redis::CannotConnectError)
     end
   end
 
@@ -111,7 +113,7 @@ describe Redis::Client do
       subject { Redis::Client.new }
 
       it "does not sleep" do
-        subject.should_not_receive(:sleep)
+        expect(subject).not_to receive(:sleep)
         expect do
           subject.auto_retry_with_timeout { raise Redis::CannotConnectError }
         end.to raise_error(Redis::CannotConnectError)
@@ -122,12 +124,12 @@ describe Redis::Client do
       subject { Redis::Client.new(:failover_reconnect_timeout => 3) }
 
       before(:each) do
-        subject.stub(:sleep)
+        allow(subject).to receive(:sleep)
       end
 
       it "only raises after the failover_reconnect_timeout" do
         called_counter = 0
-        Time.stub(:now).and_return(100, 101, 102, 103, 104, 105)
+        allow(Time).to receive(:now).and_return(100, 101, 102, 103, 104, 105)
 
         begin
           subject.auto_retry_with_timeout do
@@ -137,12 +139,12 @@ describe Redis::Client do
         rescue Redis::CannotConnectError
         end
 
-        called_counter.should == 4
+        expect(called_counter).to eq(4)
       end
 
       it "sleeps the default wait time" do
-        Time.stub(:now).and_return(100, 101, 105)
-        subject.should_receive(:sleep).with(0.1)
+        allow(Time).to receive(:now).and_return(100, 101, 105)
+        expect(subject).to receive(:sleep).with(0.1)
         begin
           subject.auto_retry_with_timeout { raise Redis::CannotConnectError }
         rescue Redis::CannotConnectError
@@ -150,7 +152,7 @@ describe Redis::Client do
       end
 
       it "does not catch other errors" do
-        subject.should_not_receive(:sleep)
+        expect(subject).not_to receive(:sleep)
         expect do
           subject.auto_retry_with_timeout { raise Redis::ConnectionError }
         end.to raise_error(Redis::ConnectionError)
@@ -161,8 +163,8 @@ describe Redis::Client do
                                     :failover_reconnect_wait => 0.01) }
 
         it "uses the configured wait time" do
-          Time.stub(:now).and_return(100, 101, 105)
-          subject.should_receive(:sleep).with(0.01)
+          allow(Time).to receive(:now).and_return(100, 101, 105)
+          expect(subject).to receive(:sleep).with(0.01)
           begin
             subject.auto_retry_with_timeout { raise Redis::CannotConnectError }
           rescue Redis::CannotConnectError
@@ -172,15 +174,14 @@ describe Redis::Client do
     end
   end
 
-  context "#reconnect" do
-    it "calls reconnect on each sentinel client" do
-      subject.stub(:connect)
-      subject.discover_master
-      subject.send(:redis_sentinels).each do |config, sentinel|
-        sentinel.client.should_receive(:reconnect)
-      end
-
-      subject.reconnect
+  context "#disconnect" do
+    it "calls disconnect on each sentinel client" do
+      sentinel = double('sentinel')
+      client = double('client')
+      allow(subject).to receive(:current_sentinel).and_return(sentinel)
+      expect(sentinel).to receive(:client).and_return(client)
+      expect(client).to receive(:disconnect)
+      subject.disconnect
     end
   end
 

data/spec/redis-sentinel/em_client_spec.rb

@@ -9,24 +9,24 @@ describe Redis::Client do
     context "configured wait time" do
 
       it "uses the wait time and blocks em" do
-        Time.stub(:now).and_return(100, 101, 105)
+        allow(Time).to receive(:now).and_return(100, 101, 105)
         flag = false; EM.next_tick { flag = true }
-        subject.should_receive(:sleep).with(0.1).and_return(0.1)
+        expect(subject).to receive(:sleep).with(0.1).and_return(0.1)
         begin
           subject.auto_retry_with_timeout { raise Redis::CannotConnectError }
         rescue Redis::CannotConnectError
         end
-        flag.should be_false
+        expect(flag).to be_false
       end
 
       it "uses the wait time and doesn't block em" do
-        Time.stub(:now).and_return(100, 101, 105)
+        allow(Time).to receive(:now).and_return(100, 101, 105)
         flag = false; EM.next_tick { flag = true }
         begin
           subject.auto_retry_with_timeout { raise Redis::CannotConnectError }
         rescue Redis::CannotConnectError
         end
-        flag.should be_true
+        expect(flag).to be_true
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-sentinel
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-25 00:00:00.000000000 Z
+date: 2014-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -114,6 +114,7 @@ files:
 - example/redis-master.conf
 - example/redis-sentinel1.conf
 - example/redis-sentinel2.conf
+- example/redis-sentinel3.conf
 - example/redis-slave.conf
 - example/test.rb
 - example/test_wait_for_failover.rb
@@ -145,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: another redis automatic master/slave failover solution for ruby by using