private void start() throws IOException { /* The port on which the server should run */ int port = 50051; server = ServerBuilder.forPort(port).addService(new GreeterImpl()).build().start(); logger.info("Server started, listening on " + port); Runtime.getRuntime() .addShutdownHook( new Thread() { @Override public void run() { // 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"); HelloWorldServer.this.stop(); System.err.println("*** server shut down"); } }); }
@SuppressWarnings("rawtypes") public void init() throws Exception{ if(!init){ synchronized (this) { if(!init){ registry = new MotanHandlerRegistry(); serviceDefinetions = new HashMap<URL, ServerServiceDefinition>(); io.grpc.ServerBuilder builder = ServerBuilder.forPort(port); builder.fallbackHandlerRegistry(registry); if(executor != null){ builder.executor(executor); } if(builder instanceof NettyServerBuilder){ httpHandler = new NettyHttpRequestHandler(executor); ((NettyServerBuilder)builder).protocolNegotiator(new HttpProtocolNegotiator(httpHandler)); } server = builder.build(); server.start(); init = true; } } } }
@Override public void run(String... args) throws Exception { log.info("Starting gRPC Server ..."); Collection<ServerInterceptor> globalInterceptors = getBeanNamesByTypeWithAnnotation(GRpcGlobalInterceptor.class, ServerInterceptor.class) .map(name -> applicationContext.getBeanFactory().getBean(name, ServerInterceptor.class)) .collect(Collectors.toList()); // Adding health service serverBuilder.addService(healthStatusManager.getHealthService()); // find and register all GRpcService-enabled beans getBeanNamesByTypeWithAnnotation(GRpcService.class, BindableService.class) .forEach(name -> { BindableService srv = applicationContext.getBeanFactory().getBean(name, BindableService.class); ServerServiceDefinition serviceDefinition = srv.bindService(); GRpcService gRpcServiceAnn = applicationContext.findAnnotationOnBean(name, GRpcService.class); serviceDefinition = bindInterceptors(serviceDefinition, gRpcServiceAnn, globalInterceptors); serverBuilder.addService(serviceDefinition); String serviceName = serviceDefinition.getServiceDescriptor().getName(); healthStatusManager.setStatus(serviceName, HealthCheckResponse.ServingStatus.SERVING); log.info("'{}' service has been registered.", srv.getClass().getName()); }); if (gRpcServerProperties.isEnableReflection()) { serverBuilder.addService(ProtoReflectionService.newInstance()); log.info("'{}' service has been registered.", ProtoReflectionService.class.getName()); } configurer.configure(serverBuilder); server = serverBuilder.build().start(); applicationContext.publishEvent(new GRpcServerInitializedEvent(server)); log.info("gRPC Server started, listening on port {}.", server.getPort()); startDaemonAwaitThread(); }
.forPort(port) .useTransportSecurity(crt, key) .addService(dataTransferPipedServer) .build() .start();
Server server = ServerBuilder.forPort(serverPort) .addService(ServerInterceptors.intercept(objectStoreServicer, new LMDBServicer.KvStoreInterceptor())) .maxInboundMessageSize(256 << 20).build();
/** * Starts the RPC server. * * @throws IOException if a server cannot be successfully initialized */ @Override public void start() throws IOException { if (useInProcessServer) { final ServerBuilder builder = InProcessServerBuilder.forName(address.toString()); server = builder.addService(this) .executor(grpcExecutor) .build() .start(); } else { server = NettyServerBuilder.forAddress(new InetSocketAddress(address.getHostname(), address.getPort())) .workerEventLoopGroup(eventLoopGroup) .addService(this) .executor(grpcExecutor) .build() .start(); } // Use stderr here since the logger may have been reset by its JVM shutdown hook. Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown)); }
@Bean @ConditionalOnProperty(value = "grpc.enabled", havingValue = "true", matchIfMissing = true) public GRpcServerRunner grpcServerRunner(GRpcServerBuilderConfigurer configurer) { return new GRpcServerRunner(configurer, ServerBuilder.forPort(port)); }
/** * Configures the services that should be served by the server. * * @param builder The server builder to configure. */ protected void configureServices(final T builder) { // support health check if (this.properties.isHealthServiceEnabled()) { builder.addService(this.healthStatusManager.getHealthService()); } if (this.properties.isReflectionServiceEnabled()) { builder.addService(ProtoReflectionService.newInstance()); } for (final GrpcServiceDefinition service : this.serviceList) { final String serviceName = service.getDefinition().getServiceDescriptor().getName(); log.info("Registered gRPC service: " + serviceName + ", bean: " + service.getBeanName() + ", class: " + service.getBeanClazz().getName()); builder.addService(service.getDefinition()); this.healthStatusManager.setStatus(serviceName, HealthCheckResponse.ServingStatus.SERVING); } }
protected Server createServer(GRpcTestNode node) { GrpcServerBuilderConfigurer configurer = builder -> builder.addService(new DiscoveryService(node.consumer)); GrpcServerRunner runner = new GrpcServerRunner(configurer, ServerBuilder.forPort(node.port)); runner.setApplicationContext(context); try { runner.run(); return runner.getServer(); } catch (Exception e) { return null; } } }
@Override public Server createServer() { final T builder = newServerBuilder(); configure(builder); return builder.build(); }
void registerGrpcComponent(final Object wsComponent) { if (wsComponent instanceof BindableService) { final BindableService grpcService = (BindableService) wsComponent; getGrpcExternalServerBuilder().addService(grpcService); if (isRestServerEnabled()) { registerRestService(grpcService); } } else if (wsComponent instanceof ServerInterceptor) { final ServerInterceptor grpcInterceptor = (ServerInterceptor) wsComponent; getGrpcExternalServerBuilder().intercept(grpcInterceptor); if (isRestServerEnabled()) { registerRestInterceptor(grpcInterceptor); } } else if (wsComponent instanceof ServerServiceDefinition) { getGrpcExternalServerBuilder().addService((ServerServiceDefinition) wsComponent); } else if (wsComponent instanceof ServerTransportFilter) { getGrpcExternalServerBuilder().addTransportFilter((ServerTransportFilter) wsComponent); } else if (wsComponent instanceof HandlerRegistry) { getGrpcExternalServerBuilder().fallbackHandlerRegistry((HandlerRegistry) wsComponent); } else if (wsComponent instanceof DecompressorRegistry) { getGrpcExternalServerBuilder().decompressorRegistry((DecompressorRegistry) wsComponent); } else if (wsComponent instanceof CompressorRegistry) { getGrpcExternalServerBuilder().compressorRegistry((CompressorRegistry) wsComponent); } else { throw new UnsupportedOperationException("Error exists in AppBuilder framework. " + "Encountered web server of type " + wsComponent.getClass().getName() + " for auto-binding, " + "but do not know how to bind this type within Grpc."); } }
@Override public void configure(ServerBuilder<?> serverBuilder){ serverBuilder.executor(command -> { System.out.println(CUSTOM_EXECUTOR_MESSAGE); command.run(); } ); } };
protected AbstractGrpcServer() { name = getClass().getName(); ServerBuilder<?> serverBuilder = InProcessServerBuilder.forName(name).directExecutor(); this.server = serverBuilder.addService(getService()).build(); }
/** * Create gRPC server on the specified port. * * @param controllerService The controller service implementation. * @param serverConfig The RPC Server config. * @param requestTracker Cache to track and access to client request identifiers. */ public GRPCServer(ControllerService controllerService, GRPCServerConfig serverConfig, RequestTracker requestTracker) { this.objectId = "gRPCServer"; this.config = serverConfig; AuthHelper authHelper = new AuthHelper(serverConfig.isAuthorizationEnabled(), serverConfig.getTokenSigningKey()); ServerBuilder<?> builder = ServerBuilder .forPort(serverConfig.getPort()) .addService(ServerInterceptors.intercept(new ControllerServiceImpl(controllerService, authHelper, requestTracker, serverConfig.isReplyWithStackTraceOnError()), RPCTracingHelpers.getServerInterceptor(requestTracker))); if (serverConfig.isAuthorizationEnabled()) { this.pravegaAuthManager = new PravegaAuthManager(serverConfig); this.pravegaAuthManager.registerInterceptors(builder); } else { this.pravegaAuthManager = null; } if (serverConfig.isTlsEnabled() && !Strings.isNullOrEmpty(serverConfig.getTlsCertFile())) { builder = builder.useTransportSecurity(new File(serverConfig.getTlsCertFile()), new File(serverConfig.getTlsKeyFile())); } this.server = builder.build(); }
public GrpcStartable(GrpcServerConfig serverConfig, BindableService... services) { ServerBuilder<?> serverBuilder; if (serverConfig.isSslEnable()){ serverBuilder = NettyServerBuilder.forAddress( new InetSocketAddress(serverConfig.getHost(), serverConfig.getPort())); try { ((NettyServerBuilder) serverBuilder).sslContext(getSslContextBuilder(serverConfig).build()); } catch (SSLException e) { throw new IllegalStateException("Unable to setup grpc to use SSL.", e); } } else { serverBuilder = ServerBuilder.forPort(serverConfig.getPort()); } Arrays.stream(services).forEach(serverBuilder::addService); server = serverBuilder.build(); }
LMDBServicer objectStoreServicer = new LMDBServicer(new LMDBStoreManager(dataDir)); Server server = ServerBuilder.forPort(serverPort) .addService(ServerInterceptors.intercept(processorService, new ObjectStoreServicer.KvStoreInterceptor())) .addService(ServerInterceptors.intercept(objectStoreServicer, new LMDBServicer.KvStoreInterceptor())) .maxInboundMessageSize(32 * 1024 * 1024).build();
static void startServer(String endPoint) throws IOException { ServerBuilder<?> builder = NettyServerBuilder.forAddress(parseEndpoint(endPoint)); Executor executor = MoreExecutors.directExecutor(); builder.executor(executor); final Server server = builder.addService(new FakeOcAgentTraceServiceGrpcImpl()).build(); server.start(); logger.info("Server started at " + endPoint); Runtime.getRuntime() .addShutdownHook( new Thread() { @Override public void run() { server.shutdown(); } }); try { server.awaitTermination(); } catch (InterruptedException e) { logger.warning("Thread interrupted: " + e.getMessage()); Thread.currentThread().interrupt(); } }
public GRpcServerBuilderConfigure(List<BindServiceAdapter> bindServiceAdapterList, int port) { this.bindServiceAdapterList = bindServiceAdapterList; this.port = port; this.serverBuilder = ServerBuilder.forPort(port); }
/** * Override this method to override how a {@link BindableService} is added to the {@link ServerBuilder}. */ protected void registerService(ServerBuilder builder, BindableService service) { builder.addService(service); }