@Override
public ManagedChannel build() {
  if (!CheckGcpEnvironment.isOnGcp()) {
    if (enableUntrustedAlts) {
      logger.log(
          Level.WARNING,
          "Untrusted ALTS mode is enabled and we cannot guarantee the trustworthiness of the "
              + "ALTS handshaker service");
    } else {
      Status status =
          Status.INTERNAL.withDescription("ALTS is only allowed to run on Google Cloud Platform");
      delegate().intercept(new FailingClientInterceptor(status));
    }
  }
  InternalNettyChannelBuilder.setProtocolNegotiatorFactory(
      delegate(),
      new ClientAltsProtocolNegotiatorFactory(
          targetServiceAccountsBuilder.build(), handshakerChannelPool));

  return delegate().build();
}
 

private ComputeEngineChannelBuilder(String target) {
  delegate = NettyChannelBuilder.forTarget(target);
  SslContext sslContext;
  try {
    sslContext = GrpcSslContexts.forClient().build();
  } catch (SSLException e) {
    throw new RuntimeException(e);
  }
  InternalNettyChannelBuilder.setProtocolNegotiatorFactory(
      delegate(),
      new GoogleDefaultProtocolNegotiatorFactory(
          /* targetServiceAccounts= */ ImmutableList.<String>of(),
          SharedResourcePool.forResource(HandshakerServiceChannel.SHARED_HANDSHAKER_CHANNEL),
          sslContext));
  CallCredentials credentials = MoreCallCredentials.from(ComputeEngineCredentials.create());
  Status status = Status.OK;
  if (!CheckGcpEnvironment.isOnGcp()) {
    status =
        Status.INTERNAL.withDescription(
            "Compute Engine Credentials can only be used on Google Cloud Platform");
  }
  delegate().intercept(new CallCredentialsInterceptor(credentials, status));
}
 

private AltsChannelBuilder(String target) {
  delegate =
      NettyChannelBuilder.forTarget(target)
          .keepAliveTime(20, TimeUnit.SECONDS)
          .keepAliveTimeout(10, TimeUnit.SECONDS)
          .keepAliveWithoutCalls(true);
  InternalNettyChannelBuilder.setProtocolNegotiatorFactory(
      delegate(), new ProtocolNegotiatorFactory());
}
 

/**
 * Resets client/server and their flow control windows.
 */
private void createAndStartChannel(int clientFlowControlWindow) {
  NettyChannelBuilder channelBuilder =
      NettyChannelBuilder
          .forAddress(new InetSocketAddress("localhost", proxyPort))
          .initialFlowControlWindow(clientFlowControlWindow)
          .negotiationType(NegotiationType.PLAINTEXT);
  InternalNettyChannelBuilder.setProtocolNegotiatorFactory(channelBuilder, capturingPnFactory);
  channel = channelBuilder.build();
}
 

private GoogleDefaultChannelBuilder(String target) {
  delegate = NettyChannelBuilder.forTarget(target);
  InternalNettyChannelBuilder.setProtocolNegotiatorFactory(
      delegate(), new ProtocolNegotiatorFactory());
}
 

private void setupInternal(NettyChannelBuilder channelBuilder) {
    InternalNettyChannelBuilder.setStatsEnabled(channelBuilder, false);
    InternalNettyChannelBuilder.setTracingEnabled(channelBuilder, false);
    InternalNettyChannelBuilder.setStatsRecordStartedRpcs(channelBuilder, false);
}
 

@Override
public ManagedChannel build() {
  InternalNettyChannelBuilder.setProtocolNegotiatorFactory(
      delegate, SdsProtocolNegotiators.clientProtocolNegotiatorFactory());
  return delegate.build();
}