Document and cleanup plugins

Terracotta-OSS · Nov 6, 2023 · 081ecb0 · 081ecb0
1 parent 4bcf4eb
commit 081ecb0
Show file tree

Hide file tree

Showing 9 changed files with 425 additions and 299 deletions.
diff --git a/src/main/java/org/terracotta/build/plugins/BlacklistPlugin.java b/src/main/java/org/terracotta/build/plugins/BlacklistPlugin.java
@@ -4,6 +4,7 @@
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.DependencyScopeConfiguration;
 import org.gradle.api.artifacts.MutableVersionConstraint;
 import org.gradle.api.plugins.JavaBasePlugin;
 import org.gradle.api.tasks.SourceSetContainer;
@@ -12,18 +13,15 @@
 
 import static org.gradle.api.tasks.SourceSet.TEST_SOURCE_SET_NAME;
 
+@SuppressWarnings("UnstableApiUsage")
 public class BlacklistPlugin implements Plugin<Project> {
 
   private static final String BLACKLIST_CONFIGURATION = "blacklist";
   private static final String TEST_BLACKLIST_CONFIGURATION = "testBlacklist";
 
   @Override
   public void apply(Project project) {
-    NamedDomainObjectProvider<Configuration> blacklist = project.getConfigurations().register(BLACKLIST_CONFIGURATION, config -> {
-      config.setVisible(false);
-      config.setCanBeConsumed(false);
-      config.setCanBeResolved(false);
-    });
+    NamedDomainObjectProvider<DependencyScopeConfiguration> blacklist = project.getConfigurations().dependencyScope(BLACKLIST_CONFIGURATION);
 
     project.getConfigurations().configureEach(other -> {
       Configuration config = blacklist.get();
@@ -32,11 +30,7 @@ public void apply(Project project) {
       }
     });
 
-    NamedDomainObjectProvider<Configuration> testBlacklist = project.getConfigurations().register(TEST_BLACKLIST_CONFIGURATION, config -> {
-      config.setVisible(false);
-      config.setCanBeConsumed(false);
-      config.setCanBeResolved(false);
-    });
+    NamedDomainObjectProvider<DependencyScopeConfiguration> testBlacklist = project.getConfigurations().dependencyScope(TEST_BLACKLIST_CONFIGURATION);
 
     project.getPlugins().withType(JavaBasePlugin.class).configureEach(javaBasePlugin -> {
       project.getExtensions().configure(SourceSetContainer.class, sourceSets ->

diff --git a/src/main/java/org/terracotta/build/plugins/PackagePlugin.java b/src/main/java/org/terracotta/build/plugins/PackagePlugin.java
@@ -24,23 +24,24 @@
 
 import javax.inject.Inject;
 
-import static org.gradle.api.internal.tasks.JvmConstants.JAVA_COMPONENT_NAME;
+import static org.gradle.api.artifacts.Dependency.DEFAULT_CONFIGURATION;
+import static org.gradle.api.internal.tasks.JvmConstants.RUNTIME_ELEMENTS_CONFIGURATION_NAME;
 import static org.gradle.api.plugins.JavaPlugin.API_CONFIGURATION_NAME;
 import static org.gradle.api.plugins.JavaPlugin.COMPILE_ONLY_API_CONFIGURATION_NAME;
 import static org.gradle.api.plugins.JavaPlugin.IMPLEMENTATION_CONFIGURATION_NAME;
 import static org.gradle.api.plugins.JavaPlugin.RUNTIME_ONLY_CONFIGURATION_NAME;
 import static org.terracotta.build.plugins.packaging.PackageInternal.CONTENTS_API_CONFIGURATION_NAME;
 import static org.terracotta.build.plugins.packaging.PackageInternal.CONTENTS_CONFIGURATION_NAME;
-import static org.terracotta.build.plugins.packaging.PackageInternal.PROVIDED_CONFIGURATION_NAME;
-import static org.terracotta.build.plugins.packaging.PackageInternal.UNPACKAGED_JAVA_RUNTIME;
 import static org.terracotta.build.plugins.packaging.PackageInternal.camelPrefix;
 
 /**
- * EhDistribute
+ * A plugin which assembles partial uber-jars.
  */
 @SuppressWarnings("UnstableApiUsage")
 public abstract class PackagePlugin implements Plugin<Project> {
 
+  public static final String PACKAGE_COMPONENT_NAME = "package";
+  public static final String EXPLODED_JAVA_RUNTIME = "exploded-java-runtime";
   public static final String COMMON_PREFIX = "common";
 
   @Inject
@@ -50,13 +51,16 @@ public abstract class PackagePlugin implements Plugin<Project> {
   public void apply(Project project) {
     project.getPlugins().apply(BasePlugin.class);
 
-    AdhocComponentWithVariants javaComponent = getSoftwareComponentFactory().adhoc(JAVA_COMPONENT_NAME);
-    project.getComponents().add(javaComponent);
+    project.getComponents().registerFactory(AdhocComponentWithVariants.class, getSoftwareComponentFactory()::adhoc);
+    NamedDomainObjectProvider<AdhocComponentWithVariants> component = project.getComponents().register(PACKAGE_COMPONENT_NAME, AdhocComponentWithVariants.class);
 
     project.getTasks().withType(ShadowJar.class).configureEach(shadow -> shadow.getExtensions().create("osgi", OsgiManifestJarExtension.class, shadow));
 
 
     ConfigurationContainer configurations = project.getConfigurations();
+    /*
+     * Create the set of common dependency scopes that all the package specific scopes extend.
+     */
     NamedDomainObjectProvider<DependencyScopeConfiguration> commonContentsApi = configurations.dependencyScope(camelPrefix(COMMON_PREFIX, CONTENTS_API_CONFIGURATION_NAME),
         c -> c.setDescription("API dependencies for all packages contents."));
     configurations.dependencyScope(camelPrefix(COMMON_PREFIX, CONTENTS_CONFIGURATION_NAME),
@@ -70,41 +74,45 @@ public void apply(Project project) {
         c -> c.setDescription("Compile-only API dependencies for all packaged artifacts."));
     configurations.dependencyScope(camelPrefix(COMMON_PREFIX, RUNTIME_ONLY_CONFIGURATION_NAME),
         c -> c.setDescription("Runtime-only dependencies for all packaged artifacts."));
-    configurations.dependencyScope(camelPrefix(COMMON_PREFIX, PROVIDED_CONFIGURATION_NAME),
-        c -> c.setDescription("'Provided' API dependencies for all packaged artifacts."));
 
     PackagingExtensionInternal packaging = (PackagingExtensionInternal) project.getExtensions().create(PackagingExtension.class, "packaging", PackagingExtensionInternal.class);
     packaging.getDefaultPackage().create();
     packaging.getVariants().all(PackageInternal::create);
 
+    configurations.named(DEFAULT_CONFIGURATION).configure(c -> c.extendsFrom(configurations.getByName(RUNTIME_ELEMENTS_CONFIGURATION_NAME)));
+
     project.getPlugins().withType(MavenPublishPlugin.class).configureEach(plugin -> {
       project.getExtensions().configure(PublishingExtension.class, publishing -> {
-        publishing.getPublications().register("mavenJava", MavenPublication.class, mavenPublication -> {
-          mavenPublication.from(javaComponent);
+        publishing.getPublications().register("mavenPackage", MavenPublication.class, mavenPublication -> {
+          mavenPublication.from(component.get());
         });
       });
     });
   }
 
   public static void augmentAttributeSchema(AttributesSchema schema) {
-    schema.attribute(Usage.USAGE_ATTRIBUTE, strategy -> strategy.getCompatibilityRules().add(UnpackagedJavaRuntimeCompatibility.class));
+    schema.attribute(Usage.USAGE_ATTRIBUTE, strategy -> strategy.getCompatibilityRules().add(ExplodedJavaRuntimeCompatibility.class));
   }
 
-  public static class UnpackagedJavaRuntimeCompatibility implements AttributeCompatibilityRule<Usage> {
+  @SuppressWarnings("deprecation")
+  public static class ExplodedJavaRuntimeCompatibility implements AttributeCompatibilityRule<Usage> {
 
     @Override
     public void execute(CompatibilityCheckDetails<Usage> details) {
-      Usage consumer = details.getConsumerValue();
+      Usage consumerValue = details.getConsumerValue();
+      Usage producerValue = details.getProducerValue();
+
+      if (consumerValue == null) {
+        details.compatible();
+        return;
+      }
 
-      if (consumer != null && UNPACKAGED_JAVA_RUNTIME.equals(consumer.getName())) {
-        Usage producer = details.getProducerValue();
-        if (producer != null) {
-          switch (producer.getName()) {
-            case Usage.JAVA_RUNTIME:
+      if (producerValue != null && EXPLODED_JAVA_RUNTIME.equals(consumerValue.getName())) {
+        switch (producerValue.getName()) {
+          case Usage.JAVA_RUNTIME:
             case JavaEcosystemSupport.DEPRECATED_JAVA_RUNTIME_JARS:
-              details.compatible();
-              break;
-          }
+            details.compatible();
+            break;
         }
       }
     }

diff --git a/src/main/java/org/terracotta/build/plugins/VoltronPlugin.java b/src/main/java/org/terracotta/build/plugins/VoltronPlugin.java
@@ -4,8 +4,10 @@
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.DependencyScopeConfiguration;
 import org.gradle.api.artifacts.ModuleDependency;
 import org.gradle.api.artifacts.ProjectDependency;
+import org.gradle.api.artifacts.ResolvableConfiguration;
 import org.gradle.api.artifacts.dsl.DependencyFactory;
 import org.gradle.api.capabilities.Capability;
 import org.gradle.api.file.FileCollection;
@@ -44,6 +46,7 @@ public class VoltronPlugin implements Plugin<Project> {
   public static final String XML_CONFIG_VARIANT_NAME = "xml";
   public static final String VOLTRON_CONFIGURATION_NAME = "voltron";
   public static final String SERVICE_CONFIGURATION_NAME = "service";
+  private static final String PROVIDED_CLASSPATH_CONFIGURATION_NAME = "providedClasspath";
 
   @Override
   public void apply(Project project) {
@@ -67,16 +70,12 @@ public void apply(Project project) {
       });
     });
 
-    NamedDomainObjectProvider<Configuration> voltron = project.getConfigurations().register(VOLTRON_CONFIGURATION_NAME, config -> {
-      config.setDescription("Dependencies provided by the platform Kit, either from server/lib or from plugins/api");
-      config.setCanBeResolved(true);
-      config.setCanBeConsumed(true);
-    });
-    NamedDomainObjectProvider<Configuration> service = project.getConfigurations().register(SERVICE_CONFIGURATION_NAME, config -> {
-      config.setDescription("Services consumed by this plugin");
-      config.setCanBeResolved(true);
-      config.setCanBeConsumed(true);
-    });
+    NamedDomainObjectProvider<DependencyScopeConfiguration> voltron = project.getConfigurations().dependencyScope(VOLTRON_CONFIGURATION_NAME,
+        c -> c.setDescription("Dependencies provided by the platform Kit, either from server/lib or from plugins/api"));
+    NamedDomainObjectProvider<DependencyScopeConfiguration> service = project.getConfigurations().dependencyScope(SERVICE_CONFIGURATION_NAME,
+        c -> c.setDescription("Services consumed by this plugin"));
+    NamedDomainObjectProvider<ResolvableConfiguration> providedClasspath = project.getConfigurations().resolvable(PROVIDED_CLASSPATH_CONFIGURATION_NAME, c -> c.extendsFrom(voltron.get(), service.get()));
+
     project.getConfigurations().named(JavaPlugin.API_CONFIGURATION_NAME, config -> config.extendsFrom(service.get()));
     project.getConfigurations().named(JavaPlugin.COMPILE_ONLY_CONFIGURATION_NAME, config -> config.extendsFrom(voltron.get()));
     project.getConfigurations().named(JavaPlugin.TEST_IMPLEMENTATION_CONFIGURATION_NAME, config -> config.extendsFrom(voltron.get()));
@@ -85,10 +84,9 @@ public void apply(Project project) {
       NamedDomainObjectProvider<Configuration> runtimeClasspath = project.getConfigurations().named(RUNTIME_CLASSPATH_CONFIGURATION_NAME);
 
       jar.getInputs().property(RUNTIME_CLASSPATH_CONFIGURATION_NAME, runtimeClasspath.flatMap(c -> c.getElements().map(e -> e.stream().map(f -> f.getAsFile().getName()).collect(toSet()))));
-      jar.getInputs().property(SERVICE_CONFIGURATION_NAME, service.flatMap(c -> c.getElements().map(e -> e.stream().map(f -> f.getAsFile().getName()).collect(toSet()))));
-      jar.getInputs().property(VOLTRON_CONFIGURATION_NAME, voltron.flatMap(c -> c.getElements().map(e -> e.stream().map(f -> f.getAsFile().getName()).collect(toSet()))));
+      jar.getInputs().property(PROVIDED_CLASSPATH_CONFIGURATION_NAME, providedClasspath.flatMap(c -> c.getElements().map(e -> e.stream().map(f -> f.getAsFile().getName()).collect(toSet()))));
 
-      Provider<String> voltronClasspath = runtimeClasspath.zip(service.zip(voltron, FileCollection::plus), FileCollection::minus)
+      Provider<String> voltronClasspath = runtimeClasspath.zip(providedClasspath, FileCollection::minus)
               .map(c -> c.getFiles().stream().map(File::getName).collect(joining(" ")));
       jar.manifest(manifest -> manifest.attributes(mapOf(Attributes.Name.CLASS_PATH.toString(), voltronClasspath)));
     });

diff --git a/src/main/java/org/terracotta/build/plugins/docker/DockerBuildPlugin.java b/src/main/java/org/terracotta/build/plugins/docker/DockerBuildPlugin.java
@@ -173,14 +173,11 @@ public void apply(Project project) {
       purge.getArguments().add("--force");
     });
 
-    project.getConfigurations().register("outgoingDocker", config -> {
-      config.setDescription("Built Docker image-id files.");
-      config.setCanBeConsumed(true);
-      config.setCanBeResolved(false);
-      config.setVisible(false);
-      config.attributes(attrs -> attrs.attribute(Category.CATEGORY_ATTRIBUTE, project.getObjects().named(Category.class, DOCKER_IMAGE_ID)));
-      config.outgoing(outgoing -> outgoing.artifact(dockerBuild));
-    });
+    project.getConfigurations().consumable("outgoingDocker", c -> c
+        .setDescription("Built Docker image-id files.")
+        .attributes(attrs -> attrs.attribute(Category.CATEGORY_ATTRIBUTE, project.getObjects().named(Category.class, DOCKER_IMAGE_ID)))
+        .outgoing(outgoing -> outgoing.artifact(dockerBuild))
+    );
 
     project.getPlugins().withType(CopyrightPlugin.class).configureEach(plugin ->
             ((ExtensionAware) buildExtension).getExtensions().add("copyright", plugin.createCopyrightSet(project, "docker", copyright -> {

diff --git a/src/main/java/org/terracotta/build/plugins/docker/DockerEcosystemPlugin.java b/src/main/java/org/terracotta/build/plugins/docker/DockerEcosystemPlugin.java
@@ -4,34 +4,32 @@
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.DependencyScopeConfiguration;
+import org.gradle.api.artifacts.ResolvableConfiguration;
+import org.gradle.api.artifacts.ResolvableDependencies;
 import org.gradle.api.attributes.Category;
 import org.gradle.api.provider.Provider;
 
 import java.util.Map;
 
 import static java.util.stream.Collectors.toMap;
 
+@SuppressWarnings("UnstableApiUsage")
 public class DockerEcosystemPlugin implements Plugin<Project> {
 
   public static final String DOCKER_IMAGE_ID = "docker-image";
 
   @Override
   public void apply(Project project) {
-    NamedDomainObjectProvider<Configuration> dockerBucket = project.getConfigurations().register("docker", config -> {
-      config.setDescription("Docker image dependencies.");
-      config.setCanBeConsumed(false);
-      config.setCanBeResolved(false);
-      config.setVisible(false);
+    NamedDomainObjectProvider<DependencyScopeConfiguration> dockerBucket = project.getConfigurations().dependencyScope("docker", c -> {
+      c.setDescription("Docker image dependencies.");
     });
 
-    NamedDomainObjectProvider<Configuration> dockerImageIds = project.getConfigurations().register("dockerImageIds", config -> {
-      config.setDescription("Incoming docker image-id files.");
-      config.setCanBeConsumed(false);
-      config.setCanBeResolved(true);
-      config.setVisible(false);
-      config.extendsFrom(dockerBucket.get());
-      config.attributes(attrs -> attrs.attribute(Category.CATEGORY_ATTRIBUTE, project.getObjects().named(Category.class, DOCKER_IMAGE_ID)));
-    });
+    NamedDomainObjectProvider<ResolvableConfiguration> dockerImageIds = project.getConfigurations().resolvable("dockerImageIds", c -> c
+        .setDescription("Incoming docker image-id files.")
+        .extendsFrom(dockerBucket.get())
+        .attributes(attrs -> attrs.attribute(Category.CATEGORY_ATTRIBUTE, project.getObjects().named(Category.class, DOCKER_IMAGE_ID)))
+    );
 
     project.getExtensions().create("docker", DockerExtension.class, dockerImageIds);
   }
@@ -40,7 +38,7 @@ public static class DockerExtension {
 
     private final Images images;
 
-    public DockerExtension(Provider<Configuration> imageIdConfiguration) {
+    public DockerExtension(Provider<ResolvableConfiguration> imageIdConfiguration) {
       this.images = new Images(imageIdConfiguration);
     }
 
@@ -53,7 +51,7 @@ public static class Images {
 
     private final Provider<Map<String, String>> images;
 
-    public Images(Provider<Configuration> imageIdConfiguration) {
+    public Images(Provider<ResolvableConfiguration> imageIdConfiguration) {
       this.images = imageIdConfiguration.flatMap(c -> c.getElements().map(files -> files.stream().collect(
               toMap(a -> a.getAsFile().getName().replaceAll("\\.iid$", ""), DockerBuild::readImageId))));
     }

diff --git a/src/main/java/org/terracotta/build/plugins/packaging/CustomCapabilities.java b/src/main/java/org/terracotta/build/plugins/packaging/CustomCapabilities.java
@@ -1,11 +1,24 @@
 package org.terracotta.build.plugins.packaging;
 
 import org.gradle.api.DomainObjectSet;
+import org.gradle.api.artifacts.ModuleDependencyCapabilitiesHandler;
 import org.gradle.api.capabilities.Capability;
+import org.gradle.api.plugins.JavaPluginExtension;
 
 public interface CustomCapabilities {
 
+  /**
+   * The capabilities of this package/variant.
+   *
+   * @return the capability set
+   */
   DomainObjectSet<Capability> getCapabilities();
 
+  /**
+   * Declares a capability for this package/variant.
+   *
+   * @param notation capability notation
+   * @see ModuleDependencyCapabilitiesHandler
+   */
   void capability(Object notation);
 }