ticketing 0.0.2 → 0.1.0

data/lib/ticketing/connection.rb

@@ -1,256 +1,347 @@
 # frozen_string_literal: true
 
-require 'socket'
-require 'logger'
-
-require_relative 'errors'
-require_relative 'protocol'
+require "socket"
+require "openssl"
 
 module Ticketing
-  # The outcome of a single request, matched back to its waiter by (op, key).
-  module Reply
-    TIMED_OUT = :timed_out
-    RELEASED = :released
-    NOT_FOUND = :not_found
-    Acquired = Struct.new(:token)
-
-    def self.acquired(token)
-      Acquired.new(token)
+  # One-way TLS: the client verifies the server, never the reverse.
+  # 단방향 TLS: 클라이언트가 서버만 검증한다.
+  module Tls
+    module_function
+
+    # tls: nil(off) | 'system-roots' | 'insecure-skip-verify' | CA PEM path.
+    # Returns [ssl_context, verify_host]. 빌드 시 1회 결정.
+    def build(tls)
+      case tls
+      when nil, "off"
+        [nil, false]
+      when "system-roots"
+        context = OpenSSL::SSL::SSLContext.new
+        context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        context.cert_store = OpenSSL::X509::Store.new.tap(&:set_default_paths)
+        [context, true]
+      when "insecure-skip-verify"
+        context = OpenSSL::SSL::SSLContext.new
+        context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        [context, false]
+      else
+        context = OpenSSL::SSL::SSLContext.new
+        context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        store = OpenSSL::X509::Store.new
+        begin
+          store.add_file(tls.to_s)
+        rescue OpenSSL::X509::StoreError => e
+          raise TicketError.new(:io, "TLS config load failed: #{tls} (#{e.message})")
+        end
+        context.cert_store = store
+        [context, true]
+      end
     end
   end
 
-  # A one-shot channel a caller blocks on until its reply (or a failure)
-  # arrives from the reader thread.
-  class Waiter
-    def initialize
-      @queue = Queue.new
-    end
+  # Shared cluster view: addresses + leader hint. Plain ivars are safe under
+  # the GVL. 공유 클러스터 뷰(주소 + 리더 힌트) — GVL 하에서 단순 대입은 안전.
+  class Topology
+    attr_reader :addrs, :leader
 
-    def complete(reply)
-      @queue.push([:ok, reply])
+    def initialize(addrs)
+      @addrs = addrs
+      @leader = -1
     end
 
-    def fail(error)
-      @queue.push([:err, error])
-    end
-
-    def await
-      kind, value = @queue.pop
-      raise value if kind == :err
+    # Map a `M`(Moved) address to a leader hint. M 주소 → 리더 힌트.
+    def set_leader(addr) = @leader = @addrs.index(addr) || -1
 
-      value
+    def clear_leader_if(index)
+      @leader = -1 if @leader == index
     end
   end
 
-  # One persistent TCP connection to a lock server, managed on a background
-  # thread. A dropped connection is retried automatically without disturbing
-  # others. Requests are pipelined: a reply is matched back to its waiter by
-  # (op, key).
+  # One server connection: request queue + batching writer thread + reader,
+  # with self-healing reconnect. 서버 연결 하나 — 요청 큐 + 배칭 writer 스레드 +
+  # reader, 자가 치유 재접속.
   class Conn
-    RECONNECT_INTERVAL = 3.0
+    STATUS_DOWN = 0
+    STATUS_UP = 1
+    STATUS_DRAINING = 2
+
+    REQ_QUEUE = 1024
+    WRITE_BATCH = 64
+    BACKOFF_MIN = 0.1
+    BACKOFF_MAX = 3.2
+    # A session shorter than this is a failure (auth/crash loop) — back off.
+    # 이보다 짧은 세션은 실패로 간주 — 백오프 적용.
+    SHORT_SESSION = 1.0
+    CONNECT_TIMEOUT = 3
+
+    DRAIN_REASONS = %w[not_active auth_failed no_leader].freeze
 
     attr_reader :addr
 
-    def initialize(addr, logger)
+    def initialize(addr, index, token, ssl_context, verify_host, topo, logger)
       @addr = addr
+      @index = index
+      @token = token
+      @ssl_context = ssl_context
+      @verify_host = verify_host
+      @topo = topo
       @logger = logger
-      @host, @port = parse_addr(addr)
-      @status = :down
-      @writer = nil
-      @socket = nil
-      @running = true
-      @thread = nil
-      @writer_mutex = Mutex.new
-      @pending_mutex = Mutex.new
-      @acquire_waiters = {}
-      @release_waiters = {}
+      @status = STATUS_DOWN
+      @session = nil
+      @ever_connected = false
+      Thread.new { run_loop }
     end
 
-    # True while at least one reply can currently be sent and received.
-    def usable?
-      @status == :up
+    def usable? = @status == STATUS_UP
+
+    # Give a drained (non-leader) connection another chance. 드레인 연결 부활.
+    def revive
+      @status = STATUS_UP if @status == STATUS_DRAINING
     end
 
-    # Enqueues a waiter under (op, key), writes the frame, then blocks until the
-    # reader thread resolves it. Raises {IoError} if the write fails or the
-    # connection is not up.
+    # Send one request; pop the returned queue for the reply (array) or a
+    # TicketError. 요청 전송 — 반환 큐를 pop해 응답/오류 수신.
     def request(op, key, frame)
-      waiter = Waiter.new
-      @writer_mutex.synchronize do
-        w = @writer or raise Ticketing.closed_error
+      resolver = Queue.new
+      session = @session
+      if session.nil?
+        resolver << TicketError.aborted
+        return resolver
+      end
+      begin
+        session.queue.push([op, key, frame, resolver]) # blocking push = backpressure. 백프레셔.
+      rescue ClosedQueueError
+        resolver << TicketError.aborted
+        return resolver
+      end
+      session.abort_queued if session.closed
+      resolver
+    end
 
-        @pending_mutex.synchronize do
-          (waiters(op)[key] ||= []).push(waiter)
-        end
+    private
+
+    def logf(message) = @logger&.warn(message)
 
+    def run_loop
+      backoff = BACKOFF_MIN
+      loop do
+        healthy = false
         begin
-          w.write(frame)
-          w.flush
-        rescue IOError, SystemCallError => e
-          @pending_mutex.synchronize do
-            queue = waiters(op)[key]
-            if queue
-              queue.pop
-              waiters(op).delete(key) if queue.empty?
+          socket = dial
+          begin
+            parser = Protocol::FrameParser.new
+            handshake(socket, parser)
+            logf("reconnected: #{@addr}") if @ever_connected
+            @ever_connected = true
+            started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            run_session(socket, parser)
+            healthy = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started >= SHORT_SESSION
+            logf("connection lost: #{@addr}")
+          ensure
+            begin
+              socket.close
+            rescue StandardError
+              nil
             end
           end
-          raise IoError.new(e)
+        rescue StandardError => e
+          logf("connect failed: #{@addr} (#{e.message}) — retry in #{(backoff * 1000).to_i}ms")
+        end
+        if healthy
+          backoff = BACKOFF_MIN
+        else
+          sleep(backoff)
+          backoff = [backoff * 2, BACKOFF_MAX].min
         end
       end
-      waiter.await
     end
 
-    # Starts the background connect/read/reconnect loop.
-    def start_connector
-      @thread = Thread.new do
-        ever_connected = false
-        while @running
-          sock = connect_socket
-          next if sock.nil?
+    def dial
+      host, _, port = @addr.rpartition(":")
+      raise TicketError.new(:invalid_input, "address must be host:port — #{@addr}") if host.empty?
 
-          @socket = sock
-          @writer = sock
-          @status = :up
-          @logger.warn("reconnected: #{@addr}") if ever_connected
-          ever_connected = true
+      socket = Socket.tcp(host, Integer(port), connect_timeout: CONNECT_TIMEOUT)
+      socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      return socket if @ssl_context.nil?
 
-          begin
-            read_loop(sock)
-          rescue StandardError
-            nil
-          end
+      ssl = OpenSSL::SSL::SSLSocket.new(socket, @ssl_context)
+      ssl.hostname = host
+      ssl.sync_close = true
+      ssl.connect
+      ssl.post_connection_check(host) if @verify_host
+      ssl
+    end
 
-          teardown(sock)
-          @logger.warn("connection lost: #{@addr} — reconnecting every #{RECONNECT_INTERVAL}s")
-          sleep RECONNECT_INTERVAL if @running
-        end
+    # Answer the `"<hash> <nonce>"` challenge. challenge 응답.
+    def handshake(socket, parser)
+      line = nil
+      while line.nil?
+        parser.feed(socket.readpartial(4096))
+        line = parser.next_line
       end
+      space = line.index(" ")
+      raise TicketError.new(:protocol, "bad challenge") if space.nil? || space.zero?
+
+      socket.write(Protocol.auth_digest(@token, line.byteslice(space + 1..)) + "\n")
     end
 
-    # Stops the background thread, closes the socket, and fails all waiters.
-    def stop
-      @running = false
-      @status = :down
-      thread = @thread
+    # One live session. Teardown aborts every in-flight request so the broker
+    # retries elsewhere. 세션 하나 — 종료 시 진행 중 요청 전부 중단.
+    def run_session(socket, parser)
+      session = Session.new
+      @session = session
+      @status = STATUS_UP
+      writer = Thread.new { write_loop(session, socket) }
+      read_loop(session, socket, parser)
+    ensure
+      session.closed = true
+      @session = nil
+      @status = STATUS_DOWN
+      @topo.clear_leader_if(@index)
+      session.queue.close
       begin
-        @socket&.close
+        socket.close
       rescue StandardError
         nil
       end
-      thread&.kill
-      clear_pending
-    end
-
-    private
-
-    def waiters(op)
-      op == Protocol::OP_ACQUIRE ? @acquire_waiters : @release_waiters
-    end
-
-    def connect_socket
-      sock = TCPSocket.new(@host, @port)
-      sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-      sock
-    rescue StandardError => e
-      @logger.warn("connect failed: #{@addr} (#{e.message}) — retrying in #{RECONNECT_INTERVAL}s")
-      sleep RECONNECT_INTERVAL if @running
-      nil
+      writer&.join(1)
+      session.abort_queued
+      session.fail_all
     end
 
-    def read_loop(sock)
+    # Register pending then write, in queue order — same-key FIFO holds because
+    # this is the single consumer. 단일 소비자가 등록→쓰기 순서 보장(같은 키 FIFO).
+    def write_loop(session, socket)
+      batch = []
       loop do
-        frame =
-          begin
-            Protocol.read_frame(sock) { |op| Protocol.reply_fixed(op) }
-          rescue IOError, SystemCallError
-            return
+        first = session.queue.pop
+        return if first.nil? # closed queue. 큐 닫힘.
+
+        batch.clear
+        batch << first
+        while batch.size < WRITE_BATCH
+          item = begin
+            session.queue.pop(true)
+          rescue ThreadError
+            break
           end
+          break if item.nil?
 
-        if frame.equal?(Protocol::Frame::EOF)
-          return
-        elsif frame.equal?(Protocol::Frame::TOO_LONG)
-          next
-        else
-          bytes = frame.bytes
-          next if bytes.bytesize.zero?
-
-          incoming = Protocol.parse_reply(bytes)
-          if incoming.nil?
-            @logger.error("unrecognized reply from #{@addr}")
-            next
-          end
-          dispatch(incoming)
+          batch << item
+        end
+        data = +"".b
+        batch.each do |op, key, frame, resolver|
+          session.register(op, key, resolver)
+          data << frame
         end
+        socket.write(data)
+      end
+    rescue StandardError
+      begin
+        socket.close
+      rescue StandardError
+        nil
       end
     end
 
-    def dispatch(incoming)
-      case incoming
-      when Protocol::Incoming::Acquired
-        resolve(Protocol::OP_ACQUIRE, incoming.key, Reply.acquired(incoming.token))
-      when Protocol::Incoming::TimedOut
-        resolve(Protocol::OP_ACQUIRE, incoming.key, Reply::TIMED_OUT)
-      when Protocol::Incoming::Released
-        resolve(Protocol::OP_RELEASE, incoming.key, Reply::RELEASED)
-      when Protocol::Incoming::NotFound
-        resolve(Protocol::OP_RELEASE, incoming.key, Reply::NOT_FOUND)
-      when Protocol::Incoming::Moved
-        @logger.warn("server draining: #{@addr} (moved to #{incoming.addr})")
-        @status = :draining
-      when Protocol::Incoming::Error
-        @logger.error("server error from #{@addr}: #{incoming.reason}")
-        if incoming.reason == "not_active"
-          @status = :draining
-          clear_pending
+    def read_loop(session, socket, parser)
+      loop do
+        while (frame = parser.next_frame)
+          handle_reply(session, frame) unless frame.empty?
         end
+        parser.feed(socket.readpartial(65_536))
       end
+    rescue EOFError, IOError, SystemCallError, OpenSSL::SSL::SSLError
+      nil
     end
 
-    def resolve(op, key, reply)
-      waiter =
-        @pending_mutex.synchronize do
-          map = waiters(op)
-          queue = map[key]
-          next nil if queue.nil?
-
-          w = queue.shift
-          map.delete(key) if queue.empty?
-          w
+    def handle_reply(session, frame)
+      op, text, token = Protocol.parse_reply(frame)
+      if op.nil?
+        logf("unrecognized reply from #{@addr}")
+        return
+      end
+      case op
+      when "A" then session.resolve(Protocol::OP_ACQUIRE, text, [:acquired, token])
+      when "T" then session.resolve(Protocol::OP_ACQUIRE, text, [:timed_out, 0])
+      when "R" then session.resolve(Protocol::OP_RELEASE, text, [:released, 0])
+      when "N" then session.resolve(Protocol::OP_RELEASE, text, [:not_found, 0])
+      when "M"
+        logf("not leader: #{@addr} (leader is #{text})")
+        @topo.set_leader(text)
+        drain(session)
+      when "E"
+        logf("server error from #{@addr}: #{text}")
+        if DRAIN_REASONS.include?(text)
+          @topo.clear_leader_if(@index) if text == "no_leader"
+          drain(session)
         end
-      waiter&.complete(reply)
+      end
     end
 
-    def teardown(sock)
-      @status = :down
-      @writer = nil
-      begin
-        sock.close
-      rescue StandardError
-        nil
-      end
-      clear_pending
+    # Stop routing here; abort in-flight so the broker retries elsewhere.
+    # 라우팅 중지 + 진행 중 요청 중단 → 브로커가 다른 노드로 재시도.
+    def drain(session)
+      @status = STATUS_DRAINING
+      session.fail_all
     end
 
-    def clear_pending
-      orphans =
-        @pending_mutex.synchronize do
-          all = []
-          @acquire_waiters.each_value { |queue| all.concat(queue) }
-          @release_waiters.each_value { |queue| all.concat(queue) }
-          @acquire_waiters.clear
-          @release_waiters.clear
-          all
+    # In-flight requests per (op, key), FIFO — matches server reply order.
+    # (op, key)별 FIFO 대기 — 서버 응답 순서와 일치.
+    class Session
+      attr_reader :queue
+      attr_accessor :closed
+
+      def initialize
+        @queue = SizedQueue.new(REQ_QUEUE)
+        @closed = false
+        @mutex = Mutex.new
+        @acquire = {}
+        @release = {}
+      end
+
+      def map(op) = op == Protocol::OP_ACQUIRE ? @acquire : @release
+
+      def register(op, key, resolver)
+        @mutex.synchronize { (map(op)[key] ||= []) << resolver }
+      end
+
+      def resolve(op, key, reply)
+        resolver = @mutex.synchronize do
+          pending = map(op)[key]
+          next nil if pending.nil? || pending.empty?
+
+          first = pending.shift
+          map(op).delete(key) if pending.empty?
+          first
         end
-      orphans.each { |waiter| waiter.fail(Ticketing.closed_error) }
-    end
+        resolver << reply unless resolver.nil?
+      end
 
-    def parse_addr(addr)
-      i = addr.rindex(":")
-      unless i && i.positive? && i < addr.length - 1
-        raise ArgumentError, "address must be host:port, got '#{addr}'"
+      # Abort every in-flight request so the broker retries elsewhere.
+      # 진행 중 요청 전부 중단 → 브로커가 다른 노드로 재시도.
+      def fail_all
+        victims = @mutex.synchronize do
+          all = (@acquire.values + @release.values).flatten
+          @acquire.clear
+          @release.clear
+          all
+        end
+        victims.each { |resolver| resolver << TicketError.aborted }
       end
 
-      [addr[0...i], addr[(i + 1)..].to_i]
+      def abort_queued
+        loop do
+          item = begin
+            @queue.pop(true)
+          rescue ThreadError
+            break
+          end
+          break if item.nil?
+
+          item[3] << TicketError.aborted
+        end
+      end
     end
   end
 end

data/lib/ticketing/errors.rb

@@ -1,64 +1,21 @@
 # frozen_string_literal: true
 
 module Ticketing
-  # Base class for every error raised by this library.
-  class Error < StandardError; end
-
-  # The wait budget elapsed before the lock could be acquired.
-  class TimeoutError < Error
-    def initialize(message = "timed out waiting to acquire the lock")
-      super
-    end
-  end
-
-  # No server connection was usable for the request.
-  class NotConnectedError < Error
-    def initialize(message = "no connected server")
-      super
-    end
-  end
-
-  # The key (or other argument) failed local validation before any network I/O.
-  class InvalidInput < Error
-    attr_reader :reason
-
-    def initialize(reason)
-      @reason = reason
-      super("invalid input: #{reason}")
+  # Client error with a machine-checkable kind. 종류를 코드로 판별할 수 있는 오류.
+  #
+  # Kinds — :timeout (wait 안에 획득 실패) / :not_connected (연결 없음) /
+  # :auth (토큰 거부) / :invalid_input (잘못된 입력) / :protocol (규격 외 응답) /
+  # :io (전송 오류) / :connection_aborted (장애조치 중단 — 내부 재시도).
+  class TicketError < StandardError
+    attr_reader :kind
+
+    def initialize(kind, message)
+      super(message)
+      @kind = kind
     end
-  end
-
-  # The server sent a reply that does not fit the request that was made.
-  class ProtocolError < Error
-    attr_reader :reason
 
-    def initialize(reason)
-      @reason = reason
-      super("protocol error: #{reason}")
-    end
-  end
-
-  # A socket read or write failed. {#cause_error} carries the underlying error;
-  # when it is a {ConnectionClosed} the broker treats the drop as retryable.
-  class IoError < Error
-    attr_reader :cause_error
-
-    def initialize(cause)
-      @cause_error = cause
-      super("io error: #{cause}")
-    end
-  end
-
-  # Marker for a connection that was lost or never established. Wrapped in an
-  # {IoError} so a dropped socket can be told apart from a real I/O fault.
-  class ConnectionClosed < StandardError
-    def initialize(message = "connection closed")
-      super
-    end
-  end
+    def self.aborted = new(:connection_aborted, "connection closed")
 
-  # An {IoError} standing for a closed connection.
-  def self.closed_error
-    IoError.new(ConnectionClosed.new)
+    def aborted? = kind == :connection_aborted
   end
 end