em-hiredis-sentinel 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12da4ece90b62751bab33970653fc6646597c5ab
-  data.tar.gz: 5df06626c12576441d7ec5fe3a18465f5dd5d44c
+  metadata.gz: 104a38dedcc6966ffbc70bbc9d75aa9f4575355c
+  data.tar.gz: 33f24f9988e59d6949f2dab4061c7cbe749b7bca
 SHA512:
-  metadata.gz: 5ecdcce6e55f24b4a0b31346dd5512c5009fd3432fb31efd459b3c23fb8a980429110dda986ad8f5d05e29842dd0a5f34f22e1ce415dac090c1dd9b83dade89a
-  data.tar.gz: 38223becb9dfc216e004da3009fc46a6525f89253349c2ed2da9da06023392637489debd842172b45f650087755d13e6b8d6ca59d8901ffdf65ea137a24842c0
+  metadata.gz: 3bf1bb72150d1bf7ccd0b68e2c6a9c49c8c09bb19c79820f6c6d5ad25857d4dc56a9f1bb8a8360532940e899ea7277959eda4cd179e26fd7cd66de66d9b54a7b
+  data.tar.gz: 0e4f3e54b0cdf3a8cf2c2e67a2a841e194a230ee4b983e11bce6cc70421f4c40142178ff662c04a534f1d054e47f753bf12bca9b462e7a7efabeb3925b382a0b

data/README.md

@@ -19,13 +19,36 @@ Or install it yourself as:
 ## Usage
 
     require 'em-hiredis-sentinel'
-    redis_sentinel = EM::Hiredis::Client.new('127.0.0.1',6379,nil,nil,
-                                                :sentinels => [
-                                                    {:host => '127.0.0.1', :port => 26379},
-                                                    {:host => '127.0.0.1', :port => 26380},
-                                                    {:host => '127.0.0.1', :port => 26381}
-                                                ],
-                                                :master_name => 'mymaster').connect
+    EM.run do
+      redis = EM::Hiredis::Sentinel::RedisClient.new(sentinels:[
+                              'redis://sentinel1.example.net',
+                              'xyz://sentinel2.example.net:26378',
+                              {host:'sentinel3.example.net'},
+                              {host:'sentinel4.example.net', port:26380},
+                              {url:'blah://sentinel5.example.net:26381'},
+                              {url:'ignored://sentinel6.example.net'}
+                            ],
+                            master_name:'mymaster'
+                          )
+      redis.connect
+      counter = 0
+      t = nil
+
+      redis.pubsub.on(:connected) do
+        p "connect callback"
+
+        t = EM.add_periodic_timer(2) do
+          counter += 1
+          redis.pubsub.publish("test", "test-#{counter}")
+        end
+      end
+
+      redis.pubsub.on(:disconnected) do
+        p "disconnect callback"
+        t.cancel
+      end
+
+    end
 
 
 ## Contributing

data/em-hiredis-sentinel.gemspec

@@ -1,6 +1,5 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
 require 'em-hiredis-sentinel/version'
 
 Gem::Specification.new do |spec|

data/lib/em-hiredis-sentinel/redis_client.rb

@@ -0,0 +1,352 @@
+require 'em-hiredis'
+
+module EventMachine::Hiredis::Sentinel
+  class RedisClient < EventMachine::Hiredis::Client
+    alias :super_connect :connect #to ref super's connect
+
+    def initialize(sentinels:[], master_name:'mymaster', db:0, password:nil)
+      @master_name = master_name
+      @sentinels = _parse_sentinel_options(sentinels)
+      p @sentinels
+      raise "Need at least 1 sentinel" if @sentinels.nil? || @sentinels.count < 1
+      @sentinels.uniq! {|h| h.values_at(:host, :port) }
+      @sentinels.shuffle! #try to randomize
+
+      init_sentinel_client
+
+      super(nil, nil, password, db)
+      init_master_client
+
+      #waits for connect to do anything
+    end
+
+    #override bc of auto .connect in super
+    def pubsub
+      #EM::Hiredis.logger.debug("pubsub")
+      @pubsub ||= begin
+        @with_pubsub = true
+        init_master_pubsub_client
+        update_master_pubsub_client(@master_client.host, @master_client.port) if @master_client.connected?
+        @master_pubsub_client
+      end
+    end
+
+    def connect(with_pubsub:false)
+      @with_pubsub ||= with_pubsub
+      try_next_sentinel
+      self
+    end
+
+    protected
+
+    def init_sentinel_client
+      @sentinel_client = EM::Hiredis::Client.new
+
+      @sentinel_client.on(:connected) do
+        EM::Hiredis.logger.debug("Connected to sentinel")
+        emit(:sentinel_connected)
+
+        EM.next_tick do
+          #wait till sentinel connected to init pubsub
+          @sentinel_pubsub_client ?
+            update_sentinel_pubsub_client(@sentinel_client.host, @sentinel_client.port) :
+            init_sentinel_pubsub_client #auto connects
+
+          discover_master unless @master_client.connected?
+        end
+      end
+
+      @sentinel_client.on(:failed) do
+        EM::Hiredis.logger.debug("Failed sentinel")
+        @sentinel_client.close_connection
+        emit(:sentinel_failed)
+
+        EM.add_timer(0.5) do
+          try_next_sentinel
+        end
+      end
+
+      @sentinel_client.on(:disconnected) do
+        EM::Hiredis.logger.debug("Disconnected from sentinel")
+        emit(:sentinel_disconnected)
+      end
+    end
+
+    def init_sentinel_pubsub_client
+      @sentinel_pubsub_client = @sentinel_client.pubsub #lazy init, this will auto try connect
+      @sentinel_pubsub_client.on(:connected) do
+        EM::Hiredis.logger.debug("Connected to sentinel for pubsub")
+        emit(:sentinel_pubsub_connected)
+      end
+
+       @sentinel_pubsub_client.on(:failed) do
+        EM::Hiredis.logger.debug("#{@name} pubsub failed")
+        @sentinel_pubsub_client.close_connection
+        emit(:sentinel_pubsub_failed)
+       end
+
+      @sentinel_pubsub_client.on(:disconnected) do
+        EM::Hiredis.logger.debug("Disconnected from sentinel for pubsub")
+        emit(:sentinel_pubsub_disconnected)
+      end
+
+      watch_sentinel
+    end
+
+    def watch_sentinel
+      #EM::Hiredis.logger.debug("watch_sentinel")
+
+      #@sentinel_pubsub_client.punsubscribe('*') #in case already subscribe?
+      @sentinel_pubsub_client.psubscribe('*') do |channel, message|
+        EM::Hiredis.logger.debug("SENTINEL PUBSUB #{channel} #{message}")
+
+        if channel == '+switch-master'
+          master_name, old_host, old_port, new_host, new_port = message.split(" ")
+
+          if master_name == @master_name
+            EM::Hiredis.logger.debug("Failover: #{old_host}:#{old_port} => #{new_host}:#{new_port}")
+            update_master_client(new_host, new_port.to_i)
+          end
+
+        elsif channel == '-odown' #TODO necessary?
+          type, master_name, host, port = message.split(" ")
+
+          if master_name == @master_name #&& type == 'master' type is always master for odown
+            EM::Hiredis.logger.debug("-ODOWN #{connected?}")
+            update_master_client(host, port.to_i)
+          end
+        end
+      end
+    end
+
+    def init_master_client
+      @master_client = self
+      @master_client.on(:connected) do
+        EM::Hiredis.logger.debug("#{@name} Connected to master")
+        @is_master_updating = false
+
+        #TODO confirm is master with ROLE (2.8.12)
+        emit(:master_connected)
+
+        EM.next_tick do
+          if @with_pubsub
+            if @master_pubsub_client
+              update_master_pubsub_client(@master_client.host, @master_client.port)
+            else
+              pubsub
+            end
+          end
+
+          refresh_sentinels_list #TODO maybe do on sentinel connect
+        end
+      end
+
+      @master_client.on(:failed) do
+        EM::Hiredis.logger.debug("#{@name} failed")
+        @is_master_updating = false
+        @master_client.close_connection
+        emit(:master_failed)
+        queue_discover_master
+      end
+
+      @master_client.on(:disconnected) do
+        EM::Hiredis.logger.debug("#{@name} Disconnected from master")
+        emit(:master_disconnected)
+      end
+    end
+
+    def init_master_pubsub_client
+      #EM::Hiredis.logger.debug("init_master_pubsub_client")
+      @master_pubsub_client = EM::Hiredis::PubsubClient.new(@master_client.host,
+                                                @master_client.port,
+                                                @master_client.password,
+                                                @master_client.db
+                                              )
+      @master_pubsub_client.on(:connected) do
+        EM::Hiredis.logger.debug("#{@name} Connected to master for pubsub")
+        emit(:master_pubsub_connected)
+      end
+
+       @master_pubsub_client.on(:failed) do
+        EM::Hiredis.logger.debug("#{@name} pubsub failed")
+        @master_pubsub_client.close_connection
+        emit(:master_pubsub_failed)
+       end
+
+      @master_pubsub_client.on(:disconnected) do
+        EM::Hiredis.logger.debug("#{@name} Disconnected from master for pubsub")
+        emit(:master_pubsub_disconnected)
+      end
+    end
+
+    def update_sentinel_client(host, port)
+      EM::Hiredis.logger.debug("update_sentinel_client #{host}, #{port}")
+
+      @sentinel_client.configure("redis://#{host}:#{port}")
+
+      if @sentinel_client.instance_variable_get(:@connection)
+        @sentinel_client.close_connection
+        EM.next_tick {
+          @sentinel_client.reconnect_connection
+        }
+      else
+        EM::Hiredis.logger.debug("FIRST SENTINEL CONNECT ATTEMPT")
+        EM.next_tick {
+          @sentinel_client.connect #first time, bc baseclient isnt expecting deferred connecting
+        }
+      end
+
+    rescue => e
+      EM::Hiredis.logger.warn(e)
+      EM.next_tick do
+        try_next_sentinel
+      end
+    end
+
+    def update_sentinel_pubsub_client(host, port)
+      EM::Hiredis.logger.debug("update_sentinel_pubsub_client #{host}, #{port}")
+      @sentinel_pubsub_client.configure("redis://#{host}:#{port}")
+
+      if @sentinel_pubsub_client.instance_variable_get(:@connection)
+        @sentinel_pubsub_client.close_connection
+        EM.next_tick {
+          @sentinel_pubsub_client.reconnect_connection
+        }
+      else
+        EM::Hiredis.logger.debug("FIRST SENTINEL PUBSUB CONNECT ATTEMPT")
+        EM.next_tick {
+          @sentinel_pubsub_client.connect #first time, bc baseclient isnt expecting deferred connecting
+        }
+      end
+
+    rescue => e
+      EM::Hiredis.logger.warn(e)
+    end
+
+    def update_master_client(host, port)
+      EM::Hiredis.logger.debug("update_master_client #{host}, #{port}")
+      EM::Hiredis.logger.debug("MASTER IS UPDATING") if @is_master_updating
+      EM::Hiredis.logger.debug("MASTER IS ALREADY CONNECTED") if @master_client.connected?
+
+      return if @master_client.connected?
+      return if @is_master_updating #prevent reupdate, can be updated by discover or sentinel pubsub watching
+
+      @is_master_updating = true
+
+      @master_client.configure("redis://#{host}:#{port}") #@host, @port = host, port
+
+      if @master_client.instance_variable_get(:@connection)
+        @master_client.close_connection
+        EM.next_tick {
+          @master_client.reconnect_connection
+        }
+      else
+        EM::Hiredis.logger.debug("FIRST MASTER CONNECT ATTEMPT")
+        EM.next_tick {
+          @master_client.super_connect #first time, bc baseclient isnt expecting deferred connecting
+        }
+      end
+
+      rescue => e
+        EM::Hiredis.logger.warn(e)
+        @is_master_updating = false
+        queue_discover_master
+    end
+
+    def update_master_pubsub_client(host, port)
+      EM::Hiredis.logger.debug("update_master_pubsub_client #{host}, #{port}")
+      @master_pubsub_client.configure("redis://#{host}:#{port}")
+
+      if @master_pubsub_client.instance_variable_get(:@connection)
+        @master_pubsub_client.close_connection
+        EM.next_tick {
+          @master_pubsub_client.reconnect_connection
+        }
+      else
+        EM::Hiredis.logger.debug("FIRST MASTER PUBSUB CONNECT ATTEMPT")
+        EM.next_tick {
+          @master_pubsub_client.connect #first time, bc baseclient isnt expecting deferred connecting
+        }
+      end
+    rescue => e
+      EM::Hiredis.logger.warn(e)
+    end
+
+    def try_next_sentinel
+      #EM::Hiredis.logger.debug("try_next_sentinel")
+      s = @sentinels.shift
+      @sentinels.push s
+      s = @sentinels.first
+      update_sentinel_client(s[:host], s[:port])
+    end
+
+    def queue_discover_master
+      EM.add_timer(0.5) {
+        discover_master
+      }
+    end
+
+    def discover_master
+      EM::Hiredis.logger.debug("discover_master")
+
+      if @sentinel_client.connected?
+        response_deferrable = @sentinel_client.sentinel("get-master-addr-by-name", @master_name)
+
+        response_deferrable.callback do |value|
+          EM::Hiredis.logger.debug("discover_master callback")
+          master_host, master_port = value
+          EM::Hiredis.logger.debug("returned #{master_host} #{master_port}")
+          if master_host && master_port #TODO better check, seems either insufficient or unnecessary
+            update_master_client(master_host, master_port.to_i)
+          else
+            EM::Hiredis.logger.debug("discover_master trying again")
+            queue_discover_master
+          end
+        end
+
+        response_deferrable.errback do |e|
+          EM::Hiredis.logger.WARN("discover_master error")
+          queue_discover_master
+        end
+
+      end
+    end
+
+    def refresh_sentinels_list
+      response_deferrable = @sentinel_client.sentinel("sentinels", @master_name)
+
+      response_deferrable.callback do |sentinels|
+        sentinels.each do |s|
+          @sentinels << {:host => s[3], :port => s[5]} #TODO will break if order changes
+        end
+
+        @sentinels.uniq! {|h| h.values_at(:host, :port) }
+      end
+    end
+
+    private
+
+    def _parse_sentinel_options(options)
+      opts = []
+      options.each do |o|
+        o = o[:url] if o.is_a?(Hash) && o.key?(:url)
+
+        case o
+          when Hash
+            opts << {
+              host: o[:host],
+              port: o[:port] || 26379
+            }
+          else
+            uri = URI.parse(o)
+            opts << {
+              :host => uri.host,
+              :port => uri.port || 26379
+            }
+        end
+      end
+
+      opts
+    end
+  end
+end

data/lib/em-hiredis-sentinel/version.rb

@@ -3,7 +3,7 @@ require 'eventmachine'
 module EventMachine
   module Hiredis
     module Sentinel
-      VERSION = '0.1.3'
+      VERSION = '0.2.0'
     end
   end
 end

data/lib/em-hiredis-sentinel.rb

@@ -1,14 +1,2 @@
 require 'em-hiredis'
-require 'em-hiredis-sentinel/client'
-require 'em-hiredis-sentinel/base_client'
-require 'em-hiredis-sentinel/pubsub_client'
-
-module EventMachine::Hiredis
-  class_eval {
-    def self.connect_sentinel(options={})
-      # Should Return an EM-Hiredis client with added sentinel support
-      sentinel_client = EM::Hiredis::Sentinel::Client.new options
-      sentinel_client.redis_client
-    end
-  }
-end
+require 'em-hiredis-sentinel/redis_client'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: em-hiredis-sentinel
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Justin Schneck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-10 00:00:00.000000000 Z
+date: 2014-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,12 +65,8 @@ files:
 - README.md
 - Rakefile
 - em-hiredis-sentinel.gemspec
-- examples/getting_started.rb
-- examples/pubsub.rb
 - lib/em-hiredis-sentinel.rb
-- lib/em-hiredis-sentinel/base_client.rb
-- lib/em-hiredis-sentinel/client.rb
-- lib/em-hiredis-sentinel/pubsub_client.rb
+- lib/em-hiredis-sentinel/redis_client.rb
 - lib/em-hiredis-sentinel/version.rb
 homepage: https://github.com/mobileoverlord/em-hiredis-sentinel
 licenses:

data/examples/getting_started.rb

@@ -1,28 +0,0 @@
-$:.unshift(File.expand_path('../../lib', __FILE__))
-require 'em-hiredis-sentinel'
-require 'logger'
-
-EM.run {
-
-  EM::Hiredis.logger = Logger.new('output.log')
-
-
-  redis_sentinel = EM::Hiredis::Client.new('127.0.0.1',6379,nil,nil,
-                                                :sentinels => [
-                                                    {:host => '127.0.0.1', :port => 26379},
-                                                    {:host => '127.0.0.1', :port => 26380},
-                                                    {:host => '127.0.0.1', :port => 26381}
-                                                ],
-                                                :master_name => 'mymaster').connect
-
-  EM.add_periodic_timer(1) {
-    puts "Connected: #{redis_sentinel.connected?}"
-    response_deferrable = redis_sentinel.get('foo')
-    response_deferrable.callback { |value|
-      puts value
-    }
-    response_deferrable.errback { |e|
-      puts e
-    }
-  }
-}

data/examples/pubsub.rb

@@ -1,21 +0,0 @@
-$:.unshift(File.expand_path('../../lib', __FILE__))
-require 'em-hiredis-sentinel'
-require 'logger'
-
-EM.run {
-
-  EM::Hiredis.logger = Logger.new('output.log')
-
-
-  redis_sentinel = EM::Hiredis::Client.new('127.0.0.1',6379,nil,nil,
-                                                :sentinels => [
-                                                    {:host => '127.0.0.1', :port => 26379},
-                                                    {:host => '127.0.0.1', :port => 26380},
-                                                    {:host => '127.0.0.1', :port => 26381}
-                                                ],
-                                                :master_name => 'mymaster').connect
-
-  redis_sentinel.pubsub.subscribe('foo') { |msg|
-    puts msg
-  }
-}

data/lib/em-hiredis-sentinel/base_client.rb

@@ -1,129 +0,0 @@
-module EventMachine::Hiredis
-  class BaseClient
-    class_eval {
-      attr_reader :sentinel_options
-
-      def initialize_with_sentinel(host = 'localhost', port = 6379, password = nil, db = nil, sentinel_options={})
-        
-        initialize_without_sentinel(host,port,password,db)
-        if sentinel_options.nil? || sentinel_options.empty?
-          return
-        end
-
-        @sentinel_options = sentinel_options.dup
-        @master_name = @sentinel_options[:master_name]
-        @sentinels_options = _parse_sentinel_options(@sentinel_options[:sentinels])
-
-        @current_sentinel = EM::Hiredis::Client.new(@sentinels_options[0][:host],@sentinels_options[0][:port]).connect
-        @current_sentinel.on(:disconnected) {
-          EM::Hiredis.logger.info('Sentinel Failed')
-          try_next_sentinel
-        }
-
-        #discover_master
-        watch_sentinel
-        
-      end
-
-      alias initialize_without_sentinel initialize
-      alias initialize initialize_with_sentinel
-
-      def watch_sentinel
-        pubsub = @current_sentinel.pubsub
-        pubsub.punsubscribe('*')
-        pubsub.psubscribe('*')
-        pubsub.on(:pmessage) { |pattern, channel, message|
-          next if channel != '+switch-master'
-
-          master_name, old_host, old_port, new_host, new_port = message.split(" ")
-
-          next if master_name != @master_name
-          EM::Hiredis.logger.info("Failover: #{old_host}:#{old_port} => #{new_host}:#{new_port}")
-          close_connection
-          @host, @port = new_host,new_port.to_i
-          reconnect_connection
-        }
-      end
-
-      def try_next_sentinel
-
-        sentinel_options = @sentinels_options.shift
-        @sentinels_options.push sentinel_options
-
-        EM::Hiredis.logger.info("Trying next sentinel: #{sentinel_options[:host]}:#{sentinel_options[:port]}")
-        @current_sentinel.close_connection
-        @current_sentinel.configure("redis://#{sentinel_options[:host]}:#{sentinel_options[:port]}")
-        @current_sentinel.reconnect_connection
-        unless @switching_sentinels
-          @switching_sentinels = true
-          @sentinel_timer = EM.add_periodic_timer(1) {
-            if @current_sentinel.connected?
-              @switching_sentinels = false
-              @sentinel_timer.cancel
-            else
-              try_next_sentinel
-            end
-          }
-        end
-      end
-
-      def discover_master
-        response_deferrable = @current_sentinel.sentinel("get-master-addr-by-name", @master_name)
-        response_deferrable.callback { |value|
-          master_host, master_port = value
-
-          if master_host && master_port
-
-            @host, @port = master_host,master_port.to_i
-            reconnect_connection
-            refresh_sentinels_list
-          else
-            EM.next_tick {
-              self.discover_master
-            }
-          end
-        }
-        response_deferrable.errback { |e|
-          EM.next_tick {
-            self.discover_master
-          }
-        }
-      end
-
-      def refresh_sentinels_list
-        response_deferrable = @current_sentinel.sentinel("sentinels", @master_name)
-        response_deferrable.callback { |sentinels|
-          sentinels.each { |sentinel|
-            @sentinels_options << {:host => sentinel[3], :port => sentinel[5]}
-            @sentinels_options.uniq! {|h| h.values_at(:host, :port) }
-          }
-        }
-        response_deferrable.errback { |e|
-          try_next_sentinel
-        }
-      end
-
-      private
-
-      def _parse_sentinel_options(options)
-        return if options.nil?
-
-        sentinel_options = []
-        options.each do |opts|
-          opts = opts[:url] if opts.is_a?(Hash) && opts.key?(:url)
-          case opts
-            when Hash
-              sentinel_options << opts
-            else
-              uri = URI.parse(opts)
-              sentinel_options << {
-                  :host => uri.host,
-                  :port => uri.port
-              }
-          end
-        end
-        sentinel_options
-      end
-    }    
-  end
-end

data/lib/em-hiredis-sentinel/client.rb

@@ -1,11 +0,0 @@
-module EventMachine::Hiredis
-  class Client < BaseClient
-    class_eval {
-      def pubsub
-        @pubsub ||= begin
-          PubsubClient.new(@host, @port, @password, @db, @sentinel_options).connect
-        end
-      end
-    }
-  end
-end

data/lib/em-hiredis-sentinel/pubsub_client.rb

@@ -1,11 +0,0 @@
-module EventMachine::Hiredis
-  class PubsubClient < BaseClient
-    class_eval {
-      def initialize(host='localhost', port='6379', password=nil, db=nil, sentinel_options={})
-        @subs, @psubs = [], []
-        @pubsub_defs = Hash.new { |h,k| h[k] = [] }
-        super
-      end
-    }
-  end
-end