[grpc-protoc] Add an option to generate default service methods (#3110)

### Motivation When evolving a service definition that has multiple implementations it is ideal not to break these implementations. Therefore it would be nice if the protoc generator was able to generate default implementations on the service interface to ensure implementations always conform. ### Modifications Add an option, `defaultServiceMethods` to the grpc-protoc stub compiler to generate these default implementations. The result is that service interfaces will provide a default, throwing `UNIMPLEMENTED` exception, implementation of all service RPC interfaces that they implement.
apple · Dec 7, 2024 · 1bcf8ea · 1bcf8ea
1 parent 3a45a23
commit 1bcf8ea
Show file tree

Hide file tree

Showing 14 changed files with 494 additions and 226 deletions.
diff --git a/servicetalk-examples/grpc/protoc-options/build.gradle b/servicetalk-examples/grpc/protoc-options/build.gradle
@@ -76,6 +76,9 @@ protobuf {
           option 'typeNameSuffix=St'
           // Option to tell the compiler to exclude all Deprecated fields, types, and methods from the output
           option 'skipDeprecated=true'
+          // Option to generate default throwing service definitions on the service interfaces. This will allow
+          // teams to evolve their codebases and not break dependent libraries.
+          option 'defaultServiceMethods=true'
         }
       }
     }

diff --git a/...src/main/java/io/servicetalk/examples/grpc/protocoptions/BlockingProtocOptionsServer.java b/...src/main/java/io/servicetalk/examples/grpc/protocoptions/BlockingProtocOptionsServer.java
@@ -15,16 +15,22 @@
  */
 package io.servicetalk.examples.grpc.protocoptions;
 
+import io.servicetalk.grpc.api.GrpcServiceContext;
 import io.servicetalk.grpc.netty.GrpcServers;
 
 import io.grpc.examples.helloworld.GreeterSt.BlockingGreeterService;
 import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
 
 public final class BlockingProtocOptionsServer {
     public static void main(String[] args) throws Exception {
         GrpcServers.forPort(8080)
-                .listenAndAwait((BlockingGreeterService) (ctx, request) ->
-                        HelloReply.newBuilder().setMessage("Hello " + request.getName()).build())
+                .listenAndAwait(new BlockingGreeterService() {
+                    @Override
+                    public HelloReply sayHello(GrpcServiceContext ctx, HelloRequest request) {
+                        return HelloReply.newBuilder().setMessage("Hello " + request.getName()).build();
+                    }
+                })
                 .awaitShutdown();
     }
 }
diff --git a/servicetalk-grpc-netty/build.gradle b/servicetalk-grpc-netty/build.gradle
@@ -110,6 +110,8 @@ protobuf {
         grpc {}
         servicetalk_grpc {
           outputSubDir = "java"
+          // this will eventually become the default behavior
+          option "defaultServiceMethods=true"
         }
       }
     }

diff --git a/...-netty/src/test/java/io/servicetalk/grpc/netty/GrpcClientResolvesOnNewConnectionTest.java b/...-netty/src/test/java/io/servicetalk/grpc/netty/GrpcClientResolvesOnNewConnectionTest.java
@@ -19,7 +19,9 @@
 import io.servicetalk.client.api.ServiceDiscoverer;
 import io.servicetalk.client.api.ServiceDiscovererEvent;
 import io.servicetalk.concurrent.api.Publisher;
+import io.servicetalk.concurrent.api.Single;
 import io.servicetalk.grpc.api.GrpcServerContext;
+import io.servicetalk.grpc.api.GrpcServiceContext;
 import io.servicetalk.transport.api.HostAndPort;
 
 import io.grpc.examples.helloworld.Greeter.BlockingGreeterClient;
@@ -52,8 +54,13 @@ void forAddress() throws Exception {
         String greetingPrefix = "Hello ";
         String name = "foo";
         try (GrpcServerContext serverContext = GrpcServers.forAddress(localAddress(0))
-                .listenAndAwait((GreeterService) (ctx, request) ->
-                        succeeded(HelloReply.newBuilder().setMessage(greetingPrefix + request.getName()).build()));
+                .listenAndAwait(new GreeterService() {
+                    @Override
+                    public Single<HelloReply> sayHello(GrpcServiceContext ctx, HelloRequest request) {
+                        return succeeded(HelloReply.newBuilder()
+                                .setMessage(greetingPrefix + request.getName()).build());
+                    }
+                });
              // Use "localhost" to demonstrate that the address will be resolved.
              BlockingGreeterClient client = GrpcClients.forAddress("localhost",
                              serverHostAndPort(serverContext).port(), ON_NEW_CONNECTION)
@@ -69,8 +76,13 @@ void withCustomSd() throws Exception {
         String greetingPrefix = "Hello ";
         String name = "foo";
         try (GrpcServerContext serverContext = GrpcServers.forAddress(localAddress(0))
-                .listenAndAwait((GreeterService) (ctx, request) ->
-                        succeeded(HelloReply.newBuilder().setMessage(greetingPrefix + request.getName()).build()))) {
+                .listenAndAwait(new GreeterService() {
+                    @Override
+                    public Single<HelloReply> sayHello(GrpcServiceContext ctx, HelloRequest request) {
+                        return succeeded(HelloReply.newBuilder()
+                                .setMessage(greetingPrefix + request.getName()).build());
+                    }
+                })) {
             // Use "localhost" to demonstrate that the address will be resolved.
             HostAndPort hostAndPort = HostAndPort.of("localhost", serverHostAndPort(serverContext).port());
             @SuppressWarnings("unchecked")

diff --git a/servicetalk-grpc-netty/src/test/java/io/servicetalk/grpc/netty/GrpcOverH1Test.java b/servicetalk-grpc-netty/src/test/java/io/servicetalk/grpc/netty/GrpcOverH1Test.java
@@ -15,6 +15,8 @@
  */
 package io.servicetalk.grpc.netty;
 
+import io.servicetalk.concurrent.api.Single;
+import io.servicetalk.grpc.api.GrpcServiceContext;
 import io.servicetalk.http.api.HttpProtocolConfig;
 import io.servicetalk.test.resources.DefaultTestCerts;
 import io.servicetalk.transport.api.ClientSslConfigBuilder;
@@ -69,8 +71,13 @@ void tlsNegotiated(ProtocolTestMode testMode) throws Exception {
                         .sslConfig(new ServerSslConfigBuilder(DefaultTestCerts::loadServerPem,
                                 DefaultTestCerts::loadServerKey).build())
                         .protocols(testMode.serverConfigs))
-                .listenAndAwait((Greeter.GreeterService) (ctx, request) ->
-                        succeeded(HelloReply.newBuilder().setMessage(greetingPrefix + request.getName()).build()));
+                .listenAndAwait(new Greeter.GreeterService() {
+                    @Override
+                    public Single<HelloReply> sayHello(GrpcServiceContext ctx, HelloRequest request) {
+                        return succeeded(HelloReply.newBuilder()
+                                .setMessage(greetingPrefix + request.getName()).build());
+                    }
+                });
              BlockingGreeterClient client = forResolvedAddress(serverContext.listenAddress())
                      .initializeHttp(builder -> builder
                              .sslConfig(new ClientSslConfigBuilder(DefaultTestCerts::loadServerCAPem)

diff --git a/servicetalk-grpc-netty/src/test/java/io/servicetalk/grpc/netty/GrpcProxyTunnelTest.java b/servicetalk-grpc-netty/src/test/java/io/servicetalk/grpc/netty/GrpcProxyTunnelTest.java
@@ -19,6 +19,7 @@
 import io.servicetalk.context.api.ContextMap.Key;
 import io.servicetalk.grpc.api.DefaultGrpcClientMetadata;
 import io.servicetalk.grpc.api.GrpcClientMetadata;
+import io.servicetalk.grpc.api.GrpcServiceContext;
 import io.servicetalk.grpc.api.GrpcStatusCode;
 import io.servicetalk.grpc.api.GrpcStatusException;
 import io.servicetalk.http.api.HttpResponseStatus;
@@ -87,8 +88,12 @@ class GrpcProxyTunnelTest {
                 .initializeHttp(httpBuilder -> httpBuilder
                         .sslConfig(new ServerSslConfigBuilder(DefaultTestCerts::loadServerPem,
                                 DefaultTestCerts::loadServerKey).build()))
-                .listenAndAwait((Greeter.BlockingGreeterService) (ctx, request) ->
-                        HelloReply.newBuilder().setMessage(GREETING_PREFIX + request.getName()).build());
+                .listenAndAwait(new Greeter.BlockingGreeterService() {
+                    @Override
+                    public HelloReply sayHello(GrpcServiceContext ctx, HelloRequest request) {
+                        return HelloReply.newBuilder().setMessage(GREETING_PREFIX + request.getName()).build();
+                    }
+                });
         client = GrpcClients.forAddress(serverHostAndPort(serverContext))
                 .initializeHttp(httpBuilder -> httpBuilder.proxyConfig(forAddress(proxyAddress))
                         .sslConfig(new ClientSslConfigBuilder(DefaultTestCerts::loadServerCAPem)

diff --git a/...lk-grpc-netty/src/test/java/io/servicetalk/grpc/netty/GrpcServiceContextProtocolTest.java b/...lk-grpc-netty/src/test/java/io/servicetalk/grpc/netty/GrpcServiceContextProtocolTest.java
@@ -103,21 +103,21 @@ void tearDown() throws Exception {
         }
     }
 
-    @ParameterizedTest(name = "httpVersion={0) streamingService={0)")
+    @ParameterizedTest(name = "httpVersion={0} streamingService={1}")
     @MethodSource("params")
     void testAggregated(HttpProtocolVersion httpProtocol, boolean streamingService) throws Exception {
         setUp(httpProtocol, streamingService);
         assertResponse(client.test(newRequest()));
     }
 
-    @ParameterizedTest(name = "httpVersion={0) streamingService={0)")
+    @ParameterizedTest(name = "httpVersion={0} streamingService={1}")
     @MethodSource("params")
     void testRequestStream(HttpProtocolVersion httpProtocol, boolean streamingService) throws Exception {
         setUp(httpProtocol, streamingService);
         assertResponse(client.testRequestStream(Arrays.asList(newRequest(), newRequest())));
     }
 
-    @ParameterizedTest(name = "httpVersion={0) streamingService={0)")
+    @ParameterizedTest(name = "httpVersion={0} streamingService={1}")
     @MethodSource("params")
     void testBiDiStream(HttpProtocolVersion httpProtocol, boolean streamingService) throws Exception {
         setUp(httpProtocol, streamingService);
@@ -127,7 +127,7 @@ void testBiDiStream(HttpProtocolVersion httpProtocol, boolean streamingService)
         }
     }
 
-    @ParameterizedTest(name = "httpVersion={0) streamingService={0)")
+    @ParameterizedTest(name = "httpVersion={0} streamingService={1}")
     @MethodSource("params")
     void testResponseStream(HttpProtocolVersion httpProtocol, boolean streamingService) throws Exception {
         setUp(httpProtocol, streamingService);

diff --git a/servicetalk-grpc-netty/src/test/java/io/servicetalk/grpc/netty/GrpcTimeoutOrderTest.java b/servicetalk-grpc-netty/src/test/java/io/servicetalk/grpc/netty/GrpcTimeoutOrderTest.java
@@ -16,6 +16,7 @@
 package io.servicetalk.grpc.netty;
 
 import io.servicetalk.concurrent.api.Single;
+import io.servicetalk.grpc.api.GrpcServiceContext;
 import io.servicetalk.grpc.api.GrpcStatusException;
 import io.servicetalk.http.api.FilterableStreamingHttpClient;
 import io.servicetalk.http.api.HttpExecutionStrategy;
@@ -87,8 +88,12 @@ void serverFilterNeverRespondsAppliesDeadline(boolean appendNonOffloading, boole
                         builder.appendServiceFilter(NEVER_SERVER_FILTER);
                     }
                 })
-                .listenAndAwait((GreeterService) (ctx, request) ->
-                        succeeded(HelloReply.newBuilder().setMessage("hello " + request.getName()).build()));
+                .listenAndAwait(new GreeterService() {
+                    @Override
+                    public Single<HelloReply> sayHello(GrpcServiceContext ctx, HelloRequest request) {
+                        return succeeded(HelloReply.newBuilder().setMessage("hello " + request.getName()).build());
+                    }
+                });
              BlockingGreeterClient client = forResolvedAddress(serverContext.listenAddress())
                      .defaultTimeout(clientAppliesTimeout ? DEFAULT_TIMEOUT : null, clientAppliesTimeout)
                      .buildBlocking(new Greeter.ClientFactory())) {
@@ -102,8 +107,11 @@ void serverFilterNeverRespondsAppliesDeadline(boolean appendNonOffloading, boole
     void clientFilterNeverRespondsAppliesDeadline(boolean builderEnableTimeout) throws Exception {
         try (ServerContext serverContext = forAddress(localAddress(0))
                 .defaultTimeout(null, false)
-                .listenAndAwait((GreeterService) (ctx, request) -> {
-                    throw new IllegalStateException("client using never filter, server shouldn't read response");
+                .listenAndAwait(new GreeterService() {
+                    @Override
+                    public Single<HelloReply> sayHello(GrpcServiceContext ctx, HelloRequest request) {
+                        throw new IllegalStateException("client using never filter, server shouldn't read response");
+                    }
                 });
              BlockingGreeterClient client = forResolvedAddress(serverContext.listenAddress())
                      .defaultTimeout(DEFAULT_TIMEOUT, builderEnableTimeout)

diff --git a/servicetalk-grpc-netty/src/test/java/io/servicetalk/grpc/netty/GrpcUdsTest.java b/servicetalk-grpc-netty/src/test/java/io/servicetalk/grpc/netty/GrpcUdsTest.java
@@ -15,6 +15,8 @@
  */
 package io.servicetalk.grpc.netty;
 
+import io.servicetalk.concurrent.api.Single;
+import io.servicetalk.grpc.api.GrpcServiceContext;
 import io.servicetalk.transport.api.IoExecutor;
 import io.servicetalk.transport.api.ServerContext;
 
@@ -61,8 +63,13 @@ void udsRoundTrip() throws Exception {
         String name = "foo";
         try (ServerContext serverContext = forAddress(newSocketAddress())
                 .initializeHttp(builder -> builder.ioExecutor(ioExecutor))
-                .listenAndAwait((GreeterService) (ctx, request) ->
-                        succeeded(HelloReply.newBuilder().setMessage(greetingPrefix + request.getName()).build()));
+                .listenAndAwait(new GreeterService() {
+                    @Override
+                    public Single<HelloReply> sayHello(GrpcServiceContext ctx, HelloRequest request) {
+                        return succeeded(HelloReply.newBuilder()
+                                .setMessage(greetingPrefix + request.getName()).build());
+                    }
+                });
              BlockingGreeterClient client = forResolvedAddress(serverContext.listenAddress())
                      .buildBlocking(new ClientFactory())) {
             HelloRequest request = HelloRequest.newBuilder().setName(name).build();