redis 4.4.0 → 4.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5ff2ee4b6a6f2b087ac26bf96a3c1769cf42f70ea90008361157f7ef04cdb14
-  data.tar.gz: f2c24654294c4fa81a5cff4ddb545bc59e6f85b64ee61273278cb1e286a4edb8
+  metadata.gz: 7e99f4e628112a227719d2000dc5b081893273cfbd51ae25bf00a8f6b6594061
+  data.tar.gz: 42a8e0cf75aebbc14cdf680b4bc1f7bbdec9e20b53f150c6443c01126960a959
 SHA512:
-  metadata.gz: 0d88c6621659a178dca04d3ca62f25520f5f1a846b6300f93fb008966551fb4795a3e6c37810f99ea18f77a6292b955fa180ae3e06f8c90df7e6a3ca27087ae1
-  data.tar.gz: 1427cc268e867872388f214184d23a5c6062104fcb9d1e50d6026dd9daf6e51b9833866fee9fcf80c7a64e4de705295de8399d8e8ac22fa890bf358bd63ff707
+  metadata.gz: 8bc57fe306c601f27d32df4940d5632e9e7d75529f6ac5d42732b21fe04452a4a1ab89567492c6fb7249ef4d69ebb2c0b7c985e18b0ef4f9ee6fb816c31bcbda
+  data.tar.gz: 42b2f8c584d6f96d0fc783d0b36af0fd9415d1dbd43ad8fe7a980688e52fbdb51645a07960d9cb3faacf6696c460cf38a013e290d0b58d4bbbb07626f18f15c7

data/CHANGELOG.md

@@ -1,5 +1,77 @@
 # 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,
+  redis-rb will first try to connect as the provided user, but then will fallback to connect as the `default` user with the provided password.
+  This behavior is deprecated and will be removed in Redis 4.6.0. Fix #1038.
+
+# 4.5.0
+
+* Handle parts of the command using incompatible encodings. See #1037.
+* Add GET option to SET command. See #1036.
+* Add ZRANDMEMBER command. See #1035.
+* Add LMOVE/BLMOVE commands. See #1034.
+* Add ZMSCORE command. See #1032.
+* Add LT/GT options to ZADD. See #1033.
+* Add SMISMEMBER command. See #1031.
+* Add EXAT/PXAT options to SET. See #1028.
+* Add GETDEL/GETEX commands. See #1024.
+* `Redis#exists` now returns an Integer by default, as warned since 4.2.0. The old behavior can be restored with `Redis.exists_returns_integer = false`.
+* Fix Redis < 6 detection during connect. See #1025.
+* Fix fetching command details in Redis cluster when the first node is unhealthy. See #1026.
+
 # 4.4.0
 
 * Redis cluster: fix cross-slot validation in pipelines. Fix ##1019.

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)
@@ -119,8 +117,23 @@ class Redis
           if username
             begin
               call [:auth, username, password]
-            rescue CommandError # Likely on Redis < 6
-              call [:auth, password]
+            rescue CommandError => err # Likely on Redis < 6
+              case err.message
+              when /ERR wrong number of arguments for 'auth' command/
+                call [:auth, password]
+              when /WRONGPASS invalid username-password pair/
+                begin
+                  call [:auth, password]
+                rescue CommandError
+                  raise err
+                end
+                ::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 5.0.0."
+                )
+              else
+                raise
+              end
             end
           else
             call [:auth, password]
@@ -238,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
@@ -428,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)
 
@@ -445,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
@@ -463,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/command_loader.rb

@@ -10,22 +10,21 @@ class Redis
       module_function
 
       def load(nodes)
-        details = {}
-
         nodes.each do |node|
-          details = fetch_command_details(node)
-          details.empty? ? next : break
+          begin
+            return fetch_command_details(node)
+          rescue CannotConnectError, ConnectionError, CommandError
+            next # can retry on another node
+          end
         end
 
-        details
+        raise CannotConnectError, 'Redis client could not connect to any cluster nodes'
       end
 
       def fetch_command_details(node)
         node.call(%i[command]).map do |reply|
           [reply[0], { arity: reply[1], flags: reply[2], first: reply[3], last: reply[4], step: reply[5] }]
         end.to_h
-      rescue CannotConnectError, ConnectionError, CommandError
-        {} # can retry on another node
       end
 
       private_class_method :fetch_command_details

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