- add DI support to gRPC services

Author: jknack

modules/jooby-grpc/src/main/java/io/jooby/grpc/GrpcModule.java

@@ -5,25 +5,21 @@
  */
 package io.jooby.grpc;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 import org.slf4j.bridge.SLF4JBridgeHandler;
 
 import edu.umd.cs.findbugs.annotations.NonNull;
 import io.grpc.BindableService;
 import io.grpc.MethodDescriptor;
-import io.grpc.Server;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
 import io.jooby.*;
 import io.jooby.internal.grpc.DefaultGrpcProcessor;
 
 public class GrpcModule implements Extension {
-  private final List<BindableService> services;
-  private final Map<String, MethodDescriptor<?, ?>> registry = new HashMap<>();
-  private Server grpcServer;
+  private final List<BindableService> services = new ArrayList<>();
+  private final List<Class<? extends BindableService>> serviceClasses = new ArrayList<>();
 
   static {
     // Optionally remove existing handlers attached to the j.u.l root logger
@@ -33,52 +29,78 @@ public class GrpcModule implements Extension {
   }
 
   public GrpcModule(BindableService... services) {
-    this.services = List.of(services);
+    this.services.addAll(Arrays.asList(services));
+  }
+
+  @SafeVarargs
+  public GrpcModule(Class<? extends BindableService>... serviceClasses) {
+    bind(serviceClasses);
+  }
+
+  @SafeVarargs
+  public final GrpcModule bind(Class<? extends BindableService>... serviceClasses) {
+    this.serviceClasses.addAll(List.of(serviceClasses));
+    return this;
   }
 
   @Override
   public void install(@NonNull Jooby app) throws Exception {
     var serverName = app.getName();
     var builder = InProcessServerBuilder.forName(serverName);
+    final Map<String, MethodDescriptor<?, ?>> registry = new HashMap<>();
 
     // 1. Register user-provided services
     for (var service : services) {
-      builder.addService(service);
-      for (var method : service.bindService().getMethods()) {
-        var descriptor = method.getMethodDescriptor();
-        String methodFullName = descriptor.getFullMethodName();
-        registry.put(methodFullName, descriptor);
-        String routePath = "/" + methodFullName;
-
-        //
-        app.post(
-            routePath,
-            ctx -> {
-              throw new IllegalStateException(
-                  "gRPC request reached the standard HTTP router for path: "
-                      + routePath
-                      + ". "
-                      + "This means the native gRPC server interceptor was bypassed. "
-                      + "Ensure you are running Jetty, Netty, or Undertow with HTTP/2 enabled, "
-                      + "and that the GrpcProcessor SPI is correctly loaded.");
-            });
-      }
+      bindService(app, builder, registry, service);
     }
 
-    this.grpcServer = builder.build().start();
-
-    // KEEP .directExecutor() here!
-    // This ensures that when the background gRPC worker finishes, it instantly pushes
-    // the response back to Undertow/Netty without wasting time on another thread hop.
-    var channel = InProcessChannelBuilder.forName(serverName).directExecutor().build();
     var services = app.getServices();
-    var bridge = new DefaultGrpcProcessor(channel, registry);
+    var processor = new DefaultGrpcProcessor(registry);
+    services.put(GrpcProcessor.class, processor);
+
+    // Lazy init service from DI.
+    app.onStarting(
+        () -> {
+          for (Class<? extends BindableService> serviceClass : serviceClasses) {
+            var service = app.require(serviceClass);
+            bindService(app, builder, registry, service);
+          }
+          var grpcServer = builder.build().start();
 
-    // Register it in the Service Registry so the server layer can find it
-    services.put(DefaultGrpcProcessor.class, bridge);
-    services.put(GrpcProcessor.class, bridge);
+          // KEEP .directExecutor() here!
+          // This ensures that when the background gRPC worker finishes, it instantly pushes
+          // the response back to Undertow/Netty without wasting time on another thread hop.
+          var channel = InProcessChannelBuilder.forName(serverName).directExecutor().build();
+          processor.setChannel(channel);
 
-    app.onStop(channel::shutdownNow);
-    app.onStop(grpcServer::shutdownNow);
+          app.onStop(channel::shutdownNow);
+          app.onStop(grpcServer::shutdownNow);
+        });
+  }
+
+  private static void bindService(
+      Jooby app,
+      InProcessServerBuilder server,
+      Map<String, MethodDescriptor<?, ?>> registry,
+      BindableService service) {
+    server.addService(service);
+    for (var method : service.bindService().getMethods()) {
+      var descriptor = method.getMethodDescriptor();
+      String methodFullName = descriptor.getFullMethodName();
+      registry.put(methodFullName, descriptor);
+      String routePath = "/" + methodFullName;
+      //
+      app.post(
+          routePath,
+          ctx -> {
+            throw new IllegalStateException(
+                "gRPC request reached the standard HTTP router for path: "
+                    + routePath
+                    + ". "
+                    + "This means the native gRPC server interceptor was bypassed. "
+                    + "Ensure you are running Jetty, Netty, or Undertow with HTTP/2 enabled, "
+                    + "and that the GrpcProcessor SPI is correctly loaded.");
+          });
+    }
   }
 }

modules/jooby-grpc/src/main/java/io/jooby/internal/grpc/DefaultGrpcProcessor.java

@@ -47,15 +47,17 @@ public byte[] parse(InputStream stream) {
   }
 
   private final Logger log = LoggerFactory.getLogger(getClass());
-  private final ManagedChannel channel;
+  private ManagedChannel channel;
   private final Map<String, MethodDescriptor<?, ?>> registry;
 
-  public DefaultGrpcProcessor(
-      ManagedChannel channel, Map<String, MethodDescriptor<?, ?>> registry) {
-    this.channel = channel;
+  public DefaultGrpcProcessor(Map<String, MethodDescriptor<?, ?>> registry) {
     this.registry = registry;
   }
 
+  public void setChannel(ManagedChannel channel) {
+    this.channel = channel;
+  }
+
   @Override
   public boolean isGrpcMethod(String path) {
     // gRPC paths typically come in as "/package.Service/Method"

modules/jooby-grpc/src/test/java/io/jooby/grpc/DefaultGrpcProcessorTest.java

@@ -54,7 +54,8 @@ public void setUp() {
     // The interceptor wraps the channel, but eventually delegates to the real one
     when(channel.newCall(any(MethodDescriptor.class), any(CallOptions.class))).thenReturn(call);
 
-    bridge = new DefaultGrpcProcessor(channel, registry);
+    bridge = new DefaultGrpcProcessor(registry);
+    bridge.setChannel(channel);
   }
 
   @Test

tests/src/test/java/io/jooby/i3875/EchoGreeterService.java

@@ -8,9 +8,17 @@
 import io.grpc.stub.StreamObserver;
 
 public class EchoGreeterService extends GreeterGrpc.GreeterImplBase {
+
+  private final EchoService echoService;
+
+  @jakarta.inject.Inject
+  public EchoGreeterService(EchoService echoService) {
+    this.echoService = echoService;
+  }
+
   @Override
   public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
-    HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+    HelloReply reply = HelloReply.newBuilder().setMessage(echoService.echo(req.getName())).build();
     responseObserver.onNext(reply);
     responseObserver.onCompleted();
   }

tests/src/test/java/io/jooby/i3875/EchoService.java

@@ -0,0 +1,13 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.i3875;
+
+public class EchoService {
+
+  public String echo(String value) {
+    return "Hello " + value;
+  }
+}

tests/src/test/java/io/jooby/i3875/GrpcTest.java

@@ -23,17 +23,18 @@
 import io.jooby.Jooby;
 import io.jooby.ServerOptions;
 import io.jooby.grpc.GrpcModule;
+import io.jooby.guice.GuiceModule;
 import io.jooby.junit.ServerTest;
 import io.jooby.junit.ServerTestRunner;
 
 public class GrpcTest {
 
   private void setupApp(Jooby app) {
+    app.install(new GuiceModule());
+
     app.install(
-        new GrpcModule(
-            new EchoGreeterService(),
-            new EchoChatService(),
-            ProtoReflectionServiceV1.newInstance()));
+        new GrpcModule(new EchoChatService(), ProtoReflectionServiceV1.newInstance())
+            .bind(EchoGreeterService.class));
   }
 
   @ServerTest
@@ -50,9 +51,10 @@ void shouldHandleUnaryRequests(ServerTestRunner runner) {
 
               try {
                 var stub = GreeterGrpc.newBlockingStub(channel);
-                var response = stub.sayHello(HelloRequest.newBuilder().setName("Edgar").build());
+                var response =
+                    stub.sayHello(HelloRequest.newBuilder().setName("Pablo Marmol").build());
 
-                assertThat(response.getMessage()).isEqualTo("Hello Edgar");
+                assertThat(response.getMessage()).isEqualTo("Hello Pablo Marmol");
               } finally {
                 channel.shutdown();
               }
@@ -80,7 +82,9 @@ void shouldHandleDeadlineExceeded(ServerTestRunner runner) {
                 var exception =
                     org.junit.jupiter.api.Assertions.assertThrows(
                         StatusRuntimeException.class,
-                        () -> stub.sayHello(HelloRequest.newBuilder().setName("Edgar").build()));
+                        () ->
+                            stub.sayHello(
+                                HelloRequest.newBuilder().setName("Pablo Marmol").build()));
 
                 // Assert that the bridge correctly caught the timeout and returned Status 4
                 assertThat(exception.getStatus().getCode())
@@ -352,7 +356,7 @@ void shouldHandleMethodNotFound(ServerTestRunner runner) {
                                 channel,
                                 unknownMethod,
                                 io.grpc.CallOptions.DEFAULT,
-                                HelloRequest.newBuilder().setName("Edgar").build()));
+                                HelloRequest.newBuilder().setName("Pablo Marmol").build()));
 
                 // 3. Assert that Jooby's HTTP 404 is correctly translated by the gRPC client into
                 // UNIMPLEMENTED