grpc-swift/Sources/GRPC/AsyncAwaitSupport/GRPCAsyncServerCallContext.swift

/*
 * Copyright 2021, gRPC Authors All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import Logging
import NIOConcurrencyHelpers
import NIOHPACK

@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
public struct GRPCAsyncServerCallContext: Sendable {
  @usableFromInline
  let contextProvider: AsyncServerCallContextProvider

  /// Details of the request, including request headers and a logger.
  public var request: Request

  /// A response context which may be used to set response headers and trailers.
  public var response: Response {
    Response(contextProvider: self.contextProvider)
  }

  /// Notifies the client that the RPC has been accepted for processing by the server.
  ///
  /// On accepting the RPC the server will send the given headers (which may be empty) along with
  /// any transport specific headers (such the ":status" pseudo header) to the client.
  ///
  /// It is not necessary to call this function: the RPC is implicitly accepted when the first
  /// response message is sent, however this may be useful when clients require an early indication
  /// that the RPC has been accepted.
  ///
  /// If the RPC has already been accepted (either implicitly or explicitly) then this function is
  /// a no-op.
  public func acceptRPC(headers: HPACKHeaders) async {
    await self.contextProvider.acceptRPC(headers)
  }

  /// Access the ``UserInfo`` dictionary which is shared with the interceptor contexts for this RPC.
  ///
  /// - Important: While ``UserInfo`` has value-semantics, this function accesses a reference
  ///   wrapped ``UserInfo``. The contexts passed to interceptors provide the same reference. As such
  ///   this may be used as a mechanism to pass information between interceptors and service
  ///   providers.
  public func withUserInfo<Result: Sendable>(
    _ body: @Sendable @escaping (UserInfo) throws -> Result
  ) async throws -> Result {
    return try await self.contextProvider.withUserInfo(body)
  }

  /// Modify the ``UserInfo`` dictionary which is shared with the interceptor contexts for this RPC.
  ///
  /// - Important: While ``UserInfo`` has value-semantics, this function accesses a reference
  ///   wrapped ``UserInfo``. The contexts passed to interceptors provide the same reference. As such
  ///   this may be used as a mechanism to pass information between interceptors and service
  ///   providers.
  public func withMutableUserInfo<Result: Sendable>(
    _ modify: @Sendable @escaping (inout UserInfo) -> Result
  ) async throws -> Result {
    return try await self.contextProvider.withMutableUserInfo(modify)
  }

  @inlinable
  internal init(
    headers: HPACKHeaders,
    logger: Logger,
    contextProvider: AsyncServerCallContextProvider
  ) {
    self.request = Request(headers: headers, logger: logger)
    self.contextProvider = contextProvider
  }
}

@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
extension GRPCAsyncServerCallContext {
  public struct Request: Sendable {
    /// The request headers received from the client at the start of the RPC.
    public var headers: HPACKHeaders

    /// A logger.
    public var logger: Logger

    @usableFromInline
    init(headers: HPACKHeaders, logger: Logger) {
      self.headers = headers
      self.logger = logger
    }
  }

  public struct Response: Sendable {
    private let contextProvider: AsyncServerCallContextProvider

    /// Set the metadata to return at the start of the RPC.
    ///
    /// - Important: If this is required it should be updated _before_ the first response is sent
    ///   via the response stream writer. Updates must not be made after the RPC has been accepted
    ///   or the first response has been sent otherwise this method will throw an error.
    public func setHeaders(_ headers: HPACKHeaders) async throws {
      try await self.contextProvider.setResponseHeaders(headers)
    }

    /// Set the metadata to return at the end of the RPC.
    ///
    /// If this is required it must be updated before returning from the handler.
    public func setTrailers(_ trailers: HPACKHeaders) async throws {
      try await self.contextProvider.setResponseTrailers(trailers)
    }

    /// Whether compression should be enabled for responses, defaulting to `true`. Note that for
    /// this value to take effect compression must have been enabled on the server and a compression
    /// algorithm must have been negotiated with the client.
    public func compressResponses(_ compress: Bool) async throws {
      try await self.contextProvider.setResponseCompression(compress)
    }

    @usableFromInline
    internal init(contextProvider: AsyncServerCallContextProvider) {
      self.contextProvider = contextProvider
    }
  }
}