connectrpc 0.1.0

data/lib/connectrpc/streaming/streams.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  class StreamStateError < StandardError; end
+  class StreamNotConsumedError < StreamStateError; end
+
+  StreamRequest = Struct.new(:url, :http_method, :headers, :deadline, :lifecycle, :cancellation, keyword_init: true)
+  StreamHead = Struct.new(:status, :headers, keyword_init: true)
+
+  class StreamingContext < Context
+    def initialize(publish:, request_metadata: {}, deadline: nil, lifecycle: nil, cancellation: nil)
+      super(request_metadata: request_metadata, deadline: deadline, lifecycle: lifecycle, cancellation: cancellation)
+      @publish = publish
+      @headers_sent = false
+      @owner_thread = Thread.current
+      @owner_scheduler = Fiber.scheduler
+      @stream_closed = false
+    end
+
+    def send_headers(metadata: {})
+      check_headers_scope!
+      raise StreamStateError, "Response headers already published" if @headers_sent
+
+      check!
+      Metadata.new(metadata).each { |key, values| @response_metadata[key] = values }
+      @response_metadata.freeze
+      @headers_sent = true
+      @publish.call(@response_metadata)
+      nil
+    end
+
+    def close
+      @stream_closed = true
+      super
+    end
+
+    private
+
+    def check_headers_scope!
+      raise StreamStateError, "Stream scope is closed" if @stream_closed
+      return if Thread.current.equal?(@owner_thread) && Fiber.scheduler.equal?(@owner_scheduler)
+
+      raise StreamStateError, "Use the stream's owning reactor and thread"
+    end
+
+    def publish_headers(check: true)
+      return if @headers_sent
+      return send_headers if check
+
+      @response_metadata.freeze
+      @headers_sent = true
+      @publish.call(@response_metadata)
+      nil
+    end
+  end
+
+  class ResponseReader
+    def initialize(session)
+      @session = session
+    end
+
+    def receive = @session.receive
+    def headers = @session.headers
+    def trailers = @session.trailers
+    def abandon = @session.abandon
+
+    def each
+      raise ArgumentError, "A block is required" unless block_given?
+
+      while true # rubocop:disable Style/InfiniteLoop -- Kernel.loop swallows application StopIteration.
+        case message = receive
+        when nil then break
+        else yield message
+        end
+      end
+      nil
+    end
+  end
+
+  class RequestWriter
+    def initialize(session)
+      @session = session
+    end
+
+    def send_message(message) = @session.send_message(message)
+    def close_send = @session.close_send
+    def abandon = @session.abandon
+  end
+
+  class ClientDuplex < ResponseReader
+    def send_message(message) = @session.send_message(message)
+    def close_send = @session.close_send
+  end
+
+  class RequestReader < ResponseReader; end
+
+  class ResponseWriter
+    def initialize(session, context)
+      @session = session
+      @context = context
+    end
+
+    def send_message(message) = @session.send_message(message)
+    def send_headers(metadata: {}) = @context.send_headers(metadata: metadata)
+  end
+
+  class ServerDuplex < RequestReader
+    def initialize(session, context)
+      super(session)
+      @context = context
+    end
+
+    def send_message(message) = @session.send_message(message)
+    def send_headers(metadata: {}) = @context.send_headers(metadata: metadata)
+  end
+end

data/lib/connectrpc/streaming/terminal.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  module Streaming
+    def self.parse_terminal(bytes, metadata: Metadata.new, on_error: nil)
+      object = JSON.parse(bytes, max_nesting: 64)
+      raise ArgumentError unless object.is_a?(Hash)
+
+      trailers = terminal_metadata(object)
+      [terminal_error(object["error"], metadata, trailers), trailers]
+    rescue JSON::ParserError, ArgumentError, TypeError, EncodingError => e
+      on_error&.call(e)
+      raise Error.new(:internal, "Malformed streaming terminal"), cause: nil
+    end
+
+    def self.terminal_metadata(object)
+      empty = {} #: headers
+      trailers = object.fetch("metadata", empty)
+      raise ArgumentError unless trailers.is_a?(Hash)
+
+      Protocol.metadata(trailers).freeze
+    end
+
+    def self.terminal_error(error, metadata, trailers)
+      return if error.nil?
+      raise ArgumentError unless Protocol.valid_wire_error?(error)
+
+      empty = [] #: Array[ErrorDetail]
+      details = Protocol.wire_details(error.fetch("details", empty))
+      code = Error::HTTP_STATUS.key?(error["code"]) ? error["code"] : "unknown"
+      Error.new(code, error.fetch("message", ""), details: details, metadata: metadata, trailers: trailers)
+    end
+
+    def self.terminal_bytes(error, trailers, wire_limit:, limit:)
+      # @type var object: Hash[String, headers | Hash[String, String | Array[Hash[String, String]]]]
+      object = { "metadata" => trailers.to_h }
+      object["error"] = error.to_h if error
+      bytes = JSON.generate(object, max_nesting: 64)
+      return [bytes, error] if bytes.bytesize <= wire_limit && bytes.bytesize <= limit
+
+      minimal_terminal(wire_limit, limit)
+    end
+
+    def self.minimal_terminal(wire_limit, limit)
+      replacement = Error.new(:resource_exhausted, "Terminal exceeds byte limit")
+      bytes = JSON.generate({ "error" => { "code" => replacement.code } })
+      raise replacement if bytes.bytesize > wire_limit || bytes.bytesize > limit
+
+      [bytes, replacement]
+    end
+  end
+end

data/lib/connectrpc/transports/net_http.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require_relative "../../connectrpc"
+
+module ConnectRPC
+  module Transports
+    class NetHTTP # rubocop:disable Metrics/ClassLength
+      # Net::HTTP uses the open timeout again for TLS. Recompute it from the
+      # original deadline after TCP/DNS, rather than starting another budget.
+      class Connection < Net::HTTP
+        attr_accessor :deadline, :cancellation, :socket_lifecycle
+
+        private
+
+        def check_cancellation!
+          cancellation ? cancellation.check! : deadline&.check!
+        end
+
+        def connect
+          check_cancellation!
+          # begin_transport can reconnect a closed socket even with retries
+          # disabled. A second socket would escape the call's watchdog.
+          raise IOError, "Owned connection is closed" if @socket
+
+          super
+        end
+
+        def begin_transport(request)
+          check_cancellation!
+          super
+          request["connect-timeout-ms"] = deadline.timeout_ms if deadline
+        end
+
+        def ssl_socket_connect(socket, _timeout)
+          socket_lifecycle&.attach(socket.to_io)
+          check_cancellation!
+          super(socket, deadline ? deadline.native_timeout : Deadline::MAX_NATIVE_WAIT)
+          check_cancellation!
+        end
+      end
+
+      # Owns only this call's raw socket. Closing wakes Net::HTTP's blocking
+      # read/write waits even when individual header/body reads keep progressing.
+      class Watchdog
+        def initialize(socket, deadline)
+          @mutex = Mutex.new
+          @condition = ConditionVariable.new
+          @done = false
+          @thread = Thread.new { watch(socket, deadline) }
+        end
+
+        def watch(socket, deadline)
+          @mutex.synchronize do
+            @condition.wait(@mutex, deadline.native_timeout) until @done || deadline.expired?
+            close_socket(socket) unless @done
+          end
+        end
+
+        def close_socket(socket)
+          socket.shutdown(Socket::SHUT_RDWR)
+          socket.close
+        rescue IOError, SystemCallError
+          # Net::HTTP may have closed the same owned socket first.
+          nil
+        end
+
+        def stop
+          @mutex.synchronize do
+            @done = true
+            @condition.signal
+          end
+          @thread.join
+        end
+      end
+
+      # Retirement and callback closure share this guard. Unregister alone
+      # cannot prevent an already-running callback from touching a reused FD.
+      class SocketLifecycle
+        def initialize(cancellation)
+          @mutex = Mutex.new
+          @socket = nil
+          @closed = false
+          @retired = false
+          @registration = cancellation&.on_cancel { close }
+        end
+
+        def attach(socket)
+          @mutex.synchronize do
+            return if @retired
+
+            @socket = socket
+            close_socket if @closed
+          end
+        end
+
+        def close
+          @mutex.synchronize do
+            return if @retired
+
+            @closed = true
+            close_socket
+          end
+        end
+
+        def retire
+          @mutex.synchronize do
+            @retired = true
+            @socket = nil
+          end
+          @registration&.unregister
+          @registration = nil
+        end
+
+        private
+
+        def close_socket
+          @socket&.shutdown(Socket::SHUT_RDWR)
+          @socket&.close
+        rescue IOError, SystemCallError
+          nil
+        end
+      end
+
+      def call(request)
+        CallCancellation.with_request(request) { |outgoing| perform_call(outgoing) }
+      end
+
+      private
+
+      def perform_call(request) # rubocop:disable Metrics/MethodLength
+        deadline = request.deadline
+        outgoing = prepare_request(request)
+        http = connection(request.url, deadline)
+        http.cancellation = request.cancellation
+        with_connection(http, deadline, request.cancellation) { exchange(http, request, outgoing) }
+      rescue Net::OpenTimeout, Net::ReadTimeout, Net::WriteTimeout,
+             SocketError, IOError, SystemCallError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+             OpenSSL::SSL::SSLError => e
+        request.lifecycle&.record_failure(e)
+        check_request!(request)
+        raise Error.new(:unavailable, "HTTP transport failed"), cause: nil
+      end
+
+      def check_request!(request)
+        request.cancellation ? request.cancellation.check! : request.deadline&.check!
+      end
+
+      def prepare_request(request)
+        check_request!(request)
+        outgoing = outgoing_request(request)
+        check_request!(request)
+        outgoing
+      end
+
+      # Keep startup ownership and terminal retirement in one ensure.
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+      def with_connection(http, deadline, cancellation = nil)
+        sockets = SocketLifecycle.new(cancellation)
+        http.socket_lifecycle = sockets
+        cancellation&.check!
+        http.start
+        sockets.attach(http.instance_variable_get(:@socket).io.to_io)
+        cancellation ? cancellation.check! : deadline&.check!
+        # Pinned Net::HTTP exposes its BufferedIO; one call owns this raw socket.
+        watchdog = Watchdog.new(http.instance_variable_get(:@socket).io.to_io, deadline) if deadline
+        yield
+      ensure
+        watchdog&.stop
+        sockets&.retire
+        http.finish if http.started?
+      end
+
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+      def exchange(http, request, outgoing)
+        result = nil
+        http.request(outgoing) do |response|
+          check_request!(request)
+          check_response_size!(response, request.response_limit)
+          body = read_body(response, request)
+          result = TransportResponse.new(status: response.code.to_i, headers: response.to_hash, body: body)
+        end
+        check_request!(request)
+        result
+      end
+
+      def check_response_size!(response, limit)
+        length = Protocol.content_length!(response.get_fields("content-length"), invalid_code: :internal)
+        raise Error.new(:resource_exhausted, "Response exceeds byte limit") if length && length > limit
+      end
+
+      def outgoing_request(request) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        headers = request.headers.merge("connection" => ["close"])
+        accept = request.headers.fetch("accept-encoding", ["identity"]).join(", ")
+        has_body = request.http_method != "GET"
+        outgoing = Net::HTTPGenericRequest.new(request.http_method, has_body, true, request.url.request_uri,
+                                               "accept-encoding" => accept)
+        headers.each do |key, values|
+          next if key == "accept-encoding"
+
+          values.each { |value| outgoing.add_field(key, value) }
+        end
+        outgoing.body = request.body unless request.http_method == "GET"
+        outgoing
+      end
+
+      def read_body(response, request)
+        body = +"".b
+        response.read_body do |chunk|
+          check_request!(request)
+          if body.bytesize + chunk.bytesize > request.response_limit
+            raise Error.new(:resource_exhausted, "Response exceeds byte limit")
+          end
+
+          body << chunk
+        end
+        body
+      end
+
+      def verify_tls!(http)
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.verify_hostname = true
+      end
+
+      def connection(uri, deadline)
+        http = Connection.new(uri.hostname, uri.port, nil)
+        http.deadline = deadline
+        http.use_ssl = uri.scheme == "https"
+        configure_http(http, deadline)
+        http
+      end
+
+      def configure_http(http, deadline)
+        verify_tls!(http) if http.use_ssl?
+        native_timeout = deadline ? deadline.native_timeout : Deadline::MAX_NATIVE_WAIT
+        http.open_timeout = native_timeout
+        http.read_timeout = native_timeout
+        http.write_timeout = native_timeout
+        http.max_retries = 0
+        http.ignore_eof = false
+      end
+    end
+  end
+end

data/lib/connectrpc/version.rb

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

data/lib/connectrpc.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "connectrpc/version"
+require_relative "connectrpc/method"
+require_relative "connectrpc/streaming/method"
+require_relative "connectrpc/metadata"
+require_relative "connectrpc/error"
+require_relative "connectrpc/cancellation"
+require_relative "connectrpc/deadline"
+require_relative "connectrpc/protocol"
+require_relative "connectrpc/compression"
+require_relative "connectrpc/instrumentation"
+require_relative "connectrpc/get_query"
+require_relative "connectrpc/grpc"
+require_relative "connectrpc/client"
+require_relative "connectrpc/message_io"
+require_relative "connectrpc/server"
+require_relative "connectrpc/streaming/framing"
+require_relative "connectrpc/streaming/framing_io"
+require_relative "connectrpc/streaming/terminal"
+require_relative "connectrpc/streaming/strategy"
+require_relative "connectrpc/streaming/streams"
+require_relative "connectrpc/streaming/session"
+require_relative "connectrpc/streaming/session_messages"
+require_relative "connectrpc/streaming/session_io"
+require_relative "connectrpc/streaming/session_completion"
+require_relative "connectrpc/streaming/client"
+require_relative "connectrpc/streaming/client_scope"
+require_relative "connectrpc/streaming/client_execution"
+require_relative "connectrpc/grpc_client"
+require_relative "connectrpc/streaming/server"
+require_relative "connectrpc/streaming/server_execution"
+require_relative "connectrpc/streaming/server_terminal"
+require_relative "connectrpc/grpc_server"
+require_relative "connectrpc/grpc_web"
+require_relative "connectrpc/grpc_web_io"
+require_relative "connectrpc/grpc_web_cors"
+require_relative "connectrpc/grpc_web_server"

data/rbs/google_protobuf_4_36/runtime.rbs

@@ -0,0 +1,41 @@
+# protoc 36.2 / google-protobuf 4.36.2 compatibility shapes only.
+# Official message field signatures remain upstream-owned. No iteration API.
+module Google
+  module Protobuf
+    class AbstractMessage
+    end
+    interface _MessageClass[T]
+    end
+    class RepeatedField[Read, Write]
+      def []: (Integer index) -> Read?
+      def []=: (Integer index, Write value) -> nil
+      def <<: (Write value) -> self
+    end
+    class Map[KeyRead, ValueRead, KeyWrite, ValueWrite]
+      def []: (KeyWrite key) -> ValueRead?
+      def []=: (KeyWrite key, ValueWrite value) -> ValueWrite
+    end
+    interface _EnumModule
+      def lookup: (Integer) -> Symbol?
+      def resolve: (Symbol) -> Integer?
+    end
+    interface _SpecificDescriptor[T]
+      def msgclass: () -> T
+    end
+    interface _SpecificEnumDescriptor[T]
+      def enummodule: () -> T
+    end
+    class Descriptor
+      def msgclass: () -> Class
+    end
+    class EnumDescriptor
+      def enummodule: () -> Module
+    end
+    class DescriptorPool
+      def self.generated_pool: () -> DescriptorPool
+      # Other names can resolve to file/service/extension descriptors. Keep
+      # those runtime shapes opaque; upstream literal overloads refine messages.
+      def lookup: (String name) -> Object?
+    end
+  end
+end