connectrpc-async 0.1.0

data/lib/connectrpc/async/http1_connection.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "protocol/http1/connection"
+require_relative "http1_stream"
+
+module ConnectRPC
+  module Async
+    module Internal
+      class HTTP1Connection < ::Protocol::HTTP1::Connection
+        STATUS = %r{\AHTTP/1\.1 ([0-9]{3}) [\x09\x20-\x7e\x80-\xff]*\z}n
+
+        attr_reader :response_version
+
+        def read_head(method)
+          raise IOError, "HTTP/1 connection is not open" unless open? || half_closed_local?
+
+          interim = 0
+          loop do
+            line = read_line
+            match = STATUS.match(line)
+            raise IOError, "Invalid HTTP/1.1 status line" unless match
+
+            @response_version = "HTTP/1.1"
+            status = match[1].to_i
+            headers = read_headers
+            leading = snapshot(headers)
+            validate_framing!(leading)
+            raise IOError, "HTTP upgrade is unsupported" if status == 101
+
+            # The pinned native parser compares the transfer token literally.
+            # Our validation already permits exactly one case-insensitive token.
+            headers["transfer-encoding"] = "chunked" if leading.key?("transfer-encoding")
+            @persistent &&= persistent?(@response_version, method, headers)
+            if status.between?(100, 199)
+              interim += 1
+              raise IOError, "Too many interim responses" if interim > 16
+
+              next
+            end
+            body = read_response_body(method, status, headers)
+            receive_end_stream! unless body
+            @count += 1
+            return [StreamHead.new(status: status, headers: leading), body]
+          end
+        end
+
+        def viable? = idle? && persistent && stream.viable?
+
+        private
+
+        def snapshot(headers)
+          result = headers.header.each_with_object({}) do |(name, value), result|
+            (result[name.downcase] ||= []) << value.dup.freeze
+          end
+          result.each_value(&:freeze)
+          result.freeze
+        end
+
+        # Validate the original fields before the native parser deletes or
+        # combines them. Only a single chunked transfer coding is supported.
+        def validate_framing!(headers)
+          lengths = headers["content-length"]
+          coding = headers["transfer-encoding"]
+          if lengths && (lengths.size != 1 || !/\A[0-9]+\z/.match?(lengths.first))
+            raise IOError, "Invalid HTTP Content-Length"
+          end
+          return unless coding && (lengths || coding.size != 1 || !coding.first.strip.casecmp?("chunked"))
+
+          raise IOError, "Unsupported HTTP transfer framing"
+        end
+      end
+
+      class HTTP1Output < OutputBody
+        def initialize(dispatched)
+          super()
+          @dispatched = dispatched
+        end
+
+        def ready? = false
+
+        def read
+          @dispatched.resolve(nil)
+          super
+        end
+      end
+
+      # One resource per reserved slot, including setup and destructive joins.
+      class HTTP1Resource
+        attr_accessor :raw, :socket, :connection, :setup
+
+        def finished? = !!@finished
+        def finish! = @finished = true
+
+        def abort
+          pending_tls = @socket.is_a?(OpenSSL::SSL::SSLSocket) && @connection.nil?
+          return if @raw.nil? || @raw.closed?
+
+          # Ruby 4 marks raw closed before waiting for blocked fibers, before
+          # closing the descriptor. Transfer descriptor ownership first so an
+          # interruption cannot strand it behind raw.closed?. Retain the same
+          # descriptor until every native waiter and lifecycle child has joined.
+          # This handle has no readers/writers and is never used for transport IO.
+          @raw_close_io ||= ::IO.for_fd(@raw.fileno)
+          @raw.autoclose = false
+          # Ruby 4 raw close can wait on SSL setup. Shutdown wakes it first.
+          @raw.shutdown(Socket::SHUT_RDWR)
+        rescue IOError, SystemCallError
+          nil
+        ensure
+          begin
+            Internal.raw_close(@raw)
+          ensure
+            # Ruby 4 raw close of pending SSL setup can leave its abandoned
+            # EOF in OpenSSL's thread-local queue, including on interruption.
+            # Drain only this destructive setup boundary before sibling TLS.
+            # The final post-join abort also drains a late native waiter EOF.
+            OpenSSL.errors if pending_tls
+          end
+        end
+
+        # Only the final owner calls this, after all accessing tasks have joined.
+        def close
+          interruption = nil
+          [@connection, @socket, @raw_close_io].each do |owned|
+            next unless owned
+            next if owned.equal?(@raw_close_io) && owned.closed?
+
+            begin
+              owned.close
+            rescue Exception => e # rubocop:disable Lint/RescueException -- complete every close stage before propagating the first interruption
+              interruption ||= e
+              # Native wrappers can be interrupted before completing their own
+              # cleanup even when raw.closed? is true. Retry interruptions, but
+              # let ordinary wrapper failures proceed to the remaining stages.
+              retry if !e.is_a?(StandardError) && !owned.equal?(@raw_close_io)
+              retry if owned.equal?(@raw_close_io) && !owned.closed?
+            end
+          end
+          raise interruption if interruption
+        end
+      end
+    end
+  end
+end

data/lib/connectrpc/async/http1_exchange.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  module Async
+    module Internal
+      class HTTP1Exchange
+        def initialize(transport, operation)
+          @transport = transport
+          @operation = operation
+        end
+
+        def response_head(timeout: nil) = invoke(:response_head, timeout: timeout)
+        def read(length, timeout: nil) = invoke(:read, length, timeout: timeout)
+        def write(bytes) = invoke(:write, bytes)
+        def close_send = invoke(:close_send)
+        def finish(timeout: nil) = invoke(:finish, timeout: timeout)
+        def abort = invoke(:abort)
+
+        private
+
+        def invoke(method, *, **)
+          @transport.send(method, @operation, *, **)
+        end
+      end
+    end
+  end
+end

data/lib/connectrpc/async/http1_stream.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "io/stream/buffered"
+
+module ConnectRPC
+  module Async
+    module Internal
+      # Unlike IO::Stream's coupled read path, an H1 response must remain
+      # readable while the request writer holds its output mutex.
+      class HTTP1Stream < ::IO::Stream::Buffered
+        def initialize(io)
+          super(io, minimum_read_size: 16_384, maximum_read_size: 16_384)
+        end
+
+        def readpartial(length, buffer = nil)
+          super([length, 16_384].min, buffer)
+        end
+
+        def close_read
+          # Destructive retirement closes raw IO before unfinished body cleanup.
+          super unless closed?
+        end
+
+        def viable?
+          return false if closed? || @finished || !@read_buffer.empty?
+
+          result = sysread_nonblock(1, @input_buffer)
+          result == :wait_readable
+        rescue IOError, SystemCallError, OpenSSL::SSL::SSLError
+          false
+        end
+
+        private
+
+        # Keep pinned buffer/EOF behavior without acquiring the writer's mutex.
+        def fill_read_buffer(size = @minimum_read_size) # rubocop:disable Naming/PredicateMethod -- Pinned upstream override.
+          size = [size, @maximum_read_size].min
+          if @read_buffer.empty?
+            return true if sysread(size, @read_buffer)
+          elsif (chunk = sysread(size, @input_buffer))
+            @read_buffer << chunk
+            return true
+          end
+          @finished = true
+          false
+        end
+
+        # Buffered#sysread in io-stream 0.14 swallows SSL errors other than
+        # unexpected EOF. Preserve those native failures rather than returning
+        # a clean close-delimited HTTP EOF.
+        def sysread(size, buffer)
+          loop do
+            result = @io.read_nonblock(size, buffer, exception: false)
+            case result
+            when :wait_readable
+              @io.wait_readable(@io.timeout) or raise ::IO::TimeoutError, "read timeout"
+            when :wait_writable
+              @io.wait_writable(@io.timeout) or raise ::IO::TimeoutError, "write timeout"
+            else
+              return result
+            end
+          end
+        rescue OpenSSL::SSL::SSLError => e
+          raise ::IO::Stream::ConnectionResetError, "Connection reset by peer!" if
+            e.message.include?("unexpected eof while reading")
+
+          raise
+        rescue Errno::ECONNRESET
+          raise ::IO::Stream::ConnectionResetError, "Connection reset by peer!"
+        rescue Errno::EBADF
+          raise IOError, "stream closed"
+        end
+      end
+    end
+  end
+end