From d714215efef13f8a082e38495e9544acfe6d3204 Mon Sep 17 00:00:00 2001 From: Dan Sanduleac Date: Wed, 12 Aug 2020 17:47:42 +0100 Subject: [PATCH 01/14] lock via platform --- .../gradle/versions/VersionsLockPlugin.java | 33 +++++++++++++++++-- 1 file changed, 30 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java index 0adc9d24..23d9f526 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java @@ -800,13 +800,40 @@ private static void configureAllProjectsUsingConstraints( gradleLockfile, rootProject.getDependencies().getConstraints()); List publishableConstraints = constructPublishableConstraintsFromLockFile( gradleLockfile, rootProject.getDependencies().getConstraints()); + + // Create platform in root project, holding the strictConstraints + ObjectFactory objectFactory = rootProject.getObjects(); + Usage gcvLocksUsage = objectFactory.named(Usage.class, "gcv-locks"); + String gcvLocksCapability = "gcv:locks:0"; + + rootProject.getConfigurations().create("gcvLocks", conf -> { + conf.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, gcvLocksUsage); + // conf.getAttributes() + // .attribute( + // Category.CATEGORY_ATTRIBUTE, + // objectFactory.named(Category.class, Category.REGULAR_PLATFORM)); + conf.getOutgoing().capability(gcvLocksCapability); + conf.setCanBeResolved(false); + conf.getDependencyConstraints().addAll(strictConstraints); + }); + + ProjectDependency locksDependency = + (ProjectDependency) rootProject.getDependencies().create(rootProject); + locksDependency.capabilities(moduleDependencyCapabilitiesHandler -> + moduleDependencyCapabilitiesHandler.requireCapabilities(gcvLocksCapability)); + locksDependency.attributes(attrs -> { + // attrs.attribute( + // Category.CATEGORY_ATTRIBUTE, objectFactory.named(Category.class, Category.REGULAR_PLATFORM)); + attrs.attribute(Usage.USAGE_ATTRIBUTE, gcvLocksUsage); + }); + rootProject.allprojects(subproject -> configureUsingConstraints( - subproject, strictConstraints, publishableConstraints, lockedConfigurations.get(subproject))); + subproject, locksDependency, publishableConstraints, lockedConfigurations.get(subproject))); } private static void configureUsingConstraints( Project subproject, - List lockConstraints, + ProjectDependency locksDependency, List publishableConstraints, LockedConfigurations lockedConfigurations) { Configuration locksConfiguration = subproject @@ -815,7 +842,7 @@ private static void configureUsingConstraints( locksConf.setVisible(false); locksConf.setCanBeConsumed(false); locksConf.setCanBeResolved(false); - lockConstraints.forEach(locksConf.getDependencyConstraints()::add); + locksConf.getDependencies().add(locksDependency); }); Set configurationsToLock = lockedConfigurations.allConfigurations(); From 746e371900155bc9329aa0a3bff342de113b8e52 Mon Sep 17 00:00:00 2001 From: Dan Sanduleac Date: Wed, 12 Aug 2020 19:19:48 +0100 Subject: [PATCH 02/14] fix - create configuration early --- .../gradle/versions/VersionsLockPlugin.java | 53 ++++++++++--------- 1 file changed, 28 insertions(+), 25 deletions(-) diff --git a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java index 23d9f526..d272e1cc 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java @@ -219,6 +219,26 @@ public final void apply(Project project) { // (but that's internal) project.getPluginManager().apply("java-base"); + // Create "platform" configuration in root project, which will hold the strictConstraints + ObjectFactory objectFactory = project.getObjects(); + Usage gcvLocksUsage = objectFactory.named(Usage.class, "gcv-locks"); + String gcvLocksCapability = "gcv:locks:0"; + + NamedDomainObjectProvider gcvLocksConfiguration = project.getConfigurations() + .register("gcvLocks", conf -> { + conf.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, gcvLocksUsage); + conf.getOutgoing().capability(gcvLocksCapability); + conf.setCanBeResolved(false); + }); + + ProjectDependency locksDependency = + (ProjectDependency) project.getDependencies().create(project); + locksDependency.capabilities(moduleDependencyCapabilitiesHandler -> + moduleDependencyCapabilitiesHandler.requireCapabilities(gcvLocksCapability)); + locksDependency.attributes(attrs -> { + attrs.attribute(Usage.USAGE_ATTRIBUTE, gcvLocksUsage); + }); + // afterEvaluate is necessary to ensure all projects' dependencies have been configured, because we // need to copy them eagerly before we add the constraints from the lock file. // @@ -265,7 +285,8 @@ public final void apply(Project project) { } } - configureAllProjectsUsingConstraints(project, rootLockfile, lockedConfigurations); + configureAllProjectsUsingConstraints( + project, rootLockfile, lockedConfigurations, gcvLocksConfiguration, locksDependency); }); TaskProvider verifyLocks = project.getTasks().register("verifyLocks", VerifyLocksTask.class, task -> { @@ -795,38 +816,20 @@ private String formatUnresolvedDependencyResult(UnresolvedDependencyResult resul } private static void configureAllProjectsUsingConstraints( - Project rootProject, Path gradleLockfile, Map lockedConfigurations) { + Project rootProject, + Path gradleLockfile, + Map lockedConfigurations, + NamedDomainObjectProvider gcvLocksConfiguration, + ProjectDependency locksDependency) { List strictConstraints = constructConstraintsFromLockFile( gradleLockfile, rootProject.getDependencies().getConstraints()); List publishableConstraints = constructPublishableConstraintsFromLockFile( gradleLockfile, rootProject.getDependencies().getConstraints()); - // Create platform in root project, holding the strictConstraints - ObjectFactory objectFactory = rootProject.getObjects(); - Usage gcvLocksUsage = objectFactory.named(Usage.class, "gcv-locks"); - String gcvLocksCapability = "gcv:locks:0"; - - rootProject.getConfigurations().create("gcvLocks", conf -> { - conf.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, gcvLocksUsage); - // conf.getAttributes() - // .attribute( - // Category.CATEGORY_ATTRIBUTE, - // objectFactory.named(Category.class, Category.REGULAR_PLATFORM)); - conf.getOutgoing().capability(gcvLocksCapability); - conf.setCanBeResolved(false); + gcvLocksConfiguration.configure(conf -> { conf.getDependencyConstraints().addAll(strictConstraints); }); - ProjectDependency locksDependency = - (ProjectDependency) rootProject.getDependencies().create(rootProject); - locksDependency.capabilities(moduleDependencyCapabilitiesHandler -> - moduleDependencyCapabilitiesHandler.requireCapabilities(gcvLocksCapability)); - locksDependency.attributes(attrs -> { - // attrs.attribute( - // Category.CATEGORY_ATTRIBUTE, objectFactory.named(Category.class, Category.REGULAR_PLATFORM)); - attrs.attribute(Usage.USAGE_ATTRIBUTE, gcvLocksUsage); - }); - rootProject.allprojects(subproject -> configureUsingConstraints( subproject, locksDependency, publishableConstraints, lockedConfigurations.get(subproject))); } From 0d7eaae3efeac86bbff9729b5ab5fe64b4222597 Mon Sep 17 00:00:00 2001 From: Dan Sanduleac Date: Wed, 12 Aug 2020 18:19:48 +0000 Subject: [PATCH 03/14] Add generated changelog entries --- changelog/@unreleased/pr-557.v2.yml | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 changelog/@unreleased/pr-557.v2.yml diff --git a/changelog/@unreleased/pr-557.v2.yml b/changelog/@unreleased/pr-557.v2.yml new file mode 100644 index 00000000..6990b86f --- /dev/null +++ b/changelog/@unreleased/pr-557.v2.yml @@ -0,0 +1,6 @@ +type: improvement +improvement: + description: Manage lock file constraints using a single gradle "platform", reducing + the number of constraints that have to be created. + links: + - https://github.com/palantir/gradle-consistent-versions/pull/557 From 273dd1c5116d41a4320b35ba23610a76817ac434 Mon Sep 17 00:00:00 2001 From: Dan Sanduleac Date: Wed, 12 Aug 2020 21:35:16 +0100 Subject: [PATCH 04/14] move some code more upfront --- .../gradle/versions/VersionsLockPlugin.java | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java index d272e1cc..a6b35695 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java @@ -229,6 +229,7 @@ public final void apply(Project project) { conf.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, gcvLocksUsage); conf.getOutgoing().capability(gcvLocksCapability); conf.setCanBeResolved(false); + conf.setVisible(false); }); ProjectDependency locksDependency = @@ -285,8 +286,14 @@ public final void apply(Project project) { } } - configureAllProjectsUsingConstraints( - project, rootLockfile, lockedConfigurations, gcvLocksConfiguration, locksDependency); + // Wire up the locks from the lock file into the strict locks platform. + gcvLocksConfiguration.configure(conf -> { + conf.getDependencyConstraints() + .addAll(constructConstraintsFromLockFile( + rootLockfile, project.getDependencies().getConstraints())); + }); + + configureAllProjectsUsingConstraints(project, rootLockfile, lockedConfigurations, locksDependency); }); TaskProvider verifyLocks = project.getTasks().register("verifyLocks", VerifyLocksTask.class, task -> { @@ -819,17 +826,11 @@ private static void configureAllProjectsUsingConstraints( Project rootProject, Path gradleLockfile, Map lockedConfigurations, - NamedDomainObjectProvider gcvLocksConfiguration, ProjectDependency locksDependency) { - List strictConstraints = constructConstraintsFromLockFile( - gradleLockfile, rootProject.getDependencies().getConstraints()); + List publishableConstraints = constructPublishableConstraintsFromLockFile( gradleLockfile, rootProject.getDependencies().getConstraints()); - gcvLocksConfiguration.configure(conf -> { - conf.getDependencyConstraints().addAll(strictConstraints); - }); - rootProject.allprojects(subproject -> configureUsingConstraints( subproject, locksDependency, publishableConstraints, lockedConfigurations.get(subproject))); } From 90b1ed9dd858d604f343f91c89fde9726a7359e9 Mon Sep 17 00:00:00 2001 From: Dan Sanduleac Date: Wed, 12 Aug 2020 22:29:55 +0100 Subject: [PATCH 05/14] VersionsPropsPlugin also defines constraints in a single configuration then uses that as a platform --- .../gradle/versions/VersionsPropsPlugin.java | 48 +++++++++++++++---- 1 file changed, 40 insertions(+), 8 deletions(-) diff --git a/src/main/java/com/palantir/gradle/versions/VersionsPropsPlugin.java b/src/main/java/com/palantir/gradle/versions/VersionsPropsPlugin.java index 2e9e71fa..e4b1c762 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsPropsPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsPropsPlugin.java @@ -35,9 +35,12 @@ import org.gradle.api.artifacts.DependencySet; import org.gradle.api.artifacts.ExternalDependency; import org.gradle.api.artifacts.ModuleDependency; +import org.gradle.api.artifacts.ProjectDependency; import org.gradle.api.artifacts.dsl.DependencyConstraintHandler; +import org.gradle.api.attributes.Usage; import org.gradle.api.logging.Logger; import org.gradle.api.logging.Logging; +import org.gradle.api.model.ObjectFactory; import org.gradle.api.plugins.JavaPlugin; import org.gradle.api.provider.ListProperty; import org.gradle.api.provider.Provider; @@ -58,6 +61,15 @@ public class VersionsPropsPlugin implements Plugin { @Override public final void apply(Project project) { checkPreconditions(); + + // Shared across root project / other project + ObjectFactory objectFactory = project.getObjects(); + Usage gcvVersionsPropsUsage = objectFactory.named(Usage.class, "gcv-versions-props"); + String gcvVersionsPropsCapability = "gcv:versions-props:0"; + + VersionsProps versionsProps = loadVersionsProps( + project.getRootProject().file("versions.props").toPath()); + if (project.getRootProject().equals(project)) { applyToRootProject(project); @@ -71,29 +83,39 @@ public final void apply(Project project) { .set(project.getLayout().getProjectDirectory().file("versions.props")); }); project.getTasks().named("check").configure(task -> task.dependsOn(checkNoUnusedConstraints)); + + // Create "platform" configuration in root project, which will hold the versions props constraints + project.getConfigurations().register("gcvVersionsPropsConstraints", conf -> { + conf.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, gcvVersionsPropsUsage); + conf.getOutgoing().capability(gcvVersionsPropsCapability); + conf.setCanBeResolved(false); + conf.setCanBeConsumed(true); + conf.setVisible(false); + + // Note: don't add constraints to the ConstraintHandler, only call `create` / `platform` on it. + addVersionsPropsConstraints(project.getDependencies().getConstraints(), conf, versionsProps); + }); } VersionRecommendationsExtension extension = project.getRootProject().getExtensions().getByType(VersionRecommendationsExtension.class); - VersionsProps versionsProps = loadVersionsProps( - project.getRootProject().file("versions.props").toPath()); - NamedDomainObjectProvider rootConfiguration = project.getConfigurations() .register(ROOT_CONFIGURATION_NAME, conf -> { conf.setCanBeResolved(false); + conf.setCanBeConsumed(false); conf.setVisible(false); + + // Wire in the constraints from the main configuration. + conf.getDependencies() + .add(createDepOnRootConstraintsConfiguration( + project, gcvVersionsPropsUsage, gcvVersionsPropsCapability)); }); project.getConfigurations().configureEach(conf -> { setupConfiguration(project, extension, rootConfiguration.get(), versionsProps, conf); }); - // Note: don't add constraints to this, only call `create` / `platform` on it. - DependencyConstraintHandler constraintHandler = - project.getDependencies().getConstraints(); - rootConfiguration.configure(conf -> addVersionsPropsConstraints(constraintHandler, conf, versionsProps)); - log.info("Configuring rules to assign *-constraints to platforms in {}", project); project.getDependencies() .getComponents() @@ -103,10 +125,20 @@ public final void apply(Project project) { configureResolvedVersionsWithVersionMapping(project); } + private static ProjectDependency createDepOnRootConstraintsConfiguration( + Project project, Usage usage, String capability) { + ProjectDependency projectDep = + ((ProjectDependency) project.getDependencies().create(project.getRootProject())); + projectDep.capabilities(capabilities -> capabilities.requireCapability(capability)); + projectDep.attributes(attrs -> attrs.attribute(Usage.USAGE_ATTRIBUTE, usage)); + return projectDep; + } + private static void applyToRootProject(Project project) { project.getPluginManager().apply(LifecycleBasePlugin.class); project.getExtensions() .create(VersionRecommendationsExtension.EXTENSION, VersionRecommendationsExtension.class, project); + project.subprojects(subproject -> subproject.getPluginManager().apply(VersionsPropsPlugin.class)); } From 00f6c131310a91272745e0abc69f8ab9fb1407a6 Mon Sep 17 00:00:00 2001 From: Dan Sanduleac Date: Wed, 12 Aug 2020 22:44:04 +0100 Subject: [PATCH 06/14] consolidate on single usage --- .../gradle/versions/ConsistentVersionsPlugin.java | 2 ++ .../gradle/versions/VersionsLockPlugin.java | 15 ++++++--------- .../gradle/versions/VersionsPropsPlugin.java | 7 ++++--- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/main/java/com/palantir/gradle/versions/ConsistentVersionsPlugin.java b/src/main/java/com/palantir/gradle/versions/ConsistentVersionsPlugin.java index a88881ec..85d8a3c2 100644 --- a/src/main/java/com/palantir/gradle/versions/ConsistentVersionsPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/ConsistentVersionsPlugin.java @@ -21,6 +21,8 @@ import org.gradle.api.Project; public class ConsistentVersionsPlugin implements Plugin { + static final String CONSISTENT_VERSIONS_USAGE = "consistent-versions-usage"; + @Override public final void apply(Project project) { if (!project.getRootProject().equals(project)) { diff --git a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java index a6b35695..3441c347 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java @@ -115,6 +115,7 @@ public class VersionsLockPlugin implements Plugin { private static final Attribute GCV_USAGE_ATTRIBUTE = Attribute.of("com.palantir.consistent-versions.usage", GcvUsage.class); + private static final String GCV_LOCKS_CAPABILITY = "gcv:locks:0"; public enum GcvUsage implements Named { /** @@ -180,7 +181,7 @@ public String getName() { @Inject public VersionsLockPlugin(Gradle gradle, ObjectFactory objectFactory) { showStacktrace = gradle.getStartParameter().getShowStacktrace(); - internalUsage = objectFactory.named(Usage.class, "consistent-versions-usage"); + internalUsage = objectFactory.named(Usage.class, ConsistentVersionsPlugin.CONSISTENT_VERSIONS_USAGE); } static Path getRootLockFile(Project project) { @@ -220,14 +221,10 @@ public final void apply(Project project) { project.getPluginManager().apply("java-base"); // Create "platform" configuration in root project, which will hold the strictConstraints - ObjectFactory objectFactory = project.getObjects(); - Usage gcvLocksUsage = objectFactory.named(Usage.class, "gcv-locks"); - String gcvLocksCapability = "gcv:locks:0"; - NamedDomainObjectProvider gcvLocksConfiguration = project.getConfigurations() .register("gcvLocks", conf -> { - conf.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, gcvLocksUsage); - conf.getOutgoing().capability(gcvLocksCapability); + conf.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, internalUsage); + conf.getOutgoing().capability(GCV_LOCKS_CAPABILITY); conf.setCanBeResolved(false); conf.setVisible(false); }); @@ -235,9 +232,9 @@ public final void apply(Project project) { ProjectDependency locksDependency = (ProjectDependency) project.getDependencies().create(project); locksDependency.capabilities(moduleDependencyCapabilitiesHandler -> - moduleDependencyCapabilitiesHandler.requireCapabilities(gcvLocksCapability)); + moduleDependencyCapabilitiesHandler.requireCapabilities(GCV_LOCKS_CAPABILITY)); locksDependency.attributes(attrs -> { - attrs.attribute(Usage.USAGE_ATTRIBUTE, gcvLocksUsage); + attrs.attribute(Usage.USAGE_ATTRIBUTE, internalUsage); }); // afterEvaluate is necessary to ensure all projects' dependencies have been configured, because we diff --git a/src/main/java/com/palantir/gradle/versions/VersionsPropsPlugin.java b/src/main/java/com/palantir/gradle/versions/VersionsPropsPlugin.java index e4b1c762..c5ed544f 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsPropsPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsPropsPlugin.java @@ -40,7 +40,6 @@ import org.gradle.api.attributes.Usage; import org.gradle.api.logging.Logger; import org.gradle.api.logging.Logging; -import org.gradle.api.model.ObjectFactory; import org.gradle.api.plugins.JavaPlugin; import org.gradle.api.provider.ListProperty; import org.gradle.api.provider.Provider; @@ -63,8 +62,10 @@ public final void apply(Project project) { checkPreconditions(); // Shared across root project / other project - ObjectFactory objectFactory = project.getObjects(); - Usage gcvVersionsPropsUsage = objectFactory.named(Usage.class, "gcv-versions-props"); + // This must be usable during VersionsLockPlugin's resolution of unifiedClasspath, so the usage + // must be 'compatible with' (or the same as) the one for the VersionsLockPlugin's own configurations. + Usage gcvVersionsPropsUsage = + project.getObjects().named(Usage.class, ConsistentVersionsPlugin.CONSISTENT_VERSIONS_USAGE); String gcvVersionsPropsCapability = "gcv:versions-props:0"; VersionsProps versionsProps = loadVersionsProps( From c24cbd4b6b5c73ccd32784ca5e936eaff9e0d2e2 Mon Sep 17 00:00:00 2001 From: Dan Sanduleac Date: Wed, 12 Aug 2020 22:50:51 +0100 Subject: [PATCH 07/14] smooth things over with a compatibility rule --- .../gradle/versions/VersionsLockPlugin.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java index 3441c347..c98e5870 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java @@ -79,7 +79,9 @@ import org.gradle.api.artifacts.result.ResolvedComponentResult; import org.gradle.api.artifacts.result.UnresolvedDependencyResult; import org.gradle.api.attributes.Attribute; +import org.gradle.api.attributes.AttributeCompatibilityRule; import org.gradle.api.attributes.AttributesSchema; +import org.gradle.api.attributes.CompatibilityCheckDetails; import org.gradle.api.attributes.Usage; import org.gradle.api.invocation.Gradle; import org.gradle.api.logging.Logger; @@ -197,6 +199,9 @@ public final void apply(Project project) { AttributesSchema attributesSchema = p.getDependencies().getAttributesSchema(); attributesSchema.attribute(GCV_SCOPE_ATTRIBUTE); attributesSchema.attribute(GCV_USAGE_ATTRIBUTE); + attributesSchema.attribute(Usage.USAGE_ATTRIBUTE, strategy -> { + strategy.getCompatibilityRules().add(EverythingIsCompatibleWithConsistentVersionsUsage.class); + }); }); Configuration unifiedClasspath = project.getConfigurations() @@ -306,6 +311,20 @@ public final void apply(Project project) { }); } + static class EverythingIsCompatibleWithConsistentVersionsUsage implements AttributeCompatibilityRule { + @Override + public void execute(CompatibilityCheckDetails details) { + if (ConsistentVersionsPlugin.CONSISTENT_VERSIONS_USAGE.equals( + details.getProducerValue().getName()) + // This shouldn't be necessary, because we never resolve configurations with this usage. + // However, 5.3 tests fail without it + || ConsistentVersionsPlugin.CONSISTENT_VERSIONS_USAGE.equals( + details.getConsumerValue().getName())) { + details.compatible(); + } + } + } + static boolean isIgnoreLockFile(Project project) { return project.hasProperty("ignoreLockFile"); } From 20bac8bd480e1dbb2d0b6777e4fa23c8bee52d57 Mon Sep 17 00:00:00 2001 From: Dan Sanduleac Date: Thu, 13 Aug 2020 17:00:53 +0100 Subject: [PATCH 08/14] TEMPORARILY get rid of published constraints --- .../gradle/versions/VersionsLockPlugin.java | 23 ------------------- 1 file changed, 23 deletions(-) diff --git a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java index c98e5870..e9710617 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java @@ -88,7 +88,6 @@ import org.gradle.api.logging.Logging; import org.gradle.api.logging.configuration.ShowStacktrace; import org.gradle.api.model.ObjectFactory; -import org.gradle.api.plugins.JavaPlugin; import org.gradle.api.plugins.JavaPluginConvention; import org.gradle.api.provider.Property; import org.gradle.api.tasks.SourceSet; @@ -871,28 +870,6 @@ private static void configureUsingConstraints( conf.extendsFrom(locksConfiguration); VersionsLockPlugin.ensureNoFailOnVersionConflict(conf); }); - - NamedDomainObjectProvider publishConstraints = subproject - .getConfigurations() - .register("gcvPublishConstraints", conf -> { - conf.setDescription("Publishable constraints from the GCV versions.lock file"); - conf.setCanBeResolved(false); - conf.setCanBeConsumed(false); - conf.getDependencyConstraints().addAll(publishableConstraints); - }); - - // Enrich the configurations being published as part of the java component (components.java) - // with constraints generated from the lock file. - subproject.getPluginManager().withPlugin("java", _plugin -> { - subproject - .getConfigurations() - .named(JavaPlugin.API_ELEMENTS_CONFIGURATION_NAME) - .configure(conf -> conf.extendsFrom(publishConstraints.get())); - subproject - .getConfigurations() - .named(JavaPlugin.RUNTIME_ELEMENTS_CONFIGURATION_NAME) - .configure(conf -> conf.extendsFrom(publishConstraints.get())); - }); } private static LockedConfigurations computeConfigurationsToLock(Project project, VersionsLockExtension ext) { From 56e722584e738426083fc205adf4fa5fce443acc Mon Sep 17 00:00:00 2001 From: Carter Kozak Date: Thu, 13 Aug 2020 12:05:02 -0400 Subject: [PATCH 09/14] remove unused --- .../gradle/versions/VersionsLockPlugin.java | 30 +++---------------- 1 file changed, 4 insertions(+), 26 deletions(-) diff --git a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java index e9710617..297b85c5 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java @@ -839,22 +839,16 @@ private String formatUnresolvedDependencyResult(UnresolvedDependencyResult resul private static void configureAllProjectsUsingConstraints( Project rootProject, - Path gradleLockfile, + Path _gradleLockfile, Map lockedConfigurations, ProjectDependency locksDependency) { - List publishableConstraints = constructPublishableConstraintsFromLockFile( - gradleLockfile, rootProject.getDependencies().getConstraints()); - - rootProject.allprojects(subproject -> configureUsingConstraints( - subproject, locksDependency, publishableConstraints, lockedConfigurations.get(subproject))); + rootProject.allprojects(subproject -> + configureUsingConstraints(subproject, locksDependency, lockedConfigurations.get(subproject))); } private static void configureUsingConstraints( - Project subproject, - ProjectDependency locksDependency, - List publishableConstraints, - LockedConfigurations lockedConfigurations) { + Project subproject, ProjectDependency locksDependency, LockedConfigurations lockedConfigurations) { Configuration locksConfiguration = subproject .getConfigurations() .create(LOCK_CONSTRAINTS_CONFIGURATION_NAME, locksConf -> { @@ -952,20 +946,4 @@ private static List constructConstraintsFromLockFile( })) .collect(Collectors.toList()); } - - private static List constructPublishableConstraintsFromLockFile( - Path gradleLockfile, DependencyConstraintHandler constraintHandler) { - LockState lockState = new ConflictSafeLockFile(gradleLockfile).readLocks(); - // We only publish the production locks. - return lockState.productionLinesByModuleIdentifier().entrySet().stream() - .map(e -> e.getKey() + ":" + e.getValue().version()) - .map(notation -> constraintHandler.create(notation, constraint -> { - constraint.version(v -> { - String version = Objects.requireNonNull(constraint.getVersion()); - v.require(version); - }); - constraint.because("Computed from com.palantir.consistent-versions' versions.lock"); - })) - .collect(Collectors.toList()); - } } From 31c5e6ff24dfe500c98e34952bdd442fed054f8d Mon Sep 17 00:00:00 2001 From: Dan Sanduleac Date: Wed, 19 Aug 2020 16:54:27 +0100 Subject: [PATCH 10/14] Revert "remove unused" This reverts commit 56e722584e738426083fc205adf4fa5fce443acc. --- .../gradle/versions/VersionsLockPlugin.java | 30 ++++++++++++++++--- 1 file changed, 26 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java index 297b85c5..e9710617 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java @@ -839,16 +839,22 @@ private String formatUnresolvedDependencyResult(UnresolvedDependencyResult resul private static void configureAllProjectsUsingConstraints( Project rootProject, - Path _gradleLockfile, + Path gradleLockfile, Map lockedConfigurations, ProjectDependency locksDependency) { - rootProject.allprojects(subproject -> - configureUsingConstraints(subproject, locksDependency, lockedConfigurations.get(subproject))); + List publishableConstraints = constructPublishableConstraintsFromLockFile( + gradleLockfile, rootProject.getDependencies().getConstraints()); + + rootProject.allprojects(subproject -> configureUsingConstraints( + subproject, locksDependency, publishableConstraints, lockedConfigurations.get(subproject))); } private static void configureUsingConstraints( - Project subproject, ProjectDependency locksDependency, LockedConfigurations lockedConfigurations) { + Project subproject, + ProjectDependency locksDependency, + List publishableConstraints, + LockedConfigurations lockedConfigurations) { Configuration locksConfiguration = subproject .getConfigurations() .create(LOCK_CONSTRAINTS_CONFIGURATION_NAME, locksConf -> { @@ -946,4 +952,20 @@ private static List constructConstraintsFromLockFile( })) .collect(Collectors.toList()); } + + private static List constructPublishableConstraintsFromLockFile( + Path gradleLockfile, DependencyConstraintHandler constraintHandler) { + LockState lockState = new ConflictSafeLockFile(gradleLockfile).readLocks(); + // We only publish the production locks. + return lockState.productionLinesByModuleIdentifier().entrySet().stream() + .map(e -> e.getKey() + ":" + e.getValue().version()) + .map(notation -> constraintHandler.create(notation, constraint -> { + constraint.version(v -> { + String version = Objects.requireNonNull(constraint.getVersion()); + v.require(version); + }); + constraint.because("Computed from com.palantir.consistent-versions' versions.lock"); + })) + .collect(Collectors.toList()); + } } From c3ae86fa79823e4faa9f0d3b7bdca0d1025fe0fc Mon Sep 17 00:00:00 2001 From: Dan Sanduleac Date: Wed, 19 Aug 2020 16:54:28 +0100 Subject: [PATCH 11/14] Revert "TEMPORARILY get rid of published constraints" This reverts commit 20bac8bd480e1dbb2d0b6777e4fa23c8bee52d57. --- .../gradle/versions/VersionsLockPlugin.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java index e9710617..c98e5870 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java @@ -88,6 +88,7 @@ import org.gradle.api.logging.Logging; import org.gradle.api.logging.configuration.ShowStacktrace; import org.gradle.api.model.ObjectFactory; +import org.gradle.api.plugins.JavaPlugin; import org.gradle.api.plugins.JavaPluginConvention; import org.gradle.api.provider.Property; import org.gradle.api.tasks.SourceSet; @@ -870,6 +871,28 @@ private static void configureUsingConstraints( conf.extendsFrom(locksConfiguration); VersionsLockPlugin.ensureNoFailOnVersionConflict(conf); }); + + NamedDomainObjectProvider publishConstraints = subproject + .getConfigurations() + .register("gcvPublishConstraints", conf -> { + conf.setDescription("Publishable constraints from the GCV versions.lock file"); + conf.setCanBeResolved(false); + conf.setCanBeConsumed(false); + conf.getDependencyConstraints().addAll(publishableConstraints); + }); + + // Enrich the configurations being published as part of the java component (components.java) + // with constraints generated from the lock file. + subproject.getPluginManager().withPlugin("java", _plugin -> { + subproject + .getConfigurations() + .named(JavaPlugin.API_ELEMENTS_CONFIGURATION_NAME) + .configure(conf -> conf.extendsFrom(publishConstraints.get())); + subproject + .getConfigurations() + .named(JavaPlugin.RUNTIME_ELEMENTS_CONFIGURATION_NAME) + .configure(conf -> conf.extendsFrom(publishConstraints.get())); + }); } private static LockedConfigurations computeConfigurationsToLock(Project project, VersionsLockExtension ext) { From e489812bddf0d1df280bcf36ff32882740bad76b Mon Sep 17 00:00:00 2001 From: Dan Sanduleac Date: Fri, 21 Aug 2020 12:26:35 +0100 Subject: [PATCH 12/14] remove comment, use own interface that can only _create_ constraints --- .../versions/DependencyConstraintCreator.java | 24 +++++++++++++++++++ .../gradle/versions/VersionsProps.java | 7 +++--- .../gradle/versions/VersionsPropsPlugin.java | 8 +++---- 3 files changed, 30 insertions(+), 9 deletions(-) create mode 100644 src/main/java/com/palantir/gradle/versions/DependencyConstraintCreator.java diff --git a/src/main/java/com/palantir/gradle/versions/DependencyConstraintCreator.java b/src/main/java/com/palantir/gradle/versions/DependencyConstraintCreator.java new file mode 100644 index 00000000..b421b687 --- /dev/null +++ b/src/main/java/com/palantir/gradle/versions/DependencyConstraintCreator.java @@ -0,0 +1,24 @@ +/* + * (c) Copyright 2020 Palantir Technologies Inc. All rights reserved. + * + * 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.palantir.gradle.versions; + +import org.gradle.api.artifacts.DependencyConstraint; + +@FunctionalInterface +public interface DependencyConstraintCreator { + DependencyConstraint create(Object var1); +} diff --git a/src/main/java/com/palantir/gradle/versions/VersionsProps.java b/src/main/java/com/palantir/gradle/versions/VersionsProps.java index f9ac9f96..04d27c9c 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsProps.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsProps.java @@ -32,7 +32,6 @@ import java.util.stream.Stream; import org.gradle.api.artifacts.DependencyConstraint; import org.gradle.api.artifacts.ModuleIdentifier; -import org.gradle.api.artifacts.dsl.DependencyConstraintHandler; /** A {@code versions.props} file. */ public final class VersionsProps { @@ -95,15 +94,15 @@ static VersionsProps empty() { return new VersionsProps(FuzzyPatternResolver.builder().build()); } - public Stream constructConstraints(DependencyConstraintHandler handler) { + public Stream constructConstraints(DependencyConstraintCreator constraintCreator) { Map versions = fuzzyResolver.versions(); return Stream.concat( fuzzyResolver.exactMatches().stream() .map(key -> key + ":" + versions.get(key)) - .map(handler::create), + .map(constraintCreator::create), patternToPlatform.entrySet().stream() .map(entry -> entry.getValue() + ":" + versions.get(entry.getKey())) - .map(handler::create)); + .map(constraintCreator::create)); } /** diff --git a/src/main/java/com/palantir/gradle/versions/VersionsPropsPlugin.java b/src/main/java/com/palantir/gradle/versions/VersionsPropsPlugin.java index c5ed544f..29fb58b6 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsPropsPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsPropsPlugin.java @@ -36,7 +36,6 @@ import org.gradle.api.artifacts.ExternalDependency; import org.gradle.api.artifacts.ModuleDependency; import org.gradle.api.artifacts.ProjectDependency; -import org.gradle.api.artifacts.dsl.DependencyConstraintHandler; import org.gradle.api.attributes.Usage; import org.gradle.api.logging.Logger; import org.gradle.api.logging.Logging; @@ -93,8 +92,7 @@ public final void apply(Project project) { conf.setCanBeConsumed(true); conf.setVisible(false); - // Note: don't add constraints to the ConstraintHandler, only call `create` / `platform` on it. - addVersionsPropsConstraints(project.getDependencies().getConstraints(), conf, versionsProps); + addVersionsPropsConstraints(project.getDependencies().getConstraints()::create, conf, versionsProps); }); } @@ -286,9 +284,9 @@ private static void tryAssignComponentToPlatform(VersionsProps versionsProps, Co } private static void addVersionsPropsConstraints( - DependencyConstraintHandler constraintHandler, Configuration conf, VersionsProps versionsProps) { + DependencyConstraintCreator constraintCreator, Configuration conf, VersionsProps versionsProps) { ImmutableList constraints = - versionsProps.constructConstraints(constraintHandler).collect(ImmutableList.toImmutableList()); + versionsProps.constructConstraints(constraintCreator).collect(ImmutableList.toImmutableList()); log.info("Adding constraints to {}: {}", conf, constraints); constraints.forEach(conf.getDependencyConstraints()::add); } From a513092e95e7e4726e16b457e094973a5e32f89c Mon Sep 17 00:00:00 2001 From: Dan Sanduleac Date: Fri, 21 Aug 2020 12:30:54 +0100 Subject: [PATCH 13/14] Use DependencyConstraintCreator in VersionsLockPlugin too --- .../versions/DependencyConstraintCreator.java | 7 ++++++- .../gradle/versions/VersionsLockPlugin.java | 13 ++++++------- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/src/main/java/com/palantir/gradle/versions/DependencyConstraintCreator.java b/src/main/java/com/palantir/gradle/versions/DependencyConstraintCreator.java index b421b687..a763530e 100644 --- a/src/main/java/com/palantir/gradle/versions/DependencyConstraintCreator.java +++ b/src/main/java/com/palantir/gradle/versions/DependencyConstraintCreator.java @@ -16,9 +16,14 @@ package com.palantir.gradle.versions; +import org.gradle.api.Action; import org.gradle.api.artifacts.DependencyConstraint; @FunctionalInterface public interface DependencyConstraintCreator { - DependencyConstraint create(Object var1); + default DependencyConstraint create(Object notation) { + return create(notation, _constraint -> {}); + } + + DependencyConstraint create(Object notation, Action action); } diff --git a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java index c98e5870..6443759b 100644 --- a/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java +++ b/src/main/java/com/palantir/gradle/versions/VersionsLockPlugin.java @@ -74,7 +74,6 @@ import org.gradle.api.artifacts.component.ModuleComponentIdentifier; import org.gradle.api.artifacts.component.ModuleComponentSelector; import org.gradle.api.artifacts.component.ProjectComponentIdentifier; -import org.gradle.api.artifacts.dsl.DependencyConstraintHandler; import org.gradle.api.artifacts.result.ResolutionResult; import org.gradle.api.artifacts.result.ResolvedComponentResult; import org.gradle.api.artifacts.result.UnresolvedDependencyResult; @@ -292,7 +291,7 @@ public final void apply(Project project) { gcvLocksConfiguration.configure(conf -> { conf.getDependencyConstraints() .addAll(constructConstraintsFromLockFile( - rootLockfile, project.getDependencies().getConstraints())); + rootLockfile, project.getDependencies().getConstraints()::create)); }); configureAllProjectsUsingConstraints(project, rootLockfile, lockedConfigurations, locksDependency); @@ -845,7 +844,7 @@ private static void configureAllProjectsUsingConstraints( ProjectDependency locksDependency) { List publishableConstraints = constructPublishableConstraintsFromLockFile( - gradleLockfile, rootProject.getDependencies().getConstraints()); + gradleLockfile, rootProject.getDependencies().getConstraints()::create); rootProject.allprojects(subproject -> configureUsingConstraints( subproject, locksDependency, publishableConstraints, lockedConfigurations.get(subproject))); @@ -958,7 +957,7 @@ default ImmutableSet allConfigurations() { } private static List constructConstraintsFromLockFile( - Path gradleLockfile, DependencyConstraintHandler constraintHandler) { + Path gradleLockfile, DependencyConstraintCreator constraintCreator) { LockState lockState = new ConflictSafeLockFile(gradleLockfile).readLocks(); Stream> locks = Stream.concat( lockState.productionLinesByModuleIdentifier().entrySet().stream(), @@ -966,7 +965,7 @@ private static List constructConstraintsFromLockFile( return locks.map(e -> e.getKey() + ":" + e.getValue().version()) // Note: constraints.create sets the version as preferred + required, we want 'strictly' just like // gradle does when verifying a lock file. - .map(notation -> constraintHandler.create(notation, constraint -> { + .map(notation -> constraintCreator.create(notation, constraint -> { constraint.version(v -> { String version = Objects.requireNonNull(constraint.getVersion()); v.strictly(version); @@ -977,12 +976,12 @@ private static List constructConstraintsFromLockFile( } private static List constructPublishableConstraintsFromLockFile( - Path gradleLockfile, DependencyConstraintHandler constraintHandler) { + Path gradleLockfile, DependencyConstraintCreator constraintCreator) { LockState lockState = new ConflictSafeLockFile(gradleLockfile).readLocks(); // We only publish the production locks. return lockState.productionLinesByModuleIdentifier().entrySet().stream() .map(e -> e.getKey() + ":" + e.getValue().version()) - .map(notation -> constraintHandler.create(notation, constraint -> { + .map(notation -> constraintCreator.create(notation, constraint -> { constraint.version(v -> { String version = Objects.requireNonNull(constraint.getVersion()); v.require(version); From 7ff784f12d26718bf8e7e653d2db5a635abe080f Mon Sep 17 00:00:00 2001 From: Dan Sanduleac Date: Fri, 21 Aug 2020 12:31:05 +0100 Subject: [PATCH 14/14] make package private --- .../palantir/gradle/versions/DependencyConstraintCreator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/palantir/gradle/versions/DependencyConstraintCreator.java b/src/main/java/com/palantir/gradle/versions/DependencyConstraintCreator.java index a763530e..cef057e3 100644 --- a/src/main/java/com/palantir/gradle/versions/DependencyConstraintCreator.java +++ b/src/main/java/com/palantir/gradle/versions/DependencyConstraintCreator.java @@ -20,7 +20,7 @@ import org.gradle.api.artifacts.DependencyConstraint; @FunctionalInterface -public interface DependencyConstraintCreator { +interface DependencyConstraintCreator { default DependencyConstraint create(Object notation) { return create(notation, _constraint -> {}); }