redis-cluster-client 0.3.14 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 909179c8cf02cee3894f4cb11c7d51e8de13d667345daceb3c0f13306b661613
-  data.tar.gz: 959e61ae91001a48177cc19e72e4e7af3f95224481080751cebf2c8d04f2665c
+  metadata.gz: 780e5f1653b6633dbd4bb1bdc4f4da174d70176a5287bf6156ad5784f0612cf1
+  data.tar.gz: ca1681357111afdc82bdf32a18985963dba85f89fd49961ac62c56075daa0cc8
 SHA512:
-  metadata.gz: c5e4ce403a09a18bfa94d5e0bf70db3277d16bcb05a8d300b4555ecb4f3b743a50af10a19ffe5988f8f60e06813a5dd147895410fb02b1f15522907a6dfe4143
-  data.tar.gz: 56154b82f8ced444d757df7b6438d58d2d2d187917f61aa40e78b980811e7b597d090c1a982d72b6ca100fa6e606a7719faeec9eef0688d102058d4976178e41
+  metadata.gz: 4111e4b1305d955d3eb56df912debd0cfbbd388bae1d841cf1b9274a21d2e121fb511f1630d85f6c503d53ebf514503303b94402d3416517886b93f615584a22
+  data.tar.gz: 1f6e2be52bcd834482d17bebfeead2b8d1346c954d03b61251dd973ab19f27275e53571d73ba6425dceedc34dc07cd5e6dbb98fa46de00281b6d00eeb1c87f08

data/lib/redis_client/cluster/node/latency_replica.rb

@@ -43,7 +43,7 @@ class RedisClient
           clients.each_slice(::RedisClient::Cluster::Node::MAX_THREADS).each_with_object({}) do |chuncked_clients, acc|
             threads = chuncked_clients.map do |k, v|
               Thread.new(k, v) do |node_key, client|
-                Thread.current.thread_variable_set(:node_key, node_key)
+                Thread.current[:node_key] = node_key
 
                 min = DUMMY_LATENCY_NSEC
                 MEASURE_ATTEMPT_COUNT.times do
@@ -53,15 +53,15 @@ class RedisClient
                   min = duration if duration < min
                 end
 
-                Thread.current.thread_variable_set(:latency, min)
+                Thread.current[:latency] = min
               rescue StandardError
-                Thread.current.thread_variable_set(:latency, DUMMY_LATENCY_NSEC)
+                Thread.current[:latency] = DUMMY_LATENCY_NSEC
               end
             end
 
             threads.each do |t|
               t.join
-              acc[t.thread_variable_get(:node_key)] = t.thread_variable_get(:latency)
+              acc[t[:node_key]] = t[:latency]
             end
           end
         end

data/lib/redis_client/cluster/node.rb

@@ -18,7 +18,6 @@ class RedisClient
       MAX_STARTUP_SAMPLE = 37
       MAX_THREADS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', 5))
       IGNORE_GENERIC_CONFIG_KEYS = %i[url host port path].freeze
-      SLOT_OPTIMIZATION_STRING = '0' * SLOT_SIZE
 
       ReloadNeeded = Class.new(::RedisClient::Error)
 
@@ -37,27 +36,36 @@ class RedisClient
         end
       end
 
-      Slot = Struct.new('StringArray', :string, :elements, keyword_init: true) do
+      class CharArray
+        BASE = ''
+        PADDING = '0'
+
+        def initialize(size, elements)
+          @elements = elements
+          @string = String.new(BASE, encoding: Encoding::BINARY, capacity: size)
+          size.times { @string << PADDING }
+        end
+
         def [](index)
           raise IndexError if index < 0
-          return if index >= string.bytesize
+          return if index >= @string.bytesize
 
-          elements[string.getbyte(index)]
+          @elements[@string.getbyte(index)]
         end
 
         def []=(index, element)
           raise IndexError if index < 0
-          return if index >= string.bytesize
+          return if index >= @string.bytesize
 
-          pos = elements.find_index(element) # O(N)
+          pos = @elements.find_index(element) # O(N)
           if pos.nil?
-            raise(RangeError, 'full of elements') if elements.size >= 256
+            raise(RangeError, 'full of elements') if @elements.size >= 256
 
-            pos = elements.size
-            elements << element
+            pos = @elements.size
+            @elements << element
           end
 
-          string.setbyte(index, pos)
+          @string.setbyte(index, pos)
         end
       end
 
@@ -85,11 +93,11 @@ class RedisClient
           startup_nodes.each_slice(MAX_THREADS).with_index do |chuncked_startup_nodes, chuncked_idx|
             threads = chuncked_startup_nodes.each_with_index.map do |raw_client, idx|
               Thread.new(raw_client, (MAX_THREADS * chuncked_idx) + idx) do |cli, i|
-                Thread.current.thread_variable_set(:index, i)
+                Thread.current[:index] = i
                 reply = cli.call('CLUSTER', 'NODES')
-                Thread.current.thread_variable_set(:info, parse_cluster_node_reply(reply))
+                Thread.current[:info] = parse_cluster_node_reply(reply)
               rescue StandardError => e
-                Thread.current.thread_variable_set(:error, e)
+                Thread.current[:error] = e
               ensure
                 cli&.close
               end
@@ -97,12 +105,12 @@ class RedisClient
 
             threads.each do |t|
               t.join
-              if t.thread_variable?(:info)
+              if t.key?(:info)
                 node_info_list ||= Array.new(startup_size)
-                node_info_list[t.thread_variable_get(:index)] = t.thread_variable_get(:info)
-              elsif t.thread_variable?(:error)
+                node_info_list[t[:index]] = t[:info]
+              elsif t.key?(:error)
                 errors ||= Array.new(startup_size)
-                errors[t.thread_variable_get(:index)] = t.thread_variable_get(:error)
+                errors[t[:index]] = t[:error]
               end
             end
           end
@@ -268,10 +276,8 @@ class RedisClient
       def make_array_for_slot_node_mappings(node_info_list)
         return Array.new(SLOT_SIZE) if node_info_list.count(&:primary?) > 256
 
-        ::RedisClient::Cluster::Node::Slot.new(
-          string: String.new(SLOT_OPTIMIZATION_STRING, encoding: Encoding::BINARY, capacity: SLOT_SIZE),
-          elements: node_info_list.select(&:primary?).map(&:node_key)
-        )
+        primary_node_keys = node_info_list.select(&:primary?).map(&:node_key)
+        ::RedisClient::Cluster::Node::CharArray.new(SLOT_SIZE, primary_node_keys)
       end
 
       def build_replication_mappings(node_info_list) # rubocop:disable Metrics/AbcSize
@@ -285,7 +291,7 @@ class RedisClient
 
       def call_multiple_nodes(clients, method, command, args, &block)
         results, errors = try_map(clients) do |_, client|
-          client.send(method, *args, command, &block)
+          client.public_send(method, *args, command, &block)
         end
 
         [results&.values, errors]
@@ -303,22 +309,22 @@ class RedisClient
         clients.each_slice(MAX_THREADS) do |chuncked_clients|
           threads = chuncked_clients.map do |k, v|
             Thread.new(k, v) do |node_key, client|
-              Thread.current.thread_variable_set(:node_key, node_key)
+              Thread.current[:node_key] = node_key
               reply = yield(node_key, client)
-              Thread.current.thread_variable_set(:result, reply)
+              Thread.current[:result] = reply
             rescue StandardError => e
-              Thread.current.thread_variable_set(:error, e)
+              Thread.current[:error] = e
             end
           end
 
           threads.each do |t|
             t.join
-            if t.thread_variable?(:result)
+            if t.key?(:result)
               results ||= {}
-              results[t.thread_variable_get(:node_key)] = t.thread_variable_get(:result)
-            elsif t.thread_variable?(:error)
+              results[t[:node_key]] = t[:result]
+            elsif t.key?(:error)
               errors ||= {}
-              errors[t.thread_variable_get(:node_key)] = t.thread_variable_get(:error)
+              errors[t[:node_key]] = t[:error]
             end
           end
         end

data/lib/redis_client/cluster/pipeline.rb

@@ -150,34 +150,34 @@ class RedisClient
         @pipelines&.each_slice(MAX_THREADS) do |chuncked_pipelines|
           threads = chuncked_pipelines.map do |node_key, pipeline|
             Thread.new(node_key, pipeline) do |nk, pl|
-              Thread.current.thread_variable_set(:node_key, nk)
+              Thread.current[:node_key] = nk
               replies = do_pipelining(@router.find_node(nk), pl)
               raise ReplySizeError, "commands: #{pl._size}, replies: #{replies.size}" if pl._size != replies.size
 
-              Thread.current.thread_variable_set(:replies, replies)
+              Thread.current[:replies] = replies
             rescue ::RedisClient::Cluster::Pipeline::RedirectionNeeded => e
-              Thread.current.thread_variable_set(:redirection_needed, e)
+              Thread.current[:redirection_needed] = e
             rescue StandardError => e
-              Thread.current.thread_variable_set(:error, e)
+              Thread.current[:error] = e
             end
           end
 
           threads.each(&:join)
           threads.each do |t|
-            if t.thread_variable?(:replies)
+            if t.key?(:replies)
               all_replies ||= Array.new(@size)
-              @pipelines[t.thread_variable_get(:node_key)]
+              @pipelines[t[:node_key]]
                 .outer_indices
-                .each_with_index { |outer, inner| all_replies[outer] = t.thread_variable_get(:replies)[inner] }
-            elsif t.thread_variable?(:redirection_needed)
+                .each_with_index { |outer, inner| all_replies[outer] = t[:replies][inner] }
+            elsif t.key?(:redirection_needed)
               all_replies ||= Array.new(@size)
-              pipeline = @pipelines[t.thread_variable_get(:node_key)]
-              err = t.thread_variable_get(:redirection_needed)
+              pipeline = @pipelines[t[:node_key]]
+              err = t[:redirection_needed]
               err.indices.each { |i| err.replies[i] = handle_redirection(err.replies[i], pipeline, i) }
               pipeline.outer_indices.each_with_index { |outer, inner| all_replies[outer] = err.replies[inner] }
-            elsif t.thread_variable?(:error)
+            elsif t.key?(:error)
               errors ||= {}
-              errors[t.thread_variable_get(:node_key)] = t.thread_variable_get(:error)
+              errors[t[:node_key]] = t[:error]
             end
           end
         end

data/lib/redis_client/cluster/router.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'redis_client'
+require 'redis_client/circuit_breaker'
 require 'redis_client/cluster/command'
 require 'redis_client/cluster/errors'
 require 'redis_client/cluster/key_slot_converter'
@@ -54,13 +55,18 @@ class RedisClient
           node = assign_node(command)
           try_send(node, method, command, args, &block)
         end
+      rescue ::RedisClient::CircuitBreaker::OpenCircuitError
+        raise
       rescue ::RedisClient::Cluster::Node::ReloadNeeded
         update_cluster_info!
         raise ::RedisClient::Cluster::NodeMightBeDown
       rescue ::RedisClient::Cluster::ErrorCollection => e
+        raise if e.errors.any?(::RedisClient::CircuitBreaker::OpenCircuitError)
+
         update_cluster_info! if e.errors.values.any? do |err|
           err.message.start_with?('CLUSTERDOWN Hash slot not served')
         end
+
         raise
       end
 
@@ -68,10 +74,12 @@ class RedisClient
       def try_send(node, method, command, args, retry_count: 3, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         if args.empty?
           # prevent memory allocation for variable-length args
-          node.send(method, command, &block)
+          node.public_send(method, command, &block)
         else
-          node.send(method, *args, command, &block)
+          node.public_send(method, *args, command, &block)
         end
+      rescue ::RedisClient::CircuitBreaker::OpenCircuitError
+        raise
       rescue ::RedisClient::CommandError => e
         raise if retry_count <= 0
 
@@ -101,7 +109,9 @@ class RedisClient
       end
 
       def try_delegate(node, method, *args, retry_count: 3, **kwargs, &block) # rubocop:disable Metrics/AbcSize
-        node.send(method, *args, **kwargs, &block)
+        node.public_send(method, *args, **kwargs, &block)
+      rescue ::RedisClient::CircuitBreaker::OpenCircuitError
+        raise
       rescue ::RedisClient::CommandError => e
         raise if retry_count <= 0
 
@@ -197,9 +207,10 @@ class RedisClient
 
       private
 
-      def send_wait_command(method, command, args, retry_count: 3, &block)
+      def send_wait_command(method, command, args, retry_count: 3, &block) # rubocop:disable Metrics/AbcSize
         @node.call_primaries(method, command, args, &block).select { |r| r.is_a?(Integer) }.sum
       rescue ::RedisClient::Cluster::ErrorCollection => e
+        raise if e.errors.any?(::RedisClient::CircuitBreaker::OpenCircuitError)
         raise if retry_count <= 0
         raise if e.errors.values.none? do |err|
           err.message.include?('WAIT cannot be used with replica instances')
@@ -214,7 +225,7 @@ class RedisClient
         case ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_subcommand(command)
         when 'resetstat', 'rewrite', 'set'
           @node.call_all(method, command, args, &block).first
-        else assign_node(command).send(method, *args, command, &block)
+        else assign_node(command).public_send(method, *args, command, &block)
         end
       end
 
@@ -222,7 +233,7 @@ class RedisClient
         case ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_subcommand(command)
         when 'stats' then @node.call_all(method, command, args, &block)
         when 'purge' then @node.call_all(method, command, args, &block).first
-        else assign_node(command).send(method, *args, command, &block)
+        else assign_node(command).public_send(method, *args, command, &block)
         end
       end
 
@@ -231,7 +242,7 @@ class RedisClient
         when 'list' then @node.call_all(method, command, args, &block).flatten
         when 'pause', 'reply', 'setname'
           @node.call_all(method, command, args, &block).first
-        else assign_node(command).send(method, *args, command, &block)
+        else assign_node(command).public_send(method, *args, command, &block)
         end
       end
 
@@ -244,8 +255,8 @@ class RedisClient
         when 'getkeysinslot'
           raise ArgumentError, command.join(' ') if command.size != 4
 
-          find_node(@node.find_node_key_of_replica(command[2])).send(method, *args, command, &block)
-        else assign_node(command).send(method, *args, command, &block)
+          find_node(@node.find_node_key_of_replica(command[2])).public_send(method, *args, command, &block)
+        else assign_node(command).public_send(method, *args, command, &block)
         end
       end
 
@@ -255,7 +266,9 @@ class RedisClient
           @node.call_all(method, command, args, &block).first
         when 'flush', 'load'
           @node.call_primaries(method, command, args, &block).first
-        else assign_node(command).send(method, *args, command, &block)
+        when 'exists'
+          @node.call_all(method, command, args, &block).transpose.map { |arr| arr.any?(&:zero?) ? 0 : 1 }
+        else assign_node(command).public_send(method, *args, command, &block)
         end
       end
 
@@ -266,7 +279,7 @@ class RedisClient
           @node.call_all(method, command, args, &block).reject(&:empty?).map { |e| Hash[*e] }
                .reduce({}) { |a, e| a.merge(e) { |_, v1, v2| v1 + v2 } }
         when 'numpat' then @node.call_all(method, command, args, &block).select { |e| e.is_a?(Integer) }.sum
-        else assign_node(command).send(method, *args, command, &block)
+        else assign_node(command).public_send(method, *args, command, &block)
         end
       end
 

data/lib/redis_client/cluster_config.rb

@@ -98,7 +98,7 @@ class RedisClient
 
     def build_node_configs(addrs)
       configs = Array[addrs].flatten.filter_map { |addr| parse_node_addr(addr) }
-      raise InvalidClientConfigError, '`nodes` option is empty' if configs.size.zero?
+      raise InvalidClientConfigError, '`nodes` option is empty' if configs.empty?
 
       configs
     end
@@ -150,7 +150,7 @@ class RedisClient
     end
 
     def merge_generic_config(client_config, node_configs)
-      return client_config if node_configs.size.zero?
+      return client_config if node_configs.empty?
 
       cfg = node_configs.first
       MERGE_CONFIG_KEYS.each { |k| client_config[k] = cfg[k] if cfg.key?(k) }

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.3.14
+  version: 0.4.0
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-13 00:00:00.000000000 Z
+date: 2023-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.12'
 description:
 email:
 - proxy0721@gmail.com
@@ -69,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.22
+rubygems_version: 3.3.23
 signing_key:
 specification_version: 4
 summary: A Redis cluster client for Ruby