Better progress reports

Author: Arthur McGibbon

model/src/main/java/com/microsoft/java/bs/gradle/model/GradleSourceSet.java

@@ -54,6 +54,16 @@ public interface GradleSourceSet extends Serializable {
    */
   public String getClassesTaskName();
 
+  /**
+   * The name of the clean task.
+   */
+  public String getCleanTaskName();
+
+  /**
+   * All the tasks relevant to compiling this source set.
+   */
+  public Set<String> getTaskNames();
+
   /**
    * The source directories of this source set.
    */

model/src/main/java/com/microsoft/java/bs/gradle/model/impl/DefaultGradleSourceSet.java

@@ -37,6 +37,10 @@ public class DefaultGradleSourceSet implements GradleSourceSet {
 
   private String classesTaskName;
 
+  private String cleanTaskName;
+
+  private Set<String> taskNames;
+
   private Set<File> sourceDirs;
 
   private Set<File> generatedSourceDirs;
@@ -73,6 +77,8 @@ public DefaultGradleSourceSet(GradleSourceSet gradleSourceSet) {
     this.rootDir = gradleSourceSet.getRootDir();
     this.sourceSetName = gradleSourceSet.getSourceSetName();
     this.classesTaskName = gradleSourceSet.getClassesTaskName();
+    this.cleanTaskName = gradleSourceSet.getCleanTaskName();
+    this.taskNames = gradleSourceSet.getTaskNames();
     this.sourceDirs = gradleSourceSet.getSourceDirs();
     this.generatedSourceDirs = gradleSourceSet.getGeneratedSourceDirs();
     this.sourceOutputDir = gradleSourceSet.getSourceOutputDir();
@@ -165,7 +171,22 @@ public void setClassesTaskName(String classesTaskName) {
     this.classesTaskName = classesTaskName;
   }
 
-  @Override
+  public String getCleanTaskName() {
+    return cleanTaskName;
+  }
+
+  public void setCleanTaskName(String cleanTaskName) {
+    this.cleanTaskName = cleanTaskName;
+  }
+
+  public void setTaskNames(Set<String> taskNames) {
+    this.taskNames = taskNames;
+  }
+
+  public Set<String> getTaskNames() {
+    return taskNames;
+  }
+
   public Set<File> getSourceDirs() {
     return sourceDirs;
   }
@@ -258,7 +279,7 @@ public void setExtensions(Map<String, LanguageExtension> extensions) {
   @Override
   public int hashCode() {
     return Objects.hash(gradleVersion, displayName, projectName, projectPath,
-        projectDir, rootDir, sourceSetName, classesTaskName, sourceDirs,
+        projectDir, rootDir, sourceSetName, classesTaskName, cleanTaskName, taskNames, sourceDirs,
         generatedSourceDirs, sourceOutputDir, resourceDirs, resourceOutputDir,
         compileClasspath, moduleDependencies, buildTargetDependencies,
         hasTests, extensions);
@@ -284,6 +305,8 @@ public boolean equals(Object obj) {
         && Objects.equals(rootDir, other.rootDir)
         && Objects.equals(sourceSetName, other.sourceSetName)
         && Objects.equals(classesTaskName, other.classesTaskName)
+        && Objects.equals(cleanTaskName, other.cleanTaskName)
+        && Objects.equals(taskNames, other.taskNames)
         && Objects.equals(sourceDirs, other.sourceDirs)
         && Objects.equals(generatedSourceDirs, other.generatedSourceDirs)
         && Objects.equals(sourceOutputDir, other.sourceOutputDir)

plugin/build.gradle

@@ -12,9 +12,7 @@ dependencies {
     transitive = false
   }
 
-  testImplementation 'org.gradle:gradle-tooling-api:8.1.1'
-  testImplementation(platform('org.junit:junit-bom:5.9.2'))
-  testImplementation 'org.junit.jupiter:junit-jupiter'
+  testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
 }
 
 java {

plugin/src/main/java/com/microsoft/java/bs/gradle/plugin/SourceSetsModelBuilder.java

@@ -14,6 +14,7 @@
 import java.util.Set;
 
 import org.gradle.api.Project;
+import org.gradle.api.Task;
 import org.gradle.api.file.CopySpec;
 import org.gradle.api.file.Directory;
 import org.gradle.api.file.FileCollection;
@@ -64,11 +65,20 @@ public Object buildAll(String modelName, Project rootProject) {
         cache.addProject(sourceSet, project);
         gradleSourceSet.setGradleVersion(project.getGradle().getGradleVersion());
         gradleSourceSet.setProjectName(project.getName());
-        gradleSourceSet.setProjectPath(project.getPath());
+        String projectPath = project.getPath();
+        gradleSourceSet.setProjectPath(projectPath);
         gradleSourceSet.setProjectDir(project.getProjectDir());
         gradleSourceSet.setRootDir(project.getRootDir());
         gradleSourceSet.setSourceSetName(sourceSet.getName());
-        gradleSourceSet.setClassesTaskName(sourceSet.getClassesTaskName());
+        String classesTaskName = getFullTaskName(projectPath, sourceSet.getClassesTaskName());
+        gradleSourceSet.setClassesTaskName(classesTaskName);
+        String cleanTaskName = getFullTaskName(projectPath, "clean");
+        gradleSourceSet.setCleanTaskName(cleanTaskName);
+        Set<String> taskNames = new HashSet<>();
+        gradleSourceSet.setTaskNames(taskNames);
+        taskNames.add(classesTaskName);
+        taskNames.add(cleanTaskName);
+        taskNames.add(getFullTaskName(projectPath, sourceSet.getProcessResourcesTaskName()));
         String projectName = stripPathPrefix(gradleSourceSet.getProjectPath());
         if (projectName == null || projectName.length() == 0) {
           projectName = gradleSourceSet.getProjectName();
@@ -82,6 +92,11 @@ public Object buildAll(String modelName, Project rootProject) {
         for (LanguageModelBuilder languageModelBuilder :
             GradleBuildServerPlugin.SUPPORTED_LANGUAGE_BUILDERS) {
           if (languageModelBuilder.appliesFor(project, sourceSet)) {
+            Task compileTask = languageModelBuilder.getLanguageCompileTask(project, sourceSet);
+            if (compileTask != null) {
+              String compileTaskName = getFullTaskName(projectPath, compileTask.getName());
+              taskNames.add(compileTaskName);
+            }
             srcDirs.addAll(languageModelBuilder.getSourceFoldersFor(project, sourceSet));
             generatedSrcDirs.addAll(
                 languageModelBuilder.getGeneratedSourceFoldersFor(project, sourceSet));
@@ -259,6 +274,24 @@ private SourceSetContainer getSourceSetContainer(Project project) {
     return null;
   }
 
+  /**
+   * Return a project task name - [project path]:[task].
+   */
+  private String getFullTaskName(String modulePath, String taskName) {
+    if (taskName == null) {
+      return null;
+    }
+    if (taskName.isEmpty()) {
+      return taskName;
+    }
+
+    if (modulePath == null || modulePath.equals(":")) {
+      // must be prefixed with ":" as taskPaths are reported back like that in progress messages
+      return ":" + taskName;
+    }
+    return modulePath + ":" + taskName;
+  }
+
   private String stripPathPrefix(String projectPath) {
     if (projectPath.startsWith(":")) {
       return projectPath.substring(1);

plugin/src/test/java/com/microsoft/java/bs/gradle/plugin/GradleBuildServerPluginTest.java

@@ -57,8 +57,8 @@ void testModelBuilder() throws IOException {
         assertEquals(projectDir, gradleSourceSet.getRootDir());
         assertTrue(gradleSourceSet.getSourceSetName().equals("main")
             || gradleSourceSet.getSourceSetName().equals("test"));
-        assertTrue(gradleSourceSet.getClassesTaskName().equals("classes")
-            || gradleSourceSet.getClassesTaskName().equals("testClasses"));
+        assertTrue(gradleSourceSet.getClassesTaskName().equals(":classes")
+            || gradleSourceSet.getClassesTaskName().equals(":testClasses"));
         assertFalse(gradleSourceSet.getCompileClasspath().isEmpty());
         assertTrue(gradleSourceSet.getSourceDirs().size() > 0);
         assertTrue(gradleSourceSet.getGeneratedSourceDirs().size() > 0);
@@ -354,8 +354,8 @@ void testScala2ModelBuilder() throws IOException {
         assertEquals(projectDir, gradleSourceSet.getRootDir());
         assertTrue(gradleSourceSet.getSourceSetName().equals("main")
                 || gradleSourceSet.getSourceSetName().equals("test"));
-        assertTrue(gradleSourceSet.getClassesTaskName().equals("classes")
-                || gradleSourceSet.getClassesTaskName().equals("testClasses"));
+        assertTrue(gradleSourceSet.getClassesTaskName().equals(":classes")
+                || gradleSourceSet.getClassesTaskName().equals(":testClasses"));
         assertFalse(gradleSourceSet.getCompileClasspath().isEmpty());
         assertTrue(gradleSourceSet.getSourceDirs().size() > 0);
         assertTrue(gradleSourceSet.getGeneratedSourceDirs().size() > 0);
@@ -406,8 +406,8 @@ void testScala3ModelBuilder() throws IOException {
         assertEquals(projectDir, gradleSourceSet.getRootDir());
         assertTrue(gradleSourceSet.getSourceSetName().equals("main")
                 || gradleSourceSet.getSourceSetName().equals("test"));
-        assertTrue(gradleSourceSet.getClassesTaskName().equals("classes")
-                || gradleSourceSet.getClassesTaskName().equals("testClasses"));
+        assertTrue(gradleSourceSet.getClassesTaskName().equals(":classes")
+                || gradleSourceSet.getClassesTaskName().equals(":testClasses"));
         assertFalse(gradleSourceSet.getCompileClasspath().isEmpty());
         assertTrue(gradleSourceSet.getSourceDirs().size() > 0);
         assertTrue(gradleSourceSet.getGeneratedSourceDirs().size() > 0);

server/src/main/java/com/microsoft/java/bs/core/internal/gradle/GradleApiConnector.java

@@ -12,6 +12,7 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Function;
 
 import org.gradle.tooling.BuildException;
 import org.gradle.tooling.BuildLauncher;
@@ -23,14 +24,12 @@
 import org.gradle.tooling.model.build.BuildEnvironment;
 
 import com.microsoft.java.bs.core.internal.managers.PreferenceManager;
-import com.microsoft.java.bs.core.internal.reporter.CompileProgressReporter;
 import com.microsoft.java.bs.core.internal.reporter.DefaultProgressReporter;
-import com.microsoft.java.bs.core.internal.reporter.TaskProgressReporter;
+import com.microsoft.java.bs.core.internal.reporter.ProgressReporter;
 import com.microsoft.java.bs.gradle.model.GradleSourceSets;
 import com.microsoft.java.bs.gradle.model.impl.DefaultGradleSourceSets;
 
 import ch.epfl.scala.bsp4j.BuildClient;
-import ch.epfl.scala.bsp4j.BuildTargetIdentifier;
 import ch.epfl.scala.bsp4j.StatusCode;
 
 /**
@@ -77,13 +76,10 @@ public GradleSourceSets getGradleSourceSets(URI projectUri) {
     if (!initScript.exists()) {
       throw new IllegalStateException("Failed to get init script file.");
     }
-    TaskProgressReporter reporter = new TaskProgressReporter(new DefaultProgressReporter(client));
+    ProgressReporter reporter = new DefaultProgressReporter(client);
     ByteArrayOutputStream errorOut = new ByteArrayOutputStream();
-    String summary = "";
-    StatusCode statusCode = StatusCode.OK;
     try (ProjectConnection connection = getGradleConnector(projectUri).connect();
         errorOut;) {
-      reporter.taskStarted("Retrieve source sets");
       ModelBuilder<GradleSourceSets> customModelBuilder = Utils.getModelBuilder(
           connection,
           preferenceManager.getPreferences(),
@@ -103,51 +99,46 @@ public GradleSourceSets getGradleSourceSets(URI projectUri) {
       // via a copy constructor and return as a POJO.
       return new DefaultGradleSourceSets(customModelBuilder.get());
     } catch (GradleConnectionException | IllegalStateException | IOException e) {
-      summary = e.getMessage();
+      String summary = e.getMessage();
       if (errorOut.size() > 0) {
-        summary += "\n" + errorOut.toString();
+        summary += "\n" + errorOut;
       }
-      statusCode = StatusCode.ERROR;
+      reporter.sendError(summary);
       throw new IllegalStateException("Error retrieving sourcesets \n" + summary, e);
-    } finally {
-      reporter.taskFinished(summary, statusCode);
     }
   }
 
   /**
    * Request Gradle daemon to run the tasks.
    */
-  public StatusCode runTasks(URI projectUri, Set<BuildTargetIdentifier> btIds, String... tasks) {
-    // Note: this might be anti-sepc, because the spec limits that one compile task report
-    // can only have one build target id. While we aggregate all compile related tasks into one
-    // Gradle call for the perf consideration. So, the build target id passed into the reporter
-    // is not accurate.
-    TaskProgressReporter reporter = new TaskProgressReporter(
-        new CompileProgressReporter(client, btIds.iterator().next()));
+  public StatusCode runTasks(URI projectUri, Set<String> tasks,
+      Function<BuildClient, ProgressReporter> reporterCreator) {
+    // Don't issue a start progress update - the listener will pick that up automatically
+    ProgressReporter reporter = reporterCreator.apply(client);
+
     final ByteArrayOutputStream errorOut = new ByteArrayOutputStream();
-    String summary = "BUILD SUCCESSFUL";
     StatusCode statusCode = StatusCode.OK;
     try (ProjectConnection connection = getGradleConnector(projectUri).connect();
-        errorOut;
+        errorOut
     ) {
-      reporter.taskStarted("Start to build: " + String.join(" ", tasks));
+      String[] taskArr = tasks.toArray(String[]::new);
       BuildLauncher launcher = Utils.getBuildLauncher(connection,
           preferenceManager.getPreferences());
       // TODO: consider to use outputstream to capture the output.
       launcher.addProgressListener(reporter, OperationType.TASK)
           .setStandardError(errorOut)
-          .forTasks(tasks)
+          .forTasks(taskArr)
           .run();
     } catch (IOException e) {
       // caused by close the output stream, just simply log the error.
       LOGGER.severe(e.getMessage());
     } catch (BuildException e) {
-      summary = errorOut.toString();
+      String summary = e.getMessage();
+      if (errorOut.size() > 0) {
+        summary += "\n" + errorOut;
+      }
+      reporter.sendError(summary);
       statusCode = StatusCode.ERROR;
-    } finally {
-      // If a build/taskStart notification has been sent,
-      // the server must send build/taskFinish on completion of the same task.
-      reporter.taskFinished(summary, statusCode);
     }
 
     return statusCode;

server/src/main/java/com/microsoft/java/bs/core/internal/reporter/CompileProgressReporter.java

@@ -3,7 +3,9 @@
 
 package com.microsoft.java.bs.core.internal.reporter;
 
-import java.util.UUID;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
 
 import ch.epfl.scala.bsp4j.BuildClient;
 import ch.epfl.scala.bsp4j.BuildTargetIdentifier;
@@ -16,57 +18,101 @@
 import ch.epfl.scala.bsp4j.TaskProgressParams;
 import ch.epfl.scala.bsp4j.TaskStartParams;
 
+import org.gradle.tooling.events.FailureResult;
+import org.gradle.tooling.events.FinishEvent;
+import org.gradle.tooling.events.OperationResult;
+import org.gradle.tooling.events.ProgressEvent;
+import org.gradle.tooling.events.ProgressListener;
+import org.gradle.tooling.events.StartEvent;
+
 /**
- * An implementation of {@link ProgressReporter} used for compilation tasks.
+ * An implementation of {@link ProgressReporter}
+ * and {@link ProgressListener} used for compilation tasks.
  */
-public class CompileProgressReporter implements ProgressReporter {
+public class CompileProgressReporter extends ProgressReporter {
 
-  private final BuildTargetIdentifier btId;
-  private final TaskId taskId;
-  private final BuildClient client;
+  private final String originId;
+  private final Map<String, Set<BuildTargetIdentifier>> taskPathMap;
+  private final Map<String, Long> startTimes;
 
   /**
    * Instantiates a {@link CompileProgressReporter}.
    *
-   * @param btId Build target identifier
+   * @param client BSP client to report to.
+   * @param originId id of the BSP client message.
+   * @param taskPathMap all know task paths to their build targets.
    */
-  public CompileProgressReporter(BuildClient client, BuildTargetIdentifier btId) {
-    this.btId = btId;
-    this.taskId = new TaskId(UUID.randomUUID().toString());
-    this.client = client;
+  public CompileProgressReporter(BuildClient client, String originId,
+      Map<String, Set<BuildTargetIdentifier>> taskPathMap) {
+    super(client);
+    this.originId = originId;
+    this.taskPathMap = taskPathMap;
+    startTimes = new HashMap<>();
   }
 
   @Override
-  public void taskStarted(String message) {
+  public void statusChanged(ProgressEvent event) {
     if (client != null) {
+      String taskPath = getTaskPath(event.getDescriptor());
+      TaskId taskId = getTaskId(taskPath);
+      Set<BuildTargetIdentifier> targets = taskPathMap.get(taskPath);
+      if (targets != null) {
+        if (event instanceof StartEvent) {
+          startTimes.put(taskPath, event.getEventTime());
+          taskStarted(taskId, targets, event.getDisplayName());
+        } else if (event instanceof FinishEvent) {
+          OperationResult result = ((FinishEvent) event).getResult();
+          StatusCode status = result instanceof FailureResult ? StatusCode.ERROR : StatusCode.OK;
+          Long compileStartTime = startTimes.get(taskPath);
+          Long compileTimeDuration = compileStartTime == null ? null
+              : event.getEventTime() - compileStartTime;
+          taskFinished(taskId, targets, event.getDisplayName(), compileTimeDuration, status);
+        } else {
+          taskInProgress(taskId, targets, event.getDisplayName());
+        }
+      }
+    }
+  }
+
+  private void taskStarted(TaskId taskId, Set<BuildTargetIdentifier> targets, String message) {
+    long eventTime = System.currentTimeMillis();
+    targets.forEach(btId -> {
       TaskStartParams startParam = new TaskStartParams(taskId);
+      startParam.setEventTime(eventTime);
       startParam.setMessage(message);
       startParam.setDataKind(TaskDataKind.COMPILE_TASK);
-      startParam.setData(new CompileTask(this.btId));
+      startParam.setData(new CompileTask(btId));
       client.onBuildTaskStart(startParam);
-    }
+    });
   }
 
-  @Override
-  public void taskInProgress(String message) {
-    if (client != null) {
+  private void taskInProgress(TaskId taskId, Set<BuildTargetIdentifier> targets, String message) {
+    long eventTime = System.currentTimeMillis();
+    targets.forEach(btId -> {
       TaskProgressParams progressParam = new TaskProgressParams(taskId);
+      progressParam.setEventTime(eventTime);
       progressParam.setMessage(message);
       progressParam.setDataKind(TaskDataKind.COMPILE_TASK);
-      progressParam.setData(new CompileTask(this.btId));
+      progressParam.setData(new CompileTask(btId));
       client.onBuildTaskProgress(progressParam);
-    }
+    });
   }
 
-  @Override
-  public void taskFinished(String message, StatusCode statusCode) {
-    if (client != null) {
+  private void taskFinished(TaskId taskId, Set<BuildTargetIdentifier> targets, String message,
+      Long compileTimeDuration, StatusCode statusCode) {
+    long eventTime = System.currentTimeMillis();
+    targets.forEach(btId -> {
       TaskFinishParams endParam = new TaskFinishParams(taskId, statusCode);
+      endParam.setEventTime(eventTime);
       endParam.setMessage(message);
       endParam.setDataKind(TaskDataKind.COMPILE_REPORT);
-      endParam.setData(new CompileReport(this.btId, 0, 0)); // TODO: parse the errors and warnings
+      // TODO Gradle > 8.8 Problems API will allow errors/warnings to be reported on
+      CompileReport compileReport = new CompileReport(btId, 0, 0);
+      compileReport.setOriginId(originId);
+      compileReport.setTime(compileTimeDuration);
+      endParam.setData(compileReport);
       client.onBuildTaskFinish(endParam);
-    }
+    });
   }
 }
 

server/src/main/java/com/microsoft/java/bs/core/internal/reporter/DefaultProgressReporter.java

@@ -3,7 +3,11 @@
 
 package com.microsoft.java.bs.core.internal.reporter;
 
-import java.util.UUID;
+import org.gradle.tooling.events.FailureResult;
+import org.gradle.tooling.events.FinishEvent;
+import org.gradle.tooling.events.OperationResult;
+import org.gradle.tooling.events.ProgressEvent;
+import org.gradle.tooling.events.StartEvent;
 
 import ch.epfl.scala.bsp4j.BuildClient;
 import ch.epfl.scala.bsp4j.StatusCode;
@@ -15,40 +19,53 @@
 /**
  * A default implementation of {@link ProgressReporter}.
  */
-public class DefaultProgressReporter implements ProgressReporter {
-
-  private final TaskId taskId;
-  private final BuildClient client;
+public class DefaultProgressReporter extends ProgressReporter {
 
+  /**
+   * Instantiates a {@link DefaultProgressReporter}.
+   *
+   * @param client BSP client to report to.
+   */
   public DefaultProgressReporter(BuildClient client) {
-    this.taskId = new TaskId(UUID.randomUUID().toString());
-    this.client = client;
+    super(client);
   }
 
   @Override
-  public void taskStarted(String message) {
+  public void statusChanged(ProgressEvent event) {
     if (client != null) {
-      TaskStartParams startParam = new TaskStartParams(taskId);
-      startParam.setMessage(message);
-      client.onBuildTaskStart(startParam);
+      String taskPath = getTaskPath(event.getDescriptor());
+      TaskId taskId = getTaskId(taskPath);
+      if (event instanceof StartEvent) {
+        taskStarted(taskId, event.getDisplayName());
+      } else if (event instanceof FinishEvent) {
+        OperationResult result = ((FinishEvent) event).getResult();
+        StatusCode status = result instanceof FailureResult ? StatusCode.ERROR : StatusCode.OK;
+        taskFinished(taskId, event.getDisplayName(), status);
+      } else {
+        taskInProgress(taskId, event.getDisplayName());
+      }
     }
   }
 
-  @Override
-  public void taskInProgress(String message) {
-    if (client != null) {
-      TaskProgressParams progressParam = new TaskProgressParams(taskId);
-      progressParam.setMessage(message);
-      client.onBuildTaskProgress(progressParam);
-    }
+  private void taskStarted(TaskId taskId, String message) {
+    TaskStartParams startParam = new TaskStartParams(taskId);
+    startParam.setEventTime(System.currentTimeMillis());
+    startParam.setMessage(message);
+    client.onBuildTaskStart(startParam);
   }
 
-  @Override
-  public void taskFinished(String message, StatusCode statusCode) {
-    if (client != null) {
-      TaskFinishParams endParam = new TaskFinishParams(taskId, statusCode);
-      endParam.setMessage(message);
-      client.onBuildTaskFinish(endParam);
-    }
+  private void taskInProgress(TaskId taskId, String message) {
+    TaskProgressParams progressParam = new TaskProgressParams(taskId);
+    progressParam.setEventTime(System.currentTimeMillis());
+    progressParam.setMessage(message);
+    client.onBuildTaskProgress(progressParam);
+  }
+
+  private void taskFinished(TaskId taskId, String message,
+      StatusCode statusCode) {
+    TaskFinishParams endParam = new TaskFinishParams(taskId, statusCode);
+    endParam.setEventTime(System.currentTimeMillis());
+    endParam.setMessage(message);
+    client.onBuildTaskFinish(endParam);
   }
 }

server/src/main/java/com/microsoft/java/bs/core/internal/reporter/ProgressReporter.java

@@ -3,32 +3,71 @@
 
 package com.microsoft.java.bs.core.internal.reporter;
 
-import ch.epfl.scala.bsp4j.StatusCode;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+import org.gradle.tooling.events.OperationDescriptor;
+import org.gradle.tooling.events.ProgressListener;
+import org.gradle.tooling.events.task.TaskOperationDescriptor;
+
+import ch.epfl.scala.bsp4j.BuildClient;
+import ch.epfl.scala.bsp4j.LogMessageParams;
+import ch.epfl.scala.bsp4j.MessageType;
+import ch.epfl.scala.bsp4j.TaskId;
 
 /**
- * A progress reporter that reports the progress of a task.
+ * An extension of {@link ProgressListener} that allows sending errors.
  */
-public interface ProgressReporter {
+public abstract class ProgressReporter implements ProgressListener {
 
-  /**
-   * Notify the client that a task has been started.
-   *
-   * @param message the message to be displayed.
-   */
-  void taskStarted(String message);
+  protected final BuildClient client;
+  protected final TaskId taskId;
+  protected final List<String> taskIds;
 
   /**
-   * Notify the progress of the task.
+   * Instantiates a {@link ProgressReporter}.
    *
-   * @param message the message to be displayed.
+   * @param client BSP client to report to.
    */
-  void taskInProgress(String message);
+  public ProgressReporter(BuildClient client) {
+    this.client = client;
+    taskId = new TaskId(UUID.randomUUID().toString());
+    taskIds = new ArrayList<>();
+    taskIds.add(taskId.getId());
+  }
 
   /**
-   * Notify the client that a task has been finished.
+   * Notify the client of an error.
    *
-   * @param message the message to be displayed.
-   * @param statusCode the status code of the task.
+   * @param error the error message.
    */
-  void taskFinished(String message, StatusCode statusCode);
+  public void sendError(String error) {
+    if (client != null) {
+      LogMessageParams messageParam = new LogMessageParams(MessageType.ERROR, error);
+      messageParam.setTask(taskId);
+      client.onBuildLogMessage(messageParam);
+    }
+  }
+
+  protected TaskId getTaskId(String taskPath) {
+    TaskId taskId = new TaskId(taskPath == null ? "null" : taskPath);
+    taskId.setParents(taskIds);
+    return taskId;
+  }
+
+  protected String getTaskPath(OperationDescriptor operationDescriptor) {
+    if (operationDescriptor == null) {
+      return null;
+    } else if (operationDescriptor instanceof TaskOperationDescriptor) {
+      return ((TaskOperationDescriptor) operationDescriptor).getTaskPath();
+    } else {
+      OperationDescriptor parent = operationDescriptor.getParent();
+      if (parent != operationDescriptor) {
+        return getTaskPath(operationDescriptor.getParent());
+      } else {
+        return null;
+      }
+    }
+  }
 }

server/src/main/java/com/microsoft/java/bs/core/internal/reporter/TaskProgressReporter.java

@@ -18,25 +18,20 @@
 import java.util.logging.Level;
 import java.util.stream.Collectors;
 
-import ch.epfl.scala.bsp4j.DependencySourcesItem;
-import ch.epfl.scala.bsp4j.DependencySourcesParams;
-import ch.epfl.scala.bsp4j.DependencySourcesResult;
-import ch.epfl.scala.bsp4j.ScalacOptionsItem;
-import ch.epfl.scala.bsp4j.ScalacOptionsParams;
-import ch.epfl.scala.bsp4j.ScalacOptionsResult;
-import com.microsoft.java.bs.gradle.model.JavaExtension;
-import com.microsoft.java.bs.gradle.model.ScalaExtension;
-import org.apache.commons.lang3.StringUtils;
-
 import com.microsoft.java.bs.core.internal.gradle.GradleApiConnector;
 import com.microsoft.java.bs.core.internal.managers.BuildTargetManager;
 import com.microsoft.java.bs.core.internal.managers.PreferenceManager;
 import com.microsoft.java.bs.core.internal.model.GradleBuildTarget;
+import com.microsoft.java.bs.core.internal.reporter.CompileProgressReporter;
+import com.microsoft.java.bs.core.internal.reporter.DefaultProgressReporter;
+import com.microsoft.java.bs.core.internal.reporter.ProgressReporter;
 import com.microsoft.java.bs.core.internal.utils.TelemetryUtils;
 import com.microsoft.java.bs.core.internal.utils.UriUtils;
 import com.microsoft.java.bs.gradle.model.GradleModuleDependency;
 import com.microsoft.java.bs.gradle.model.GradleSourceSet;
 import com.microsoft.java.bs.gradle.model.GradleSourceSets;
+import com.microsoft.java.bs.gradle.model.JavaExtension;
+import com.microsoft.java.bs.gradle.model.ScalaExtension;
 import com.microsoft.java.bs.gradle.model.SupportedLanguages;
 
 import ch.epfl.scala.bsp4j.BuildClient;
@@ -51,6 +46,9 @@
 import ch.epfl.scala.bsp4j.DependencyModulesItem;
 import ch.epfl.scala.bsp4j.DependencyModulesParams;
 import ch.epfl.scala.bsp4j.DependencyModulesResult;
+import ch.epfl.scala.bsp4j.DependencySourcesItem;
+import ch.epfl.scala.bsp4j.DependencySourcesParams;
+import ch.epfl.scala.bsp4j.DependencySourcesResult;
 import ch.epfl.scala.bsp4j.JavacOptionsItem;
 import ch.epfl.scala.bsp4j.JavacOptionsParams;
 import ch.epfl.scala.bsp4j.JavacOptionsResult;
@@ -65,13 +63,17 @@
 import ch.epfl.scala.bsp4j.ResourcesItem;
 import ch.epfl.scala.bsp4j.ResourcesParams;
 import ch.epfl.scala.bsp4j.ResourcesResult;
+import ch.epfl.scala.bsp4j.ScalacOptionsItem;
+import ch.epfl.scala.bsp4j.ScalacOptionsParams;
+import ch.epfl.scala.bsp4j.ScalacOptionsResult;
 import ch.epfl.scala.bsp4j.SourceItem;
 import ch.epfl.scala.bsp4j.SourceItemKind;
 import ch.epfl.scala.bsp4j.SourcesItem;
 import ch.epfl.scala.bsp4j.SourcesParams;
 import ch.epfl.scala.bsp4j.SourcesResult;
 import ch.epfl.scala.bsp4j.StatusCode;
 import ch.epfl.scala.bsp4j.WorkspaceBuildTargetsResult;
+import org.apache.commons.lang3.StringUtils;
 
 /**
  * Service to handle build target related BSP requests.
@@ -260,7 +262,7 @@ public OutputPathsResult getBuildTargetOutputPaths(OutputPathsParams params) {
   public DependencySourcesResult getBuildTargetDependencySources(DependencySourcesParams params) {
     List<DependencySourcesItem> items = new ArrayList<>();
     for (BuildTargetIdentifier btId : params.getTargets()) {
-      GradleBuildTarget target = buildTargetManager.getGradleBuildTarget(btId);
+      GradleBuildTarget target = getGradleBuildTarget(btId);
       if (target == null) {
         LOGGER.warning("Skip output collection for the build target: " + btId.getUri()
                 + ". Because it cannot be found in the cache.");
@@ -329,14 +331,20 @@ public CompileResult compile(CompileParams params) {
     if (params.getTargets().isEmpty()) {
       return new CompileResult(StatusCode.OK);
     } else {
-      StatusCode code = runTasks(params.getTargets(), this::getBuildTaskName);
+      Function<Map<String, Set<BuildTargetIdentifier>>,
+          Function<BuildClient, ProgressReporter>> reporterCreator =
+              fullTaskPathMap -> buildClient ->
+                  new CompileProgressReporter(client, params.getOriginId(), fullTaskPathMap);
+      StatusCode code = runTasks(params.getTargets(), this::getBuildTaskName, reporterCreator);
       CompileResult result = new CompileResult(code);
       result.setOriginId(params.getOriginId());
 
       // Schedule a task to refetch the build targets after compilation, this is to
       // auto detect the source roots changes for those code generation framework,
       // such as Protocol Buffer.
-      CompletableFuture.runAsync(this::reloadWorkspace);
+      if (!Boolean.getBoolean("bsp.plugin.reloadworkspace.disabled")) {
+        CompletableFuture.runAsync(this::reloadWorkspace);
+      }
       return result;
     }
   }
@@ -345,22 +353,52 @@ public CompileResult compile(CompileParams params) {
    * clean the build targets.
    */
   public CleanCacheResult cleanCache(CleanCacheParams params) {
-    StatusCode code = runTasks(params.getTargets(), this::getCleanTaskName);
+    Function<Map<String, Set<BuildTargetIdentifier>>,
+        Function<BuildClient, ProgressReporter>> reporterCreator =
+            fullTaskPathMap -> buildClient ->
+                new DefaultProgressReporter(client);
+    StatusCode code = runTasks(params.getTargets(), this::getCleanTaskName, reporterCreator);
     return new CleanCacheResult(null, code == StatusCode.OK);
   }
 
+  /**
+   * create a map of all known taskpaths to the build targets they affect.
+   * used to associate progress events to the correct target.
+   */
+  private Map<String, Set<BuildTargetIdentifier>> getFullTaskPathMap() {
+    Map<String, Set<BuildTargetIdentifier>> fullTaskPathMap = new HashMap<>();
+    for (GradleBuildTarget buildTarget : buildTargetManager.getAllGradleBuildTargets()) {
+      Set<String> tasks = buildTarget.getSourceSet().getTaskNames();
+      BuildTargetIdentifier btId = buildTarget.getBuildTarget().getId();
+      for (String taskName : tasks) {
+        fullTaskPathMap.computeIfAbsent(taskName, k -> new HashSet<>())
+            .add(btId);
+      }
+    }
+    return fullTaskPathMap;
+  }
+
   /**
    * group targets by project root and execute the supplied tasks.
    */
   private StatusCode runTasks(List<BuildTargetIdentifier> targets,
-      Function<BuildTargetIdentifier, String> taskNameCreator) {
+      Function<BuildTargetIdentifier, String> taskNameCreator,
+      Function<Map<String, Set<BuildTargetIdentifier>>,
+        Function<BuildClient, ProgressReporter>> progressReporterCreator) {
+    // create task name for all build targets to be able to monitor progress
+    Map<String, Set<BuildTargetIdentifier>> fullTaskPathMap = getFullTaskPathMap();
+
     Map<URI, Set<BuildTargetIdentifier>> groupedTargets = groupBuildTargetsByRootDir(targets);
     StatusCode code = StatusCode.OK;
     for (Map.Entry<URI, Set<BuildTargetIdentifier>> entry : groupedTargets.entrySet()) {
-      Set<BuildTargetIdentifier> btIds = entry.getValue();
-      // remove duplicates as some tasks will have the same name for each sourceset e.g. clean.
-      String[] tasks = btIds.stream().map(taskNameCreator).distinct().toArray(String[]::new);
-      code = connector.runTasks(entry.getKey(), btIds, tasks);
+      // use Set to remove duplicates. Some tasks have the same name for each sourceset e.g. clean.
+      Set<String> tasks = entry.getValue().stream()
+          .map(taskNameCreator)
+          .collect(Collectors.toSet());
+      Function<BuildClient, ProgressReporter> reporterCreator =
+          progressReporterCreator.apply(fullTaskPathMap);
+      code = connector.runTasks(entry.getKey(), tasks, reporterCreator);
+
       if (code == StatusCode.ERROR) {
         break;
       }
@@ -484,44 +522,34 @@ private URI getRootProjectUri(BuildTargetIdentifier btId) {
   }
 
   /**
-   * Return the build task name - [project path]:[task].
+   * Return a source set task name.
    */
-  private String getBuildTaskName(BuildTargetIdentifier btId) {
+  private String getProjectTaskName(BuildTargetIdentifier btId, String title,
+      Function<GradleSourceSet, String> creator) {
     GradleBuildTarget gradleBuildTarget = getGradleBuildTarget(btId);
     if (gradleBuildTarget == null) {
       // TODO: https://github.com/microsoft/build-server-for-gradle/issues/50
       throw new IllegalArgumentException("The build target does not exist: " + btId.getUri());
     }
-    GradleSourceSet sourceSet = gradleBuildTarget.getSourceSet();
-    String classesTaskName = sourceSet.getClassesTaskName();
-    if (StringUtils.isBlank(classesTaskName)) {
-      throw new IllegalArgumentException("The build target does not have a classes task: "
+    String taskName = creator.apply(gradleBuildTarget.getSourceSet());
+    if (StringUtils.isBlank(taskName)) {
+      throw new IllegalArgumentException("The build target does not have a " + title + " task: "
           + btId.getUri());
     }
+    return taskName;
+  }
 
-    String modulePath = sourceSet.getProjectPath();
-    if (modulePath == null || modulePath.equals(":")) {
-      return classesTaskName;
-    }
-    return modulePath + ":" + classesTaskName;
+  /**
+   * Return the build task name - [project path]:[task].
+   */
+  private String getBuildTaskName(BuildTargetIdentifier btId) {
+    return getProjectTaskName(btId, "classes", GradleSourceSet::getClassesTaskName);
   }
 
   /**
    * Return the clean task name - [project path]:[task].
    */
   private String getCleanTaskName(BuildTargetIdentifier btId) {
-    GradleBuildTarget gradleBuildTarget = getGradleBuildTarget(btId);
-    if (gradleBuildTarget == null) {
-      // TODO: https://github.com/microsoft/build-server-for-gradle/issues/50
-      throw new IllegalArgumentException("The build target does not exist: " + btId.getUri());
-    }
-    GradleSourceSet sourceSet = gradleBuildTarget.getSourceSet();
-    String classesTaskName = "clean";
-
-    String modulePath = sourceSet.getProjectPath();
-    if (modulePath == null || modulePath.equals(":")) {
-      return classesTaskName;
-    }
-    return modulePath + ":" + classesTaskName;
+    return getProjectTaskName(btId, "clean", GradleSourceSet::getCleanTaskName);
   }
 }

server/src/main/java/com/microsoft/java/bs/core/internal/services/BuildTargetService.java

@@ -4,7 +4,6 @@
 package com.microsoft.java.bs.core.internal.server;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -14,33 +13,13 @@
 import java.io.PipedOutputStream;
 import java.nio.file.Paths;
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.function.BiConsumer;
+import java.util.function.IntSupplier;
 import java.util.stream.Collectors;
 
-import ch.epfl.scala.bsp4j.DependencyModulesParams;
-import ch.epfl.scala.bsp4j.DependencyModulesResult;
-import ch.epfl.scala.bsp4j.DependencySourcesParams;
-import ch.epfl.scala.bsp4j.DependencySourcesResult;
-import ch.epfl.scala.bsp4j.MavenDependencyModule;
-import ch.epfl.scala.bsp4j.MavenDependencyModuleArtifact;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
-
-import com.microsoft.java.bs.core.Launcher;
-import com.microsoft.java.bs.core.internal.gradle.GradleApiConnector;
-import com.microsoft.java.bs.core.internal.managers.BuildTargetManager;
-import com.microsoft.java.bs.core.internal.managers.PreferenceManager;
-import com.microsoft.java.bs.core.internal.services.BuildTargetService;
-import com.microsoft.java.bs.core.internal.services.LifecycleService;
-import com.microsoft.java.bs.core.internal.utils.JsonUtils;
-import com.microsoft.java.bs.gradle.model.SupportedLanguages;
-
 import ch.epfl.scala.bsp4j.BuildClient;
 import ch.epfl.scala.bsp4j.BuildClientCapabilities;
 import ch.epfl.scala.bsp4j.BuildServer;
@@ -51,18 +30,36 @@
 import ch.epfl.scala.bsp4j.CompileParams;
 import ch.epfl.scala.bsp4j.CompileReport;
 import ch.epfl.scala.bsp4j.CompileResult;
+import ch.epfl.scala.bsp4j.DependencyModulesParams;
+import ch.epfl.scala.bsp4j.DependencyModulesResult;
+import ch.epfl.scala.bsp4j.DependencySourcesParams;
+import ch.epfl.scala.bsp4j.DependencySourcesResult;
 import ch.epfl.scala.bsp4j.DidChangeBuildTarget;
 import ch.epfl.scala.bsp4j.InitializeBuildParams;
 import ch.epfl.scala.bsp4j.JavaBuildServer;
 import ch.epfl.scala.bsp4j.JvmBuildServer;
 import ch.epfl.scala.bsp4j.LogMessageParams;
+import ch.epfl.scala.bsp4j.MavenDependencyModule;
+import ch.epfl.scala.bsp4j.MavenDependencyModuleArtifact;
 import ch.epfl.scala.bsp4j.PublishDiagnosticsParams;
 import ch.epfl.scala.bsp4j.ShowMessageParams;
 import ch.epfl.scala.bsp4j.StatusCode;
 import ch.epfl.scala.bsp4j.TaskFinishParams;
 import ch.epfl.scala.bsp4j.TaskProgressParams;
 import ch.epfl.scala.bsp4j.TaskStartParams;
 import ch.epfl.scala.bsp4j.WorkspaceBuildTargetsResult;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import com.microsoft.java.bs.core.Launcher;
+import com.microsoft.java.bs.core.internal.gradle.GradleApiConnector;
+import com.microsoft.java.bs.core.internal.managers.BuildTargetManager;
+import com.microsoft.java.bs.core.internal.managers.PreferenceManager;
+import com.microsoft.java.bs.core.internal.services.BuildTargetService;
+import com.microsoft.java.bs.core.internal.services.LifecycleService;
+import com.microsoft.java.bs.core.internal.utils.JsonUtils;
+import com.microsoft.java.bs.gradle.model.SupportedLanguages;
 
 // TODO: Move to a dedicated source set for integration tests
 class BuildTargetServerIntegrationTest {
@@ -73,24 +70,38 @@ private interface TestServer extends BuildServer, JavaBuildServer, JvmBuildServe
   private static class TestClient implements BuildClient {
 
     private final List<TaskStartParams> startReports = new ArrayList<>();
-    private final List<TaskFinishParams> finishReports = new ArrayList<>();
-    private final Set<CompileReport> compileReports = new HashSet<>();
+    private final List<String> finishReports = new ArrayList<>();
+    private final List<CompileReport> compileReports = new ArrayList<>();
+    private final List<CompileResult> compileResults = new ArrayList<>();
 
     void clearMessages() {
       startReports.clear();
       finishReports.clear();
       compileReports.clear();
+      compileResults.clear();
+    }
+
+    void waitOnStartReports(int size) {
+      waitOnMessages("Start Reports", size, startReports::size);
+    }
+
+    void waitOnFinishReports(int size) {
+      waitOnMessages("Finish Reports", size, finishReports::size);
+    }
+
+    void waitOnCompileReports(int size) {
+      waitOnMessages("Compile Reports", size, compileReports::size);
+    }
+
+    void waitOnCompileResults(int size) {
+      waitOnMessages("Compile Results", size, compileResults::size);
     }
 
-    void waitOnMessages(int startMessagesSize,
-                        int finishMessagesSize,
-                        int compileReportsSize) {
+    private void waitOnMessages(String message, int size, IntSupplier sizeSupplier) {
       // set to 5000ms because it seems reasonable
       long timeoutMs = 5000;
       long endTime = System.currentTimeMillis() + timeoutMs;
-      while ((startReports.size() < startMessagesSize
-              || finishReports.size() < finishMessagesSize
-              || compileReports.size() < compileReportsSize)
+      while (sizeSupplier.getAsInt() < size
               && System.currentTimeMillis() < endTime) {
         synchronized (this) {
           long waitTime = endTime - System.currentTimeMillis();
@@ -103,9 +114,7 @@ void waitOnMessages(int startMessagesSize,
           }
         }
       }
-      assertEquals(startMessagesSize, startReports.size(), "Start Report count error");
-      assertEquals(finishMessagesSize, finishReports.size(), "Finish Reports count error");
-      assertEquals(compileReportsSize, compileReports.size(), "Compile Reports count error");
+      assertEquals(size, sizeSupplier.getAsInt(), message + " count error");
     }
 
     private CompileReport findCompileReport(BuildTargetIdentifier btId) {
@@ -150,9 +159,11 @@ public void onBuildTaskFinish(TaskFinishParams params) {
       if (params.getDataKind() != null) {
         if (params.getDataKind().equals("compile-report")) {
           compileReports.add(JsonUtils.toModel(params.getData(), CompileReport.class));
+        } else if (params.getDataKind().equals("compile-result")) {
+          compileResults.add(JsonUtils.toModel(params.getData(), CompileResult.class));
         }
       }
-      finishReports.add(params);
+      finishReports.add(params.getMessage());
       synchronized (this) {
         notify();
       }
@@ -174,11 +185,13 @@ static void beforeClass() {
     String pluginDir = Paths.get(System.getProperty("user.dir"),
         "build", "libs", "plugins").toString();
     System.setProperty(Launcher.PROP_PLUGIN_DIR, pluginDir);
+    System.setProperty("bsp.plugin.reloadworkspace.disabled", "true");
   }
 
   @AfterAll
   static void afterClass() {
     System.clearProperty(Launcher.PROP_PLUGIN_DIR);
+    System.clearProperty("bsp.plugin.reloadworkspace.disabled");
   }
 
   private InitializeBuildParams getInitializeBuildParams(String projectDir) {
@@ -257,22 +270,6 @@ private void withNewTestServer(String project, BiConsumer<TestServer, TestClient
     }
   }
 
-  private BuildTargetIdentifier getBt(List<BuildTargetIdentifier> btIds,
-      String projectPathSection, String sourceSetName) {
-    String sourceSet = "?sourceset=" + sourceSetName;
-    List<BuildTargetIdentifier> matching = btIds.stream()
-            .filter(id -> id.getUri().contains(projectPathSection))
-            .filter(id -> id.getUri().endsWith(sourceSet))
-            .collect(Collectors.toList());
-    assertFalse(matching.isEmpty(), () -> "Build Target " + projectPathSection
-            + " with source set " + sourceSetName + " not found in "
-            + btIds.stream().map(Object::toString).collect(Collectors.joining(", ")));
-    assertEquals(1, matching.size(), () -> "Too many Build Targets like " + projectPathSection
-            + " with source set " + sourceSetName + " found in "
-            + btIds.stream().map(Object::toString).collect(Collectors.joining(", ")));
-    return matching.get(0);
-  }
-
   @Test
   void testCompilingSingleProjectServer() {
     withNewTestServer("junit5-jupiter-starter-gradle", (gradleBuildServer, client) -> {
@@ -314,18 +311,28 @@ void testCompilingSingleProjectServer() {
       CleanCacheResult cleanResult = gradleBuildServer
           .buildTargetCleanCache(cleanCacheParams).join();
       assertTrue(cleanResult.getCleaned());
-      client.waitOnMessages(2, 2, 1);
+      client.waitOnStartReports(2);
+      client.waitOnFinishReports(2);
+      client.waitOnCompileReports(0);
+      client.waitOnCompileResults(0);
       client.clearMessages();
 
       // compile targets
       CompileParams compileParams = new CompileParams(btIds);
+      compileParams.setOriginId("originId");
       CompileResult compileResult = gradleBuildServer.buildTargetCompile(compileParams).join();
       assertEquals(StatusCode.OK, compileResult.getStatusCode());
-      client.waitOnMessages(2, 2, 1);
-      BuildTargetIdentifier testBt = getBt(btIds, "/junit5-jupiter-starter-gradle/", "test");
-      CompileReport compileReportTest = client.findCompileReport(testBt);
-      assertEquals(0, compileReportTest.getWarnings());
-      assertEquals(0, compileReportTest.getErrors());
+      client.waitOnStartReports(6);
+      client.waitOnFinishReports(6);
+      client.waitOnCompileReports(6);
+      client.waitOnCompileResults(0);
+      for (BuildTargetIdentifier btId : btIds) {
+        CompileReport compileReport = client.findCompileReport(btId);
+        assertEquals("originId", compileReport.getOriginId());
+        // TODO compile results are not yet implemented so always zero for now.
+        assertEquals(0, compileReport.getWarnings());
+        assertEquals(0, compileReport.getErrors());
+      }
       client.clearMessages();
     });
   }