connectrpc 0.1.0

data/lib/connectrpc/server.rb

@@ -0,0 +1,398 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  class Server # rubocop:disable Metrics/ClassLength
+    attr_reader :services
+
+    # Public configuration keeps each validation next to its assignment.
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def initialize(services:, binding:, handlers: {}, invoker: nil, request_limit: Protocol::DEFAULT_LIMIT,
+                   response_limit: Protocol::DEFAULT_LIMIT, request_wire_limit: request_limit,
+                   response_wire_limit: response_limit, protocol: :connect, mode: :unary, encoding: :identity,
+                   instrumentation: nil, get_query_limit: nil, terminal_wire_limit: 65_536, terminal_limit: 65_536,
+                   status_codec: nil, grpc_status_wire_limit: 65_536, grpc_status_limit: 65_536, cors: nil)
+      Protocol.profile!(protocol, mode, encoding, server: true)
+      @protocol = Protocol.server_protocols(protocol)
+      unless cors.nil? || (cors.is_a?(GRPCWebCORS) && @protocol.include?(:grpc_web))
+        raise ArgumentError, "cors requires a GRPCWebCORS policy and explicit gRPC-Web enablement"
+      end
+
+      @cors = cors
+      @grpc_status_wire_limit = Protocol.limit!(grpc_status_wire_limit)
+      @grpc_status_limit = Protocol.limit!(grpc_status_limit)
+      @status_codec = GRPCProtocol.status_codec!(binding, status_codec) if @protocol.intersect?(%i[grpc grpc_web])
+      @terminal_wire_limit = Protocol.limit!(terminal_wire_limit)
+      @terminal_limit = Protocol.limit!(terminal_limit)
+      @services = services.dup.freeze
+      @methods = declarations(services)
+      raise ArgumentError, "Handler path is not declared" unless handlers.keys.all? { |key| @methods.key?(key) }
+
+      @handlers = handlers.dup.freeze
+      @invoker = invoker || method(:invoke_handler)
+      @instrumentation = instrumentation
+      @binding = binding
+      @encoding = encoding
+      @request_wire_limit = Protocol.limit!(request_wire_limit)
+      query_limit = (3 * (4 * ((@request_wire_limit + 2) / 3))) + 1024
+      @get_query_limit = Protocol.limit!(get_query_limit.nil? ? query_limit : get_query_limit)
+      @response_wire_limit = Protocol.limit!(response_wire_limit)
+      @request_limit = Protocol.limit!(request_limit)
+      @response_limit = Protocol.limit!(response_limit)
+      @error_limit = [@response_limit, @response_wire_limit].min
+    end
+
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    def handles?(path)
+      services.any? { |service| path == "/#{service.name}" || path.start_with?("/#{service.name}/") }
+    end
+
+    def start_call(path:, headers:, http_method: "POST")
+      instrumentation = @instrumentation
+      return unless instrumentation
+
+      instrumentation.start(owner: self, path: path.dup.freeze, role: :server, method: @methods[path],
+                            carrier: Instrumentation.carrier(headers),
+                            protocol: request_protocol(headers, http_method))
+    end
+
+    # Keep processing and terminal ensures adjacent to their owner.
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def call(path:, http_method:, headers:, input:, query: "", lifecycle: nil, cancellation: nil)
+      if @protocol.include?(:grpc_web)
+        early = cors_response(path: path, http_method: http_method, headers: headers)
+        return early if early
+        if request_protocol(headers, http_method) == :grpc_web
+          return call_grpc_web_unary(path, http_method, headers, input, lifecycle, cancellation)
+        end
+      end
+      unless lifecycle || @instrumentation
+        return process_call(path: path, http_method: http_method, headers: headers, input: input, query: query,
+                            cancellation: cancellation)
+      end
+
+      owned = lifecycle.nil?
+      lifecycle ||= start_call(path: path, headers: headers, http_method: http_method)
+      active = lifecycle #: Instrumentation::Handle
+      active.begin_processing(self, path)
+      # @type var error: Exception?
+      error = nil
+      begin
+        active.activate do
+          process_call(path: path, http_method: http_method, headers: headers, input: input, query: query,
+                       lifecycle: active, cancellation: cancellation)
+        end
+      rescue Exception => e # rubocop:disable Lint/RescueException -- include escapes from processing cleanup
+        error = e
+        raise
+      ensure
+        active.processing_finished(code: nil, error: error) unless active.outcome
+        active.finish(delivery: :unobserved) if owned
+      end
+    end
+
+    private
+
+    def request_protocol(headers, http_method)
+      # Query controls own Connect GET, including rejection before header work.
+      return :connect if http_method == "GET" && @protocol.include?(:connect)
+
+      headers = Protocol.headers(headers)
+      return :grpc_web if GRPCWeb.intent?(headers)
+
+      GRPCProtocol.intent?(headers) ? :grpc : :connect
+    end
+
+    def process_call(path:, http_method:, headers:, input:, query:, lifecycle: nil, cancellation: nil)
+      # @type var response: TransportResponse?
+      # @type var context: Context?
+      context = nil
+      # @type var error: Exception?
+      error = nil
+      # @type var cleaned: bool
+      cleaned = false
+      begin
+        cancellation&.check!
+        return response = bare(415, {}, cancellation: cancellation) unless @protocol.include?(:connect)
+
+        method = @methods[path]
+        safe = method.is_a?(Method) && method.idempotency == :no_side_effects
+        unless http_method == "POST" || (http_method == "GET" && (!method || safe))
+          return response = bare(405, { "allow" => [safe ? "GET, POST" : "POST"] }, cancellation: cancellation)
+        end
+        if http_method == "GET"
+          return response = process_get(path, headers, input, query, lifecycle, cancellation) do |created|
+            context = created
+          end
+        end
+
+        headers = Protocol.headers(headers)
+        codec = Protocol.content_codec(Protocol.single(headers, "content-type"))
+        unless codec
+          return response = bare(415, { "accept-post" => ["application/proto, application/json"] },
+                                 cancellation: cancellation)
+        end
+
+        decoded_context = context = request_context(headers, lifecycle, cancellation)
+        response = dispatch(path, headers, input, codec, decoded_context, lifecycle: lifecycle)
+      rescue Error => e
+        lifecycle&.record_failure(e)
+        response = error_response(terminal_error(e, context, cancellation), context, lifecycle)
+      rescue StandardError => e
+        lifecycle&.record_failure(e)
+        safe = terminal_error(Error.new(:internal, "Internal error"), context, cancellation)
+        response = error_response(safe, context, lifecycle)
+      ensure
+        context&.close
+        vary_get(response) if http_method == "GET" && response
+        cleaned = true
+      end
+    rescue Exception => e # rubocop:disable Lint/RescueException -- include rescue handlers and cleanup in the escape boundary
+      error = e
+      raise
+    ensure
+      if lifecycle && !lifecycle.outcome
+        lifecycle.processing_finished(code: response&.status == 200 && cleaned && !error ? "OK" : lifecycle.code,
+                                      error: error,
+                                      normalized_error: lifecycle.normalized_error,
+                                      http_status: response&.status, response_bytes: response&.body&.bytesize,
+                                      response_metadata: response ? Instrumentation.carrier(response.headers) : {})
+      end
+    end
+
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    # GET negotiation and dispatch preserve the specified rejection order.
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def process_get(path, headers, input, query, lifecycle, state) # rubocop:disable Metrics/ParameterLists
+      Protocol.check_size!(query, @get_query_limit)
+      headers = Protocol.headers(headers)
+      # Start valid deadlines before query work, but defer invalid timeout errors
+      # until after codec/body/compression/version negotiation.
+      timeout_error = nil #: Error?
+      deadline = begin
+        request_deadline(headers)
+      rescue Error => e
+        timeout_error = e
+        nil
+      end
+      context = Context.new(deadline: deadline, lifecycle: lifecycle, cancellation: state)
+      yield context
+      values = GetQuery.parse(query, limit: @get_query_limit, wire_limit: @request_wire_limit, deadline: context)
+      codecs = { "proto" => :proto, "json" => :json } #: Hash[String, codec]
+      codec = codecs[values["encoding"] || ""]
+      return bare(415, { "accept-post" => ["application/proto, application/json"] }, context: context) unless codec
+      unless empty_get_body?(headers, input, context)
+        return bare(415, { "accept-post" => ["application/proto, application/json"] }, context: context)
+      end
+
+      negotiated = get_headers(headers, values)
+      raise Error.new(:invalid_argument, "Missing GET message") unless values.key?("message")
+      raise timeout_error if timeout_error
+
+      metadata = Protocol.metadata(headers)
+      lifecycle.request_metadata = Instrumentation.carrier(metadata) if lifecycle
+      metadata.each { |key, values| context.request_metadata[key] = values }
+      context.check!
+      method = @methods[path]
+      raise Error.new(:unimplemented, "Unknown method") unless method.is_a?(Method)
+
+      bytes = GetQuery.payload(values, limit: @request_wire_limit, deadline: context)
+      lifecycle.request_bytes = bytes.bytesize if lifecycle
+      bytes = inflate_request(bytes, negotiated, context)
+      request = decode_request(bytes, method, codec, context)
+      response = @invoker.call(method, request, context)
+      encoding = Protocol.response_encoding(negotiated, Protocol.content_encoding(negotiated), @encoding)
+      encode_response(response, method, codec, context, encoding)
+    end
+
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    def empty_get_body?(headers, input, deadline)
+      deadline&.check!
+      length = Protocol.content_length!(headers["content-length"], invalid_code: :invalid_argument)
+      return false if length&.positive?
+
+      bytes = input&.read(1)
+      deadline&.check!
+      bytes.nil? || bytes.empty?
+    end
+
+    def get_headers(headers, values)
+      negotiated = headers.except("content-type", "content-encoding", "connect-protocol-version")
+      coding = values["compression"]
+      negotiated["content-encoding"] = [coding] if coding && !coding.empty?
+      # Validate coding before version, matching the GET negotiation order.
+      validate_headers!(negotiated)
+      version = values["connect"]
+      if version && !version.empty? && version != "v1"
+        raise Error.new(:invalid_argument, "Unsupported Connect protocol version")
+      end
+
+      negotiated
+    end
+
+    def vary_get(response)
+      values = response.headers.fetch("vary", [])
+      tokens = values.flat_map { |value| value.split(",").map(&:strip) }
+      return if tokens.any? { |token| token == "*" || token.casecmp?("accept-encoding") }
+
+      response.headers["vary"] = values + ["Accept-Encoding"]
+    end
+
+    def declarations(services)
+      raise ArgumentError, "Invalid service declarations" unless services.is_a?(Array) && services.all?(Service)
+      raise ArgumentError, "Duplicate service" unless services.map(&:name).uniq.size == services.size
+
+      services.flat_map(&:methods).to_h { |method| [method.path, method] }.freeze
+    end
+
+    def invoke_handler(method, request, context)
+      handler = @handlers[method.path]
+      raise Error.new(:unimplemented, "Unknown method") unless handler
+
+      unary = handler #: _Handler[untyped, untyped]
+      unary.call(request, context)
+    end
+
+    def dispatch(path, headers, input, codec, context, lifecycle: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      context.check!
+      method = @methods[path]
+      raise Error.new(:unimplemented, "Unknown method") unless method.is_a?(Method)
+
+      length = Protocol.content_length!(headers["content-length"], invalid_code: :invalid_argument)
+      bytes = MessageIO.new(input, @request_wire_limit, context).read(length)
+      lifecycle.request_bytes = bytes.bytesize if lifecycle
+      bytes = inflate_request(bytes, headers, context)
+      request = decode_request(bytes, method, codec, context)
+      response = @invoker.call(method, request, context)
+      encoding = Protocol.response_encoding(headers, Protocol.content_encoding(headers), @encoding)
+      encode_response(response, method, codec, context, encoding)
+    end
+
+    def inflate_request(bytes, headers, context)
+      if Protocol.content_encoding(headers) == :gzip && !bytes.empty?
+        bytes = Compression.decode(bytes, limit: @request_limit, deadline: context,
+                                          on_error: ->(error) { context.record_failure(error) })
+      end
+      Protocol.check_size!(bytes, @request_limit)
+      bytes
+    rescue Compression::Malformed => e
+      context.record_failure(e)
+      raise Error.new(:invalid_argument, "Cannot decompress request")
+    end
+
+    def decode_request(bytes, method, codec, context)
+      context.check!
+      request = @binding.decode(bytes, type: method.request_type, codec: codec)
+      context.check!
+      request
+    rescue CodecError => e
+      context.record_failure(e)
+      raise Error.new(:invalid_argument, "Cannot decode request")
+    end
+
+    def encode_response(message, method, codec, context, encoding) # rubocop:disable Metrics/MethodLength
+      body = serialize_response(message, method, codec, context)
+      headers = response_headers(context, Protocol::CONTENT_TYPES.fetch(codec))
+      if encoding == :gzip
+        body = Compression.encode(body, limit: @response_wire_limit, deadline: context,
+                                        on_error: ->(error) { context.record_failure(error) })
+        headers["content-encoding"] = ["gzip"]
+      end
+      Protocol.check_size!(body, @response_wire_limit)
+      context.check!
+      context.commit!
+      TransportResponse.new(status: 200, headers: headers, body: body)
+    end
+
+    def serialize_response(message, method, codec, context)
+      context.check!
+      body = @binding.encode(message, type: method.response_type, codec: codec)
+      context.check!
+      Protocol.check_size!(body, @response_limit)
+      body
+    end
+
+    def bare(status, headers, context: nil, cancellation: nil)
+      context ? context.commit! : cancellation&.check!
+      TransportResponse.new(status: status, headers: headers, body: "")
+    end
+
+    def request_context(headers, lifecycle = nil, cancellation = nil)
+      validate_headers!(headers)
+      metadata = Protocol.metadata(headers)
+      lifecycle.request_metadata = Instrumentation.carrier(metadata) if lifecycle
+      Context.new(request_metadata: metadata, deadline: request_deadline(headers), lifecycle: lifecycle,
+                  cancellation: cancellation)
+    rescue ArgumentError => e
+      lifecycle&.record_failure(e)
+      raise Error.new(:invalid_argument, "Malformed request metadata")
+    end
+
+    def validate_headers!(headers)
+      if headers.key?("connect-protocol-version") && Protocol.single(headers, "connect-protocol-version") != "1"
+        raise Error.new(:invalid_argument, "Unsupported Connect protocol version")
+      end
+
+      encoding = Protocol.content_encoding(headers)
+      return if encoding == :identity || (encoding == :gzip && @encoding == :gzip)
+
+      supported = @encoding == :gzip ? "gzip, identity" : "identity"
+      raise Error.new(:unimplemented, "Supported content encodings: #{supported}")
+    end
+
+    def request_deadline(headers)
+      return unless headers.key?("connect-timeout-ms")
+
+      value = Protocol.single(headers, "connect-timeout-ms")
+      unless value && /\A[0-9]{1,10}\z/.match?(value) && value.to_i.positive?
+        raise Error.new(:invalid_argument, "Invalid Connect timeout")
+      end
+
+      Deadline.new(value.to_i / 1000.0)
+    end
+
+    def response_headers(context, content_type)
+      # @type var headers: headers
+      headers = context ? context.response_metadata.to_h : {}
+      context&.response_trailers&.each { |key, values| headers["trailer-#{key}"] = values }
+      headers["accept-encoding"] = ["gzip, identity"] if @encoding == :gzip
+      headers.merge("content-type" => [content_type])
+    end
+
+    def terminal_error(error, context, cancellation)
+      if context
+        context.commit!
+      else
+        cancellation&.check!
+      end
+      error
+    rescue Error => e
+      e
+    end
+
+    def error_response(error, context, lifecycle = nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      # @type var effective: Error?
+      # @type var code: String?
+      effective = code = nil
+      body, status = if lifecycle
+                       Protocol.error_body(error, @error_limit) do |selected, emitted|
+                         effective = selected
+                         code = emitted
+                       end
+                     else
+                       Protocol.error_body(error, @error_limit)
+                     end
+      headers = response_headers(context, "application/json")
+      error.metadata.each { |key, values| headers[key] = (headers[key] || []) + values }
+      error.trailers.each { |key, values| headers["trailer-#{key}"] = (headers["trailer-#{key}"] || []) + values }
+      response = TransportResponse.new(status: status, headers: headers, body: body)
+      if lifecycle
+        lifecycle.code = code
+        lifecycle.normalized_error = effective
+      end
+      response
+    end
+  end
+end

data/lib/connectrpc/streaming/client.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  class Client
+    def server_stream(method, request, metadata: {}, timeout: 30, cancellation: nil, &block)
+      validate_stream_call!(method, ServerStreamMethod, cancellation, block)
+      stream_call(method, request, metadata, timeout, cancellation, &block)
+    end
+
+    def client_stream(method, metadata: {}, timeout: 30, cancellation: nil, &block)
+      validate_stream_call!(method, ClientStreamMethod, cancellation, block)
+      stream_call(method, nil, metadata, timeout, cancellation, &block)
+    end
+
+    def bidi_stream(method, metadata: {}, timeout: 30, cancellation: nil, &block)
+      validate_stream_call!(method, BidiStreamMethod, cancellation, block)
+      stream_call(method, nil, metadata, timeout, cancellation, &block)
+    end
+
+    private
+
+    def validate_stream_call!(method, type, cancellation, block)
+      raise ArgumentError, "Wrong streaming declaration" unless method.is_a?(type)
+      raise ArgumentError, "A streaming block is required" unless block
+      unless cancellation.nil? || cancellation.is_a?(CancellationToken)
+        raise ArgumentError, "cancellation must be a CancellationToken or nil"
+      end
+      return if stream_capability?(method)
+
+      raise ArgumentError, "Transport does not support #{method.cardinality}"
+    end
+
+    def stream_capability?(method)
+      if @protocol == :grpc
+        candidate = @transport #: (_Transport | _StreamingTransport | _GRPCTransport) & _GRPCCapabilityProbe
+        return false unless candidate.respond_to?(:grpc_capabilities) && candidate.respond_to?(:open_grpc_stream)
+
+        grpc = @transport #: _GRPCTransport
+        return grpc.grpc_capabilities.include?(method.cardinality)
+      end
+      capability = @transport #: _StreamingTransport
+      streaming_transport? && capability.streaming_capabilities.include?(method.cardinality)
+    end
+
+    def streaming_transport?
+      # Runtime reflection is confined here; unary structural callers need only call.
+      transport = @transport #: (_Transport | _StreamingTransport) & _StreamCapabilityProbe
+      transport.respond_to?(:streaming_capabilities) && transport.respond_to?(:open_stream)
+    end
+
+    def stream_call(method, request, metadata, timeout, cancellation, &)
+      injection = {} #: headers
+      lifecycle = @instrumentation&.start(owner: self, role: :client, method: method, carrier: injection,
+                                          protocol: @protocol,
+                                          server_address: @base_url.hostname.freeze, server_port: @base_url.port)
+      lifecycle&.begin_processing(self)
+      work = lambda do
+        run_stream(method, request, metadata, timeout: timeout, cancellation: cancellation,
+                                              lifecycle: lifecycle, injection: injection, &)
+      end
+      lifecycle ? lifecycle.activate(&work) : work.call
+    end
+
+    def run_stream(method, request, metadata, timeout:, cancellation:, lifecycle:, injection:, &) # rubocop:disable Metrics/MethodLength
+      scope = Streaming::ClientScope.new(lifecycle)
+      scope.run(timeout, cancellation) do |state, deadline|
+        outgoing = stream_request(method, stream_metadata(metadata, injection, lifecycle), deadline, state, lifecycle)
+        transport = @transport #: _StreamingTransport
+        work = lambda do |exchange|
+          session = new_client_stream_session(method, state, exchange, lifecycle)
+          with_stream_session(session, scope) { perform_stream_scope(method, request, session, scope, &) }
+        end
+        if @protocol == :grpc
+          grpc = @transport #: _GRPCTransport
+          grpc.open_grpc_stream(outgoing, &work)
+        else
+          transport.open_stream(outgoing, &work)
+        end
+      end
+    end
+
+    def stream_metadata(metadata, injection, lifecycle)
+      metadata = Metadata.new(metadata)
+      metadata = injected_metadata(metadata, injection) if lifecycle
+      lifecycle.request_metadata = Instrumentation.carrier(metadata) if lifecycle
+      metadata
+    end
+
+    def stream_request(method, metadata, deadline, state, lifecycle) # rubocop:disable Metrics/MethodLength
+      url = @base_url.dup
+      base_path = @base_url.path #: String
+      url.path = base_path.delete_suffix("/") + method.path
+      return grpc_stream_request(url, metadata, deadline, state, lifecycle) if @protocol == :grpc
+
+      headers = metadata.to_h.merge("content-type" => [Streaming::CONTENT_TYPES.fetch(@codec)],
+                                    "connect-protocol-version" => ["1"],
+                                    "connect-accept-encoding" => [@accept_encoding.join(", ")])
+      headers["connect-content-encoding"] = ["gzip"] if @encoding == :gzip
+      headers["connect-timeout-ms"] = [deadline.timeout_ms] if deadline
+      StreamRequest.new(url: url, http_method: "POST", headers: headers, deadline: deadline,
+                        cancellation: state, lifecycle: lifecycle)
+    end
+  end
+end

data/lib/connectrpc/streaming/client_execution.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  class Client
+    private
+
+    def new_client_stream_session(method, state, exchange, lifecycle)
+      Streaming::Session.new(binding: @binding, method: method, codec: @codec, state: state,
+                             input: exchange, output: exchange, request_limit: @request_limit,
+                             response_limit: @response_limit, request_wire_limit: @request_wire_limit,
+                             response_wire_limit: @response_wire_limit, request_encoding: @encoding,
+                             response_encoding: :identity, accept_encoding: @accept_encoding,
+                             terminal_wire_limit: @terminal_wire_limit, terminal_limit: @terminal_limit,
+                             lifecycle: lifecycle, strategy: client_stream_strategy(lifecycle))
+    end
+
+    def with_stream_session(session, scope) # rubocop:disable Metrics/MethodLength
+      yield
+    rescue StandardError => e
+      scope.failure = e
+      scope.delivered_error = e if session.remote_completed?(e)
+      recovered = session.recover_send_failure if session.send_failure?(e)
+      if recovered
+        scope.delivered_error = recovered if session.remote_completed?(recovered)
+        raise recovered, cause: nil
+      end
+
+      raise
+    ensure
+      scope.cleanup(session)
+      session.close
+    end
+
+    def perform_stream_scope(method, request, session, scope)
+      prepare_server_stream(method, request, session)
+      yield_stream_endpoint(session, scope) { yield stream_endpoint(method, session) }
+      scope.abandoned = session.abandoned?
+      scope.result = finish_stream_scope(method, session)
+      scope.completed = !scope.abandoned
+    end
+
+    def prepare_server_stream(method, request, session)
+      return unless method.is_a?(ServerStreamMethod) || method.is_a?(Method)
+
+      session.send_message(request)
+      session.close_send
+    end
+
+    def yield_stream_endpoint(session, scope)
+      yield
+    rescue Exception => e # rubocop:disable Lint/RescueException -- Preserve fatal user exceptions through transport cleanup.
+      scope.record_user_error(e) unless session.owned_error?(e)
+      raise
+    end
+
+    def stream_endpoint(method, session)
+      case method
+      when ServerStreamMethod then ResponseReader.new(session)
+      when ClientStreamMethod then RequestWriter.new(session)
+      else ClientDuplex.new(session)
+      end
+    end
+
+    def finish_stream_scope(method, session)
+      return client_stream_response(session) if method.is_a?(ClientStreamMethod) || method.is_a?(Method)
+      return if session.abandoned?
+      return session.receive if session.consumed?
+
+      raise StreamNotConsumedError, "Response stream was not consumed"
+    end
+
+    def client_stream_response(session)
+      raise StreamNotConsumedError, "Client streaming was abandoned" if session.abandoned?
+
+      session.close_send
+      message = session.receive
+      raise Error.new(:unimplemented, "Expected exactly one response"), cause: nil if message.nil?
+
+      if @protocol == :grpc
+        session.receive until session.consumed?
+      else
+        session.receive
+      end
+      Response.new(message: message, metadata: session.headers, trailers: session.trailers || Metadata.new)
+    end
+  end
+end