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/ExtensionParametersSpec.java

@@ -0,0 +1,47 @@
+/*
+ * 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 javax.inject.Inject;
+import org.gradle.api.Action;
+import org.gradle.api.Project;
+import org.gradle.api.provider.ListProperty;
+
+/** Allows to add {@link ExtensionParameters} objects to the list property of the same type. */
+public class ExtensionParametersSpec {
+
+  private final Project project;
+  private final ListProperty<ExtensionParameters> pluginExtensions;
+
+  @Inject
+  public ExtensionParametersSpec(
+      Project project, ListProperty<ExtensionParameters> pluginExtensions) {
+    this.project = project;
+    this.pluginExtensions = pluginExtensions;
+  }
+
+  /**
+   * Adds a new plugin extension configuration to the extensions list.
+   *
+   * @param action closure representing an extension configuration
+   */
+  public void pluginExtension(Action<? super ExtensionParameters> action) {
+    ExtensionParameters extension = project.getObjects().newInstance(ExtensionParameters.class);
+    action.execute(extension);
+    pluginExtensions.add(extension);
+  }
+}

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

@@ -22,7 +22,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.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -209,6 +208,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,12 @@
  *   }
  *   allowInsecureRegistries = false
  *   containerizingMode = 'exploded'
+ *   pluginExtensions {
+ *     pluginExtension {
+ *       implementation = 'com.example.ThirdPartyJibGradleExtension'
+ *       properties = [customKey: 'value]
+ *     }
+ *   }
  * }
  * }</pre>
  */
@@ -81,6 +88,8 @@ public class JibExtension {
   private final SkaffoldParameters skaffold;
   private final Property<Boolean> allowInsecureRegistries;
   private final Property<String> containerizingMode;
+  private final ListProperty<ExtensionParameters> pluginExtensions;
+  private final ExtensionParametersSpec extensionParametersSpec;
 
   /**
    * Should be called using {@link org.gradle.api.plugins.ExtensionContainer#create}.
@@ -98,6 +107,9 @@ public JibExtension(Project project) {
     outputPaths = objectFactory.newInstance(OutputPathsParameters.class, project);
     skaffold = objectFactory.newInstance(SkaffoldParameters.class, project);
 
+    pluginExtensions = objectFactory.listProperty(ExtensionParameters.class).empty();
+    extensionParametersSpec =
+        objectFactory.newInstance(ExtensionParametersSpec.class, project, pluginExtensions);
     allowInsecureRegistries = objectFactory.property(Boolean.class);
     containerizingMode = objectFactory.property(String.class);
 
@@ -134,6 +146,10 @@ public void skaffold(Action<? super SkaffoldParameters> action) {
     action.execute(skaffold);
   }
 
+  public void pluginExtensions(Action<? super ExtensionParametersSpec> action) {
+    action.execute(extensionParametersSpec);
+  }
+
   public void setAllowInsecureRegistries(boolean allowInsecureRegistries) {
     this.allowInsecureRegistries.set(allowInsecureRegistries);
   }
@@ -198,4 +214,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;
+  }
 }