redis 2.1.1 → 2.2.0

data/examples/unicorn/config.ru

@@ -0,0 +1,3 @@
+run lambda { |env|
+  [200, {"Content-Type" => "text/plain"}, [$redis.randomkey]]
+}

data/examples/unicorn/unicorn.rb

@@ -0,0 +1,20 @@
+require "redis"
+
+worker_processes 3
+
+# If you set the connection to Redis *before* forking,
+# you will cause forks to share a file descriptor.
+#
+# This causes a concurrency problem by which one fork
+# can read or write to the socket while others are
+# performing other operations.
+#
+# Most likely you'll be getting ProtocolError exceptions
+# mentioning a wrong initial byte in the reply.
+#
+# Thus we need to connect to Redis after forking the
+# worker processes.
+
+after_fork do |server, worker|
+  $redis = Redis.connect
+end

data/lib/redis.rb

@@ -1,8 +1,6 @@
-require 'socket'
+require "monitor"
 
 class Redis
-  VERSION = "2.1.1"
-
   class ProtocolError < RuntimeError
     def initialize(reply_type)
       super(<<-EOS.gsub(/(?:^|\n)\s*/, " "))
@@ -15,6 +13,12 @@ class Redis
     end
   end
 
+  module DisableThreadSafety
+    def synchronize
+      yield
+    end
+  end
+
   def self.deprecate(message, trace = caller[0])
     $stderr.puts "\n#{message} (in #{trace})"
   end
@@ -44,414 +48,770 @@ class Redis
     Thread.current[:redis] = redis
   end
 
+  include MonitorMixin
+
   def initialize(options = {})
-    if options[:thread_safe]
-      @client = Client::ThreadSafe.new(options)
+    @client = Client.new(options)
+
+    if options[:thread_safe] == false
+      # Override #synchronize
+      extend DisableThreadSafety
     else
-      @client = Client.new(options)
+      # Monitor#initialize
+      super()
     end
   end
 
+  # Run code without the client reconnecting
+  def without_reconnect(&block)
+    synchronize do
+      @client.without_reconnect(&block)
+    end
+  end
+
+  # Authenticate to the server.
   def auth(password)
-    @client.call(:auth, password)
+    synchronize do
+      @client.call(:auth, password)
+    end
   end
 
+  # Change the selected database for the current connection.
   def select(db)
-    @client.db = db
-    @client.call(:select, db)
+    synchronize do
+      @client.db = db
+      @client.call(:select, db)
+    end
   end
 
+  # Get information and statistics about the server.
   def info
-    Hash[*@client.call(:info).split(/:|\r\n/)]
+    synchronize do
+      reply = @client.call(:info)
+
+      if reply.kind_of?(String)
+        Hash[*reply.split(/:|\r\n/).grep(/^[^#]/)]
+      else
+        reply
+      end
+    end
   end
 
   def config(action, *args)
-    response = @client.call(:config, action, *args)
-    response = Hash[*response] if action == :get
-    response
+    synchronize do
+      reply = @client.call(:config, action, *args)
+
+      if reply.kind_of?(Array) && action == :get
+        Hash[*reply]
+      else
+        reply
+      end
+    end
   end
 
+  # Remove all keys from the current database.
   def flushdb
-    @client.call(:flushdb)
+    synchronize do
+      @client.call(:flushdb)
+    end
   end
 
+  # Remove all keys from all databases.
   def flushall
-    @client.call(:flushall)
+    synchronize do
+      @client.call(:flushall)
+    end
   end
 
+  # Synchronously save the dataset to disk.
   def save
-    @client.call(:save)
+    synchronize do
+      @client.call(:save)
+    end
   end
 
+  # Asynchronously save the dataset to disk.
   def bgsave
-    @client.call(:bgsave)
+    synchronize do
+      @client.call(:bgsave)
+    end
   end
 
+  # Asynchronously rewrite the append-only file.
   def bgrewriteaof
-    @client.call(:bgrewriteaof)
+    synchronize do
+      @client.call(:bgrewriteaof)
+    end
   end
 
+  # Get the value of a key.
   def get(key)
-    @client.call(:get, key)
+    synchronize do
+      @client.call(:get, key)
+    end
   end
 
+  # Returns the bit value at offset in the string value stored at key.
+  def getbit(key, offset)
+    synchronize do
+      @client.call(:getbit, key, offset)
+    end
+  end
+
+  # Get a substring of the string stored at a key.
+  def getrange(key, start, stop)
+    synchronize do
+      @client.call(:getrange, key, start, stop)
+    end
+  end
+
+  # Set the string value of a key and return its old value.
   def getset(key, value)
-    @client.call(:getset, key, value)
+    synchronize do
+      @client.call(:getset, key, value)
+    end
   end
 
+  # Get the values of all the given keys.
   def mget(*keys)
-    @client.call(:mget, *keys)
+    synchronize do
+      @client.call(:mget, *keys)
+    end
   end
 
+  # Append a value to a key.
   def append(key, value)
-    @client.call(:append, key, value)
+    synchronize do
+      @client.call(:append, key, value)
+    end
   end
 
   def substr(key, start, stop)
-    @client.call(:substr, key, start, stop)
+    synchronize do
+      @client.call(:substr, key, start, stop)
+    end
   end
 
+  # Get the length of the value stored in a key.
   def strlen(key)
-    @client.call(:strlen, key)
+    synchronize do
+      @client.call(:strlen, key)
+    end
   end
 
+  # Get all the fields and values in a hash.
   def hgetall(key)
-    Hash[*@client.call(:hgetall, key)]
+    synchronize do
+      reply = @client.call(:hgetall, key)
+
+      if reply.kind_of?(Array)
+        Hash[*reply]
+      else
+        reply
+      end
+    end
   end
 
+  # Get the value of a hash field.
   def hget(key, field)
-    @client.call(:hget, key, field)
+    synchronize do
+      @client.call(:hget, key, field)
+    end
   end
 
+  # Delete a hash field.
   def hdel(key, field)
-    @client.call(:hdel, key, field)
+    synchronize do
+      @client.call(:hdel, key, field)
+    end
   end
 
+  # Get all the fields in a hash.
   def hkeys(key)
-    @client.call(:hkeys, key)
+    synchronize do
+      @client.call(:hkeys, key)
+    end
   end
 
+  # Find all keys matching the given pattern.
   def keys(pattern = "*")
-    _array @client.call(:keys, pattern)
+    synchronize do
+      reply = @client.call(:keys, pattern)
+
+      if reply.kind_of?(String)
+        reply.split(" ")
+      else
+        reply
+      end
+    end
   end
 
+  # Return a random key from the keyspace.
   def randomkey
-    @client.call(:randomkey)
+    synchronize do
+      @client.call(:randomkey)
+    end
   end
 
+  # Echo the given string.
   def echo(value)
-    @client.call(:echo, value)
+    synchronize do
+      @client.call(:echo, value)
+    end
   end
 
+  # Ping the server.
   def ping
-    @client.call(:ping)
+    synchronize do
+      @client.call(:ping)
+    end
   end
 
+  # Get the UNIX time stamp of the last successful save to disk.
   def lastsave
-    @client.call(:lastsave)
+    synchronize do
+      @client.call(:lastsave)
+    end
   end
 
+  # Return the number of keys in the selected database.
   def dbsize
-    @client.call(:dbsize)
+    synchronize do
+      @client.call(:dbsize)
+    end
   end
 
+  # Determine if a key exists.
   def exists(key)
-    _bool @client.call(:exists, key)
+    synchronize do
+      _bool @client.call(:exists, key)
+    end
   end
 
+  # Get the length of a list.
   def llen(key)
-    @client.call(:llen, key)
+    synchronize do
+      @client.call(:llen, key)
+    end
   end
 
+  # Get a range of elements from a list.
   def lrange(key, start, stop)
-    @client.call(:lrange, key, start, stop)
+    synchronize do
+      @client.call(:lrange, key, start, stop)
+    end
   end
 
+  # Trim a list to the specified range.
   def ltrim(key, start, stop)
-    @client.call(:ltrim, key, start, stop)
+    synchronize do
+      @client.call(:ltrim, key, start, stop)
+    end
   end
 
+  # Get an element from a list by its index.
   def lindex(key, index)
-    @client.call(:lindex, key, index)
+    synchronize do
+      @client.call(:lindex, key, index)
+    end
   end
 
+  # Insert an element before or after another element in a list.
   def linsert(key, where, pivot, value)
-    @client.call(:linsert, key, where, pivot, value)
+    synchronize do
+      @client.call(:linsert, key, where, pivot, value)
+    end
   end
 
+  # Set the value of an element in a list by its index.
   def lset(key, index, value)
-    @client.call(:lset, key, index, value)
+    synchronize do
+      @client.call(:lset, key, index, value)
+    end
   end
 
+  # Remove elements from a list.
   def lrem(key, count, value)
-    @client.call(:lrem, key, count, value)
+    synchronize do
+      @client.call(:lrem, key, count, value)
+    end
   end
 
+  # Append a value to a list.
   def rpush(key, value)
-    @client.call(:rpush, key, value)
+    synchronize do
+      @client.call(:rpush, key, value)
+    end
   end
 
+  # Append a value to a list, only if the list exists.
   def rpushx(key, value)
-    @client.call(:rpushx, key, value)
+    synchronize do
+      @client.call(:rpushx, key, value)
+    end
   end
 
+  # Prepend a value to a list.
   def lpush(key, value)
-    @client.call(:lpush, key, value)
+    synchronize do
+      @client.call(:lpush, key, value)
+    end
   end
 
+  # Prepend a value to a list, only if the list exists.
   def lpushx(key, value)
-    @client.call(:lpushx, key, value)
+    synchronize do
+      @client.call(:lpushx, key, value)
+    end
   end
 
+  # Remove and get the last element in a list.
   def rpop(key)
-    @client.call(:rpop, key)
+    synchronize do
+      @client.call(:rpop, key)
+    end
   end
 
+  # Remove and get the first element in a list, or block until one is available.
   def blpop(*args)
-    @client.call_without_timeout(:blpop, *args)
+    synchronize do
+      @client.call_without_timeout(:blpop, *args)
+    end
   end
 
+  # Remove and get the last element in a list, or block until one is available.
   def brpop(*args)
-    @client.call_without_timeout(:brpop, *args)
+    synchronize do
+      @client.call_without_timeout(:brpop, *args)
+    end
+  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)
+    synchronize do
+      @client.call_without_timeout(:brpoplpush, source, destination, timeout)
+    end
   end
 
+  # Remove the last element in a list, append it to another list and return it.
   def rpoplpush(source, destination)
-    @client.call(:rpoplpush, source, destination)
+    synchronize do
+      @client.call(:rpoplpush, source, destination)
+    end
   end
 
+  # Remove and get the first element in a list.
   def lpop(key)
-    @client.call(:lpop, key)
+    synchronize do
+      @client.call(:lpop, key)
+    end
   end
 
+  # Get all the members in a set.
   def smembers(key)
-    @client.call(:smembers, key)
+    synchronize do
+      @client.call(:smembers, key)
+    end
   end
 
+  # Determine if a given value is a member of a set.
   def sismember(key, member)
-    _bool @client.call(:sismember, key, member)
+    synchronize do
+      _bool @client.call(:sismember, key, member)
+    end
   end
 
+  # Add a member to a set.
   def sadd(key, value)
-    _bool @client.call(:sadd, key, value)
+    synchronize do
+      _bool @client.call(:sadd, key, value)
+    end
   end
 
+  # Remove a member from a set.
   def srem(key, value)
-    _bool @client.call(:srem, key, value)
+    synchronize do
+      _bool @client.call(:srem, key, value)
+    end
   end
 
+  # Move a member from one set to another.
   def smove(source, destination, member)
-    _bool @client.call(:smove, source, destination, member)
+    synchronize do
+      _bool @client.call(:smove, source, destination, member)
+    end
   end
 
+  # Remove and return a random member from a set.
   def spop(key)
-    @client.call(:spop, key)
+    synchronize do
+      @client.call(:spop, key)
+    end
   end
 
+  # Get the number of members in a set.
   def scard(key)
-    @client.call(:scard, key)
+    synchronize do
+      @client.call(:scard, key)
+    end
   end
 
+  # Intersect multiple sets.
   def sinter(*keys)
-    @client.call(:sinter, *keys)
+    synchronize do
+      @client.call(:sinter, *keys)
+    end
   end
 
+  # Intersect multiple sets and store the resulting set in a key.
   def sinterstore(destination, *keys)
-    @client.call(:sinterstore, destination, *keys)
+    synchronize do
+      @client.call(:sinterstore, destination, *keys)
+    end
   end
 
+  # Add multiple sets.
   def sunion(*keys)
-    @client.call(:sunion, *keys)
+    synchronize do
+      @client.call(:sunion, *keys)
+    end
   end
 
+  # Add multiple sets and store the resulting set in a key.
   def sunionstore(destination, *keys)
-    @client.call(:sunionstore, destination, *keys)
+    synchronize do
+      @client.call(:sunionstore, destination, *keys)
+    end
   end
 
+  # Subtract multiple sets.
   def sdiff(*keys)
-    @client.call(:sdiff, *keys)
+    synchronize do
+      @client.call(:sdiff, *keys)
+    end
   end
 
+  # Subtract multiple sets and store the resulting set in a key.
   def sdiffstore(destination, *keys)
-    @client.call(:sdiffstore, destination, *keys)
+    synchronize do
+      @client.call(:sdiffstore, destination, *keys)
+    end
   end
 
+  # Get a random member from a set.
   def srandmember(key)
-    @client.call(:srandmember, key)
+    synchronize do
+      @client.call(:srandmember, key)
+    end
   end
 
+  # Add a member to a sorted set, or update its score if it already exists.
   def zadd(key, score, member)
-    _bool @client.call(:zadd, key, score, member)
+    synchronize do
+      _bool @client.call(:zadd, key, score, member)
+    end
   end
 
+  # Determine the index of a member in a sorted set.
   def zrank(key, member)
-    @client.call(:zrank, key, member)
+    synchronize do
+      @client.call(:zrank, key, member)
+    end
   end
 
+  # Determine the index of a member in a sorted set, with scores ordered from
+  # high to low.
   def zrevrank(key, member)
-    @client.call(:zrevrank, key, member)
+    synchronize do
+      @client.call(:zrevrank, key, member)
+    end
   end
 
+  # Increment the score of a member in a sorted set.
   def zincrby(key, increment, member)
-    @client.call(:zincrby, key, increment, member)
+    synchronize do
+      @client.call(:zincrby, key, increment, member)
+    end
   end
 
+  # Get the number of members in a sorted set.
   def zcard(key)
-    @client.call(:zcard, key)
+    synchronize do
+      @client.call(:zcard, key)
+    end
   end
 
+  # Return a range of members in a sorted set, by index.
   def zrange(key, start, stop, options = {})
     command = CommandOptions.new(options) do |c|
+      c.bool :withscores
       c.bool :with_scores
     end
 
-    @client.call(:zrange, key, start, stop, *command.to_a)
+    synchronize do
+      @client.call(:zrange, key, start, stop, *command.to_a)
+    end
   end
 
+  # Return a range of members in a sorted set, by score.
   def zrangebyscore(key, min, max, options = {})
     command = CommandOptions.new(options) do |c|
       c.splat :limit
+      c.bool  :withscores
       c.bool  :with_scores
     end
 
-    @client.call(:zrangebyscore, key, min, max, *command.to_a)
+    synchronize do
+      @client.call(:zrangebyscore, key, min, max, *command.to_a)
+    end
   end
 
+  # Count the members in a sorted set with scores within the given values.
   def zcount(key, start, stop)
-    @client.call(:zcount, key, start, stop)
+    synchronize do
+      @client.call(:zcount, key, start, stop)
+    end
   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 = {})
     command = CommandOptions.new(options) do |c|
+      c.bool :withscores
       c.bool :with_scores
     end
 
-    @client.call(:zrevrange, key, start, stop, *command.to_a)
+    synchronize do
+      @client.call(:zrevrange, key, start, stop, *command.to_a)
+    end
   end
 
+  # Return a range of members in a sorted set, by score, with scores ordered
+  # from high to low.
+  def zrevrangebyscore(key, max, min, options = {})
+    command = CommandOptions.new(options) do |c|
+      c.splat :limit
+      c.bool  :withscores
+      c.bool  :with_scores
+    end
+
+    synchronize do
+      @client.call(:zrevrangebyscore, key, max, min, *command.to_a)
+    end
+  end
+
+  # Remove all members in a sorted set within the given scores.
   def zremrangebyscore(key, min, max)
-    @client.call(:zremrangebyscore, key, min, max)
+    synchronize do
+      @client.call(:zremrangebyscore, key, min, max)
+    end
   end
 
+  # Remove all members in a sorted set within the given indexes.
   def zremrangebyrank(key, start, stop)
-    @client.call(:zremrangebyrank, key, start, stop)
+    synchronize do
+      @client.call(:zremrangebyrank, key, start, stop)
+    end
   end
 
+  # Get the score associated with the given member in a sorted set.
   def zscore(key, member)
-    @client.call(:zscore, key, member)
+    synchronize do
+      @client.call(:zscore, key, member)
+    end
   end
 
+  # Remove a member from a sorted set.
   def zrem(key, member)
-    _bool @client.call(:zrem, key, member)
+    synchronize do
+      _bool @client.call(:zrem, key, member)
+    end
   end
 
+  # Intersect multiple sorted sets and store the resulting sorted set in a new
+  # key.
   def zinterstore(destination, keys, options = {})
     command = CommandOptions.new(options) do |c|
       c.splat :weights
       c.value :aggregate
     end
 
-    @client.call(:zinterstore, destination, keys.size, *(keys + command.to_a))
+    synchronize do
+      @client.call(:zinterstore, destination, keys.size, *(keys + command.to_a))
+    end
   end
 
+  # Add multiple sorted sets and store the resulting sorted set in a new key.
   def zunionstore(destination, keys, options = {})
     command = CommandOptions.new(options) do |c|
       c.splat :weights
       c.value :aggregate
     end
 
-    @client.call(:zunionstore, destination, keys.size, *(keys + command.to_a))
+    synchronize do
+      @client.call(:zunionstore, destination, keys.size, *(keys + command.to_a))
+    end
   end
 
+  # Move a key to another database.
   def move(key, db)
-    _bool @client.call(:move, key, db)
+    synchronize do
+      _bool @client.call(:move, key, db)
+    end
   end
 
+  # Set the value of a key, only if the key does not exist.
   def setnx(key, value)
-    _bool @client.call(:setnx, key, value)
+    synchronize do
+      _bool @client.call(:setnx, key, value)
+    end
   end
 
+  # Delete a key.
   def del(*keys)
-    @client.call(:del, *keys)
+    synchronize do
+      @client.call(:del, *keys)
+    end
   end
 
+  # Rename a key.
   def rename(old_name, new_name)
-    @client.call(:rename, old_name, new_name)
+    synchronize do
+      @client.call(:rename, old_name, new_name)
+    end
   end
 
+  # Rename a key, only if the new key does not exist.
   def renamenx(old_name, new_name)
-    _bool @client.call(:renamenx, old_name, new_name)
+    synchronize do
+      _bool @client.call(:renamenx, old_name, new_name)
+    end
   end
 
+  # Set a key's time to live in seconds.
   def expire(key, seconds)
-    _bool @client.call(:expire, key, seconds)
+    synchronize do
+      _bool @client.call(:expire, key, seconds)
+    end
   end
 
+  # Remove the expiration from a key.
   def persist(key)
-    _bool @client.call(:persist, key)
+    synchronize do
+      _bool @client.call(:persist, key)
+    end
   end
 
+  # Get the time to live for a key.
   def ttl(key)
-    @client.call(:ttl, key)
+    synchronize do
+      @client.call(:ttl, key)
+    end
   end
 
+  # Set the expiration for a key as a UNIX timestamp.
   def expireat(key, unix_time)
-    _bool @client.call(:expireat, key, unix_time)
+    synchronize do
+      _bool @client.call(:expireat, key, unix_time)
+    end
   end
 
+  # Set the string value of a hash field.
   def hset(key, field, value)
-    _bool @client.call(:hset, key, field, value)
+    synchronize do
+      _bool @client.call(:hset, key, field, value)
+    end
   end
 
+  # Set the value of a hash field, only if the field does not exist.
   def hsetnx(key, field, value)
-    _bool @client.call(:hsetnx, key, field, value)
+    synchronize do
+      _bool @client.call(:hsetnx, key, field, value)
+    end
   end
 
+  # Set multiple hash fields to multiple values.
   def hmset(key, *attrs)
-    @client.call(:hmset, key, *attrs)
+    synchronize do
+      @client.call(:hmset, key, *attrs)
+    end
   end
 
   def mapped_hmset(key, hash)
     hmset(key, *hash.to_a.flatten)
   end
 
+  # Get the values of all the given hash fields.
   def hmget(key, *fields)
-    @client.call(:hmget, key, *fields)
+    synchronize do
+      @client.call(:hmget, key, *fields)
+    end
   end
 
   def mapped_hmget(key, *fields)
-    Hash[*fields.zip(hmget(key, *fields)).flatten]
+    reply = hmget(key, *fields)
+
+    if reply.kind_of?(Array)
+      Hash[*fields.zip(reply).flatten]
+    else
+      reply
+    end
   end
 
+  # Get the number of fields in a hash.
   def hlen(key)
-    @client.call(:hlen, key)
+    synchronize do
+      @client.call(:hlen, key)
+    end
   end
 
+  # Get all the values in a hash.
   def hvals(key)
-    @client.call(:hvals, key)
+    synchronize do
+      @client.call(:hvals, key)
+    end
   end
 
+  # Increment the integer value of a hash field by the given number.
   def hincrby(key, field, increment)
-    @client.call(:hincrby, key, field, increment)
+    synchronize do
+      @client.call(:hincrby, key, field, increment)
+    end
   end
 
+  # Discard all commands issued after MULTI.
   def discard
-    @client.call(:discard)
+    synchronize do
+      @client.call(:discard)
+    end
   end
 
+  # Determine if a hash field exists.
   def hexists(key, field)
-    _bool @client.call(:hexists, key, field)
+    synchronize do
+      _bool @client.call(:hexists, key, field)
+    end
   end
 
+  # Listen for all requests received by the server in real time.
   def monitor(&block)
-    @client.call_loop(:monitor, &block)
+    synchronize do
+      @client.call_loop(:monitor, &block)
+    end
   end
 
   def debug(*args)
-    @client.call(:debug, *args)
+    synchronize do
+      @client.call(:debug, *args)
+    end
   end
 
+  # Internal command used for replication.
   def sync
-    @client.call(:sync)
+    synchronize do
+      @client.call(:sync)
+    end
   end
 
   def [](key)
@@ -462,24 +822,50 @@ class Redis
     set(key, value)
   end
 
+  # Set the string value of a key.
   def set(key, value)
-    @client.call(:set, key, value)
+    synchronize do
+      @client.call(:set, key, value)
+    end
   end
 
+  # Sets or clears the bit at offset in the string value stored at key.
+  def setbit(key, offset, value)
+    synchronize do
+      @client.call(:setbit, key, offset, value)
+    end
+  end
+
+  # Set the value and expiration of a key.
   def setex(key, ttl, value)
-    @client.call(:setex, key, ttl, value)
+    synchronize do
+      @client.call(:setex, key, ttl, value)
+    end
+  end
+
+  # Overwrite part of a string at key starting at the specified offset.
+  def setrange(key, offset, value)
+    synchronize do
+      @client.call(:setrange, key, offset, value)
+    end
   end
 
+  # Set multiple keys to multiple values.
   def mset(*args)
-    @client.call(:mset, *args)
+    synchronize do
+      @client.call(:mset, *args)
+    end
   end
 
   def mapped_mset(hash)
     mset(*hash.to_a.flatten)
   end
 
+  # Set multiple keys to multiple values, only if none of the keys exist.
   def msetnx(*args)
-    @client.call(:msetnx, *args)
+    synchronize do
+      @client.call(:msetnx, *args)
+    end
   end
 
   def mapped_msetnx(hash)
@@ -487,9 +873,16 @@ class Redis
   end
 
   def mapped_mget(*keys)
-    Hash[*keys.zip(mget(*keys)).flatten]
+    reply = mget(*keys)
+
+    if reply.kind_of?(Array)
+      Hash[*keys.zip(reply).flatten]
+    else
+      reply
+    end
   end
 
+  # Sort the elements in a list, set or sorted set.
   def sort(key, options = {})
     command = CommandOptions.new(options) do |c|
       c.value :by
@@ -499,115 +892,181 @@ class Redis
       c.value :store
     end
 
-    @client.call(:sort, key, *command.to_a)
+    synchronize do
+      @client.call(:sort, key, *command.to_a)
+    end
   end
 
+  # Increment the integer value of a key by one.
   def incr(key)
-    @client.call(:incr, key)
+    synchronize do
+      @client.call(:incr, key)
+    end
   end
 
+  # Increment the integer value of a key by the given number.
   def incrby(key, increment)
-    @client.call(:incrby, key, increment)
+    synchronize do
+      @client.call(:incrby, key, increment)
+    end
   end
 
+  # Decrement the integer value of a key by one.
   def decr(key)
-    @client.call(:decr, key)
+    synchronize do
+      @client.call(:decr, key)
+    end
   end
 
+  # Decrement the integer value of a key by the given number.
   def decrby(key, decrement)
-    @client.call(:decrby, key, decrement)
+    synchronize do
+      @client.call(:decrby, key, decrement)
+    end
   end
 
+  # Determine the type stored at key.
   def type(key)
-    @client.call(:type, key)
+    synchronize do
+      @client.call(:type, key)
+    end
   end
 
+  # Close the connection.
   def quit
-    @client.call(:quit)
-  rescue Errno::ECONNRESET
-  ensure
-    @client.disconnect
+    synchronize do
+      begin
+        @client.call(:quit)
+      rescue Errno::ECONNRESET
+      ensure
+        @client.disconnect
+      end
+    end
   end
 
+  # Synchronously save the dataset to disk and then shut down the server.
   def shutdown
-    @client.call(:shutdown)
+    synchronize do
+      @client.call(:shutdown)
+    end
   end
 
+  # Make the server a slave of another instance, or promote it as master.
   def slaveof(host, port)
-    @client.call(:slaveof, host, port)
+    synchronize do
+      @client.call(:slaveof, host, port)
+    end
   end
 
-  def pipelined
-    original, @client = @client, Pipeline.new
-    yield
-    original.call_pipelined(@client.commands) unless @client.commands.empty?
-  ensure
-    @client = original
+  def pipelined(options = {})
+    synchronize do
+      begin
+        original, @client = @client, Pipeline.new
+        yield
+        original.call_pipelined(@client.commands, options) unless @client.commands.empty?
+      ensure
+        @client = original
+      end
+    end
   end
 
+  # Watch the given keys to determine execution of the MULTI/EXEC block.
   def watch(*keys)
-    @client.call(:watch, *keys)
+    synchronize do
+      @client.call(:watch, *keys)
+    end
   end
 
+  # Forget about all watched keys.
   def unwatch
-    @client.call(:unwatch)
+    synchronize do
+      @client.call(:unwatch)
+    end
   end
 
+  # Execute all commands issued after MULTI.
   def exec
-    @client.call(:exec)
+    synchronize do
+      @client.call(:exec)
+    end
   end
 
-  def multi(&block)
-    result = @client.call :multi
-
-    return result unless block_given?
-
-    begin
-      yield(self)
-    rescue Exception => e
-      discard
-      raise e
+  # Mark the start of a transaction block.
+  def multi
+    synchronize do
+      if !block_given?
+        @client.call :multi
+      else
+        result = pipelined(:raise => false) do
+          multi
+          yield(self)
+          exec
+        end
+
+        result.last
+      end
     end
-
-    exec
   end
 
+  # Post a message to a channel.
   def publish(channel, message)
-    @client.call(:publish, channel, message)
+    synchronize do
+      @client.call(:publish, channel, message)
+    end
   end
 
   def subscribed?
-    @client.kind_of? SubscribedClient
+    synchronize do
+      @client.kind_of? SubscribedClient
+    end
   end
 
+  # Stop listening for messages posted to the given channels.
   def unsubscribe(*channels)
-    raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
-    @client.unsubscribe(*channels)
+    synchronize do
+      raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
+      @client.unsubscribe(*channels)
+    end
   end
 
+  # Stop listening for messages posted to channels matching the given patterns.
   def punsubscribe(*channels)
-    raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
-    @client.punsubscribe(*channels)
+    synchronize do
+      raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
+      @client.punsubscribe(*channels)
+    end
   end
 
+  # Listen for messages published to the given channels.
   def subscribe(*channels, &block)
-    subscription(:subscribe, channels, block)
+    synchronize do
+      subscription(:subscribe, channels, block)
+    end
   end
 
+  # Listen for messages published to channels matching the given patterns.
   def psubscribe(*channels, &block)
-    subscription(:psubscribe, channels, block)
+    synchronize do
+      subscription(:psubscribe, channels, block)
+    end
   end
 
   def id
-    @client.id
+    synchronize do
+      @client.id
+    end
   end
 
   def inspect
-    "#<Redis client v#{Redis::VERSION} connected to #{id} (Redis v#{info["redis_version"]})>"
+    synchronize do
+      "#<Redis client v#{Redis::VERSION} connected to #{id} (Redis v#{info["redis_version"]})>"
+    end
   end
 
   def method_missing(command, *args)
-    @client.call(command, *args)
+    synchronize do
+      @client.call(command, *args)
+    end
   end
 
   class CommandOptions
@@ -652,10 +1111,6 @@ private
     value == 1
   end
 
-  def _array(value)
-    value.kind_of?(Array) ? value : value.split(" ")
-  end
-
   def subscription(method, channels, block)
     return @client.call(method, *channels) if subscribed?
 
@@ -669,7 +1124,8 @@ private
 
 end
 
-require "redis/connection" unless defined?(Redis::Connection)
+require "redis/version"
+require "redis/connection"
 require "redis/client"
 require "redis/pipeline"
 require "redis/subscribe"