Java ServerBuilder.forPort方法代码示例

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
@Override
public void onLocalNodeStarted() {
  if (grpcPort != 0) {
    ServerBuilder sb = ServerBuilder.forPort(grpcPort);
    RegisterGrpcApi.registerWithServer(sb);
    netty = sb.build();
    try {
      netty.start();
      Log.info("Started GRPC server on localhost:" + grpcPort);
    } catch (IOException e) {
      netty = null;
      throw new RuntimeException("Failed to start the GRPC server on port " + grpcPort, e);
    }
    Runtime.getRuntime().addShutdownHook(new Thread() {
      @Override
      public void run() {
        if (netty != null) {
          // Use stderr here since the logger may have been reset by its JVM shutdown hook.
          System.err.println("*** shutting down gRPC server since JVM is shutting down");
          netty.shutdown();
          System.err.println("*** server shut down");
        }
      }
    });
  }
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
private static void startServerOnPort(int port) {
  ServerBuilder<?> serverBuilder = ServerBuilder.forPort(port);
  serverBuilder.addService(new MyTxEventService(connected.get(port), eventsMap.get(port), delays.get(port)));
  Server server = serverBuilder.build();

  try {
    server.start();
    servers.put(port, server);
  } catch (IOException e) {
    fail(e.getMessage());
  }
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
@Test
public void testSyncFunctions() throws IOException, InterruptedException {
    ServerBuilder.forPort(port);
    AskerServer server = new AskerServer();

    try {
        server.start();

        AskerClient client = new AskerClient();
        AskerBlockingStub blockingStub = client.blockingStub;

        SyncHelper helper = new SyncHelper(collector);

        helper.checkEcho(blockingStub);
        helper.checkCount(blockingStub);
        helper.checkReverse(blockingStub);
        helper.checkUpperCast(blockingStub);
        helper.checkLowerCast(blockingStub);

        helper.checkRandom(blockingStub, 5 + random.nextInt(10));

    } finally {
        if (server != null) {
            server.stop();
        }
    }
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
@Test
public void testAsyncFunctions() throws IOException, InterruptedException, ExecutionException {
    ServerBuilder.forPort(port);
    AskerServer server = new AskerServer();

    try {
        server.start();

        AskerClient client = new AskerClient();
        AskerStub stub = client.asyncStub;

        AsyncHelper helper = new AsyncHelper(collector);

        helper.checkEcho(stub);
        helper.checkCount(stub);
        helper.checkReverse(stub);
        helper.checkUpperCast(stub);
        helper.checkLowerCast(stub);

        helper.checkRandom(stub, 5 + random.nextInt(10));

    } finally {
        if (server != null) {
            server.stop();
        }
    }
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
public void startInsecure(int port) throws IOException {
    ServerBuilder builder = ServerBuilder.forPort(port);
    if (mAuthenticator != null) {
        builder.addService(ServerInterceptors.intercept(
            mSdkService, new AuthenticationInterceptor(this.mAuthenticator)));
    } else {
        builder.addService(mSdkService);
    }
    mGrpc = builder.build();
    mGrpc.start();
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
@Override
public Server buildServerForServices(int port, Collection<BindableService> services) {
    ServerBuilder builder = ServerBuilder.forPort(port);
    setupServer(builder);
    services.forEach(service -> registerService(builder, service));
    return builder.build();
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
@Override
public Server buildServer() throws IOException {

  ServerBuilder serverBuilder = ServerBuilder.forPort(0);
  
  serverBuilder = bindService(serverBuilder);
  rpcServer = serverBuilder.build();
  return rpcServer;
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
/**
 * @param environment to use
 * @return A {@link ServerBuilder}, with port and optional transport security set from the configuration. To use
 *         this, add gRPC services to the server, then call build(). The returned server is lifecycle-managed in the
 *         given {@link Environment}.
 */
public ServerBuilder<?> builder(final Environment environment) {
    final ServerBuilder<?> originBuilder;
    final ServerBuilder<?> dropwizardBuilder;
    originBuilder = ServerBuilder.forPort(port);
    dropwizardBuilder = new DropwizardServerBuilder(environment, originBuilder, shutdownPeriod);
    if (certChainFile != null && privateKeyFile != null) {
        dropwizardBuilder.useTransportSecurity(certChainFile.toFile(), privateKeyFile.toFile());
    }
    return dropwizardBuilder;
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
@VisibleForTesting
Server createGrpcServer() {
    final ServerBuilder builder = ServerBuilder.forPort(port);
    for (ServerServiceDefinition service : services) {
        builder.addService(service);
    }

    return builder.build();
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
@Autowired
public ExternalRpcServer(PredictionService predictionService)
{
	logger.info("Initializing RPC server...");
	this.predictionService = predictionService;
	ServerBuilder<?> serverBuilder = ServerBuilder.forPort(port);
	server = serverBuilder.addService(ServerInterceptors.intercept(this, this)).build();
	
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
LoadServer(Control.ServerConfig config) throws Exception {
  log.log(Level.INFO, "Server Config \n" + config.toString());
  port = config.getPort() ==  0 ? Utils.pickUnusedPort() : config.getPort();
  ServerBuilder<?> serverBuilder = ServerBuilder.forPort(port);
  int asyncThreads = config.getAsyncServerThreads() == 0
      ? Runtime.getRuntime().availableProcessors()
      : config.getAsyncServerThreads();
  // The concepts of sync & async server are quite different in the C impl and the names
  // chosen for the enum are based on that implementation. We use 'sync' to mean
  // the direct executor case in Java even though the service implementations are always
  // fully async.
  switch (config.getServerType()) {
    case ASYNC_SERVER: {
      serverBuilder.executor(getExecutor(asyncThreads));
      break;
    }
    case SYNC_SERVER: {
      serverBuilder.directExecutor();
      break;
    }
    case ASYNC_GENERIC_SERVER: {
      serverBuilder.executor(getExecutor(asyncThreads));
      // Create buffers for the generic service
      PooledByteBufAllocator alloc = PooledByteBufAllocator.DEFAULT;
      genericResponse = alloc.buffer(config.getPayloadConfig().getBytebufParams().getRespSize());
      if (genericResponse.capacity() > 0) {
        genericResponse.writerIndex(genericResponse.capacity() - 1);
      }
      break;
    }
    default: {
      throw new IllegalArgumentException();
    }
  }
  if (config.hasSecurityParams()) {
    File cert = TestUtils.loadCert("server1.pem");
    File key = TestUtils.loadCert("server1.key");
    serverBuilder.useTransportSecurity(cert, key);
  }
  benchmarkService = new AsyncServer.BenchmarkServiceImpl();
  if (config.getServerType() == Control.ServerType.ASYNC_GENERIC_SERVER) {
    serverBuilder.addService(
        ServerServiceDefinition
            .builder(new ServiceDescriptor(BenchmarkServiceGrpc.SERVICE_NAME,
                GENERIC_STREAMING_PING_PONG_METHOD))
            .addMethod(GENERIC_STREAMING_PING_PONG_METHOD, new GenericServiceCallHandler())
            .build());
  } else {
    serverBuilder.addService(benchmarkService);
  }
  server = serverBuilder.build();

  List<OperatingSystemMXBean> beans =
      ManagementFactory.getPlatformMXBeans(OperatingSystemMXBean.class);
  if (!beans.isEmpty()) {
    osBean = beans.get(0);
  } else {
    osBean = null;
  }
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
GrpcStartable(int port, BindableService... services) {
  ServerBuilder<?> serverBuilder = ServerBuilder.forPort(port);
  Arrays.stream(services).forEach(serverBuilder::addService);
  server = serverBuilder.build();
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
public void start() throws IOException {
    ServerBuilder serverBuilder = ServerBuilder.forPort(port);
    server = serverBuilder.addService(new AskerService()).build();
    server.start();
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
public SeldonGrpcServer(AppProperties appProperties,DeploymentStore deploymentStore,TokenStore tokenStore,DeploymentsHandler deploymentsHandler,int port)
{
    this(appProperties,deploymentStore,tokenStore,ServerBuilder.forPort(port), deploymentsHandler, port);
}
 

import io.grpc.ServerBuilder; //导入方法依赖的package包/类
public BuildFarmServer(BuildFarmServerConfig config) {
  this(ServerBuilder.forPort(config.getPort()), config);
}