redis 3.2.2 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 183e90b7d3961182b8b5b20b1295b6dd9d30df12
-  data.tar.gz: 60023071a61af0e34d85b0a999db0bc5877070ad
+  metadata.gz: 6ab43fd7b8221a41ea88facf6051b6c7b94e87bf
+  data.tar.gz: 333fb1bbd2de6cd74db7cfd40542c979d92a6fbd
 SHA512:
-  metadata.gz: a1d93f8ee26f3dfecb10d223d178e4f78aa399d3bc8a78a4db479f0e6d89bd77c97d9e113b0138d102fbecf3d0a4452ce5f0da9412e069726c3b1fd7bb7bf7a4
-  data.tar.gz: 1a2077544497d0f2a1cd9035677dc1d514a9395b070b10f380e8fcc35cbbbbbae898e1b4ad3e7ff44e2fb96930330cb66b021ccaa726451c2c15276ff26b0011
+  metadata.gz: 3f734315d527b2b92eeb1a6bff2089b583a06784f01fa411f68d4ad23cf9bdb5ae753d6da69a570014ac5d207cc765eb70107f8781c9e432457a7f81ef48fb98
+  data.tar.gz: 686e1a0b28c573d7342335a52fc14d5636f2e1e32e8dba0adab663283e9d6fcc6acfd5d8b100b365ee54905a77a7c3a555c3c87917ef3a77b2689c8ff5afe927

data/.travis.yml

@@ -6,8 +6,10 @@ rvm:
   - 2.0
   - 2.1
   - 2.2
+  - 2.3.0
   - jruby-18mode
   - jruby-19mode
+  - jruby-9.0.5.0
   - rbx-2
 
 gemfile: ".travis/Gemfile"
@@ -37,6 +39,9 @@ matrix:
     - rvm: jruby-19mode
       gemfile: .travis/Gemfile
       env: conn=hiredis REDIS_BRANCH=2.8
+    - rvm: jruby-9.0.5.0
+      gemfile: .travis/Gemfile
+      env: conn=hiredis REDIS_BRANCH=2.8
 
     # synchrony
     - rvm: 1.8.7
@@ -48,12 +53,13 @@ matrix:
     - rvm: jruby-19mode
       gemfile: .travis/Gemfile
       env: conn=synchrony REDIS_BRANCH=2.8
+    - rvm: jruby-9.0.5.0
+      gemfile: .travis/Gemfile
+      env: conn=synchrony REDIS_BRANCH=2.8
   allow_failures:
     - rvm: rbx-2
 
 notifications:
   irc:
     - irc.freenode.net#redis-rb
-  email:
-    - damian.janowski@gmail.com
-    - pcnoordhuis@gmail.com
+  email: false

data/CHANGELOG.md

@@ -12,6 +12,20 @@
   security updates in June of 2013; continuing to support it would prevent
   the use of newer features of Ruby.
 
+# 3.3.0
+
+* Added support for SSL/TLS. Redis doesn't support SSL natively, so you still
+  need to run a terminating proxy on Redis' side. See #496.
+
+* Added `read_timeout` and `write_timeout` options. See #437, #482.
+
+* Added support for pub/sub with timeouts. See #329.
+
+* Added `Redis#call`, `Redis#queue` and `Redis#commit` as a more minimal API to
+  the client.
+
+* Deprecated `Redis#disconnect!` in favor of `Redis#close`.
+
 # 3.2.2
 
 * Added support for `ZADD` options `NX`, `XX`, `CH`, `INCR`. See #547.

data/README.md

@@ -29,7 +29,7 @@ To install **redis-rb**, run the following command:
   gem install redis
 ```
 
-Or if you are using **bundler**, add 
+Or if you are using **bundler**, add
 
 ```
   gem 'redis', '~>3.2'
@@ -222,6 +222,86 @@ end
 
 See lib/redis/errors.rb for information about what exceptions are possible.
 
+## Timeouts
+
+The client allows you to configure connect, read, and write timeouts.
+Passing a single `timeout` option will set all three values:
+
+```ruby
+Redis.new(:timeout => 1)
+```
+
+But you can use specific values for each of them:
+
+```ruby
+Redis.new(
+  :connect_timeout => 0.2,
+  :read_timeout    => 1.0,
+  :write_timeout   => 0.5
+)
+```
+
+All timeout values are specified in seconds.
+
+When using pub/sub, you can subscribe to a channel using a timeout as well:
+
+```ruby
+redis.subscribe_with_timeout(5, "news") do |on|
+  on.message do |channel, message|
+    # ...
+  end
+end
+```
+
+If no message is received after 5 seconds, the client will unsubscribe.
+
+
+## SSL/TLS Support
+
+This library supports natively terminating client side SSL/TLS connections
+when talking to Redis via a server-side proxy such as [stunnel], [hitch],
+or [ghostunnel].
+
+To enable SSL support, pass the `:ssl => :true` option when configuring the
+Redis client, or pass in `:url => "rediss://..."` (like HTTPS for Redis).
+You will also need to pass in an `:ssl_params => { ... }` hash used to
+configure the `OpenSSL::SSL::SSLContext` object used for the connection:
+
+```ruby
+redis = Redis.new(
+  :url        => "rediss://:p4ssw0rd@10.0.1.1:6381/15",
+  :ssl_params => {
+    :ca_file => "/path/to/ca.crt"
+  }
+)
+```
+
+The options given to `:ssl_params` are passed directly to the
+`OpenSSL::SSL::SSLContext#set_params` method and can be any valid attribute
+of the SSL context. Please see the [OpenSSL::SSL::SSLContext documentation]
+for all of the available attributes.
+
+Here is an example of passing in params that can be used for SSL client
+certificate authentication (a.k.a. mutual TLS):
+
+```ruby
+redis = Redis.new(
+  :url        => "rediss://:p4ssw0rd@10.0.1.1:6381/15",
+  :ssl_params => {
+    :ca_file => "/path/to/ca.crt",
+    :cert    => OpenSSL::X509::Certificate.new(File.read("client.crt")),
+    :key     => OpenSSL::PKey::RSA.new(File.read("client.key"))
+  }
+)
+```
+
+[stunnel]: https://www.stunnel.org/
+[hitch]: https://hitch-tls.org/
+[ghostunnel]: https://github.com/square/ghostunnel
+[OpenSSL::SSL::SSLContext documentation]: http://ruby-doc.org/stdlib-2.3.0/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html
+
+*NOTE:* SSL is only supported by the default "Ruby" driver
+
 
 ## Expert-Mode Options
 
@@ -298,9 +378,11 @@ This library is tested using [Travis][travis-home], where it is tested
 against the following interpreters and drivers:
 
 * MRI 1.8.7 (drivers: ruby, hiredis)
-* MRI 1.9.2 (drivers: ruby, hiredis, synchrony)
 * MRI 1.9.3 (drivers: ruby, hiredis, synchrony)
-* MRI 2.0.0 (drivers: ruby, hiredis, synchrony)
+* MRI 2.0 (drivers: ruby, hiredis, synchrony)
+* MRI 2.1 (drivers: ruby, hiredis, synchrony)
+* MRI 2.2 (drivers: ruby, hiredis, synchrony)
+* MRI 2.3 (drivers: ruby, hiredis, synchrony)
 * JRuby 1.7 (1.8 mode) (drivers: ruby)
 * JRuby 1.7 (1.9 mode) (drivers: ruby)
 

data/lib/redis.rb

@@ -49,6 +49,7 @@ class Redis
   def initialize(options = {})
     @options = options.dup
     @original_client = @client = Client.new(options)
+    @queue = Hash.new { |h, k| h[k] = [] }
 
     super() # Monitor#initialize
   end
@@ -75,9 +76,48 @@ class Redis
   end
 
   # Disconnect the client as quickly and silently as possible.
-  def disconnect!
+  def close
     @original_client.disconnect
   end
+  alias disconnect! close
+
+  # Sends a command to Redis and returns its reply.
+  #
+  # Replies are converted to Ruby objects according to the RESP protocol, so
+  # you can expect a Ruby array, integer or nil when Redis sends one. Higher
+  # level transformations, such as converting an array of pairs into a Ruby
+  # hash, are up to consumers.
+  #
+  # Redis error replies are raised as Ruby exceptions.
+  def call(*command)
+    synchronize do |client|
+      client.call(command)
+    end
+  end
+
+  # Queues a command for pipelining.
+  #
+  # Commands in the queue are executed with the Redis#commit method.
+  #
+  # See http://redis.io/topics/pipelining for more details.
+  #
+  def queue(*command)
+    @queue[Thread.current.object_id] << command
+  end
+
+  # Sends all commands in the queue.
+  #
+  # See http://redis.io/topics/pipelining for more details.
+  #
+  def commit
+    synchronize do |client|
+      begin
+        client.call_pipelined(@queue[Thread.current.object_id])
+      ensure
+        @queue.delete(Thread.current.object_id)
+      end
+    end
+  end
 
   # Authenticate to the server.
   #
@@ -161,7 +201,7 @@ class Redis
     synchronize do |client|
       client.call([:config, action] + args) do |reply|
         if reply.kind_of?(Array) && action == :get
-          Hash[_pairify(reply)]
+          Hashify.call(reply)
         else
           reply
         end
@@ -320,7 +360,7 @@ class Redis
   # @return [Boolean] whether the timeout was removed or not
   def persist(key)
     synchronize do |client|
-      client.call([:persist, key], &_boolify)
+      client.call([:persist, key], &Boolify)
     end
   end
 
@@ -331,7 +371,7 @@ class Redis
   # @return [Boolean] whether the timeout was set or not
   def expire(key, seconds)
     synchronize do |client|
-      client.call([:expire, key, seconds], &_boolify)
+      client.call([:expire, key, seconds], &Boolify)
     end
   end
 
@@ -342,7 +382,7 @@ class Redis
   # @return [Boolean] whether the timeout was set or not
   def expireat(key, unix_time)
     synchronize do |client|
-      client.call([:expireat, key, unix_time], &_boolify)
+      client.call([:expireat, key, unix_time], &Boolify)
     end
   end
 
@@ -371,7 +411,7 @@ class Redis
   # @return [Boolean] whether the timeout was set or not
   def pexpire(key, milliseconds)
     synchronize do |client|
-      client.call([:pexpire, key, milliseconds], &_boolify)
+      client.call([:pexpire, key, milliseconds], &Boolify)
     end
   end
 
@@ -382,7 +422,7 @@ class Redis
   # @return [Boolean] whether the timeout was set or not
   def pexpireat(key, ms_unix_time)
     synchronize do |client|
-      client.call([:pexpireat, key, ms_unix_time], &_boolify)
+      client.call([:pexpireat, key, ms_unix_time], &Boolify)
     end
   end
 
@@ -461,7 +501,7 @@ class Redis
   # @return [Boolean]
   def exists(key)
     synchronize do |client|
-      client.call([:exists, key], &_boolify)
+      client.call([:exists, key], &Boolify)
     end
   end
 
@@ -502,7 +542,7 @@ class Redis
   # @return [Boolean] whether the key was moved or not
   def move(key, db)
     synchronize do |client|
-      client.call([:move, key, db], &_boolify)
+      client.call([:move, key, db], &Boolify)
     end
   end
 
@@ -539,7 +579,7 @@ class Redis
   # @return [Boolean] whether the key was renamed or not
   def renamenx(old_name, new_name)
     synchronize do |client|
-      client.call([:renamenx, old_name, new_name], &_boolify)
+      client.call([:renamenx, old_name, new_name], &Boolify)
     end
   end
 
@@ -678,7 +718,7 @@ class Redis
   # @return [Float] value after incrementing it
   def incrbyfloat(key, increment)
     synchronize do |client|
-      client.call([:incrbyfloat, key, increment], &_floatify)
+      client.call([:incrbyfloat, key, increment], &Floatify)
     end
   end
 
@@ -709,7 +749,7 @@ class Redis
 
     synchronize do |client|
       if nx || xx
-        client.call([:set, key, value.to_s] + args, &_boolify_set)
+        client.call([:set, key, value.to_s] + args, &BoolifySet)
       else
         client.call([:set, key, value.to_s] + args)
       end
@@ -749,7 +789,7 @@ class Redis
   # @return [Boolean] whether the key was set or not
   def setnx(key, value)
     synchronize do |client|
-      client.call([:setnx, key, value.to_s], &_boolify)
+      client.call([:setnx, key, value.to_s], &Boolify)
     end
   end
 
@@ -795,7 +835,7 @@ class Redis
   # @see #mapped_msetnx
   def msetnx(*args)
     synchronize do |client|
-      client.call([:msetnx] + args, &_boolify)
+      client.call([:msetnx] + args, &Boolify)
     end
   end
 
@@ -844,7 +884,7 @@ class Redis
   # Get the values of all the given keys.
   #
   # @example
-  #   redis.mapped_mget("key1", "key1")
+  #   redis.mapped_mget("key1", "key2")
   #     # => { "key1" => "v1", "key2" => "v2" }
   #
   # @param [Array<String>] keys array of keys
@@ -1268,7 +1308,7 @@ class Redis
           reply
         else
           # Single argument: return boolean
-          _boolify.call(reply)
+          Boolify.call(reply)
         end
       end
     end
@@ -1290,7 +1330,7 @@ class Redis
           reply
         else
           # Single argument: return boolean
-          _boolify.call(reply)
+          Boolify.call(reply)
         end
       end
     end
@@ -1329,7 +1369,7 @@ class Redis
   # @return [Boolean]
   def smove(source, destination, member)
     synchronize do |client|
-      client.call([:smove, source, destination, member], &_boolify)
+      client.call([:smove, source, destination, member], &Boolify)
     end
   end
 
@@ -1340,7 +1380,7 @@ class Redis
   # @return [Boolean]
   def sismember(key, member)
     synchronize do |client|
-      client.call([:sismember, key, member], &_boolify)
+      client.call([:sismember, key, member], &Boolify)
     end
   end
 
@@ -1483,10 +1523,10 @@ class Redis
     synchronize do |client|
       if args.size == 1 && args[0].is_a?(Array)
         # Variadic: return float if INCR, integer if !INCR
-        client.call([:zadd, key] + zadd_options + args[0], &(incr ? _floatify : _identity))
+        client.call([:zadd, key] + zadd_options + args[0], &(incr ? Floatify : nil))
       elsif args.size == 2
         # Single pair: return float if INCR, boolean if !INCR
-        client.call([:zadd, key] + zadd_options + args, &(incr ? _floatify : _boolify))
+        client.call([:zadd, key] + zadd_options + args, &(incr ? Floatify : Boolify))
       else
         raise ArgumentError, "wrong number of arguments"
       end
@@ -1505,7 +1545,7 @@ class Redis
   # @return [Float] score of the member after incrementing it
   def zincrby(key, increment, member)
     synchronize do |client|
-      client.call([:zincrby, key, increment, member], &_floatify)
+      client.call([:zincrby, key, increment, member], &Floatify)
     end
   end
 
@@ -1534,7 +1574,7 @@ class Redis
           reply
         else
           # Single argument: return boolean
-          _boolify.call(reply)
+          Boolify.call(reply)
         end
       end
     end
@@ -1551,7 +1591,7 @@ class Redis
   # @return [Float] score of the member
   def zscore(key, member)
     synchronize do |client|
-      client.call([:zscore, key, member], &_floatify)
+      client.call([:zscore, key, member], &Floatify)
     end
   end
 
@@ -1580,7 +1620,7 @@ class Redis
 
     if with_scores
       args << "WITHSCORES"
-      block = _floatify_pairs
+      block = FloatifyPairs
     end
 
     synchronize do |client|
@@ -1606,7 +1646,7 @@ class Redis
 
     if with_scores
       args << "WITHSCORES"
-      block = _floatify_pairs
+      block = FloatifyPairs
     end
 
     synchronize do |client|
@@ -1744,7 +1784,7 @@ class Redis
 
     if with_scores
       args << "WITHSCORES"
-      block = _floatify_pairs
+      block = FloatifyPairs
     end
 
     limit = options[:limit]
@@ -1776,7 +1816,7 @@ class Redis
 
     if with_scores
       args << ["WITHSCORES"]
-      block = _floatify_pairs
+      block = FloatifyPairs
     end
 
     limit = options[:limit]
@@ -1906,7 +1946,7 @@ class Redis
   # @return [Boolean] whether or not the field was **added** to the hash
   def hset(key, field, value)
     synchronize do |client|
-      client.call([:hset, key, field, value], &_boolify)
+      client.call([:hset, key, field, value], &Boolify)
     end
   end
 
@@ -1918,7 +1958,7 @@ class Redis
   # @return [Boolean] whether or not the field was **added** to the hash
   def hsetnx(key, field, value)
     synchronize do |client|
-      client.call([:hsetnx, key, field, value], &_boolify)
+      client.call([:hsetnx, key, field, value], &Boolify)
     end
   end
 
@@ -2021,7 +2061,7 @@ class Redis
   # @return [Boolean] whether or not the field exists in the hash
   def hexists(key, field)
     synchronize do |client|
-      client.call([:hexists, key, field], &_boolify)
+      client.call([:hexists, key, field], &Boolify)
     end
   end
 
@@ -2045,7 +2085,7 @@ class Redis
   # @return [Float] value of the field after incrementing it
   def hincrbyfloat(key, field, increment)
     synchronize do |client|
-      client.call([:hincrbyfloat, key, field, increment], &_floatify)
+      client.call([:hincrbyfloat, key, field, increment], &Floatify)
     end
   end
 
@@ -2075,7 +2115,7 @@ class Redis
   # @return [Hash<String, String>]
   def hgetall(key)
     synchronize do |client|
-      client.call([:hgetall, key], &_hashify)
+      client.call([:hgetall, key], &Hashify)
     end
   end
 
@@ -2095,7 +2135,14 @@ class Redis
   # Listen for messages published to the given channels.
   def subscribe(*channels, &block)
     synchronize do |client|
-      _subscription(:subscribe, channels, block)
+      _subscription(:subscribe, 0, channels, block)
+    end
+  end
+
+  # Listen for messages published to the given channels. Throw a timeout error if there is no messages for a timeout period.
+  def subscribe_with_timeout(timeout, *channels, &block)
+    synchronize do |client|
+      _subscription(:subscribe_with_timeout, timeout, channels, block)
     end
   end
 
@@ -2110,7 +2157,14 @@ class Redis
   # Listen for messages published to channels matching the given patterns.
   def psubscribe(*channels, &block)
     synchronize do |client|
-      _subscription(:psubscribe, channels, block)
+      _subscription(:psubscribe, 0, channels, block)
+    end
+  end
+
+  # Listen for messages published to channels matching the given patterns. Throw a timeout error if there is no messages for a timeout period.
+  def psubscribe_with_timeout(timeout, *channels, &block)
+    synchronize do |client|
+      _subscription(:psubscribe_with_timeout, timeout, channels, block)
     end
   end
 
@@ -2312,7 +2366,7 @@ class Redis
         arg = args.first
 
         client.call([:script, :exists, arg]) do |reply|
-          reply = reply.map { |r| _boolify.call(r) }
+          reply = reply.map { |r| Boolify.call(r) }
 
           if arg.is_a?(Array)
             reply
@@ -2466,7 +2520,7 @@ class Redis
   # @return [String, Array<[String, String]>] the next cursor and all found keys
   def hscan(key, cursor, options={})
     _scan(:hscan, cursor, [key], options) do |reply|
-      [reply[0], _pairify(reply[1])]
+      [reply[0], reply[1].each_slice(2).to_a]
     end
   end
 
@@ -2505,7 +2559,7 @@ class Redis
   #   members and scores
   def zscan(key, cursor, options={})
     _scan(:zscan, cursor, [key], options) do |reply|
-      [reply[0], _floatify_pairs.call(reply[1])]
+      [reply[0], FloatifyPairs.call(reply[1])]
     end
   end
 
@@ -2573,7 +2627,7 @@ class Redis
   # @return [Boolean] true if at least 1 HyperLogLog internal register was altered. false otherwise.
   def pfadd(key, member)
     synchronize do |client|
-      client.call([:pfadd, key, member], &_boolify)
+      client.call([:pfadd, key, member], &Boolify)
     end
   end
 
@@ -2598,7 +2652,7 @@ class Redis
   # @return [Boolean]
   def pfmerge(dest_key, *source_key)
     synchronize do |client|
-      client.call([:pfmerge, dest_key, *source_key], &_boolify_set)
+      client.call([:pfmerge, dest_key, *source_key], &BoolifySet)
     end
   end
 
@@ -2617,9 +2671,9 @@ class Redis
         else
           if reply.kind_of?(Array)
             if reply[0].kind_of?(Array)
-              reply.map(&_hashify)
+              reply.map(&Hashify)
             else
-              _hashify.call(reply)
+              Hashify.call(reply)
             end
           else
             reply
@@ -2652,13 +2706,12 @@ private
   # Commands returning 1 for true and 0 for false may be executed in a pipeline
   # where the method call will return nil. Propagate the nil instead of falsely
   # returning false.
-  def _boolify
+  Boolify =
     lambda { |value|
       value == 1 if value
     }
-  end
 
-  def _boolify_set
+  BoolifySet =
     lambda { |value|
       if value && "OK" == value
         true
@@ -2666,9 +2719,8 @@ private
         false
       end
     }
-  end
 
-  def _hashify
+  Hashify =
     lambda { |array|
       hash = Hash.new
       array.each_slice(2) do |field, value|
@@ -2676,46 +2728,37 @@ private
       end
       hash
     }
-  end
 
-  def _floatify
+  Floatify =
     lambda { |str|
-      return unless str
-
-      if (inf = str.match(/^(-)?inf/i))
-        (inf[1] ? -1.0 : 1.0) / 0.0
-      else
-        Float(str)
+      if str
+        if (inf = str.match(/^(-)?inf/i))
+          (inf[1] ? -1.0 : 1.0) / 0.0
+        else
+          Float(str)
+        end
       end
     }
-  end
 
-  def _floatify_pairs
+  FloatifyPairs =
     lambda { |array|
-      return unless array
-
-      array.each_slice(2).map do |member, score|
-        [member, _floatify.call(score)]
+      if array
+        array.each_slice(2).map do |member, score|
+          [member, Floatify.call(score)]
+        end
       end
     }
-  end
-
-  def _pairify(array)
-    array.each_slice(2).to_a
-  end
-
-  def _identity
-    lambda { |value|
-      value
-    }
-  end
 
-  def _subscription(method, channels, block)
+  def _subscription(method, timeout, channels, block)
     return @client.call([method] + channels) if subscribed?
 
     begin
       original, @client = @client, SubscribedClient.new(@client)
-      @client.send(method, *channels, &block)
+      if timeout > 0
+        @client.send(method, timeout, *channels, &block)
+      else
+        @client.send(method, *channels, &block)
+      end
     ensure
       @client = original
     end