redis-cluster-client 0.3.7 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5243f77ab4cb1322ddaaade9b001780e8f24d702d293f56870ce9e1109780222
-  data.tar.gz: fabae20f3a0d9bede270602adb247ca3cbe2b36ad42d68ecdd908320b18a31bb
+  metadata.gz: 18f675a5c604e59eed84fc2b90de0b42ddfbddfe947ccdee442fdf39f379270a
+  data.tar.gz: bf3962c29e9df010c2ef25ea226c5e041bf120ca65ae2392ab0a251a21276b44
 SHA512:
-  metadata.gz: 999a6b334092b0e498d5e8ba773131542d212d8e5b8cb7b117811c465ccb4385b5bea11637cd8e4febdebc3d1e33c218b084e13bd5e5f1686ab477dca0f9411f
-  data.tar.gz: b7edede3965d1878459a128a3e7cc0f5c84b9b3e434ec44c86b408830670058b28ec023ffeeb2f0bcd1503ba5c274c46ecf791f5b03ebbdcccff09c3e3b1cf06
+  metadata.gz: 1a8894042ac085a832548195a519095c73036d0da1ce4f3f543d675f272751fb46af42defe9a83f5dc0aea1681c1abc6b82a98c44d9b855ddbe7005a04b8cfa8
+  data.tar.gz: ef2f92ee572dae262b3eb4e94c198e5618ad013343636fd5442d3da46b0ec48f433fd977a723d624d8a14e93a5315631ad8cb72a16ad3d46ad918186197a0070

data/lib/redis_client/cluster/command.rb

@@ -9,6 +9,14 @@ class RedisClient
     class Command
       EMPTY_STRING = ''
 
+      Detail = Struct.new(
+        'RedisCommand',
+        :first_key_position,
+        :write?,
+        :readonly?,
+        keyword_init: true
+      )
+
       class << self
         def load(nodes)
           errors = []
@@ -17,8 +25,8 @@ class RedisClient
             break unless cmd.nil?
 
             reply = node.call('COMMAND')
-            details = parse_command_details(reply)
-            cmd = ::RedisClient::Cluster::Command.new(details)
+            commands = parse_command_reply(reply)
+            cmd = ::RedisClient::Cluster::Command.new(commands)
           rescue ::RedisClient::Error => e
             errors << e
           end
@@ -30,15 +38,22 @@ class RedisClient
 
         private
 
-        def parse_command_details(rows)
+        def parse_command_reply(rows)
           rows&.reject { |row| row[0].nil? }.to_h do |row|
-            [row[0].downcase, { arity: row[1], flags: row[2], first: row[3], last: row[4], step: row[5] }]
+            [
+              row[0].downcase,
+              ::RedisClient::Cluster::Command::Detail.new(
+                first_key_position: row[3],
+                write?: row[2].include?('write'),
+                readonly?: row[2].include?('readonly')
+              )
+            ]
           end
         end
       end
 
-      def initialize(details)
-        @details = pick_details(details)
+      def initialize(commands)
+        @commands = commands || {}
       end
 
       def extract_first_key(command)
@@ -51,39 +66,23 @@ class RedisClient
       end
 
       def should_send_to_primary?(command)
-        dig_details(command, :write)
+        name = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
+        @commands[name]&.write?
       end
 
       def should_send_to_replica?(command)
-        dig_details(command, :readonly)
+        name = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
+        @commands[name]&.readonly?
       end
 
       def exists?(name)
-        key = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_name(name)
-        @details.key?(key)
+        @commands.key?(::RedisClient::Cluster::NormalizedCmdName.instance.get_by_name(name))
       end
 
       private
 
-      def pick_details(details)
-        (details || {}).transform_values do |detail|
-          {
-            first_key_position: detail[:first],
-            write: detail[:flags].include?('write'),
-            readonly: detail[:flags].include?('readonly')
-          }
-        end
-      end
-
-      def dig_details(command, key)
-        name = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
-        return if name.empty? || !@details.key?(name)
-
-        @details.fetch(name).fetch(key)
-      end
-
       def determine_first_key_position(command) # rubocop:disable Metrics/CyclomaticComplexity
-        case ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
+        case name = ::RedisClient::Cluster::NormalizedCmdName.instance.get_by_command(command)
         when 'eval', 'evalsha', 'zinterstore', 'zunionstore' then 3
         when 'object' then 2
         when 'memory'
@@ -93,7 +92,7 @@ class RedisClient
         when 'xread', 'xreadgroup'
           determine_optional_key_position(command, 'streams')
         else
-          dig_details(command, :first_key_position).to_i
+          @commands[name]&.first_key_position.to_i
         end
       end
 

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

@@ -34,7 +34,7 @@ class RedisClient
 
         def any_replica_node_key(seed: nil)
           random = seed.nil? ? Random : Random.new(seed)
-          @existed_replicas.sample(random: random)&.first
+          @existed_replicas.sample(random: random)&.first || any_primary_node_key(seed: seed)
         end
 
         private

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

@@ -29,7 +29,7 @@ class RedisClient
 
         def any_replica_node_key(seed: nil)
           random = seed.nil? ? Random : Random.new(seed)
-          @replica_node_keys.sample(random: random)
+          @replica_node_keys.sample(random: random) || any_primary_node_key(seed: seed)
         end
       end
     end

data/lib/redis_client/cluster/node.rb

@@ -20,6 +20,40 @@ class RedisClient
       IGNORE_GENERIC_CONFIG_KEYS = %i[url host port path].freeze
 
       ReloadNeeded = Class.new(::RedisClient::Error)
+      Info = Struct.new(
+        'RedisNode',
+        :id, :node_key, :role, :primary_id, :ping_sent,
+        :pong_recv, :config_epoch, :link_state, :slots,
+        keyword_init: true
+      ) do
+        def primary?
+          role == 'master'
+        end
+
+        def replica?
+          role == 'slave'
+        end
+      end
+
+      SLOT_OPTIMIZATION_MAX_SHARD_SIZE = 256
+      SLOT_OPTIMIZATION_STRING = '0' * SLOT_SIZE
+      Slot = Struct.new('RedisSlot', :slots, :primary_node_keys, keyword_init: true) do
+        def [](slot)
+          primary_node_keys[slots.getbyte(slot)]
+        end
+
+        def []=(slot, primary_node_key)
+          index = primary_node_keys.find_index(primary_node_key)
+          if index.nil?
+            raise(::RedisClient::Cluster::Node::ReloadNeeded, primary_node_key) if primary_node_keys.size >= SLOT_OPTIMIZATION_MAX_SHARD_SIZE
+
+            index = primary_node_keys.size
+            primary_node_keys << primary_node_key
+          end
+
+          slots.setbyte(slot, index)
+        end
+      end
 
       class Config < ::RedisClient::Config
         def initialize(scale_read: false, **kwargs)
@@ -48,7 +82,7 @@ class RedisClient
                 Thread.pass
                 Thread.current.thread_variable_set(:index, i)
                 reply = cli.call('CLUSTER', 'NODES')
-                Thread.current.thread_variable_set(:info, parse_node_info(reply))
+                Thread.current.thread_variable_set(:info, parse_cluster_node_reply(reply))
               rescue StandardError => e
                 Thread.current.thread_variable_set(:error, e)
               ensure
@@ -70,10 +104,11 @@ class RedisClient
 
           raise ::RedisClient::Cluster::InitialSetupError, errors if node_info_list.nil?
 
-          grouped = node_info_list.compact.group_by do |rows|
-            rows.sort_by { |row| row[:id] }
-                .map { |r| "#{r[:id]}#{r[:node_key]}#{r[:role]}#{r[:primary_id]}#{r[:config_epoch]}" }
-                .join
+          grouped = node_info_list.compact.group_by do |info_list|
+            info_list
+              .sort_by(&:id)
+              .map { |i| "#{i.id}#{i.node_key}#{i.role}#{i.primary_id}#{i.config_epoch}" }
+              .join
           end
 
           grouped.max_by { |_, v| v.size }[1].first
@@ -83,8 +118,8 @@ class RedisClient
 
         # @see https://redis.io/commands/cluster-nodes/
         # @see https://github.com/redis/redis/blob/78960ad57b8a5e6af743d789ed8fd767e37d42b8/src/cluster.c#L4660-L4683
-        def parse_node_info(info) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-          rows = info.split("\n").map(&:split)
+        def parse_cluster_node_reply(reply) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          rows = reply.split("\n").map(&:split)
           rows.each { |arr| arr[2] = arr[2].split(',') }
           rows.select! { |arr| arr[7] == 'connected' && (arr[2] & %w[fail? fail handshake noaddr noflags]).empty? }
           rows.each do |arr|
@@ -99,23 +134,25 @@ class RedisClient
           end
 
           rows.map do |arr|
-            { id: arr[0], node_key: arr[1], role: arr[2], primary_id: arr[3], ping_sent: arr[4],
-              pong_recv: arr[5], config_epoch: arr[6], link_state: arr[7], slots: arr[8] }
+            ::RedisClient::Cluster::Node::Info.new(
+              id: arr[0], node_key: arr[1], role: arr[2], primary_id: arr[3], ping_sent: arr[4],
+              pong_recv: arr[5], config_epoch: arr[6], link_state: arr[7], slots: arr[8]
+            )
           end
         end
       end
 
-      def initialize( # rubocop:disable Metrics/ParameterLists
+      def initialize(
         options,
-        node_info: [],
+        node_info_list: [],
         with_replica: false,
         replica_affinity: :random,
         pool: nil,
         **kwargs
       )
 
-        @slots = build_slot_node_mappings(node_info)
-        @replications = build_replication_mappings(node_info)
+        @slots = build_slot_node_mappings(node_info_list)
+        @replications = build_replication_mappings(node_info_list)
         @topology = make_topology_class(with_replica, replica_affinity).new(@replications, options, pool, **kwargs)
         @mutex = Mutex.new
       end
@@ -207,23 +244,32 @@ class RedisClient
         end
       end
 
-      def build_slot_node_mappings(node_info)
-        slots = Array.new(SLOT_SIZE)
-        node_info.each do |info|
-          next if info[:slots].nil? || info[:slots].empty?
+      def build_slot_node_mappings(node_info_list)
+        slots = make_array_for_slot_node_mappings(node_info_list)
+        node_info_list.each do |info|
+          next if info.slots.nil? || info.slots.empty?
 
-          info[:slots].each { |start, last| (start..last).each { |i| slots[i] = info[:node_key] } }
+          info.slots.each { |start, last| (start..last).each { |i| slots[i] = info.node_key } }
         end
 
         slots
       end
 
-      def build_replication_mappings(node_info) # rubocop:disable Metrics/AbcSize
-        dict = node_info.to_h { |info| [info[:id], info] }
-        node_info.each_with_object(Hash.new { |h, k| h[k] = [] }) do |info, acc|
-          primary_info = dict[info[:primary_id]]
-          acc[primary_info[:node_key]] << info[:node_key] unless primary_info.nil?
-          acc[info[:node_key]] if info[:role] == 'master' # for the primary which have no replicas
+      def make_array_for_slot_node_mappings(node_info_list)
+        return Array.new(SLOT_SIZE) if node_info_list.count(&:primary?) > SLOT_OPTIMIZATION_MAX_SHARD_SIZE
+
+        ::RedisClient::Cluster::Node::Slot.new(
+          slots: String.new(SLOT_OPTIMIZATION_STRING, encoding: Encoding::BINARY, capacity: SLOT_SIZE),
+          primary_node_keys: node_info_list.select(&:primary?).map(&:node_key)
+        )
+      end
+
+      def build_replication_mappings(node_info_list) # rubocop:disable Metrics/AbcSize
+        dict = node_info_list.to_h { |info| [info.id, info] }
+        node_info_list.each_with_object(Hash.new { |h, k| h[k] = [] }) do |info, acc|
+          primary_info = dict[info.primary_id]
+          acc[primary_info.node_key] << info.node_key unless primary_info.nil?
+          acc[info.node_key] if info.primary? # for the primary which have no replicas
         end
       end
 

data/lib/redis_client/cluster/router.rb

@@ -63,8 +63,7 @@ class RedisClient
         raise
       end
 
-      # @see https://redis.io/topics/cluster-spec#redirection-and-resharding
-      #   Redirection and resharding
+      # @see https://redis.io/docs/reference/cluster-spec/#redirection-and-resharding Redirection and resharding
       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
@@ -271,12 +270,12 @@ class RedisClient
       end
 
       def fetch_cluster_info(config, pool: nil, **kwargs)
-        node_info = ::RedisClient::Cluster::Node.load_info(config.per_node_key, **kwargs)
-        node_addrs = node_info.map { |info| ::RedisClient::Cluster::NodeKey.hashify(info[:node_key]) }
+        node_info_list = ::RedisClient::Cluster::Node.load_info(config.per_node_key, **kwargs)
+        node_addrs = node_info_list.map { |i| ::RedisClient::Cluster::NodeKey.hashify(i.node_key) }
         config.update_node(node_addrs)
         ::RedisClient::Cluster::Node.new(
           config.per_node_key,
-          node_info: node_info,
+          node_info_list: node_info_list,
           pool: pool,
           with_replica: config.use_replica?,
           replica_affinity: config.replica_affinity,

data/lib/redis_client/cluster_config.rb

@@ -22,7 +22,7 @@ class RedisClient
 
     attr_reader :command_builder, :client_config, :replica_affinity
 
-    def initialize( # rubocop:disable Metrics/ParameterLists
+    def initialize(
       nodes: DEFAULT_NODES,
       replica: false,
       replica_affinity: :random,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.3.8
 platform: ruby
 authors:
 - Taishi Kasuga
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-22 00:00:00.000000000 Z
+date: 2022-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client