Java Code Examples for io.grpc.protobuf.services.ProtoReflectionService

The following examples show how to use io.grpc.protobuf.services.ProtoReflectionService. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
private void start() throws IOException {
	/* The port on which the server should run */
	int port = 50051;
	server = ServerBuilder.forPort(port)
			.addService(ProtoReflectionService.newInstance())
			.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");
			ProtoApplication.this.stop();
			System.err.println("*** server shut down");
		}
	});
}
 
Example 2
Source Project: spring-graalvm-native   Source File: ProtoApplication.java    License: Apache License 2.0 6 votes vote down vote up
private void start() throws IOException {
	/* The port on which the server should run */
	int port = 50051;
	server = ServerBuilder.forPort(port)
			.addService(ProtoReflectionService.newInstance())
			.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");
			ProtoApplication.this.stop();
			System.err.println("*** server shut down");
		}
	});
}
 
Example 3
Source Project: startup-os   Source File: LocalServer.java    License: Apache License 2.0 6 votes vote down vote up
@Inject
LocalServer(
    @Named("Server log path") String logPath,
    AuthService authService,
    CodeReviewService codeReviewService) {
  if (logToFile.get()) {
    // TODO: Figure out how to also direct Flogger to log file.
    try {
      PrintStream logStream = new PrintStream(logPath);
      System.setOut(logStream);
      System.setErr(logStream);
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
  }
  server =
      ServerBuilder.forPort(localServerPort.get())
          .addService(authService)
          .addService(codeReviewService)
          .addService(ProtoReflectionService.newInstance())
          .build();
}
 
Example 4
@Bean
@Lazy
InfoContributor grpcInfoContributor(final GrpcServerProperties properties,
        final Collection<BindableService> grpcServices, final HealthStatusManager healthStatusManager) {
    final Map<String, Object> details = new LinkedHashMap<>();
    details.put("port", properties.getPort());

    if (properties.isReflectionServiceEnabled()) {
        // Only expose services via web-info if we do the same via grpc.
        final Map<String, List<String>> services = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
        details.put("services", services);
        final List<BindableService> mutableGrpcServiceList = new ArrayList<>(grpcServices);
        mutableGrpcServiceList.add(ProtoReflectionService.newInstance());
        if (properties.isHealthServiceEnabled()) {
            mutableGrpcServiceList.add(healthStatusManager.getHealthService());
        }
        for (final BindableService grpcService : mutableGrpcServiceList) {
            final ServiceDescriptor serviceDescriptor = grpcService.bindService().getServiceDescriptor();

            final List<String> methods = collectMethodNamesForService(serviceDescriptor);
            services.put(serviceDescriptor.getName(), methods);
        }
    }

    return new SimpleInfoContributor("grpc.server", details);
}
 
Example 5
/**
 * 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);
    }
}
 
Example 6
Source Project: conductor   Source File: GRPCServerProvider.java    License: Apache License 2.0 6 votes vote down vote up
private GRPCServer buildGRPCServer(GRPCServerConfiguration grpcServerConfiguration) {
    ImmutableList.Builder<BindableService> services = ImmutableList.<BindableService>builder().add(
            healthServiceImpl,
            eventServiceImpl,
            metadataServiceImpl,
            taskServiceImpl,
            workflowServiceImpl);

    if (grpcServerConfiguration.isReflectionEnabled()) {
        services.add(ProtoReflectionService.newInstance());
    }

    return new GRPCServer(
            grpcServerConfiguration.getPort(),
            services.build().toArray(new BindableService[]{})
    );
}
 
Example 7
@Bean
@Lazy
InfoContributor grpcInfoContributor(final GrpcServerProperties properties,
        final Collection<BindableService> grpcServices, final HealthStatusManager healthStatusManager) {
    final Map<String, Object> details = new LinkedHashMap<>();
    details.put("port", properties.getPort());

    if (properties.isReflectionServiceEnabled()) {
        // Only expose services via web-info if we do the same via grpc.
        final Map<String, List<String>> services = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
        details.put("services", services);
        final List<BindableService> mutableGrpcServiceList = new ArrayList<>(grpcServices);
        mutableGrpcServiceList.add(ProtoReflectionService.newInstance());
        if (properties.isHealthServiceEnabled()) {
            mutableGrpcServiceList.add(healthStatusManager.getHealthService());
        }
        for (final BindableService grpcService : mutableGrpcServiceList) {
            final ServiceDescriptor serviceDescriptor = grpcService.bindService().getServiceDescriptor();

            final List<String> methods = collectMethodNamesForService(serviceDescriptor);
            services.put(serviceDescriptor.getName(), methods);
        }
    }

    return new SimpleInfoContributor("grpc.server", details);
}
 
Example 8
/**
 * 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);
    }
}
 
Example 9
Source Project: metastore   Source File: MetaStoreServer.java    License: Apache License 2.0 5 votes vote down vote up
/** Create a RouteGuide server using serverBuilder as a base and features as data. */
private MetaStoreServer(String configPath, ServerBuilder<?> serverBuilder, int port)
    throws IOException {
  MetaStore metaStore = new MetaStore(configPath);
  this.port = port;

  server =
      serverBuilder
          .addService(new MetaStoreService(metaStore))
          .addService(new RegistryService(metaStore))
          .addService(ProtoReflectionService.newInstance())
          .build();
}
 
Example 10
Source Project: grpc-swagger   Source File: HelloServiceServer.java    License: MIT License 5 votes vote down vote up
public static void main(String[] args) throws Exception {
    logger.info("Starting server on port " + DEMO_SERVER_PORT);
    Server server = ServerBuilder.forPort(DEMO_SERVER_PORT)
            .addService(ProtoReflectionService.newInstance())
            .addService(new HelloServiceImpl())
            .build()
            .start();
    server.awaitTermination();
}
 
Example 11
Source Project: grpc-swagger   Source File: HelloServiceServer.java    License: MIT License 5 votes vote down vote up
public static void main(String[] args) throws Exception {
    logger.info("Starting server on port " + DEMO_SERVER_PORT);
    Server server = ServerBuilder.forPort(DEMO_SERVER_PORT)
            .addService(ProtoReflectionService.newInstance())
            .addService(new HelloServiceImpl())
            .build()
            .start();
    server.awaitTermination();
}
 
Example 12
Source Project: grpc-spring-boot-starter   Source File: GRpcServerRunner.java    License: Apache License 2.0 5 votes vote down vote up
@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());
    }

    configurator.accept(serverBuilder);
    server = serverBuilder.build().start();
    applicationContext.publishEvent(new GRpcServerInitializedEvent(applicationContext,server));

    log.info("gRPC Server started, listening on port {}.", server.getPort());
    startDaemonAwaitThread();

}
 
Example 13
Source Project: grpc-by-example-java   Source File: ArmeriaGrpcServer.java    License: Apache License 2.0 5 votes vote down vote up
static Server newServer(int httpPort, int httpsPort) throws Exception {
    final HelloRequest exampleRequest = HelloRequest.newBuilder().setName("Armeria").build();
    final HttpServiceWithRoutes grpcService =
            GrpcService.builder()
                       .addService(new HelloServiceImpl())
                       // See https://github.com/grpc/grpc-java/blob/master/documentation/server-reflection-tutorial.md
                       .addService(ProtoReflectionService.newInstance())
                       .supportedSerializationFormats(GrpcSerializationFormats.values())
                       .enableUnframedRequests(true)
                       // You can set useBlockingTaskExecutor(true) in order to execute all gRPC
                       // methods in the blockingTaskExecutor thread pool.
                       // .useBlockingTaskExecutor(true)
                       .build();

    return Server.builder()
                 .http(httpPort)
                 .https(httpsPort)
                 .tlsSelfSigned()
                 .service(grpcService)
                 // You can access the documentation service at http://127.0.0.1:8080/docs.
                 // See https://line.github.io/armeria/server-docservice.html for more information.
                 .serviceUnder("/docs", DocService.builder()
                                                  .exampleRequestForMethod(HelloServiceGrpc.SERVICE_NAME,
                                                                           "Hello", exampleRequest)
                                                  .exampleRequestForMethod(HelloServiceGrpc.SERVICE_NAME,
                                                                           "LazyHello", exampleRequest)
                                                  .exampleRequestForMethod(HelloServiceGrpc.SERVICE_NAME,
                                                                           "BlockingHello", exampleRequest)
                                                  .exclude(DocServiceFilter.ofServiceName(
                                                          ServerReflectionGrpc.SERVICE_NAME))
                                                  .build())
                 .build();
}
 
Example 14
Source Project: armeria   Source File: Main.java    License: Apache License 2.0 5 votes vote down vote up
static Server newServer(int httpPort, int httpsPort) throws Exception {
    final HelloRequest exampleRequest = HelloRequest.newBuilder().setName("Armeria").build();
    final HttpServiceWithRoutes grpcService =
            GrpcService.builder()
                       .addService(new HelloServiceImpl())
                       // See https://github.com/grpc/grpc-java/blob/master/documentation/server-reflection-tutorial.md
                       .addService(ProtoReflectionService.newInstance())
                       .supportedSerializationFormats(GrpcSerializationFormats.values())
                       .enableUnframedRequests(true)
                       // You can set useBlockingTaskExecutor(true) in order to execute all gRPC
                       // methods in the blockingTaskExecutor thread pool.
                       // .useBlockingTaskExecutor(true)
                       .build();
    return Server.builder()
                 .http(httpPort)
                 .https(httpsPort)
                 .tlsSelfSigned()
                 .service(grpcService)
                 // You can access the documentation service at http://127.0.0.1:8080/docs.
                 // See https://armeria.dev/docs/server-docservice for more information.
                 .serviceUnder("/docs",
                         DocService.builder()
                                   .exampleRequestForMethod(
                                           HelloServiceGrpc.SERVICE_NAME,
                                           "Hello", exampleRequest)
                                   .exampleRequestForMethod(
                                           HelloServiceGrpc.SERVICE_NAME,
                                           "LazyHello", exampleRequest)
                                   .exampleRequestForMethod(
                                           HelloServiceGrpc.SERVICE_NAME,
                                           "BlockingHello", exampleRequest)
                                   .exclude(DocServiceFilter.ofServiceName(
                                           ServerReflectionGrpc.SERVICE_NAME))
                                   .build())
                 .build();
}
 
Example 15
Source Project: armeria   Source File: Main.java    License: Apache License 2.0 5 votes vote down vote up
static Server newServer(int httpPort, int httpsPort) throws Exception {
    final HelloRequest exampleRequest = HelloRequest.newBuilder().setName("Armeria").build();
    final HttpServiceWithRoutes grpcService =
            GrpcService.builder()
                       .addService(new HelloServiceImpl())
                       // See https://github.com/grpc/grpc-java/blob/master/documentation/server-reflection-tutorial.md
                       .addService(ProtoReflectionService.newInstance())
                       .supportedSerializationFormats(GrpcSerializationFormats.values())
                       .enableUnframedRequests(true)
                       // You can set useBlockingTaskExecutor(true) in order to execute all gRPC
                       // methods in the blockingTaskExecutor thread pool.
                       // .useBlockingTaskExecutor(true)
                       .build();
    return Server.builder()
                 .http(httpPort)
                 .https(httpsPort)
                 .tlsSelfSigned()
                 .service(grpcService)
                 // You can access the documentation service at http://127.0.0.1:8080/docs.
                 // See https://armeria.dev/docs/server-docservice for more information.
                 .serviceUnder("/docs",
                         DocService.builder()
                                   .exampleRequestForMethod(HelloServiceGrpc.SERVICE_NAME,
                                              "Hello", exampleRequest)
                                   .exampleRequestForMethod(HelloServiceGrpc.SERVICE_NAME,
                                              "LazyHello", exampleRequest)
                                   .exampleRequestForMethod(HelloServiceGrpc.SERVICE_NAME,
                                              "BlockingHello", exampleRequest)
                                   .exclude(DocServiceFilter.ofServiceName(
                                                ServerReflectionGrpc.SERVICE_NAME))
                                   .build())
                 .build();
}
 
Example 16
Source Project: armeria   Source File: GrpcServiceBuilder.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Adds a gRPC {@link BindableService} to this {@link GrpcServiceBuilder}. Most gRPC service
 * implementations are {@link BindableService}s.
 */
public GrpcServiceBuilder addService(BindableService bindableService) {
    if (bindableService instanceof ProtoReflectionService) {
        checkState(protoReflectionServiceInterceptor == null,
                   "Attempting to add a ProtoReflectionService but one is already present. " +
                   "ProtoReflectionService must only be added once.");
        protoReflectionServiceInterceptor = new ProtoReflectionServiceInterceptor();
        return addService(ServerInterceptors.intercept(bindableService, protoReflectionServiceInterceptor));
    }

    return addService(bindableService.bindService());
}
 
Example 17
Source Project: geowave   Source File: GeoWaveGrpcServer.java    License: Apache License 2.0 5 votes vote down vote up
/** Start serving requests. */
public void start(final int port) throws IOException {
  final ServerBuilder<?> builder = NettyServerBuilder.forPort(port);
  builder.addService(ProtoReflectionService.newInstance());
  try {
    final Iterator<GeoWaveGrpcServiceSpi> grpcServices = serviceLoader.iterator();
    while (grpcServices.hasNext()) {
      final GeoWaveGrpcServiceSpi s = grpcServices.next();
      builder.addService(s.getBindableService());
    }
  } catch (final ServiceConfigurationError e) {
    LOGGER.error("Exception encountered initializing services for gRPC server", e);
  }

  server = builder.build();
  server.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");
      GeoWaveGrpcServer.this.stop();
      System.err.println("*** server shut down");
    }
  });
}
 
Example 18
Source Project: grpc-java   Source File: XdsTestServer.java    License: Apache License 2.0 5 votes vote down vote up
private void start() throws Exception {
  health = new HealthStatusManager();
  server =
      NettyServerBuilder.forPort(port)
          .addService(new TestServiceImpl(serverId))
          .addService(new XdsUpdateHealthServiceImpl(health))
          .addService(health.getHealthService())
          .addService(ProtoReflectionService.newInstance())
          .build()
          .start();
  health.setStatus("", ServingStatus.SERVING);
}
 
Example 19
Source Project: liiklus   Source File: GRPCConfiguration.java    License: MIT License 4 votes vote down vote up
@Override
public void initialize(GenericApplicationContext applicationContext) {
    var environment = applicationContext.getEnvironment();

    if (!environment.acceptsProfiles(Profiles.of("gateway"))) {
        return;
    }

    var serverProperties = PropertiesUtil.bind(environment, new GRpcServerProperties());

    if (!serverProperties.isEnabled()) {
        return;
    }

    applicationContext.registerBean(GRPCLiiklusService.class);

    applicationContext.registerBean(
            Server.class,
            () -> {
                var serverBuilder = NettyServerBuilder
                        .forPort(serverProperties.getPort())
                        .permitKeepAliveTime(150, TimeUnit.SECONDS)
                        .permitKeepAliveWithoutCalls(true)
                        .directExecutor()
                        .intercept(new ServerInterceptor() {
                            @Override
                            public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
                                call.setCompression("gzip");
                                return next.startCall(call, headers);
                            }
                        })
                        .addService(ProtoReflectionService.newInstance());

                for (var bindableService : applicationContext.getBeansOfType(BindableService.class).values()) {
                    serverBuilder.addService(bindableService);
                }

                for (var transportConfigurer : applicationContext.getBeansOfType(GRPCLiiklusTransportConfigurer.class).values()) {
                    transportConfigurer.apply(serverBuilder);
                }

                return serverBuilder.build();
            },
            it -> {
                it.setInitMethodName("start");
                it.setDestroyMethodName("shutdownNow");
            }
    );
}
 
Example 20
@PostConstruct
public void start() {
    if (started.getAndSet(true)) {
        return;
    }
    this.port = config.getGrpcPort();
    this.server = configure(ServerBuilder.forPort(port).executor(grpcCallbackExecutor))
            .addService(ServerInterceptors.intercept(
                    healthService,
                    createInterceptors(HealthGrpc.getServiceDescriptor())
            ))
            .addService(ServerInterceptors.intercept(
                    schedulerService,
                    createInterceptors(SchedulerServiceGrpc.getServiceDescriptor())
            ))
            .addService(ServerInterceptors.intercept(
                    jobManagementService,
                    createInterceptors(JobManagementServiceGrpc.getServiceDescriptor())
            ))
            .addService(ServerInterceptors.intercept(
                    autoScalingService,
                    createInterceptors(AutoScalingServiceGrpc.getServiceDescriptor())
            ))
            .addService(ServerInterceptors.intercept(
                    loadBalancerService,
                    createInterceptors(LoadBalancerServiceGrpc.getServiceDescriptor())))
            .addService(
                    ServerInterceptors.intercept(
                            reactorServerFactory.apply(
                                    MachineServiceGrpc.getServiceDescriptor(),
                                    reactorMachineGrpcService
                            ),
                            createInterceptors(MachineServiceGrpc.getServiceDescriptor())
                    )
            )
            .addService(ProtoReflectionService.newInstance())
            .build();

    LOG.info("Starting gRPC server on port {}.", port);
    try {
        this.server.start();
        this.port = server.getPort();
    } catch (final IOException e) {
        throw new RuntimeException(e);
    }
    LOG.info("Started gRPC server on port {}.", port);
}
 
Example 21
@PostConstruct
public void start() {
    if (started.getAndSet(true)) {
        return;
    }
    this.port = config.getPort();
    this.server = configure(ServerBuilder.forPort(port).executor(grpcCallbackExecutor))
            .addService(ServerInterceptors.intercept(
                    healthService,
                    createInterceptors(HealthGrpc.getServiceDescriptor())
            ))
            .addService(ServerInterceptors.intercept(
                    jobManagementService,
                    createInterceptors(JobManagementServiceGrpc.getServiceDescriptor())
            ))
            .addService(ServerInterceptors.intercept(
                    evictionService,
                    createInterceptors(EvictionServiceGrpc.getServiceDescriptor())
            ))
            .addService(ServerInterceptors.intercept(
                    agentManagementService,
                    createInterceptors(AgentManagementServiceGrpc.getServiceDescriptor())
            ))
            .addService(ServerInterceptors.intercept(
                    appAutoScalingService,
                    createInterceptors(AutoScalingServiceGrpc.getServiceDescriptor())
            ))
            .addService(ServerInterceptors.intercept(
                    schedulerService,
                    createInterceptors(SchedulerServiceGrpc.getServiceDescriptor())
            ))
            .addService(ServerInterceptors.intercept(
                    reactorServerFactory.apply(
                            MachineServiceGrpc.getServiceDescriptor(),
                            reactorMachineGrpcService
                    ),
                    createInterceptors(MachineServiceGrpc.getServiceDescriptor())
            ))
            .addService(ServerInterceptors.intercept(
                    loadBalancerService,
                    createInterceptors(LoadBalancerServiceGrpc.getServiceDescriptor())
            ))
            .addService(ProtoReflectionService.newInstance())
            .build();

    LOG.info("Starting gRPC server on port {}.", port);
    try {
        this.server.start();
        this.port = server.getPort();
    } catch (final IOException e) {
        throw new RuntimeException(e);
    }
    LOG.info("Started gRPC server on port {}.", port);
}
 
Example 22
Source Project: armeria   Source File: GrpcServiceServerTest.java    License: Apache License 2.0 4 votes vote down vote up
@Override
protected void configure(ServerBuilder sb) throws Exception {
    sb.workerGroup(EventLoopGroups.newEventLoopGroup(1), true);
    sb.maxRequestLength(0);

    sb.service(
            GrpcService.builder()
                       .setMaxInboundMessageSizeBytes(MAX_MESSAGE_SIZE)
                       .addService(ServerInterceptors.intercept(
                               new UnitTestServiceImpl(),
                               REPLACE_EXCEPTION, ADD_TO_CONTEXT))
                       .enableUnframedRequests(true)
                       .supportedSerializationFormats(GrpcSerializationFormats.values())
                       .build(),
            service -> service
                    .decorate(LoggingService.newDecorator())
                    .decorate((delegate, ctx, req) -> {
                        ctx.log().whenComplete().thenAccept(requestLogQueue::add);
                        return delegate.serve(ctx, req);
                    }));

    // For simplicity, mount onto subpaths with custom options
    sb.serviceUnder(
            "/json-preserving/",
            GrpcService.builder()
                       .addService(new UnitTestServiceImpl())
                       .supportedSerializationFormats(GrpcSerializationFormats.values())
                       .jsonMarshallerFactory(serviceDescriptor -> {
                           return GrpcJsonMarshaller.builder()
                                                    .jsonMarshallerCustomizer(marshaller -> {
                                                        marshaller.preservingProtoFieldNames(true);
                                                    })
                                                    .build(serviceDescriptor);
                       })
                       .build());
    sb.serviceUnder(
            "/no-client-timeout/",
            GrpcService.builder()
                       .addService(new UnitTestServiceImpl())
                       .useClientTimeoutHeader(false)
                       .build());

    sb.service(
            GrpcService.builder()
                       .addService(ProtoReflectionService.newInstance())
                       .build(),
            service -> service.decorate(LoggingService.newDecorator()));
}