Is er een manier om taakafhankelijkheden in Gradle op te sommen?

./gradle tasksgeeft een lijst van “sommige” taken. Kijken naar
http://gradle.org/docs/current/userguide/java_plugin.htmler zijn verborgen die niet worden vermeld. Ook zullen andere plug-ins niet zo’n mooie, mooie grafiek hebben van de afhankelijkheden tussen taken.

Is er een manier om

1. lijst alle taken in alle plug-ins met gradle
2. maak een lijst van de taken en van welke taken ze afhankelijk zijn (een beetje zoals maven’s dependency:treemaar voor taken)

Antwoord 1, autoriteit 100%

maak een lijst van de taken en van welke taken ze afhankelijk zijn (een beetje zoals die van maven
depenceny:tree maar voor taken)

hiervoor kunt u de optie --dry-run(of -m) gebruiken die een lijst geeft van taken die worden uitgevoerd in volgorde voor een bepaalde opdracht, maar de commando, bijv.

gradle assemble --dry-run

meer hier

Antwoord 2, autoriteit 55%

Vóór Gradle 3.3 kon je de vlag --allgebruiken om een ​​meer gedetailleerde lijst te krijgen van de beschikbare taken en de taakafhankelijkheden:

gradle tasks --all

De afhankelijkheidsrapportage is vanaf Gradle 3.3 om prestatieredenen uit deze taak verwijderd. Deze wijziging en de grondgedachte zijn gedocumenteerd in de Gradle 3.3 release-opmerkingen.

Antwoord 3, autoriteit 33%

Je kunt de plug-in com.dorongold.task-treeproberen met eenvoudig gebruik:

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

Voorbeeldresultaat van de readme:

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

Antwoord 4, autoriteit 23%

Je kunt dit in je build.gradleplakken:

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
        }
    }
}

of dit in uw 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")
        }
    }
})

Voer vervolgens uw taak uit met gradle:

./gradlew build

En je zou dit moeten zien:

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

Antwoord 5, autoriteit 8%

gradle-takenboom kan worden gevisualiseerd door gradle tasks --allofprobeer de volgende plug-ins:

Grafieken Gradle en Talaiot:
Kijk hier eens naar: https://proandroiddev.com/graphs-gradle-and-talaiot- b0c02c50d2b1blog omdat het de taken en afhankelijkheden grafisch weergeeft. Dit maakt gebruik van de gratisopen Graphviz-tool Gephi(https://gephi .org/features/)

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

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

1. gradle-vistegplug-in: het gegenereerde bestand kan worden nabewerkt via Graphvizdothulpprogramma.

2. Bijvoorbeeldwordt een png-afbeelding als volgt geproduceerd:

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

Ga voor meer informatie naar de Graphviz-startpagina.

Alle taken die daadwerkelijk worden gebruikt om een ​​taak uit te voeren (bijvoorbeeld: build) kunnen worden bekeken op een mooie HTML-pagina met de optie --profile

gradle –profileclean build

Zodra dit is voltooid, gaat u naar de map build/reports/profile en bladert u door het .html-bestand. Je zult de oplossing van afhankelijkheden en andere informatie na verloop van tijd zien op een mooie html-pagina.

Antwoord 6, autoriteit 7%

Hier is een nieuwe plug-in voor:

plugins {
    id 'org.barfuin.gradle.taskinfo' version '1.0.1'
}

Vervolgens kun je typen:

./gradlew tiTree assemble

en krijg zoiets als dit:

:assemble                             (org.gradle.api.DefaultTask)
+--- :jar                             (org.gradle.api.tasks.bundling.Jar)
|    `--- :classes                    (org.gradle.api.DefaultTask)
|         +--- :compileJava           (org.gradle.api.tasks.compile.JavaCompile)
|         `--- :processResources      (org.gradle.language.jvm.tasks.ProcessResources)
+--- :javadocJar                      (org.gradle.api.tasks.bundling.Jar)
|    `--- :javadoc                    (org.gradle.api.tasks.javadoc.Javadoc)
|         `--- :classes               (org.gradle.api.DefaultTask)
|              +--- :compileJava      (org.gradle.api.tasks.compile.JavaCompile)
|              `--- :processResources (org.gradle.language.jvm.tasks.ProcessResources)
`--- :sourcesJar                      (org.gradle.api.tasks.bundling.Jar)

De plug-in kan ook de volgorde weergeven waarin taken worden uitgevoerd:

In order to execute task ':assemble', the following tasks would be executed in this order:
  1. :compileJava      (org.gradle.api.tasks.compile.JavaCompile)
  2. :processResources (org.gradle.language.jvm.tasks.ProcessResources)
  3. :classes          (org.gradle.api.DefaultTask)
  4. :jar              (org.gradle.api.tasks.bundling.Jar)
  5. :javadoc          (org.gradle.api.tasks.javadoc.Javadoc)
  6. :javadocJar       (org.gradle.api.tasks.bundling.Jar)
  7. :sourcesJar       (org.gradle.api.tasks.bundling.Jar)
  8. :assemble         (org.gradle.api.DefaultTask)

Meer info in de documentatie van de plug-in.
Volledige openbaarmaking: ik ben de auteur van gradle-taskinfo.

Antwoord 7, autoriteit 4%

U kunt programmatisch toegang krijgen tot de taakgrafiek om deze in het buildscript te inspecteren met Gradle.getTaskGraph()

Antwoord 8, autoriteit 2%

Naarmate uw multiproject groeit, wordt de oplossing die ik als correct heb gemarkeerd een beetje onhandig en moeilijk leesbaar

gradle tasks --all

In plaats daarvan ben ik overgestapt op het kijken naar een specifiek project, waardoor het veel gemakkelijker is

gradlew :full-httpproxy:tasks --all

waarbij ‘full-httpproxy’ de naam is van mijn project (en directory zoals gebruikelijk).

Ik ben echter benieuwd hoe ik taken op het master/root-project kan vermelden en heb hier ook een openstaande vraag

Alle taken weergeven voor het masterproject alleen in gradle?

omdat dat op dit moment niet mogelijk lijkt.

Antwoord 9, autoriteit 2%

Volgend op het antwoord van cstroe, drukt het volgende ook de invoer- en uitvoerbestanden van elke Gradle-taak af. Dit is handig omdat afhankelijkheden soms worden gedefinieerd door input/output-relaties. D.w.z. als taak B de uitvoer van taak A gebruikt, zal het antwoord van cstroe u de afhankelijkheid niet laten zien. Het volgende is erg primitief, maar toont wel de lijst met invoer- en uitvoerbestanden voor elke taak:

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)}
    }
}

Antwoord 10

Je kunt ook de volgende plug-in toevoegen voor je lokale omgeving build.gradle, https:// github.com/dorongold/gradle-task-tree

Antwoord 11

Als plug-ins niet voor u werken, kunt u deze kern gebruiken in uw build.gradle

https://gist.github.com/jrodbx/046b66618c558ca9002a825629d59cde