redis 3.2.2 → 3.3.1

data/lib/redis/client.rb

@@ -12,7 +12,6 @@ class Redis
       :port => 6379,
       :path => nil,
       :timeout => 5.0,
-      :connect_timeout => 5.0,
       :password => nil,
       :db => 0,
       :driver => nil,
@@ -42,8 +41,16 @@ class Redis
       @options[:path]
     end
 
+    def read_timeout
+      @options[:read_timeout]
+    end
+
+    def connect_timeout
+      @options[:connect_timeout]
+    end
+
     def timeout
-      @options[:timeout]
+      @options[:read_timeout]
     end
 
     def password
@@ -109,21 +116,21 @@ class Redis
       path || "#{host}:#{port}"
     end
 
-    def call(command, &block)
+    def call(command)
       reply = process([command]) { read }
       raise reply if reply.is_a?(CommandError)
 
-      if block
-        block.call(reply)
+      if block_given?
+        yield reply
       else
         reply
       end
     end
 
-    def call_loop(command)
+    def call_loop(command, timeout = 0)
       error = nil
 
-      result = without_socket_timeout do
+      result = with_socket_timeout(timeout) do
         process([command]) do
           loop do
             reply = read
@@ -175,15 +182,21 @@ class Redis
       reconnect = @reconnect
 
       begin
+        exception = nil
+
         process(commands) do
           result[0] = read
 
           @reconnect = false
 
           (commands.size - 1).times do |i|
-            result[i + 1] = read
+            reply = read
+            result[i + 1] = reply
+            exception = reply if exception.nil? && reply.is_a?(CommandError)
           end
         end
+
+        raise exception if exception
       ensure
         @reconnect = reconnect
       end
@@ -392,7 +405,7 @@ class Redis
 
         if uri.scheme == "unix"
           defaults[:path]   = uri.path
-        elsif uri.scheme == "redis"
+        elsif uri.scheme == "redis" || uri.scheme == "rediss"
           defaults[:scheme]   = uri.scheme
           defaults[:host]     = uri.host if uri.host
           defaults[:port]     = uri.port if uri.port
@@ -402,6 +415,8 @@ class Redis
         else
           raise ArgumentError, "invalid uri scheme '#{uri.scheme}'"
         end
+
+        defaults[:ssl] = true if uri.scheme == "rediss"
       end
 
       # Use default when option is not specified or nil
@@ -420,13 +435,16 @@ class Redis
         options[:port] = options[:port].to_i
       end
 
-      options[:timeout] = options[:timeout].to_f
-      options[:connect_timeout] = if options[:connect_timeout]
-        options[:connect_timeout].to_f
-      else
-        options[:timeout]
+      if options.has_key?(:timeout)
+        options[:connect_timeout] ||= options[:timeout]
+        options[:read_timeout]    ||= options[:timeout]
+        options[:write_timeout]   ||= options[:timeout]
       end
 
+      options[:connect_timeout] = Float(options[:connect_timeout])
+      options[:read_timeout]    = Float(options[:read_timeout])
+      options[:write_timeout]   = Float(options[:write_timeout])
+
       options[:db] = options[:db].to_i
       options[:driver] = _parse_driver(options[:driver]) || Connection.drivers.last
 

data/lib/redis/connection/hiredis.rb

@@ -13,12 +13,14 @@ class Redis
 
         if config[:scheme] == "unix"
           connection.connect_unix(config[:path], connect_timeout)
+        elsif config[:scheme] == "rediss" || config[:ssl]
+          raise NotImplementedError, "SSL not supported by hiredis driver"
         else
           connection.connect(config[:host], config[:port], connect_timeout)
         end
 
         instance = new(connection)
-        instance.timeout = config[:timeout]
+        instance.timeout = config[:read_timeout]
         instance
       rescue Errno::ETIMEDOUT
         raise TimeoutError

data/lib/redis/connection/ruby.rb

@@ -2,6 +2,23 @@ require "redis/connection/registry"
 require "redis/connection/command_helper"
 require "redis/errors"
 require "socket"
+require "timeout"
+
+begin
+  require "openssl"
+rescue LoadError
+  # Not all systems have OpenSSL support
+end
+
+if RUBY_VERSION < "1.9.3"
+  class String
+    # Ruby 1.8.7 does not have byteslice, but it handles encodings differently anyway.
+    # We can simply slice the string, which is a byte array there.
+    def byteslice(*args)
+      slice(*args)
+    end
+  end
+end
 
 class Redis
   module Connection
@@ -9,10 +26,14 @@ class Redis
 
       CRLF = "\r\n".freeze
 
+      # Exceptions raised during non-blocking I/O ops that require retrying the op
+      NBIO_EXCEPTIONS = [Errno::EWOULDBLOCK, Errno::EAGAIN]
+      NBIO_EXCEPTIONS << IO::WaitReadable if RUBY_VERSION >= "1.9.3"
+
       def initialize(*args)
         super(*args)
 
-        @timeout = nil
+        @timeout = @write_timeout = nil
         @buffer = ""
       end
 
@@ -24,6 +45,14 @@ class Redis
         end
       end
 
+      def write_timeout=(timeout)
+        if timeout && timeout > 0
+          @write_timeout = timeout
+        else
+          @write_timeout = nil
+        end
+      end
+
       def read(nbytes)
         result = @buffer.slice!(0, nbytes)
 
@@ -45,10 +74,11 @@ class Redis
       end
 
       def _read_from_socket(nbytes)
+
         begin
           read_nonblock(nbytes)
 
-        rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+        rescue *NBIO_EXCEPTIONS
           if IO.select([self], nil, nil, @timeout)
             retry
           else
@@ -59,6 +89,36 @@ class Redis
       rescue EOFError
         raise Errno::ECONNRESET
       end
+
+      def _write_to_socket(data)
+        begin
+          write_nonblock(data)
+
+        rescue *NBIO_EXCEPTIONS
+          if IO.select(nil, [self], nil, @write_timeout)
+            retry
+          else
+            raise Redis::TimeoutError
+          end
+        end
+
+      rescue EOFError
+        raise Errno::ECONNRESET
+      end
+
+      def write(data)
+        return super(data) unless @write_timeout
+
+        length = data.bytesize
+        total_count = 0
+        loop do
+          count = _write_to_socket(data)
+
+          total_count += count
+          return total_count if total_count >= length
+          data = data.byteslice(count..-1)
+        end
+      end
     end
 
     if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
@@ -195,6 +255,27 @@ class Redis
 
     end
 
+    if defined?(OpenSSL)
+      class SSLSocket < ::OpenSSL::SSL::SSLSocket
+        include SocketMixin
+
+        def self.connect(host, port, timeout, ssl_params)
+          # Note: this is using Redis::Connection::TCPSocket
+          tcp_sock = TCPSocket.connect(host, port, timeout)
+
+          ctx = OpenSSL::SSL::SSLContext.new
+          ctx.set_params(ssl_params) if ssl_params && !ssl_params.empty?
+
+          ssl_sock = new(tcp_sock, ctx)
+          ssl_sock.hostname = host
+          ssl_sock.connect
+          ssl_sock.post_connection_check(host)
+
+          ssl_sock
+        end
+      end
+    end
+
     class Ruby
       include Redis::Connection::CommandHelper
 
@@ -206,13 +287,17 @@ class Redis
 
       def self.connect(config)
         if config[:scheme] == "unix"
+          raise ArgumentError, "SSL incompatible with unix sockets" if config[:ssl]
           sock = UNIXSocket.connect(config[:path], config[:connect_timeout])
+        elsif config[:scheme] == "rediss" || config[:ssl]
+          sock = SSLSocket.connect(config[:host], config[:port], config[:connect_timeout], config[:ssl_params])
         else
           sock = TCPSocket.connect(config[:host], config[:port], config[:connect_timeout])
         end
 
         instance = new(sock)
         instance.timeout = config[:timeout]
+        instance.write_timeout = config[:write_timeout]
         instance.set_tcp_keepalive config[:tcp_keepalive]
         instance
       end
@@ -265,6 +350,10 @@ class Redis
         end
       end
 
+      def write_timeout=(timeout)
+        @sock.write_timeout = timeout
+      end
+
       def write(command)
         @sock.write(build_command(command))
       end

data/lib/redis/connection/synchrony.rb

@@ -9,6 +9,8 @@ class Redis
     class RedisClient < EventMachine::Connection
       include EventMachine::Deferrable
 
+      attr_accessor :timeout
+
       def post_init
         @req = nil
         @connected = false
@@ -44,6 +46,9 @@ class Redis
 
       def read
         @req = EventMachine::DefaultDeferrable.new
+        if @timeout > 0
+          @req.timeout(@timeout, :timeout)
+        end
         EventMachine::Synchrony.sync @req
       end
 
@@ -68,6 +73,8 @@ class Redis
       def self.connect(config)
         if config[:scheme] == "unix"
           conn = EventMachine.connect_unix_domain(config[:path], RedisClient)
+        elsif config[:scheme] == "rediss" || config[:ssl]
+          raise NotImplementedError, "SSL not supported by synchrony driver"
         else
           conn = EventMachine.connect(config[:host], config[:port], RedisClient) do |c|
             c.pending_connect_timeout = [config[:connect_timeout], 0.1].max
@@ -81,7 +88,7 @@ class Redis
         raise Errno::ECONNREFUSED if Fiber.yield == :refused
 
         instance = new(conn)
-        instance.timeout = config[:timeout]
+        instance.timeout = config[:read_timeout]
         instance
       end
 
@@ -94,7 +101,7 @@ class Redis
       end
 
       def timeout=(timeout)
-        @timeout = timeout
+        @connection.timeout = timeout
       end
 
       def disconnect
@@ -113,6 +120,8 @@ class Redis
           payload
         elsif type == :error
           raise payload
+        elsif type == :timeout
+          raise TimeoutError
         else
           raise "Unknown type #{type.inspect}"
         end

data/lib/redis/subscribe.rb

@@ -12,10 +12,18 @@ class Redis
       subscription("subscribe", "unsubscribe", channels, block)
     end
 
+    def subscribe_with_timeout(timeout, *channels, &block)
+      subscription("subscribe", "unsubscribe", channels, block, timeout)
+    end
+
     def psubscribe(*channels, &block)
       subscription("psubscribe", "punsubscribe", channels, block)
     end
 
+    def psubscribe_with_timeout(timeout, *channels, &block)
+      subscription("psubscribe", "punsubscribe", channels, block, timeout)
+    end
+
     def unsubscribe(*channels)
       call([:unsubscribe, *channels])
     end
@@ -26,13 +34,13 @@ class Redis
 
   protected
 
-    def subscription(start, stop, channels, block)
+    def subscription(start, stop, channels, block, timeout = 0)
       sub = Subscription.new(&block)
 
       unsubscribed = false
 
       begin
-        @client.call_loop([start, *channels]) do |line|
+        @client.call_loop([start, *channels], timeout) do |line|
           type, *rest = line
           sub.callbacks[type].call(*rest)
           unsubscribed = type == stop && rest.last == 0

data/lib/redis/version.rb

@@ -1,3 +1,3 @@
 class Redis
-  VERSION = "3.2.2"
+  VERSION = "3.3.1"
 end

data/redis.gemspec

@@ -39,6 +39,6 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
 
-  s.add_development_dependency("rake")
-  s.add_development_dependency("test-unit")
+  s.add_development_dependency("rake", "<11.0.0")
+  s.add_development_dependency("test-unit", "3.1.5")
 end

data/test/client_test.rb

@@ -0,0 +1,59 @@
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class TestClient < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_call
+    result = r.call("PING")
+    assert_equal result, "PONG"
+  end
+
+  def test_call_with_arguments
+    result = r.call("SET", "foo", "bar")
+    assert_equal result, "OK"
+  end
+
+  def test_call_integers
+    result = r.call("INCR", "foo")
+    assert_equal result, 1
+  end
+
+  def test_call_raise
+    assert_raises(Redis::CommandError) do
+      r.call("INCR")
+    end
+  end
+
+  def test_queue_commit
+    r.queue("SET", "foo", "bar")
+    r.queue("GET", "foo")
+    result = r.commit
+
+    assert_equal result, ["OK", "bar"]
+  end
+
+  def test_commit_raise
+    r.queue("SET", "foo", "bar")
+    r.queue("INCR")
+
+    assert_raise(Redis::CommandError) do
+      r.commit
+    end
+  end
+
+  def test_queue_after_error
+    r.queue("SET", "foo", "bar")
+    r.queue("INCR")
+
+    assert_raise(Redis::CommandError) do
+      r.commit
+    end
+
+    r.queue("SET",  "foo", "bar")
+    r.queue("INCR", "baz")
+    result = r.commit
+
+    assert_equal result, ["OK", 1]
+  end
+end