redis 3.0.0.rc1 → 3.0.0.rc2

data/lib/redis/client.rb

@@ -2,40 +2,76 @@ require "redis/errors"
 
 class Redis
   class Client
-    attr_accessor :db, :host, :port, :path, :password, :logger
-    attr :timeout
+
+    DEFAULTS = {
+      :scheme => "redis",
+      :host => "127.0.0.1",
+      :port => 6379,
+      :path => nil,
+      :timeout => 5.0,
+      :password => nil,
+      :db => 0,
+    }
+
+    def scheme
+      @options[:scheme]
+    end
+
+    def host
+      @options[:host]
+    end
+
+    def port
+      @options[:port]
+    end
+
+    def path
+      @options[:path]
+    end
+
+    def timeout
+      @options[:timeout]
+    end
+
+    def password
+      @options[:password]
+    end
+
+    def db
+      @options[:db]
+    end
+
+    def db=(db)
+      @options[:db] = db.to_i
+    end
+
+    attr :logger
     attr :connection
     attr :command_map
 
     def initialize(options = {})
-      @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_f
-      @password = options[:password]
-      @logger = options[:logger]
+      @options = _parse_options(options)
       @reconnect = true
-      @connection = Connection.drivers.last.new
+      @logger = @options[:logger]
+      @connection = nil
       @command_map = {}
     end
 
     def connect
+      @pid = Process.pid
+
       establish_connection
-      call [:auth, @password] if @password
-      call [:select, @db] if @db != 0
+      call [:auth, password] if password
+      call [:select, db] if db != 0
       self
     end
 
     def id
-      "redis://#{location}/#{db}"
+      @options[:id] || "redis://#{location}/#{db}"
     end
 
     def location
-      @path || "#{@host}:#{@port}"
+      path || "#{host}:#{port}"
     end
 
     def call(command, &block)
@@ -155,11 +191,11 @@ class Redis
     end
 
     def connected?
-      connection.connected?
+      connection && connection.connected?
     end
 
     def disconnect
-      connection.disconnect if connection.connected?
+      connection.disconnect if connected?
     end
 
     def reconnect
@@ -169,7 +205,7 @@ class Redis
 
     def io
       yield
-    rescue Errno::EAGAIN
+    rescue TimeoutError
       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]
@@ -191,10 +227,10 @@ class Redis
       connect unless connected?
 
       begin
-        self.timeout = 0
+        connection.timeout = 0
         yield
       ensure
-        self.timeout = @timeout if connected?
+        connection.timeout = timeout if connected?
       end
     end
 
@@ -209,57 +245,44 @@ class Redis
 
   protected
 
-    def deprecated(old, new = nil, trace = caller[0])
-      message = "The method #{old} is deprecated and will be removed in 2.0"
-      message << " - use #{new} instead" if new
-      Redis.deprecate(message, trace)
-    end
-
     def logging(commands)
       return yield unless @logger && @logger.debug?
 
       begin
         commands.each do |name, *args|
-          @logger.debug("Redis >> #{name.to_s.upcase} #{args.join(" ")}")
+          @logger.debug("Redis >> #{name.to_s.upcase} #{args.map(&:to_s).join(" ")}")
         end
 
         t1 = Time.now
         yield
       ensure
-        @logger.debug("Redis >> %0.2fms" % ((Time.now - t1) * 1000))
+        @logger.debug("Redis >> %0.2fms" % ((Time.now - t1) * 1000)) if t1
       end
     end
 
     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
-      # to make sure a blocking read will return after the specified number
-      # of seconds. This hack is from memcached ruby client.
-      self.timeout = @timeout
+      @connection = @options[:driver].connect(@options.dup)
 
-    rescue Timeout::Error
+    rescue TimeoutError
       raise CannotConnectError, "Timed out connecting to Redis on #{location}"
     rescue Errno::ECONNREFUSED
       raise CannotConnectError, "Error connecting to Redis on #{location} (ECONNREFUSED)"
     end
 
-    def timeout=(timeout)
-      connection.timeout = Integer(timeout * 1_000_000)
-    end
-
     def ensure_connected
       tries = 0
 
       begin
-        connect unless connected?
+        if connected?
+          if Process.pid != @pid
+            raise InheritedError,
+              "Tried to use a connection from a child process without reconnecting. " +
+              "You need to reconnect to Redis after forking."
+          end
+        else
+          connect
+        end
+
         tries += 1
 
         yield
@@ -276,5 +299,70 @@ class Redis
         raise
       end
     end
+
+    def _parse_options(options)
+      defaults = DEFAULTS.dup
+
+      url = options[:url] || ENV["REDIS_URL"]
+
+      # Override defaults from URL if given
+      if url
+        require "uri"
+
+        uri = URI(url)
+
+        if uri.scheme == "unix"
+          defaults[:path]   = uri.path
+        else
+          # Require the URL to have at least a host
+          raise ArgumentError, "invalid url" unless uri.host
+
+          defaults[:scheme]   = uri.scheme
+          defaults[:host]     = uri.host
+          defaults[:port]     = uri.port if uri.port
+          defaults[:password] = uri.password if uri.password
+          defaults[:db]       = uri.path[1..-1].to_i if uri.path
+        end
+      end
+
+      options = defaults.merge(options)
+
+      if options[:path]
+        options[:scheme] = "unix"
+        options.delete(:host)
+        options.delete(:port)
+      else
+        options[:host] = options[:host].to_s
+        options[:port] = options[:port].to_i
+      end
+
+      options[:timeout] = options[:timeout].to_f
+      options[:db] = options[:db].to_i
+      options[:driver] = _parse_driver(options[:driver]) || Connection.drivers.last
+
+      options
+    end
+
+    def _parse_driver(driver)
+      driver = driver.to_s if driver.is_a?(Symbol)
+
+      if driver.kind_of?(String)
+        case driver
+        when "ruby"
+          require "redis/connection/ruby"
+          driver = Connection::Ruby
+        when "hiredis"
+          require "redis/connection/hiredis"
+          driver = Connection::Hiredis
+        when "synchrony"
+          require "redis/connection/synchrony"
+          driver = Connection::Synchrony
+        else
+          raise "Unknown driver: #{driver}"
+        end
+      end
+
+      driver
+    end
   end
 end

data/lib/redis/connection/hiredis.rb

@@ -6,42 +6,53 @@ require "timeout"
 class Redis
   module Connection
     class Hiredis
-      def initialize
-        @connection = ::Hiredis::Connection.new
-      end
 
-      def connected?
-        @connection.connected?
+      def self.connect(config)
+        connection = ::Hiredis::Connection.new
+
+        if config[:scheme] == "unix"
+          connection.connect_unix(config[:path], Integer(config[:timeout] * 1_000_000))
+        else
+          connection.connect(config[:host], config[:port], Integer(config[:timeout] * 1_000_000))
+        end
+
+        instance = new(connection)
+        instance.timeout = config[:timeout]
+        instance
+      rescue Errno::ETIMEDOUT
+        raise TimeoutError
       end
 
-      def timeout=(usecs)
-        @connection.timeout = usecs
+      def initialize(connection)
+        @connection = connection
       end
 
-      def connect(host, port, timeout)
-        @connection.connect(host, port, timeout)
-      rescue Errno::ETIMEDOUT
-        raise Timeout::Error
+      def connected?
+        @connection && @connection.connected?
       end
 
-      def connect_unix(path, timeout)
-        @connection.connect_unix(path, timeout)
-      rescue Errno::ETIMEDOUT
-        raise Timeout::Error
+      def timeout=(timeout)
+        # Hiredis works with microsecond timeouts
+        @connection.timeout = Integer(timeout * 1_000_000)
       end
 
       def disconnect
         @connection.disconnect
+        @connection = nil
       end
 
       def write(command)
         @connection.write(command.flatten(1))
+      rescue Errno::EAGAIN
+        raise TimeoutError
       end
 
       def read
         reply = @connection.read
         reply = CommandError.new(reply.message) if reply.is_a?(RuntimeError)
         reply
+      rescue Errno::EAGAIN
+        raise TimeoutError
       rescue RuntimeError => err
         raise ProtocolError.new(err.message)
       end

data/lib/redis/connection/ruby.rb

@@ -5,6 +5,155 @@ require "socket"
 
 class Redis
   module Connection
+    module SocketMixin
+
+      CRLF = "\r\n".freeze
+
+      def initialize(*args)
+        super(*args)
+
+        @timeout = nil
+        @buffer = ""
+      end
+
+      def timeout=(timeout)
+        if timeout && timeout > 0
+          @timeout = timeout
+        else
+          @timeout = nil
+        end
+      end
+
+      def read(nbytes)
+        result = @buffer.slice!(0, nbytes)
+
+        while result.bytesize < nbytes
+          result << _read_from_socket(nbytes - result.bytesize)
+        end
+
+        result
+      end
+
+      def gets
+        crlf = nil
+
+        while (crlf = @buffer.index(CRLF)) == nil
+          @buffer << _read_from_socket(1024)
+        end
+
+        @buffer.slice!(0, crlf + CRLF.bytesize)
+      end
+
+      def _read_from_socket(nbytes)
+        begin
+          read_nonblock(nbytes)
+
+        rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+          if IO.select([self], nil, nil, @timeout)
+            retry
+          else
+            raise Redis::TimeoutError
+          end
+        end
+
+      rescue EOFError
+        raise Errno::ECONNRESET
+      end
+    end
+
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+
+      require "timeout"
+
+      class TCPSocket < ::TCPSocket
+
+        include SocketMixin
+
+        def self.connect(host, port, timeout)
+          Timeout.timeout(timeout) do
+            sock = new(host, port)
+            sock
+          end
+        rescue Timeout::Error
+          raise TimeoutError
+        end
+      end
+
+      class UNIXSocket < ::UNIXSocket
+
+        # This class doesn't include the mixin, because JRuby raises
+        # Errno::EAGAIN on #read_nonblock even when IO.select says it is
+        # readable. This behavior shows in 1.6.6 in both 1.8 and 1.9 mode.
+        # Therefore, fall back on the default Unix socket implementation,
+        # without timeouts.
+
+        def self.connect(path, timeout)
+          Timeout.timeout(timeout) do
+            sock = new(path)
+            sock
+          end
+        rescue Timeout::Error
+          raise TimeoutError
+        end
+      end
+
+    else
+
+      class TCPSocket < ::Socket
+
+        include SocketMixin
+
+        def self.connect(host, port, timeout)
+          # Limit lookup to IPv4, as Redis doesn't yet do IPv6...
+          addr = ::Socket.getaddrinfo(host, nil, Socket::AF_INET)
+          sock = new(::Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
+          sockaddr = ::Socket.pack_sockaddr_in(port, addr[0][3])
+
+          begin
+            sock.connect_nonblock(sockaddr)
+          rescue Errno::EINPROGRESS
+            if IO.select(nil, [sock], nil, timeout) == nil
+              raise TimeoutError
+            end
+
+            begin
+              sock.connect_nonblock(sockaddr)
+            rescue Errno::EISCONN
+            end
+          end
+
+          sock
+        end
+      end
+
+      class UNIXSocket < ::Socket
+
+        # This class doesn't include the mixin to keep its behavior in sync
+        # with the JRuby implementation.
+
+        def self.connect(path, timeout)
+          sock = new(::Socket::AF_UNIX, Socket::SOCK_STREAM, 0)
+          sockaddr = ::Socket.pack_sockaddr_un(path)
+
+          begin
+            sock.connect_nonblock(sockaddr)
+          rescue Errno::EINPROGRESS
+            if IO.select(nil, [sock], nil, timeout) == nil
+              raise TimeoutError
+            end
+
+            begin
+              sock.connect_nonblock(sockaddr)
+            rescue Errno::EISCONN
+            end
+          end
+
+          sock
+        end
+      end
+
+    end
+
     class Ruby
       include Redis::Connection::CommandHelper
 
@@ -14,25 +163,24 @@ class Redis
       DOLLAR   = "$".freeze
       ASTERISK = "*".freeze
 
-      def initialize
-        @sock = nil
-      end
+      def self.connect(config)
+        if config[:scheme] == "unix"
+          sock = UNIXSocket.connect(config[:path], config[:timeout])
+        else
+          sock = TCPSocket.connect(config[:host], config[:port], config[:timeout])
+        end
 
-      def connected?
-        !! @sock
+        instance = new(sock)
+        instance.timeout = config[:timeout]
+        instance
       end
 
-      def connect(host, port, timeout)
-        with_timeout(timeout.to_f / 1_000_000) do
-          @sock = TCPSocket.new(host, port)
-          @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
-        end
+      def initialize(sock)
+        @sock = sock
       end
 
-      def connect_unix(path, timeout)
-        with_timeout(timeout.to_f / 1_000_000) do
-          @sock = UNIXSocket.new(path)
-        end
+      def connected?
+        !! @sock
       end
 
       def disconnect
@@ -42,16 +190,9 @@ class Redis
         @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
+      def timeout=(timeout)
+        if @sock.respond_to?(:timeout=)
+          @sock.timeout = timeout
         end
       end
 
@@ -60,13 +201,12 @@ class Redis
       end
 
       def read
-        # We read the first byte using read() mainly because gets() is
-        # immune to raw socket timeouts.
-        reply_type = @sock.read(1)
+        line = @sock.gets
+        reply_type = line.slice!(0, 1)
+        format_reply(reply_type, line)
 
-        raise Errno::ECONNRESET unless reply_type
-
-        format_reply(reply_type, @sock.gets)
+      rescue Errno::EAGAIN
+        raise TimeoutError
       end
 
       def format_reply(reply_type, line)
@@ -106,29 +246,6 @@ class Redis
 
         Array.new(n) { read }
       end
-
-    protected
-
-      begin
-        require "system_timer"
-
-        def with_timeout(seconds, &block)
-          SystemTimer.timeout_after(seconds, &block)
-        end
-
-      rescue LoadError
-        if ! defined?(RUBY_ENGINE)
-          # MRI 1.8, all other interpreters define RUBY_ENGINE, JRuby and
-          # Rubinius should have no issues with timeout.
-          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."
-        end
-
-        require "timeout"
-
-        def with_timeout(seconds, &block)
-          Timeout.timeout(seconds, &block)
-        end
-      end
     end
   end
 end