first working version of compiler daemon

- reworked based on the fact that our worker process infrastructure is asynchronous

subprojects/plugins/src/main/groovy/org/gradle/api/internal/tasks/compile/daemon/CompilerDaemon.java

@@ -16,7 +16,11 @@
 package org.gradle.api.internal.tasks.compile.daemon;
 
 import org.gradle.api.internal.tasks.compile.Compiler;
+import org.gradle.internal.Stoppable;
 
-public interface CompilerDaemon {
+/**
+ * A service that executes compilers in a (potentially) long-lived process.
+ */
+public interface CompilerDaemon extends Stoppable {
     CompileResult execute(Compiler compiler);
 }

subprojects/plugins/src/main/groovy/org/gradle/api/internal/tasks/compile/daemon/CompilerDaemonClient.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2011 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.gradle.api.internal.tasks.compile.daemon;
+
+import org.gradle.api.internal.tasks.compile.Compiler;
+import org.gradle.internal.UncheckedException;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.SynchronousQueue;
+
+public class CompilerDaemonClient implements CompilerDaemon, CompilerDaemonClientProtocol {
+    private final CompilerDaemonServerProtocol server;
+    private final BlockingQueue<CompileResult> compileResults = new SynchronousQueue<CompileResult>();
+
+    public CompilerDaemonClient(CompilerDaemonServerProtocol server) {
+        this.server = server;
+    }
+
+    public CompileResult execute(Compiler compiler) {
+        server.execute(compiler);
+        try {
+            return compileResults.take();
+        } catch (InterruptedException e) {
+            throw UncheckedException.asUncheckedException(e);
+        }
+    }
+
+    public void stop() {
+        server.stop();
+    }
+
+    public void executed(CompileResult result) {
+        try {
+            compileResults.put(result);
+        } catch (InterruptedException e) {
+            throw UncheckedException.asUncheckedException(e);
+        }
+    }
+}

subprojects/plugins/src/main/groovy/org/gradle/api/internal/tasks/compile/daemon/CompilerDaemonClientProtocol.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2011 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.gradle.api.internal.tasks.compile.daemon;
+
+/**
+ * Client part of the compiler daemon protocol. Used to report back compilation results.
+ */
+public interface CompilerDaemonClientProtocol {
+    void executed(CompileResult result);
+}

subprojects/plugins/src/main/groovy/org/gradle/api/internal/tasks/compile/daemon/CompilerDaemonManager.java

@@ -20,61 +20,62 @@
 import org.gradle.api.internal.project.ProjectInternal;
 import org.gradle.api.logging.Logger;
 import org.gradle.api.logging.Logging;
-import org.gradle.internal.Stoppable;
 import org.gradle.process.internal.JavaExecHandleBuilder;
 import org.gradle.process.internal.WorkerProcess;
 import org.gradle.process.internal.WorkerProcessBuilder;
 import org.gradle.util.Jvm;
 
 import java.io.File;
 
-public class CompilerDaemonManager implements Stoppable {
+/**
+ * Controls the lifecycle of the compiler daemon and provides access to it.
+ */
+public class CompilerDaemonManager {
     private static final Logger LOGGER = Logging.getLogger(CompilerDaemonManager.class);
     private static final CompilerDaemonManager INSTANCE = new CompilerDaemonManager();
 
-    private DefaultCompilerDaemon daemon;
+    private volatile CompilerDaemonClient client;
     private WorkerProcess process;
 
     public static CompilerDaemonManager getInstance() {
         return INSTANCE;
     }
 
     public CompilerDaemon getDaemon(ProjectInternal project) {
-        if (daemon == null) {
+        if (client == null) {
             startDaemon(project);
-            registerShutdownListener(project);
+            stopDaemonOnceBuildFinished(project);
         }
-        return daemon;
-    }
-
-    public void stop() {
-        System.out.println("Stopping Gradle compiler daemon.");
-        process.waitForStop();
-        System.out.println("Gradle compiler daemon stopped.");
+        return client;
     }
 
     private void startDaemon(ProjectInternal project) {
-        System.out.println("Starting Gradle compiler daemon.");
+        LOGGER.info("Starting Gradle compiler daemon.");
         WorkerProcessBuilder builder = project.getServices().getFactory(WorkerProcessBuilder.class).create();
+        builder.setLogLevel(project.getGradle().getStartParameter().getLogLevel()); // TODO: respect per-compile-task log level
         File toolsJar = Jvm.current().getToolsJar();
         if (toolsJar != null) {
             builder.getApplicationClasspath().add(toolsJar); // for SunJavaCompiler
         }
         JavaExecHandleBuilder javaCommand = builder.getJavaCommand();
-        javaCommand.setMinHeapSize("128m");
+        javaCommand.setMinHeapSize("128m"); // TODO: add extension object on Gradle for configuring daemon
         javaCommand.setMaxHeapSize("1g");
         javaCommand.setWorkingDir(project.getRootProject().getProjectDir());
-        daemon = new DefaultCompilerDaemon();
-        process = builder.worker(daemon).build();
+        process = builder.worker(new CompilerDaemonServer()).build();
         process.start();
-        System.out.println("Gradle compiler daemon started.");
+        CompilerDaemonServerProtocol server = process.getConnection().addOutgoing(CompilerDaemonServerProtocol.class);
+        client = new CompilerDaemonClient(server);
+        process.getConnection().addIncoming(CompilerDaemonClientProtocol.class, client);
+        LOGGER.info("Gradle compiler daemon started.");
     }
 
-    private void registerShutdownListener(ProjectInternal project) {
+    private void stopDaemonOnceBuildFinished(ProjectInternal project) {
         project.getGradle().addBuildListener(new BuildAdapter() {
             @Override
             public void buildFinished(BuildResult result) {
-                stop();
+                client.stop();
+                client = null;
+                process.waitForStop();
             }
         });
     }

subprojects/plugins/src/main/groovy/org/gradle/api/internal/tasks/compile/daemon/CompilerDaemonServer.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2011 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.gradle.api.internal.tasks.compile.daemon;
+
+import org.gradle.api.Action;
+import org.gradle.api.internal.tasks.compile.Compiler;
+import org.gradle.api.logging.Logger;
+import org.gradle.api.logging.Logging;
+import org.gradle.api.tasks.WorkResult;
+import org.gradle.internal.UncheckedException;
+import org.gradle.process.internal.WorkerProcessContext;
+
+import java.io.Serializable;
+import java.util.concurrent.CountDownLatch;
+
+
+public class CompilerDaemonServer implements Action<WorkerProcessContext>, CompilerDaemonServerProtocol, Serializable {
+    private static final Logger LOGGER = Logging.getLogger(CompilerDaemonServer.class);
+
+    private volatile CompilerDaemonClientProtocol client;
+    private volatile CountDownLatch stop;
+
+    public void execute(WorkerProcessContext context) {
+        client = context.getServerConnection().addOutgoing(CompilerDaemonClientProtocol.class);
+        stop = new CountDownLatch(1);
+        context.getServerConnection().addIncoming(CompilerDaemonServerProtocol.class, this);
+        try {
+            stop.await();
+        } catch (InterruptedException e) {
+            throw UncheckedException.asUncheckedException(e);
+        }
+
+    }
+
+    public void execute(Compiler compiler) {
+        try {
+            LOGGER.info("Executing {}.", compiler);
+            WorkResult result = compiler.execute();
+            LOGGER.info("Successfully executed {}.", compiler);
+            client.executed(new CompileResult(result.getDidWork(), null));
+        } catch (Throwable t) {
+            LOGGER.info("Exception executing {}: {}.", compiler, t);
+            client.executed(new CompileResult(true, t));
+        }
+    }
+
+    public void stop() {
+        stop.countDown();
+    }
+}

subprojects/plugins/src/main/groovy/org/gradle/api/internal/tasks/compile/daemon/DefaultCompilerDaemon.java → subprojects/plugins/src/main/groovy/org/gradle/api/internal/tasks/compile/daemon/CompilerDaemonServerProtocol.java

@@ -15,24 +15,12 @@
  */
 package org.gradle.api.internal.tasks.compile.daemon;
 
-import org.gradle.api.Action;
 import org.gradle.api.internal.tasks.compile.Compiler;
-import org.gradle.api.tasks.WorkResult;
-import org.gradle.process.internal.WorkerProcessContext;
+import org.gradle.internal.Stoppable;
 
-import java.io.Serializable;
-
-public class DefaultCompilerDaemon implements Action<WorkerProcessContext>, CompilerDaemon, Serializable {
-    public void execute(WorkerProcessContext context) {
-        context.getServerConnection().addIncoming(CompilerDaemon.class, this);
-    }
-
-    public CompileResult execute(Compiler compiler) {
-        try {
-            WorkResult result = compiler.execute();
-            return new CompileResult(result.getDidWork(), null);
-        } catch (Throwable t) {
-            return new CompileResult(true, t);
-        }
-    }
+/**
+ * Server part of the compiler daemon protocol. Used to submit compilation jobs.
+ */
+public interface CompilerDaemonServerProtocol extends Stoppable {
+    void execute(Compiler compiler);
 }

subprojects/plugins/src/main/groovy/org/gradle/api/internal/tasks/compile/daemon/DaemonJavaCompiler.java

@@ -18,10 +18,14 @@
 import org.gradle.api.internal.project.ProjectInternal;
 import org.gradle.api.internal.tasks.compile.JavaCompiler;
 import org.gradle.api.internal.tasks.compile.JavaCompilerSupport;
+import org.gradle.api.logging.Logger;
+import org.gradle.api.logging.Logging;
 import org.gradle.api.tasks.WorkResult;
 import org.gradle.internal.UncheckedException;
 
 public class DaemonJavaCompiler extends JavaCompilerSupport {
+    private static final Logger LOGGER = Logging.getLogger(DaemonJavaCompiler.class);
+
     private final ProjectInternal project;
     private final JavaCompiler delegate;
 
@@ -34,7 +38,7 @@ public WorkResult execute() {
         configure(delegate);
         CompilerDaemon daemon = CompilerDaemonManager.getInstance().getDaemon(project);
         CompileResult result = daemon.execute(delegate);
-        if (result.isSuccess()) {
+        if (result.isSuccess() || !compileOptions.isFailOnError()) {
             return result;
         }
         throw UncheckedException.asUncheckedException(result.getException());