redis 4.1.0.beta1 → 4.1.0

data/test/ssl_test.rb

@@ -1,69 +0,0 @@
-require_relative "helper"
-
-class SslTest < Test::Unit::TestCase
-
-  include Helper::Client
-
-  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
-    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
-
-  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
-      end
-    end
-
-  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")
-
-    {
-      :ssl => true,
-      :ssl_params => {
-        :cert => OpenSSL::X509::Certificate.new(File.read(ssl_cert)),
-        :key  => OpenSSL::PKey::RSA.new(File.read(ssl_key))
-      }
-    }
-  end
-
-  def ssl_ca_file
-    File.join(cert_path, "trusted-ca.crt")
-  end
-
-  def cert_path
-    File.expand_path("../support/ssl/", __FILE__)
-  end
-end

data/test/support/cluster/orchestrator.rb

@@ -1,199 +0,0 @@
-# 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 +0,0 @@
-require_relative "../wire/thread"

data/test/support/connection/ruby.rb

@@ -1 +0,0 @@
-require_relative "../wire/thread"

data/test/support/connection/synchrony.rb

@@ -1,17 +0,0 @@
-require_relative "../wire/synchrony"
-
-module Helper
-  def around
-    rv = nil
-
-    EM.synchrony do
-      begin
-        rv = yield
-      ensure
-        EM.stop
-      end
-    end
-
-    rv
-  end
-end

data/test/support/redis_mock.rb

@@ -1,130 +0,0 @@
-require "socket"
-
-module RedisMock
-  class Server
-    def initialize(options = {}, &block)
-      tcp_server = TCPServer.new(options[:host] || "127.0.0.1", 0)
-      tcp_server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
-
-      if options[:ssl]
-        ctx = OpenSSL::SSL::SSLContext.new
-
-        ssl_params = options.fetch(:ssl_params, {})
-        ctx.set_params(ssl_params) unless ssl_params.empty?
-
-        @server = OpenSSL::SSL::SSLServer.new(tcp_server, ctx)
-      else
-        @server = tcp_server
-      end
-    end
-
-    def port
-      @server.addr[1]
-    end
-
-    def start(&block)
-      @thread = Thread.new { run(&block) }
-    end
-
-    def shutdown
-      @thread.kill
-    end
-
-    def run
-      begin
-        loop do
-          session = @server.accept
-
-          begin
-            return if yield(session) == :exit
-          ensure
-            session.close
-          end
-        end
-      rescue => ex
-        $stderr.puts "Error running mock server: #{ex.class}: #{ex.message}"
-        $stderr.puts ex.backtrace
-        retry
-      ensure
-        @server.close
-      end
-    end
-  end
-
-  # Starts a mock Redis server in a thread.
-  #
-  # The server will use the lambda handler passed as argument to handle
-  # connections. For example:
-  #
-  #   handler = lambda { |session| session.close }
-  #   RedisMock.start_with_handler(handler) do
-  #     # Every connection will be closed immediately
-  #   end
-  #
-  def self.start_with_handler(blk, options = {})
-    server = Server.new(options)
-    port = server.port
-
-    begin
-      server.start(&blk)
-      yield(port)
-    ensure
-      server.shutdown
-    end
-  end
-
-  # Starts a mock Redis server in a thread.
-  #
-  # The server will reply with a `+OK` to all commands, but you can
-  # customize it by providing a hash. For example:
-  #
-  #   RedisMock.start(:ping => lambda { "+PONG" }) do |port|
-  #     assert_equal "PONG", Redis.new(:port => port).ping
-  #   end
-  #
-  def self.start(commands, options = {}, &blk)
-    handler = lambda do |session|
-      while line = session.gets
-        argv = Array.new(line[1..-3].to_i) do
-          bytes = session.gets[1..-3].to_i
-          arg = session.read(bytes)
-          session.read(2) # Discard \r\n
-          arg
-        end
-
-        command = argv.shift
-        blk = commands[command.to_sym]
-        blk ||= lambda { |*_| "+OK" }
-
-        response = blk.call(*argv)
-
-        # Convert a nil response to :close
-        response ||= :close
-
-        if response == :exit
-          break :exit
-        elsif response == :close
-          break :close
-        elsif response.is_a?(Array)
-          session.write("*%d\r\n" % response.size)
-
-          response.each do |resp|
-            if resp.is_a?(Array)
-              session.write("*%d\r\n" % resp.size)
-              resp.each do |r|
-                session.write("$%d\r\n%s\r\n" % [r.length, r])
-              end
-            else
-              session.write("$%d\r\n%s\r\n" % [resp.length, resp])
-            end
-          end
-        else
-          session.write(response)
-          session.write("\r\n") unless response.end_with?("\r\n")
-        end
-      end
-    end
-
-    start_with_handler(handler, options, &blk)
-  end
-end

data/test/support/ssl/gen_certs.sh

@@ -1,31 +0,0 @@
-#!/bin/sh
-
-get_subject() {
-  if [ "$1" = "trusted" ]
-  then
-    echo "/C=IT/ST=Sicily/L=Catania/O=Redis/OU=Security/CN=127.0.0.1"
-  else
-    echo "/C=XX/ST=Untrusted/L=Evilville/O=Evil Hacker/OU=Attack Department/CN=127.0.0.1"
-  fi
-}
-
-# Generate two CAs: one to be considered trusted, and one that's untrusted
-for type in trusted untrusted; do
-  rm -rf ./demoCA
-  mkdir -p ./demoCA
-  mkdir -p ./demoCA/certs
-  mkdir -p ./demoCA/crl
-  mkdir -p ./demoCA/newcerts
-  mkdir -p ./demoCA/private
-  touch ./demoCA/index.txt
-
-  openssl genrsa -out ${type}-ca.key 2048
-  openssl req -new -x509 -days 12500 -key ${type}-ca.key -out ${type}-ca.crt -subj "$(get_subject $type)"
-  openssl x509 -in ${type}-ca.crt -noout -next_serial -out ./demoCA/serial
-
-  openssl req -newkey rsa:2048 -keyout ${type}-cert.key -nodes -out ${type}-cert.req -subj "$(get_subject $type)"
-  openssl ca -days 12500 -cert ${type}-ca.crt -keyfile ${type}-ca.key -out ${type}-cert.crt -infiles ${type}-cert.req
-  rm ${type}-cert.req
-done
-
-rm -rf ./demoCA