redis-clustering 5.1.0 → 5.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48b10241c3e0f41500b8ce224013546591a034dfbc6a0fbbcbb9bef136eeca9e
-  data.tar.gz: 7acea63bfa0f3eab6f4c570ddb9a164f6901090964cf5988b54a913e4becc794
+  metadata.gz: 9af906fe28a4173e248c913e907c2adf777e090f1c381a1eaec9f8c58f0c7b1b
+  data.tar.gz: 215aa3069d1af1e8d2279da77f89716743601c7ca1fadee5dc5b065f7c5fd4ea
 SHA512:
-  metadata.gz: b7631f15ef1ce8b13d1af35f98e17f83a27b9dbd80ae8fd95c592010ed0d94dfcb3112bc1aed2e69044d9572e2cc4abe525bb88ae7bc44e72914cb66bb597a10
-  data.tar.gz: ce47057bada6b051033e3ca8f9338c62388b0efa530cabf8aca5210243c21deb336a7de459f7c8ce0aa638a0645eb9d1b5ec82edc6075bc73a5670bd67c2107f
+  metadata.gz: 10afda63eeecbfb356e5c5dfda8cea0268a7d46721e6a5935f8d6fb67bc3f53402b2be4636d44a0c5af924158b145fb93899c84dba9c61edabd59dede84a0fe5
+  data.tar.gz: '0901be8172249c31b9b47fe11cd111fcb4b713684d1b34abf1bd179e25335c0bea5a10ea55aef09eb7781ea33fab40f347610c6d0e72005fa1ae54800b970828'

data/README.md

@@ -75,3 +75,27 @@ Redis::Cluster.new(nodes: %w[rediss://foo-endpoint.example.com:6379], fixed_host
 ```
 
 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.
+
+## Transaction with an optimistic locking
+Since Redis cluster is a distributed system, several behaviors are different from a standalone server.
+Client libraries can make them compatible up to a point, but a part of features needs some restrictions.
+Especially, some cautions are needed to use the transaction feature with an optimistic locking.
+
+```ruby
+# The client is an instance of the internal adapter for the optimistic locking
+redis.watch("{my}key") do |client|
+  if client.get("{my}key") == "some value"
+    # The tx is an instance of the internal adapter for the transaction
+    client.multi do |tx|
+      tx.set("{my}key", "other value")
+      tx.incr("{my}counter")
+    end
+  else
+    client.unwatch
+  end
+end
+```
+
+In a cluster mode client, you need to pass a block if you call the watch method and you need to specify an argument to the block.
+Also, you should use the block argument as a receiver to call commands in the block.
+Although the above restrictions are needed, this implementations is compatible with a standalone client.

data/lib/redis/cluster/client.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'redis-cluster-client'
+require 'redis/cluster/transaction_adapter'
 
 class Redis
   class Cluster
@@ -53,11 +54,11 @@ class Redis
       ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
 
       def id
-        @router.node_keys.join(' ')
+        server_url.join(' ')
       end
 
       def server_url
-        @router.node_keys
+        @router.nil? ? @config.startup_nodes.keys : router.node_keys
       end
 
       def connected?
@@ -90,14 +91,42 @@ 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(watch: nil, &block)
         handle_errors { super(watch: watch, &block) }
       end
 
+      def watch(*keys, &block)
+        unless block_given?
+          raise(
+            Redis::Cluster::TransactionConsistencyError,
+            'A block is required if you use the cluster client.'
+          )
+        end
+
+        unless block.arity == 1
+          raise(
+            Redis::Cluster::TransactionConsistencyError,
+            'Given block needs an argument if you use the cluster client.'
+          )
+        end
+
+        handle_errors do
+          RedisClient::Cluster::OptimisticLocking.new(router).watch(keys) do |c, slot, asking|
+            transaction = Redis::Cluster::TransactionAdapter.new(
+              self, router, @command_builder, node: c, slot: slot, asking: asking
+            )
+
+            result = yield transaction
+            c.call('UNWATCH') unless transaction.lock_released?
+            result
+          end
+        end
+      end
+
       private
 
       def handle_errors

data/lib/redis/cluster/transaction_adapter.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'redis_client/cluster/transaction'
+
+class Redis
+  class Cluster
+    class TransactionAdapter
+      class Internal < RedisClient::Cluster::Transaction
+        def initialize(client, router, command_builder, node: nil, slot: nil, asking: false)
+          @client = client
+          super(router, command_builder, node: node, slot: slot, asking: asking)
+        end
+
+        def multi
+          raise(Redis::Cluster::TransactionConsistencyError, "Can't nest multi transaction")
+        end
+
+        def exec
+          # no need to do anything
+        end
+
+        def discard
+          # no need to do anything
+        end
+
+        def watch(*_)
+          raise(Redis::Cluster::TransactionConsistencyError, "Can't use watch in a transaction")
+        end
+
+        def unwatch
+          # no need to do anything
+        end
+
+        private
+
+        def method_missing(name, *args, **kwargs, &block)
+          return call(name, *args, **kwargs, &block) if @client.respond_to?(name)
+
+          super
+        end
+
+        def respond_to_missing?(name, include_private = false)
+          return true if @client.respond_to?(name)
+
+          super
+        end
+      end
+
+      def initialize(client, router, command_builder, node: nil, slot: nil, asking: false)
+        @client = client
+        @router = router
+        @command_builder = command_builder
+        @node = node
+        @slot = slot
+        @asking = asking
+        @lock_released = false
+      end
+
+      def lock_released?
+        @lock_released
+      end
+
+      def multi
+        @lock_released = true
+        transaction = Redis::Cluster::TransactionAdapter::Internal.new(
+          @client, @router, @command_builder, node: @node, slot: @slot, asking: @asking
+        )
+        yield transaction
+        transaction.execute
+      end
+
+      def exec
+        # no need to do anything
+      end
+
+      def discard
+        # no need to do anything
+      end
+
+      def watch(*_)
+        raise(Redis::Cluster::TransactionConsistencyError, "Can't nest watch command if you use the cluster client")
+      end
+
+      def unwatch
+        @lock_released = true
+        @node.call('UNWATCH')
+      end
+
+      private
+
+      def method_missing(name, *args, **kwargs, &block)
+        return @client.public_send(name, *args, **kwargs, &block) if @client.respond_to?(name)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        return true if @client.respond_to?(name)
+
+        super
+      end
+    end
+  end
+end

data/lib/redis/cluster.rb

@@ -96,6 +96,35 @@ class Redis
       send_command([:cluster, subcommand] + args, &block)
     end
 
+    # Watch the given keys to determine execution of the MULTI/EXEC block.
+    #
+    # Using a block is required for a cluster client. It's different from a standalone client.
+    # And you should use the block argument as a receiver if you call commands.
+    #
+    # An `#unwatch` is automatically issued if an exception is raised within the
+    # block that is a subclass of StandardError and is not a ConnectionError.
+    #
+    # @param keys [String, Array<String>] one or more keys to watch
+    # @return [Object] returns the return value of the block
+    #
+    # @example A typical use case.
+    #   # The client is an instance of the internal adapter for the optimistic locking
+    #   redis.watch("{my}key") do |client|
+    #     if client.get("{my}key") == "some value"
+    #       # The tx is an instance of the internal adapter for the transaction
+    #       client.multi do |tx|
+    #         tx.set("{my}key", "other value")
+    #         tx.incr("{my}counter")
+    #       end
+    #     else
+    #       client.unwatch
+    #     end
+    #   end
+    #   #=> ["OK", 6]
+    def watch(*keys, &block)
+      synchronize { |c| c.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.1.0
+  version: 5.3.0
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -16,7 +16,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-09 00:00:00.000000000 Z
+date: 2024-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -24,28 +24,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.1.0
+        version: 5.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.1.0
+        version: 5.3.0
 - !ruby/object:Gem::Dependency
   name: redis-cluster-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.10.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.10.0
 description: |2
     A Ruby client that tries to match Redis' Cluster API one-to-one, while still
       providing an idiomatic interface.
@@ -61,6 +61,7 @@ files:
 - lib/redis-clustering.rb
 - lib/redis/cluster.rb
 - lib/redis/cluster/client.rb
+- lib/redis/cluster/transaction_adapter.rb
 - lib/redis/cluster/version.rb
 homepage: https://github.com/redis/redis-rb/blob/master/cluster
 licenses:
@@ -68,9 +69,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.1.0
+  documentation_uri: https://www.rubydoc.info/gems/redis/5.3.0
   homepage_uri: https://github.com/redis/redis-rb/blob/master/cluster
-  source_code_uri: https://github.com/redis/redis-rb/tree/v5.1.0/cluster
+  source_code_uri: https://github.com/redis/redis-rb/tree/v5.3.0/cluster
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -86,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: A Ruby client library for Redis Cluster