die gleiche Aufgabe in mehrere Male während der Ausführung Lauf gradle

Question

Ist es möglich,

task enableMe() << { 
    println "Enable" 
} 
task disableMe() << { 
    shouldRunAfter 'taskAwork' 
    println "Disable" 
} 

task taskAwork(){ 
    shouldRunAfter 'enableMe' 
    println "do work in A while disabled" 
} 
task taskA(dependsOn: disableMe, taskAwork, enableMe){ 
} 
task taskBwork(){ 
    shouldRunAfter 'enableMe' 
    println "do work in B while disabled" 
} 
task taskB(dependsOn: disableMe, taskBwork, enableMe){ 
} 

task taskC(dependsOn: taskA, taskB){ 
} 

So etwas wie die folgende in gradle zu haben, dass, wenn sie die Aufgaben läuft in der Reihenfolge ausgeführt werden

disableMe 
taskAwork 
enableMe 
disableMe 
taskBwork 
enableMe 

aber zur Zeit werden disableMe und enableMe nur einmal ausgeführt. Ist es trotzdem dort um den Status zu setzen, damit sie wieder laufen können.

Der einzige Weg, wie ich dies tun kann, ist, die Aufgaben zu duplizieren;

task enableMeA() << { 
    println "Enable" 
} 
task disableMeA() << { 
    shouldRunAfter 'taskAwork' 
    println "Disable" 
} 
task enableMeB() << { 
    println "Enable" 
} 
task disableMeB() << { 
    shouldRunAfter 'taskBwork' 
    println "Disable" 
} 

task taskAwork(){ 
    shouldRunAfter 'enableMeA' 
    println "do work in A while disabled" 
} 
task taskA(dependsOn: disableMeA, taskAwork, enableMeA){ 
} 
task taskBwork(){ 
    shouldRunAfter 'enableMeB' 
    println "do work in B while disabled" 
} 
task taskB(dependsOn: disableMeB, taskBwork, enableMeB){ 
} 

task taskC(dependsOn: taskA, taskB){ 
} 

Answer 1

Scheint In Ihrem Fall müssen Sie TaskExecutionListener für Ihre Aufgabe implementieren und die Methoden beforeExecute und afterExecute verwenden, um Ihre Logik zu implementieren.

Dies könnte etwa so aussehen:

task taskAwork() << { 
    println "do work in A while disabled" 
} 
task taskBwork() << { 
    println "do work in B while disabled" 
} 

task doAllWorkTask(dependsOn: [taskAwork, taskBwork]){ 
} 

gradle.taskGraph.addTaskExecutionListener new WorkTasksExecutionListener() 

class WorkTasksExecutionListener implements TaskExecutionListener { 

    @Override 
    void afterExecute(final Task task, final TaskState state) { 
     if (task.name.contains('work')) { 
      println('Enabling smth before execution of work task') 
     } 
    } 

    @Override 
    void beforeExecute(final Task task) { 
     if (task.name.contains('work')) { 
      println('Disabling smth after execution of work task') 
     } 
    } 
} 

Hier zwei Aufgaben angegeben, die etwas tun und erfordert einige gemeinsame loigic ausgeführt werden vor und nach jedem. Um diese gemeinsame Logik zu implementieren, verwendet WorkTasksExecutionListener implementieren TaskExecutionListener Schnittstelle und registriert als ein Listener in der taskGraph.

WorkTasksExecutionListener implementiert 2 Methoden der TaskExecutionListener: beforeExecute und afterExecute. Diese Methoden werden vor und nach jeder tsk-Ausführung aufgerufen, also wurde in ihrer Implementierung die Bedingung hinzugefügt, um zu prüfen, ob die Aufgabe etwas funktioniert und wenn ja, dann wird eine zusätzliche Logik ausgeführt.

Ausgabe in diesem Fall wird sein:

:taskAwork 
Enabling smth after execution of work task 
do work in A while disabled 
Disabling smth before execution of work task 
:taskBwork 
Enabling smth after execution of work task 
do work in B while disabled 
Disabling smth before execution of work task 
:doAllWorkTask 

Answer 2

Gradle, standardmäßig wird keine Aufgabe ausgeführt, die auf dem neuesten Stand ist. Aufgabe wird als aktuell betrachtet, wenn die Eigenschaft TaskOutputs nicht geändert wurde.

Wenn Sie eine Aufgabe mehrmals während der gleichen Ausführung ausführen möchten, können Sie upToDateWhen Eigenschaft verwenden, um ein Prädikat zu definieren, die falsch zurückkehren wird, wenn Sie die Aufgabe erneut ausgeführt werden soll:

task myTask() { 
    outputs.upToDateWhen {some_condition} 

    // Do some stuff 
}