redis-client 0.1.0

data/lib/redis_client/resp3.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "set"
+
+class RedisClient
+  module RESP3
+    module_function
+
+    Error = Class.new(RedisClient::Error)
+    UnknownType = Class.new(Error)
+    SyntaxError = Class.new(Error)
+
+    EOL = "\r\n".b.freeze
+    EOL_SIZE = EOL.bytesize
+    DUMP_TYPES = {
+      String => :dump_string,
+      Symbol => :dump_symbol,
+      Integer => :dump_numeric,
+      Float => :dump_numeric,
+    }.freeze
+    PARSER_TYPES = {
+      '#' => :parse_boolean,
+      '$' => :parse_blob,
+      '+' => :parse_string,
+      '=' => :parse_verbatim_string,
+      '-' => :parse_error,
+      ':' => :parse_integer,
+      '(' => :parse_integer,
+      ',' => :parse_double,
+      '_' => :parse_null,
+      '*' => :parse_array,
+      '%' => :parse_map,
+      '~' => :parse_set,
+      '>' => :parse_array,
+    }.transform_keys(&:ord).freeze
+    INTEGER_RANGE = ((((2**64) / 2) * -1)..(((2**64) / 2) - 1)).freeze
+
+    def dump(command, buffer = nil)
+      buffer ||= new_buffer
+      command = command.flat_map do |element|
+        case element
+        when Hash
+          element.flatten
+        when Set
+          element.to_a
+        else
+          element
+        end
+      end
+      dump_array(command, buffer)
+    end
+
+    def load(io)
+      parse(io)
+    end
+
+    def new_buffer
+      String.new(encoding: Encoding::BINARY, capacity: 128)
+    end
+
+    def coerce_command!(command)
+      command = command.flat_map do |element|
+        case element
+        when Hash
+          element.flatten
+        when Set
+          element.to_a
+        else
+          element
+        end
+      end
+
+      command.map! do |element|
+        case element
+        when String
+          element
+        when Integer, Float, Symbol
+          element.to_s
+        else
+          raise TypeError, "Unsupported command argument type: #{element.class}"
+        end
+      end
+
+      command
+    end
+
+    def dump_any(object, buffer)
+      method = DUMP_TYPES.fetch(object.class) do
+        raise TypeError, "Unsupported command argument type: #{object.class}"
+      end
+      send(method, object, buffer)
+    end
+
+    def dump_array(array, buffer)
+      buffer << '*' << array.size.to_s << EOL
+      array.each do |item|
+        dump_any(item, buffer)
+      end
+      buffer
+    end
+
+    def dump_set(set, buffer)
+      buffer << '~' << set.size.to_s << EOL
+      set.each do |item|
+        dump_any(item, buffer)
+      end
+      buffer
+    end
+
+    def dump_hash(hash, buffer)
+      buffer << '%' << hash.size.to_s << EOL
+      hash.each_pair do |key, value|
+        dump_any(key, buffer)
+        dump_any(value, buffer)
+      end
+      buffer
+    end
+
+    def dump_numeric(numeric, buffer)
+      dump_string(numeric.to_s, buffer)
+    end
+
+    def dump_string(string, buffer)
+      string = string.b unless string.ascii_only?
+      buffer << '$' << string.bytesize.to_s << EOL << string << EOL
+    end
+
+    if Symbol.method_defined?(:name)
+      def dump_symbol(symbol, buffer)
+        dump_string(symbol.name, buffer)
+      end
+    else
+      def dump_symbol(symbol, buffer)
+        dump_string(symbol.to_s, buffer)
+      end
+    end
+
+    def parse(io)
+      type = io.getbyte
+      method = PARSER_TYPES.fetch(type) do
+        raise UnknownType, "Unknown sigil type: #{type.chr.inspect}"
+      end
+      send(method, io)
+    end
+
+    def parse_string(io)
+      str = io.gets_chomp
+      str.force_encoding(Encoding.default_external)
+      str.force_encoding(Encoding::BINARY) unless str.valid_encoding?
+      str
+    end
+
+    def parse_error(io)
+      CommandError.parse(parse_string(io))
+    end
+
+    def parse_boolean(io)
+      case value = io.gets_chomp
+      when "t"
+        true
+      when "f"
+        false
+      else
+        raise SyntaxError, "Expected `t` or `f` after `#`, got: #{value}"
+      end
+    end
+
+    def parse_array(io)
+      parse_sequence(io, parse_integer(io))
+    end
+
+    def parse_set(io)
+      parse_sequence(io, parse_integer(io)).to_set
+    end
+
+    def parse_map(io)
+      Hash[*parse_sequence(io, parse_integer(io) * 2)]
+    end
+
+    def parse_push(io)
+      parse_array(io)
+    end
+
+    def parse_sequence(io, size)
+      array = Array.new(size)
+      size.times do |index|
+        array[index] = parse(io)
+      end
+      array
+    end
+
+    def parse_integer(io)
+      Integer(io.gets_chomp)
+    end
+
+    def parse_double(io)
+      case value = io.gets_chomp
+      when "inf"
+        Float::INFINITY
+      when "-inf"
+        -Float::INFINITY
+      else
+        Float(value)
+      end
+    end
+
+    def parse_null(io)
+      io.skip(EOL_SIZE)
+      nil
+    end
+
+    def parse_blob(io)
+      bytesize = parse_integer(io)
+      str = io.read_chomp(bytesize)
+      str.force_encoding(Encoding.default_external)
+      str.force_encoding(Encoding::BINARY) unless str.valid_encoding?
+      str
+    end
+
+    def parse_verbatim_string(io)
+      blob = parse_blob(io)
+      blob.byteslice(4..-1)
+    end
+  end
+end

data/lib/redis_client/sentinel_config.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+class RedisClient
+  class SentinelConfig
+    include Config::Common
+
+    SENTINEL_DELAY = 0.25
+    DEFAULT_RECONNECT_ATTEMPTS = 2
+
+    def initialize(name:, sentinels:, role: :master, **client_config)
+      unless %i(master replica slave).include?(role)
+        raise ArgumentError, "Expected role to be either :master or :replica, got: #{role.inspect}"
+      end
+
+      @name = name
+      @sentinel_configs = sentinels.map { |s| Config.new(**s) }
+      @sentinels = {}.compare_by_identity
+      @role = role
+      @mutex = Mutex.new
+      @config = nil
+
+      client_config[:reconnect_attempts] ||= DEFAULT_RECONNECT_ATTEMPTS
+      @client_config = client_config || {}
+      super(**client_config)
+    end
+
+    def sentinels
+      @mutex.synchronize do
+        @sentinel_configs.dup
+      end
+    end
+
+    def reset
+      @mutex.synchronize do
+        @config = nil
+      end
+    end
+
+    def host
+      config.host
+    end
+
+    def port
+      config.port
+    end
+
+    def path
+      nil
+    end
+
+    def retry_connecting?(attempt, error)
+      reset unless error.is_a?(TimeoutError)
+      super
+    end
+
+    def sentinel?
+      true
+    end
+
+    def check_role!(role)
+      if @role == :master
+        unless role == "master"
+          sleep SENTINEL_DELAY
+          raise FailoverError, "Expected to connect to a master, but the server is a replica"
+        end
+      else
+        unless role == "slave"
+          sleep SENTINEL_DELAY
+          raise FailoverError, "Expected to connect to a replica, but the server is a master"
+        end
+      end
+    end
+
+    private
+
+    def config
+      @mutex.synchronize do
+        @config ||= if @role == :master
+          resolve_master
+        else
+          resolve_replica
+        end
+      end
+    end
+
+    def resolve_master
+      each_sentinel do |sentinel_client|
+        host, port = sentinel_client.call("SENTINEL", "get-master-addr-by-name", @name)
+        if host && port
+          return Config.new(host: host, port: Integer(port), **@client_config)
+        end
+      end
+      raise ConnectionError, "Couldn't locate a master for role: #{@name}"
+    end
+
+    def sentinel_client(sentinel_config)
+      @sentinels[sentinel_config] ||= sentinel_config.new_client
+    end
+
+    def resolve_replica
+      each_sentinel do |sentinel_client|
+        replicas = sentinel_client.call("SENTINEL", "replicas", @name)
+        next if replicas.empty?
+
+        replica = replicas.reject { |r| r["flags"].to_s.split(",").include?("disconnected") }.sample
+        replica ||= replicas.sample
+        return Config.new(host: replica["ip"], port: Integer(replica["port"]), **@client_config)
+      end
+      raise ConnectionError, "Couldn't locate a replica for role: #{@name}"
+    end
+
+    def each_sentinel
+      last_error = nil
+
+      @sentinel_configs.dup.each do |sentinel_config|
+        sentinel_client = sentinel_client(sentinel_config)
+        success = true
+        begin
+          yield sentinel_client
+        rescue RedisClient::Error => error
+          last_error = error
+          success = false
+          sleep SENTINEL_DELAY
+        ensure
+          if success
+            @sentinel_configs.unshift(@sentinel_configs.delete(sentinel_config))
+          end
+        end
+      end
+
+      raise last_error if last_error
+    end
+  end
+end

data/lib/redis_client/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class RedisClient
+  VERSION = "0.1.0"
+end