io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder#forAddress ( )源码实例Demo

/**
 * Create new connection
 *
 * @param url
 */
private ManagedChannel initChannel(ProviderInfo url) {
    ClientInterceptor clientHeaderClientInterceptor = buildClientHeaderClientInterceptor();
    NettyChannelBuilder builder = NettyChannelBuilder.forAddress(url.getHost(), url.getPort());
    builder.usePlaintext();
    builder.disableRetry();
    builder.intercept(clientHeaderClientInterceptor);
    return builder.build();
}
 

public static ManagedChannel getServerChannel()
{
    final NettyChannelBuilder channelBuilder =
        NettyChannelBuilder.forAddress(getServerHost(), getServerPort());
    if (getBoolean(TLS))
    {
        final Path certificatesDir = Configuration.certificatesDirectory();
        final SslContextBuilder sslClientContextBuilder = GrpcSslContexts.forClient()
            .trustManager(certificatesDir.resolve("ca.pem").toFile())
            .keyManager(
            certificatesDir.resolve("client.pem").toFile(), certificatesDir.resolve("client.key").toFile());

        try
        {
            channelBuilder.sslContext(sslClientContextBuilder.build());
        }
        catch (final SSLException ex)
        {
            LangUtil.rethrowUnchecked(ex);
        }
    }
    else
    {
        channelBuilder.usePlaintext();
    }
    return channelBuilder.build();
}
 

public MetaStep(String... args) throws IOException, ArgumentParserException {
  ArgumentParser parser = ArgumentParsers.newFor("metastep").build();

  Subparsers subparsers = parser.addSubparsers().help("sub-command help");

  Subparser submitParser = subparsers.addParser("publish").help("publish help");
  submitParser.setDefault("sub-command", "publish");
  submitParser.addArgument("--package_prefix").required(false);
  submitParser.addArgument("--package_name").required(false);
  submitParser.addArgument("--file_name").required(false);
  submitParser.addArgument("--descriptor_set").required(false);
  submitParser.addArgument("--profile").required(false);
  submitParser.addArgument("--workspace").required(false);
  submitParser.addArgument("--server").required(true);
  submitParser.addArgument("--registry").required(false);
  submitParser.addArgument("--tls").required(false);
  submitParser.addArgument("--tls_env").required(false);
  submitParser.addArgument("--source").required(false);
  submitParser.addArgument("--comment").required(true);
  submitParser.addArgument("--user").required(false);
  submitParser.addArgument("--email").required(false);
  submitParser.addArgument("--include").nargs("*").required(false);

  Subparser validateParser = subparsers.addParser("validate").help("validate help");
  validateParser.setDefault("sub-command", "validate");
  validateParser.addArgument("--package_prefix").required(false);
  validateParser.addArgument("--package_name").required(false);
  validateParser.addArgument("--file_name").required(false);
  validateParser.addArgument("--descriptor_set").required(false);
  validateParser.addArgument("--profile").required(false);
  validateParser.addArgument("--workspace").required(false);
  validateParser.addArgument("--server").required(true);
  validateParser.addArgument("--registry").required(false);
  validateParser.addArgument("--tls").required(false);
  validateParser.addArgument("--tls_env").required(false);
  validateParser.addArgument("--source").required(false);
  validateParser.addArgument("--include").nargs("*").required(false);
  res = parser.parseArgs(args);

  descriptorFile = File.createTempFile("descriptor", ".pb");

  String server = res.getString("server");
  String[] sp = server.split(":");
  String host = sp[0];
  int port = Integer.parseInt(sp[1]);

  String protoWorkspace = res.getString("workspace");
  if (protoWorkspace == null) {
    protoWorkspace = "/var/workspace";
  }
  workspace = new File(protoWorkspace);
  System.out.println("Workspace set to: " + workspace);

  protoIncludes = res.getList("include");
  if (protoIncludes == null) {
    protoIncludes = new ArrayList<>();
  }
  protoIncludes.add("/usr/include");

  if (res.get("source") != null) {
    includeSource = true;
  }

  String tlsFileName = res.getString("tls");
  if (tlsFileName == null) {
    String tlsEnv = res.getString("tls_env");
    if (tlsEnv != null) {
      File tlsFile = File.createTempFile("tls", ".pem");
      tlsFileName = tlsFile.getAbsolutePath();
      String tlsBase64 = System.getenv(tlsEnv);
      if (tlsBase64 == null) {
        throw new RuntimeException("No ENVIRONMENT_VARIABLE of name " + tlsEnv + " found.");
      }
      try (FileOutputStream writer = new FileOutputStream(tlsFile)) {
        writer.write(Base64.getDecoder().decode(tlsBase64));
      }
    }
  }

  NettyChannelBuilder channelBuilder = NettyChannelBuilder.forAddress(host, port);
  if (tlsFileName != null) {
    SslContext sslContext =
        GrpcSslContexts.forClient().trustManager(new File(tlsFileName)).build();

    channelBuilder.sslContext(sslContext).useTransportSecurity().build();
  } else {
    channelBuilder.usePlaintext();
  }
  schemaRegistry = RegistryGrpc.newBlockingStub(channelBuilder.build());
}
 

private ManagedChannelFactory createManagedChannelFactory(String serviceName,
                                                          boolean tlsEnabled,
                                                          String trustCertCollectionFile,
                                                          String clientCertChainFile,
                                                          String clientPrivateKeyFile) {
    Supplier<ManagedChannel> dynamicManagedChannel = () -> {

        NettyChannelBuilder nettyChannelBuilder;

        if (flairCachingConfig.getUrl() == null) {
            InstanceInfo instanceInfo = client.getNextServerFromEureka(serviceName, false);

            nettyChannelBuilder = NettyChannelBuilder.forAddress(
                    tlsEnabled ? instanceInfo.getHostName() : instanceInfo.getIPAddr(),
                    instanceInfo.getPort());

            log.info("GRPC config: Hostname {} IP {} port {} secure port {} secure vip {}",
                    instanceInfo.getHostName(), instanceInfo.getIPAddr(), instanceInfo.getPort(), instanceInfo.getSecurePort(),
                    instanceInfo.getSecureVipAddress());
        } else {
            nettyChannelBuilder = NettyChannelBuilder.forTarget(flairCachingConfig.getUrl());

            log.info("GRPC config: Hostname url {}", flairCachingConfig.getUrl());
        }

        if (tlsEnabled) {

            nettyChannelBuilder.negotiationType(NegotiationType.TLS);

            log.info("GRPC config: GRPC TLS enabled");

            try {
                nettyChannelBuilder.sslContext(buildSslContext(
                        trustCertCollectionFile,
                        clientCertChainFile,
                        clientPrivateKeyFile
                ));
            } catch (SSLException e) {
                log.error("GRPC config: error", e);
            }
        } else {
            nettyChannelBuilder.usePlaintext();
        }
        return nettyChannelBuilder.build();
    };
    return new ManagedChannelFactory(dynamicManagedChannel);
}