Esegui attività JavaExec in background e termina al completamento della build

Question

Sto cercando di capire come avviare un'attività JavaExec che genera un server Jetty senza bloccare le attività successive. Inoltre, avrò bisogno di terminare questo server al termine della compilazione. Qualche idea su come posso fare questo?

Answer 1

Spero che questo frammento possa darti un'idea di come può essere fatto.

È possibile utilizzare le chiusure di listener per eseguire il codice all'avvio/finitura della build. Tuttavia, per qualche motivo, la chiusura gradle.buildStarted non funziona in milestone-3, quindi l'ho sostituita con gradle.taskGraph.whenReady che fa il trucco.

quindi è possibile chiamare il compito runJetty utilizzando Task#execute() (Nota, questa API non è ufficiale e può scomparire), e inoltre, eseguirlo da un ExecutorService per ottenere qualche comportamento asincrono.

import java.util.concurrent.* 

task myTask << { 
    println "Do usual tasks here" 
} 

task runJetty << { 
    print "Pretend we are running Jetty ..." 
    while(!stopJetty){ 
    Thread.sleep(100) 
    } 
    println "Jetty Stopped." 
} 

stopJetty = false 
es = Executors.newSingleThreadExecutor() 
jettyFuture = null 

//gradle.buildStarted { ... } 
gradle.taskGraph.whenReady { g -> 
    jettyFuture = es.submit({ runJetty.execute() } as Callable) 
} 

gradle.buildFinished { 
    println "Stopping Jetty ... " 
    stopJetty = true 

    //This is optional. Could be useful when debugging. 
    try{ 
    jettyFuture?.get() 
    }catch(ExecutionException e){ 
    println "Error during Jetty execution: " 
    e.printStackTrace() 
    } 
} 

Answer 2

Non è possibile farlo con JavaExec; dovrai scrivere il tuo compito.

Answer 3

So che il filo è dal 2011, ma ho ancora imbattuto nel problema. Quindi, ecco una soluzione di lavoro con Gradle 2.14:

import java.util.concurrent.Callable 
import java.util.concurrent.ExecutorService 
import java.util.concurrent.Executors  

class RunAsyncTask extends DefaultTask { 
    String taskToExecute = '<YourTask>' 
    @TaskAction 
    def startAsync() { 
     ExecutorService es = Executors.newSingleThreadExecutor() 
     es.submit({taskToExecute.execute()} as Callable) 
    } 
} 


task runRegistry(type: RunAsyncTask, dependsOn: build){ 
    taskToExecute = '<NameOfYourTaskHere>' 
} 

Answer 4

Ho aggiornato la soluzione da @chrishuen perché non si può chiamare eseguire sul compito più. Qui funziona il mio build.gradle

import java.time.LocalDateTime 
import java.util.concurrent.Callable 
import java.util.concurrent.ExecutorService 
import java.util.concurrent.Executors 

group 'sk.bsmk' 
version '1.0-SNAPSHOT' 

apply plugin: 'java' 

task wrapper(type: Wrapper) { 
    gradleVersion = '3.4' 
} 

class RunAsyncTask extends DefaultTask { 
    @TaskAction 
    def startAsync() { 
    ExecutorService es = Executors.newSingleThreadExecutor() 
    es.submit({ 
     project.javaexec { 
     classpath = project.sourceSets.main.runtimeClasspath 
     main = "Main" 
     } 
    } as Callable) 

    } 
} 

task helloAsync(type: RunAsyncTask, dependsOn: compileJava) { 
    doLast { 
    println LocalDateTime.now().toString() + 'sleeping' 
    sleep(2 * 1000) 
    } 
}