redis-clustering 5.0.0 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a56bfd7058c6f9725eec33ece596de34d45895d73bfb88cc948d0cdb998f2a0
-  data.tar.gz: 0d53e2862f76de964e64910c0104bf58e95b8e0621173fb39113534f319ccd37
+  metadata.gz: '0390ca44d9f71661f4cfb1a7f8d1a396a84e204e992cf8a5d0755af4232cb7ac'
+  data.tar.gz: 923cffa3fc0a5a2aaecb4d669ea685e25047c7dc70f932f3e807e6e381fc3ecb
 SHA512:
-  metadata.gz: 75db8468905383ebc5e1df7ac2d018289ed81a140620ea95250102d1cdec988afec684d242656f12495eb6d4f3e99c3ad42589a0910b65deba84dd30a2e80b06
-  data.tar.gz: 9c394084604571ed515d20c2309b348acfe63283db1a8118885c6d85425fc0ba840fbe4072e12a5b16c9aab6e32353d3743ddf2e5beea89cdfd38af3406934c6
+  metadata.gz: b4c5f9903044360cd0317a2ad75d0c41cbd8627c34da86c9cca3471ef78e0256778c15f997f0073386b8dbfa38ca906ab03b31efb3b7c190b7412a0d6bdd1987
+  data.tar.gz: 4e331655c8142429b1fbee72eec3c1fd26b42f5fa4e33156a0f3415151bd7bc3b9da85e604d464b4db33c2425d6a2b910718a6b6108ede5e7bc30635371ea33f

data/README.md

@@ -39,6 +39,12 @@ If you want [the connection to be able to read from any replica](https://redis.i
 Redis::Cluster.new(nodes: nodes, replica: true)
 ```
 
+Also, you can specify the `:replica_affinity` option if you want to prevent accessing cross availability zones.
+
+```ruby
+Redis::Cluster.new(nodes: nodes, replica: true, replica_affinity: :latency)
+```
+
 The calling code is responsible for [avoiding cross slot commands](https://redis.io/topics/cluster-spec#keys-distribution-model).
 
 ```ruby
@@ -59,13 +65,13 @@ redis.mget('{key}1', '{key}2')
 Since Redis can return FQDN of nodes in reply to client since `7.*` with CLUSTER commands, we can use cluster feature with SSL/TLS connection like this:
 
 ```ruby
-Redis.new(cluster: %w[rediss://foo.example.com:6379])
+Redis::Cluster.new(nodes: %w[rediss://foo.example.com:6379])
 ```
 
 On the other hand, in Redis versions prior to `6.*`, you can specify options like the following if cluster mode is enabled and client has to connect to nodes via single endpoint with SSL/TLS.
 
 ```ruby
-Redis.new(cluster: %w[rediss://foo-endpoint.example.com:6379], fixed_hostname: 'foo-endpoint.example.com')
+Redis::Cluster.new(nodes: %w[rediss://foo-endpoint.example.com:6379], fixed_hostname: 'foo-endpoint.example.com')
 ```
 
 In case of the above architecture, if you don't pass the `fixed_hostname` option to the client and servers return IP addresses of nodes, the client may fail to verify certificates.

data/lib/redis/cluster/client.rb

@@ -9,8 +9,10 @@ class Redis
         RedisClient::Cluster::InitialSetupError => Redis::Cluster::InitialSetupError,
         RedisClient::Cluster::OrchestrationCommandNotSupported => Redis::Cluster::OrchestrationCommandNotSupported,
         RedisClient::Cluster::AmbiguousNodeError => Redis::Cluster::AmbiguousNodeError,
-        RedisClient::Cluster::ErrorCollection => Redis::Cluster::CommandErrorCollection
-      ).freeze
+        RedisClient::Cluster::ErrorCollection => Redis::Cluster::CommandErrorCollection,
+        RedisClient::Cluster::Transaction::ConsistencyError => Redis::Cluster::TransactionConsistencyError,
+        RedisClient::Cluster::NodeMightBeDown => Redis::Cluster::NodeMightBeDown,
+      )
 
       class << self
         def config(**kwargs)
@@ -20,21 +22,42 @@ class Redis
         def sentinel(**kwargs)
           super(protocol: 2, **kwargs)
         end
+
+        def translate_error!(error, mapping: ERROR_MAPPING)
+          case error
+          when RedisClient::Cluster::ErrorCollection
+            error.errors.each do |_node, node_error|
+              if node_error.is_a?(RedisClient::AuthenticationError)
+                raise mapping.fetch(node_error.class), node_error.message, node_error.backtrace
+              end
+            end
+
+            remapped_node_errors = error.errors.map do |node_key, node_error|
+              remapped = mapping.fetch(node_error.class, node_error.class).new(node_error.message)
+              remapped.set_backtrace node_error.backtrace
+              [node_key, remapped]
+            end.to_h
+
+            raise(Redis::Cluster::CommandErrorCollection.new(remapped_node_errors, error.message).tap do |remapped|
+              remapped.set_backtrace error.backtrace
+            end)
+          else
+            Redis::Client.translate_error!(error, mapping: mapping)
+          end
+        end
       end
 
       def initialize(*)
         handle_errors { super }
-        @inherit_socket = false
-        @pid = Process.pid
       end
       ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
 
       def id
-        @router.node.node_keys.join(' ')
+        @router.node_keys.join(' ')
       end
 
       def server_url
-        @router.node.node_keys
+        @router.node_keys
       end
 
       def connected?
@@ -67,27 +90,20 @@ class Redis
         handle_errors { super(timeout, command, &block) }
       end
 
-      def pipelined(&block)
-        handle_errors { super(&block) }
+      def pipelined(exception: true, &block)
+        handle_errors { super(exception: exception, &block) }
       end
 
-      def multi(&block)
-        handle_errors { super(&block) }
+      def multi(watch: nil, &block)
+        handle_errors { super(watch: watch, &block) }
       end
 
       private
 
       def handle_errors
         yield
-      rescue RedisClient::Cluster::ErrorCollection => error
-        error.errors.each do |_node, node_error|
-          if node_error.is_a?(RedisClient::AuthenticationError)
-            raise ERROR_MAPPING.fetch(node_error.class), node_error.message, node_error.backtrace
-          end
-        end
-        raise ERROR_MAPPING.fetch(error.class), error.message, error.backtrace
       rescue ::RedisClient::Error => error
-        raise ERROR_MAPPING.fetch(error.class), error.message, error.backtrace
+        Redis::Cluster::Client.translate_error!(error)
       end
     end
   end

data/lib/redis/cluster.rb

@@ -38,6 +38,12 @@ class Redis
     class AmbiguousNodeError < BaseError
     end
 
+    class TransactionConsistencyError < BaseError
+    end
+
+    class NodeMightBeDown < BaseError
+    end
+
     def connection
       raise NotImplementedError, "Redis::Cluster doesn't implement #connection"
     end
@@ -53,6 +59,7 @@ class Redis
     # @option options [Boolean] :inherit_socket (false) Whether to use socket in forked process or not
     # @option options [Array<String, Hash{Symbol => String, Integer}>] :nodes List of cluster nodes to contact
     # @option options [Boolean] :replica Whether to use readonly replica nodes in Redis Cluster or not
+    # @option options [Symbol] :replica_affinity scale reading strategy, currently supported: `:random`, `:latency`
     # @option options [String] :fixed_hostname Specify a FQDN if cluster mode enabled and
     #   client has to connect nodes via single endpoint with SSL/TLS
     # @option options [Class] :connector Class of custom connector
@@ -89,6 +96,10 @@ class Redis
       send_command([:cluster, subcommand] + args, &block)
     end
 
+    def watch(*keys, &block)
+      synchronize { |c| c.call_v([:watch] + keys, &block) }
+    end
+
     private
 
     def initialize_client(options)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-clustering
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -16,7 +16,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-29 00:00:00.000000000 Z
+date: 2024-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -24,28 +24,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 5.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 5.2.0
 - !ruby/object:Gem::Dependency
   name: redis-cluster-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: 0.7.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: 0.7.11
 description: |2
     A Ruby client that tries to match Redis' Cluster API one-to-one, while still
       providing an idiomatic interface.
@@ -68,9 +68,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/redis/redis-rb/issues
   changelog_uri: https://github.com/redis/redis-rb/blob/master/cluster/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/redis/5.0.0
+  documentation_uri: https://www.rubydoc.info/gems/redis/5.2.0
   homepage_uri: https://github.com/redis/redis-rb/blob/master/cluster
-  source_code_uri: https://github.com/redis/redis-rb/tree/v5.0.0/cluster
+  source_code_uri: https://github.com/redis/redis-rb/tree/v5.2.0/cluster
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -86,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: A Ruby client library for Redis Cluster