redis_cluster 0.2.9 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d5f4f4dd87bea457c22bcb596945c12e2cffad6b
-  data.tar.gz: 9cce133f24ba35be564f9a241513a8ae28a49254
+  metadata.gz: f4e3f46f9197fb5e41afea6d2b4e0f41af7defbc
+  data.tar.gz: 21e8e6613f409e4d2ea6942cac0c5a44dc855bff
 SHA512:
-  metadata.gz: 5d88d716725acf7b52ca0c99690b86d4203a3a725f5589a4af3f5020317b73139626105a5858336c559131c566d109a542b6a2f4dd1cfae05936deac3bb57ee4
-  data.tar.gz: 55428c277ba8d8a7accc20a4d5cdf572b7df74df550b73409570fe60fd5131f90cf1551133968f8cd4c387bcedc738f82330b13ed077f8582579198d6f1a9015
+  metadata.gz: d01fd2610f8e69cec1344105227b0ae007aa60fd066d4f5bc9d77320dbd6eb0b8af6bd524bc4fb9771a3a125cf43b686c4838ac3ec85d414dd7aa9d41a1fdab3
+  data.tar.gz: e8006dabb95bfc9ff141fdf0b8120b308b649e65f3183fe6400ff77c4b655f00d91db5ceb5e4131ebfa48d343afe9dc1ca2f2382db0fb77a84acf379626ef3cf

data/Gemfile

@@ -2,3 +2,11 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in redis_cluster.gemspec
 gemspec
+
+group :development do
+  platforms :mri do
+    if RUBY_VERSION >= "2.0.0"
+      gem "pry-byebug"
+    end
+  end
+end

data/README.md

@@ -28,13 +28,15 @@ Or install it yourself as:
 First you need to configure redis cluster with some nodes! Please see: [https://redis.io/topics/cluster-tutorial](https://redis.io/topics/cluster-tutorial)
 
 ```ruby
-# don't need all, gem can auto detect all nodes, and process failover if some master nodes down
+# Don't need all, gem can auto detect all nodes, and process failover if some master nodes down
 hosts = [{host: '127.0.0.1', port: 7000}, {host: '127.0.0.1', port: 7001}]
 rs = RedisCluster.new hosts
 rs.set "test", 1
 rs.get "test"
 ```
 
+At development environment with single redis node, you can set hosts a hash value: {host: 'xx', port: 6379}.
+
 If masterauth & requirepass configed, you can initialize below:
 ```ruby
 RedisCluster.new hosts, password: 'password'
@@ -74,20 +76,16 @@ rs.eval "return 'hello redis!'", [:foo]
 
 ## Benchmark test
 
-A simple benchmark at my macbook, start 4 master nodes (and 4 cold slave nodes), running with one ruby process.
-This only testing redis_cluster can work, not for redis Performance. When I fork 8 ruby process same time and run get command，redis can run 80,000 - 110,000 times per second at my macbook.
-
-
 ```ruby
 Benchmark.bm do |x|
   x.report do
     1.upto(100_000).each do |i|
-      redis.get "test#{i}"
+      redis.set "test#{i}", i
     end
   end
   x.report do
     1.upto(100_000).each do |i|
-      redis.set "test#{i}", i
+      redis.get "test#{i}"
     end
   end
   x.report do

data/lib/redis_cluster/client.rb

@@ -4,40 +4,77 @@ module RedisCluster
 
   class Client
 
-    def initialize(startup_hosts, global_configs = {})
+    def initialize(startup_hosts, configs = {})
       @startup_hosts = startup_hosts
-      @pool = Pool.new(global_configs)
+
+      # Extract configuration options relevant to Redis Cluster.
+
+      # force_cluster defaults to true to match the client's behavior before
+      # the option existed
+      @force_cluster = configs.delete(:force_cluster) { |_key| true }
+
+      # The number of times to retry a failed execute. Redis errors, `MOVE`, or
+      # `ASK` are all considered failures that will count towards this tally. A
+      # count of at least 2 is probably sensible because if a node disappears
+      # the first try will be a Redis error, the second try retry will probably
+      # be a `MOVE` (whereupon the node pool is reloaded), and it will take
+      # until the third try to succeed.
+      @retry_count = configs.delete(:retry_count) { |_key| 3 }
+
+      # Any leftover configuration goes through to the pool and onto individual
+      # Redis clients.
+      @pool = Pool.new(configs)
       @mutex = Mutex.new
+
       reload_pool_nodes(true)
     end
 
     def execute(method, args, &block)
-      ttl = Configuration::REQUEST_TTL
       asking = false
+      last_error = nil
+      retries_left = @retry_count
       try_random_node = false
 
-      while ttl > 0
-        ttl -= 1
+      # We use `>= 0` instead of `> 0` because we decrement this counter on the
+      # first run.
+      while retries_left >= 0
+        retries_left -= 1
+
         begin
           return @pool.execute(method, args, {asking: asking, random_node: try_random_node}, &block)
-        rescue Errno::ECONNREFUSED, Redis::TimeoutError, Redis::CannotConnectError, Errno::EACCES
+
+        rescue Errno::ECONNREFUSED, Redis::TimeoutError, Redis::CannotConnectError, Errno::EACCES => e
+          last_error = e
+
+          # Getting an error while executing may be an indication that we've
+          # lost the node that we were talking to and in that case it makes
+          # sense to try a different node and maybe reload our node pool (if
+          # the new node issues a `MOVE`).
           try_random_node = true
-          sleep 0.1 if ttl < Configuration::REQUEST_TTL/2
+
         rescue => e
+          last_error = e
+
           err_code = e.to_s.split.first
           raise e unless %w(MOVED ASK).include?(err_code)
 
           if err_code == 'ASK'
             asking = true
           else
-            reload_pool_nodes
-            sleep 0.1 if ttl < Configuration::REQUEST_TTL/2
+            # `MOVED` indicates a permanent redirect which means that our slot
+            # mappings are stale: reload them.
+            reload_pool_nodes(false)
           end
         end
       end
+
+      # If we ran out of retries (the maximum number may have been set to 0),
+      # surface any error that was thrown back to the caller. We'd otherwise
+      # suppress the error, which would return something quite unexpected.
+      raise last_error
     end
 
-    Configuration::SUPPORT_SINGLE_NODE_METHODS.each do |method_name|
+    Configuration.method_names.each do |method_name|
       define_method method_name do |*args, &block|
         execute(method_name, args, &block)
       end
@@ -49,33 +86,86 @@ module RedisCluster
 
     private
 
-    def reload_pool_nodes(raise_error = false)
-      return @pool.add_node!(@startup_hosts, [(0..Configuration::HASH_SLOTS)]) unless @startup_hosts.is_a? Array
+    # Adds only a single node to the client pool and sets it result for the
+    # entire space of slots. This is useful when running either a standalone
+    # Redis or a single-node Redis Cluster.
+    def create_single_node_pool
+      host = @startup_hosts
+      if host.is_a?(Array)
+        if host.length > 1
+          raise ArgumentError, "Can only create single node pool for single host"
+        end
 
-      @mutex.synchronize do
-        @startup_hosts.each do |options|
-          begin
-            redis = Node.redis(@pool.global_configs.merge(options))
-            slots_mapping = redis.cluster("slots").group_by{|x| x[2]}
-            @pool.delete_except!(slots_mapping.keys)
-            slots_mapping.each do |host, infos|
-              slots_ranges = infos.map {|x| x[0]..x[1] }
-              @pool.add_node!({host: host[0], port: host[1]}, slots_ranges)
+        # Flatten the configured host so that we can easily add it to the
+        # client pool.
+        host = host.first
+      end
+
+      @pool.add_node!(host, [(0..Configuration::HASH_SLOTS)])
+    end
+
+    def create_multi_node_pool(raise_error)
+      unless @startup_hosts.is_a?(Array)
+        raise ArgumentError, "Can only create multi-node pool for multiple hosts"
+      end
+
+      @startup_hosts.each do |options|
+        begin
+          redis = Node.redis(@pool.global_configs.merge(options))
+          slots_mapping = redis.cluster("slots").group_by{|x| x[2]}
+          @pool.delete_except!(slots_mapping.keys)
+          slots_mapping.each do |host, infos|
+            slots_ranges = infos.map {|x| x[0]..x[1] }
+            @pool.add_node!({host: host[0], port: host[1]}, slots_ranges)
+          end
+        rescue Redis::CommandError => e
+          if e.message =~ /cluster\ support\ disabled$/
+            if !@force_cluster
+              # We're running outside of cluster-mode -- just create a
+              # single-node pool and move on. The exception is if we've been
+              # asked for force Redis Cluster, in which case we assume this is
+              # a configuration problem and maybe raise an error.
+              create_single_node_pool
+              return
+            elsif raise_error
+              raise e
             end
-          rescue Redis::CommandError => e
-            raise e if raise_error && e.message =~ /cluster\ support\ disabled$/
-            raise e if e.message =~ /NOAUTH\ Authentication\ required/
-            next
-          rescue
-            next
           end
-          break
+
+          raise e if e.message =~ /NOAUTH\ Authentication\ required/
+
+          # TODO: log error for visibility
+          next
+        rescue
+          # TODO: log error for visibility
+          next
+        end
+
+        # We only need to see a `CLUSTER SLOTS` result from a single host, so
+        # break after one success.
+        break
+      end
+    end
+
+    # Reloads the client node pool by requesting new information with `CLUSTER
+    # SLOTS` or just adding a node directly if running on standalone. Clients
+    # are "upserted" so that we don't necessarily drop clients that are still
+    # relevant.
+    def reload_pool_nodes(raise_error)
+      @mutex.synchronize do
+        if @startup_hosts.is_a?(Array)
+          create_multi_node_pool(raise_error)
+          refresh_startup_nodes
+        else
+          create_single_node_pool
         end
-        fresh_startup_nodes
       end
     end
 
-    def fresh_startup_nodes
+    # Refreshes the contents of @startup_hosts based on the hosts currently in
+    # the client pool. This is useful because we may have been told about new
+    # hosts after running `CLUSTER SLOTS`.
+    def refresh_startup_nodes
       @pool.nodes.each {|node| @startup_hosts.push(node.host_hash) }
       @startup_hosts.uniq!
     end

data/lib/redis_cluster/configuration.rb

@@ -2,7 +2,6 @@ module RedisCluster
 
   class Configuration
     HASH_SLOTS = 16384
-    REQUEST_TTL = 16
     DEFAULT_TIMEOUT = 1
 
     SUPPORT_SINGLE_NODE_METHODS = %w(
@@ -18,6 +17,10 @@ module RedisCluster
     ).freeze
 
     SUPPORT_MULTI_NODE_METHODS = %w(keys script multi pipelined).freeze
+
+    def self.method_names
+      SUPPORT_SINGLE_NODE_METHODS + SUPPORT_MULTI_NODE_METHODS
+    end
   end
 
 end

data/lib/redis_cluster/errors.rb

@@ -1,7 +1,26 @@
 module RedisCluster
-  NotSupportError = Class.new StandardError
+  class CommandNotSupportedError < StandardError
+    def initialize(command)
+      super("Command #{command} is not supported for Redis Cluster")
+    end
+  end
 
-  KeysNotAtSameSlotError = Class.new StandardError
+  class KeysNotAtSameSlotError < StandardError
+    def initialize(keys)
+      super("Keys must map to the same Redis Cluster slot when using " \
+        "EVAL/EVALSHA. Consider using Redis Cluster 'hash tags' (see " \
+        "documentation). Keys: #{keys}")
+    end
+  end
 
-  KeyNotAppointError = Class.new StandardError
+  class KeysNotSpecifiedError < StandardError
+    def initialize(command)
+      super("Keys must be specified for command #{command}")
+    end
+  end
+
+  # These error classes were renamed. These aliases are here for backwards
+  # compatibility.
+  KeyNotAppointError = KeysNotSpecifiedError
+  NotSupportError = CommandNotSupportedError
 end

data/lib/redis_cluster/pool.rb

@@ -28,7 +28,7 @@ module RedisCluster
       return send(method, args, &block) if Configuration::SUPPORT_MULTI_NODE_METHODS.include?(method.to_s)
 
       key = key_by_command(method, args)
-      raise NotSupportError if key.nil?
+      raise CommandNotSupportedError.new(method.upcase) if key.nil?
 
       node = other_options[:random_node] ? random_node : node_by(key)
       node.asking if other_options[:asking]
@@ -70,8 +70,14 @@ module RedisCluster
       when 'info', 'exec', 'slaveof', 'config', 'shutdown'
         nil
       when 'eval', 'evalsha'
-        raise KeyNotAppointError if args[1].nil? || args[1].empty?
-        raise KeysNotAtSameSlotError unless Slot.at_one?(args[1])
+        if args[1].nil? || args[1].empty?
+          raise KeysNotSpecifiedError.new(method.upcase)
+        end
+
+        unless Slot.at_one?(args[1])
+          raise KeysNotAtSameSlotError.new(args[1])
+        end
+
         return args[1][0]
       else
         return args.first

data/lib/redis_cluster/version.rb

@@ -1,3 +1,3 @@
 module RedisCluster
-  VERSION = "0.2.9"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis_cluster
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.3.0
 platform: ruby
 authors:
 - wangzc
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-04 00:00:00.000000000 Z
+date: 2018-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -142,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: redis cluster client