redis 4.5.1 → 4.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a7232fef186e6d6a11a90d8dd9aa7c71114f017e0afe9378999a96c9e6b4e05
-  data.tar.gz: 689f176b87909bf61eb60e57d1eb795198162a7e039104c80facf36880964bda
+  metadata.gz: 7e99f4e628112a227719d2000dc5b081893273cfbd51ae25bf00a8f6b6594061
+  data.tar.gz: 42a8e0cf75aebbc14cdf680b4bc1f7bbdec9e20b53f150c6443c01126960a959
 SHA512:
-  metadata.gz: 22b11dee92e298b46bb94a707156d3dbf9afb83c8e9e8cbf82cf366d582a7c1b7295d7f09a0fec01965245f4800c2482c0559d646f46ff1c6bba6423ab398ba9
-  data.tar.gz: 9a74ba29c8cb3d7634a44c78e30018a048e19cca66c7fad6a226722183f66546bebb370c92ecdf20522bb35ee72a09b2fda64891ff6d94db1702375bd1ba6b46
+  metadata.gz: 8bc57fe306c601f27d32df4940d5632e9e7d75529f6ac5d42732b21fe04452a4a1ab89567492c6fb7249ef4d69ebb2c0b7c985e18b0ef4f9ee6fb816c31bcbda
+  data.tar.gz: 42b2f8c584d6f96d0fc783d0b36af0fd9415d1dbd43ad8fe7a980688e52fbdb51645a07960d9cb3faacf6696c460cf38a013e290d0b58d4bbbb07626f18f15c7

data/CHANGELOG.md

@@ -1,5 +1,56 @@
 # Unreleased
 
+# 4.6.0
+
+* Deprecate `Redis.current`.
+* Deprecate calling commands on `Redis` inside `Redis#pipelined`. See #1059.
+  ```ruby
+  redis.pipelined do
+    redis.get("key")
+  end
+  ```
+
+  should be replaced by:
+
+  ```ruby
+  redis.pipelined do |pipeline|
+    pipeline.get("key")
+  end
+  ```
+* Deprecate calling commands on `Redis` inside `Redis#multi`. See #1059.
+  ```ruby
+  redis.multi do
+    redis.get("key")
+  end
+  ```
+
+  should be replaced by:
+
+  ```ruby
+  redis.multi do |transaction|
+    transaction.get("key")
+  end
+  ```
+* Deprecate `Redis#queue` and `Redis#commit`. See #1059.
+
+* Fix `zpopmax` and `zpopmin` when called inside a pipeline. See #1055.
+* `Redis#synchronize` is now private like it should always have been.
+
+* Add `Redis.silence_deprecations=` to turn off deprecation warnings.
+  If you don't wish to see warnings yet, you can set `Redis.silence_deprecations = false`.
+  It is however heavily recommended to fix them instead when possible.
+* Add `Redis.raise_deprecations=` to turn deprecation warnings into errors.
+  This makes it easier to identitify the source of deprecated APIs usage.
+  It is recommended to set `Redis.raise_deprecations = true` in development and test environments.
+* Add new options to ZRANGE. See #1053.
+* Add ZRANGESTORE command. See #1053.
+* Add SCAN support for `Redis::Cluster`. See #1049.
+* Add COPY command. See #1053. See #1048.
+* Add ZDIFFSTORE command. See #1046.
+* Add ZDIFF command. See #1044.
+* Add ZUNION command. See #1042.
+* Add HRANDFIELD command. See #1040.
+
 # 4.5.1
 
 * Restore the accidential auth behavior of redis-rb 4.3.0 with a warning. If provided with the `default` user's password, but a wrong username,

data/README.md

@@ -184,9 +184,9 @@ commands to Redis and gathers their replies. These replies are returned
 by the `#pipelined` method.
 
 ```ruby
-redis.pipelined do
-  redis.set "foo", "bar"
-  redis.incr "baz"
+redis.pipelined do |pipeline|
+  pipeline.set "foo", "bar"
+  pipeline.incr "baz"
 end
 # => ["OK", 1]
 ```
@@ -200,9 +200,9 @@ the regular pipeline, the replies to the commands are returned by the
 `#multi` method.
 
 ```ruby
-redis.multi do
-  redis.set "foo", "bar"
-  redis.incr "baz"
+redis.multi do |transaction|
+  transaction.set "foo", "bar"
+  transaction.incr "baz"
 end
 # => ["OK", 1]
 ```
@@ -210,15 +210,15 @@ end
 ### Futures
 
 Replies to commands in a pipeline can be accessed via the *futures* they
-emit (since redis-rb 3.0). All calls inside a pipeline block return a
+emit (since redis-rb 3.0). All calls on the pipeline object return a
 `Future` object, which responds to the `#value` method. When the
 pipeline has successfully executed, all futures are assigned their
 respective replies and can be used.
 
 ```ruby
-redis.pipelined do
-  @set = redis.set "foo", "bar"
-  @incr = redis.incr "baz"
+redis.pipelined do |pipeline|
+  @set = pipeline.set "foo", "bar"
+  @incr = pipeline.incr "baz"
 end
 
 @set.value

data/lib/redis/client.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "errors"
 require "socket"
 require "cgi"
+require "redis/errors"
 
 class Redis
   class Client
@@ -32,7 +32,7 @@ class Redis
       role: nil
     }.freeze
 
-    attr_reader :options
+    attr_reader :options, :connection, :command_map
 
     def scheme
       @options[:scheme]
@@ -87,8 +87,6 @@ class Redis
     end
 
     attr_accessor :logger
-    attr_reader :connection
-    attr_reader :command_map
 
     def initialize(options = {})
       @options = _parse_options(options)
@@ -120,17 +118,18 @@ class Redis
             begin
               call [:auth, username, password]
             rescue CommandError => err # Likely on Redis < 6
-              if err.message.match?(/ERR wrong number of arguments for \'auth\' command/)
+              case err.message
+              when /ERR wrong number of arguments for 'auth' command/
                 call [:auth, password]
-              elsif err.message.match?(/WRONGPASS invalid username-password pair/)
+              when /WRONGPASS invalid username-password pair/
                 begin
                   call [:auth, password]
                 rescue CommandError
                   raise err
                 end
-                ::Kernel.warn(
+                ::Redis.deprecate!(
                   "[redis-rb] The Redis connection was configured with username #{username.inspect}, but" \
-                  " the provided password was for the default user. This will start failing in redis-rb 4.6."
+                  " the provided password was for the default user. This will start failing in redis-rb 5.0.0."
                 )
               else
                 raise
@@ -252,7 +251,8 @@ class Redis
       result
     end
 
-    def call_with_timeout(command, timeout, &blk)
+    def call_with_timeout(command, extra_timeout, &blk)
+      timeout = extra_timeout == 0 ? 0 : self.timeout + extra_timeout
       with_socket_timeout(timeout) do
         call(command, &blk)
       end
@@ -442,7 +442,7 @@ class Redis
       defaults = DEFAULTS.dup
       options = options.dup
 
-      defaults.keys.each do |key|
+      defaults.each_key do |key|
         # Fill in defaults if needed
         defaults[key] = defaults[key].call if defaults[key].respond_to?(:call)
 
@@ -459,9 +459,10 @@ class Redis
 
         uri = URI(url)
 
-        if uri.scheme == "unix"
+        case uri.scheme
+        when "unix"
           defaults[:path] = uri.path
-        elsif uri.scheme == "redis" || uri.scheme == "rediss"
+        when "redis", "rediss"
           defaults[:scheme]   = uri.scheme
           defaults[:host]     = uri.host if uri.host
           defaults[:port]     = uri.port if uri.port
@@ -477,7 +478,7 @@ class Redis
       end
 
       # Use default when option is not specified or nil
-      defaults.keys.each do |key|
+      defaults.each_key do |key|
         options[key] = defaults[key] if options[key].nil?
       end
 

data/lib/redis/cluster/command.rb

@@ -31,13 +31,13 @@ class Redis
       private
 
       def pick_details(details)
-        details.map do |command, detail|
-          [command, {
+        details.transform_values do |detail|
+          {
             first_key_position: detail[:first],
             write: detail[:flags].include?('write'),
             readonly: detail[:flags].include?('readonly')
-          }]
-        end.to_h
+          }
+        end
       end
 
       def dig_details(command, key)
@@ -53,8 +53,6 @@ class Redis
         when 'object' then 2
         when 'memory'
           command[1].to_s.casecmp('usage').zero? ? 2 : 0
-        when 'scan', 'sscan', 'hscan', 'zscan'
-          determine_optional_key_position(command, 'match')
         when 'xread', 'xreadgroup'
           determine_optional_key_position(command, 'streams')
         else

data/lib/redis/cluster/node.rb

@@ -58,6 +58,18 @@ class Redis
         try_map { |_, client| client.process(commands, &block) }.values
       end
 
+      def scale_reading_clients
+        reading_clients = []
+
+        @clients.each do |node_key, client|
+          next unless replica_disabled? ? master?(node_key) : slave?(node_key)
+
+          reading_clients << client
+        end
+
+        reading_clients
+      end
+
       private
 
       def replica_disabled?

data/lib/redis/cluster.rb

@@ -137,6 +137,7 @@ class Redis
       when 'wait'     then @node.call_master(command, &block).reduce(:+)
       when 'keys'     then @node.call_slave(command, &block).flatten.sort
       when 'dbsize'   then @node.call_slave(command, &block).reduce(:+)
+      when 'scan'     then _scan(command, &block)
       when 'lastsave' then @node.call_all(command, &block).sort
       when 'role'     then @node.call_all(command, &block)
       when 'config'   then send_config_command(command, &block)
@@ -238,6 +239,29 @@ class Redis
       raise
     end
 
+    def _scan(command, &block)
+      input_cursor = Integer(command[1])
+
+      client_index = input_cursor % 256
+      raw_cursor = input_cursor >> 8
+
+      clients = @node.scale_reading_clients
+
+      client = clients[client_index]
+      return ['0', []] unless client
+
+      command[1] = raw_cursor.to_s
+
+      result_cursor, result_keys = client.call(command, &block)
+      result_cursor = Integer(result_cursor)
+
+      if result_cursor == 0
+        client_index += 1
+      end
+
+      [((result_cursor << 8) + client_index).to_s, result_keys]
+    end
+
     def assign_redirection_node(err_msg)
       _, slot, node_key = err_msg.split(' ')
       slot = slot.to_i

data/lib/redis/commands/bitmaps.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Bitmaps
+      # Sets or clears the bit at offset in the string value stored at key.
+      #
+      # @param [String] key
+      # @param [Integer] offset bit offset
+      # @param [Integer] value bit value `0` or `1`
+      # @return [Integer] the original bit value stored at `offset`
+      def setbit(key, offset, value)
+        send_command([:setbit, key, offset, value])
+      end
+
+      # Returns the bit value at offset in the string value stored at key.
+      #
+      # @param [String] key
+      # @param [Integer] offset bit offset
+      # @return [Integer] `0` or `1`
+      def getbit(key, offset)
+        send_command([:getbit, key, offset])
+      end
+
+      # Count the number of set bits in a range of the string value stored at key.
+      #
+      # @param [String] key
+      # @param [Integer] start start index
+      # @param [Integer] stop stop index
+      # @return [Integer] the number of bits set to 1
+      def bitcount(key, start = 0, stop = -1)
+        send_command([:bitcount, key, start, stop])
+      end
+
+      # Perform a bitwise operation between strings and store the resulting string in a key.
+      #
+      # @param [String] operation e.g. `and`, `or`, `xor`, `not`
+      # @param [String] destkey destination key
+      # @param [String, Array<String>] keys one or more source keys to perform `operation`
+      # @return [Integer] the length of the string stored in `destkey`
+      def bitop(operation, destkey, *keys)
+        send_command([:bitop, operation, destkey, *keys])
+      end
+
+      # Return the position of the first bit set to 1 or 0 in a string.
+      #
+      # @param [String] key
+      # @param [Integer] bit whether to look for the first 1 or 0 bit
+      # @param [Integer] start start index
+      # @param [Integer] stop stop index
+      # @return [Integer] the position of the first 1/0 bit.
+      #                  -1 if looking for 1 and it is not found or start and stop are given.
+      def bitpos(key, bit, start = nil, stop = nil)
+        raise(ArgumentError, 'stop parameter specified without start parameter') if stop && !start
+
+        command = [:bitpos, key, bit]
+        command << start if start
+        command << stop if stop
+        send_command(command)
+      end
+    end
+  end
+end

data/lib/redis/commands/cluster.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Cluster
+      # 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
+
+        # @see https://github.com/antirez/redis/blob/unstable/src/redis-trib.rb#L127 raw reply expected
+        block = Noop unless @cluster_mode
+
+        send_command([:cluster, subcommand] + args, &block)
+      end
+
+      # Sends `ASKING` command to random node and returns its reply.
+      #
+      # @see https://redis.io/topics/cluster-spec#ask-redirection ASK redirection
+      #
+      # @return [String] `'OK'`
+      def asking
+        send_command(%i[asking])
+      end
+    end
+  end
+end

data/lib/redis/commands/connection.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Connection
+      # Authenticate to the server.
+      #
+      # @param [Array<String>] args includes both username and password
+      #   or only password
+      # @return [String] `OK`
+      # @see https://redis.io/commands/auth AUTH command
+      def auth(*args)
+        send_command([:auth, *args])
+      end
+
+      # Ping the server.
+      #
+      # @param [optional, String] message
+      # @return [String] `PONG`
+      def ping(message = nil)
+        send_command([:ping, message].compact)
+      end
+
+      # Echo the given string.
+      #
+      # @param [String] value
+      # @return [String]
+      def echo(value)
+        send_command([:echo, value])
+      end
+
+      # Change the selected database for the current connection.
+      #
+      # @param [Integer] db zero-based index of the DB to use (0 to 15)
+      # @return [String] `OK`
+      def select(db)
+        synchronize do |client|
+          client.db = db
+          client.call([:select, db])
+        end
+      end
+
+      # Close the connection.
+      #
+      # @return [String] `OK`
+      def quit
+        synchronize do |client|
+          begin
+            client.call([:quit])
+          rescue ConnectionError
+          ensure
+            client.disconnect
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis/commands/geo.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Geo
+      # Adds the specified geospatial items (latitude, longitude, name) to the specified key
+      #
+      # @param [String] key
+      # @param [Array] member arguemnts for member or members: longitude, latitude, name
+      # @return [Integer] number of elements added to the sorted set
+      def geoadd(key, *member)
+        send_command([:geoadd, key, *member])
+      end
+
+      # Returns geohash string representing position for specified members of the specified key.
+      #
+      # @param [String] key
+      # @param [String, Array<String>] member one member or array of members
+      # @return [Array<String, nil>] returns array containg geohash string if member is present, nil otherwise
+      def geohash(key, member)
+        send_command([:geohash, key, member])
+      end
+
+      # Query a sorted set representing a geospatial index to fetch members matching a
+      # given maximum distance from a point
+      #
+      # @param [Array] args key, longitude, latitude, radius, unit(m|km|ft|mi)
+      # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest
+      #   or the farthest to the nearest relative to the center
+      # @param [Integer] count limit the results to the first N matching items
+      # @param ['WITHDIST', 'WITHCOORD', 'WITHHASH'] options to return additional information
+      # @return [Array<String>] may be changed with `options`
+      def georadius(*args, **geoptions)
+        geoarguments = _geoarguments(*args, **geoptions)
+
+        send_command([:georadius, *geoarguments])
+      end
+
+      # Query a sorted set representing a geospatial index to fetch members matching a
+      # given maximum distance from an already existing member
+      #
+      # @param [Array] args key, member, radius, unit(m|km|ft|mi)
+      # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest or the farthest
+      #   to the nearest relative to the center
+      # @param [Integer] count limit the results to the first N matching items
+      # @param ['WITHDIST', 'WITHCOORD', 'WITHHASH'] options to return additional information
+      # @return [Array<String>] may be changed with `options`
+      def georadiusbymember(*args, **geoptions)
+        geoarguments = _geoarguments(*args, **geoptions)
+
+        send_command([:georadiusbymember, *geoarguments])
+      end
+
+      # Returns longitude and latitude of members of a geospatial index
+      #
+      # @param [String] key
+      # @param [String, Array<String>] member one member or array of members
+      # @return [Array<Array<String>, nil>] returns array of elements, where each
+      #   element is either array of longitude and latitude or nil
+      def geopos(key, member)
+        send_command([:geopos, key, member])
+      end
+
+      # Returns the distance between two members of a geospatial index
+      #
+      # @param [String ]key
+      # @param [Array<String>] members
+      # @param ['m', 'km', 'mi', 'ft'] unit
+      # @return [String, nil] returns distance in spefied unit if both members present, nil otherwise.
+      def geodist(key, member1, member2, unit = 'm')
+        send_command([:geodist, key, member1, member2, unit])
+      end
+
+      private
+
+      def _geoarguments(*args, options: nil, sort: nil, count: nil)
+        args.push sort if sort
+        args.push 'count', count if count
+        args.push options if options
+        args
+      end
+    end
+  end
+end