Cross project configuration and dependencies under Gradle 8

I am having trouble following the guidelines and best practices related to cross-project artifact sharing combined with needing more explicit dependencies.

I have a root project with sub-projects setup and am sharing artifacts (jar) from one sub-project to a jar task in the root project level. Achieving this via strategy described in Gradle doc here has always worked. The producer updates a consumable configuration with the task that makes the jar.
The consumer maps that configuration into its own resolvable configuration.
Then the consumer creates its own jar, referencing in a from its configuration that points to the producer.
This has all worked well, until recent upgrade to Gradle 8.
Now I get the error about the dependency between the root jar task, that uses the root consumable configuration, thereby needing the jar task of the sub-project to be more explicit.

Reason: Task ':jarApp' uses this output of task
 ':webApp:warStatic' without declaring an explicit 
or implicit dependency. This can lead to incorrect
 results being produced, depending on what order 
the tasks are executed.

I was expecting the configuration style reference to also imply a valid task depdendency. Apparently it does not.

What is the proper way to get a cross-project artifact scenario like described in the documentation example to also satisfy Gradle 8’s rule about more explicit task dependencies?

Thanks for any assistance you can provide

If Gradle 8 complains, it was most likely already incorrect in previous versions and just worked by luck. Gradle 8 just added recognition and warning of such problems.

If you did the setup correctly, the task dependency should indeed be there implicitly, as any explicit task dependency (unless a lifecycle task is on the right-hand side) is a code smell.

Can you share more details about your setup, especially how you set up the producer?
Maybe you can share an MCVE?

You are right, it never really worked right :smile:.
I just got :shamrock: lucky that the artifacts got built before I needed them to.
If they exist they are included, if not there is no dependency so they aren’t built nor included.

Basically my setup is as follows…

Producer sub-project

// create the war artifact
val warStaticTask = tasks.register<War>("warStatic") {  

// add war artifact task to consumable configuration    
var artConfig = configurations.create("published") 
artConfig.isCanBeConsumed = true  
artConfig.isCanBeResolved = false  
project.artifacts {  
  add(, warStaticTask)  

I also tried adding warStaticTask.get(), didn’t seem to make any difference.

Consumer root project

// Gather the published artifacts in a resolvable configuration  
val allPublishedArtifacts: Configuration by configurations.creating  
// wait until all the projects have been evaluated and set up their own  
// published configurations, so we can collect them here  
gradle.projectsEvaluated {  
  dependencies {  
    allprojects.forEach { p ->  
      val projectPublishedArtifacts = p.configurations.findByName("published")  
      if (projectPublishedArtifacts != null)  
        allPublishedArtifacts(project(mapOf("path" to p.path, "configuration" to "published")))

// create uber-jar of all sub-project artifacts
val jarAppTask = tasks.register<Jar>("jarApp") {  


when I run jarApp task, if the static war is already built, then it gets included in the uber-jar. If it does not exist then it does not and I get the message

file or directory '***/webApp/build/libs/static.war', not found

So I guess the artifact reference is there, since it does get included if it exists, but isn’t a proper task reference, so it is never setup as a dependency.

Any hints you can provide would be appreciated.

Thanks again.

Seems to be related to this…

If I just put the mapping directly in the root project like this it seems to work

dependencies {
  allPublishedArtifacts(project(mapOf("path" to ":webApp", "configuration" to PUBLISHED_ARTIFACTS)))

But I was trying to not hardcode all the sub-project references. If I remove the projectsEvaluated handler then the configuration is null for every sub-project (presumably because it hasn’t been configured yet).
But if I leave the projectsEvaluated, then it does find the configurations, but mapping them into the local resolvable configuration seems to break the dependency linking.

By using that “dynamic logic”, you actually totally destroy the proper publishing you tried to use by again going directly to the project model of the other projects. No wonder that this does not work properly. :smiley:

Declare a dependency on all the projects and then use a lenient artifact view to only get the ones actually existing and not fail due to dependencies on non-existing artifacts.

By “declaring a dependency” and “lenient artifact view” did you mean something like this

dependencies {
  allPublishedArtifacts(project(mapOf("path" to ":webApp", "configuration" to PUBLISHED_ARTIFACTS)))

Or something else/more?

No, that’s explicitly listing which you didn’t want.
Depend on all exisiting ones, whether they provide the artifact or not and then use a lenient artifact view to get the ones that actually exist.

Ok, so in the (root project) consumer I’m trying to follow what you suggest.
Is this a bit closer?

// Gather the published artifacts configuration of all sub-projects into the
// resolvable collection configurations here in the root project.
// We then reference that below when building the aggregate erapp.jar
val artifactConfigurationNames = mutableListOf(

// create the collecting resolvable configuration here in the root project
artifactConfigurationNames.forEach { acn ->
  val collectingName = acn + "All"
  val cfg = configurations.create(collectingName)
  cfg.isCanBeConsumed = false
  cfg.isCanBeResolved = true

// for each publish config, collect contents from each subproject
// regardless of if the subproject has the configuration or not
subprojects.forEach { p ->
  artifactConfigurationNames.forEach { acn ->
    val collectingName = acn + "All"
    val collectingConfig = configurations[collectingName]
    dependencies {
      collectingConfig(project(mapOf("path" to, "configuration" to acn)))

// create lenient views of the collecting configurations that will
// not fail if a project doesn't have them
val publishedArtifactsAllView =
        .artifactView { isLenient = true }
val publishedDependencyArtifactsAllView =
        .artifactView { isLenient = true }
val publishedSourceArtifactsAllView =
        .artifactView { isLenient = true }

then the jar task in root project that uses them

val jarAppTask = tasks.register<Jar>("jarApp") {

On the right track?
Any other tips or suggestions?

Thanks again for all the help.

I’m on mobile right now, but yes, that looks better I think, if it works. :slight_smile: I was not sure actually, whether it works with the “simple” way or only with the full-fledged attributes way. :smiley: