redis 4.0.1 → 4.0.3

data/lib/redis/connection/ruby.rb

@@ -267,7 +267,10 @@ class Redis
           ssl_sock = new(tcp_sock, ctx)
           ssl_sock.hostname = host
           ssl_sock.connect
-          ssl_sock.post_connection_check(host)
+
+          unless ctx.verify_mode == OpenSSL::SSL::VERIFY_NONE
+            ssl_sock.post_connection_check(host)
+          end
 
           ssl_sock
         end
@@ -294,7 +297,7 @@ class Redis
         end
 
         instance = new(sock)
-        instance.timeout = config[:timeout]
+        instance.timeout = config[:read_timeout]
         instance.write_timeout = config[:write_timeout]
         instance.set_tcp_keepalive config[:tcp_keepalive]
         instance

data/lib/redis/distributed.rb

@@ -161,6 +161,14 @@ class Redis
       end
     end
 
+    # Unlink keys.
+    def unlink(*args)
+      keys_per_node = args.group_by { |key| node_for(key) }
+      keys_per_node.inject(0) do |sum, (node, keys)|
+        sum + node.unlink(*keys)
+      end
+    end
+
     # Determine if a key exists.
     def exists(key)
       node_for(key).exists(key)
@@ -692,8 +700,8 @@ class Redis
     end
 
     # Delete one or more hash fields.
-    def hdel(key, field)
-      node_for(key).hdel(key, field)
+    def hdel(key, *fields)
+      node_for(key).hdel(key, *fields)
     end
 
     # Determine if a hash field exists.

data/lib/redis/errors.rb

@@ -37,4 +37,50 @@ class Redis
   # Raised when the connection was inherited by a child process.
   class InheritedError < BaseConnectionError
   end
+
+  # Raised when client options are invalid.
+  class InvalidClientOptionError < BaseError
+  end
+
+  class Cluster
+    # Raised when client connected to redis as cluster mode
+    # and some cluster subcommands were called.
+    class OrchestrationCommandNotSupported < BaseError
+      def initialize(command, subcommand = '')
+        str = [command, subcommand].map(&:to_s).reject(&:empty?).join(' ').upcase
+        msg = "#{str} command should be used with care "\
+              'only by applications orchestrating Redis Cluster, like redis-trib, '\
+              'and the command if used out of the right context can leave the cluster '\
+              'in a wrong state or cause data loss.'
+        super(msg)
+      end
+    end
+
+    # Raised when error occurs on any node of cluster.
+    class CommandErrorCollection < BaseError
+      attr_reader :errors
+
+      # @param errors [Hash{String => Redis::CommandError}]
+      # @param error_message [String]
+      def initialize(errors, error_message = 'Command errors were replied on any node')
+        @errors = errors
+        super(error_message)
+      end
+    end
+
+    # Raised when cluster client can't select node.
+    class AmbiguousNodeError < BaseError
+      def initialize(command)
+        super("Cluster client doesn't know which node the #{command} command should be sent to.")
+      end
+    end
+
+    # Raised when commands in pipelining include cross slot keys.
+    class CrossSlotPipeliningError < BaseError
+      def initialize(keys)
+        super("Cluster client couldn't send pipelining to single node. "\
+              "The commands include cross slot keys. #{keys}")
+      end
+    end
+  end
 end

data/lib/redis/pipeline.rb

@@ -22,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.
@@ -86,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 = "4.0.1"
+  VERSION = "4.0.3"
 end

data/makefile

@@ -1,33 +1,43 @@
-TEST_FILES   := $(shell find test -name *_test.rb -type f)
-REDIS_BRANCH := unstable
-TMP          := tmp
-BUILD_DIR    := ${TMP}/redis-${REDIS_BRANCH}
-TARBALL      := ${TMP}/redis-${REDIS_BRANCH}.tar.gz
-BINARY       := ${BUILD_DIR}/src/redis-server
-PID_PATH     := ${BUILD_DIR}/redis.pid
-SOCKET_PATH  := ${BUILD_DIR}/redis.sock
-PORT         := 6381
+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})
 
-test: ${TEST_FILES}
+define kill-redis
+  (ls $1 2> /dev/null && kill $$(cat $1) && rm -f $1) || true
+endef
+
+all:
 	make start
-	env SOCKET_PATH=${SOCKET_PATH} \
-		ruby -v $$(echo $? | tr ' ' '\n' | awk '{ print "-r./" $$0 }') -e ''
+	make start_cluster
+	make create_cluster
+	make test
 	make stop
+	make stop_cluster
 
 ${TMP}:
-	mkdir $@
+	mkdir -p $@
 
-${TARBALL}: ${TMP}
-	wget https://github.com/antirez/redis/archive/${REDIS_BRANCH}.tar.gz -O $@
+${BINARY}: ${TMP}
+	bin/build ${REDIS_BRANCH} $<
 
-${BINARY}: ${TARBALL} ${TMP}
-	rm -rf ${BUILD_DIR}
-	mkdir -p ${BUILD_DIR}
-	tar xf ${TARBALL} -C ${TMP}
-	cd ${BUILD_DIR} && make
+test: ${TEST_FILES}
+	env SOCKET_PATH=${SOCKET_PATH} \
+		bundle exec ruby -v -e 'ARGV.each { |test_file| require test_file }' ${TEST_FILES}
 
 stop:
-	(test -f ${PID_PATH} && (kill $$(cat ${PID_PATH}) || true) && rm -f ${PID_PATH}) || true
+	$(call kill-redis,${PID_PATH})
 
 start: ${BINARY}
 	${BINARY}                     \
@@ -36,7 +46,29 @@ start: ${BINARY}
 		--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: test start stop
+.PHONY: all test stop start stop_cluster start_cluster create_cluster clean

data/redis.gemspec

@@ -32,11 +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("test-unit", ">= 3.1.5")
+  s.add_development_dependency("mocha")
   s.add_development_dependency("hiredis")
   s.add_development_dependency("em-synchrony")
 end

data/test/client_test.rb

@@ -56,4 +56,21 @@ class TestClient < Test::Unit::TestCase
 
     assert_equal result, ["OK", 1]
   end
+
+  def test_client_with_custom_connector
+    custom_connector = Class.new(Redis::Client::Connector) do
+      def resolve
+        @options[:host] = '127.0.0.5'
+        @options[:port] = '999'
+        @options
+      end
+    end
+
+    assert_raise_message(
+      'Error connecting to Redis on 127.0.0.5:999 (Errno::ECONNREFUSED)'
+    ) do
+      new_redis = _new_client(connector: custom_connector)
+      new_redis.ping
+    end
+  end
 end

data/test/cluster_abnormal_state_test.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+# ruby -w -Itest test/cluster_abnormal_state_test.rb
+class TestClusterAbnormalState < Test::Unit::TestCase
+  include Helper::Cluster
+
+  def test_the_state_of_cluster_down
+    redis_cluster_down do
+      assert_raise(Redis::CommandError, 'CLUSTERDOWN Hash slot not served') do
+        redis.set('key1', 1)
+      end
+
+      assert_equal 'fail', redis.cluster(:info).fetch('cluster_state')
+    end
+  end
+
+  def test_the_state_of_cluster_failover
+    redis_cluster_failover do
+      100.times do |i|
+        assert_equal 'OK', r.set("key#{i}", i)
+      end
+
+      100.times do |i|
+        assert_equal i.to_s, r.get("key#{i}")
+      end
+
+      assert_equal 'ok', redis.cluster(:info).fetch('cluster_state')
+    end
+  end
+
+  def test_raising_error_when_nodes_are_not_cluster_mode
+    assert_raise(Redis::CannotConnectError, 'Redis client could not connect to any cluster nodes') do
+      build_another_client(cluster: %W[redis://127.0.0.1:#{PORT}])
+    end
+  end
+end

data/test/cluster_blocking_commands_test.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require_relative 'lint/blocking_commands'
+
+# ruby -w -Itest test/cluster_blocking_commands_test.rb
+class TestClusterBlockingCommands < Test::Unit::TestCase
+  include Helper::Cluster
+  include Lint::BlockingCommands
+
+  def mock(options = {}, &blk)
+    commands = build_mock_commands(options)
+    redis_cluster_mock(commands, &blk)
+  end
+end

data/test/cluster_client_internals_test.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+# ruby -w -Itest test/cluster_client_internals_test.rb
+class TestClusterClientInternals < Test::Unit::TestCase
+  include Helper::Cluster
+
+  def test_handle_multiple_servers
+    100.times { |i| redis.set(i.to_s, "hogehoge#{i}") }
+    100.times { |i| assert_equal "hogehoge#{i}", redis.get(i.to_s) }
+  end
+
+  def test_info_of_cluster_mode_is_enabled
+    assert_equal '1', redis.info['cluster_enabled']
+  end
+
+  def test_unknown_commands_does_not_work_by_default
+    assert_raise(Redis::CommandError) do
+      redis.not_yet_implemented_command('boo', 'foo')
+    end
+  end
+
+  def test_with_reconnect
+    assert_equal('Hello World', redis.with_reconnect { 'Hello World' })
+  end
+
+  def test_without_reconnect
+    assert_equal('Hello World', redis.without_reconnect { 'Hello World' })
+  end
+
+  def test_connected?
+    assert_equal true, redis.connected?
+  end
+
+  def test_close
+    assert_equal true, redis.close
+  end
+
+  def test_disconnect!
+    assert_equal true, redis.disconnect!
+  end
+
+  def test_asking
+    assert_equal 'OK', redis.asking
+  end
+
+  def test_id
+    expected = 'redis://127.0.0.1:7000/0 '\
+               'redis://127.0.0.1:7001/0 '\
+               'redis://127.0.0.1:7002/0'
+    assert_equal expected, redis.id
+  end
+
+  def test_inspect
+    expected = "#<Redis client v#{Redis::VERSION} for "\
+               'redis://127.0.0.1:7000/0 '\
+               'redis://127.0.0.1:7001/0 '\
+               'redis://127.0.0.1:7002/0>'
+
+    assert_equal expected, redis.inspect
+  end
+
+  def test_dup
+    assert_instance_of Redis, redis.dup
+  end
+
+  def test_connection
+    expected = [
+      { host: '127.0.0.1', port: 7000, db: 0, id: 'redis://127.0.0.1:7000/0', location: '127.0.0.1:7000' },
+      { host: '127.0.0.1', port: 7001, db: 0, id: 'redis://127.0.0.1:7001/0', location: '127.0.0.1:7001' },
+      { host: '127.0.0.1', port: 7002, db: 0, id: 'redis://127.0.0.1:7002/0', location: '127.0.0.1:7002' }
+    ]
+
+    assert_equal expected, redis.connection
+  end
+end

data/test/cluster_client_key_hash_tags_test.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+# ruby -w -Itest test/cluster_client_key_hash_tags_test.rb
+class TestClusterClientKeyHashTags < Test::Unit::TestCase
+  include Helper::Cluster
+
+  def build_described_class
+    option = Redis::Cluster::Option.new(cluster: ['redis://127.0.0.1:7000'])
+    node = Redis::Cluster::Node.new(option.per_node_key)
+    details = Redis::Cluster::CommandLoader.load(node)
+    Redis::Cluster::Command.new(details)
+  end
+
+  def test_key_extraction
+    described_class = build_described_class
+
+    assert_equal 'dogs:1', described_class.extract_first_key(%w[get dogs:1])
+    assert_equal 'user1000', described_class.extract_first_key(%w[get {user1000}.following])
+    assert_equal 'user1000', described_class.extract_first_key(%w[get {user1000}.followers])
+    assert_equal 'foo{}{bar}', described_class.extract_first_key(%w[get foo{}{bar}])
+    assert_equal '{bar', described_class.extract_first_key(%w[get foo{{bar}}zap])
+    assert_equal 'bar', described_class.extract_first_key(%w[get foo{bar}{zap}])
+
+    assert_equal '', described_class.extract_first_key([:get, ''])
+    assert_equal '', described_class.extract_first_key([:get, nil])
+    assert_equal '', described_class.extract_first_key([:get])
+
+    assert_equal '', described_class.extract_first_key([:set, '', 1])
+    assert_equal '', described_class.extract_first_key([:set, nil, 1])
+    assert_equal '', described_class.extract_first_key([:set])
+
+    # Keyless commands
+    assert_equal '', described_class.extract_first_key([:auth, 'password'])
+    assert_equal '', described_class.extract_first_key(%i[client kill])
+    assert_equal '', described_class.extract_first_key(%i[cluster addslots])
+    assert_equal '', described_class.extract_first_key(%i[command])
+    assert_equal '', described_class.extract_first_key(%i[command count])
+    assert_equal '', described_class.extract_first_key(%i[config get])
+    assert_equal '', described_class.extract_first_key(%i[debug segfault])
+    assert_equal '', described_class.extract_first_key([:echo, 'Hello World'])
+    assert_equal '', described_class.extract_first_key([:flushall, 'ASYNC'])
+    assert_equal '', described_class.extract_first_key([:flushdb, 'ASYNC'])
+    assert_equal '', described_class.extract_first_key([:info, 'cluster'])
+    assert_equal '', described_class.extract_first_key(%i[memory doctor])
+    assert_equal '', described_class.extract_first_key([:ping, 'Hi'])
+    assert_equal '', described_class.extract_first_key([:psubscribe, 'channel'])
+    assert_equal '', described_class.extract_first_key([:pubsub, 'channels', '*'])
+    assert_equal '', described_class.extract_first_key([:publish, 'channel', 'Hi'])
+    assert_equal '', described_class.extract_first_key([:punsubscribe, 'channel'])
+    assert_equal '', described_class.extract_first_key([:subscribe, 'channel'])
+    assert_equal '', described_class.extract_first_key([:unsubscribe, 'channel'])
+    assert_equal '', described_class.extract_first_key(%w[script exists sha1 sha1])
+    assert_equal '', described_class.extract_first_key([:select, 1])
+    assert_equal '', described_class.extract_first_key([:shutdown, 'SAVE'])
+    assert_equal '', described_class.extract_first_key([:slaveof, '127.0.0.1', 6379])
+    assert_equal '', described_class.extract_first_key([:slowlog, 'get', 2])
+    assert_equal '', described_class.extract_first_key([:swapdb, 0, 1])
+    assert_equal '', described_class.extract_first_key([:wait, 1, 0])
+
+    # 2nd argument is not a key
+    assert_equal 'key1', described_class.extract_first_key([:eval, 'script', 2, 'key1', 'key2', 'first', 'second'])
+    assert_equal '', described_class.extract_first_key([:eval, 'return 0', 0])
+    assert_equal 'key1', described_class.extract_first_key([:evalsha, 'sha1', 2, 'key1', 'key2', 'first', 'second'])
+    assert_equal '', described_class.extract_first_key([:evalsha, 'return 0', 0])
+    assert_equal 'key1', described_class.extract_first_key([:migrate, '127.0.0.1', 6379, 'key1', 0, 5000])
+    assert_equal 'key1', described_class.extract_first_key([:memory, :usage, 'key1'])
+    assert_equal 'key1', described_class.extract_first_key([:object, 'refcount', 'key1'])
+    assert_equal 'mystream', described_class.extract_first_key([:xread, 'COUNT', 2, 'STREAMS', 'mystream', 0])
+    assert_equal 'mystream', described_class.extract_first_key([:xreadgroup, 'GROUP', 'mygroup', 'Bob', 'COUNT', 2, 'STREAMS', 'mystream', '>'])
+  end
+
+  def test_whether_the_command_effect_is_readonly_or_not
+    described_class = build_described_class
+
+    assert_equal true,  described_class.should_send_to_master?([:set])
+    assert_equal false, described_class.should_send_to_slave?([:set])
+
+    assert_equal false, described_class.should_send_to_master?([:get])
+    assert_equal true,  described_class.should_send_to_slave?([:get])
+
+    target_version('3.2.0') do
+      assert_equal false, described_class.should_send_to_master?([:info])
+      assert_equal false, described_class.should_send_to_slave?([:info])
+    end
+  end
+end