Dependency Task Not Executing Correctly

[oldvarion]

Current Behavior

I'm facing an issue where a task intended to depend on another task's completion is not behaving as expected. The dependent task seems to run before the dependency is finished.

tasks.withType<RunWithPlugins> {
        val bootstrapDependencies = extension.bootstrapDependencies
        if (bootstrapDependencies.isEmpty()) {
            return@withType
        }

        pluginJars(provider {
            val jarFiles = bootstrapDependencies.flatMap { dependency ->
                val possibleNames = listOf(
                    ":${dependency.name}:${dependency.name}-paper",
                    ":${dependency.name}-paper",
                    ":${dependency.name}"
                )

                val targetProject = possibleNames.asSequence()
                    .mapNotNull { project.findProject(it) }
                    .firstOrNull() ?: throw GradleException("No valid project found for dependency ${dependency.name}")

                val filesProvider = provider {
                    val files = targetProject.layout.projectDirectory.dir("build/libs").asFileTree.files

                    var matchingFiles: List<File> = files.filter { file: File ->
                        file.nameWithoutExtension.contains(project.version.toString()) &&
                                file.nameWithoutExtension.contains("all")
                    }

                    if (matchingFiles.isEmpty()) {

                        dependsOn(targetProject.tasks.getByName("build"))

                        matchingFiles = files.filter { file: File ->
                            println("Processing file: ${file.name}")
                            file.nameWithoutExtension.contains(project.version.toString())
                        }
                    }

                    if (matchingFiles.isEmpty()) {
                        throw GradleException("Could not find any matching files for dependency ${dependency.name}")
                    }

                    matchingFiles.maxByOrNull { file: File -> file.readBytes().size } ?: throw GradleException("Failed to find the largest matching file for dependency ${dependency.name}")
                }

                listOf(filesProvider.get())
            }

            if (jarFiles.isEmpty()) {
                throw IllegalStateException("Could not resolve any dependencies in local project")
            }

            jarFiles
        })
    }

Expected Behavior

The dependent task should only start after the dependency task has successfully completed.

Context (optional)

No response

Steps to Reproduce

Create a Gradle project with two tasks: buildDependency and dependentTask.
Configure dependentTask to depend on buildDependency using dependsOn.
Execute dependentTask.

Gradle version

8.10

Build scan URL (optional)

No response

Your Environment (optional)

where? buildSrc script
where does RunWithPlugins belong? https://github.com/jpenilla/run-task

[ljacomet]

We appreciate the effort, but we must ask for more information so that we can triage it.

We do not see an immediate root cause, and we need a minimal reproducible example for the triage. If we have a reproducer, we may be able also to suggest workarounds or ways to avoid the problem.

The ideal way to provide a reproducer is to leverage our reproducer template. You can also use Gradle Project Replicator to reproduce the structure of your project.

This issue will be closed after 7 days unless you provide more information.

[oldvarion]

1. Create a script containing some task that already exists make it dependsOn("build") in buildSrc.
2. Make a new module using that script and run the task and see if the "build" task which depend is on will execute

[oldvarion]

1. Create a script containing some task that already exists make it dependsOn("build") in buildSrc.
2. Make a new module using that script and run the task and see if the "build" task which depend is on will execute

and also make sure that the task stuff is done in afterEvaluate block

[ghale]

Your instructions are a little unclear. It would be better if you provided a reproducer in the form of a project that demonstrates the behavior. Task dependencies are well tested in Gradle, so it's likely that if there is an issue here, it's due to a very specific set of circumstances.

[github-actions]

We previously asked for a reproducer, and unfortunately, none was provided. If you provide a valid reproducer, we may revisit this issue. In the meantime, this issue will be closed as unreproducible.