connectrpc-async 0.1.0

data/lib/connectrpc/async/stream_exchange.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  module Async
+    module Internal
+      # One queued fragment and the output task's one in-flight fragment. Queue
+      # ownership transfers before waking the producer; no wire-flush promise.
+      class OutputBody < ::Protocol::HTTP::Body::Readable
+        attr_reader :queued_bytes, :maximum_queued_bytes
+
+        def initialize
+          super
+          @changed = ::Async::Condition.new
+          @fragment = nil
+          @queued_bytes = @maximum_queued_bytes = 0
+          @ended = @closed = false
+        end
+
+        def write(bytes, timeout: nil)
+          raise ArgumentError, "Output fragments must fit one frame" if bytes.bytesize > 16_384
+
+          expires = Internal.now + timeout if timeout
+          while @fragment && !@closed
+            if expires
+              waiter = ::Async::Task.current.async(finished: false) { @changed.wait }
+              begin
+                Internal.wait(waiter, expires)
+              ensure
+                Internal.cancel(waiter)
+                Internal.join(waiter)
+              end
+            else
+              @changed.wait
+            end
+          end
+          raise(@error || IOError.new("Output is closed")) if @closed || @ended
+
+          @fragment = bytes.dup.freeze
+          @queued_bytes = bytes.bytesize
+          @maximum_queued_bytes = [@maximum_queued_bytes, @queued_bytes].max
+          @changed.signal
+          nil
+        end
+
+        def read
+          @changed.wait until @fragment || @ended || @closed
+          raise @error if @error
+
+          fragment = @fragment
+          @fragment = nil
+          @queued_bytes = 0
+          @changed.signal
+          fragment
+        end
+
+        def close_write
+          @ended = true
+          @changed.signal
+          nil
+        end
+
+        def close(error = nil)
+          return if @closed
+
+          @closed = true
+          @error = error
+          @fragment = nil
+          @queued_bytes = 0
+          @changed.signal
+          nil
+        end
+      end
+
+      # Publication and processing completion are independent single-assignment
+      # events. The processing task owns both, including exceptional cleanup.
+      class Publication
+        def initialize
+          @head = ::Async::Promise.new
+          @completion = ::Async::Promise.new
+        end
+
+        def publish(response)
+          raise LifecycleError, "Response head already published" if @published
+
+          @published = true
+          @transform&.call(response)
+          @body = response&.body
+          response.body = CompletionBody.new(@body, self) if response
+          @head.resolve([:response, response])
+          @head_ready = true
+          nil
+        rescue StandardError => e
+          @body = response&.body
+          complete(e)
+          raise
+        end
+
+        def complete(error = nil)
+          return if @completed
+
+          @completed = true
+          begin
+            @body&.close(error) if error
+          rescue StandardError => e
+            error ||= e
+          ensure
+            unless @head_ready
+              @head_ready = true
+              @head.resolve([:error, error || IOError.new("Processing ended without a response")])
+            end
+            @completion.resolve(error)
+          end
+          nil
+        end
+
+        def on_publish(&transform)
+          raise LifecycleError, "Response head already published" if @published
+
+          previous = @transform
+          @transform = lambda { |response|
+            previous&.call(response)
+            transform.call(response)
+          }
+          nil
+        end
+
+        def published? = @published
+
+        def response
+          tag, value = @head.wait
+          raise value if tag == :error
+
+          value
+        end
+
+        def wait
+          error = @completion.wait
+          raise error if error
+        end
+      end
+
+      class CompletionBody < ::Protocol::HTTP::Body::Wrapper
+        def initialize(body, publication)
+          super(body || ::Protocol::HTTP::Body::Buffered.wrap([]))
+          @publication = publication
+        end
+
+        # Even an empty body must retain this completion boundary.
+        def empty? = false
+        def length = nil
+
+        def read
+          bytes = super
+          @publication.wait unless bytes
+          bytes
+        end
+      end
+
+      class ServerOutput
+        def initialize(body)
+          @body = body
+        end
+
+        def write(bytes, timeout: nil) = @body.write(bytes, timeout: timeout)
+        def abort = @body.close(IOError.new("Processing abandoned"))
+      end
+
+      class GRPCInput < Input
+        def read(length, timeout: nil)
+          super
+        rescue ::Async::TimeoutError
+          raise Error.new(:unavailable, "gRPC input operation expired"), cause: nil
+        end
+      end
+
+      class GRPCServerOutput < ServerOutput
+        attr_writer :headers
+
+        def initialize(body, _trailers)
+          super(body)
+        end
+
+        def write(bytes, timeout: nil)
+          super
+        rescue ::Async::TimeoutError
+          raise Error.new(:unavailable, "gRPC output operation expired"), cause: nil
+        end
+
+        def finish(headers:)
+          GRPCProtocol.check_fields!(headers)
+          headers.each { |key, values| values.each { |value| @headers.add(key, value, trailer: true) } }
+          @body.close_write
+          nil
+        end
+      end
+
+      # ALL terminal bytes wait for the original processor, including an outer
+      # application's ensure. The consumer only slices already prepared bytes.
+      class GRPCWebBody < OutputBody
+        def initialize(publication)
+          super()
+          @publication = publication
+          @terminal_offset = 0
+        end
+
+        def stage_terminal(bytes)
+          @terminal = bytes.dup.freeze
+          close_write
+          nil
+        end
+
+        def read
+          bytes = super
+          return bytes if bytes
+
+          @publication.wait
+          return unless @terminal && @terminal_offset < @terminal.bytesize
+
+          bytes = @terminal.byteslice(@terminal_offset, 16_384)
+          @terminal_offset += bytes.bytesize
+          bytes
+        end
+
+        def close(error = nil)
+          @terminal = nil
+          super
+        end
+      end
+
+      class GRPCWebServerOutput < ServerOutput
+        def finish(terminal:)
+          @body.stage_terminal(terminal)
+        end
+      end
+
+      class StreamExchange
+        def initialize(transport, operation, body)
+          @transport = transport
+          @operation = operation
+          @body = body
+          @response = operation.fetch(:response)
+        end
+
+        def response_head(timeout: nil)
+          @response_head ||= perform(timeout: timeout) do
+            @operation.fetch(:connection).read_response(@response)
+            @input = Input.new(@response.body)
+            StreamHead.new(status: @response.status, headers: Internal.headers(@response))
+          end
+        end
+
+        def read(length, timeout: nil)
+          response_head(timeout: timeout)
+          perform(timeout: timeout) { @input.read(length) }
+        end
+
+        def write(bytes)
+          perform { @body.write(bytes) }
+          nil
+        end
+
+        def close_send
+          perform { @body.close_write }
+          nil
+        end
+
+        def finish(timeout: nil)
+          perform(timeout: timeout) { @response.stream.output_task&.wait }
+          nil
+        end
+
+        def abort
+          @body.close(IOError.new("Stream abandoned"))
+          nil
+        end
+
+        private
+
+        def perform(timeout: nil, &)
+          @transport.send(:stream_operation, @operation, timeout: timeout, &)
+        end
+      end
+
+      class GRPCStreamExchange < StreamExchange
+        def response_head(timeout: nil)
+          @response_head ||= perform(timeout: timeout) do
+            @operation.fetch(:connection).read_response(@response)
+            @input = Input.new(@response.body)
+            stream = @response.stream
+            raise stream.grpc_error if stream.grpc_error
+
+            GRPCHead.new(status: @response.status, headers: stream.grpc_initial_headers,
+                         end_stream: stream.grpc_initial_end_stream)
+          end
+        end
+
+        def read(length, timeout: nil)
+          bytes = super
+          @read_eof = true if bytes.nil? || bytes.empty?
+          raise @response.stream.grpc_error if @response.stream.grpc_error
+
+          bytes
+        end
+
+        def response_trailers
+          raise StreamStateError, "Trailers require response EOF" unless @read_eof
+
+          @response.stream.grpc_trailers
+        end
+
+        def finish(timeout: nil)
+          super
+          stream = @response.stream
+          raise stream.grpc_error if stream.grpc_error
+          unless stream.grpc_initial_end_stream || stream.grpc_trailers
+            raise Error.new(:internal, "Missing final gRPC HEADERS"), cause: nil
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/connectrpc/async/tls.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "digest"
+
+module ConnectRPC
+  module Async
+    module Internal
+      class TLS
+        CERTIFICATE = %r{\A-----BEGIN CERTIFICATE-----\s+[A-Za-z0-9+/=\s]+-----END CERTIFICATE-----\z}
+        PRIVATE_KEY = %r{
+          \A-----BEGIN\ (RSA\ PRIVATE\ KEY|EC\ PRIVATE\ KEY|PRIVATE\ KEY)-----
+          \s+[A-Za-z0-9+/=\s]+-----END\ \1-----\z
+        }x
+
+        def self.certificate(pem)
+          raise ArgumentError unless pem.is_a?(String) && CERTIFICATE.match?(pem.strip)
+
+          certificates = OpenSSL::X509::Certificate.load(pem.dup)
+          raise ArgumentError unless certificates.size == 1
+
+          certificate = certificates.first
+          raise ArgumentError unless certificate.not_before <= Time.now && certificate.not_after > Time.now
+
+          certificate
+        end
+
+        def self.identity(chain, pem)
+          raise ArgumentError unless chain.is_a?(Array) && !chain.empty?
+          raise ArgumentError unless pem.is_a?(String) && PRIVATE_KEY.match?(pem.strip)
+
+          certificates = chain.map { |element| certificate(element) }
+          key = OpenSSL::PKey.read(pem.dup) { nil }
+          digest = %w[ED25519 ED448].include?(key.oid) ? nil : "SHA256"
+          challenge = SecureRandom.random_bytes(32)
+          signature = key.sign(digest, challenge)
+          raise ArgumentError unless certificates.first.public_key.verify(digest, signature, challenge)
+
+          certificates.each_cons(2) do |child, issuer|
+            raise ArgumentError unless child.issuer == issuer.subject && child.verify(issuer.public_key)
+          end
+          [certificates, key]
+        end
+
+        def self.configure(context)
+          context.min_version = OpenSSL::SSL::TLS1_2_VERSION
+          context.options |= OpenSSL::SSL::OP_NO_TICKET
+          context.session_cache_mode = OpenSSL::SSL::SSLContext::SESSION_CACHE_OFF
+          context.session_id_context = SecureRandom.random_bytes(16)
+        end
+
+        def self.server(certificate_chain:, private_key:, client_ca:, alpn_protocols: ["h2"])
+          certificates, key = identity(certificate_chain, private_key)
+          context = OpenSSL::SSL::SSLContext.new
+          configure(context)
+          context.add_certificate(certificates.first, key, certificates.drop(1))
+          unless client_ca.nil?
+            raise ArgumentError unless client_ca.is_a?(Array) && !client_ca.empty?
+
+            store = OpenSSL::X509::Store.new
+            anchors = client_ca.map { |pem| certificate(pem) }
+            anchors.uniq(&:to_der).each { |anchor| store.add_cert(anchor) }
+            store.flags = OpenSSL::X509::V_FLAG_PARTIAL_CHAIN
+            context.cert_store = store
+            context.verify_mode = OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+          end
+          context.alpn_select_cb = lambda do |protocols|
+            selected = alpn_protocols.find { |protocol| protocols.include?(protocol) }
+            raise OpenSSL::SSL::SSLError, "Unsupported ALPN" unless selected
+
+            selected
+          end
+          context.setup
+          trust = anchors.map(&:to_der).uniq.sort if anchors
+          canonical = [certificates.map(&:to_der), key.public_to_der, trust]
+          new(context, !client_ca.nil?, fingerprint: Digest::SHA256.digest(Marshal.dump(canonical)).freeze,
+                                        expires_at: certificates.map(&:not_after).min.freeze)
+        rescue StandardError
+          raise ArgumentError, "Invalid TLS snapshot", cause: nil
+        end
+
+        def self.client(ca_file:, certificate_chain:, private_key:, alpn_protocols: ["h2"])
+          context = OpenSSL::SSL::SSLContext.new
+          context.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER, verify_hostname: true)
+          configure(context)
+          store = OpenSSL::X509::Store.new
+          store.set_default_paths
+          store.add_file(ca_file) if ca_file
+          context.cert_store = store
+          if certificate_chain || private_key
+            certificates, key = identity(certificate_chain, private_key)
+            context.add_certificate(certificates.first, key, certificates.drop(1))
+          end
+          context.alpn_protocols = alpn_protocols
+          context.setup
+          new(context, false)
+        rescue StandardError
+          raise ArgumentError, "Invalid TLS client configuration", cause: nil
+        end
+
+        def initialize(context, authenticated, fingerprint: nil, expires_at: nil)
+          @context = context
+          @authenticated = authenticated
+          @fingerprint = fingerprint
+          @expires_at = expires_at
+          freeze
+        end
+
+        attr_reader :fingerprint
+
+        def check_validity!
+          raise ArgumentError, "Expired TLS snapshot", cause: nil if @expires_at && Time.now >= @expires_at
+        end
+
+        def socket(raw)
+          OpenSSL::SSL::SSLSocket.new(raw, @context).tap { |socket| socket.sync_close = true }
+        end
+
+        def authenticated? = @authenticated
+        def inspect = "#<#{self.class} private TLS snapshot>"
+      end
+    end
+  end
+end