redis 4.1.0 → 4.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fb5e8fcd26f9729131009cc0c25bed4cdf1009f5
-  data.tar.gz: 9ed7be2cc83d01dcb6c69002680105dc544e659a
+SHA256:
+  metadata.gz: c0b16163b5714933ba20edb9595d7669c7270502586546f3e8758192039113c1
+  data.tar.gz: 150dacb8ae77a51536e3f2bc6813144b0176415d008adaa5d5e6c4d7f25624a1
 SHA512:
-  metadata.gz: b39badbb4689a4ea93cbc65ad00f0c967f24dadcc41e7750ab82977176236d6d8609d8e7b74e13a3829ce008c4a5de90930e265f6b6e03af710811419da6ccf6
-  data.tar.gz: 3ede92146cb181328657a4713e94473f86661dffe0a66d23f48edaa2c7a6c52543a7e7036794baa9dcc2945bc3f9e5eebd9192b70510bda1ad9c0d6e67253830
+  metadata.gz: 90a9fcfdefc41f5feaedfea2bde2be1ad39308dee10f0045ec227577d067d795aaaede4aec200ed6f5777167842540ff5adb6a927fe6a0a0e5ac46ea8eeaf737
+  data.tar.gz: 90c74c87892ef96d0d6ef2bd5934f8e3064d30064a9310fc2b1e31aba066ccb6a005d030458a35d9ad09ed403749e3356df3072927e6a749fc21caedee75f936

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Unreleased
 
+# 4.1.2
+
+* Fix the client hanging forever when connecting with SSL to a non-SSL server. See #835.
+* Fix several authentication problems with sentinel. See #850 and #856.
+* Explicitly drop Ruby 2.2 support.
+
+
+# 4.1.1
+
+* Fix error handling in multi blocks. See #754.
+* Fix geoadd to accept arrays like georadius and georadiusbymember. See #841.
+* Fix georadius command failing when long == lat. See #841.
+* Fix timeout error in xread block: 0. See #837.
+* Fix incompatibility issue with redis-objects. See #834.
+* Properly handle Errno::EADDRNOTAVAIL on connect.
+* Fix password authentication to sentinel instances. See #813.
+
 # 4.1.0
 
 * Add Redis Cluster support. See #716.

data/README.md

@@ -95,6 +95,55 @@ 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.
+
+```ruby
+SENTINELS = [{ host: '127.0.0.1', port: 26380, password: 'mysecret' },
+             { host: '127.0.0.1', port: 26381, password: 'mysecret' }]
+
+redis = Redis.new(host: 'mymaster', sentinels: SENTINELS, role: :master)
+```
+
+## 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)
@@ -2815,10 +2823,10 @@ class Redis
   #
   # @param [String] key
   # @param [Array] member arguemnts for member or members: longitude, latitude, name
-  # @return [Intger] number of elements added to the sorted set
+  # @return [Integer] 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
@@ -568,6 +577,7 @@ class Redis
             client = Client.new(@options.merge({
               :host => sentinel[:host],
               :port => sentinel[:port],
+              password: sentinel[:password],
               :reconnect_attempts => 0,
             }))
 
@@ -599,9 +609,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/connection/ruby.rb

@@ -266,7 +266,28 @@ class Redis
 
           ssl_sock = new(tcp_sock, ctx)
           ssl_sock.hostname = host
-          ssl_sock.connect
+
+          begin
+            # Initiate the socket connection in the background. If it doesn't fail
+            # immediately it will raise an IO::WaitWritable (Errno::EINPROGRESS)
+            # indicating the connection is in progress.
+            # Unlike waiting for a tcp socket to connect, you can't time out ssl socket
+            # connections during the connect phase properly, because IO.select only partially works.
+            # Instead, you have to retry.
+            ssl_sock.connect_nonblock
+          rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
+            if IO.select([ssl_sock], nil, nil, timeout)
+              retry
+            else
+              raise TimeoutError
+            end
+          rescue IO::WaitWritable
+            if IO.select(nil, [ssl_sock], nil, timeout)
+              retry
+            else
+              raise TimeoutError
+            end
+          end
 
           unless ctx.verify_mode == OpenSSL::SSL::VERIFY_NONE
             ssl_sock.post_connection_check(host)

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.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 4.1.2
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -16,22 +16,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-13 00:00:00.000000000 Z
+date: 2019-05-30 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: test-unit
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.1.5
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.1.5
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -122,15 +108,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.2
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A Ruby client library for Redis