redis-cluster-client 0.3.15 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0492c31a84cc5a5982973891f9c305d67d6121f03fb12fef76b7045a8960421
-  data.tar.gz: e2531e6b21591974103c794cea27fa7383fb3c7aef27ab08850d7468bc6555c0
+  metadata.gz: 3edb3d83fd54184b6e3069f156944fb1e51459dea9f72f6a149a2fba1fe1cfd8
+  data.tar.gz: 02fbd7531bcfcca5363351b3be60c832c43df320748f8641a39073ef6c08490a
 SHA512:
-  metadata.gz: 472a05c3122f7847df1fa316ac1e20722abb5c34a299daf2dee71cc71a3cf74437100f97c9ed2105a105b517bdf01066a8702296182126a232d5b7cc463caac0
-  data.tar.gz: 9c5bfa33629d5ec005e20c8672748967796a150a190a7aa9de46f11225731b0cec6ce02b6e00b7b94ba1703d5bd103e584d538ccf5219a10c713fbc206f07598
+  metadata.gz: 9a7aece18852c1b31fad6f4d3fdd43d0201496439ce2bd5a1eea96682d916cfa99217983e96067e29dfc41001c0d35690c2c8054e9dbf299520a564d80568470
+  data.tar.gz: 8ba145cc9c9d017c768ae15c44483512d033ac24256bdb46953ec25a9d28d404a6d9a3297cdb31445448ee0d82cda2036328d674db6dc35fab8fe14037ebced1

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'
@@ -13,6 +14,7 @@ class RedisClient
     class Router
       ZERO_CURSOR_FOR_SCAN = '0'
       METHODS_FOR_BLOCKING_CMD = %i[blocking_call_v blocking_call].freeze
+      TSF = ->(b, s) { b.nil? ? s : b.call(s) }.curry
 
       attr_reader :node
 
@@ -29,38 +31,43 @@ class RedisClient
       def send_command(method, command, *args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         cmd = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
         case cmd
-        when 'acl', 'auth', 'bgrewriteaof', 'bgsave', 'quit', 'save'
-          @node.call_all(method, command, args, &block).first
-        when 'flushall', 'flushdb'
-          @node.call_primaries(method, command, args, &block).first
-        when 'ping'     then @node.send_ping(method, command, args, &block).first
+        when 'ping'     then @node.send_ping(method, command, args).first.then(&TSF.call(block))
         when 'wait'     then send_wait_command(method, command, args, &block)
-        when 'keys'     then @node.call_replicas(method, command, args, &block).flatten.sort_by(&:to_s)
-        when 'dbsize'   then @node.call_replicas(method, command, args, &block).select { |e| e.is_a?(Integer) }.sum
+        when 'keys'     then @node.call_replicas(method, command, args).flatten.sort_by(&:to_s).then(&TSF.call(block))
+        when 'dbsize'   then @node.call_replicas(method, command, args).select { |e| e.is_a?(Integer) }.sum.then(&TSF.call(block))
         when 'scan'     then scan(command, seed: 1)
-        when 'lastsave' then @node.call_all(method, command, args, &block).sort_by(&:to_i)
+        when 'lastsave' then @node.call_all(method, command, args).sort_by(&:to_i).then(&TSF.call(block))
         when 'role'     then @node.call_all(method, command, args, &block)
         when 'config'   then send_config_command(method, command, args, &block)
         when 'client'   then send_client_command(method, command, args, &block)
         when 'cluster'  then send_cluster_command(method, command, args, &block)
-        when 'readonly', 'readwrite', 'shutdown'
-          raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, cmd
         when 'memory'   then send_memory_command(method, command, args, &block)
         when 'script'   then send_script_command(method, command, args, &block)
         when 'pubsub'   then send_pubsub_command(method, command, args, &block)
+        when 'acl', 'auth', 'bgrewriteaof', 'bgsave', 'quit', 'save'
+          @node.call_all(method, command, args).first.then(&TSF.call(block))
+        when 'flushall', 'flushdb'
+          @node.call_primaries(method, command, args).first.then(&TSF.call(block))
+        when 'readonly', 'readwrite', 'shutdown'
+          raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, cmd
         when 'discard', 'exec', 'multi', 'unwatch'
           raise ::RedisClient::Cluster::AmbiguousNodeError, cmd
         else
           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 +79,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 +111,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 +208,10 @@ class RedisClient
 
       private
 
-      def send_wait_command(method, command, args, retry_count: 3, &block)
-        @node.call_primaries(method, command, args, &block).select { |r| r.is_a?(Integer) }.sum
+      def send_wait_command(method, command, args, retry_count: 3, &block) # rubocop:disable Metrics/AbcSize
+        @node.call_primaries(method, command, args).select { |r| r.is_a?(Integer) }.sum.then(&TSF.call(block))
       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')
@@ -213,7 +225,7 @@ class RedisClient
       def send_config_command(method, command, args, &block)
         case ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_subcommand(command)
         when 'resetstat', 'rewrite', 'set'
-          @node.call_all(method, command, args, &block).first
+          @node.call_all(method, command, args).first.then(&TSF.call(block))
         else assign_node(command).public_send(method, *args, command, &block)
         end
       end
@@ -221,16 +233,16 @@ class RedisClient
       def send_memory_command(method, command, args, &block)
         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
+        when 'purge' then @node.call_all(method, command, args).first.then(&TSF.call(block))
         else assign_node(command).public_send(method, *args, command, &block)
         end
       end
 
       def send_client_command(method, command, args, &block)
         case ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_subcommand(command)
-        when 'list' then @node.call_all(method, command, args, &block).flatten
+        when 'list' then @node.call_all(method, command, args).flatten.then(&TSF.call(block))
         when 'pause', 'reply', 'setname'
-          @node.call_all(method, command, args, &block).first
+          @node.call_all(method, command, args).first.then(&TSF.call(block))
         else assign_node(command).public_send(method, *args, command, &block)
         end
       end
@@ -240,7 +252,7 @@ class RedisClient
         when 'addslots', 'delslots', 'failover', 'forget', 'meet', 'replicate',
              'reset', 'set-config-epoch', 'setslot'
           raise ::RedisClient::Cluster::OrchestrationCommandNotSupported, ['cluster', subcommand]
-        when 'saveconfig' then @node.call_all(method, command, args, &block).first
+        when 'saveconfig' then @node.call_all(method, command, args).first.then(&TSF.call(block))
         when 'getkeysinslot'
           raise ArgumentError, command.join(' ') if command.size != 4
 
@@ -249,25 +261,25 @@ class RedisClient
         end
       end
 
-      def send_script_command(method, command, args, &block)
+      def send_script_command(method, command, args, &block) # rubocop:disable Metrics/AbcSize
         case ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_subcommand(command)
         when 'debug', 'kill'
-          @node.call_all(method, command, args, &block).first
+          @node.call_all(method, command, args).first.then(&TSF.call(block))
         when 'flush', 'load'
-          @node.call_primaries(method, command, args, &block).first
+          @node.call_primaries(method, command, args).first.then(&TSF.call(block))
         when 'exists'
-          @node.call_all(method, command, args, &block).transpose.map { |arr| arr.any?(&:zero?) ? 0 : 1 }
+          @node.call_all(method, command, args).transpose.map { |arr| arr.any?(&:zero?) ? 0 : 1 }.then(&TSF.call(block))
         else assign_node(command).public_send(method, *args, command, &block)
         end
       end
 
       def send_pubsub_command(method, command, args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         case ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_subcommand(command)
-        when 'channels' then @node.call_all(method, command, args, &block).flatten.uniq.sort_by(&:to_s)
+        when 'channels' then @node.call_all(method, command, args).flatten.uniq.sort_by(&:to_s).then(&TSF.call(block))
         when 'numsub'
-          @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
+          @node.call_all(method, command, args).reject(&:empty?).map { |e| Hash[*e] }
+               .reduce({}) { |a, e| a.merge(e) { |_, v1, v2| v1 + v2 } }.then(&TSF.call(block))
+        when 'numpat' then @node.call_all(method, command, args).select { |e| e.is_a?(Integer) }.sum.then(&TSF.call(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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.3.15
+  version: 0.4.1
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-21 00:00:00.000000000 Z
+date: 2023-01-22 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