redis 4.1.0 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb5e8fcd26f9729131009cc0c25bed4cdf1009f5
-  data.tar.gz: 9ed7be2cc83d01dcb6c69002680105dc544e659a
+  metadata.gz: fba6921160b00d34cc11548defceaaee4fc9c181
+  data.tar.gz: e5eac2ace205355e4890084cc96fe98c651e8d30
 SHA512:
-  metadata.gz: b39badbb4689a4ea93cbc65ad00f0c967f24dadcc41e7750ab82977176236d6d8609d8e7b74e13a3829ce008c4a5de90930e265f6b6e03af710811419da6ccf6
-  data.tar.gz: 3ede92146cb181328657a4713e94473f86661dffe0a66d23f48edaa2c7a6c52543a7e7036794baa9dcc2945bc3f9e5eebd9192b70510bda1ad9c0d6e67253830
+  metadata.gz: 5e88bba869f876bc046935479283f108b46107ab00e7ab60487ca524977635dbdc9b0dcfd037a9b057e43765975c26cdc3a0ceea95aefacf608041a18b50f14e
+  data.tar.gz: 91360e891b269c8ecb962414f29d023ace19af98e929d7f7680590dcb8520a87deb6c2a47ba27da0ea16eb47ee90d4c8bdf2be894a40c00820f9c07479188cc2

data/README.md

@@ -95,6 +95,46 @@ 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.
 
+## Cluster support
+
+`redis-rb` supports [clustering](https://redis.io/topics/cluster-spec).
+
+```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.new(cluster: 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.new(cluster: %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.new(cluster: 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.new(cluster: %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 supports `MOVED` and `ASK` redirections transparently.
+
 ## Storing objects
 
 Redis only stores strings as values. If you want to store an object, you

data/lib/redis.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "monitor"
 require_relative "redis/errors"
 
@@ -104,7 +106,12 @@ class Redis
   def commit
     synchronize do |client|
       begin
-        client.call_pipelined(@queue[Thread.current.object_id])
+        pipeline = Pipeline.new(client)
+        @queue[Thread.current.object_id].each do |command|
+          pipeline.call(command)
+        end
+
+        client.call_pipelined(pipeline)
       ensure
         @queue.delete(Thread.current.object_id)
       end
@@ -2403,7 +2410,8 @@ class Redis
   def pipelined
     synchronize do |client|
       begin
-        original, @client = @client, Pipeline.new
+        pipeline = Pipeline.new(@client)
+        original, @client = @client, pipeline
         yield(self)
         original.call_pipeline(@client)
       ensure
@@ -2448,7 +2456,7 @@ class Redis
         client.call([:multi])
       else
         begin
-          pipeline = Pipeline::Multi.new
+          pipeline = Pipeline::Multi.new(@client)
           original, @client = @client, pipeline
           yield(self)
           original.call_pipeline(pipeline)
@@ -2818,7 +2826,7 @@ class Redis
   # @return [Intger] number of elements added to the sorted set
   def geoadd(key, *member)
     synchronize do |client|
-      client.call([:geoadd, key, member])
+      client.call([:geoadd, key, *member])
     end
   end
 
@@ -2977,24 +2985,6 @@ class Redis
     synchronize { |client| client.call(args) }
   end
 
-  # Fetches entries of the stream.
-  #
-  # @example Without options
-  #   redis.xrange('mystream')
-  # @example With first entry id option
-  #   redis.xrange('mystream', first: '0-1')
-  # @example With first and last entry id options
-  #   redis.xrange('mystream', first: '0-1', last: '0-3')
-  # @example With count options
-  #   redis.xrange('mystream', count: 10)
-  #
-  # @param key   [String]  the stream key
-  # @param start  [String]  first entry id of range, default value is `+`
-  # @param end [String]  last entry id of range, default value is `-`
-  # @param count [Integer] the number of entries as limit
-  #
-  # @return [Hash{String => Hash}] the entries
-
   # Fetches entries of the stream in ascending order.
   #
   # @example Without options
@@ -3327,131 +3317,135 @@ private
   # 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|
-      value == 1 if value
-    }
+  Boolify = lambda { |value|
+    case value
+    when 1
+      true
+    when 0
+      false
+    else
+      value
+    end
+  }
 
-  BoolifySet =
-    lambda { |value|
-      if value && "OK" == value
-        true
-      else
-        false
-      end
-    }
+  BoolifySet = lambda { |value|
+    case value
+    when "OK"
+      true
+    when nil
+      false
+    else
+      value
+    end
+  }
 
-  Hashify =
-    lambda { |array|
-      hash = Hash.new
-      array.each_slice(2) do |field, value|
-        hash[field] = value
-      end
-      hash
-    }
+  Hashify = lambda { |value|
+    if value.respond_to?(:each_slice)
+      value.each_slice(2).to_h
+    else
+      value
+    end
+  }
+
+  Floatify = lambda { |value|
+    case value
+    when "inf"
+      Float::INFINITY
+    when "-inf"
+      -Float::INFINITY
+    when String
+      Float(value)
+    else
+      value
+    end
+  }
 
-  Floatify =
-    lambda { |str|
-      if str
-        if (inf = str.match(/^(-)?inf/i))
-          (inf[1] ? -1.0 : 1.0) / 0.0
-        else
-          Float(str)
-        end
-      end
-    }
+  FloatifyPairs = lambda { |value|
+    return value unless value.respond_to?(:each_slice)
 
-  FloatifyPairs =
-    lambda { |result|
-      result.each_slice(2).map do |member, score|
-        [member, Floatify.call(score)]
-      end
-    }
+    value.each_slice(2).map do |member, score|
+      [member, Floatify.call(score)]
+    end
+  }
 
-  HashifyInfo =
-    lambda { |reply|
-      Hash[reply.split("\r\n").map do |line|
-        line.split(':', 2) unless line =~ /^(#|$)/
-      end.compact]
-    }
+  HashifyInfo = lambda { |reply|
+    lines = reply.split("\r\n").grep_v(/^(#|$)/)
+    lines.map! { |line| line.split(':', 2) }
+    lines.compact!
+    lines.to_h
+  }
 
-  HashifyStreams =
-    lambda { |reply|
-      return {} if reply.nil?
-      reply.map do |stream_key, entries|
-        [stream_key, HashifyStreamEntries.call(entries)]
-      end.to_h
-    }
+  HashifyStreams = lambda { |reply|
+    case reply
+    when nil
+      {}
+    else
+      reply.map { |key, entries| [key, HashifyStreamEntries.call(entries)] }.to_h
+    end
+  }
 
-  HashifyStreamEntries =
-    lambda { |reply|
-      reply.map do |entry_id, values|
-        [entry_id, values.each_slice(2).to_h]
-      end
+  HashifyStreamEntries = lambda { |reply|
+    reply.map do |entry_id, values|
+      [entry_id, values.each_slice(2).to_h]
+    end
+  }
+
+  HashifyStreamPendings = lambda { |reply|
+    {
+      'size'         => reply[0],
+      'min_entry_id' => reply[1],
+      'max_entry_id' => reply[2],
+      'consumers'    => reply[3].nil? ? {} : reply[3].to_h
     }
+  }
 
-  HashifyStreamPendings =
-    lambda { |reply|
+  HashifyStreamPendingDetails = lambda { |reply|
+    reply.map do |arr|
       {
-        'size'         => reply[0],
-        'min_entry_id' => reply[1],
-        'max_entry_id' => reply[2],
-        'consumers'    => reply[3].nil? ? {} : Hash[reply[3]]
+        'entry_id' => arr[0],
+        'consumer' => arr[1],
+        'elapsed'  => arr[2],
+        'count'    => arr[3]
       }
-    }
+    end
+  }
 
-  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('-'))
     }
+  }
 
-  HashifyClusterNodeInfo =
-    lambda { |str|
-      arr = str.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] } }
       {
-        '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('-'))
+        'start_slot' => first_slot,
+        'end_slot'   => last_slot,
+        'master'     => master,
+        'replicas'   => replicas
       }
-    }
-
-  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
-    }
+    end
+  }
 
-  HashifyClusterNodes =
-    lambda { |reply|
-      reply.split(/[\r\n]+/).map { |str| HashifyClusterNodeInfo.call(str) }
-    }
+  HashifyClusterNodes = lambda { |reply|
+    reply.split(/[\r\n]+/).map { |str| HashifyClusterNodeInfo.call(str) }
+  }
 
-  HashifyClusterSlaves =
-    lambda { |reply|
-      reply.map { |str| HashifyClusterNodeInfo.call(str) }
-    }
+  HashifyClusterSlaves = lambda { |reply|
+    reply.map { |str| HashifyClusterNodeInfo.call(str) }
+  }
 
   Noop = ->(reply) { reply }
 
@@ -3459,8 +3453,7 @@ private
     args.push sort if sort
     args.push 'count', count if count
     args.push options if options
-
-    args.uniq
+    args
   end
 
   def _subscription(method, timeout, channels, block)
@@ -3488,6 +3481,8 @@ private
     synchronize do |client|
       if blocking_timeout_msec.nil?
         client.call(args, &HashifyStreams)
+      elsif blocking_timeout_msec.to_f.zero?
+        client.call_without_timeout(args, &HashifyStreams)
       else
         timeout = client.timeout.to_f + blocking_timeout_msec.to_f / 1000.0
         client.call_with_timeout(args, timeout, &HashifyStreams)

data/lib/redis/client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "errors"
 require "socket"
 require "cgi"
@@ -155,12 +157,11 @@ class Redis
     end
 
     def call_pipeline(pipeline)
-      commands = pipeline.commands
-      return [] if commands.empty?
+      return [] if pipeline.futures.empty?
 
       with_reconnect pipeline.with_reconnect? do
         begin
-          pipeline.finish(call_pipelined(commands)).tap do
+          pipeline.finish(call_pipelined(pipeline)).tap do
             self.db = pipeline.db if pipeline.db
           end
         rescue ConnectionError => e
@@ -173,8 +174,8 @@ class Redis
       end
     end
 
-    def call_pipelined(commands)
-      return [] if commands.empty?
+    def call_pipelined(pipeline)
+      return [] if pipeline.futures.empty?
 
       # The method #ensure_connected (called from #process) reconnects once on
       # I/O errors. To make an effort in making sure that commands are not
@@ -184,6 +185,8 @@ class Redis
       # already successfully executed commands. To circumvent this, don't retry
       # after the first reply has been read successfully.
 
+      commands = pipeline.commands
+
       result = Array.new(commands.size)
       reconnect = @reconnect
 
@@ -191,8 +194,12 @@ class Redis
         exception = nil
 
         process(commands) do
-          commands.size.times do |i|
-            reply = read
+          pipeline.timeouts.each_with_index do |timeout, i|
+            reply = if timeout
+              with_socket_timeout(timeout) { read }
+            else
+              read
+            end
             result[i] = reply
             @reconnect = false
             exception = reply if exception.nil? && reply.is_a?(CommandError)
@@ -343,12 +350,14 @@ class Redis
       @pending_reads = 0
     rescue TimeoutError,
            SocketError,
+           Errno::EADDRNOTAVAIL,
            Errno::ECONNREFUSED,
            Errno::EHOSTDOWN,
            Errno::EHOSTUNREACH,
            Errno::ENETUNREACH,
            Errno::ENOENT,
-           Errno::ETIMEDOUT
+           Errno::ETIMEDOUT,
+           Errno::EINVAL
 
       raise CannotConnectError, "Error connecting to Redis on #{location} (#{$!.class})"
     end
@@ -407,7 +416,8 @@ class Redis
         options[key] = options[key.to_s] if options.has_key?(key.to_s)
       end
 
-      url = options[:url] || defaults[:url]
+      url = options[:url]
+      url = defaults[:url] if url == nil
 
       # Override defaults from URL if given
       if url
@@ -525,7 +535,6 @@ class Redis
         def initialize(options)
           super(options)
 
-          @options[:password] = DEFAULTS.fetch(:password)
           @options[:db] = DEFAULTS.fetch(:db)
 
           @sentinels = @options.delete(:sentinels).dup
@@ -586,6 +595,11 @@ class Redis
           end
 
           raise CannotConnectError, "No sentinels available."
+        rescue Redis::CommandError => err
+          # this feature is only available starting with Redis 5.0.1
+          raise unless err.message.start_with?('ERR unknown command `auth`')
+          @options[:password] = DEFAULTS.fetch(:password)
+          retry
         end
 
         def resolve_master
@@ -599,9 +613,19 @@ class Redis
         def resolve_slave
           sentinel_detect do |client|
             if reply = client.call(["sentinel", "slaves", @master])
-              slave = Hash[*reply.sample]
-
-              {:host => slave.fetch("ip"), :port => slave.fetch("port")}
+              slaves = reply.map { |s| s.each_slice(2).to_h }
+              slaves.each { |s| s['flags'] = s.fetch('flags').split(',') }
+              slaves.reject! { |s| s.fetch('flags').include?('s_down') }
+
+              if slaves.empty?
+                raise CannotConnectError, 'No slaves available.'
+              else
+                slave = slaves.sample
+                {
+                  host: slave.fetch('ip'),
+                  port: slave.fetch('port'),
+                }
+              end
             end
           end
         end

data/lib/redis/cluster/slot.rb

@@ -57,7 +57,7 @@ class Redis
       end
 
       def assign_node_key(mappings, slot, node_key)
-        mappings[slot] ||= { master: nil, slaves: Set.new }
+        mappings[slot] ||= { master: nil, slaves: ::Set.new }
         if master?(node_key)
           mappings[slot][:master] = node_key
         else

data/lib/redis/pipeline.rb

@@ -1,15 +1,21 @@
 class Redis
   class Pipeline
     attr_accessor :db
+    attr_reader :client
 
     attr :futures
 
-    def initialize
+    def initialize(client)
+      @client = client.is_a?(Pipeline) ? client.client : client
       @with_reconnect = true
       @shutdown = false
       @futures = []
     end
 
+    def timeout
+      client.timeout
+    end
+
     def with_reconnect?
       @with_reconnect
     end
@@ -26,15 +32,19 @@ class Redis
       @futures.empty?
     end
 
-    def call(command, &block)
+    def call(command, timeout: nil, &block)
       # A pipeline that contains a shutdown should not raise ECONNRESET when
       # the connection is gone.
       @shutdown = true if command.first == :shutdown
-      future = Future.new(command, block)
+      future = Future.new(command, block, timeout)
       @futures << future
       future
     end
 
+    def call_with_timeout(command, timeout, &block)
+      call(command, timeout: timeout, &block)
+    end
+
     def call_pipeline(pipeline)
       @shutdown = true if pipeline.shutdown?
       @futures.concat(pipeline.futures)
@@ -43,7 +53,11 @@ class Redis
     end
 
     def commands
-      @futures.map { |f| f._command }
+      @futures.map(&:_command)
+    end
+
+    def timeouts
+      @futures.map(&:timeout)
     end
 
     def with_reconnect(val=true)
@@ -89,6 +103,14 @@ class Redis
         end
       end
 
+      def timeouts
+        if empty?
+          []
+        else
+          [nil, *super, nil]
+        end
+      end
+
       def commands
         if empty?
           []
@@ -108,9 +130,12 @@ class Redis
   class Future < BasicObject
     FutureNotReady = ::Redis::FutureNotReady.new
 
-    def initialize(command, transformation)
+    attr_reader :timeout
+
+    def initialize(command, transformation, timeout)
       @command = command
       @transformation = transformation
+      @timeout = timeout
       @object = FutureNotReady
     end
 

data/lib/redis/version.rb

@@ -1,3 +1,3 @@
 class Redis
-  VERSION = '4.1.0'
+  VERSION = '4.1.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 4.1.1
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -16,7 +16,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-13 00:00:00.000000000 Z
+date: 2019-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit