redis-cluster-client 0.3.15 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0492c31a84cc5a5982973891f9c305d67d6121f03fb12fef76b7045a8960421
-  data.tar.gz: e2531e6b21591974103c794cea27fa7383fb3c7aef27ab08850d7468bc6555c0
+  metadata.gz: 780e5f1653b6633dbd4bb1bdc4f4da174d70176a5287bf6156ad5784f0612cf1
+  data.tar.gz: ca1681357111afdc82bdf32a18985963dba85f89fd49961ac62c56075daa0cc8
 SHA512:
-  metadata.gz: 472a05c3122f7847df1fa316ac1e20722abb5c34a299daf2dee71cc71a3cf74437100f97c9ed2105a105b517bdf01066a8702296182126a232d5b7cc463caac0
-  data.tar.gz: 9c5bfa33629d5ec005e20c8672748967796a150a190a7aa9de46f11225731b0cec6ce02b6e00b7b94ba1703d5bd103e584d538ccf5219a10c713fbc206f07598
+  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
@@ -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
 
@@ -72,6 +78,8 @@ class RedisClient
         else
           node.public_send(method, *args, command, &block)
         end
+      rescue ::RedisClient::CircuitBreaker::OpenCircuitError
+        raise
       rescue ::RedisClient::CommandError => e
         raise if retry_count <= 0
 
@@ -102,6 +110,8 @@ class RedisClient
 
       def try_delegate(node, method, *args, retry_count: 3, **kwargs, &block) # rubocop:disable Metrics/AbcSize
         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')

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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.3.15
+  version: 0.4.0
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-21 00:00:00.000000000 Z
+date: 2023-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.11'
+        version: '0.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.11'
+        version: '0.12'
 description:
 email:
 - proxy0721@gmail.com