redis 4.5.0 → 4.7.0

data/lib/redis/commands/transactions.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Transactions
+      # Mark the start of a transaction block.
+      #
+      # Passing a block is optional.
+      #
+      # @example With a block
+      #   redis.multi do |multi|
+      #     multi.set("key", "value")
+      #     multi.incr("counter")
+      #   end # => ["OK", 6]
+      #
+      # @example Without a block
+      #   redis.multi
+      #     # => "OK"
+      #   redis.set("key", "value")
+      #     # => "QUEUED"
+      #   redis.incr("counter")
+      #     # => "QUEUED"
+      #   redis.exec
+      #     # => ["OK", 6]
+      #
+      # @yield [multi] the commands that are called inside this block are cached
+      #   and written to the server upon returning from it
+      # @yieldparam [Redis] multi `self`
+      #
+      # @return [String, Array<...>]
+      #   - when a block is not given, `OK`
+      #   - when a block is given, an array with replies
+      #
+      # @see #watch
+      # @see #unwatch
+      def multi(&block) # :nodoc:
+        if block_given?
+          if block&.arity == 0
+            Pipeline.deprecation_warning("multi", Kernel.caller_locations(1, 5))
+          end
+
+          synchronize do |prior_client|
+            pipeline = Pipeline::Multi.new(prior_client)
+            pipelined_connection = PipelinedConnection.new(pipeline)
+            yield pipelined_connection
+            prior_client.call_pipeline(pipeline)
+          end
+        else
+          send_command([:multi])
+        end
+      end
+
+      # Watch the given keys to determine execution of the MULTI/EXEC block.
+      #
+      # Using a block is optional, but is necessary for thread-safety.
+      #
+      # An `#unwatch` is automatically issued if an exception is raised within the
+      # block that is a subclass of StandardError and is not a ConnectionError.
+      #
+      # @example With a block
+      #   redis.watch("key") do
+      #     if redis.get("key") == "some value"
+      #       redis.multi do |multi|
+      #         multi.set("key", "other value")
+      #         multi.incr("counter")
+      #       end
+      #     else
+      #       redis.unwatch
+      #     end
+      #   end
+      #     # => ["OK", 6]
+      #
+      # @example Without a block
+      #   redis.watch("key")
+      #     # => "OK"
+      #
+      # @param [String, Array<String>] keys one or more keys to watch
+      # @return [Object] if using a block, returns the return value of the block
+      # @return [String] if not using a block, returns `OK`
+      #
+      # @see #unwatch
+      # @see #multi
+      def watch(*keys)
+        synchronize do |client|
+          res = client.call([:watch, *keys])
+
+          if block_given?
+            begin
+              yield(self)
+            rescue ConnectionError
+              raise
+            rescue StandardError
+              unwatch
+              raise
+            end
+          else
+            res
+          end
+        end
+      end
+
+      # Forget about all watched keys.
+      #
+      # @return [String] `OK`
+      #
+      # @see #watch
+      # @see #multi
+      def unwatch
+        send_command([:unwatch])
+      end
+
+      # Execute all commands issued after MULTI.
+      #
+      # Only call this method when `#multi` was called **without** a block.
+      #
+      # @return [nil, Array<...>]
+      #   - when commands were not executed, `nil`
+      #   - when commands were executed, an array with their replies
+      #
+      # @see #multi
+      # @see #discard
+      def exec
+        send_command([:exec])
+      end
+
+      # Discard all commands issued after MULTI.
+      #
+      # Only call this method when `#multi` was called **without** a block.
+      #
+      # @return [String] `"OK"`
+      #
+      # @see #multi
+      # @see #exec
+      def discard
+        send_command([:discard])
+      end
+    end
+  end
+end

data/lib/redis/commands.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "redis/commands/bitmaps"
+require "redis/commands/cluster"
+require "redis/commands/connection"
+require "redis/commands/geo"
+require "redis/commands/hashes"
+require "redis/commands/hyper_log_log"
+require "redis/commands/keys"
+require "redis/commands/lists"
+require "redis/commands/pubsub"
+require "redis/commands/scripting"
+require "redis/commands/server"
+require "redis/commands/sets"
+require "redis/commands/sorted_sets"
+require "redis/commands/streams"
+require "redis/commands/strings"
+require "redis/commands/transactions"
+
+class Redis
+  module Commands
+    include Bitmaps
+    include Cluster
+    include Connection
+    include Geo
+    include Hashes
+    include HyperLogLog
+    include Keys
+    include Lists
+    include Pubsub
+    include Scripting
+    include Server
+    include Sets
+    include SortedSets
+    include Streams
+    include Strings
+    include Transactions
+
+    # Commands returning 1 for true and 0 for false may be executed in a pipeline
+    # where the method call will return nil. Propagate the nil instead of falsely
+    # returning false.
+    Boolify = lambda { |value|
+      case value
+      when 1
+        true
+      when 0
+        false
+      else
+        value
+      end
+    }
+
+    BoolifySet = lambda { |value|
+      case value
+      when "OK"
+        true
+      when nil
+        false
+      else
+        value
+      end
+    }
+
+    Hashify = lambda { |value|
+      if value.respond_to?(:each_slice)
+        value.each_slice(2).to_h
+      else
+        value
+      end
+    }
+
+    Pairify = lambda { |value|
+      if value.respond_to?(:each_slice)
+        value.each_slice(2).to_a
+      else
+        value
+      end
+    }
+
+    Floatify = lambda { |value|
+      case value
+      when "inf"
+        Float::INFINITY
+      when "-inf"
+        -Float::INFINITY
+      when String
+        Float(value)
+      else
+        value
+      end
+    }
+
+    FloatifyPairs = lambda { |value|
+      return value unless value.respond_to?(:each_slice)
+
+      value.each_slice(2).map do |member, score|
+        [member, Floatify.call(score)]
+      end
+    }
+
+    HashifyInfo = lambda { |reply|
+      lines = reply.split("\r\n").grep_v(/^(#|$)/)
+      lines.map! { |line| line.split(':', 2) }
+      lines.compact!
+      lines.to_h
+    }
+
+    HashifyStreams = lambda { |reply|
+      case reply
+      when nil
+        {}
+      else
+        reply.map { |key, entries| [key, HashifyStreamEntries.call(entries)] }.to_h
+      end
+    }
+
+    EMPTY_STREAM_RESPONSE = [nil].freeze
+    private_constant :EMPTY_STREAM_RESPONSE
+
+    HashifyStreamEntries = lambda { |reply|
+      reply.compact.map do |entry_id, values|
+        [entry_id, values&.each_slice(2)&.to_h]
+      end
+    }
+
+    HashifyStreamAutoclaim = lambda { |reply|
+      {
+        'next' => reply[0],
+        'entries' => reply[1].map { |entry| [entry[0], entry[1].each_slice(2).to_h] }
+      }
+    }
+
+    HashifyStreamAutoclaimJustId = lambda { |reply|
+      {
+        'next' => reply[0],
+        'entries' => reply[1]
+      }
+    }
+
+    HashifyStreamPendings = lambda { |reply|
+      {
+        'size' => reply[0],
+        'min_entry_id' => reply[1],
+        'max_entry_id' => reply[2],
+        'consumers' => reply[3].nil? ? {} : reply[3].to_h
+      }
+    }
+
+    HashifyStreamPendingDetails = lambda { |reply|
+      reply.map do |arr|
+        {
+          'entry_id' => arr[0],
+          'consumer' => arr[1],
+          'elapsed' => arr[2],
+          'count' => arr[3]
+        }
+      end
+    }
+
+    HashifyClusterNodeInfo = lambda { |str|
+      arr = str.split(' ')
+      {
+        'node_id' => arr[0],
+        'ip_port' => arr[1],
+        'flags' => arr[2].split(','),
+        'master_node_id' => arr[3],
+        'ping_sent' => arr[4],
+        'pong_recv' => arr[5],
+        'config_epoch' => arr[6],
+        'link_state' => arr[7],
+        'slots' => arr[8].nil? ? nil : Range.new(*arr[8].split('-'))
+      }
+    }
+
+    HashifyClusterSlots = lambda { |reply|
+      reply.map do |arr|
+        first_slot, last_slot = arr[0..1]
+        master = { 'ip' => arr[2][0], 'port' => arr[2][1], 'node_id' => arr[2][2] }
+        replicas = arr[3..-1].map { |r| { 'ip' => r[0], 'port' => r[1], 'node_id' => r[2] } }
+        {
+          'start_slot' => first_slot,
+          'end_slot' => last_slot,
+          'master' => master,
+          'replicas' => replicas
+        }
+      end
+    }
+
+    HashifyClusterNodes = lambda { |reply|
+      reply.split(/[\r\n]+/).map { |str| HashifyClusterNodeInfo.call(str) }
+    }
+
+    HashifyClusterSlaves = lambda { |reply|
+      reply.map { |str| HashifyClusterNodeInfo.call(str) }
+    }
+
+    Noop = ->(reply) { reply }
+
+    # Sends a command to Redis and returns its reply.
+    #
+    # Replies are converted to Ruby objects according to the RESP protocol, so
+    # you can expect a Ruby array, integer or nil when Redis sends one. Higher
+    # level transformations, such as converting an array of pairs into a Ruby
+    # hash, are up to consumers.
+    #
+    # Redis error replies are raised as Ruby exceptions.
+    def call(*command)
+      send_command(command)
+    end
+
+    # Interact with the sentinel command (masters, master, slaves, failover)
+    #
+    # @param [String] subcommand e.g. `masters`, `master`, `slaves`
+    # @param [Array<String>] args depends on subcommand
+    # @return [Array<String>, Hash<String, String>, String] depends on subcommand
+    def sentinel(subcommand, *args)
+      subcommand = subcommand.to_s.downcase
+      send_command([:sentinel, subcommand] + args) do |reply|
+        case subcommand
+        when "get-master-addr-by-name"
+          reply
+        else
+          if reply.is_a?(Array)
+            if reply[0].is_a?(Array)
+              reply.map(&Hashify)
+            else
+              Hashify.call(reply)
+            end
+          else
+            reply
+          end
+        end
+      end
+    end
+
+    private
+
+    def method_missing(*command) # rubocop:disable Style/MissingRespondToMissing
+      send_command(command)
+    end
+  end
+end

data/lib/redis/connection/hiredis.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "registry"
-require_relative "../errors"
+require "redis/connection/registry"
+require "redis/errors"
+
 require "hiredis/connection"
 require "timeout"
 
@@ -14,8 +15,6 @@ class Redis
 
         if config[:scheme] == "unix"
           connection.connect_unix(config[:path], connect_timeout)
-        elsif config[:scheme] == "rediss" || config[:ssl]
-          raise NotImplementedError, "SSL not supported by hiredis driver"
         else
           connection.connect(config[:host], config[:port], connect_timeout)
         end

data/lib/redis/connection/ruby.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "registry"
-require_relative "command_helper"
-require_relative "../errors"
+require "redis/connection/registry"
+require "redis/connection/command_helper"
+require "redis/errors"
+
 require "socket"
 require "timeout"
 
@@ -21,7 +22,7 @@ class Redis
         super(*args)
 
         @timeout = @write_timeout = nil
-        @buffer = "".dup
+        @buffer = "".b
       end
 
       def timeout=(timeout)
@@ -32,30 +33,13 @@ class Redis
         @write_timeout = (timeout if timeout && timeout > 0)
       end
 
-      string_capacity_support = begin
-        String.new(capacity: 0)
-        true # Ruby 2.4+
-      rescue ArgumentError
-        false # Ruby 2.3
-      end
-
-      if string_capacity_support
-        def read(nbytes)
-          result = @buffer.slice!(0, nbytes)
-
-          buffer = String.new(capacity: nbytes, encoding: Encoding::ASCII_8BIT)
-          result << _read_from_socket(nbytes - result.bytesize, buffer) while result.bytesize < nbytes
+      def read(nbytes)
+        result = @buffer.slice!(0, nbytes)
 
-          result
-        end
-      else
-        def read(nbytes)
-          result = @buffer.slice!(0, nbytes)
+        buffer = String.new(capacity: nbytes, encoding: Encoding::ASCII_8BIT)
+        result << _read_from_socket(nbytes - result.bytesize, buffer) while result.bytesize < nbytes
 
-          result << _read_from_socket(nbytes - result.bytesize, "".b) while result.bytesize < nbytes
-
-          result
-        end
+        result
       end
 
       def gets
@@ -150,7 +134,9 @@ class Redis
           # says it is readable (1.6.6, in both 1.8 and 1.9 mode).
           # Use the blocking #readpartial method instead.
 
-          def _read_from_socket(nbytes)
+          def _read_from_socket(nbytes, _buffer = nil)
+            # JRuby: Throw away the buffer as we won't need it
+            # but still need to support the max arity of 2
             readpartial(nbytes)
           rescue EOFError
             raise Errno::ECONNRESET
@@ -257,7 +243,7 @@ class Redis
         end
 
         def self.connect(host, port, timeout, ssl_params)
-          # Note: this is using Redis::Connection::TCPSocket
+          # NOTE: this is using Redis::Connection::TCPSocket
           tcp_sock = TCPSocket.connect(host, port, timeout)
 
           ctx = OpenSSL::SSL::SSLContext.new

data/lib/redis/connection/synchrony.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
-require_relative "command_helper"
-require_relative "registry"
-require_relative "../errors"
+require "redis/connection/registry"
+require "redis/connection/command_helper"
+require "redis/errors"
+
 require "em-synchrony"
 require "hiredis/reader"
 
-Kernel.warn(
-  "The redis synchrony driver is deprecated and will be removed in redis-rb 5.0. " \
+::Redis.deprecate!(
+  "The redis synchrony driver is deprecated and will be removed in redis-rb 5.0.0. " \
   "We're looking for people to maintain it as a separate gem, see https://github.com/redis/redis-rb/issues/915"
 )
 
@@ -129,11 +130,12 @@ class Redis
       def read
         type, payload = @connection.read
 
-        if type == :reply
+        case type
+        when :reply
           payload
-        elsif type == :error
+        when :error
           raise payload
-        elsif type == :timeout
+        when :timeout
           raise TimeoutError
         else
           raise "Unknown type #{type.inspect}"

data/lib/redis/connection.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "connection/registry"
+require "redis/connection/registry"
 
 # If a connection driver was required before this file, the array
 # Redis::Connection.drivers will contain one or more classes. The last driver

data/lib/redis/distributed.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "hash_ring"
+require "redis/hash_ring"
 
 class Redis
   class Distributed
@@ -178,15 +178,11 @@ class Redis
     # Determine if a key exists.
     def exists(*args)
       if !Redis.exists_returns_integer && args.size == 1
-        message = "`Redis#exists(key)` will return an Integer in redis-rb 4.3, if you want to keep the old behavior, " \
+        ::Redis.deprecate!(
+          "`Redis#exists(key)` will return an Integer in redis-rb 4.3, if you want to keep the old behavior, " \
           "use `exists?` instead. To opt-in to the new behavior now you can set Redis.exists_returns_integer = true. " \
           "(#{::Kernel.caller(1, 1).first})\n"
-
-        if defined?(::Warning)
-          ::Warning.warn(message)
-        else
-          warn(message)
-        end
+        )
         exists?(*args)
       else
         keys_per_node = args.group_by { |key| node_for(key) }
@@ -215,6 +211,13 @@ class Redis
       node_for(key).move(key, db)
     end
 
+    # Copy a value from one key to another.
+    def copy(source, destination, **options)
+      ensure_same_node(:copy, [source, destination]) do |node|
+        node.copy(source, destination, **options)
+      end
+    end
+
     # Return a random key from the keyspace.
     def randomkey
       raise CannotDistribute, :randomkey
@@ -666,11 +669,19 @@ class Redis
       node_for(key).zmscore(key, *members)
     end
 
-    # Return a range of members in a sorted set, by index.
+    # Return a range of members in a sorted set, by index, score or lexicographical ordering.
     def zrange(key, start, stop, **options)
       node_for(key).zrange(key, start, stop, **options)
     end
 
+    # Select a range of members in a sorted set, by index, score or lexicographical ordering
+    # and store the resulting sorted set in a new key.
+    def zrangestore(dest_key, src_key, start, stop, **options)
+      ensure_same_node(:zrangestore, [dest_key, src_key]) do |node|
+        node.zrangestore(dest_key, src_key, start, stop, **options)
+      end
+    end
+
     # Return a range of members in a sorted set, by index, with scores ordered
     # from high to low.
     def zrevrange(key, start, stop, **options)
@@ -729,6 +740,13 @@ class Redis
       end
     end
 
+    # Return the union of multiple sorted sets.
+    def zunion(*keys, **options)
+      ensure_same_node(:zunion, keys) do |node|
+        node.zunion(*keys, **options)
+      end
+    end
+
     # Add multiple sorted sets and store the resulting sorted set in a new key.
     def zunionstore(destination, keys, **options)
       ensure_same_node(:zunionstore, [destination] + keys) do |node|
@@ -736,6 +754,21 @@ class Redis
       end
     end
 
+    # Return the difference between the first and all successive input sorted sets.
+    def zdiff(*keys, **options)
+      ensure_same_node(:zdiff, keys) do |node|
+        node.zdiff(*keys, **options)
+      end
+    end
+
+    # Compute the difference between the first and all successive input sorted sets
+    # and store the resulting sorted set in a new key.
+    def zdiffstore(destination, keys, **options)
+      ensure_same_node(:zdiffstore, [destination] + keys) do |node|
+        node.zdiffstore(destination, keys, **options)
+      end
+    end
+
     # Get the number of fields in a hash.
     def hlen(key)
       node_for(key).hlen(key)
@@ -774,6 +807,10 @@ class Redis
       Hash[*fields.zip(hmget(key, *fields)).flatten]
     end
 
+    def hrandfield(key, count = nil, **options)
+      node_for(key).hrandfield(key, count, **options)
+    end
+
     # Delete one or more hash fields.
     def hdel(key, *fields)
       node_for(key).hdel(key, *fields)

data/lib/redis/errors.rb

@@ -45,6 +45,15 @@ class Redis
   end
 
   class Cluster
+    # Raised when client connected to redis as cluster mode
+    # and failed to fetch cluster state information by commands.
+    class InitialSetupError < BaseError
+      # @param errors [Array<Redis::BaseError>]
+      def initialize(errors)
+        super("Redis client could not fetch cluster information: #{errors.map(&:message).uniq.join(',')}")
+      end
+    end
+
     # Raised when client connected to redis as cluster mode
     # and some cluster subcommands were called.
     class OrchestrationCommandNotSupported < BaseError