redis 3.0.0.rc1 → 3.0.0.rc2

data/lib/redis/connection/synchrony.rb

@@ -60,30 +60,36 @@ class Redis
     class Synchrony
       include Redis::Connection::CommandHelper
 
-      def initialize
-        @timeout = 5_000_000
-        @connection = nil
-      end
+      def self.connect(config)
+        if config[:scheme] == "unix"
+          conn = EventMachine.connect_unix_domain(config[:path], RedisClient)
+        else
+          conn = EventMachine.connect(config[:host], config[:port], RedisClient) do |c|
+            c.pending_connect_timeout = [config[:timeout], 0.1].max
+          end
+        end
 
-      def connected?
-        @connection && @connection.connected?
-      end
+        fiber = Fiber.current
+        conn.callback { fiber.resume }
+        conn.errback { fiber.resume :refused }
 
-      def timeout=(usecs)
-        @timeout = usecs
+        raise Errno::ECONNREFUSED if Fiber.yield == :refused
+
+        instance = new(conn)
+        instance.timeout = config[:timeout]
+        instance
       end
 
-      def connect(host, port, timeout)
-        conn = EventMachine.connect(host, port, RedisClient) do |c|
-          c.pending_connect_timeout = [Float(timeout / 1_000_000), 0.1].max
-        end
+      def initialize(connection)
+        @connection = connection
+      end
 
-        setup_connect_callbacks(conn, Fiber.current)
+      def connected?
+        @connection && @connection.connected?
       end
 
-      def connect_unix(path, timeout)
-        conn = EventMachine.connect_unix_domain(path, RedisClient)
-        setup_connect_callbacks(conn, Fiber.current)
+      def timeout=(timeout)
+        @timeout = timeout
       end
 
       def disconnect
@@ -106,24 +112,6 @@ class Redis
           raise "Unknown type #{type.inspect}"
         end
       end
-
-    private
-
-      def setup_connect_callbacks(conn, f)
-        conn.callback do
-          @connection = conn
-          f.resume conn
-        end
-
-        conn.errback do
-          @connection = conn
-          f.resume :refused
-        end
-
-        r = Fiber.yield
-        raise Errno::ECONNREFUSED if r == :refused
-        r
-      end
     end
   end
 end

data/lib/redis/distributed.rb

@@ -18,7 +18,7 @@ class Redis
     def initialize(urls, options = {})
       @tag = options.delete(:tag) || /^\{(.+?)\}/
       @default_options = options
-      @ring = HashRing.new urls.map { |url| Redis.connect(options.merge(:url => url)) }
+      @ring = HashRing.new urls.map { |url| Redis.new(options.merge(:url => url)) }
       @subscribed_node = nil
     end
 
@@ -31,7 +31,7 @@ class Redis
     end
 
     def add_node(url)
-      @ring.add_node Redis.connect(@default_options.merge(:url => url))
+      @ring.add_node Redis.new(@default_options.merge(:url => url))
     end
 
     # Close the connection.
@@ -84,14 +84,14 @@ class Redis
 
     # Rename a key.
     def rename(old_name, new_name)
-      ensure_same_node(:rename, old_name, new_name) do |node|
+      ensure_same_node(:rename, [old_name, new_name]) do |node|
         node.rename(old_name, new_name)
       end
     end
 
     # Rename a key, only if the new key does not exist.
     def renamenx(old_name, new_name)
-      ensure_same_node(:renamenx, old_name, new_name) do |node|
+      ensure_same_node(:renamenx, [old_name, new_name]) do |node|
         node.renamenx(old_name, new_name)
       end
     end
@@ -106,21 +106,36 @@ class Redis
       node_for(key).expire(key, seconds)
     end
 
+    # Set a key's time to live in milliseconds.
+    def pexpire(key, milliseconds)
+      node_for(key).pexpire(key, milliseconds)
+    end
+
     # Set the expiration for a key as a UNIX timestamp.
     def expireat(key, unix_time)
       node_for(key).expireat(key, unix_time)
     end
 
+    # Set the expiration for a key as number of milliseconds from UNIX Epoch.
+    def pexpireat(key, ms_unix_time)
+      node_for(key).pexpireat(key, ms_unix_time)
+    end
+
     # Remove the expiration from a key.
     def persist(key)
       node_for(key).persist(key)
     end
 
-    # Get the time to live for a key.
+    # Get the time to live (in seconds) for a key.
     def ttl(key)
       node_for(key).ttl(key)
     end
 
+    # Get the time to live (in milliseconds) for a key.
+    def pttl(key)
+      node_for(key).pttl(key)
+    end
+
     # Move a key to another database.
     def move(key, db)
       node_for(key).move(key, db)
@@ -146,11 +161,16 @@ class Redis
       node_for(key).setrange(key, offset, value)
     end
 
-    # Set the value and expiration of a key.
+    # Set the time to live in seconds of a key.
     def setex(key, ttl, value)
       node_for(key).setex(key, ttl, value)
     end
 
+    # Set the time to live in milliseconds of a key.
+    def psetex(key, ttl, value)
+      node_for(key).psetex(key, ttl, value)
+    end
+
     # Get the value of a key.
     def get(key)
       node_for(key).get(key)
@@ -221,11 +241,16 @@ class Redis
       node_for(key).incr(key)
     end
 
-    # Increment the integer value of a key by the given number.
+    # Increment the integer value of a key by the given integer number.
     def incrby(key, increment)
       node_for(key).incrby(key, increment)
     end
 
+    # Increment the numeric value of a key by the given float number.
+    def incrbyfloat(key, increment)
+      node_for(key).incrbyfloat(key, increment)
+    end
+
     # Decrement the integer value of a key by one.
     def decr(key)
       node_for(key).decr(key)
@@ -289,28 +314,56 @@ class Redis
     # Remove the last element in a list, append it to another list and return
     # it.
     def rpoplpush(source, destination)
-      ensure_same_node(:rpoplpush, source, destination) do |node|
+      ensure_same_node(:rpoplpush, [source, destination]) do |node|
         node.rpoplpush(source, destination)
       end
     end
 
+    def _bpop(cmd, args)
+      options = {}
+
+      case args.last
+      when Hash
+        options = args.pop
+      when Integer
+        # Issue deprecation notice in obnoxious mode...
+        options[:timeout] = args.pop
+      end
+
+      if args.size > 1
+        # Issue deprecation notice in obnoxious mode...
+      end
+
+      keys = args.flatten
+
+      ensure_same_node(cmd, keys) do |node|
+        node.__send__(cmd, keys, options)
+      end
+    end
+
     # Remove and get the first element in a list, or block until one is
     # available.
-    def blpop(key, timeout)
-      node_for(key).blpop(key, timeout)
+    def blpop(*args)
+      _bpop(:blpop, args)
     end
 
     # Remove and get the last element in a list, or block until one is
     # available.
-    def brpop(key, timeout)
-      node_for(key).brpop(key, timeout)
+    def brpop(*args)
+      _bpop(:brpop, args)
     end
 
     # Pop a value from a list, push it to another list and return it; or block
     # until one is available.
-    def brpoplpush(source, destination, timeout)
-      ensure_same_node(:brpoplpush, source, destination) do |node|
-        node.brpoplpush(source, destination, timeout)
+    def brpoplpush(source, destination, options = {})
+      case options
+      when Integer
+        # Issue deprecation notice in obnoxious mode...
+        options = { :timeout => options }
+      end
+
+      ensure_same_node(:brpoplpush, [source, destination]) do |node|
+        node.brpoplpush(source, destination, options)
       end
     end
 
@@ -331,7 +384,7 @@ class Redis
 
     # Move a member from one set to another.
     def smove(source, destination, member)
-      ensure_same_node(:smove, source, destination) do |node|
+      ensure_same_node(:smove, [source, destination]) do |node|
         node.smove(source, destination, member)
       end
     end
@@ -348,42 +401,42 @@ class Redis
 
     # Intersect multiple sets.
     def sinter(*keys)
-      ensure_same_node(:sinter, *keys) do |node|
+      ensure_same_node(:sinter, keys) do |node|
         node.sinter(*keys)
       end
     end
 
     # Intersect multiple sets and store the resulting set in a key.
     def sinterstore(destination, *keys)
-      ensure_same_node(:sinterstore, destination, *keys) do |node|
+      ensure_same_node(:sinterstore, [destination] + keys) do |node|
         node.sinterstore(destination, *keys)
       end
     end
 
     # Add multiple sets.
     def sunion(*keys)
-      ensure_same_node(:sunion, *keys) do |node|
+      ensure_same_node(:sunion, keys) do |node|
         node.sunion(*keys)
       end
     end
 
     # Add multiple sets and store the resulting set in a key.
     def sunionstore(destination, *keys)
-      ensure_same_node(:sunionstore, destination, *keys) do |node|
+      ensure_same_node(:sunionstore, [destination] + keys) do |node|
         node.sunionstore(destination, *keys)
       end
     end
 
     # Subtract multiple sets.
     def sdiff(*keys)
-      ensure_same_node(:sdiff, *keys) do |node|
+      ensure_same_node(:sdiff, keys) do |node|
         node.sdiff(*keys)
       end
     end
 
     # Subtract multiple sets and store the resulting set in a key.
     def sdiffstore(destination, *keys)
-      ensure_same_node(:sdiffstore, destination, *keys) do |node|
+      ensure_same_node(:sdiffstore, [destination] + keys) do |node|
         node.sdiffstore(destination, *keys)
       end
     end
@@ -475,14 +528,14 @@ class Redis
     # Intersect multiple sorted sets and store the resulting sorted set in a new
     # key.
     def zinterstore(destination, keys, options = {})
-      ensure_same_node(:zinterstore, destination, *keys) do |node|
+      ensure_same_node(:zinterstore, [destination] + keys) do |node|
         node.zinterstore(destination, keys, options)
       end
     end
 
     # Add multiple sorted sets and store the resulting sorted set in a new key.
     def zunionstore(destination, keys, options = {})
-      ensure_same_node(:zunionstore, destination, *keys) do |node|
+      ensure_same_node(:zunionstore, [destination] + keys) do |node|
         node.zunionstore(destination, keys, options)
       end
     end
@@ -550,16 +603,21 @@ class Redis
       Hash[*fields.zip(hmget(key, *fields)).flatten]
     end
 
-    # Increment the integer value of a hash field by the given number.
+    # Increment the integer value of a hash field by the given integer number.
     def hincrby(key, field, increment)
       node_for(key).hincrby(key, field, increment)
     end
 
+    # Increment the numeric value of a hash field by the given float number.
+    def hincrbyfloat(key, field, increment)
+      node_for(key).hincrbyfloat(key, field, increment)
+    end
+
     # Sort the elements in a list, set or sorted set.
     def sort(key, options = {})
       keys = [key, options[:by], options[:store], *Array(options[:get])].compact
 
-      ensure_same_node(:sort, *keys) do |node|
+      ensure_same_node(:sort, keys) do |node|
         node.sort(key, options)
       end
     end
@@ -610,7 +668,7 @@ class Redis
         @subscribed_node = node_for(channel)
         @subscribed_node.subscribe(channel, &block)
       else
-        ensure_same_node(:subscribe, channel, *channels) do |node|
+        ensure_same_node(:subscribe, [channel] + channels) do |node|
           @subscribed_node = node
           node.subscribe(channel, *channels, &block)
         end
@@ -658,15 +716,17 @@ class Redis
       on_each_node :echo, value
     end
 
+    # Get server time: an UNIX timestamp and the elapsed microseconds in the current second.
+    def time
+      on_each_node :time
+    end
+
     def pipelined
       raise CannotDistribute, :pipelined
     end
 
     def inspect
-      node_info = nodes.map do |node|
-        "#{node.id} (Redis v#{node.info['redis_version']})"
-      end
-      "#<Redis client v#{Redis::VERSION} connected to #{node_info.join(', ')}>"
+      "#<Redis client v#{Redis::VERSION} for #{nodes.map(&:id).join(', ')}>"
     end
 
   protected
@@ -685,7 +745,7 @@ class Redis
       key.to_s[@tag, 1] if @tag
     end
 
-    def ensure_same_node(command, *keys)
+    def ensure_same_node(command, keys)
       tags = keys.map { |key| key_tag(key) }
 
       raise CannotDistribute, command if !tags.all? || tags.uniq.size != 1

data/lib/redis/errors.rb

@@ -8,8 +8,6 @@ class Redis
     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
@@ -35,4 +33,8 @@ class Redis
   # Raised when performing I/O times out.
   class TimeoutError < BaseConnectionError
   end
+
+  # Raised when the connection was inherited by a child process.
+  class InheritedError < BaseConnectionError
+  end
 end

data/lib/redis/pipeline.rb

@@ -46,9 +46,15 @@ class Redis
       yield
     end
 
-    def finish(replies)
-      futures.each_with_index.map do |future, i|
-        future._set(replies[i])
+    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
       end
     end
 
@@ -58,10 +64,15 @@ class Redis
 
         if replies.last.size < futures.size - 2
           # Some command wasn't recognized by Redis.
-          raise replies.detect { |r| r.kind_of?(::Exception) }
+          raise replies.detect { |r| r.kind_of?(::RuntimeError) }
         end
 
-        super(replies.last)
+        super(replies.last) 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
 
       def commands
@@ -99,7 +110,7 @@ class Redis
     end
 
     def value
-      ::Kernel.raise(@object) if @object.kind_of?(::Exception)
+      ::Kernel.raise(@object) if @object.kind_of?(::RuntimeError)
       @object
     end
   end

data/lib/redis/version.rb

@@ -1,3 +1,3 @@
 class Redis
-  VERSION = "3.0.0.rc1"
+  VERSION = "3.0.0.rc2"
 end