redis 3.0.0.rc2 → 3.0.0

data/lib/redis/client.rb

@@ -110,26 +110,15 @@ class Redis
     end
 
     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|
+      with_reconnect pipeline.with_reconnect? do
         begin
-          blk.call
-        rescue ConnectionError
+          pipeline.finish(call_pipelined(pipeline.commands))
+        rescue ConnectionError => e
+          return nil if pipeline.shutdown?
           # 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))
+          raise e
         end
       end
     end
@@ -234,15 +223,19 @@ class Redis
       end
     end
 
-    def without_reconnect
+    def with_reconnect(val=true)
       begin
-        original, @reconnect = @reconnect, false
+        original, @reconnect = @reconnect, val
         yield
       ensure
         @reconnect = original
       end
     end
 
+    def without_reconnect(&blk)
+      with_reconnect(false, &blk)
+    end
+
   protected
 
     def logging(commands)

data/lib/redis/distributed.rb

@@ -34,11 +34,6 @@ class Redis
       @ring.add_node Redis.new(@default_options.merge(:url => url))
     end
 
-    # Close the connection.
-    def quit
-      on_each_node :quit
-    end
-
     # Change the selected database for the current connection.
     def select(db)
       on_each_node :select, db
@@ -49,14 +44,94 @@ class Redis
       on_each_node :ping
     end
 
+    # Echo the given string.
+    def echo(value)
+      on_each_node :echo, value
+    end
+
+    # Close the connection.
+    def quit
+      on_each_node :quit
+    end
+
+    # Asynchronously save the dataset to disk.
+    def bgsave
+      on_each_node :bgsave
+    end
+
+    # Return the number of keys in the selected database.
+    def dbsize
+      on_each_node :dbsize
+    end
+
     # Remove all keys from all databases.
     def flushall
       on_each_node :flushall
     end
 
-    # Determine if a key exists.
-    def exists(key)
-      node_for(key).exists(key)
+    # Remove all keys from the current database.
+    def flushdb
+      on_each_node :flushdb
+    end
+
+    # Get information and statistics about the server.
+    def info(cmd = nil)
+      on_each_node :info, cmd
+    end
+
+    # Get the UNIX time stamp of the last successful save to disk.
+    def lastsave
+      on_each_node :lastsave
+    end
+
+    # Listen for all requests received by the server in real time.
+    def monitor
+      raise NotImplementedError
+    end
+
+    # Synchronously save the dataset to disk.
+    def save
+      on_each_node :save
+    end
+
+    # Get server time: an UNIX timestamp and the elapsed microseconds in the current second.
+    def time
+      on_each_node :time
+    end
+
+    # Remove the expiration from a key.
+    def persist(key)
+      node_for(key).persist(key)
+    end
+
+    # Set a key's time to live in seconds.
+    def expire(key, seconds)
+      node_for(key).expire(key, seconds)
+    end
+
+    # Set the expiration for a key as a UNIX timestamp.
+    def expireat(key, unix_time)
+      node_for(key).expireat(key, unix_time)
+    end
+
+    # Get the time to live (in seconds) for a key.
+    def ttl(key)
+      node_for(key).ttl(key)
+    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 number of milliseconds from UNIX Epoch.
+    def pexpireat(key, ms_unix_time)
+      node_for(key).pexpireat(key, ms_unix_time)
+    end
+
+    # Get the time to live (in milliseconds) for a key.
+    def pttl(key)
+      node_for(key).pttl(key)
     end
 
     # Delete a key.
@@ -67,9 +142,9 @@ class Redis
       end
     end
 
-    # Determine the type stored at key.
-    def type(key)
-      node_for(key).type(key)
+    # Determine if a key exists.
+    def exists(key)
+      node_for(key).exists(key)
     end
 
     # Find all keys matching the given pattern.
@@ -77,6 +152,11 @@ class Redis
       on_each_node(:keys, glob).flatten
     end
 
+    # Move a key to another database.
+    def move(key, db)
+      node_for(key).move(key, db)
+    end
+
     # Return a random key from the keyspace.
     def randomkey
       raise CannotDistribute, :randomkey
@@ -96,54 +176,43 @@ class Redis
       end
     end
 
-    # Return the number of keys in the selected database.
-    def dbsize
-      on_each_node :dbsize
-    end
-
-    # Set a key's time to live in seconds.
-    def expire(key, seconds)
-      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
+    # Sort the elements in a list, set or sorted set.
+    def sort(key, options = {})
+      keys = [key, options[:by], options[:store], *Array(options[:get])].compact
 
-    # Set the expiration for a key as a UNIX timestamp.
-    def expireat(key, unix_time)
-      node_for(key).expireat(key, unix_time)
+      ensure_same_node(:sort, keys) do |node|
+        node.sort(key, options)
+      end
     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)
+    # Determine the type stored at key.
+    def type(key)
+      node_for(key).type(key)
     end
 
-    # Remove the expiration from a key.
-    def persist(key)
-      node_for(key).persist(key)
+    # Decrement the integer value of a key by one.
+    def decr(key)
+      node_for(key).decr(key)
     end
 
-    # Get the time to live (in seconds) for a key.
-    def ttl(key)
-      node_for(key).ttl(key)
+    # Decrement the integer value of a key by the given number.
+    def decrby(key, decrement)
+      node_for(key).decrby(key, decrement)
     end
 
-    # Get the time to live (in milliseconds) for a key.
-    def pttl(key)
-      node_for(key).pttl(key)
+    # Increment the integer value of a key by one.
+    def incr(key)
+      node_for(key).incr(key)
     end
 
-    # Move a key to another database.
-    def move(key, db)
-      node_for(key).move(key, db)
+    # Increment the integer value of a key by the given integer number.
+    def incrby(key, increment)
+      node_for(key).incrby(key, increment)
     end
 
-    # Remove all keys from the current database.
-    def flushdb
-      on_each_node :flushdb
+    # Increment the numeric value of a key by the given float number.
+    def incrbyfloat(key, increment)
+      node_for(key).incrbyfloat(key, increment)
     end
 
     # Set the string value of a key.
@@ -151,16 +220,6 @@ class Redis
       node_for(key).set(key, value)
     end
 
-    # Sets or clears the bit at offset in the string value stored at key.
-    def setbit(key, offset, value)
-      node_for(key).setbit(key, offset, value)
-    end
-
-    # Overwrite part of a string at key starting at the specified offset.
-    def setrange(key, offset, value)
-      node_for(key).setrange(key, offset, value)
-    end
-
     # Set the time to live in seconds of a key.
     def setex(key, ttl, value)
       node_for(key).setex(key, ttl, value)
@@ -171,37 +230,32 @@ class Redis
       node_for(key).psetex(key, ttl, value)
     end
 
-    # Get the value of a key.
-    def get(key)
-      node_for(key).get(key)
-    end
-
-    # Returns the bit value at offset in the string value stored at key.
-    def getbit(key, offset)
-      node_for(key).getbit(key, offset)
+    # Set the value of a key, only if the key does not exist.
+    def setnx(key, value)
+      node_for(key).setnx(key, value)
     end
 
-    # Get a substring of the string stored at a key.
-    def getrange(key, start, stop)
-      node_for(key).getrange(key, start, stop)
+    # Set multiple keys to multiple values.
+    def mset(*args)
+      raise CannotDistribute, :mset
     end
 
-    # Set the string value of a key and return its old value.
-    def getset(key, value)
-      node_for(key).getset(key, value)
+    def mapped_mset(hash)
+      raise CannotDistribute, :mapped_mset
     end
 
-    def [](key)
-      get(key)
+    # Set multiple keys to multiple values, only if none of the keys exist.
+    def msetnx(*args)
+      raise CannotDistribute, :msetnx
     end
 
-    # Append a value to a key.
-    def append(key, value)
-      node_for(key).append(key, value)
+    def mapped_msetnx(hash)
+      raise CannotDistribute, :mapped_msetnx
     end
 
-    def []=(key,value)
-      set(key, value)
+    # Get the value of a key.
+    def get(key)
+      node_for(key).get(key)
     end
 
     # Get the values of all the given keys.
@@ -213,62 +267,47 @@ class Redis
       raise CannotDistribute, :mapped_mget
     end
 
-    # Set the value of a key, only if the key does not exist.
-    def setnx(key, value)
-      node_for(key).setnx(key, value)
-    end
-
-    # Set multiple keys to multiple values.
-    def mset(*args)
-      raise CannotDistribute, :mset
-    end
-
-    def mapped_mset(hash)
-      raise CannotDistribute, :mapped_mset
-    end
-
-    # Set multiple keys to multiple values, only if none of the keys exist.
-    def msetnx(*args)
-      raise CannotDistribute, :msetnx
+    # Overwrite part of a string at key starting at the specified offset.
+    def setrange(key, offset, value)
+      node_for(key).setrange(key, offset, value)
     end
 
-    def mapped_msetnx(hash)
-      raise CannotDistribute, :mapped_msetnx
+    # Get a substring of the string stored at a key.
+    def getrange(key, start, stop)
+      node_for(key).getrange(key, start, stop)
     end
 
-    # Increment the integer value of a key by one.
-    def incr(key)
-      node_for(key).incr(key)
+    # Sets or clears the bit at offset in the string value stored at key.
+    def setbit(key, offset, value)
+      node_for(key).setbit(key, offset, value)
     end
 
-    # Increment the integer value of a key by the given integer number.
-    def incrby(key, increment)
-      node_for(key).incrby(key, increment)
+    # Returns the bit value at offset in the string value stored at key.
+    def getbit(key, offset)
+      node_for(key).getbit(key, offset)
     end
 
-    # Increment the numeric value of a key by the given float number.
-    def incrbyfloat(key, increment)
-      node_for(key).incrbyfloat(key, increment)
+    # Append a value to a key.
+    def append(key, value)
+      node_for(key).append(key, value)
     end
 
-    # Decrement the integer value of a key by one.
-    def decr(key)
-      node_for(key).decr(key)
+    # Set the string value of a key and return its old value.
+    def getset(key, value)
+      node_for(key).getset(key, value)
     end
 
-    # Decrement the integer value of a key by the given number.
-    def decrby(key, decrement)
-      node_for(key).decrby(key, decrement)
+    # Get the length of the value stored in a key.
+    def strlen(key)
+      node_for(key).strlen(key)
     end
 
-    # Append one or more values to a list.
-    def rpush(key, value)
-      node_for(key).rpush(key, value)
+    def [](key)
+      get(key)
     end
 
-    # Prepend one or more values to a list.
-    def lpush(key, value)
-      node_for(key).lpush(key, value)
+    def []=(key,value)
+      set(key, value)
     end
 
     # Get the length of a list.
@@ -276,29 +315,24 @@ class Redis
       node_for(key).llen(key)
     end
 
-    # Get a range of elements from a list.
-    def lrange(key, start, stop)
-      node_for(key).lrange(key, start, stop)
-    end
-
-    # Trim a list to the specified range.
-    def ltrim(key, start, stop)
-      node_for(key).ltrim(key, start, stop)
+    # Prepend one or more values to a list.
+    def lpush(key, value)
+      node_for(key).lpush(key, value)
     end
 
-    # Get an element from a list by its index.
-    def lindex(key, index)
-      node_for(key).lindex(key, index)
+    # Prepend a value to a list, only if the list exists.
+    def lpushx(key, value)
+      node_for(key).lpushx(key, value)
     end
 
-    # Set the value of an element in a list by its index.
-    def lset(key, index, value)
-      node_for(key).lset(key, index, value)
+    # Append one or more values to a list.
+    def rpush(key, value)
+      node_for(key).rpush(key, value)
     end
 
-    # Remove elements from a list.
-    def lrem(key, count, value)
-      node_for(key).lrem(key, count, value)
+    # Append a value to a list, only if the list exists.
+    def rpushx(key, value)
+      node_for(key).rpushx(key, value)
     end
 
     # Remove and get the first element in a list.
@@ -367,6 +401,41 @@ class Redis
       end
     end
 
+    # Get an element from a list by its index.
+    def lindex(key, index)
+      node_for(key).lindex(key, index)
+    end
+
+    # Insert an element before or after another element in a list.
+    def linsert(key, where, pivot, value)
+      node_for(key).linsert(key, where, pivot, value)
+    end
+
+    # Get a range of elements from a list.
+    def lrange(key, start, stop)
+      node_for(key).lrange(key, start, stop)
+    end
+
+    # Remove elements from a list.
+    def lrem(key, count, value)
+      node_for(key).lrem(key, count, value)
+    end
+
+    # Set the value of an element in a list by its index.
+    def lset(key, index, value)
+      node_for(key).lset(key, index, value)
+    end
+
+    # Trim a list to the specified range.
+    def ltrim(key, start, stop)
+      node_for(key).ltrim(key, start, stop)
+    end
+
+    # Get the number of members in a set.
+    def scard(key)
+      node_for(key).scard(key)
+    end
+
     # Add one or more members to a set.
     def sadd(key, member)
       node_for(key).sadd(key, member)
@@ -382,6 +451,11 @@ class Redis
       node_for(key).spop(key)
     end
 
+    # Get a random member from a set.
+    def srandmember(key)
+      node_for(key).srandmember(key)
+    end
+
     # Move a member from one set to another.
     def smove(source, destination, member)
       ensure_same_node(:smove, [source, destination]) do |node|
@@ -389,16 +463,30 @@ class Redis
       end
     end
 
-    # Get the number of members in a set.
-    def scard(key)
-      node_for(key).scard(key)
-    end
-
     # Determine if a given value is a member of a set.
     def sismember(key, member)
       node_for(key).sismember(key, member)
     end
 
+    # Get all the members in a set.
+    def smembers(key)
+      node_for(key).smembers(key)
+    end
+
+    # Subtract multiple sets.
+    def sdiff(*keys)
+      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|
+        node.sdiffstore(destination, *keys)
+      end
+    end
+
     # Intersect multiple sets.
     def sinter(*keys)
       ensure_same_node(:sinter, keys) do |node|
@@ -427,28 +515,9 @@ class Redis
       end
     end
 
-    # Subtract multiple sets.
-    def sdiff(*keys)
-      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|
-        node.sdiffstore(destination, *keys)
-      end
-    end
-
-    # Get all the members in a set.
-    def smembers(key)
-      node_for(key).smembers(key)
-    end
-
-    # Get a random member from a set.
-    def srandmember(key)
-      node_for(key).srandmember(key)
+    # Get the number of members in a sorted set.
+    def zcard(key)
+      node_for(key).zcard(key)
     end
 
     # Add one or more members to a sorted set, or update the score for members
@@ -457,14 +526,19 @@ class Redis
       node_for(key).zadd(key, *args)
     end
 
+    # Increment the score of a member in a sorted set.
+    def zincrby(key, increment, member)
+      node_for(key).zincrby(key, increment, member)
+    end
+
     # Remove one or more members from a sorted set.
     def zrem(key, member)
       node_for(key).zrem(key, member)
     end
 
-    # Increment the score of a member in a sorted set.
-    def zincrby(key, increment, member)
-      node_for(key).zincrby(key, increment, member)
+    # Get the score associated with the given member in a sorted set.
+    def zscore(key, member)
+      node_for(key).zscore(key, member)
     end
 
     # Return a range of members in a sorted set, by index.
@@ -472,6 +546,12 @@ class Redis
       node_for(key).zrange(key, start, stop, options)
     end
 
+    # Return a range of members in a sorted set, by index, with scores ordered
+    # from high to low.
+    def zrevrange(key, start, stop, options = {})
+      node_for(key).zrevrange(key, start, stop, options)
+    end
+
     # Determine the index of a member in a sorted set.
     def zrank(key, member)
       node_for(key).zrank(key, member)
@@ -483,17 +563,6 @@ class Redis
       node_for(key).zrevrank(key, member)
     end
 
-    # Return a range of members in a sorted set, by index, with scores ordered
-    # from high to low.
-    def zrevrange(key, start, stop, options = {})
-      node_for(key).zrevrange(key, start, stop, options)
-    end
-
-    # Remove all members in a sorted set within the given scores.
-    def zremrangebyscore(key, min, max)
-      node_for(key).zremrangebyscore(key, min, max)
-    end
-
     # Remove all members in a sorted set within the given indexes.
     def zremrangebyrank(key, start, stop)
       node_for(key).zremrangebyrank(key, start, stop)
@@ -510,9 +579,9 @@ class Redis
       node_for(key).zrevrangebyscore(key, max, min, options)
     end
 
-    # Get the number of members in a sorted set.
-    def zcard(key)
-      node_for(key).zcard(key)
+    # Remove all members in a sorted set within the given scores.
+    def zremrangebyscore(key, min, max)
+      node_for(key).zremrangebyscore(key, min, max)
     end
 
     # Get the number of members in a particular score range.
@@ -520,11 +589,6 @@ class Redis
       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)
-    end
-
     # Intersect multiple sorted sets and store the resulting sorted set in a new
     # key.
     def zinterstore(destination, keys, options = {})
@@ -540,6 +604,11 @@ class Redis
       end
     end
 
+    # Get the number of fields in a hash.
+    def hlen(key)
+      node_for(key).hlen(key)
+    end
+
     # Set the string value of a hash field.
     def hset(key, field, value)
       node_for(key).hset(key, field, value)
@@ -550,41 +619,6 @@ class Redis
       node_for(key).hsetnx(key, field, value)
     end
 
-    # Get the value of a hash field.
-    def hget(key, field)
-      node_for(key).hget(key, field)
-    end
-
-    # Delete one or more hash fields.
-    def hdel(key, field)
-      node_for(key).hdel(key, field)
-    end
-
-    # Determine if a hash field exists.
-    def hexists(key, field)
-      node_for(key).hexists(key, field)
-    end
-
-    # Get the number of fields in a hash.
-    def hlen(key)
-      node_for(key).hlen(key)
-    end
-
-    # Get all the fields in a hash.
-    def hkeys(key)
-      node_for(key).hkeys(key)
-    end
-
-    # Get all the values in a hash.
-    def hvals(key)
-      node_for(key).hvals(key)
-    end
-
-    # Get all the fields and values in a hash.
-    def hgetall(key)
-      node_for(key).hgetall(key)
-    end
-
     # Set multiple hash fields to multiple values.
     def hmset(key, *attrs)
       node_for(key).hmset(key, *attrs)
@@ -594,6 +628,11 @@ class Redis
       node_for(key).hmset(key, *hash.to_a.flatten)
     end
 
+    # Get the value of a hash field.
+    def hget(key, field)
+      node_for(key).hget(key, field)
+    end
+
     # Get the values of all the given hash fields.
     def hmget(key, *fields)
       node_for(key).hmget(key, *fields)
@@ -603,6 +642,16 @@ class Redis
       Hash[*fields.zip(hmget(key, *fields)).flatten]
     end
 
+    # Delete one or more hash fields.
+    def hdel(key, field)
+      node_for(key).hdel(key, field)
+    end
+
+    # Determine if a hash field exists.
+    def hexists(key, field)
+      node_for(key).hexists(key, field)
+    end
+
     # 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)
@@ -613,38 +662,19 @@ class Redis
       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|
-        node.sort(key, options)
-      end
-    end
-
-    # Mark the start of a transaction block.
-    def multi
-      raise CannotDistribute, :multi
-    end
-
-    # Watch the given keys to determine execution of the MULTI/EXEC block.
-    def watch(*keys)
-      raise CannotDistribute, :watch
-    end
-
-    # Forget about all watched keys.
-    def unwatch
-      raise CannotDistribute, :unwatch
+    # Get all the fields in a hash.
+    def hkeys(key)
+      node_for(key).hkeys(key)
     end
 
-    # Execute all commands issued after MULTI.
-    def exec
-      raise CannotDistribute, :exec
+    # Get all the values in a hash.
+    def hvals(key)
+      node_for(key).hvals(key)
     end
 
-    # Discard all commands issued after MULTI.
-    def discard
-      raise CannotDistribute, :discard
+    # Get all the fields and values in a hash.
+    def hgetall(key)
+      node_for(key).hgetall(key)
     end
 
     # Post a message to a channel.
@@ -656,12 +686,6 @@ class Redis
       !! @subscribed_node
     end
 
-    # Stop listening for messages posted to the given channels.
-    def unsubscribe(*channels)
-      raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
-      @subscribed_node.unsubscribe(*channels)
-    end
-
     # Listen for messages published to the given channels.
     def subscribe(channel, *channels, &block)
       if channels.empty?
@@ -675,54 +699,78 @@ class Redis
       end
     end
 
+    # Stop listening for messages posted to the given channels.
+    def unsubscribe(*channels)
+      raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
+      @subscribed_node.unsubscribe(*channels)
+    end
+
+    # Listen for messages published to channels matching the given patterns.
+    def psubscribe(*channels, &block)
+      raise NotImplementedError
+    end
+
     # Stop listening for messages posted to channels matching the given
     # patterns.
     def punsubscribe(*channels)
       raise NotImplementedError
     end
 
-    # Listen for messages published to channels matching the given patterns.
-    def psubscribe(*channels, &block)
-      raise NotImplementedError
+    # Watch the given keys to determine execution of the MULTI/EXEC block.
+    def watch(*keys)
+      raise CannotDistribute, :watch
     end
 
-    # Synchronously save the dataset to disk.
-    def save
-      on_each_node :save
+    # Forget about all watched keys.
+    def unwatch
+      raise CannotDistribute, :unwatch
     end
 
-    # Asynchronously save the dataset to disk.
-    def bgsave
-      on_each_node :bgsave
+    def pipelined
+      raise CannotDistribute, :pipelined
     end
 
-    # Get the UNIX time stamp of the last successful save to disk.
-    def lastsave
-      on_each_node :lastsave
+    # Mark the start of a transaction block.
+    def multi
+      raise CannotDistribute, :multi
     end
 
-    # Get information and statistics about the server.
-    def info(cmd = nil)
-      on_each_node :info, cmd
+    # Execute all commands issued after MULTI.
+    def exec
+      raise CannotDistribute, :exec
     end
 
-    # Listen for all requests received by the server in real time.
-    def monitor
-      raise NotImplementedError
+    # Discard all commands issued after MULTI.
+    def discard
+      raise CannotDistribute, :discard
     end
 
-    # Echo the given string.
-    def echo(value)
-      on_each_node :echo, value
+    # Control remote script registry.
+    def script(subcommand, *args)
+      on_each_node(:script, subcommand, *args)
     end
 
-    # Get server time: an UNIX timestamp and the elapsed microseconds in the current second.
-    def time
-      on_each_node :time
+    def _eval(cmd, args)
+      script = args.shift
+      options = args.pop if args.last.is_a?(Hash)
+      options ||= {}
+
+      keys = args.shift || options[:keys] || []
+      argv = args.shift || options[:argv] || []
+
+      ensure_same_node(cmd, keys) do |node|
+        node.send(cmd, script, keys, argv)
+      end
     end
 
-    def pipelined
-      raise CannotDistribute, :pipelined
+    # Evaluate Lua script.
+    def eval(*args)
+      _eval(:eval, args)
+    end
+
+    # Evaluate Lua script by its SHA.
+    def evalsha(*args)
+      _eval(:evalsha, args)
     end
 
     def inspect
@@ -746,9 +794,18 @@ class Redis
     end
 
     def ensure_same_node(command, keys)
-      tags = keys.map { |key| key_tag(key) }
+      all = true
+
+      tags = keys.map do |key|
+        tag = key_tag(key)
+        all = false unless tag
+        tag
+      end
 
-      raise CannotDistribute, command if !tags.all? || tags.uniq.size != 1
+      if (all && tags.uniq.size != 1) || (!all && keys.uniq.size != 1)
+        # Not 1 unique tag or not 1 unique key
+        raise CannotDistribute, command
+      end
 
       yield(node_for(keys.first))
     end