Add and enable new plugin extension configuration in Gradle

jib-gradle-plugin-extension-api/src/main/java/com/google/cloud/tools/jib/gradle/extension/JibGradlePluginExtension.java

@@ -20,6 +20,7 @@
 import com.google.cloud.tools.jib.plugins.extension.ExtensionLogger;
 import com.google.cloud.tools.jib.plugins.extension.JibPluginExtension;
 import com.google.cloud.tools.jib.plugins.extension.JibPluginExtensionException;
+import java.util.Map;
 
 /**
  * Jib Gradle plugin extension API.
@@ -34,12 +35,16 @@ public interface JibGradlePluginExtension extends JibPluginExtension {
    * Extends the build plan prepared by the Jib Gradle plugin.
    *
    * @param buildPlan original build plan prepared by the Jib Gradle plugin
+   * @param properties custom properties configured for the plugin extension
    * @param gradleData {@link GradleData} providing Gradle-specific data and properties
    * @param logger logger for writing log messages
    * @return updated build plan
    * @throws JibPluginExtensionException if an error occurs while running the plugin extension
    */
   ContainerBuildPlan extendContainerBuildPlan(
-      ContainerBuildPlan buildPlan, GradleData gradleData, ExtensionLogger logger)
+      ContainerBuildPlan buildPlan,
+      Map<String, String> properties,
+      GradleData gradleData,
+      ExtensionLogger logger)
       throws JibPluginExtensionException;
 }

jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/ExtensionParameters.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.cloud.tools.jib.gradle;
+
+import com.google.cloud.tools.jib.plugins.common.RawConfiguration.ExtensionConfiguration;
+import java.util.Collections;
+import java.util.Map;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.Internal;
+
+/** Configuration of a plugin extension. */
+public class ExtensionParameters implements ExtensionConfiguration {
+
+  private String implementation = "<extension implementation not configured>";
+  private Map<String, String> properties = Collections.emptyMap();
+
+  @Input
+  public String getImplementation() {
+    return getExtensionClass();
+  }
+
+  @Internal
+  @Override
+  public String getExtensionClass() {
+    return implementation;
+  }
+
+  public void setImplementation(String implementation) {
+    this.implementation = implementation;
+  }
+
+  @Input
+  @Override
+  public Map<String, String> getProperties() {
+    return properties;
+  }
+
+  public void setProperties(Map<String, String> properties) {
+    this.properties = properties;
+  }
+}

jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/GradleProjectProperties.java

@@ -16,6 +16,7 @@
 
 package com.google.cloud.tools.jib.gradle;
 
+import com.google.api.client.util.Lists;
 import com.google.cloud.tools.jib.api.Containerizer;
 import com.google.cloud.tools.jib.api.ImageReference;
 import com.google.cloud.tools.jib.api.InvalidImageReferenceException;
@@ -50,9 +51,9 @@
 import java.nio.file.Paths;
 import java.time.Duration;
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
 import java.util.ServiceLoader;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import javax.annotation.Nullable;
 import org.apache.tools.ant.taskdefs.condition.Os;
@@ -401,27 +402,40 @@ public JibContainerBuilder runPluginExtensions(
       List<? extends ExtensionConfiguration> extensionConfigs,
       JibContainerBuilder jibContainerBuilder)
       throws JibPluginExtensionException {
-    return runPluginExtensions(
-        ServiceLoader.load(JibGradlePluginExtension.class).iterator(), jibContainerBuilder);
+    List<JibGradlePluginExtension> services =
+        Lists.newArrayList(ServiceLoader.load(JibGradlePluginExtension.class).iterator());
+    return runPluginExtensions(services, extensionConfigs, jibContainerBuilder);
   }
 
   @VisibleForTesting
   JibContainerBuilder runPluginExtensions(
-      Iterator<JibGradlePluginExtension> services, JibContainerBuilder jibContainerBuilder)
+      List<JibGradlePluginExtension> services,
+      List<? extends ExtensionConfiguration> extensionConfigs,
+      JibContainerBuilder jibContainerBuilder)
       throws JibPluginExtensionException {
-    if (!services.hasNext()) {
-      log(LogEvent.debug("No Jib plugin extensions discovered"));
+    if (extensionConfigs.isEmpty()) {
+      log(LogEvent.debug("No Jib plugin extensions configured to load"));
       return jibContainerBuilder;
     }
 
     JibGradlePluginExtension extension = null;
     ContainerBuildPlan buildPlan = jibContainerBuilder.toContainerBuildPlan();
     GradleExtensionLogger extensionLogger = new GradleExtensionLogger(this::log);
     try {
-      while (services.hasNext()) {
-        extension = services.next();
-        log(LogEvent.lifecycle("Running extension: " + extension.getClass().getName()));
-        buildPlan = extension.extendContainerBuildPlan(buildPlan, () -> project, extensionLogger);
+      for (ExtensionConfiguration config : extensionConfigs) {
+        String extensionClass = config.getExtensionClass();
+        extension = findConfiguredExtension(services, extensionClass);
+        if (extension == null) {
+          throw new JibPluginExtensionException(
+              JibGradlePluginExtension.class,
+              "extension configured but not discovered on Jib runtime classpath: "
+                  + extensionClass);
+        }
+
+        log(LogEvent.lifecycle("Running extension: " + extensionClass));
+        buildPlan =
+            extension.extendContainerBuildPlan(
+                buildPlan, config.getProperties(), () -> project, extensionLogger);
         ImageReference.parse(buildPlan.getBaseImage()); // to validate image reference
       }
       return jibContainerBuilder.applyContainerBuildPlan(buildPlan);
@@ -433,4 +447,12 @@ JibContainerBuilder runPluginExtensions(
           ex);
     }
   }
+
+  @Nullable
+  private JibGradlePluginExtension findConfiguredExtension(
+      List<JibGradlePluginExtension> extensions, String extensionClass) {
+    Predicate<JibGradlePluginExtension> matchesClassName =
+        extension -> extension.getClass().getName().equals(extensionClass);
+    return extensions.stream().filter(matchesClassName).findFirst().orElse(null);
+  }
 }

jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/GradleRawConfiguration.java

@@ -21,7 +21,6 @@
 import com.google.cloud.tools.jib.plugins.common.AuthProperty;
 import com.google.cloud.tools.jib.plugins.common.RawConfiguration;
 import java.nio.file.Path;
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -203,6 +202,6 @@ public Path getImageJsonOutputPath() {
 
   @Override
   public List<? extends ExtensionConfiguration> getPluginExtensions() {
-    return Collections.emptyList();
+    return jibExtension.getPluginExtensions().get();
   }
 }

jib-gradle-plugin/src/main/java/com/google/cloud/tools/jib/gradle/JibExtension.java

@@ -21,6 +21,7 @@
 import org.gradle.api.Action;
 import org.gradle.api.Project;
 import org.gradle.api.model.ObjectFactory;
+import org.gradle.api.provider.ListProperty;
 import org.gradle.api.provider.Property;
 import org.gradle.api.tasks.Input;
 import org.gradle.api.tasks.Nested;
@@ -63,6 +64,10 @@
  *   }
  *   allowInsecureRegistries = false
  *   containerizingMode = 'exploded'
+ *   pluginExtensions {
+ *     implementation = 'com.example.ThirdPartyJibGradleExtension'
+ *     properties = [customKey: 'value]
+ *   }
  * }
  * }</pre>
  */
@@ -72,6 +77,8 @@ public class JibExtension {
   private static final boolean DEFAULT_ALLOW_INSECURE_REGISTIRIES = false;
   private static final String DEFAULT_CONTAINERIZING_MODE = "exploded";
 
+  private final Project project;
+
   private final BaseImageParameters from;
   private final TargetImageParameters to;
   private final ContainerParameters container;
@@ -81,13 +88,15 @@ public class JibExtension {
   private final SkaffoldParameters skaffold;
   private final Property<Boolean> allowInsecureRegistries;
   private final Property<String> containerizingMode;
+  private final ListProperty<ExtensionParameters> pluginExtensions;
 
   /**
    * Should be called using {@link org.gradle.api.plugins.ExtensionContainer#create}.
    *
    * @param project the injected gradle project
    */
   public JibExtension(Project project) {
+    this.project = project;
     ObjectFactory objectFactory = project.getObjects();
 
     from = objectFactory.newInstance(BaseImageParameters.class);
@@ -98,6 +107,7 @@ public JibExtension(Project project) {
     outputPaths = objectFactory.newInstance(OutputPathsParameters.class, project);
     skaffold = objectFactory.newInstance(SkaffoldParameters.class, project);
 
+    pluginExtensions = objectFactory.listProperty(ExtensionParameters.class).empty();
     allowInsecureRegistries = objectFactory.property(Boolean.class);
     containerizingMode = objectFactory.property(String.class);
 
@@ -134,6 +144,17 @@ public void skaffold(Action<? super SkaffoldParameters> action) {
     action.execute(skaffold);
   }
 
+  /**
+   * Adds a new plugin extension configuration to the extensions list.
+   *
+   * @param action closure representing an extension configuration
+   */
+  public void pluginExtensions(Action<? super ExtensionParameters> action) {
+    ExtensionParameters extension = project.getObjects().newInstance(ExtensionParameters.class);
+    action.execute(extension);
+    pluginExtensions.add(extension);
+  }
+
   public void setAllowInsecureRegistries(boolean allowInsecureRegistries) {
     this.allowInsecureRegistries.set(allowInsecureRegistries);
   }
@@ -198,4 +219,10 @@ public String getContainerizingMode() {
     String property = System.getProperty(PropertyNames.CONTAINERIZING_MODE);
     return property != null ? property : containerizingMode.get();
   }
+
+  @Nested
+  @Optional
+  public ListProperty<ExtensionParameters> getPluginExtensions() {
+    return pluginExtensions;
+  }
 }