redis 3.3.5 → 4.0.3

data/test/publish_subscribe_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestPublishSubscribe < Test::Unit::TestCase
 

data/test/remote_server_control_commands_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestRemoteServerControlCommands < Test::Unit::TestCase
 
@@ -115,4 +113,63 @@ class TestRemoteServerControlCommands < Test::Unit::TestCase
     result = r.slowlog(:len)
     assert_equal 0, result
   end
+
+  def test_client
+    assert_equal r.instance_variable_get(:@client), r._client
+  end
+
+  def test_client_list
+    return if version < "2.4.0"
+
+    keys = [
+     "addr",
+     "fd",
+     "name",
+     "age",
+     "idle",
+     "flags",
+     "db",
+     "sub",
+     "psub",
+     "multi",
+     "qbuf",
+     "qbuf-free",
+     "obl",
+     "oll",
+     "omem",
+     "events",
+     "cmd"
+    ]
+
+    clients = r.client(:list)
+    clients.each do |client|
+      keys.each do |k|
+        msg = "expected #client(:list) to include #{k}"
+        assert client.keys.include?(k), msg
+      end
+    end
+  end
+
+  def test_client_kill
+    return if version < "2.6.9"
+
+    r.client(:setname, 'redis-rb')
+    clients = r.client(:list)
+    i = clients.index {|client| client['name'] == 'redis-rb'}
+    assert_equal "OK", r.client(:kill, clients[i]["addr"])
+
+    clients = r.client(:list)
+    i = clients.index {|client| client['name'] == 'redis-rb'}
+    assert_equal nil, i
+  end
+
+  def test_client_getname_and_setname
+    return if version < "2.6.9"
+
+    assert_equal nil, r.client(:getname)
+
+    r.client(:setname, 'redis-rb')
+    name = r.client(:getname)
+    assert_equal 'redis-rb', name
+  end
 end

data/test/scanning_test.rb

@@ -1,10 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-
-unless defined?(Enumerator)
-  Enumerator = Enumerable::Enumerator
-end
+require_relative "helper"
 
 class TestScanning < Test::Unit::TestCase
 

data/test/scripting_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestScripting < Test::Unit::TestCase
 

data/test/sentinel_command_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class SentinelCommandsTest < Test::Unit::TestCase
 

data/test/sentinel_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class SentinelTest < Test::Unit::TestCase
 

data/test/sorting_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestSorting < Test::Unit::TestCase
 

data/test/ssl_test.rb

@@ -1,73 +1,69 @@
-# encoding: UTF-8
+require_relative "helper"
 
-if RUBY_VERSION >= "1.9.3"
-  require File.expand_path("helper", File.dirname(__FILE__))
+class SslTest < Test::Unit::TestCase
 
-  class SslTest < Test::Unit::TestCase
+  include Helper::Client
 
-    include Helper::Client
+  driver(:ruby) do
 
-    driver(:ruby) do
-
-      def test_verified_ssl_connection
-        RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("trusted")) do |port|
-          redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
-          assert_equal redis.ping, "PONG"
-        end
-      end
-
-      def test_unverified_ssl_connection
-        assert_raise(OpenSSL::SSL::SSLError) do
-          RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("untrusted")) do |port|
-            redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
-            redis.ping
-          end
-        end
+    def test_verified_ssl_connection
+      RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("trusted")) do |port|
+        redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
+        assert_equal redis.ping, "PONG"
       end
+    end
 
-      def test_ssl_blocking
-        RedisMock.start({}, ssl_server_opts("trusted")) do |port|
+    def test_unverified_ssl_connection
+      assert_raise(OpenSSL::SSL::SSLError) do
+        RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("untrusted")) do |port|
           redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
-          assert_equal redis.set("boom", "a" * 10_000_000), "OK"
+          redis.ping
         end
       end
+    end
 
+    def test_ssl_blocking
+      RedisMock.start({}, ssl_server_opts("trusted")) do |port|
+        redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
+        assert_equal redis.set("boom", "a" * 10_000_000), "OK"
+      end
     end
 
-    driver(:hiredis, :synchrony) do
+  end
+
+  driver(:hiredis, :synchrony) do
 
-      def test_ssl_not_implemented_exception
-        assert_raise(NotImplementedError) do
-          RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("trusted")) do |port|
-            redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
-            redis.ping
-          end
+    def test_ssl_not_implemented_exception
+      assert_raise(NotImplementedError) do
+        RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("trusted")) do |port|
+          redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
+          redis.ping
         end
       end
-
     end
 
-    private
+  end
+
+  private
 
-    def ssl_server_opts(prefix)
-      ssl_cert = File.join(cert_path, "#{prefix}-cert.crt")
-      ssl_key  = File.join(cert_path, "#{prefix}-cert.key")
+  def ssl_server_opts(prefix)
+    ssl_cert = File.join(cert_path, "#{prefix}-cert.crt")
+    ssl_key  = File.join(cert_path, "#{prefix}-cert.key")
 
-      {
-        :ssl => true,
-        :ssl_params => {
-          :cert => OpenSSL::X509::Certificate.new(File.read(ssl_cert)),
-          :key  => OpenSSL::PKey::RSA.new(File.read(ssl_key))
-        }
+    {
+      :ssl => true,
+      :ssl_params => {
+        :cert => OpenSSL::X509::Certificate.new(File.read(ssl_cert)),
+        :key  => OpenSSL::PKey::RSA.new(File.read(ssl_key))
       }
-    end
+    }
+  end
 
-    def ssl_ca_file
-      File.join(cert_path, "trusted-ca.crt")
-    end
+  def ssl_ca_file
+    File.join(cert_path, "trusted-ca.crt")
+  end
 
-    def cert_path
-      File.expand_path("../support/ssl/", __FILE__)
-    end
+  def cert_path
+    File.expand_path("../support/ssl/", __FILE__)
   end
 end

data/test/support/cluster/orchestrator.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/redis'
+
+class ClusterOrchestrator
+  SLOT_SIZE = 16384
+
+  def initialize(node_addrs)
+    raise 'Redis Cluster requires at least 3 master nodes.' if node_addrs.size < 3
+    @clients = node_addrs.map { |addr| Redis.new(url: addr) }
+  end
+
+  def rebuild
+    flush_all_data(@clients)
+    reset_cluster(@clients)
+    assign_slots(@clients)
+    save_config_epoch(@clients)
+    meet_each_other(@clients)
+    wait_meeting(@clients)
+    replicate(@clients)
+    save_config(@clients)
+    wait_cluster_building(@clients)
+    sleep 3
+  end
+
+  def down
+    flush_all_data(@clients)
+    reset_cluster(@clients)
+  end
+
+  def failover
+    take_slaves(@clients).last.cluster(:failover, :takeover)
+    sleep 3
+  end
+
+  def start_resharding(slot, src_node_key, dest_node_key)
+    node_map = hashify_node_map(@clients.first)
+    src_node_id = node_map.fetch(src_node_key)
+    src_client = find_client(@clients, src_node_key)
+    dest_node_id = node_map.fetch(dest_node_key)
+    dest_client = find_client(@clients, dest_node_key)
+    dest_host, dest_port = dest_node_key.split(':')
+
+    dest_client.cluster(:setslot, slot, 'IMPORTING', src_node_id)
+    src_client.cluster(:setslot, slot, 'MIGRATING', dest_node_id)
+
+    loop do
+      keys = src_client.cluster(:getkeysinslot, slot, 100)
+      break if keys.empty?
+      keys.each { |k| src_client.migrate(k, host: dest_host, port: dest_port) }
+      sleep 0.1
+    end
+  end
+
+  def finish_resharding(slot, dest_node_key)
+    node_map = hashify_node_map(@clients.first)
+    @clients.first.cluster(:setslot, slot, 'NODE', node_map.fetch(dest_node_key))
+  end
+
+  def close
+    @clients.each(&:quit)
+  end
+
+  private
+
+  def flush_all_data(clients)
+    clients.each do |c|
+      begin
+        c.flushall
+      rescue Redis::CommandError
+        # READONLY You can't write against a read only slave.
+        nil
+      end
+    end
+  end
+
+  def reset_cluster(clients)
+    clients.each { |c| c.cluster(:reset) }
+  end
+
+  def assign_slots(clients)
+    masters = take_masters(clients)
+    slot_slice = SLOT_SIZE / masters.size
+    mod = SLOT_SIZE % masters.size
+    slot_sizes = Array.new(masters.size, slot_slice)
+    mod.downto(1) { |i| slot_sizes[i] += 1 }
+
+    slot_idx = 0
+    masters.zip(slot_sizes).each do |c, s|
+      slot_range = slot_idx..slot_idx + s - 1
+      c.cluster(:addslots, *slot_range.to_a)
+      slot_idx += s
+    end
+  end
+
+  def save_config_epoch(clients)
+    clients.each_with_index do |c, i|
+      begin
+        c.cluster('set-config-epoch', i + 1)
+      rescue Redis::CommandError
+        # ERR Node config epoch is already non-zero
+        nil
+      end
+    end
+  end
+
+  def meet_each_other(clients)
+    first_cliient = clients.first
+    target_info = first_cliient.connection
+    target_host = target_info.fetch(:host)
+    target_port = target_info.fetch(:port)
+
+    clients.each do |client|
+      next if first_cliient.id == client.id
+      client.cluster(:meet, target_host, target_port)
+    end
+  end
+
+  def wait_meeting(clients)
+    first_cliient = clients.first
+    size = clients.size
+
+    loop do
+      info = hashify_cluster_info(first_cliient)
+      break if info['cluster_known_nodes'].to_i == size
+      sleep 0.1
+    end
+  end
+
+  def replicate(clients)
+    node_map = hashify_node_map(clients.first)
+    masters = take_masters(clients)
+
+    take_slaves(clients).each_with_index do |slave, i|
+      master_info = masters[i].connection
+      master_host = master_info.fetch(:host)
+      master_port = master_info.fetch(:port)
+
+      loop do
+        begin
+          master_node_id = node_map.fetch("#{master_host}:#{master_port}")
+          slave.cluster(:replicate, master_node_id)
+        rescue Redis::CommandError
+          # ERR Unknown node [key]
+          sleep 0.1
+          node_map = hashify_node_map(clients.first)
+          next
+        end
+
+        break
+      end
+    end
+  end
+
+  def save_config(clients)
+    clients.each { |c| c.cluster(:saveconfig) }
+  end
+
+  def wait_cluster_building(clients)
+    first_cliient = clients.first
+
+    loop do
+      info = hashify_cluster_info(first_cliient)
+      break if info['cluster_state'] == 'ok'
+      sleep 0.1
+    end
+  end
+
+  def hashify_cluster_info(client)
+    client.cluster(:info).split("\r\n").map { |str| str.split(':') }.to_h
+  end
+
+  def hashify_node_map(client)
+    client.cluster(:nodes)
+          .split("\n")
+          .map { |str| str.split(' ') }
+          .map { |arr| [arr[1].split('@').first, arr[0]] }
+          .to_h
+  end
+
+  def take_masters(clients)
+    size = clients.size / 2
+    return clients if size < 3
+    clients.take(size)
+  end
+
+  def take_slaves(clients)
+    size = clients.size / 2
+    return [] if size < 3
+    clients[size..size * 2]
+  end
+
+  def find_client(clients, node_key)
+    clients.find do |cli|
+      con = cli.connection
+      node_key == "#{con.fetch(:host)}:#{con.fetch(:port)}"
+    end
+  end
+end

data/test/support/connection/hiredis.rb

@@ -1 +1 @@
-require "support/wire/thread"
+require_relative "../wire/thread"

data/test/support/connection/ruby.rb

@@ -1 +1 @@
-require "support/wire/thread"
+require_relative "../wire/thread"

data/test/support/connection/synchrony.rb

@@ -1,4 +1,4 @@
-require "support/wire/synchrony"
+require_relative "../wire/synchrony"
 
 module Helper
   def around

data/test/support/redis_mock.rb

@@ -42,7 +42,7 @@ module RedisMock
           end
         end
       rescue => ex
-        $stderr.puts "Error running mock server: #{ex.message}"
+        $stderr.puts "Error running mock server: #{ex.class}: #{ex.message}"
         $stderr.puts ex.backtrace
         retry
       ensure

data/test/synchrony_driver.rb

@@ -1,13 +1,10 @@
-# encoding: UTF-8
+require "em-synchrony"
+require "em-synchrony/connection_pool"
 
-require 'em-synchrony'
-require 'em-synchrony/connection_pool'
+require_relative "../lib/redis"
+require_relative "../lib/redis/connection/synchrony"
 
-require 'redis'
-require 'redis/connection/synchrony'
-
-
-require File.expand_path("./helper", File.dirname(__FILE__))
+require_relative "helper"
 
 PORT    = 6381
 OPTIONS = {:port => PORT, :db => 15}
@@ -55,7 +52,7 @@ EM.synchrony do
   assert_equal "s2", r.lpop("foo")
   assert_equal "s1", r.lpop("foo")
 
-  assert_equal "OK", r.client.call(:quit)
+  assert_equal "OK", r._client.call(:quit)
   assert_equal "PONG", r.ping
 
 

data/test/thread_safety_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestThreadSafety < Test::Unit::TestCase
 

data/test/transactions_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestTransactions < Test::Unit::TestCase
 
@@ -116,6 +114,16 @@ class TestTransactions < Test::Unit::TestCase
     assert_equal "s1", r.get("foo")
   end
 
+  def test_empty_multi_exec
+    result = nil
+
+    redis_mock(:exec => lambda { |*_| "-ERROR" }) do |redis|
+      result = redis.multi {}
+    end
+
+    assert_equal [], result
+  end
+
   def test_raise_command_errors_when_accessing_futures_after_multi_exec
     begin
       r.multi do |m|

data/test/unknown_commands_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestUnknownCommands < Test::Unit::TestCase