Overhauled handling of local extensions in Gradle Plugins

This completely changes how local extensions are handled by the Gradle plugins (`io.quarkus` and `io.quarkus.extension`) by now also resolving deployment modules in included builds and properly adding them and their artifacts as dependencies to the respective Quarkus code generation tasks and configurations.

In addition it no longer depends on an extension descriptor to exist to determine the deployment module, conditional dependencies and dependency conditions. These are now read directly from the `QuarkusExtensionConfiguration` extension of any local extension module. Due to Gradle using different ClassLoaders for included builds this is done using Reflection.

To achieve this deeper integration with Gradle a bit more internal classes have been used than I would normally be comfortable with, but they are pretty essential to the functioning of Gradle and Composite Builds so I'm fairly confident that they won't break any time soon.

Author: vemilyus

devtools/gradle/gradle-application-plugin/src/main/java/io/quarkus/gradle/QuarkusPlugin.java

@@ -18,6 +18,7 @@
 import org.gradle.api.UnknownTaskException;
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.artifacts.ConfigurationContainer;
+import org.gradle.api.artifacts.ExternalModuleDependency;
 import org.gradle.api.artifacts.ProjectDependency;
 import org.gradle.api.file.FileCollection;
 import org.gradle.api.plugins.BasePlugin;
@@ -59,6 +60,10 @@
 import io.quarkus.gradle.tasks.QuarkusTestConfig;
 import io.quarkus.gradle.tasks.QuarkusUpdate;
 import io.quarkus.gradle.tooling.GradleApplicationModelBuilder;
+import io.quarkus.gradle.tooling.ToolingUtils;
+import io.quarkus.gradle.tooling.dependency.DependencyUtils;
+import io.quarkus.gradle.tooling.dependency.ExtensionDependency;
+import io.quarkus.gradle.tooling.dependency.ProjectExtensionDependency;
 import io.quarkus.runtime.LaunchMode;
 
 public class QuarkusPlugin implements Plugin<Project> {
@@ -508,16 +513,15 @@ private void visitProjectDep(Project project, Project dep, Set<String> visited)
         if (dep.getState().getExecuted()) {
             setupQuarkusBuildTaskDeps(project, dep, visited);
         } else {
-            dep.afterEvaluate(p -> {
-                setupQuarkusBuildTaskDeps(project, p, visited);
-            });
+            dep.afterEvaluate(p -> setupQuarkusBuildTaskDeps(project, p, visited));
         }
     }
 
     private void setupQuarkusBuildTaskDeps(Project project, Project dep, Set<String> visited) {
-        if (!visited.add(dep.getPath())) {
+        if (!visited.add(dep.getGroup() + ":" + dep.getName())) {
             return;
         }
+
         project.getLogger().debug("Configuring {} task dependencies on {} tasks", project, dep);
 
         getLazyTask(project, QUARKUS_BUILD_TASK_NAME)
@@ -555,13 +559,40 @@ protected void visitProjectDependencies(Project project, Project dep, Set<String
             }
             compilePlusRuntimeConfig.getIncoming().getDependencies()
                     .forEach(d -> {
+                        Project depProject = null;
+
                         if (d instanceof ProjectDependency) {
-                            visitProjectDep(project, ((ProjectDependency) d).getDependencyProject(), visited);
+                            depProject = ((ProjectDependency) d).getDependencyProject();
+                        } else if (d instanceof ExternalModuleDependency) {
+                            depProject = ToolingUtils.findIncludedProject(project, (ExternalModuleDependency) d);
+                        }
+
+                        if (depProject == null) {
+                            return;
+                        }
+
+                        if (depProject.getState().getExecuted()) {
+                            visitLocalProject(project, depProject, visited);
+                        } else {
+                            depProject.afterEvaluate(p -> visitLocalProject(project, p, visited));
                         }
                     });
         }
     }
 
+    private void visitLocalProject(Project project, Project localProject, Set<String> visited) {
+        // local dependency, so we collect also its dependencies
+        visitProjectDep(project, localProject, visited);
+
+        ExtensionDependency<?> extensionDependency = DependencyUtils
+                .getExtensionInfoOrNull(project, localProject);
+
+        if (extensionDependency instanceof ProjectExtensionDependency) {
+            visitProjectDep(project,
+                    ((ProjectExtensionDependency) extensionDependency).getDeploymentModule(), visited);
+        }
+    }
+
     private Optional<TaskProvider<Task>> getLazyTask(Project project, String name) {
         try {
             return Optional.of(project.getTasks().named(name));

devtools/gradle/gradle-extension-plugin/src/main/java/io/quarkus/extension/gradle/QuarkusExtensionPlugin.java

@@ -24,14 +24,15 @@
 import io.quarkus.extension.gradle.tasks.ExtensionDescriptorTask;
 import io.quarkus.extension.gradle.tasks.ValidateExtensionTask;
 import io.quarkus.gradle.dependency.ApplicationDeploymentClasspathBuilder;
+import io.quarkus.gradle.extension.ExtensionConstants;
 import io.quarkus.gradle.tooling.ToolingUtils;
 import io.quarkus.gradle.tooling.dependency.DependencyUtils;
 import io.quarkus.runtime.LaunchMode;
 
 public class QuarkusExtensionPlugin implements Plugin<Project> {
 
     public static final String DEFAULT_DEPLOYMENT_PROJECT_NAME = "deployment";
-    public static final String EXTENSION_CONFIGURATION_NAME = "quarkusExtension";
+    public static final String EXTENSION_CONFIGURATION_NAME = ExtensionConstants.EXTENSION_CONFIGURATION_NAME;
 
     public static final String EXTENSION_DESCRIPTOR_TASK_NAME = "extensionDescriptor";
     public static final String VALIDATE_EXTENSION_TASK_NAME = "validateExtension";
@@ -42,6 +43,7 @@ public class QuarkusExtensionPlugin implements Plugin<Project> {
     public void apply(Project project) {
         final QuarkusExtensionConfiguration quarkusExt = project.getExtensions().create(EXTENSION_CONFIGURATION_NAME,
                 QuarkusExtensionConfiguration.class);
+
         project.getPluginManager().apply(JavaPlugin.class);
         registerTasks(project, quarkusExt);
     }
@@ -141,17 +143,12 @@ private Project findDeploymentProject(Project project, QuarkusExtensionConfigura
             deploymentProjectName = DEFAULT_DEPLOYMENT_PROJECT_NAME;
         }
 
-        Project deploymentProject = project.getRootProject().findProject(deploymentProjectName);
+        Project deploymentProject = ToolingUtils.findLocalProject(project, deploymentProjectName);
         if (deploymentProject == null) {
-            if (project.getParent() != null) {
-                deploymentProject = project.getParent().findProject(deploymentProjectName);
-            }
-            if (deploymentProject == null) {
-                project.getLogger().warn("Unable to find deployment project with name: " + deploymentProjectName
-                        + ". You can configure the deployment project name by setting the 'deploymentModule' property in the plugin extension.");
-            }
+            project.getLogger().warn("Unable to find deployment project with name: " + deploymentProjectName
+                    + ". You can configure the deployment project name by setting the 'deploymentModule' property in the plugin extension.");
         }
+
         return deploymentProject;
     }
-
 }

devtools/gradle/gradle-extension-plugin/src/main/java/io/quarkus/extension/gradle/dependency/DeploymentClasspathBuilder.java

@@ -15,7 +15,6 @@
 import io.quarkus.gradle.tooling.ToolingUtils;
 import io.quarkus.gradle.tooling.dependency.DependencyUtils;
 import io.quarkus.gradle.tooling.dependency.ExtensionDependency;
-import io.quarkus.gradle.tooling.dependency.LocalExtensionDependency;
 
 public class DeploymentClasspathBuilder {
 
@@ -32,27 +31,23 @@ public void exportDeploymentClasspath(String configurationName) {
         project.getConfigurations().create(deploymentConfigurationName, config -> {
             Configuration configuration = DependencyUtils.duplicateConfiguration(project,
                     project.getConfigurations().getByName(configurationName));
-            Set<ExtensionDependency> extensionDependencies = collectFirstMetQuarkusExtensions(configuration);
+            Set<ExtensionDependency<?>> extensionDependencies = collectFirstMetQuarkusExtensions(configuration);
 
             DependencyHandler dependencies = project.getDependencies();
 
-            for (ExtensionDependency extension : extensionDependencies) {
-                if (extension instanceof LocalExtensionDependency) {
-                    DependencyUtils.addLocalDeploymentDependency(deploymentConfigurationName,
-                            (LocalExtensionDependency) extension,
-                            dependencies);
-                } else {
-                    DependencyUtils.requireDeploymentDependency(deploymentConfigurationName, extension, dependencies);
-                    if (!alreadyProcessed.add(extension.getExtensionId())) {
-                        continue;
-                    }
+            for (ExtensionDependency<?> extension : extensionDependencies) {
+                if (!alreadyProcessed.add(extension.getExtensionId())) {
+                    continue;
                 }
+
+                dependencies.add(deploymentConfigurationName,
+                        DependencyUtils.createDeploymentDependency(dependencies, extension));
             }
         });
     }
 
-    private Set<ExtensionDependency> collectFirstMetQuarkusExtensions(Configuration configuration) {
-        Set<ExtensionDependency> firstLevelExtensions = new HashSet<>();
+    private Set<ExtensionDependency<?>> collectFirstMetQuarkusExtensions(Configuration configuration) {
+        Set<ExtensionDependency<?>> firstLevelExtensions = new HashSet<>();
         Set<ResolvedDependency> firstLevelModuleDependencies = configuration.getResolvedConfiguration()
                 .getFirstLevelModuleDependencies();
 
@@ -64,16 +59,16 @@ private Set<ExtensionDependency> collectFirstMetQuarkusExtensions(Configuration
         return firstLevelExtensions;
     }
 
-    private Set<ExtensionDependency> collectQuarkusExtensions(ResolvedDependency dependency,
+    private Set<ExtensionDependency<?>> collectQuarkusExtensions(ResolvedDependency dependency,
             Set<ModuleVersionIdentifier> visitedArtifacts) {
         if (visitedArtifacts.contains(dependency.getModule().getId())) {
             return Collections.emptySet();
         } else {
             visitedArtifacts.add(dependency.getModule().getId());
         }
-        Set<ExtensionDependency> extensions = new LinkedHashSet<>();
+        Set<ExtensionDependency<?>> extensions = new LinkedHashSet<>();
         for (ResolvedArtifact moduleArtifact : dependency.getModuleArtifacts()) {
-            ExtensionDependency extension = DependencyUtils.getExtensionInfoOrNull(project, moduleArtifact);
+            ExtensionDependency<?> extension = DependencyUtils.getExtensionInfoOrNull(project, moduleArtifact);
             if (extension != null) {
                 extensions.add(extension);
                 return extensions;
@@ -83,7 +78,7 @@ private Set<ExtensionDependency> collectQuarkusExtensions(ResolvedDependency dep
         for (ResolvedDependency child : dependency.getChildren()) {
             extensions.addAll(collectQuarkusExtensions(child, visitedArtifacts));
         }
+
         return extensions;
     }
-
 }

devtools/gradle/gradle-extension-plugin/src/main/java/io/quarkus/extension/gradle/tasks/ValidateExtensionTask.java

@@ -17,8 +17,10 @@
 
 import io.quarkus.bootstrap.model.AppArtifactKey;
 import io.quarkus.extension.gradle.QuarkusExtensionConfiguration;
+import io.quarkus.gradle.tooling.dependency.ArtifactExtensionDependency;
 import io.quarkus.gradle.tooling.dependency.DependencyUtils;
 import io.quarkus.gradle.tooling.dependency.ExtensionDependency;
+import io.quarkus.gradle.tooling.dependency.ProjectExtensionDependency;
 
 public class ValidateExtensionTask extends DefaultTask {
 
@@ -82,10 +84,20 @@ public void validateExtension() {
     private List<AppArtifactKey> collectRuntimeExtensionsDeploymentKeys(Set<ResolvedArtifact> runtimeArtifacts) {
         List<AppArtifactKey> runtimeExtensions = new ArrayList<>();
         for (ResolvedArtifact resolvedArtifact : runtimeArtifacts) {
-            ExtensionDependency extension = DependencyUtils.getExtensionInfoOrNull(getProject(), resolvedArtifact);
+            ExtensionDependency<?> extension = DependencyUtils.getExtensionInfoOrNull(getProject(), resolvedArtifact);
             if (extension != null) {
-                runtimeExtensions.add(new AppArtifactKey(extension.getDeploymentModule().getGroupId(),
-                        extension.getDeploymentModule().getArtifactId()));
+                if (extension instanceof ProjectExtensionDependency) {
+                    final ProjectExtensionDependency ped = (ProjectExtensionDependency) extension;
+
+                    runtimeExtensions
+                            .add(new AppArtifactKey(ped.getDeploymentModule().getGroup().toString(),
+                                    ped.getDeploymentModule().getName()));
+                } else if (extension instanceof ArtifactExtensionDependency) {
+                    final ArtifactExtensionDependency aed = (ArtifactExtensionDependency) extension;
+
+                    runtimeExtensions.add(new AppArtifactKey(aed.getDeploymentModule().getGroupId(),
+                            aed.getDeploymentModule().getArtifactId()));
+                }
             }
         }
         return runtimeExtensions;

devtools/gradle/gradle-model/src/main/java/io/quarkus/gradle/dependency/ApplicationDeploymentClasspathBuilder.java

@@ -31,8 +31,6 @@
 import io.quarkus.gradle.tooling.ToolingUtils;
 import io.quarkus.gradle.tooling.dependency.DependencyUtils;
 import io.quarkus.gradle.tooling.dependency.ExtensionDependency;
-import io.quarkus.gradle.tooling.dependency.IncludedBuildExtensionDependency;
-import io.quarkus.gradle.tooling.dependency.LocalExtensionDependency;
 import io.quarkus.runtime.LaunchMode;
 
 public class ApplicationDeploymentClasspathBuilder {
@@ -224,11 +222,11 @@ private void setUpDeploymentConfiguration() {
                 configuration.getDependencies().addAllLater(dependencyListProperty.value(project.provider(() -> {
                     ConditionalDependenciesEnabler cdEnabler = new ConditionalDependenciesEnabler(project, mode,
                             enforcedPlatforms);
-                    final Collection<ExtensionDependency> allExtensions = cdEnabler.getAllExtensions();
-                    Set<ExtensionDependency> extensions = collectFirstMetQuarkusExtensions(getRawRuntimeConfiguration(),
+                    final Collection<ExtensionDependency<?>> allExtensions = cdEnabler.getAllExtensions();
+                    Set<ExtensionDependency<?>> extensions = collectFirstMetQuarkusExtensions(getRawRuntimeConfiguration(),
                             allExtensions);
                     // Add conditional extensions
-                    for (ExtensionDependency knownExtension : allExtensions) {
+                    for (ExtensionDependency<?> knownExtension : allExtensions) {
                         if (knownExtension.isConditional()) {
                             extensions.add(knownExtension);
                         }
@@ -237,23 +235,13 @@ private void setUpDeploymentConfiguration() {
                     final Set<ModuleVersionIdentifier> alreadyProcessed = new HashSet<>(extensions.size());
                     final DependencyHandler dependencies = project.getDependencies();
                     final Set<Dependency> deploymentDependencies = new HashSet<>();
-                    for (ExtensionDependency extension : extensions) {
-                        if (extension instanceof IncludedBuildExtensionDependency) {
-                            deploymentDependencies.add(((IncludedBuildExtensionDependency) extension).getDeployment());
-                        } else if (extension instanceof LocalExtensionDependency) {
-                            LocalExtensionDependency localExtensionDependency = (LocalExtensionDependency) extension;
-                            deploymentDependencies.add(
-                                    dependencies.project(Collections.singletonMap("path",
-                                            localExtensionDependency.findDeploymentModulePath())));
-                        } else {
-                            if (!alreadyProcessed.add(extension.getExtensionId())) {
-                                continue;
-                            }
-                            deploymentDependencies.add(dependencies.create(
-                                    extension.getDeploymentModule().getGroupId() + ":"
-                                            + extension.getDeploymentModule().getArtifactId() + ":"
-                                            + extension.getDeploymentModule().getVersion()));
+                    for (ExtensionDependency<?> extension : extensions) {
+                        if (!alreadyProcessed.add(extension.getExtensionId())) {
+                            continue;
                         }
+
+                        deploymentDependencies.add(
+                                DependencyUtils.createDeploymentDependency(dependencies, extension));
                     }
                     return deploymentDependencies;
                 })));
@@ -307,10 +295,10 @@ public PlatformImports getPlatformImports() {
         return platformImports.get(this.platformImportName);
     }
 
-    private Set<ExtensionDependency> collectFirstMetQuarkusExtensions(Configuration configuration,
-            Collection<ExtensionDependency> knownExtensions) {
+    private Set<ExtensionDependency<?>> collectFirstMetQuarkusExtensions(Configuration configuration,
+            Collection<ExtensionDependency<?>> knownExtensions) {
 
-        Set<ExtensionDependency> firstLevelExtensions = new HashSet<>();
+        Set<ExtensionDependency<?>> firstLevelExtensions = new HashSet<>();
         Set<ResolvedDependency> firstLevelModuleDependencies = configuration.getResolvedConfiguration()
                 .getFirstLevelModuleDependencies();
 
@@ -322,15 +310,15 @@ private Set<ExtensionDependency> collectFirstMetQuarkusExtensions(Configuration
         return firstLevelExtensions;
     }
 
-    private Set<ExtensionDependency> collectQuarkusExtensions(ResolvedDependency dependency, Set<String> visitedArtifacts,
-            Collection<ExtensionDependency> knownExtensions) {
+    private Set<ExtensionDependency<?>> collectQuarkusExtensions(ResolvedDependency dependency, Set<String> visitedArtifacts,
+            Collection<ExtensionDependency<?>> knownExtensions) {
         String artifactKey = String.format("%s:%s", dependency.getModuleGroup(), dependency.getModuleName());
         if (!visitedArtifacts.add(artifactKey)) {
             return Collections.emptySet();
         }
 
-        Set<ExtensionDependency> extensions = new LinkedHashSet<>();
-        ExtensionDependency extension = getExtensionOrNull(dependency.getModuleGroup(), dependency.getModuleName(),
+        Set<ExtensionDependency<?>> extensions = new LinkedHashSet<>();
+        ExtensionDependency<?> extension = getExtensionOrNull(dependency.getModuleGroup(), dependency.getModuleName(),
                 dependency.getModuleVersion(), knownExtensions);
         if (extension != null) {
             extensions.add(extension);
@@ -342,9 +330,9 @@ private Set<ExtensionDependency> collectQuarkusExtensions(ResolvedDependency dep
         return extensions;
     }
 
-    private ExtensionDependency getExtensionOrNull(String group, String artifact, String version,
-            Collection<ExtensionDependency> knownExtensions) {
-        for (ExtensionDependency knownExtension : knownExtensions) {
+    private ExtensionDependency<?> getExtensionOrNull(String group, String artifact, String version,
+            Collection<ExtensionDependency<?>> knownExtensions) {
+        for (ExtensionDependency<?> knownExtension : knownExtensions) {
             if (group.equals(knownExtension.getGroup()) && artifact.equals(knownExtension.getName())
                     && version.equals(knownExtension.getVersion())) {
                 return knownExtension;