redis 2.1.1 → 2.2.0

data/lib/redis/client.rb

@@ -1,48 +1,104 @@
 class Redis
   class Client
-    attr_accessor :db, :host, :port, :password, :logger
+    attr_accessor :db, :host, :port, :path, :password, :logger
     attr :timeout
     attr :connection
 
     def initialize(options = {})
-      @host = options[:host] || "127.0.0.1"
-      @port = (options[:port] || 6379).to_i
+      @path = options[:path]
+      if @path.nil?
+        @host = options[:host] || "127.0.0.1"
+        @port = (options[:port] || 6379).to_i
+      end
+
       @db = (options[:db] || 0).to_i
-      @timeout = (options[:timeout] || 5).to_i
+      @timeout = (options[:timeout] || 5).to_f
       @password = options[:password]
       @logger = options[:logger]
-      @connection = Connection.new
+      @reconnect = true
+      @connection = Connection.drivers.last.new
     end
 
     def connect
-      connect_to(@host, @port)
+      establish_connection
       call(:auth, @password) if @password
       call(:select, @db) if @db != 0
       self
     end
 
     def id
-      "redis://#{host}:#{port}/#{db}"
+      "redis://#{location}/#{db}"
+    end
+
+    def location
+      @path || "#{@host}:#{@port}"
     end
 
     def call(*args)
-      process(args) do
-        read
-      end
+      reply = process(args) { read }
+      raise reply if reply.is_a?(RuntimeError)
+      reply
     end
 
     def call_loop(*args)
-      without_socket_timeout do
+      error = nil
+
+      result = without_socket_timeout do
         process(args) do
-          loop { yield(read) }
+          loop do
+            reply = read
+            if reply.is_a?(RuntimeError)
+              error = reply
+              break
+            else
+              yield reply
+            end
+          end
         end
       end
+
+      # Raise error when previous block broke out of the loop.
+      raise error if error
+
+      # Result is set to the value that the provided block used to break.
+      result
     end
 
-    def call_pipelined(commands)
-      process(*commands) do
-        Array.new(commands.size) { read }
+    def call_pipelined(commands, options = {})
+      options[:raise] = true unless options.has_key?(:raise)
+
+      # 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)
+
+      begin
+        remaining = commands.size - 1
+        if remaining > 0
+          replies = Array.new(remaining) do
+            reply = read
+            error ||= reply if reply.is_a?(RuntimeError)
+            reply
+          end
+          replies.unshift first
+          replies
+        else
+          replies = [first]
+        end
+      rescue Exception
+        disconnect
+        raise
       end
+
+      # Raise first error in pipeline when we should raise.
+      raise error if error && options[:raise]
+
+      replies
     end
 
     def call_without_timeout(*args)
@@ -106,6 +162,15 @@ class Redis
       end
     end
 
+    def without_reconnect
+      begin
+        original, @reconnect = @reconnect, false
+        yield
+      ensure
+        @reconnect = original
+      end
+    end
+
   protected
 
     def deprecated(old, new = nil, trace = caller[0])
@@ -129,9 +194,14 @@ class Redis
       end
     end
 
-    def connect_to(host, port)
-      with_timeout(@timeout) do
-        connection.connect(host, port)
+    def establish_connection
+      # Need timeout in usecs, like socket timeout.
+      timeout = Integer(@timeout * 1_000_000)
+
+      if @path
+        connection.connect_unix(@path, timeout)
+      else
+        connection.connect(@host, @port, timeout)
       end
 
       # If the timeout is set we set the low level socket options in order
@@ -140,7 +210,7 @@ class Redis
       self.timeout = @timeout
 
     rescue Errno::ECONNREFUSED
-      raise Errno::ECONNREFUSED, "Unable to connect to Redis on #{host}:#{port}"
+      raise Errno::ECONNREFUSED, "Unable to connect to Redis on #{location}"
     end
 
     def timeout=(timeout)
@@ -148,13 +218,18 @@ class Redis
     end
 
     def ensure_connected
-      connect unless connected?
+      tries = 0
 
       begin
+        connect unless connected?
+        tries += 1
+
         yield
-      rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF
-        if reconnect
-          yield
+      rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL
+        disconnect
+
+        if tries < 2 && @reconnect
+          retry
         else
           raise Errno::ECONNRESET
         end
@@ -163,39 +238,5 @@ class Redis
         raise
       end
     end
-
-    class ThreadSafe < self
-      def initialize(*args)
-        require "monitor"
-
-        super(*args)
-        @mutex = ::Monitor.new
-      end
-
-      def synchronize(&block)
-        @mutex.synchronize(&block)
-      end
-
-      def ensure_connected(&block)
-        synchronize { super }
-      end
-    end
-
-    begin
-      require "system_timer"
-
-      def with_timeout(seconds, &block)
-        SystemTimer.timeout_after(seconds, &block)
-      end
-
-    rescue LoadError
-      warn "WARNING: using the built-in Timeout class which is known to have issues when used for opening connections. Install the SystemTimer gem if you want to make sure the Redis client will not hang." unless RUBY_VERSION >= "1.9" || RUBY_PLATFORM =~ /java/
-
-      require "timeout"
-
-      def with_timeout(seconds, &block)
-        Timeout.timeout(seconds, &block)
-      end
-    end
   end
 end

data/lib/redis/connection.rb

@@ -1,134 +1,9 @@
-class Redis
-  class Connection
-    MINUS    = "-".freeze
-    PLUS     = "+".freeze
-    COLON    = ":".freeze
-    DOLLAR   = "$".freeze
-    ASTERISK = "*".freeze
-
-    def initialize
-      @sock = nil
-    end
-
-    def connected?
-      !! @sock
-    end
-
-    def connect(host, port)
-      @sock = TCPSocket.new(host, port)
-      @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
-    end
-
-    def disconnect
-      @sock.close
-    rescue
-    ensure
-      @sock = nil
-    end
-
-    def timeout=(usecs)
-      secs   = Integer(usecs / 1_000_000)
-      usecs  = Integer(usecs - (secs * 1_000_000)) # 0 - 999_999
-
-      optval = [secs, usecs].pack("l_2")
-
-      begin
-        @sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
-        @sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
-      rescue Errno::ENOPROTOOPT
-      end
-    end
-
-    COMMAND_DELIMITER = "\r\n"
-
-    def write(command)
-      @sock.write(build_command(*command).join(COMMAND_DELIMITER))
-      @sock.write(COMMAND_DELIMITER)
-    end
-
-    def build_command(name, *args)
-      command = []
-      command << "*#{args.size + 1}"
-      command << "$#{string_size name}"
-      command << name
-
-      args.each do |arg|
-        arg = arg.to_s
-        command << "$#{string_size arg}"
-        command << arg
-      end
-
-      command
-    end
-
-    def read
-      # We read the first byte using read() mainly because gets() is
-      # immune to raw socket timeouts.
-      reply_type = @sock.read(1)
-
-      raise Errno::ECONNRESET unless reply_type
-
-      format_reply(reply_type, @sock.gets)
-    end
-
-    def format_reply(reply_type, line)
-      case reply_type
-      when MINUS    then format_error_reply(line)
-      when PLUS     then format_status_reply(line)
-      when COLON    then format_integer_reply(line)
-      when DOLLAR   then format_bulk_reply(line)
-      when ASTERISK then format_multi_bulk_reply(line)
-      else raise ProtocolError.new(reply_type)
-      end
-    end
-
-    def format_error_reply(line)
-      raise "-" + line.strip
-    end
-
-    def format_status_reply(line)
-      line.strip
-    end
-
-    def format_integer_reply(line)
-      line.to_i
-    end
-
-    def format_bulk_reply(line)
-      bulklen = line.to_i
-      return if bulklen == -1
-      reply = encode(@sock.read(bulklen))
-      @sock.read(2) # Discard CRLF.
-      reply
-    end
-
-    def format_multi_bulk_reply(line)
-      n = line.to_i
-      return if n == -1
-
-      Array.new(n) { read }
-    end
-
-  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)
-      end
-    else
-      def encode(string)
-        string
-      end
-    end
-  end
-end
+require "redis/connection/registry"
+
+# If a connection driver was required before this file, the array
+# Redis::Connection.drivers will contain one or more classes. The last driver
+# in this array will be used as default driver. If this array is empty, we load
+# the plain Ruby driver as our default. Another driver can be required at a
+# later point in time, causing it to be the last element of the #drivers array
+# and therefore be chosen by default.
+require "redis/connection/ruby" if Redis::Connection.drivers.empty?

data/lib/redis/connection/command_helper.rb

@@ -0,0 +1,45 @@
+class Redis
+  module Connection
+    module CommandHelper
+
+      COMMAND_DELIMITER = "\r\n"
+
+      def build_command(*args)
+        command = []
+        command << "*#{args.size}"
+
+        args.each do |arg|
+          arg = arg.to_s
+          command << "$#{string_size arg}"
+          command << arg
+        end
+
+        # Trailing delimiter
+        command << ""
+        command
+      end
+
+    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)
+        end
+      else
+        def encode(string)
+          string
+        end
+      end
+    end
+  end
+end

data/lib/redis/connection/hiredis.rb

@@ -0,0 +1,49 @@
+require "redis/connection/registry"
+require "hiredis/connection"
+require "timeout"
+
+class Redis
+  module Connection
+    class Hiredis
+      def initialize
+        @connection = ::Hiredis::Connection.new
+      end
+
+      def connected?
+        @connection.connected?
+      end
+
+      def timeout=(usecs)
+        @connection.timeout = usecs
+      end
+
+      def connect(host, port, timeout)
+        @connection.connect(host, port, timeout)
+      rescue Errno::ETIMEDOUT
+        raise Timeout::Error
+      end
+
+      def connect_unix(path, timeout)
+        @connection.connect_unix(path, timeout)
+      rescue Errno::ETIMEDOUT
+        raise Timeout::Error
+      end
+
+      def disconnect
+        @connection.disconnect
+      end
+
+      def write(command)
+        @connection.write(command)
+      end
+
+      def read
+        @connection.read
+      rescue RuntimeError => err
+        raise ::Redis::ProtocolError.new(err.message)
+      end
+    end
+  end
+end
+
+Redis::Connection.drivers << Redis::Connection::Hiredis