Existe-t-il un moyen de répertorier les dépendances de tâches dans Gradle?

./gradle tasksliste «certaines» des tâches. En regardant http://gradle.org/docs/current/userguide/java_plugin.html, il y en a cachés qui ne sont pas répertoriés. De plus, d'autres plugins n'auront pas un si joli graphique des dépendances entre les tâches.

Y a-t-il un moyen de

1. lister toutes les tâches dans tous les plugins avec gradle
2. lister les tâches et les tâches dont elles dépendent (un peu comme celles des maven dependency:treemais pour les tâches)

vous pouvez utiliser l'indicateur --all pour obtenir une liste plus détaillée des tâches disponibles et des dépendances des tâches

gradle tasks --all

EDIT: comme indiqué par Radim dans les commentaires, cette commande ne signale pas les dépendances, pour gradle 3.3 et plus récent (voir https://docs.gradle.org/3.3/release-notes.html#improved-performance-of-tasks- rapport ).

lister les tâches et les tâches dont elles dépendent (un peu comme la dépendance de maven: arbre mais pour les tâches)

pour cela, vous pouvez utiliser --dry-run(ou -m) l'option qui répertorie les tâches qui sont exécutées dans l'ordre pour une commande particulière, mais n'exécute pas la commande, par exemple

gradle assemble --dry-run

vous pouvez en trouver plus ici

Vous pouvez essayer le plugin com.dorongold.task-tree avec une utilisation simple:

gradle <task 1>...<task N> taskTree

Exemple de résultat du readme :

gradle build taskTree

:build
+--- :assemble
|    \--- :jar
|         \--- :classes
|              +--- :compileJava
|              \--- :processResources
\--- :check
     \--- :test
          +--- :classes
          |    +--- :compileJava
          |    \--- :processResources
          \--- :testClasses
               +--- :compileTestJava
               |    \--- :classes
               |         +--- :compileJava
               |         \--- :processResources
               \--- :processTestResources

Vous pouvez coller ceci dans votre build.gradle:

gradle.taskGraph.whenReady {taskGraph ->
    println "Found task graph: " + taskGraph
    println "Found " + taskGraph.allTasks.size() + " tasks."
    taskGraph.allTasks.forEach { task ->
        println task
        task.dependsOn.forEach { dep ->
            println "  - " + dep
        }
    }
}

ou ceci dans votre build.gradle.kts:

gradle.taskGraph.whenReady(closureOf<TaskExecutionGraph> {
    println("Found task graph: $this")
    println("Found " + allTasks.size + " tasks.")
    allTasks.forEach { task ->
        println(task)
        task.dependsOn.forEach { dep ->
            println("  - $dep")
        }
    }
})

Ensuite, exécutez votre tâche avec gradle:

./gradlew build

Et vous devriez voir ceci:

Found task graph: org.gradle.execution.taskgraph.DefaultTaskGraphExecuter@36eb780c
Found 19 tasks.
task ':compileJava'
  - task 'compileJava' input files
task ':compileScala'
  - task 'compileScala' input files
  - compileJava
task ':processResources'
  - task 'processResources' input files
task ':classes'
  - org.gradle.api.internal.tasks.DefaultTaskDependency@287a7782
  - task 'classes' input files
  - compileJava
  - dirs
  - compileScala
  - processResources
task ':jar'
  - task 'jar' input files
task ':assemble'
  - task 'assemble' input files
  - org.gradle.api.internal.artifacts.DefaultPublishArtifactSet$ArtifactsTaskDependency@5bad9616
task ':compileTestJava'
    - task 'compileTestJava' input files
task ':compileTestScala'
  - task 'compileTestScala' input files
  - compileTestJava
task ':processTestResources'
  - task 'processTestResources' input files
task ':testClasses'
  - processTestResources
  - task 'testClasses' input files
  - compileTestScala
  - org.gradle.api.internal.tasks.DefaultTaskDependency@42c1fa08
  - compileTestJava
  - dirs
task ':compileIntegrationTestJava'
  - task 'compileIntegrationTestJava' input files
task ':compileIntegrationTestScala'
  - task 'compileIntegrationTestScala' input files
  - compileIntegrationTestJava
task ':processIntegrationTestResources'
  - task 'processIntegrationTestResources' input files
task ':integrationTestClasses'
  - processIntegrationTestResources
  - compileIntegrationTestJava
  - org.gradle.api.internal.tasks.DefaultTaskDependency@7c8aa0fe
  - compileIntegrationTestScala
  - dirs
  - task 'integrationTestClasses' input files
task ':composeUp'
  - task 'composeUp' input files
task ':integrationTest'
  - task ':composeUp'
  - task 'integrationTest' input files
task ':test'
  - task 'test' input files
task ':check'
  - task 'check' input files
  - task ':test'
  - task ':integrationTest'
task ':build'
  - task 'build' input files
  - check
  - assemble

L'arborescence des tâches gradle peut être visualisée par gradle tasks --all ou essayez les plugins suivants:

Graphiques Gradle et Talaiot: Regardez ceci: https://proandroiddev.com/graphs-gradle-and-talaiot-b0c02c50d2b1 blog car il répertorie graphiquement les tâches et les dépendances. Cela utilise l' outil gratuit Graphviz ouvert Gephi ( https://gephi.org/features/ )

gradle-task-tree : https://github.com/dorongold/gradle-task-tree et

gradle-visteg : https://github.com/mmalohlava/gradle-visteg

1. Plug- in gradle-visteg : Le fichier généré peut être post-traité via l' utilitaire Graphviz dot .

2. Par exemple , une image png est produite comme suit:

   cd build/reports/; dot -Tpng ./visteg.dot -o ./visteg.dot.png

Pour plus d'informations, veuillez visiter la page d'accueil de Graphviz .

Quelles que soient les tâches réellement utilisées pour exécuter une tâche (par exemple:) buildpeuvent être visualisées dans une belle page HTML en utilisant l' --profileoption

gradle --profile clean build

Une fois cette opération terminée, accédez au dossier build / reports / profile et parcourez le fichier .html. Vous verrez la résolution des dépendances et d'autres informations avec le temps nécessaire dans une belle page html.

Vous pouvez accéder par programme au graphique de tâches pour l'inspecter dans le script de construction à l'aide de Gradle.getTaskGraph ()

Au fur et à mesure que votre multiprojet grandit, la solution que j'ai marquée comme correcte devient un peu désagréable et difficile à lire

gradle tasks --all

Au lieu de cela, je suis passé à l'examen d'un projet spécifique, ce qui facilite grandement

gradlew :full-httpproxy:tasks --all

où 'full-httpproxy' est le nom de mon projet (et répertoire comme d'habitude).

Cependant, je suis curieux de savoir comment répertorier les tâches du projet maître / racine et j'ai également une question en suspens ici.

Comment lister toutes les tâches du projet maître uniquement dans Gradle?

car cela ne semble pas possible pour le moment.

Vous pouvez également ajouter le plugin suivant pour votre environnement local build.gradle, https://github.com/dorongold/gradle-task-tree

Suite à la réponse de cstroe, ce qui suit imprime également les fichiers d'entrée et de sortie de chaque tâche Gradle. Ceci est utile car les dépendances sont parfois définies par des relations d'entrée / sortie. Par exemple, si la tâche B utilise les sorties de la tâche A, la réponse de cstroe ne vous montrera pas la dépendance. Ce qui suit est très primitif, mais affiche la liste des fichiers d'entrée et de sortie pour chaque tâche:

gradle.taskGraph.whenReady {taskGraph ->
    println "Found task graph: " + taskGraph
    println "Found " + taskGraph.allTasks.size() + " tasks."
    taskGraph.allTasks.forEach { task ->
        println()
        println("----- " + task + " -----")
        println("depends on tasks: " + task.dependsOn)
        println("inputs: ")
        task.inputs.getFiles().getFiles().collect { f -> println(" - " + f)}
        println("outputs: ")
        task.outputs.getFiles().getFiles().collect { f -> println(" + " + f)}
    }
}