I'm trying to figure out why, when declaring configurations and artifacts to be consumed in one sub-project, and consuming those artifacts in another project as dependencies, the tasks for the producing project are not being executed first. When executing

./gradlew build

the build task for the consuming project will saying that the zip file can't be find, (since it hasn't been created yet). What am I missing? Producing Project (A project with

java-application

applied named "Dummy")

configurations {
		appDistribution {
			canBeConsumed = true
			canBeResolved = false
		}
	}

	artifacts {
		appDistribution(distZip)
	}

Consuming Project:

configurations {
	bundledApps {
		canBeConsumed = false
		canBeResolved = true
	}
}

dependencies {
	bundledApps(project(path: ":Dummy", configuration: 'appDistribution'))
}

configurations.bundledApps.each { file -> 
	distributions.main.contents {
		from(zipTree(file)) {
			into "tools"
		}
	}
}

try using

configurations.bundledApps.incoming.artifactFiles

to get the incoming files (or something similar - I often get muddled with area of Gradle)

@Adam Thanks for the tip. I was unfamiliar with that. I'm still getting the same error after using that method

configurations.bundledApps.incoming.files.each { file -> 
	distributions.main.contents {
		from(zipTree(file)) {
			into "tools"
		}
	}
}

possibly using

each {}

means Gradle loses the task dependency. Try using

incoming.resolvedArtifacts

(or something like that, you want one that returns a

Provider<>

), and you can unzip the files in a

map {}

, then pass the result into the distributions contents something like this:

distributions.main.contents {
  from(configurations.bundledApps.incoming.resolvedArtifacts.map { files -> ... }) {
    into "tools"
  }
}

Or maybe better, use an artifact transform to do the unzipping.

@Adam I suspect you're onto something. I included this in the first

distributions

declaration and it builds in correct order

from(configurations.bundledApps.singleFile){ into "tools" }

The unzipping is even on of the examples in the documentation

@Adam Digging into this a bit more seems to be revealing that

zipTree

is what's breaking task order resolution. The consuming task knows where the file should be based upon the output of that task. But Gradle is not executing that task first.

Use an artifact transform and it will work 😉

Do you have a suggestion for a built-in to do the unzipping?

Here a Kotlin variant with optionally stripping the top-level directory:

abstract class Unzip : TransformAction<Parameters> {
    @get:Inject
    protected abstract val fileSystem: FileSystemOperations

    @get:Inject
    protected abstract val archive: ArchiveOperations

    @get:InputArtifact
    abstract val inputArtifact: Provider<FileSystemLocation>

    override fun transform(outputs: TransformOutputs) {
        val input = inputArtifact.get().asFile
        val output = outputs.dir(input.name)
        fileSystem.sync {
            from(archive.zipTree(input))
            into(output)
            if (parameters.stripTopLevelDirectory.getOrElse(false)) {
                eachFile {
                    val segments = relativePath.segments
                    relativePath = RelativePath(
                        relativePath.isFile,
                        *segments.sliceArray(1 until segments.size)
                    )
                }
            }
        }
    }

    interface Parameters : TransformParameters {
        @get:Optional
        @get:Input
        val stripTopLevelDirectory: Property<Boolean>
    }
}

Awesome. Thanks!