redis 3.3.5 → 4.1.0

data/lib/redis/connection.rb

@@ -1,4 +1,4 @@
-require "redis/connection/registry"
+require_relative "connection/registry"
 
 # If a connection driver was required before this file, the array
 # Redis::Connection.drivers will contain one or more classes. The last driver
@@ -6,4 +6,4 @@ require "redis/connection/registry"
 # the plain Ruby driver as our default. Another driver can be required at a
 # later point in time, causing it to be the last element of the #drivers array
 # and therefore be chosen by default.
-require "redis/connection/ruby" if Redis::Connection.drivers.empty?
+require_relative "connection/ruby" if Redis::Connection.drivers.empty?

data/lib/redis/connection/command_helper.rb

@@ -30,14 +30,8 @@ class Redis
 
     protected
 
-      if defined?(Encoding::default_external)
-        def encode(string)
-          string.force_encoding(Encoding::default_external)
-        end
-      else
-        def encode(string)
-          string
-        end
+      def encode(string)
+        string.force_encoding(Encoding.default_external)
       end
     end
   end

data/lib/redis/connection/hiredis.rb

@@ -1,5 +1,5 @@
-require "redis/connection/registry"
-require "redis/errors"
+require_relative "registry"
+require_relative "../errors"
 require "hiredis/connection"
 require "timeout"
 

data/lib/redis/connection/ruby.rb

@@ -1,6 +1,6 @@
-require "redis/connection/registry"
-require "redis/connection/command_helper"
-require "redis/errors"
+require_relative "registry"
+require_relative "command_helper"
+require_relative "../errors"
 require "socket"
 require "timeout"
 
@@ -10,36 +10,17 @@ rescue LoadError
   # Not all systems have OpenSSL support
 end
 
-if RUBY_VERSION < "1.9.3"
-  class String
-    # Ruby 1.8.7 does not have byteslice, but it handles encodings differently anyway.
-    # We can simply slice the string, which is a byte array there.
-    def byteslice(*args)
-      slice(*args)
-    end
-  end
-end
-
 class Redis
   module Connection
     module SocketMixin
 
       CRLF = "\r\n".freeze
 
-      # Exceptions raised during non-blocking I/O ops that require retrying the op
-      if RUBY_VERSION >= "1.9.3"
-        NBIO_READ_EXCEPTIONS = [IO::WaitReadable]
-        NBIO_WRITE_EXCEPTIONS = [IO::WaitWritable]
-      else
-        NBIO_READ_EXCEPTIONS = [Errno::EWOULDBLOCK, Errno::EAGAIN]
-        NBIO_WRITE_EXCEPTIONS = [Errno::EWOULDBLOCK, Errno::EAGAIN]
-      end
-
       def initialize(*args)
         super(*args)
 
         @timeout = @write_timeout = nil
-        @buffer = ""
+        @buffer = "".dup
       end
 
       def timeout=(timeout)
@@ -83,13 +64,13 @@ class Redis
         begin
           read_nonblock(nbytes)
 
-        rescue *NBIO_READ_EXCEPTIONS
+        rescue IO::WaitReadable
           if IO.select([self], nil, nil, @timeout)
             retry
           else
             raise Redis::TimeoutError
           end
-        rescue *NBIO_WRITE_EXCEPTIONS
+        rescue IO::WaitWritable
           if IO.select(nil, [self], nil, @timeout)
             retry
           else
@@ -105,13 +86,13 @@ class Redis
         begin
           write_nonblock(data)
 
-        rescue *NBIO_WRITE_EXCEPTIONS
+        rescue IO::WaitWritable
           if IO.select(nil, [self], nil, @write_timeout)
             retry
           else
             raise Redis::TimeoutError
           end
-        rescue *NBIO_READ_EXCEPTIONS
+        rescue IO::WaitReadable
           if IO.select([self], nil, nil, @write_timeout)
             retry
           else
@@ -286,7 +267,10 @@ class Redis
           ssl_sock = new(tcp_sock, ctx)
           ssl_sock.hostname = host
           ssl_sock.connect
-          ssl_sock.post_connection_check(host)
+
+          unless ctx.verify_mode == OpenSSL::SSL::VERIFY_NONE
+            ssl_sock.post_connection_check(host)
+          end
 
           ssl_sock
         end
@@ -307,14 +291,13 @@ class Redis
           raise ArgumentError, "SSL incompatible with unix sockets" if config[:ssl]
           sock = UNIXSocket.connect(config[:path], config[:connect_timeout])
         elsif config[:scheme] == "rediss" || config[:ssl]
-          raise ArgumentError, "This library does not support SSL on Ruby < 1.9" if RUBY_VERSION < "1.9.3"
           sock = SSLSocket.connect(config[:host], config[:port], config[:connect_timeout], config[:ssl_params])
         else
           sock = TCPSocket.connect(config[:host], config[:port], config[:connect_timeout])
         end
 
         instance = new(sock)
-        instance.timeout = config[:timeout]
+        instance.timeout = config[:read_timeout]
         instance.write_timeout = config[:write_timeout]
         instance.set_tcp_keepalive config[:tcp_keepalive]
         instance

data/lib/redis/connection/synchrony.rb

@@ -1,6 +1,6 @@
-require "redis/connection/command_helper"
-require "redis/connection/registry"
-require "redis/errors"
+require_relative "command_helper"
+require_relative "registry"
+require_relative "../errors"
 require "em-synchrony"
 require "hiredis/reader"
 
@@ -72,7 +72,15 @@ class Redis
 
       def self.connect(config)
         if config[:scheme] == "unix"
-          conn = EventMachine.connect_unix_domain(config[:path], RedisClient)
+          begin
+            conn = EventMachine.connect_unix_domain(config[:path], RedisClient)
+          rescue RuntimeError => e
+            if e.message == "no connection"
+              raise Errno::ECONNREFUSED
+            else
+              raise e
+            end
+          end
         elsif config[:scheme] == "rediss" || config[:ssl]
           raise NotImplementedError, "SSL not supported by synchrony driver"
         else

data/lib/redis/distributed.rb

@@ -1,4 +1,4 @@
-require "redis/hash_ring"
+require_relative "hash_ring"
 
 class Redis
   class Distributed
@@ -144,8 +144,8 @@ class Redis
     end
 
     # Create a key using the serialized value, previously obtained using DUMP.
-    def restore(key, ttl, serialized_value)
-      node_for(key).restore(key, ttl, serialized_value)
+    def restore(key, ttl, serialized_value, options = {})
+      node_for(key).restore(key, ttl, serialized_value, options)
     end
 
     # Transfer a key from the connected instance to another instance.
@@ -161,6 +161,14 @@ class Redis
       end
     end
 
+    # Unlink keys.
+    def unlink(*args)
+      keys_per_node = args.group_by { |key| node_for(key) }
+      keys_per_node.inject(0) do |sum, (node, keys)|
+        sum + node.unlink(*keys)
+      end
+    end
+
     # Determine if a key exists.
     def exists(key)
       node_for(key).exists(key)
@@ -277,13 +285,16 @@ class Redis
       node_for(key).get(key)
     end
 
-    # Get the values of all the given keys.
+    # Get the values of all the given keys as an Array.
     def mget(*keys)
-      raise CannotDistribute, :mget
+      mapped_mget(*keys).values_at(*keys)
     end
 
+    # Get the values of all the given keys as a Hash.
     def mapped_mget(*keys)
-      raise CannotDistribute, :mapped_mget
+      keys.group_by { |k| node_for k }.inject({}) do |results, (node, subkeys)|
+        results.merge! node.mapped_mget(*subkeys)
+      end
     end
 
     # Overwrite part of a string at key starting at the specified offset.
@@ -392,12 +403,11 @@ class Redis
     def _bpop(cmd, args)
       options = {}
 
-      case args.last
-      when Hash
+      if args.last.is_a?(Hash)
         options = args.pop
-      when Integer
+      elsif args.last.respond_to?(:to_int)
         # Issue deprecation notice in obnoxious mode...
-        options[:timeout] = args.pop
+        options[:timeout] = args.pop.to_int
       end
 
       if args.size > 1
@@ -509,6 +519,16 @@ class Redis
       node_for(key).smembers(key)
     end
 
+    # Scan a set
+    def sscan(key, cursor, options={})
+      node_for(key).sscan(key, cursor, options)
+    end
+
+    # Scan a set and return an enumerator
+    def sscan_each(key, options={}, &block)
+      node_for(key).sscan_each(key, options, &block)
+    end
+
     # Subtract multiple sets.
     def sdiff(*keys)
       ensure_same_node(:sdiff, keys) do |node|
@@ -679,8 +699,8 @@ class Redis
     end
 
     # Delete one or more hash fields.
-    def hdel(key, field)
-      node_for(key).hdel(key, field)
+    def hdel(key, *fields)
+      node_for(key).hdel(key, *fields)
     end
 
     # Determine if a hash field exists.

data/lib/redis/errors.rb

@@ -37,4 +37,50 @@ class Redis
   # Raised when the connection was inherited by a child process.
   class InheritedError < BaseConnectionError
   end
+
+  # Raised when client options are invalid.
+  class InvalidClientOptionError < BaseError
+  end
+
+  class Cluster
+    # Raised when client connected to redis as cluster mode
+    # and some cluster subcommands were called.
+    class OrchestrationCommandNotSupported < BaseError
+      def initialize(command, subcommand = '')
+        str = [command, subcommand].map(&:to_s).reject(&:empty?).join(' ').upcase
+        msg = "#{str} command should be used with care "\
+              'only by applications orchestrating Redis Cluster, like redis-trib, '\
+              'and the command if used out of the right context can leave the cluster '\
+              'in a wrong state or cause data loss.'
+        super(msg)
+      end
+    end
+
+    # Raised when error occurs on any node of cluster.
+    class CommandErrorCollection < BaseError
+      attr_reader :errors
+
+      # @param errors [Hash{String => Redis::CommandError}]
+      # @param error_message [String]
+      def initialize(errors, error_message = 'Command errors were replied on any node')
+        @errors = errors
+        super(error_message)
+      end
+    end
+
+    # Raised when cluster client can't select node.
+    class AmbiguousNodeError < BaseError
+      def initialize(command)
+        super("Cluster client doesn't know which node the #{command} command should be sent to.")
+      end
+    end
+
+    # Raised when commands in pipelining include cross slot keys.
+    class CrossSlotPipeliningError < BaseError
+      def initialize(keys)
+        super("Cluster client couldn't send pipelining to single node. "\
+              "The commands include cross slot keys. #{keys}")
+      end
+    end
+  end
 end

data/lib/redis/hash_ring.rb

@@ -25,7 +25,6 @@ class Redis
       @nodes << node
       @replicas.times do |i|
         key = Zlib.crc32("#{node.id}:#{i}")
-        raise "Node ID collision" if @ring.has_key?(key)
         @ring[key] = node
         @sorted_keys << key
       end
@@ -61,72 +60,29 @@ class Redis
       end
     end
 
-    class << self
-
-      # gem install RubyInline to use this code
-      # Native extension to perform the binary search within the hashring.
-      # There's a pure ruby version below so this is purely optional
-      # for performance.  In testing 20k gets and sets, the native
-      # binary search shaved about 12% off the runtime (9sec -> 8sec).
-      begin
-        require 'inline'
-        inline do |builder|
-          builder.c <<-EOM
-          int binary_search(VALUE ary, unsigned int r) {
-              int upper = RARRAY_LEN(ary) - 1;
-              int lower = 0;
-              int idx = 0;
-
-              while (lower <= upper) {
-                  idx = (lower + upper) / 2;
-
-                  VALUE continuumValue = RARRAY_PTR(ary)[idx];
-                  unsigned int l = NUM2UINT(continuumValue);
-                  if (l == r) {
-                      return idx;
-                  }
-                  else if (l > r) {
-                      upper = idx - 1;
-                  }
-                  else {
-                      lower = idx + 1;
-                  }
-              }
-              if (upper < 0) {
-                upper = RARRAY_LEN(ary) - 1;
-              }
-              return upper;
-          }
-          EOM
-        end
-      rescue Exception
-        # Find the closest index in HashRing with value <= the given value
-        def binary_search(ary, value, &block)
-          upper = ary.size - 1
-          lower = 0
-          idx = 0
-
-          while(lower <= upper) do
-            idx = (lower + upper) / 2
-            comp = ary[idx] <=> value
-
-            if comp == 0
-              return idx
-            elsif comp > 0
-              upper = idx - 1
-            else
-              lower = idx + 1
-            end
-          end
-
-          if upper < 0
-            upper = ary.size - 1
-          end
-          return upper
+    # Find the closest index in HashRing with value <= the given value
+    def self.binary_search(ary, value, &block)
+      upper = ary.size - 1
+      lower = 0
+      idx = 0
+
+      while(lower <= upper) do
+        idx = (lower + upper) / 2
+        comp = ary[idx] <=> value
+
+        if comp == 0
+          return idx
+        elsif comp > 0
+          upper = idx - 1
+        else
+          lower = idx + 1
         end
+      end
 
+      if upper < 0
+        upper = ary.size - 1
       end
+      return upper
     end
-
   end
 end

data/lib/redis/pipeline.rb

@@ -1,10 +1,4 @@
 class Redis
-  unless defined?(::BasicObject)
-    class BasicObject
-      instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A(__|instance_eval)/ }
-    end
-  end
-
   class Pipeline
     attr_accessor :db
 
@@ -28,6 +22,10 @@ class Redis
       @shutdown
     end
 
+    def empty?
+      @futures.empty?
+    end
+
     def call(command, &block)
       # A pipeline that contains a shutdown should not raise ECONNRESET when
       # the connection is gone.
@@ -92,7 +90,11 @@ class Redis
       end
 
       def commands
-        [[:multi]] + super + [[:exec]]
+        if empty?
+          []
+        else
+          [[:multi]] + super + [[:exec]]
+        end
       end
     end
   end