redis 3.3.5 → 4.0.3

data/lib/redis/pipeline.rb

@@ -1,10 +1,4 @@
 class Redis
-  unless defined?(::BasicObject)
-    class BasicObject
-      instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A(__|instance_eval)/ }
-    end
-  end
-
   class Pipeline
     attr_accessor :db
 
@@ -28,6 +22,10 @@ class Redis
       @shutdown
     end
 
+    def empty?
+      @futures.empty?
+    end
+
     def call(command, &block)
       # A pipeline that contains a shutdown should not raise ECONNRESET when
       # the connection is gone.
@@ -92,7 +90,11 @@ class Redis
       end
 
       def commands
-        [[:multi]] + super + [[:exec]]
+        if empty?
+          []
+        else
+          [[:multi]] + super + [[:exec]]
+        end
       end
     end
   end

data/lib/redis/version.rb

@@ -1,3 +1,3 @@
 class Redis
-  VERSION = "3.3.5"
+  VERSION = "4.0.3"
 end

data/lib/redis.rb

@@ -1,21 +1,8 @@
 require "monitor"
-require "redis/errors"
+require_relative "redis/errors"
 
 class Redis
 
-  def self.deprecate(message, trace = caller[0])
-    $stderr.puts "\n#{message} (in #{trace})"
-  end
-
-  attr :client
-
-  # @deprecated The preferred way to create a new client object is using `#new`.
-  #             This method does not actually establish a connection to Redis,
-  #             in contrary to what you might expect.
-  def self.connect(options = {})
-    new(options)
-  end
-
   def self.current
     @current ||= Redis.new
   end
@@ -44,11 +31,16 @@ class Redis
   # @option options [Boolean] :inherit_socket (false) Whether to use socket in forked process or not
   # @option options [Array] :sentinels List of sentinels to contact
   # @option options [Symbol] :role (:master) Role to fetch via Sentinel, either `:master` or `:slave`
+  # @option options [Array<String, Hash{Symbol => String, Integer}>] :cluster List of cluster nodes to contact
+  # @option options [Boolean] :replica Whether to use readonly replica nodes in Redis Cluster or not
+  # @option options [Class] :connector Class of custom connector
   #
   # @return [Redis] a new client instance
   def initialize(options = {})
     @options = options.dup
-    @original_client = @client = Client.new(options)
+    @cluster_mode = options.key?(:cluster)
+    client = @cluster_mode ? Cluster : Client
+    @original_client = @client = client.new(options)
     @queue = Hash.new { |h, k| h[k] = [] }
 
     super() # Monitor#initialize
@@ -119,6 +111,10 @@ class Redis
     end
   end
 
+  def _client
+    @client
+  end
+
   # Authenticate to the server.
   #
   # @param [String] password must match the password specified in the
@@ -143,10 +139,11 @@ class Redis
 
   # Ping the server.
   #
+  # @param [optional, String] message
   # @return [String] `PONG`
-  def ping
+  def ping(message = nil)
     synchronize do |client|
-      client.call([:ping])
+      client.call([:ping, message].compact)
     end
   end
 
@@ -209,6 +206,25 @@ class Redis
     end
   end
 
+  # Manage client connections.
+  #
+  # @param [String, Symbol] subcommand e.g. `kill`, `list`, `getname`, `setname`
+  # @return [String, Hash] depends on subcommand
+  def client(subcommand = nil, *args)
+    synchronize do |client|
+      client.call([:client, subcommand] + args) do |reply|
+        if subcommand.to_s == "list"
+          reply.lines.map do |line|
+            entries = line.chomp.split(/[ =]/)
+            Hash[entries.each_slice(2).to_a]
+          end
+        else
+          reply
+        end
+      end
+    end
+  end
+
   # Return the number of keys in the selected database.
   #
   # @return [Fixnum]
@@ -226,19 +242,31 @@ class Redis
 
   # Remove all keys from all databases.
   #
+  # @param [Hash] options
+  #   - `:async => Boolean`: async flush (default: false)
   # @return [String] `OK`
-  def flushall
+  def flushall(options = nil)
     synchronize do |client|
-      client.call([:flushall])
+      if options && options[:async]
+        client.call([:flushall, :async])
+      else
+        client.call([:flushall])
+      end
     end
   end
 
   # Remove all keys from the current database.
   #
+  # @param [Hash] options
+  #   - `:async => Boolean`: async flush (default: false)
   # @return [String] `OK`
-  def flushdb
+  def flushdb(options = nil)
     synchronize do |client|
-      client.call([:flushdb])
+      if options && options[:async]
+        client.call([:flushdb, :async])
+      else
+        client.call([:flushdb])
+      end
     end
   end
 
@@ -250,9 +278,7 @@ class Redis
     synchronize do |client|
       client.call([:info, cmd].compact) do |reply|
         if reply.kind_of?(String)
-          reply = Hash[reply.split("\r\n").map do |line|
-            line.split(":", 2) unless line =~ /^(#|$)/
-          end.compact]
+          reply = HashifyInfo.call(reply)
 
           if cmd && cmd.to_s == "commandstats"
             # Extract nested hashes for INFO COMMANDSTATS
@@ -458,10 +484,16 @@ class Redis
   # @param [String] key
   # @param [String] ttl
   # @param [String] serialized_value
+  # @param [Hash] options
+  #   - `:replace => Boolean`: if false, raises an error if key already exists
+  # @raise [Redis::CommandError]
   # @return [String] `"OK"`
-  def restore(key, ttl, serialized_value)
+  def restore(key, ttl, serialized_value, options = {})
+    args = [:restore, key, ttl, serialized_value]
+    args << 'REPLACE' if options[:replace]
+
     synchronize do |client|
-      client.call([:restore, key, ttl, serialized_value])
+      client.call(args)
     end
   end
 
@@ -477,8 +509,8 @@ class Redis
   def migrate(key, options)
     host = options[:host] || raise(RuntimeError, ":host not specified")
     port = options[:port] || raise(RuntimeError, ":port not specified")
-    db = (options[:db] || client.db).to_i
-    timeout = (options[:timeout] || client.timeout).to_i
+    db = (options[:db] || @client.db).to_i
+    timeout = (options[:timeout] || @client.timeout).to_i
 
     synchronize do |client|
       client.call([:migrate, host, port, key, db, timeout])
@@ -495,6 +527,16 @@ class Redis
     end
   end
 
+  # Unlink one or more keys.
+  #
+  # @param [String, Array<String>] keys
+  # @return [Fixnum] number of keys that were unlinked
+  def unlink(*keys)
+    synchronize do |client|
+      client.call([:unlink] + keys)
+    end
+  end
+
   # Determine if a key exists.
   #
   # @param [String] key
@@ -756,8 +798,6 @@ class Redis
     end
   end
 
-  alias :[]= :set
-
   # Set the time to live in seconds of a key.
   #
   # @param [String] key
@@ -863,8 +903,6 @@ class Redis
     end
   end
 
-  alias :[] :get
-
   # Get the values of all the given keys.
   #
   # @example
@@ -1041,7 +1079,7 @@ class Redis
   # Prepend one or more values to a list, creating the list if it doesn't exist
   #
   # @param [String] key
-  # @param [String, Array] value string value, or array of string values to push
+  # @param [String, Array<String>] value string value, or array of string values to push
   # @return [Fixnum] the length of the list after the push operation
   def lpush(key, value)
     synchronize do |client|
@@ -1063,7 +1101,7 @@ class Redis
   # Append one or more values to a list, creating the list if it doesn't exist
   #
   # @param [String] key
-  # @param [String] value
+  # @param [String, Array<String>] value string value, or array of string values to push
   # @return [Fixnum] the length of the list after the push operation
   def rpush(key, value)
     synchronize do |client|
@@ -1701,6 +1739,30 @@ class Redis
     end
   end
 
+  # Count the members, with the same score in a sorted set, within the given lexicographical range.
+  #
+  # @example Count members matching a
+  #   redis.zlexcount("zset", "[a", "[a\xff")
+  #     # => 1
+  # @example Count members matching a-z
+  #   redis.zlexcount("zset", "[a", "[z\xff")
+  #     # => 26
+  #
+  # @param [String] key
+  # @param [String] min
+  #   - inclusive minimum is specified by prefixing `(`
+  #   - exclusive minimum is specified by prefixing `[`
+  # @param [String] max
+  #   - inclusive maximum is specified by prefixing `(`
+  #   - exclusive maximum is specified by prefixing `[`
+  #
+  # @return [Fixnum] number of members within the specified lexicographical range
+  def zlexcount(key, min, max)
+    synchronize do |client|
+      client.call([:zlexcount, key, min, max])
+    end
+  end
+
   # Return a range of members with the same score in a sorted set, by lexicographical ordering
   #
   # @example Retrieve members matching a
@@ -2053,9 +2115,9 @@ class Redis
   # @param [String] key
   # @param [String, Array<String>] field
   # @return [Fixnum] the number of fields that were removed from the hash
-  def hdel(key, field)
+  def hdel(key, *fields)
     synchronize do |client|
-      client.call([:hdel, key, field])
+      client.call([:hdel, key, *fields])
     end
   end
 
@@ -2661,6 +2723,86 @@ class Redis
     end
   end
 
+  # Adds the specified geospatial items (latitude, longitude, name) to the specified key
+  #
+  # @param [String] key
+  # @param [Array] member arguemnts for member or members: longitude, latitude, name
+  # @return [Intger] number of elements added to the sorted set
+  def geoadd(key, *member)
+    synchronize do |client|
+      client.call([:geoadd, key, member])
+    end
+  end
+
+  # Returns geohash string representing position for specified members of the specified key.
+  #
+  # @param [String] key
+  # @param [String, Array<String>] member one member or array of members
+  # @return [Array<String, nil>] returns array containg geohash string if member is present, nil otherwise
+  def geohash(key, member)
+    synchronize do |client|
+      client.call([:geohash, key, member])
+    end
+  end
+
+
+  # Query a sorted set representing a geospatial index to fetch members matching a
+  # given maximum distance from a point
+  #
+  # @param [Array] args key, longitude, latitude, radius, unit(m|km|ft|mi)
+  # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest or the farthest to the nearest relative to the center
+  # @param [Integer] count limit the results to the first N matching items
+  # @param ['WITHDIST', 'WITHCOORD', 'WITHHASH'] options to return additional information
+  # @return [Array<String>] may be changed with `options`
+
+  def georadius(*args, **geoptions)
+    geoarguments = _geoarguments(*args, **geoptions)
+
+    synchronize do |client|
+      client.call([:georadius, *geoarguments])
+    end
+  end
+
+  # Query a sorted set representing a geospatial index to fetch members matching a
+  # given maximum distance from an already existing member
+  #
+  # @param [Array] args key, member, radius, unit(m|km|ft|mi)
+  # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest or the farthest to the nearest relative to the center
+  # @param [Integer] count limit the results to the first N matching items
+  # @param ['WITHDIST', 'WITHCOORD', 'WITHHASH'] options to return additional information
+  # @return [Array<String>] may be changed with `options`
+
+  def georadiusbymember(*args, **geoptions)
+    geoarguments = _geoarguments(*args, **geoptions)
+
+    synchronize do |client|
+      client.call([:georadiusbymember, *geoarguments])
+    end
+  end
+
+  # Returns longitude and latitude of members of a geospatial index
+  #
+  # @param [String] key
+  # @param [String, Array<String>] member one member or array of members
+  # @return [Array<Array<String>, nil>] returns array of elements, where each element is either array of longitude and latitude or nil
+  def geopos(key, member)
+    synchronize do |client|
+      client.call([:geopos, key, member])
+    end
+  end
+
+  # Returns the distance between two members of a geospatial index
+  #
+  # @param [String ]key
+  # @param [Array<String>] members
+  # @param ['m', 'km', 'mi', 'ft'] unit
+  # @return [String, nil] returns distance in spefied unit if both members present, nil otherwise.
+  def geodist(key, member1, member2, unit = 'm')
+    synchronize do |client|
+      client.call([:geodist, key, member1, member2, unit])
+    end
+  end
+
   # Interact with the sentinel command (masters, master, slaves, failover)
   #
   # @param [String] subcommand e.g. `masters`, `master`, `slaves`
@@ -2688,6 +2830,41 @@ class Redis
     end
   end
 
+  # Sends `CLUSTER *` command to random node and returns its reply.
+  #
+  # @see https://redis.io/commands#cluster Reference of cluster command
+  #
+  # @param subcommand [String, Symbol] the subcommand of cluster command
+  #   e.g. `:slots`, `:nodes`, `:slaves`, `:info`
+  #
+  # @return [Object] depends on the subcommand
+  def cluster(subcommand, *args)
+    subcommand = subcommand.to_s.downcase
+    block = case subcommand
+            when 'slots'  then HashifyClusterSlots
+            when 'nodes'  then HashifyClusterNodes
+            when 'slaves' then HashifyClusterSlaves
+            when 'info'   then HashifyInfo
+            else Noop
+            end
+
+    # @see https://github.com/antirez/redis/blob/unstable/src/redis-trib.rb#L127 raw reply expected
+    block = Noop unless @cluster_mode
+
+    synchronize do |client|
+      client.call([:cluster, subcommand] + args, &block)
+    end
+  end
+
+  # Sends `ASKING` command to random node and returns its reply.
+  #
+  # @see https://redis.io/topics/cluster-spec#ask-redirection ASK redirection
+  #
+  # @return [String] `'OK'`
+  def asking
+    synchronize { |client| client.call(%i[asking]) }
+  end
+
   def id
     @original_client.id
   end
@@ -2701,12 +2878,14 @@ class Redis
   end
 
   def connection
+    return @original_client.connection_info if @cluster_mode
+
     {
-      :host     => @original_client.host,
-      :port     => @original_client.port,
-      :db       => @original_client.db,
-      :id       => @original_client.id,
-      :location => @original_client.location
+      host:     @original_client.host,
+      port:     @original_client.port,
+      db:       @original_client.db,
+      id:       @original_client.id,
+      location: @original_client.location
     }
   end
 
@@ -2756,14 +2935,70 @@ private
     }
 
   FloatifyPairs =
-    lambda { |array|
-      if array
-        array.each_slice(2).map do |member, score|
-          [member, Floatify.call(score)]
-        end
+    lambda { |result|
+      result.each_slice(2).map do |member, score|
+        [member, Floatify.call(score)]
+      end
+    }
+
+  HashifyInfo =
+    lambda { |reply|
+      Hash[reply.split("\r\n").map do |line|
+        line.split(':', 2) unless line =~ /^(#|$)/
+      end.compact]
+    }
+
+  HashifyClusterNodeInfo =
+    lambda { |str|
+      arr = str.split(' ')
+      {
+        'node_id'        => arr[0],
+        'ip_port'        => arr[1],
+        'flags'          => arr[2].split(','),
+        'master_node_id' => arr[3],
+        'ping_sent'      => arr[4],
+        'pong_recv'      => arr[5],
+        'config_epoch'   => arr[6],
+        'link_state'     => arr[7],
+        'slots'          => arr[8].nil? ? nil : Range.new(*arr[8].split('-'))
+      }
+    }
+
+  HashifyClusterSlots =
+    lambda { |reply|
+      reply.map do |arr|
+        first_slot, last_slot = arr[0..1]
+        master = { 'ip' => arr[2][0], 'port' => arr[2][1], 'node_id' => arr[2][2] }
+        replicas = arr[3..-1].map { |r| { 'ip' => r[0], 'port' => r[1], 'node_id' => r[2] } }
+        {
+          'start_slot' => first_slot,
+          'end_slot'   => last_slot,
+          'master'     => master,
+          'replicas'   => replicas
+        }
       end
     }
 
+  HashifyClusterNodes =
+    lambda { |reply|
+      reply.split(/[\r\n]+/).map { |str| HashifyClusterNodeInfo.call(str) }
+    }
+
+  HashifyClusterSlaves =
+    lambda { |reply|
+      reply.map { |str| HashifyClusterNodeInfo.call(str) }
+    }
+
+  Noop = ->(reply) { reply }
+
+  def _geoarguments(*args, options: nil, sort: nil, count: nil)
+    args.push sort if sort
+    args.push 'count', count if count
+    args.push options if options
+
+    args.uniq
+  end
+
   def _subscription(method, timeout, channels, block)
     return @client.call([method] + channels) if subscribed?
 
@@ -2778,11 +3013,11 @@ private
       @client = original
     end
   end
-
 end
 
-require "redis/version"
-require "redis/connection"
-require "redis/client"
-require "redis/pipeline"
-require "redis/subscribe"
+require_relative "redis/version"
+require_relative "redis/connection"
+require_relative "redis/client"
+require_relative "redis/cluster"
+require_relative "redis/pipeline"
+require_relative "redis/subscribe"

data/makefile

@@ -0,0 +1,74 @@
+TEST_FILES         := $(shell find ./test -name *_test.rb -type f)
+REDIS_BRANCH       ?= unstable
+TMP                := tmp
+BUILD_DIR          := ${TMP}/cache/redis-${REDIS_BRANCH}
+TARBALL            := ${TMP}/redis-${REDIS_BRANCH}.tar.gz
+BINARY             := ${BUILD_DIR}/src/redis-server
+REDIS_CLIENT       := ${BUILD_DIR}/src/redis-cli
+REDIS_TRIB         := ${BUILD_DIR}/src/redis-trib.rb
+PID_PATH           := ${BUILD_DIR}/redis.pid
+SOCKET_PATH        := ${BUILD_DIR}/redis.sock
+PORT               := 6381
+CLUSTER_PORTS      := 7000 7001 7002 7003 7004 7005
+CLUSTER_PID_PATHS  := $(addprefix ${TMP}/redis,$(addsuffix .pid,${CLUSTER_PORTS}))
+CLUSTER_CONF_PATHS := $(addprefix ${TMP}/nodes,$(addsuffix .conf,${CLUSTER_PORTS}))
+CLUSTER_ADDRS      := $(addprefix 127.0.0.1:,${CLUSTER_PORTS})
+
+define kill-redis
+  (ls $1 2> /dev/null && kill $$(cat $1) && rm -f $1) || true
+endef
+
+all:
+	make start
+	make start_cluster
+	make create_cluster
+	make test
+	make stop
+	make stop_cluster
+
+${TMP}:
+	mkdir -p $@
+
+${BINARY}: ${TMP}
+	bin/build ${REDIS_BRANCH} $<
+
+test: ${TEST_FILES}
+	env SOCKET_PATH=${SOCKET_PATH} \
+		bundle exec ruby -v -e 'ARGV.each { |test_file| require test_file }' ${TEST_FILES}
+
+stop:
+	$(call kill-redis,${PID_PATH})
+
+start: ${BINARY}
+	${BINARY}                     \
+		--daemonize  yes            \
+		--pidfile    ${PID_PATH}    \
+		--port       ${PORT}        \
+		--unixsocket ${SOCKET_PATH}
+
+stop_cluster:
+	$(call kill-redis,${CLUSTER_PID_PATHS})
+	rm -f appendonly.aof || true
+	rm -f ${CLUSTER_CONF_PATHS} || true
+
+start_cluster: ${BINARY}
+	for port in ${CLUSTER_PORTS}; do                    \
+		${BINARY}                                         \
+			--daemonize            yes                      \
+			--appendonly           yes                      \
+			--cluster-enabled      yes                      \
+			--cluster-config-file  ${TMP}/nodes$$port.conf  \
+			--cluster-node-timeout 5000                     \
+			--pidfile              ${TMP}/redis$$port.pid   \
+			--port                 $$port                   \
+			--unixsocket           ${TMP}/redis$$port.sock; \
+	done
+
+create_cluster:
+	yes yes | ((bundle exec ruby ${REDIS_TRIB} create --replicas 1 ${CLUSTER_ADDRS}) || \
+		(${REDIS_CLIENT} --cluster create ${CLUSTER_ADDRS} --cluster-replicas 1))
+
+clean:
+	(test -d ${BUILD_DIR} && cd ${BUILD_DIR}/src && make clean distclean) || true
+
+.PHONY: all test stop start stop_cluster start_cluster create_cluster clean

data/redis.gemspec

@@ -1,8 +1,4 @@
-# -*- encoding: utf-8 -*-
-
-$:.unshift File.expand_path("../lib", __FILE__)
-
-require "redis/version"
+require "./lib/redis/version"
 
 Gem::Specification.new do |s|
   s.name = "redis"
@@ -15,8 +11,7 @@ Gem::Specification.new do |s|
 
   s.description = <<-EOS
     A Ruby client that tries to match Redis' API one-to-one, while still
-    providing an idiomatic interface. It features thread-safety,
-    client-side sharding, pipelining, and an obsession for performance.
+    providing an idiomatic interface.
   EOS
 
   s.license = "MIT"
@@ -37,8 +32,12 @@ Gem::Specification.new do |s|
 
   s.files         = `git ls-files`.split("\n")
   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.executables   = `git ls-files -- exe/*`.split("\n").map{ |f| File.basename(f) }
+
+  s.required_ruby_version = '>= 2.2.2'
 
-  s.add_development_dependency("rake", "<11.0.0")
-  s.add_development_dependency("test-unit", "3.1.5")
+  s.add_development_dependency("test-unit", ">= 3.1.5")
+  s.add_development_dependency("mocha")
+  s.add_development_dependency("hiredis")
+  s.add_development_dependency("em-synchrony")
 end