solid-redis 0.1.0

data/lib/solid_redis/pool.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module SolidRedis
+  class Pool
+    attr_reader :size
+
+    def initialize(config, size: 5, timeout: 1.0)
+      @config = config
+      @size = Integer(size)
+      raise ArgumentError, "Pool size must be positive" unless @size.positive?
+
+      @timeout = Float(timeout)
+      raise ArgumentError, "Pool timeout must be positive" unless @timeout.positive?
+
+      @available = []
+      @created = 0
+      @mutex = Mutex.new
+      @resource = ConditionVariable.new
+      @closed = false
+      @owner = Ractor.current
+    end
+
+    def with
+      ensure_owner!
+      client = checkout
+      yield client
+    ensure
+      checkin(client) if client
+    end
+    alias_method :then, :with
+
+    def call(*command)
+      with { |client| client.call(*command) }
+    end
+
+    def call_v(command)
+      with { |client| client.call_v(command) }
+    end
+
+    def pipelined(&block)
+      with { |client| client.pipelined(&block) }
+    end
+
+    def close
+      ensure_owner!
+      clients = @mutex.synchronize do
+        @closed = true
+        @resource.broadcast
+        @available.shift(@available.length)
+      end
+      clients.each(&:close)
+      self
+    end
+
+    private
+
+    def checkout
+      deadline = monotonic_time + @timeout
+      @mutex.synchronize do
+        loop do
+          raise ClosedError, "Redis pool is closed" if @closed
+          return @available.pop unless @available.empty?
+
+          if @created < size
+            @created += 1
+            return @config.new_client
+          end
+
+          remaining = deadline - monotonic_time
+          unless remaining.positive?
+            raise CheckoutTimeoutError, "Redis pool checkout timed out after #{@timeout}s"
+          end
+
+          @resource.wait(@mutex, remaining)
+        end
+      end
+    end
+
+    def checkin(client)
+      @mutex.synchronize do
+        if @closed
+          @created -= 1
+          client.close
+        else
+          @available << client
+          @resource.signal
+        end
+      end
+    end
+
+    def ensure_owner!
+      return if Ractor.current == @owner
+
+      raise Ractor::IsolationError, "SolidRedis::Pool cannot cross Ractor boundaries"
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/solid_redis/resp.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module SolidRedis
+  module RESP
+    CRLF = "\r\n"
+
+    module_function
+
+    def encode(command)
+      command = command.flatten(1)
+      raise ArgumentError, "Redis command cannot be empty" if command.empty?
+
+      command.each_with_object(+"*#{command.length}#{CRLF}") do |argument, buffer|
+        value = encode_argument(argument)
+        buffer << "$#{value.bytesize}#{CRLF}#{value}#{CRLF}"
+      end
+    end
+
+    def encode_argument(value)
+      case value
+      when String then value
+      when Symbol, Integer, Float then value.to_s
+      when true then "1"
+      when false then "0"
+      when nil then ""
+      else value.to_s
+      end
+    end
+
+    class Reader
+      def initialize(io, read_timeout:)
+        @io = io
+        @read_timeout = read_timeout
+        @buffer = +""
+      end
+
+      def read(exception: true)
+        case (type = read_bytes(1))
+        when "+" then read_line
+        when "-" then error_response(read_line, exception)
+        when ":" then Integer(read_line)
+        when "$" then read_bulk
+        when "*" then read_array(exception)
+        when "_" then read_line && nil
+        when "#" then read_line == "t"
+        when "," then Float(read_line)
+        when "(" then Integer(read_line)
+        when "%" then read_map(exception)
+        when "~", ">" then read_collection(exception)
+        when "=" then read_verbatim
+        when "!" then error_response(read_sized_string, exception)
+        when "|" then read_map(exception) && read(exception: exception)
+        else raise ProtocolError, "Unknown RESP type byte: #{type.inspect}"
+        end
+      rescue EOFError
+        raise ConnectionError, "Redis closed the connection"
+      rescue ArgumentError => error
+        raise ProtocolError, "Invalid Redis response: #{error.message}", cause: error
+      end
+
+      private
+
+      def read_bulk
+        length = Integer(read_line)
+        return if length == -1
+
+        read_sized_value(length)
+      end
+
+      def read_array(exception)
+        length = Integer(read_line)
+        return if length == -1
+
+        Array.new(length) { read(exception: exception) }
+      end
+
+      def read_collection(exception)
+        length = Integer(read_line)
+        Array.new(length) { read(exception: exception) }
+      end
+
+      def read_map(exception)
+        length = Integer(read_line)
+        {}.tap do |map|
+          length.times { map[read(exception: exception)] = read(exception: exception) }
+        end
+      end
+
+      def read_verbatim
+        read_sized_string.byteslice(4..)
+      end
+
+      def read_sized_string
+        read_sized_value(Integer(read_line))
+      end
+
+      def read_sized_value(length)
+        value = read_bytes(length)
+        actual = read_bytes(2)
+        raise ProtocolError, "Expected CRLF, got #{actual.inspect}" unless actual == CRLF
+
+        value
+      end
+
+      def read_line
+        loop do
+          if (index = @buffer.index(CRLF))
+            return @buffer.slice!(0, index + 2).byteslice(0, index)
+          end
+          fill_buffer
+        end
+      end
+
+      def read_bytes(length)
+        fill_buffer while @buffer.bytesize < length
+        @buffer.slice!(0, length)
+      end
+
+      def fill_buffer
+        loop do
+          if @io.respond_to?(:to_io)
+            unless IO.select([@io], nil, nil, @read_timeout)
+              raise TimeoutError, "Redis read timed out after #{@read_timeout}s"
+            end
+
+            chunk = @io.read_nonblock(16_384, exception: false)
+          else
+            chunk = @io.read(16_384)
+          end
+
+          next if chunk == :wait_readable
+          raise EOFError if chunk.nil?
+
+          @buffer << chunk
+          return
+        end
+      rescue IOError, SystemCallError => error
+        raise ConnectionError, error.message, cause: error
+      end
+
+      def error_response(message, exception)
+        error = if message.start_with?("NOAUTH", "WRONGPASS")
+          AuthenticationError.new(message)
+        else
+          CommandError.new(message)
+        end
+        raise error if exception
+
+        error
+      end
+    end
+  end
+end

data/lib/solid_redis/sentinel/resolve_service.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module SolidRedis
+  module Sentinel
+    class ResolveService < Service::Base
+      def call
+        @endpoints.each do |endpoint|
+          client = Config.new(**@specification.sentinel_client_options, **endpoint).new_client
+          target = resolve_target(client)
+          unless target
+            append_error(
+              :target_not_found,
+              "#{endpoint_label(endpoint)} does not know #{@specification.name.inspect}",
+            )
+            next
+          end
+
+          return {
+            target: target,
+            endpoint: endpoint,
+            discovered: discover_sentinels(client),
+          }
+        rescue SolidRedis::Error, KeyError, ArgumentError => error
+          append_error(:sentinel_unavailable, "#{endpoint_label(endpoint)}: #{error.message}")
+          sleep SentinelState::SENTINEL_DELAY
+        ensure
+          client&.close
+        end
+
+        nil
+      end
+
+      private
+
+      def resolve_target(client)
+        if @specification.role == :master
+          resolve_master(client)
+        else
+          resolve_replica(client)
+        end
+      end
+
+      def resolve_master(client)
+        response = client.call("SENTINEL", "get-master-addr-by-name", @specification.name)
+        return unless response && response[0] && response[1]
+
+        { host: response[0], port: Integer(response[1]) }
+      end
+
+      def resolve_replica(client)
+        replicas = client.call("SENTINEL", "replicas", @specification.name)
+        candidates = replicas.filter_map do |entry|
+          attributes = attributes(entry)
+          flags = attributes["flags"].to_s.split(",")
+          next if flags.any? { |flag| %w[s_down o_down disconnected].include?(flag) }
+
+          { host: attributes.fetch("ip"), port: Integer(attributes.fetch("port")) }
+        end
+        candidates.sample
+      end
+
+      def discover_sentinels(client)
+        client.call("SENTINEL", "sentinels", @specification.name).map do |entry|
+          values = attributes(entry)
+          { host: values.fetch("ip"), port: Integer(values.fetch("port")) }
+        end
+      end
+
+      def attributes(entry)
+        entry.is_a?(Hash) ? entry : Hash[*entry]
+      end
+
+      def endpoint_label(endpoint)
+        "#{endpoint[:host]}:#{endpoint[:port]}"
+      end
+    end
+  end
+end

data/lib/solid_redis/sentinel_config.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module SolidRedis
+  class SentinelConfig
+    LOCAL_STATE_KEY = :solid_redis_sentinel_states
+    DEFAULT_SENTINEL_PORT = 26_379
+
+    attr_reader :name, :role, :reconnect_attempts, :redis_client_options,
+      :sentinel_client_options, :sentinel_endpoints
+
+    def initialize(
+      name:,
+      sentinels:,
+      role: :master,
+      sentinel_username: nil,
+      sentinel_password: nil,
+      sentinel_ssl: false,
+      sentinel_ssl_params: nil,
+      **redis_options
+    )
+      @name = String(name).dup.freeze
+      @role = normalize_role(role)
+      endpoints = sentinels.map { |endpoint| normalize_endpoint(endpoint) }
+      @sentinel_endpoints = Shareable.copy(endpoints, label: "sentinels")
+      raise ArgumentError, "At least one Sentinel endpoint is required" if @sentinel_endpoints.empty?
+
+      @reconnect_attempts = Integer(redis_options.fetch(:reconnect_attempts, 2))
+      raise ArgumentError, "reconnect_attempts must not be negative" if @reconnect_attempts.negative?
+
+      @redis_client_options = Shareable.copy(redis_options, label: "Redis options")
+      @sentinel_client_options = Shareable.copy(
+        sentinel_options(
+          redis_options,
+          username: sentinel_username,
+          password: sentinel_password,
+          ssl: sentinel_ssl,
+          ssl_params: sentinel_ssl_params,
+        ),
+        label: "Sentinel options",
+      )
+      Ractor.make_shareable(self)
+    end
+
+    def sentinel?
+      true
+    end
+
+    def resolved?
+      state.resolved?
+    end
+
+    def resolve
+      state.resolve
+    end
+
+    def reset
+      state.reset
+      self
+    end
+
+    def host
+      resolve.host
+    end
+
+    def port
+      resolve.port
+    end
+
+    def path
+      nil
+    end
+
+    def server_key
+      resolve.server_key
+    end
+
+    def server_url
+      resolve.server_url
+    end
+
+    def sentinels
+      state.sentinel_endpoints
+    end
+
+    def new_client(**options)
+      Client.new(self, **options)
+    end
+
+    def new_pool(**options)
+      Pool.new(self, **options)
+    end
+
+    def notify(event, *arguments)
+      callbacks = redis_client_options[:callbacks]
+      return unless callbacks&.respond_to?(event)
+
+      callbacks.respond_with(event, *arguments)
+    end
+
+    def inspect
+      "#<#{self.class.name} name=#{name.inspect} role=#{role.inspect} sentinels=#{sentinel_endpoints.length}>"
+    end
+
+    private
+
+    def state
+      registry = Ractor.current[LOCAL_STATE_KEY]
+      unless registry
+        registry = { mutex: Mutex.new, states: {} }
+        Ractor.current[LOCAL_STATE_KEY] = registry
+      end
+
+      registry[:mutex].synchronize do
+        registry[:states][self] ||= SentinelState.new(self)
+      end
+    end
+
+    def normalize_role(role)
+      role = role.to_sym
+      role = :replica if role == :slave
+      return role if %i[master replica].include?(role)
+
+      raise ArgumentError, "role must be :master or :replica"
+    end
+
+    def normalize_endpoint(endpoint)
+      return endpoint.transform_keys(&:to_sym) unless endpoint.is_a?(String)
+
+      uri = URI.parse(endpoint)
+      unless %w[redis rediss].include?(uri.scheme)
+        raise ArgumentError, "Unsupported Sentinel URL scheme: #{uri.scheme.inspect}"
+      end
+
+      {
+        host: uri.host || "127.0.0.1",
+        port: uri.port || DEFAULT_SENTINEL_PORT,
+        username: decode(uri.user),
+        password: decode(uri.password),
+        ssl: uri.scheme == "rediss",
+      }.compact
+    rescue URI::InvalidURIError => error
+      raise ArgumentError, "Invalid Sentinel URL: #{error.message}", cause: error
+    end
+
+    def sentinel_options(redis_options, **credentials)
+      timeout = redis_options.fetch(:timeout, Config::DEFAULT_TIMEOUT)
+      {
+        **credentials,
+        connect_timeout: redis_options.fetch(:connect_timeout, timeout),
+        read_timeout: redis_options.fetch(:read_timeout, timeout),
+        write_timeout: redis_options.fetch(:write_timeout, timeout),
+        reconnect_attempts: 0,
+      }.compact
+    end
+
+    def decode(value)
+      URI.decode_www_form_component(value) if value
+    end
+  end
+end

data/lib/solid_redis/sentinel_state.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module SolidRedis
+  class SentinelState
+    SENTINEL_DELAY = 0.05
+
+    def initialize(specification)
+      @specification = specification
+      @sentinels = specification.sentinel_endpoints.dup
+      @resolved = nil
+      @mutex = Mutex.new
+    end
+
+    def resolve
+      @mutex.synchronize do
+        @resolved ||= resolve_target
+      end
+    end
+
+    def reset
+      @mutex.synchronize { @resolved = nil }
+    end
+
+    def resolved?
+      @mutex.synchronize { !@resolved.nil? }
+    end
+
+    def sentinel_endpoints
+      @mutex.synchronize { @sentinels.dup }
+    end
+
+    private
+
+    def resolve_target
+      result = Sentinel::ResolveService.call(
+        specification: @specification,
+        endpoints: @sentinels.dup,
+      )
+      unless result.successful? && result.result
+        details = result.errors.map(&:message).join("; ")
+        raise ConnectionError, "No Sentinel available for #{@specification.name.inspect}: #{details}"
+      end
+
+      resolution = result.result
+      resolution[:discovered].each do |attributes|
+        endpoint = Shareable.copy(
+          attributes,
+          label: "discovered Sentinel",
+        )
+        @sentinels << endpoint unless same_endpoint?(endpoint)
+      end
+      promote(resolution[:endpoint])
+      target = Config.new(**@specification.redis_client_options, **resolution[:target])
+      @specification.notify(:resolved, @specification.name, target.server_url)
+      target
+    end
+
+    def same_endpoint?(candidate)
+      @sentinels.any? do |endpoint|
+        endpoint[:host] == candidate[:host] && endpoint[:port] == candidate[:port]
+      end
+    end
+
+    def promote(endpoint)
+      @sentinels.delete(endpoint)
+      @sentinels.unshift(endpoint)
+    end
+  end
+end

data/lib/solid_redis/shareable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidRedis
+  module Shareable
+    module_function
+
+    def copy(value, label:)
+      Ractor.make_shareable(value, copy: true)
+    rescue Ractor::Error, TypeError => error
+      raise ArgumentError, "#{label} must be Ractor-shareable: #{error.message}", cause: error
+    end
+  end
+end

data/lib/solid_redis/version.rb

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

data/lib/solid_redis.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "base_service"
+require "callback_collection"
+
+require_relative "solid_redis/version"
+require_relative "solid_redis/errors"
+require_relative "solid_redis/shareable"
+require_relative "solid_redis/config"
+require_relative "solid_redis/resp"
+require_relative "solid_redis/client"
+require_relative "solid_redis/sentinel/resolve_service"
+require_relative "solid_redis/sentinel_state"
+require_relative "solid_redis/sentinel_config"
+require_relative "solid_redis/pool"
+
+module SolidRedis
+  module_function
+
+  def config(**options)
+    Config.new(**options)
+  end
+
+  def sentinel(**options)
+    SentinelConfig.new(**options)
+  end
+end