redis 4.0.2 → 4.0.3

data/lib/redis/cluster/slot_loader.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../errors'
+require_relative 'node_key'
+
+class Redis
+  class Cluster
+    # Load and hashify slot info for Redis Cluster Client
+    module SlotLoader
+      module_function
+
+      def load(nodes)
+        info = {}
+
+        nodes.each do |node|
+          info = Hash[*fetch_slot_info(node)]
+          info.empty? ? next : break
+        end
+
+        return info unless info.empty?
+
+        raise CannotConnectError, 'Redis client could not connect to any cluster nodes'
+      end
+
+      def fetch_slot_info(node)
+        node.call(%i[cluster slots])
+            .map { |arr| parse_slot_info(arr, default_ip: node.host) }
+            .flatten
+      rescue CannotConnectError, ConnectionError, CommandError
+        {} # can retry on another node
+      end
+
+      def parse_slot_info(arr, default_ip:)
+        first_slot, last_slot = arr[0..1]
+        slot_range = (first_slot..last_slot).freeze
+        arr[2..-1].map { |addr| [stringify_node_key(addr, default_ip), slot_range] }
+                  .flatten
+      end
+
+      def stringify_node_key(arr, default_ip)
+        ip, port = arr
+        ip = default_ip if ip.empty? # When cluster is down
+        NodeKey.build_from_host_port(ip, port)
+      end
+    end
+  end
+end

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/version.rb

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

data/makefile

@@ -1,27 +1,43 @@
-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
-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} \
-		bundle exec ruby -v -e 'ARGV.each { |test_file| require test_file }' ${TEST_FILES}
+	make start_cluster
+	make create_cluster
+	make test
 	make stop
+	make stop_cluster
 
 ${TMP}:
-	mkdir $@
+	mkdir -p $@
 
 ${BINARY}: ${TMP}
-	bin/build ${REDIS_BRANCH} ${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:
-	(test -f ${PID_PATH} && (kill $$(cat ${PID_PATH}) || true) && rm -f ${PID_PATH}) || true
+	$(call kill-redis,${PID_PATH})
 
 start: ${BINARY}
 	${BINARY}                     \
@@ -30,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