redis 2.2.2 → 3.0.0.rc1

data/lib/redis/client.rb

@@ -1,8 +1,11 @@
+require "redis/errors"
+
 class Redis
   class Client
     attr_accessor :db, :host, :port, :path, :password, :logger
     attr :timeout
     attr :connection
+    attr :command_map
 
     def initialize(options = {})
       @path = options[:path]
@@ -17,6 +20,7 @@ class Redis
       @logger = options[:logger]
       @reconnect = true
       @connection = Connection.drivers.last.new
+      @command_map = {}
     end
 
     def connect
@@ -34,43 +38,25 @@ class Redis
       @path || "#{@host}:#{@port}"
     end
 
-    # Starting with 2.2.1, assume that this method is called with a single
-    # array argument. Check its size for backwards compat.
-    def call(*args)
-      if args.first.is_a?(Array) && args.size == 1
-        command = args.first
-      else
-        command = args
-      end
-
+    def call(command, &block)
       reply = process([command]) { read }
-      raise reply if reply.is_a?(RuntimeError)
-      reply
-    end
+      raise reply if reply.is_a?(CommandError)
 
-    # Assume that this method is called with a single array argument. No
-    # backwards compat here, since it was introduced in 2.2.2.
-    def call_without_reply(command)
-      process([command])
-      nil
-    end
-
-    # Starting with 2.2.1, assume that this method is called with a single
-    # array argument. Check its size for backwards compat.
-    def call_loop(*args)
-      if args.first.is_a?(Array) && args.size == 1
-        command = args.first
+      if block
+        block.call(reply)
       else
-        command = args
+        reply
       end
+    end
 
+    def call_loop(command)
       error = nil
 
       result = without_socket_timeout do
         process([command]) do
           loop do
             reply = read
-            if reply.is_a?(RuntimeError)
+            if reply.is_a?(CommandError)
               error = reply
               break
             else
@@ -87,48 +73,67 @@ class Redis
       result
     end
 
-    def call_pipelined(commands, options = {})
-      options[:raise] = true unless options.has_key?(:raise)
+    def call_pipeline(pipeline)
+      without_reconnect_wrapper = lambda do |&blk| blk.call end
+      without_reconnect_wrapper = lambda do |&blk|
+        without_reconnect(&blk)
+      end if pipeline.without_reconnect?
+
+      shutdown_wrapper = lambda do |&blk| blk.call end
+      shutdown_wrapper = lambda do |&blk|
+        begin
+          blk.call
+        rescue ConnectionError
+          # Assume the pipeline was sent in one piece, but execution of
+          # SHUTDOWN caused none of the replies for commands that were executed
+          # prior to it from coming back around.
+          nil
+        end
+      end if pipeline.shutdown?
+
+      without_reconnect_wrapper.call do
+        shutdown_wrapper.call do
+          pipeline.finish(call_pipelined(pipeline.commands))
+        end
+      end
+    end
+
+    def call_pipelined(commands)
+      return [] if commands.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
       # executed more than once, only allow reconnection before the first reply
       # has been read. When an error occurs after the first reply has been
-      # read, retrying would re-execute the entire pipeline, thus re-issueing
-      # already succesfully executed commands. To circumvent this, don't retry
-      # after the first reply has been read succesfully.
-      first = process(commands) { read }
-      error = first if first.is_a?(RuntimeError)
+      # read, retrying would re-execute the entire pipeline, thus re-issuing
+      # already successfully executed commands. To circumvent this, don't retry
+      # after the first reply has been read successfully.
+
+      result = Array.new(commands.size)
+      reconnect = @reconnect
 
       begin
-        remaining = commands.size - 1
-        if remaining > 0
-          replies = Array.new(remaining) do
-            reply = read
-            error ||= reply if reply.is_a?(RuntimeError)
-            reply
+        process(commands) do
+          result[0] = read
+
+          @reconnect = false
+
+          (commands.size - 1).times do |i|
+            result[i + 1] = read
           end
-          replies.unshift first
-          replies
-        else
-          replies = [first]
         end
-      rescue Exception
-        disconnect
-        raise
+      ensure
+        @reconnect = reconnect
       end
 
-      # Raise first error in pipeline when we should raise.
-      raise error if error && options[:raise]
-
-      replies
+      result
     end
 
-    def call_without_timeout(*args)
+    def call_without_timeout(command, &blk)
       without_socket_timeout do
-        call(*args)
+        call(command, &blk)
       end
-    rescue Errno::ECONNRESET
+    rescue ConnectionError
       retry
     end
 
@@ -136,6 +141,11 @@ class Redis
       logging(commands) do
         ensure_connected do
           commands.each do |command|
+            if command_map[command.first]
+              command = command.dup
+              command[0] = command_map[command.first]
+            end
+
             connection.write(command)
           end
 
@@ -157,20 +167,23 @@ class Redis
       connect
     end
 
+    def io
+      yield
+    rescue Errno::EAGAIN
+      raise TimeoutError, "Connection timed out"
+    rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL => e
+      raise ConnectionError, "Connection lost (%s)" % [e.class.name.split("::").last]
+    end
+
     def read
-      begin
+      io do
         connection.read
+      end
+    end
 
-      rescue Errno::EAGAIN
-        # We want to make sure it reconnects on the next command after the
-        # timeout. Otherwise the server may reply in the meantime leaving
-        # the protocol in a desync status.
-        disconnect
-
-        raise Errno::EAGAIN, "Timeout reading from the socket"
-
-      rescue Errno::ECONNRESET
-        raise Errno::ECONNRESET, "Connection lost"
+    def write(command)
+      io do
+        connection.write(command)
       end
     end
 
@@ -232,8 +245,10 @@ class Redis
       # of seconds. This hack is from memcached ruby client.
       self.timeout = @timeout
 
+    rescue Timeout::Error
+      raise CannotConnectError, "Timed out connecting to Redis on #{location}"
     rescue Errno::ECONNREFUSED
-      raise Errno::ECONNREFUSED, "Unable to connect to Redis on #{location}"
+      raise CannotConnectError, "Error connecting to Redis on #{location} (ECONNREFUSED)"
     end
 
     def timeout=(timeout)
@@ -248,13 +263,13 @@ class Redis
         tries += 1
 
         yield
-      rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL
+      rescue ConnectionError
         disconnect
 
         if tries < 2 && @reconnect
           retry
         else
-          raise Errno::ECONNRESET
+          raise
         end
       rescue Exception
         disconnect

data/lib/redis/connection/command_helper.rb

@@ -5,15 +5,24 @@ class Redis
       COMMAND_DELIMITER = "\r\n"
 
       def build_command(args)
-        command = []
-        command << "*#{args.size}"
+        command = [nil]
 
-        args.each do |arg|
-          arg = arg.to_s
-          command << "$#{string_size arg}"
-          command << arg
+        args.each do |i|
+          if i.is_a? Array
+            i.each do |j|
+              j = j.to_s
+              command << "$#{j.bytesize}"
+              command << j
+            end
+          else
+            i = i.to_s
+            command << "$#{i.bytesize}"
+            command << i
+          end
         end
 
+        command[0] = "*#{(command.length - 1) / 2}"
+
         # Trailing delimiter
         command << ""
         command.join(COMMAND_DELIMITER)
@@ -21,16 +30,6 @@ class Redis
 
     protected
 
-      if "".respond_to?(:bytesize)
-        def string_size(string)
-          string.to_s.bytesize
-        end
-      else
-        def string_size(string)
-          string.to_s.size
-        end
-      end
-
       if defined?(Encoding::default_external)
         def encode(string)
           string.force_encoding(Encoding::default_external)

data/lib/redis/connection/hiredis.rb

@@ -1,4 +1,5 @@
 require "redis/connection/registry"
+require "redis/errors"
 require "hiredis/connection"
 require "timeout"
 
@@ -34,13 +35,15 @@ class Redis
       end
 
       def write(command)
-        @connection.write(command)
+        @connection.write(command.flatten(1))
       end
 
       def read
-        @connection.read
+        reply = @connection.read
+        reply = CommandError.new(reply.message) if reply.is_a?(RuntimeError)
+        reply
       rescue RuntimeError => err
-        raise ::Redis::ProtocolError.new(err.message)
+        raise ProtocolError.new(err.message)
       end
     end
   end

data/lib/redis/connection/ruby.rb

@@ -1,5 +1,6 @@
 require "redis/connection/registry"
 require "redis/connection/command_helper"
+require "redis/errors"
 require "socket"
 
 class Redis
@@ -80,7 +81,7 @@ class Redis
       end
 
       def format_error_reply(line)
-        RuntimeError.new(line.strip)
+        CommandError.new(line.strip)
       end
 
       def format_status_reply(line)

data/lib/redis/connection/synchrony.rb

@@ -1,5 +1,6 @@
 require "redis/connection/command_helper"
 require "redis/connection/registry"
+require "redis/errors"
 require "em-synchrony"
 require "hiredis/reader"
 
@@ -28,10 +29,11 @@ class Redis
 
         begin
           until (reply = @reader.gets) == false
+            reply = CommandError.new(reply.message) if reply.is_a?(RuntimeError)
             @req.succeed [:reply, reply]
           end
         rescue RuntimeError => err
-          @req.fail [:error, ::Redis::ProtocolError.new(err.message)]
+          @req.fail [:error, ProtocolError.new(err.message)]
         end
       end
 

data/lib/redis/distributed.rb

@@ -180,10 +180,6 @@ class Redis
       node_for(key).append(key, value)
     end
 
-    def substr(key, start, stop)
-      node_for(key).substr(key, start, stop)
-    end
-
     def []=(key,value)
       set(key, value)
     end
@@ -208,7 +204,7 @@ class Redis
     end
 
     def mapped_mset(hash)
-      mset(*hash.to_a.flatten)
+      raise CannotDistribute, :mapped_mset
     end
 
     # Set multiple keys to multiple values, only if none of the keys exist.
@@ -240,12 +236,12 @@ class Redis
       node_for(key).decrby(key, decrement)
     end
 
-    # Append a value to a list.
+    # Append one or more values to a list.
     def rpush(key, value)
       node_for(key).rpush(key, value)
     end
 
-    # Prepend a value to a list.
+    # Prepend one or more values to a list.
     def lpush(key, value)
       node_for(key).lpush(key, value)
     end
@@ -318,14 +314,14 @@ class Redis
       end
     end
 
-    # Add a member to a set.
-    def sadd(key, value)
-      node_for(key).sadd(key, value)
+    # Add one or more members to a set.
+    def sadd(key, member)
+      node_for(key).sadd(key, member)
     end
 
-    # Remove a member from a set.
-    def srem(key, value)
-      node_for(key).srem(key, value)
+    # Remove one or more members from a set.
+    def srem(key, member)
+      node_for(key).srem(key, member)
     end
 
     # Remove and return a random member from a set.
@@ -402,12 +398,13 @@ class Redis
       node_for(key).srandmember(key)
     end
 
-    # Add a member to a sorted set, or update its score if it already exists.
-    def zadd(key, score, member)
-      node_for(key).zadd(key, score, member)
+    # Add one or more members to a sorted set, or update the score for members
+    # that already exist.
+    def zadd(key, *args)
+      node_for(key).zadd(key, *args)
     end
 
-    # Remove a member from a sorted set.
+    # Remove one or more members from a sorted set.
     def zrem(key, member)
       node_for(key).zrem(key, member)
     end
@@ -465,6 +462,11 @@ class Redis
       node_for(key).zcard(key)
     end
 
+    # Get the number of members in a particular score range.
+    def zcount(key, min, max)
+      node_for(key).zcount(key, min, max)
+    end
+
     # Get the score associated with the given member in a sorted set.
     def zscore(key, member)
       node_for(key).zscore(key, member)
@@ -500,7 +502,7 @@ class Redis
       node_for(key).hget(key, field)
     end
 
-    # Delete a hash field.
+    # Delete one or more hash fields.
     def hdel(key, field)
       node_for(key).hdel(key, field)
     end

data/lib/redis/errors.rb

@@ -0,0 +1,38 @@
+class Redis
+  # Base error for all redis-rb errors.
+  class BaseError < RuntimeError
+  end
+
+  # Raised by the connection when a protocol error occurs.
+  class ProtocolError < BaseError
+    def initialize(reply_type)
+      super(<<-EOS.gsub(/(?:^|\n)\s*/, " "))
+        Got '#{reply_type}' as initial reply byte.
+        If you're running in a multi-threaded environment, make sure you
+        pass the :thread_safe option when initializing the connection.
+        If you're in a forking environment, such as Unicorn, you need to
+        connect to Redis after forking.
+      EOS
+    end
+  end
+
+  # Raised by the client when command execution returns an error reply.
+  class CommandError < BaseError
+  end
+
+  # Base error for connection related errors.
+  class BaseConnectionError < BaseError
+  end
+
+  # Raised when connection to a Redis server cannot be made.
+  class CannotConnectError < BaseConnectionError
+  end
+
+  # Raised when connection to a Redis server is lost.
+  class ConnectionError < BaseConnectionError
+  end
+
+  # Raised when performing I/O times out.
+  class TimeoutError < BaseConnectionError
+  end
+end