redis 4.0.0 → 5.0.0

data/lib/redis/errors.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 class Redis
   # Base error for all redis-rb errors.
-  class BaseError < RuntimeError
+  class BaseError < StandardError
   end
 
   # Raised by the connection when a protocol error occurs.
@@ -18,6 +20,15 @@ class Redis
   class CommandError < BaseError
   end
 
+  class PermissionError < CommandError
+  end
+
+  class WrongTypeError < CommandError
+  end
+
+  class ReadOnlyError < CommandError
+  end
+
   # Base error for connection related errors.
   class BaseConnectionError < BaseError
   end
@@ -37,4 +48,11 @@ 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 SubscriptionError < BaseError
+  end
 end

data/lib/redis/hash_ring.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'zlib'
+require 'digest/md5'
 
 class Redis
   class HashRing
-
     POINTS_PER_SERVER = 160 # this is the default in libmemcached
 
     attr_reader :ring, :sorted_keys, :replicas, :nodes
@@ -10,7 +12,7 @@ class Redis
     # nodes is a list of objects that have a proper to_s representation.
     # replicas indicates how many virtual points should be used pr. node,
     # replicas are required to improve the distribution.
-    def initialize(nodes=[], replicas=POINTS_PER_SERVER)
+    def initialize(nodes = [], replicas = POINTS_PER_SERVER)
       @replicas = replicas
       @ring = {}
       @nodes = []
@@ -24,7 +26,7 @@ class Redis
     def add_node(node)
       @nodes << node
       @replicas.times do |i|
-        key = Zlib.crc32("#{node.id}:#{i}")
+        key = server_hash_for("#{node.id}:#{i}")
         @ring[key] = node
         @sorted_keys << key
       end
@@ -32,57 +34,56 @@ class Redis
     end
 
     def remove_node(node)
-      @nodes.reject!{|n| n.id == node.id}
+      @nodes.reject! { |n| n.id == node.id }
       @replicas.times do |i|
-        key = Zlib.crc32("#{node.id}:#{i}")
+        key = server_hash_for("#{node.id}:#{i}")
         @ring.delete(key)
-        @sorted_keys.reject! {|k| k == key}
+        @sorted_keys.reject! { |k| k == key }
       end
     end
 
     # get the node in the hash ring for this key
     def get_node(key)
-      get_node_pos(key)[0]
-    end
-
-    def get_node_pos(key)
-      return [nil,nil] if @ring.size == 0
-      crc = Zlib.crc32(key)
-      idx = HashRing.binary_search(@sorted_keys, crc)
-      return [@ring[@sorted_keys[idx]], idx]
+      hash = hash_for(key)
+      idx = binary_search(@sorted_keys, hash)
+      @ring[@sorted_keys[idx]]
     end
 
     def iter_nodes(key)
-      return [nil,nil] if @ring.size == 0
-      _, pos = get_node_pos(key)
+      return [nil, nil] if @ring.empty?
+
+      crc = hash_for(key)
+      pos = binary_search(@sorted_keys, crc)
       @ring.size.times do |n|
-        yield @ring[@sorted_keys[(pos+n) % @ring.size]]
+        yield @ring[@sorted_keys[(pos + n) % @ring.size]]
       end
     end
 
+    private
+
+    def hash_for(key)
+      Zlib.crc32(key)
+    end
+
+    def server_hash_for(key)
+      Digest::MD5.digest(key).unpack1("L>")
+    end
+
     # Find the closest index in HashRing with value <= the given value
-    def self.binary_search(ary, value, &block)
-      upper = ary.size - 1
+    def binary_search(ary, value)
+      upper = ary.size
       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
+      while lower < upper
+        mid = (lower + upper) / 2
+        if ary[mid] > value
+          upper = mid
         else
-          lower = idx + 1
+          lower = mid + 1
         end
       end
 
-      if upper < 0
-        upper = ary.size - 1
-      end
-      return upper
+      upper - 1
     end
   end
 end

data/lib/redis/pipeline.rb

@@ -1,93 +1,72 @@
+# frozen_string_literal: true
+
+require "delegate"
+
 class Redis
-  class Pipeline
+  class PipelinedConnection
     attr_accessor :db
 
-    attr :futures
-
-    def initialize
-      @with_reconnect = true
-      @shutdown = false
-      @futures = []
+    def initialize(pipeline, futures = [])
+      @pipeline = pipeline
+      @futures = futures
     end
 
-    def with_reconnect?
-      @with_reconnect
+    include Commands
+
+    def pipelined
+      yield self
     end
 
-    def without_reconnect?
-      !@with_reconnect
+    def multi
+      transaction = MultiConnection.new(@pipeline, @futures)
+      send_command([:multi])
+      size = @futures.size
+      yield transaction
+      multi_future = MultiFuture.new(@futures[size..-1])
+      @pipeline.call_v([:exec]) do |result|
+        multi_future._set(result)
+      end
+      @futures << multi_future
+      multi_future
     end
 
-    def shutdown?
-      @shutdown
+    private
+
+    def synchronize
+      yield self
     end
 
-    def call(command, &block)
-      # A pipeline that contains a shutdown should not raise ECONNRESET when
-      # the connection is gone.
-      @shutdown = true if command.first == :shutdown
+    def send_command(command, &block)
       future = Future.new(command, block)
+      @pipeline.call_v(command) do |result|
+        future._set(result)
+      end
       @futures << future
       future
     end
 
-    def call_pipeline(pipeline)
-      @shutdown = true if pipeline.shutdown?
-      @futures.concat(pipeline.futures)
-      @db = pipeline.db
-      nil
-    end
-
-    def commands
-      @futures.map { |f| f._command }
-    end
-
-    def with_reconnect(val=true)
-      @with_reconnect = false unless val
-      yield
-    end
-
-    def without_reconnect(&blk)
-      with_reconnect(false, &blk)
-    end
-
-    def finish(replies, &blk)
-      if blk
-        futures.each_with_index.map do |future, i|
-          future._set(blk.call(replies[i]))
-        end
-      else
-        futures.each_with_index.map do |future, i|
-          future._set(replies[i])
-        end
+    def send_blocking_command(command, timeout, &block)
+      future = Future.new(command, block)
+      @pipeline.blocking_call_v(timeout, command) do |result|
+        future._set(result)
       end
+      @futures << future
+      future
     end
+  end
 
-    class Multi < self
-      def finish(replies)
-        exec = replies.last
-
-        return if exec.nil? # The transaction failed because of WATCH.
-
-        # EXEC command failed.
-        raise exec if exec.is_a?(CommandError)
-
-        if exec.size < futures.size
-          # Some command wasn't recognized by Redis.
-          raise replies.detect { |r| r.is_a?(CommandError) }
-        end
+  class MultiConnection < PipelinedConnection
+    def multi
+      raise Redis::Error, "Can't nest multi transaction"
+    end
 
-        super(exec) do |reply|
-          # Because an EXEC returns nested replies, hiredis won't be able to
-          # convert an error reply to a CommandError instance itself. This is
-          # specific to MULTI/EXEC, so we solve this here.
-          reply.is_a?(::RuntimeError) ? CommandError.new(reply.message) : reply
-        end
-      end
+    private
 
-      def commands
-        [[:multi]] + super + [[:exec]]
-      end
+    # Blocking commands inside transaction behave like non-blocking.
+    # It shouldn't be done though.
+    # https://redis.io/commands/blpop/#blpop-inside-a-multi--exec-transaction
+    def send_blocking_command(command, _timeout, &block)
+      send_command(command, &block)
     end
   end
 
@@ -100,10 +79,10 @@ class Redis
   class Future < BasicObject
     FutureNotReady = ::Redis::FutureNotReady.new
 
-    def initialize(command, transformation)
+    def initialize(command, coerce)
       @command = command
-      @transformation = transformation
       @object = FutureNotReady
+      @coerce = coerce
     end
 
     def inspect
@@ -111,16 +90,12 @@ class Redis
     end
 
     def _set(object)
-      @object = @transformation ? @transformation.call(object) : object
+      @object = @coerce ? @coerce.call(object) : object
       value
     end
 
-    def _command
-      @command
-    end
-
     def value
-      ::Kernel.raise(@object) if @object.kind_of?(::RuntimeError)
+      ::Kernel.raise(@object) if @object.is_a?(::StandardError)
       @object
     end
 
@@ -132,4 +107,21 @@ class Redis
       Future
     end
   end
+
+  class MultiFuture < Future
+    def initialize(futures)
+      @futures = futures
+      @command = [:exec]
+      @object = FutureNotReady
+    end
+
+    def _set(replies)
+      if replies
+        @futures.each_with_index do |future, index|
+          future._set(replies[index])
+        end
+      end
+      @object = replies
+    end
+  end
 end

data/lib/redis/subscribe.rb

@@ -1,11 +1,16 @@
+# frozen_string_literal: true
+
 class Redis
   class SubscribedClient
     def initialize(client)
       @client = client
+      @write_monitor = Monitor.new
     end
 
-    def call(command)
-      @client.process([command])
+    def call_v(command)
+      @write_monitor.synchronize do
+        @client.call_v(command)
+      end
     end
 
     def subscribe(*channels, &block)
@@ -25,31 +30,36 @@ class Redis
     end
 
     def unsubscribe(*channels)
-      call([:unsubscribe, *channels])
+      call_v([:unsubscribe, *channels])
     end
 
     def punsubscribe(*channels)
-      call([:punsubscribe, *channels])
+      call_v([:punsubscribe, *channels])
+    end
+
+    def close
+      @client.close
     end
 
-  protected
+    protected
 
     def subscription(start, stop, channels, block, timeout = 0)
       sub = Subscription.new(&block)
 
-      unsubscribed = false
+      call_v([start, *channels])
+      while event = @client.next_event(timeout)
+        if event.is_a?(::RedisClient::CommandError)
+          raise Client::ERROR_MAPPING.fetch(event.class), event.message
+        end
 
-      begin
-        @client.call_loop([start, *channels], timeout) do |line|
-          type, *rest = line
-          sub.callbacks[type].call(*rest)
-          unsubscribed = type == stop && rest.last == 0
-          break if unsubscribed
+        type, *rest = event
+        if callback = sub.callbacks[type]
+          callback.call(*rest)
         end
-      ensure
-        # No need to unsubscribe here. The real client closes the connection
-        # whenever an exception is raised (see #ensure_connected).
+        break if type == stop && rest.last == 0
       end
+      # No need to unsubscribe here. The real client closes the connection
+      # whenever an exception is raised (see #ensure_connected).
     end
   end
 
@@ -57,10 +67,7 @@ class Redis
     attr :callbacks
 
     def initialize
-      @callbacks = Hash.new do |hash, key|
-        hash[key] = lambda { |*_| }
-      end
-
+      @callbacks = {}
       yield(self)
     end
 

data/lib/redis/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Redis
-  VERSION = "4.0.0"
+  VERSION = '5.0.0'
 end