redis 5.0.6 → 5.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b000349da8b2f7ae8ed14909175306d2c719a9873bf1dabe05c4719ae96d0da
-  data.tar.gz: fdcda2f50f9d33265f7ba24d3f29a2e078fabe5240e1eaf01efae51e0b83eb0b
+  metadata.gz: 68e827844bdac2fa5954e99fd259060a232719927db426788368408b02011eff
+  data.tar.gz: 46f7f0f74538f29ac4b8f72bc0e2cecaeeea44568174c25d61cf3532869c9f3d
 SHA512:
-  metadata.gz: 990972ebefe548f952cbf630708298f52c1856fa5a142a341f2548bd9173f03f0106d6b745c7e39cc5baa9f084d5fea5e4c0bf42cf1d42df94e404f3558d7816
-  data.tar.gz: e52615e0d5b7ca9d554ffc540fdfec524d2aed74ac1c7fc3c727d3096504aa81ff43a85b9e2ce7b21da87edf21ca5f92197171ff1b1c62fa85c7551839e9df83
+  metadata.gz: 996e87442dda9f5750a529b9a14627c371b8e042bc6a7c0a5a32d0c36effa24728d10404a983cea0ef07f19c6e6f1571ac75af1d14a5480021445e23a7eb24e5
+  data.tar.gz: d36cc39b9d847badfe8d63a94ac74ee588a4fa856581e93f113261156be4b6d6e802b207af6fbe526ff7fb3a00b00f27e4f935a2164da18eb329b6eb007dfb4d

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Unreleased
 
+# 5.0.8
+
+- Fix `Redis#without_reconnect` for sentinel clients. Fix #1212.
+- Add `sentinel_username`, `sentinel_password` for sentinel clients. Bump `redis-client` to `>=0.17.0`. See #1213
+
+# 5.0.7
+
+- Fix compatibility with `redis-client 0.15.0` when using Redis Sentinel. Fix #1209.
+
 # 5.0.6
 
 - Wait for an extra `config.read_timeout` in blocking commands rather than an arbitrary 100ms. See #1175.
@@ -27,6 +36,7 @@
 
 # 5.0.0
 
+- Default client timeout decreased from 5 seconds to 1 second.
 - Eagerly and strictly cast Integer and Float parameters.
 - Allow to call `subscribe`, `unsubscribe`, `psubscribe` and `punsubscribe` from a subscribed client. See #1131.
 - Use `MD5` for hashing server nodes in `Redis::Distributed`. This should improve keys distribution among servers. See #1089.
@@ -49,6 +59,10 @@
 - Removed the `synchrony` driver.
 - Removed `Redis.exists_returns_integer`, it's now always enabled.
 
+# 4.8.1
+
+* Automatically reconnect after fork regardless of `reconnect_attempts`
+
 # 4.8.0
 
 * Introduce `sadd?` and `srem?` as boolean returning versions of `sadd` and `srem`.

data/README.md

@@ -1,4 +1,4 @@
-# redis-rb [![Build Status][gh-actions-image]][gh-actions-link] [![Inline docs][inchpages-image]][inchpages-link]
+# redis-rb [![Build Status][gh-actions-image]][gh-actions-link] [![Inline docs][rdoc-master-image]][rdoc-master-link]
 
 A Ruby client that tries to match [Redis][redis-home]' API one-to-one, while still providing an idiomatic interface.
 
@@ -103,7 +103,7 @@ To connect using Sentinel, use:
 SENTINELS = [{ host: "127.0.0.1", port: 26380 },
              { host: "127.0.0.1", port: 26381 }]
 
-redis = Redis.new(url: "redis://mymaster", sentinels: SENTINELS, role: :master)
+redis = Redis.new(name: "mymaster", sentinels: SENTINELS, role: :master)
 ```
 
 * The master name identifies a group of Redis instances composed of a master
@@ -120,13 +120,39 @@ but a few so that if one is down the client will try the next one. The client
 is able to remember the last Sentinel that was able to reply correctly and will
 use it for the next requests.
 
-If you want to [authenticate](https://redis.io/topics/sentinel#configuring-sentinel-instances-with-authentication) Sentinel itself, you must specify the `password` option per instance.
+To [authenticate](https://redis.io/docs/management/sentinel/#configuring-sentinel-instances-with-authentication) Sentinel itself, you can specify the `sentinel_username` and `sentinel_password`. Exclude the `sentinel_username` option if you're using password-only authentication.
 
 ```ruby
-SENTINELS = [{ host: '127.0.0.1', port: 26380, password: 'mysecret' },
-             { host: '127.0.0.1', port: 26381, password: 'mysecret' }]
+SENTINELS = [{ host: '127.0.0.1', port: 26380},
+             { host: '127.0.0.1', port: 26381}]
 
-redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, role: :master)
+redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, sentinel_username: 'appuser', sentinel_password: 'mysecret', role: :master)
+```
+
+If you specify a username and/or password at the top level for your main Redis instance, Sentinel *will not* using thouse credentials
+
+```ruby
+# Use 'mysecret' to authenticate against the mymaster instance, but skip authentication for the sentinels:
+SENTINELS = [{ host: '127.0.0.1', port: 26380 },
+             { host: '127.0.0.1', port: 26381 }]
+
+redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, role: :master, password: 'mysecret')
+```
+
+So you have to provide Sentinel credential and Redis explictly even they are the same
+
+```ruby
+# Use 'mysecret' to authenticate against the mymaster instance and sentinel
+SENTINELS = [{ host: '127.0.0.1', port: 26380 },
+             { host: '127.0.0.1', port: 26381 }]
+
+redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, role: :master, password: 'mysecret', sentinel_password: 'mysecret')
+```
+
+Also the `name`, `password`, `username` and `db` for Redis instance can be passed as an url:
+
+```ruby
+redis = Redis.new(url: "redis://appuser:mysecret@mymaster/10", sentinels: SENTINELS, role: :master)
 ```
 
 ## Cluster support
@@ -394,11 +420,11 @@ client and evangelized Redis in Rubyland. Thank you, Ezra.
 requests.
 
 
-[inchpages-image]:  https://inch-ci.org/github/redis/redis-rb.svg
-[inchpages-link]:   https://inch-ci.org/github/redis/redis-rb
-[redis-commands]:   https://redis.io/commands
-[redis-home]:       https://redis.io
-[redis-url]:        http://www.iana.org/assignments/uri-schemes/prov/redis
-[gh-actions-image]: https://github.com/redis/redis-rb/workflows/Test/badge.svg
-[gh-actions-link]:  https://github.com/redis/redis-rb/actions
-[rubydoc]:          http://www.rubydoc.info/gems/redis
+[rdoc-master-image]: https://img.shields.io/badge/docs-rdoc.info-blue.svg
+[rdoc-master-link]:  https://rubydoc.info/github/redis/redis-rb
+[redis-commands]:    https://redis.io/commands
+[redis-home]:        https://redis.io
+[redis-url]:         https://www.iana.org/assignments/uri-schemes/prov/redis
+[gh-actions-image]:  https://github.com/redis/redis-rb/workflows/Test/badge.svg
+[gh-actions-link]:   https://github.com/redis/redis-rb/actions
+[rubydoc]:           https://rubydoc.info/gems/redis

data/lib/redis/client.rb

@@ -24,7 +24,24 @@ class Redis
       end
 
       def sentinel(**kwargs)
-        super(protocol: 2, **kwargs)
+        super(protocol: 2, **kwargs, client_implementation: ::RedisClient)
+      end
+
+      def translate_error!(error)
+        redis_error = translate_error_class(error.class)
+        raise redis_error, error.message, error.backtrace
+      end
+
+      private
+
+      def translate_error_class(error_class)
+        ERROR_MAPPING.fetch(error_class)
+      rescue IndexError
+        if (client_error = error_class.ancestors.find { |a| ERROR_MAPPING[a] })
+          ERROR_MAPPING[error_class] = ERROR_MAPPING[client_error]
+        else
+          raise
+        end
       end
     end
 
@@ -72,7 +89,7 @@ class Redis
     def call_v(command, &block)
       super(command, &block)
     rescue ::RedisClient::Error => error
-      translate_error!(error)
+      Client.translate_error!(error)
     end
 
     def blocking_call_v(timeout, command, &block)
@@ -85,44 +102,23 @@ class Redis
 
       super(timeout, command, &block)
     rescue ::RedisClient::Error => error
-      translate_error!(error)
+      Client.translate_error!(error)
     end
 
     def pipelined
       super
     rescue ::RedisClient::Error => error
-      translate_error!(error)
+      Client.translate_error!(error)
     end
 
     def multi
       super
     rescue ::RedisClient::Error => error
-      translate_error!(error)
-    end
-
-    def disable_reconnection(&block)
-      ensure_connected(retryable: false, &block)
+      Client.translate_error!(error)
     end
 
     def inherit_socket!
       @inherit_socket = true
     end
-
-    private
-
-    def translate_error!(error)
-      redis_error = translate_error_class(error.class)
-      raise redis_error, error.message, error.backtrace
-    end
-
-    def translate_error_class(error_class)
-      ERROR_MAPPING.fetch(error_class)
-    rescue IndexError
-      if (client_error = error_class.ancestors.find { |a| ERROR_MAPPING[a] })
-        ERROR_MAPPING[error_class] = ERROR_MAPPING[client_error]
-      else
-        raise
-      end
-    end
   end
 end

data/lib/redis/commands/lists.rb

@@ -183,6 +183,60 @@ class Redis
         send_blocking_command(command, timeout)
       end
 
+      # Pops one or more elements from the first non-empty list key from the list
+      # of provided key names. If lists are empty, blocks until timeout has passed.
+      #
+      # @example Popping a element
+      #   redis.blmpop(1.0, 'list')
+      #   #=> ['list', ['a']]
+      # @example With count option
+      #   redis.blmpop(1.0, 'list', count: 2)
+      #   #=> ['list', ['a', 'b']]
+      #
+      # @params timeout [Float] a float value specifying the maximum number of seconds to block) elapses.
+      #   A timeout of zero can be used to block indefinitely.
+      # @params key [String, Array<String>] one or more keys with lists
+      # @params modifier [String]
+      #  - when `"LEFT"` - the elements popped are those from the left of the list
+      #  - when `"RIGHT"` - the elements popped are those from the right of the list
+      # @params count [Integer] a number of elements to pop
+      #
+      # @return [Array<String, Array<String, Float>>] list of popped elements or nil
+      def blmpop(timeout, *keys, modifier: "LEFT", count: nil)
+        raise ArgumentError, "Pick either LEFT or RIGHT" unless modifier == "LEFT" || modifier == "RIGHT"
+
+        args = [:lmpop, keys.size, *keys, modifier]
+        args << "COUNT" << Integer(count) if count
+
+        send_blocking_command(args, timeout)
+      end
+
+      # Pops one or more elements from the first non-empty list key from the list
+      # of provided key names.
+      #
+      # @example Popping a element
+      #   redis.lmpop('list')
+      #   #=> ['list', ['a']]
+      # @example With count option
+      #   redis.lmpop('list', count: 2)
+      #   #=> ['list', ['a', 'b']]
+      #
+      # @params key [String, Array<String>] one or more keys with lists
+      # @params modifier [String]
+      #  - when `"LEFT"` - the elements popped are those from the left of the list
+      #  - when `"RIGHT"` - the elements popped are those from the right of the list
+      # @params count [Integer] a number of elements to pop
+      #
+      # @return [Array<String, Array<String, Float>>] list of popped elements or nil
+      def lmpop(*keys, modifier: "LEFT", count: nil)
+        raise ArgumentError, "Pick either LEFT or RIGHT" unless modifier == "LEFT" || modifier == "RIGHT"
+
+        args = [:lmpop, keys.size, *keys, modifier]
+        args << "COUNT" << Integer(count) if count
+
+        send_command(args)
+      end
+
       # Get an element from a list by its index.
       #
       # @param [String] key

data/lib/redis/commands/pubsub.rb

@@ -49,6 +49,27 @@ class Redis
       def pubsub(subcommand, *args)
         send_command([:pubsub, subcommand] + args)
       end
+
+      # Post a message to a channel in a shard.
+      def spublish(channel, message)
+        send_command([:spublish, channel, message])
+      end
+
+      # Listen for messages published to the given channels in a shard.
+      def ssubscribe(*channels, &block)
+        _subscription(:ssubscribe, 0, channels, block)
+      end
+
+      # Listen for messages published to the given channels in a shard.
+      # Throw a timeout error if there is no messages for a timeout period.
+      def ssubscribe_with_timeout(timeout, *channels, &block)
+        _subscription(:ssubscribe_with_timeout, timeout, channels, block)
+      end
+
+      # Stop listening for messages posted to the given channels in a shard.
+      def sunsubscribe(*channels)
+        _subscription(:sunsubscribe, 0, channels, nil)
+      end
     end
   end
 end

data/lib/redis/commands/sorted_sets.rb

@@ -167,6 +167,72 @@ class Redis
         end
       end
 
+      # Removes and returns up to count members with scores in the sorted set stored at key.
+      #
+      # @example Popping a member
+      #   redis.bzmpop('zset')
+      #   #=> ['zset', ['a', 1.0]]
+      # @example With count option
+      #   redis.bzmpop('zset', count: 2)
+      #   #=> ['zset', [['a', 1.0], ['b', 2.0]]
+      #
+      # @params timeout [Float] a float value specifying the maximum number of seconds to block) elapses.
+      #   A timeout of zero can be used to block indefinitely.
+      # @params key [String, Array<String>] one or more keys with sorted sets
+      # @params modifier [String]
+      #  - when `"MIN"` - the elements popped are those with lowest scores
+      #  - when `"MAX"` - the elements popped are those with the highest scores
+      # @params count [Integer] a number of members to pop
+      #
+      # @return [Array<String, Array<String, Float>>] list of popped elements and scores
+      def bzmpop(timeout, *keys, modifier: "MIN", count: nil)
+        raise ArgumentError, "Pick either MIN or MAX" unless modifier == "MIN" || modifier == "MAX"
+
+        args = [:bzmpop, timeout, keys.size, *keys, modifier]
+        args << "COUNT" << Integer(count) if count
+
+        send_blocking_command(args, timeout) do |response|
+          response&.map do |entry|
+            case entry
+            when String then entry
+            when Array then entry.map { |pair| FloatifyPairs.call(pair) }.flatten(1)
+            end
+          end
+        end
+      end
+
+      # Removes and returns up to count members with scores in the sorted set stored at key.
+      #
+      # @example Popping a member
+      #   redis.zmpop('zset')
+      #   #=> ['zset', ['a', 1.0]]
+      # @example With count option
+      #   redis.zmpop('zset', count: 2)
+      #   #=> ['zset', [['a', 1.0], ['b', 2.0]]
+      #
+      # @params key [String, Array<String>] one or more keys with sorted sets
+      # @params modifier [String]
+      #  - when `"MIN"` - the elements popped are those with lowest scores
+      #  - when `"MAX"` - the elements popped are those with the highest scores
+      # @params count [Integer] a number of members to pop
+      #
+      # @return [Array<String, Array<String, Float>>] list of popped elements and scores
+      def zmpop(*keys, modifier: "MIN", count: nil)
+        raise ArgumentError, "Pick either MIN or MAX" unless modifier == "MIN" || modifier == "MAX"
+
+        args = [:zmpop, keys.size, *keys, modifier]
+        args << "COUNT" << Integer(count) if count
+
+        send_command(args) do |response|
+          response&.map do |entry|
+            case entry
+            when String then entry
+            when Array then entry.map { |pair| FloatifyPairs.call(pair) }.flatten(1)
+            end
+          end
+        end
+      end
+
       # Removes and returns up to count members with the highest scores in the sorted set stored at keys,
       #   or block until one is available.
       #

data/lib/redis/distributed.rb

@@ -542,6 +542,20 @@ class Redis
       node_for(key).ltrim(key, start, stop)
     end
 
+    # Iterate over keys, blocking and removing elements from the first non empty liist found.
+    def blmpop(timeout, *keys, modifier: "LEFT", count: nil)
+      ensure_same_node(:blmpop, keys) do |node|
+        node.blmpop(timeout, *keys, modifier: modifier, count: count)
+      end
+    end
+
+    # Iterate over keys, removing elements from the first non list found.
+    def lmpop(*keys, modifier: "LEFT", count: nil)
+      ensure_same_node(:lmpop, keys) do |node|
+        node.lmpop(*keys, modifier: modifier, count: count)
+      end
+    end
+
     # Get the number of members in a set.
     def scard(key)
       node_for(key).scard(key)
@@ -694,6 +708,20 @@ class Redis
       node_for(key).zmscore(key, *members)
     end
 
+    # Iterate over keys, blocking and removing members from the first non empty sorted set found.
+    def bzmpop(timeout, *keys, modifier: "MIN", count: nil)
+      ensure_same_node(:bzmpop, keys) do |node|
+        node.bzmpop(timeout, *keys, modifier: modifier, count: count)
+      end
+    end
+
+    # Iterate over keys, removing members from the first non empty sorted set found.
+    def zmpop(*keys, modifier: "MIN", count: nil)
+      ensure_same_node(:zmpop, keys) do |node|
+        node.zmpop(*keys, modifier: modifier, count: count)
+      end
+    end
+
     # 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)

data/lib/redis/subscribe.rb

@@ -29,6 +29,14 @@ class Redis
       subscription("psubscribe", "punsubscribe", channels, block, timeout)
     end
 
+    def ssubscribe(*channels, &block)
+      subscription("ssubscribe", "sunsubscribe", channels, block)
+    end
+
+    def ssubscribe_with_timeout(timeout, *channels, &block)
+      subscription("ssubscribe", "sunsubscribe", channels, block, timeout)
+    end
+
     def unsubscribe(*channels)
       call_v([:unsubscribe, *channels])
     end
@@ -37,6 +45,10 @@ class Redis
       call_v([:punsubscribe, *channels])
     end
 
+    def sunsubscribe(*channels)
+      call_v([:sunsubscribe, *channels])
+    end
+
     def close
       @client.close
     end
@@ -46,7 +58,11 @@ class Redis
     def subscription(start, stop, channels, block, timeout = 0)
       sub = Subscription.new(&block)
 
-      call_v([start, *channels])
+      case start
+      when "ssubscribe" then channels.each { |c| call_v([start, c]) } # avoid cross-slot keys
+      else call_v([start, *channels])
+      end
+
       while event = @client.next_event(timeout)
         if event.is_a?(::RedisClient::CommandError)
           raise Client::ERROR_MAPPING.fetch(event.class), event.message
@@ -94,5 +110,17 @@ class Redis
     def pmessage(&block)
       @callbacks["pmessage"] = block
     end
+
+    def ssubscribe(&block)
+      @callbacks["ssubscribe"] = block
+    end
+
+    def sunsubscribe(&block)
+      @callbacks["sunsubscribe"] = block
+    end
+
+    def smessage(&block)
+      @callbacks["smessage"] = block
+    end
   end
 end

data/lib/redis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Redis
-  VERSION = '5.0.6'
+  VERSION = '5.0.8'
 end

data/lib/redis.rb

@@ -45,7 +45,7 @@ class Redis
   # @option options [String] :host ("127.0.0.1") server hostname
   # @option options [Integer] :port (6379) server port
   # @option options [String] :path path to server socket (overrides host and port)
-  # @option options [Float] :timeout (5.0) timeout in seconds
+  # @option options [Float] :timeout (1.0) timeout in seconds
   # @option options [Float] :connect_timeout (same as timeout) timeout for initial connect in seconds
   # @option options [String] :username Username to authenticate against server
   # @option options [String] :password Password to authenticate against server
@@ -137,21 +137,6 @@ class Redis
     end
 
     if options.key?(:sentinels)
-      if url = options.delete(:url)
-        uri = URI.parse(url)
-        if !options.key?(:name) && uri.host
-          options[:name] = uri.host
-        end
-
-        if !options.key?(:password) && uri.password && !uri.password.empty?
-          options[:password] = uri.password
-        end
-
-        if !options.key?(:username) && uri.user && !uri.user.empty?
-          options[:username] = uri.user
-        end
-      end
-
       Client.sentinel(**options).new_client
     else
       Client.config(**options).new_client
@@ -166,6 +151,8 @@ class Redis
     @monitor.synchronize do
       @client.call_v(command, &block)
     end
+  rescue ::RedisClient::Error => error
+    Client.translate_error!(error)
   end
 
   def send_blocking_command(command, timeout, &block)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 5.0.6
+  version: 5.0.8
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -16,7 +16,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-16 00:00:00.000000000 Z
+date: 2023-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -24,14 +24,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.17.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.17.0
 description: |2
       A Ruby client that tries to match Redis' API one-to-one, while still
       providing an idiomatic interface.
@@ -75,9 +75,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/redis/redis-rb/issues
   changelog_uri: https://github.com/redis/redis-rb/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/redis/5.0.6
+  documentation_uri: https://www.rubydoc.info/gems/redis/5.0.8
   homepage_uri: https://github.com/redis/redis-rb
-  source_code_uri: https://github.com/redis/redis-rb/tree/v5.0.6
+  source_code_uri: https://github.com/redis/redis-rb/tree/v5.0.8
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -93,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A Ruby client library for Redis