redis 3.3.5 → 4.1.4

data/lib/redis/cluster/slot.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'set'
+
+class Redis
+  class Cluster
+    # Keep slot and node key map for Redis Cluster Client
+    class Slot
+      ROLE_SLAVE = 'slave'
+
+      def initialize(available_slots, node_flags = {}, with_replica = false)
+        @with_replica = with_replica
+        @node_flags = node_flags
+        @map = build_slot_node_key_map(available_slots)
+      end
+
+      def exists?(slot)
+        @map.key?(slot)
+      end
+
+      def find_node_key_of_master(slot)
+        return nil unless exists?(slot)
+
+        @map[slot][:master]
+      end
+
+      def find_node_key_of_slave(slot)
+        return nil unless exists?(slot)
+        return find_node_key_of_master(slot) if replica_disabled?
+
+        @map[slot][:slaves].to_a.sample
+      end
+
+      def put(slot, node_key)
+        assign_node_key(@map, slot, node_key)
+        nil
+      end
+
+      private
+
+      def replica_disabled?
+        !@with_replica
+      end
+
+      def master?(node_key)
+        !slave?(node_key)
+      end
+
+      def slave?(node_key)
+        @node_flags[node_key] == ROLE_SLAVE
+      end
+
+      # available_slots is mapping of node_key to list of slot ranges
+      def build_slot_node_key_map(available_slots)
+        available_slots.each_with_object({}) do |(node_key, slots_arr), acc|
+          slots_arr.each do |slots|
+            slots.each { |slot| assign_node_key(acc, slot, node_key) }
+          end
+        end
+      end
+
+      def assign_node_key(mappings, slot, node_key)
+        mappings[slot] ||= { master: nil, slaves: ::Set.new }
+        if master?(node_key)
+          mappings[slot][:master] = node_key
+        else
+          mappings[slot][:slaves].add(node_key)
+        end
+      end
+    end
+  end
+end

data/lib/redis/cluster/slot_loader.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../errors'
+require_relative 'node_key'
+
+class Redis
+  class Cluster
+    # Load and hashify slot info for Redis Cluster Client
+    module SlotLoader
+      module_function
+
+      def load(nodes)
+        info = {}
+
+        nodes.each do |node|
+          info = fetch_slot_info(node)
+          info.empty? ? next : break
+        end
+
+        return info unless info.empty?
+
+        raise CannotConnectError, 'Redis client could not connect to any cluster nodes'
+      end
+
+      def fetch_slot_info(node)
+        hash_with_default_arr = Hash.new { |h, k| h[k] = [] }
+        node.call(%i[cluster slots])
+          .flat_map { |arr| parse_slot_info(arr, default_ip: node.host) }
+          .each_with_object(hash_with_default_arr) { |arr, h| h[arr[0]] << arr[1] }
+
+      rescue CannotConnectError, ConnectionError, CommandError
+        {} # can retry on another node
+      end
+
+      def parse_slot_info(arr, default_ip:)
+        first_slot, last_slot = arr[0..1]
+        slot_range = (first_slot..last_slot).freeze
+        arr[2..-1].map { |addr| [stringify_node_key(addr, default_ip), slot_range] }
+      end
+
+      def stringify_node_key(arr, default_ip)
+        ip, port = arr
+        ip = default_ip if ip.empty? # When cluster is down
+        NodeKey.build_from_host_port(ip, port)
+      end
+
+      private_class_method :fetch_slot_info, :parse_slot_info, :stringify_node_key
+    end
+  end
+end

data/lib/redis/connection.rb

@@ -1,4 +1,5 @@
-require "redis/connection/registry"
+# frozen_string_literal: true
+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 +7,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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class Redis
   module Connection
     module CommandHelper
@@ -30,14 +31,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,6 @@
-require "redis/connection/registry"
-require "redis/errors"
+# frozen_string_literal: true
+require_relative "registry"
+require_relative "../errors"
 require "hiredis/connection"
 require "timeout"
 

data/lib/redis/connection/registry.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class Redis
   module Connection
 

data/lib/redis/connection/ruby.rb

@@ -1,6 +1,7 @@
-require "redis/connection/registry"
-require "redis/connection/command_helper"
-require "redis/errors"
+# frozen_string_literal: true
+require_relative "registry"
+require_relative "command_helper"
+require_relative "../errors"
 require "socket"
 require "timeout"
 
@@ -10,36 +11,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)
@@ -72,7 +54,7 @@ class Redis
         crlf = nil
 
         while (crlf = @buffer.index(CRLF)) == nil
-          @buffer << _read_from_socket(1024)
+          @buffer << _read_from_socket(16384)
         end
 
         @buffer.slice!(0, crlf + CRLF.bytesize)
@@ -83,13 +65,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 +87,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
@@ -285,8 +267,32 @@ class Redis
 
           ssl_sock = new(tcp_sock, ctx)
           ssl_sock.hostname = host
-          ssl_sock.connect
-          ssl_sock.post_connection_check(host)
+
+          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 || (ctx.respond_to?(:verify_hostname) && !ctx.verify_hostname)
+            ssl_sock.post_connection_check(host)
+          end
 
           ssl_sock
         end
@@ -307,16 +313,16 @@ 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.set_tcp_nodelay if sock.is_a? TCPSocket
         instance
       end
 
@@ -347,6 +353,16 @@ class Redis
         end
       end
 
+      # disables Nagle's Algorithm, prevents multiple round trips with MULTI
+      if [:IPPROTO_TCP, :TCP_NODELAY].all?{|c| Socket.const_defined? c}
+        def set_tcp_nodelay
+          @sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        end
+      else
+        def set_tcp_nodelay
+        end
+      end
+
       def initialize(sock)
         @sock = sock
       end

data/lib/redis/connection/synchrony.rb

@@ -1,6 +1,7 @@
-require "redis/connection/command_helper"
-require "redis/connection/registry"
-require "redis/errors"
+# frozen_string_literal: true
+require_relative "command_helper"
+require_relative "registry"
+require_relative "../errors"
 require "em-synchrony"
 require "hiredis/reader"
 
@@ -72,7 +73,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,5 @@
-require "redis/hash_ring"
+# frozen_string_literal: true
+require_relative "hash_ring"
 
 class Redis
   class Distributed
@@ -144,8 +145,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 +162,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 +286,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.
@@ -390,14 +402,12 @@ class Redis
     end
 
     def _bpop(cmd, args)
-      options = {}
-
-      case args.last
-      when Hash
+      timeout = if args.last.is_a?(Hash)
         options = args.pop
-      when Integer
+        options[:timeout]
+      elsif args.last.respond_to?(:to_int)
         # Issue deprecation notice in obnoxious mode...
-        options[:timeout] = args.pop
+        args.pop.to_int
       end
 
       if args.size > 1
@@ -407,7 +417,11 @@ class Redis
       keys = args.flatten
 
       ensure_same_node(cmd, keys) do |node|
-        node.__send__(cmd, keys, options)
+        if timeout
+          node.__send__(cmd, keys, timeout: timeout)
+        else
+          node.__send__(cmd, keys)
+        end
       end
     end
 
@@ -509,6 +523,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 +703,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.