grpc-swift/Sources/GRPC/_EmbeddedThroughput.swift

/*
 * Copyright 2020, 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 NIOCore
import NIOEmbedded
import SwiftProtobuf

extension EmbeddedChannel {
  /// Configures an `EmbeddedChannel` for the `EmbeddedClientThroughput` benchmark.
  ///
  /// - Important: This is **not** part of the public API.
  public func _configureForEmbeddedThroughputTest<Request: Message, Response: Message>(
    callType: GRPCCallType,
    logger: Logger,
    requestType: Request.Type = Request.self,
    responseType: Response.Type = Response.self
  ) -> EventLoopFuture<Void> {
    return self.pipeline.addHandlers([
      GRPCClientChannelHandler(
        callType: callType,
        maximumReceiveMessageLength: .max,
        logger: logger
      ),
      GRPCClientCodecHandler(
        serializer: ProtobufSerializer<Request>(),
        deserializer: ProtobufDeserializer<Response>()
      ),
    ])
  }

  public func _configureForEmbeddedServerTest(
    servicesByName serviceProviders: [Substring: CallHandlerProvider],
    encoding: ServerMessageEncoding,
    normalizeHeaders: Bool,
    logger: Logger
  ) -> EventLoopFuture<Void> {
    let codec = HTTP2ToRawGRPCServerCodec(
      servicesByName: serviceProviders,
      encoding: encoding,
      errorDelegate: nil,
      normalizeHeaders: normalizeHeaders,
      maximumReceiveMessageLength: .max,
      logger: logger
    )
    return self.pipeline.addHandler(codec)
  }

  public func _configureForServerFuzzing(configuration: Server.Configuration) throws {
    let configurator = GRPCServerPipelineConfigurator(configuration: configuration)
    // We're always on an `EmbeddedEventLoop`, this is fine.
    try self.pipeline.syncOperations.addHandler(configurator)
  }
}