redis-clustering 5.0.0.beta3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a1f30a75985b5fc7e5ea4f5dfa1b8daaf85e2f0e387c669977c9602035e940cf
+  data.tar.gz: 316047ae9330f0fee89d4870a6bbf56a79158bd8050d5f382956bae971618398
+SHA512:
+  metadata.gz: 9de07f2ae00e29220f13a09aad0f2741c87e4f41597385775ec4f2dcc049fc92b7a1c559b8230d5519c8f91f41d880575017c4e0f4519fb04d5ca3f16c005906
+  data.tar.gz: e02b002e2c7b61c6acba9fc586fbd9b3f47c1cdf6e81f8e4f40d3d366dd740994040e4d9ad642c97c3a1527ae25947d90feb61f49d9fce2424af979171504002

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Ezra Zygmuntowicz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,71 @@
+# Redis::Cluster
+
+## Getting started
+
+Install with:
+
+```
+$ gem install redis-clustering
+```
+
+You can connect to Redis by instantiating the `Redis::Cluster` class:
+
+```ruby
+require "redis-clustering"
+
+redis = Redis::Cluter.new(nodes: (7000..7005).map { |port| "redis://127.0.0.1:#{port}" })
+```
+
+NB: Both `redis_cluster` and `redis-cluster` are unrelated and abandoned gems.
+
+```ruby
+# Nodes can be passed to the client as an array of connection URLs.
+nodes = (7000..7005).map { |port| "redis://127.0.0.1:#{port}" }
+redis = Redis::Cluster.new(nodes: nodes)
+
+# You can also specify the options as a Hash. The options are the same as for a single server connection.
+(7000..7005).map { |port| { host: '127.0.0.1', port: port } }
+```
+
+You can also specify only a subset of the nodes, and the client will discover the missing ones using the [CLUSTER NODES](https://redis.io/commands/cluster-nodes) command.
+
+```ruby
+Redis::Cluster.new(nodes: %w[redis://127.0.0.1:7000])
+```
+
+If you want [the connection to be able to read from any replica](https://redis.io/commands/readonly), you must pass the `replica: true`. Note that this connection won't be usable to write keys.
+
+```ruby
+Redis::Cluster.new(nodes: nodes, replica: true)
+```
+
+The calling code is responsible for [avoiding cross slot commands](https://redis.io/topics/cluster-spec#keys-distribution-model).
+
+```ruby
+redis = Redis::Cluster.new(nodes: %w[redis://127.0.0.1:7000])
+
+redis.mget('key1', 'key2')
+#=> Redis::CommandError (CROSSSLOT Keys in request don't hash to the same slot)
+
+redis.mget('{key}1', '{key}2')
+#=> [nil, nil]
+```
+
+* The client automatically reconnects after a failover occurred, but the caller is responsible for handling errors while it is happening.
+* The client support permanent node failures, and will reroute requests to promoted slaves.
+* The client supports `MOVED` and `ASK` redirections transparently.
+
+## Cluster mode with SSL/TLS
+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])
+```
+
+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')
+```
+
+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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'redis-cluster-client'
+
+class Redis
+  class Cluster
+    class Client < RedisClient::Cluster
+      ERROR_MAPPING = ::Redis::Client::ERROR_MAPPING.merge(
+        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
+
+      class << self
+        def config(**kwargs)
+          super(protocol: 2, **kwargs)
+        end
+
+        def sentinel(**kwargs)
+          super(protocol: 2, **kwargs)
+        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(' ')
+      end
+
+      def server_url
+        @router.node.node_keys
+      end
+
+      def connected?
+        true
+      end
+
+      def disable_reconnection
+        yield # TODO: do we need this, is it doable?
+      end
+
+      def timeout
+        config.read_timeout
+      end
+
+      def db
+        0
+      end
+
+      undef_method :call
+      undef_method :call_once
+      undef_method :call_once_v
+      undef_method :blocking_call
+
+      def call_v(command, &block)
+        handle_errors { super(command, &block) }
+      end
+
+      def blocking_call_v(timeout, command, &block)
+        timeout += self.timeout if timeout && timeout > 0
+        handle_errors { super(timeout, command, &block) }
+      end
+
+      def pipelined(&block)
+        handle_errors { super(&block) }
+      end
+
+      def multi(&block)
+        handle_errors { super(&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
+      end
+    end
+  end
+end

data/lib/redis/cluster/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "redis/version"
+
+class Redis
+  class Cluster
+    VERSION = Redis::VERSION
+  end
+end

data/lib/redis/cluster.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "redis"
+
+class Redis
+  class Cluster < ::Redis
+    # Raised when client connected to redis as cluster mode
+    # and failed to fetch cluster state information by commands.
+    class InitialSetupError < BaseError
+    end
+
+    # Raised when client connected to redis as cluster mode
+    # and some cluster subcommands were called.
+    class OrchestrationCommandNotSupported < BaseError
+      def initialize(command, subcommand = '')
+        str = [command, subcommand].map(&:to_s).reject(&:empty?).join(' ').upcase
+        msg = "#{str} command should be used with care "\
+              'only by applications orchestrating Redis Cluster, like redis-trib, '\
+              'and the command if used out of the right context can leave the cluster '\
+              'in a wrong state or cause data loss.'
+        super(msg)
+      end
+    end
+
+    # Raised when error occurs on any node of cluster.
+    class CommandErrorCollection < BaseError
+      attr_reader :errors
+
+      # @param errors [Hash{String => Redis::CommandError}]
+      # @param error_message [String]
+      def initialize(errors, error_message = 'Command errors were replied on any node')
+        @errors = errors
+        super(error_message)
+      end
+    end
+
+    # Raised when cluster client can't select node.
+    class AmbiguousNodeError < BaseError
+    end
+
+    def connection
+      raise NotImplementedError, "Redis::Cluster doesn't implement #connection"
+    end
+
+    # Create a new client instance
+    #
+    # @param [Hash] options
+    # @option options [Float] :timeout (5.0) timeout in seconds
+    # @option options [Float] :connect_timeout (same as timeout) timeout for initial connect in seconds
+    # @option options [Symbol] :driver Driver to use, currently supported: `:ruby`, `:hiredis`
+    # @option options [Integer, Array<Integer, Float>] :reconnect_attempts Number of attempts trying to connect,
+    #   or a list of sleep duration between attempts.
+    # @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 [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
+    #
+    # @return [Redis::Cluster] a new client instance
+    def initialize(*) # rubocop:disable Lint/UselessMethodDefinition
+      super
+    end
+    ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
+
+    # Sends `CLUSTER *` command to random node and returns its reply.
+    #
+    # @see https://redis.io/commands#cluster Reference of cluster command
+    #
+    # @param subcommand [String, Symbol] the subcommand of cluster command
+    #   e.g. `:slots`, `:nodes`, `:slaves`, `:info`
+    #
+    # @return [Object] depends on the subcommand
+    def cluster(subcommand, *args)
+      subcommand = subcommand.to_s.downcase
+      block = case subcommand
+      when 'slots'
+        HashifyClusterSlots
+      when 'nodes'
+        HashifyClusterNodes
+      when 'slaves'
+        HashifyClusterSlaves
+      when 'info'
+        HashifyInfo
+      else
+        Noop
+      end
+
+      send_command([:cluster, subcommand] + args, &block)
+    end
+
+    private
+
+    def initialize_client(options)
+      cluster_config = RedisClient.cluster(**options, protocol: 2, client_implementation: ::Redis::Cluster::Client)
+      cluster_config.new_client
+    end
+  end
+end
+
+require "redis/cluster/client"

data/lib/redis-clustering.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "redis/cluster"

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: redis-clustering
+version: !ruby/object:Gem::Version
+  version: 5.0.0.beta3
+platform: ruby
+authors:
+- Ezra Zygmuntowicz
+- Taylor Weibley
+- Matthew Clark
+- Brian McKinney
+- Salvatore Sanfilippo
+- Luca Guidi
+- Michel Martens
+- Damian Janowski
+- Pieter Noordhuis
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-08-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis-cluster-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: |2
+    A Ruby client that tries to match Redis' Cluster API one-to-one, while still
+      providing an idiomatic interface.
+email:
+- redis-db@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/redis-clustering.rb
+- lib/redis/cluster.rb
+- lib/redis/cluster/client.rb
+- lib/redis/cluster/version.rb
+homepage: https://github.com/redis/redis-rb/blob/master/cluster
+licenses:
+- MIT
+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.beta3
+  homepage_uri: https://github.com/redis/redis-rb/blob/master/cluster
+  source_code_uri: https://github.com/redis/redis-rb/tree/v5.0.0.beta3/cluster
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: A Ruby client library for Redis Cluster
+test_files: []