Draft: Selective api poc

gapic-generator-java/src/main/java/com/google/api/generator/gapic/protoparser/Parser.java

@@ -14,6 +14,7 @@
 
 package com.google.api.generator.gapic.protoparser;
 
+import com.google.api.ClientLibrarySettings;
 import com.google.api.ClientProto;
 import com.google.api.DocumentationRule;
 import com.google.api.FieldBehavior;
@@ -154,6 +155,14 @@ public static GapicContext parse(CodeGeneratorRequest request) {
     // Keep message and resource name parsing separate for cleaner logic.
     // While this takes an extra pass through the protobufs, the extra time is relatively trivial
     // and is worth the larger reduced maintenance cost.
+
+    // Note that if selective api generation is configured via service yaml, resource names
+    // and messages corresponding to RPC's methods excluded for generation are not removed.
+    // However, these resource names will not be composed.
+    // refer to ComposerTest.testComposeSelectively_shouldComposeOnlyOneHelperResource for
+    // verification.
+    // TODO: remove messages and resource names that's only used by excluded RPCs configured
+    // via selective api generation from parsed GapicContext.
     Map<String, Message> messages = parseMessages(request, outputResourceReferencesSeen);
 
     Map<String, ResourceName> resourceNames = parseResourceNames(request);
@@ -425,6 +434,47 @@ public static List<Service> parseService(
         Transport.GRPC);
   }
 
+  private static Optional<List<String>> getInclusionMethodListFromServiceYaml(
+      Optional<com.google.api.Service> serviceYamlProtoOpt, String protoPackage) {
+    if (!serviceYamlProtoOpt.isPresent()
+        || serviceYamlProtoOpt.get().getPublishing().getLibrarySettingsCount() == 0) {
+      return Optional.empty();
+    }
+    List<ClientLibrarySettings> librarySettingsList =
+        serviceYamlProtoOpt.get().getPublishing().getLibrarySettingsList();
+    // verify library_settings.version matches with proto package name
+    // This should be validated in upstream. Give warnings if not match.
+    if (!librarySettingsList.get(0).getVersion().isEmpty()
+        && !protoPackage.equals(librarySettingsList.get(0).getVersion())) {
+      LOGGER.warning(
+          "Service yaml config may be misconfigured. "
+              + "Version in publishing.library_settings does not match proto package."
+              + "Disregarding selective generation settings.");
+      return Optional.empty();
+    }
+    List<String> includeMethodsList =
+        librarySettingsList
+            .get(0)
+            .getJavaSettings()
+            .getCommon()
+            .getSelectiveGapicGeneration()
+            .getMethodsList();
+    return Optional.of(includeMethodsList);
+  }
+
+  private static boolean shouldIncludeMethodInGeneration(
+      MethodDescriptor method, Optional<List<String>> optionalIncludeMethodsList) {
+    // default to include all when no service yaml or no library setting section.
+    if (!optionalIncludeMethodsList.isPresent()) {
+      return true;
+    }
+    // default to include all when nothing specified.
+    if (optionalIncludeMethodsList.get().isEmpty()) {
+      return true;
+    }
+    return optionalIncludeMethodsList.get().contains(method.getFullName());
+  }
+
   public static List<Service> parseService(
       FileDescriptor fileDescriptor,
       Map<String, Message> messageTypes,
@@ -433,18 +483,27 @@ public static List<Service> parseService(
       Optional<GapicServiceConfig> serviceConfigOpt,
       Set<ResourceName> outputArgResourceNames,
       Transport transport) {
-
+    String protoPackage = fileDescriptor.getPackage();
+    Optional<List<String>> inclusionMethodListFromServiceYaml =
+        getInclusionMethodListFromServiceYaml(serviceYamlProtoOpt, protoPackage);
     return fileDescriptor.getServices().stream()
         .filter(
             serviceDescriptor -> {
               List<MethodDescriptor> methodsList = serviceDescriptor.getMethods();
-              if (methodsList.isEmpty()) {
+              List<MethodDescriptor> methodListSelected =
+                  methodsList.stream()
+                      .filter(
+                          method -> {
+                            return shouldIncludeMethodInGeneration(method, inclusionMethodListFromServiceYaml);
+                          })
+                      .collect(Collectors.toList());
+              if (methodListSelected.isEmpty()) {
                 LOGGER.warning(
                     String.format(
                         "Service %s has no RPC methods and will not be generated",
                         serviceDescriptor.getName()));
               }
-              return !methodsList.isEmpty();
+              return !methodListSelected.isEmpty();
             })
         .map(
             s -> {
@@ -498,6 +557,8 @@ public static List<Service> parseService(
               String pakkage = TypeParser.getPackage(fileDescriptor);
               String originalJavaPackage = pakkage;
               // Override Java package with that specified in gapic.yaml.
+              // this override is deprecated and legacy support only
+              // see go/client-user-guide#configure-long-running-operation-polling-timeouts-optional
               if (serviceConfigOpt.isPresent()
                   && serviceConfigOpt.get().getLanguageSettingsOpt().isPresent()) {
                 GapicLanguageSettings languageSettings =
@@ -518,6 +579,7 @@ public static List<Service> parseService(
                   .setMethods(
                       parseMethods(
                           s,
+                          inclusionMethodListFromServiceYaml,
                           pakkage,
                           messageTypes,
                           resourceNames,
@@ -709,6 +771,7 @@ public static Map<String, ResourceName> parseResourceNames(
   @VisibleForTesting
   static List<Method> parseMethods(
       ServiceDescriptor serviceDescriptor,
+      Optional<List<String>> inclusionMethodListFromServiceYaml,
       String servicePackage,
       Map<String, Message> messageTypes,
       Map<String, ResourceName> resourceNames,
@@ -721,8 +784,10 @@ static List<Method> parseMethods(
     // Parse the serviceYaml for autopopulated methods and fields once and put into a map
     Map<String, List<String>> autoPopulatedMethodsWithFields =
         parseAutoPopulatedMethodsAndFields(serviceYamlProtoOpt);
-
     for (MethodDescriptor protoMethod : serviceDescriptor.getMethods()) {
+      if (!shouldIncludeMethodInGeneration(protoMethod, inclusionMethodListFromServiceYaml)) {
+        continue;
+      }
       // Parse the method.
       TypeNode inputType = TypeParser.parseType(protoMethod.getInputType());
       Method.Builder methodBuilder = Method.builder();

gapic-generator-java/src/test/java/com/google/api/generator/gapic/composer/ComposerTest.java

@@ -20,6 +20,7 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import com.google.api.generator.engine.ast.ClassDefinition;
+import com.google.api.generator.engine.ast.MethodDefinition;
 import com.google.api.generator.engine.ast.ScopeNode;
 import com.google.api.generator.engine.writer.JavaWriterVisitor;
 import com.google.api.generator.gapic.composer.comment.CommentComposer;
@@ -172,6 +173,50 @@ void testComposePackageInfo_emptyGapicContext_returnsNull() {
     assertNull(Composer.composePackageInfo(GapicContext.EMPTY));
   }
 
+  @Test
+  void testComposeSelectively_shouldComposeOnlyOneHelperResource() {
+    GapicContext context = GrpcTestProtoLoader.instance().parseSelectiveGenerationTesting();
+    List<GapicClass> resourceNameHelperClasses =
+        Composer.generateResourceNameHelperClasses(context);
+    assertEquals(1, resourceNameHelperClasses.size());
+    for (GapicClass clazz : resourceNameHelperClasses) {
+      String className = clazz.classDefinition().classIdentifier().name();
+      Assert.assertGoldenClass(
+          this.getClass(), clazz, "SelectiveGenerated" + className + ".golden");
+    }
+  }
+
+  @Test
+  void testComposeSelectively_serviceClientShouldOnlyContainSelectedMethods() {
+    GapicContext context = GrpcTestProtoLoader.instance().parseSelectiveGenerationTesting();
+    List<GapicClass> serviceClasses = Composer.composeServiceClasses(context);
+    assertEquals(10, serviceClasses.size());
+    for (GapicClass clazz : serviceClasses) {
+      if (clazz
+          .classDefinition()
+          .classIdentifier()
+          .name()
+          .equals("EchoServiceShouldGeneratePartialClient")) {
+        assertEquals(25, clazz.classDefinition().methods().size());
+        for (MethodDefinition method : clazz.classDefinition().methods()) {
+          String methodName = method.methodIdentifier().name();
+          if (method.isConstructor()) {
+            continue;
+          }
+          assertTrue(
+              methodName.startsWith("echo")
+                  || methodName.startsWith("chat")
+                  || methodName.startsWith("create")
+                  || methodName.startsWith("get")
+                  || methodName.startsWith("close")
+                  || methodName.startsWith("shutdown")
+                  || methodName.startsWith("is")
+                  || methodName.startsWith("awaitTermination"));
+        }
+      }
+    }
+  }
+
   private List<GapicClass> getTestClassListFromService(Service testService) {
     GapicClass testClass =
         GrpcServiceCallableFactoryClassComposer.instance()