Add callbacks to Super Dev Mode to find out when a compile starts and finishes,

and an alternate main() that can be called after parsing options.

Change-Id: I2a27a07d2c8219d496613b1c1c88380c6dc3d032
Review-Link: https://gwt-review.googlesource.com/#/c/2540/


git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@11597 8db76d5a-ed1c-0410-87a9-c151d255dfc7

Author: skybrian@google.com

dev/codeserver/java/com/google/gwt/dev/codeserver/CodeServer.java

@@ -46,6 +46,13 @@ public static void main(String[] args) throws Exception {
       System.exit(1);
     }
 
+    main(options);
+  }
+
+  /**
+   * Starts the code server with the given options. Shuts down the JVM if startup fails.
+   */
+  public static void main(Options options) {
     if (options.isCompileTest()) {
       PrintWriterTreeLogger logger = new PrintWriterTreeLogger();
       logger.setMaxDetail(TreeLogger.Type.INFO);
@@ -110,7 +117,8 @@ private static Modules makeModules(Options options, PrintWriterTreeLogger logger
       AppSpace appSpace = AppSpace.create(new File(workDir, moduleName));
 
       Recompiler recompiler = new Recompiler(appSpace, moduleName,
-          options.getSourcePath(), options.getPreferredHost() + ":" + options.getPort(), logger);
+          options.getSourcePath(), options.getPreferredHost() + ":" + options.getPort(),
+          options.getRecompileListener(), options.isCompileTest(), logger);
       modules.addModuleState(new ModuleState(recompiler, logger, options.getNoPrecompile()));
     }
     return modules;

dev/codeserver/java/com/google/gwt/dev/codeserver/CompileDir.java

@@ -26,40 +26,63 @@
  * the app, we will create a new, empty CompileDir. This way, a failed compile doesn't
  * modify the last good compile.
  *
- * The CompileDir gets created within the appropriate {@link AppSpace} for the app
+ * <p>The CompileDir gets created within the appropriate {@link AppSpace} for the app
  * being compiled.
  */
-class CompileDir {
+public class CompileDir {
   private final File dir;
 
   /**
    * @see #create
    */
-  private CompileDir(File dir) {
+  public CompileDir(File dir) {
     this.dir = dir;
   }
 
-  File getWarDir() {
+  /**
+   * Top-level directory, containing the others.
+   */
+  public File getRoot() {
+    return dir;
+  }
+
+  /**
+   * The directory tree where the compiler saves output files that should be available
+   * via HTTP. It will be in a subdirectory based on the module name, possibly after
+   * renaming. Files will be accessible via HTTP until a new compile finishes successfully.
+   */
+  public File getWarDir() {
     return new File(dir, "war");
   }
 
   File getDeployDir() {
     return new File(getWarDir(), "WEB-INF/deploy");
   }
 
-  File getExtraDir() {
+  /**
+   * The directory where the compiler saves auxiliary files that shouldn't be available via HTTP.
+   */
+  public File getExtraDir() {
     return new File(dir, "extras");
   }
 
-  File getGenDir() {
+  /**
+   * The directory tree where the compiler saves source code created by GWT generators.
+   * The source is also accessible via HTTP, for use by browser debuggers.
+   */
+  public File getGenDir() {
     return new File(dir, "gen");
   }
 
   File getWorkDir() {
     return new File(dir, "work");
   }
 
-  File getLogFile() {
+  /**
+   * The file where the GWT compiler writes compile errors and warnings.
+   * Also accessible via HTTP.
+   */
+  public File getLogFile() {
     return new File(dir, "compile.log");
   }
 

dev/codeserver/java/com/google/gwt/dev/codeserver/Options.java

@@ -45,6 +45,7 @@ public class Options {
   private String bindAddress = "127.0.0.1";
   private String preferredHost = "localhost";
   private int port = 9876;
+  private RecompileListener recompileListener = RecompileListener.NONE;
 
   /**
    * Sets each option to the appropriate value, based on command-line arguments.
@@ -70,6 +71,18 @@ public boolean parseArgs(String[] args) {
     return true;
   }
 
+  /**
+   * A Java application that embeds Super Dev Mode can use this hook to find out
+   * when compiles start and end.
+   */
+  public void setRecompileListener(RecompileListener recompileListener) {
+    this.recompileListener = recompileListener;
+  }
+
+  RecompileListener getRecompileListener() {
+    return recompileListener;
+  }
+
   /**
    * The top level of the directory tree where the code server keeps compiler output.
    */

dev/codeserver/java/com/google/gwt/dev/codeserver/RecompileListener.java

@@ -0,0 +1,41 @@
+package com.google.gwt.dev.codeserver;
+
+/**
+ * A callback interface that can be used to find out when Super Dev Mode starts and
+ * finishes its compiles.
+ */
+public interface RecompileListener {
+
+  /**
+   * Called when starting a compile.
+   * @param moduleName The name of the module being compiled, before renaming.
+   * @param compileId An id for this compile, starting from 1 for the first compile.
+   *                  The combination of (moduleName, compileId) is unique within
+   *                  a Code Server process. After the CodeServer is restarted, starts again from 1.
+   * @param compileDir The directory used for this compile. Contains subdirectories for
+   *                   working files and compiler output.
+   */
+  void startedCompile(String moduleName, int compileId, CompileDir compileDir);
+
+  /**
+   * Called when a compile finishes.
+   * @param moduleName The same name passed to startedCompile
+   * @param compileId The same id passed to startedCompile
+   * @param success True if the compile succeeded.
+   */
+  void finishedCompile(String moduleName, int compileId, boolean success);
+
+  /**
+   * A listener that does nothing.
+   */
+  RecompileListener NONE = new RecompileListener() {
+    @Override
+    public void startedCompile(String moduleName, int compileId, CompileDir compileDir) {
+    }
+
+    @Override
+    public void finishedCompile(String moduleName, int compileId, boolean success) {
+    }
+  };
+
+}

dev/codeserver/java/com/google/gwt/dev/codeserver/Recompiler.java

@@ -50,6 +50,8 @@ class Recompiler {
   private final AppSpace appSpace;
   private final String originalModuleName;
   private final List<File> sourcePath;
+  private final RecompileListener listener;
+  private final boolean failIfListenerFails;
   private final TreeLogger logger;
   private String serverPrefix;
   private int compilesDone = 0;
@@ -62,10 +64,13 @@ class Recompiler {
       new AtomicReference<ResourceLoader>();
 
   Recompiler(AppSpace appSpace, String moduleName, List<File> sourcePath,
-             String serverPrefix, TreeLogger logger) {
+      String serverPrefix, RecompileListener listener, boolean failIfListenerFails,
+      TreeLogger logger) {
     this.appSpace = appSpace;
     this.originalModuleName = moduleName;
     this.sourcePath = sourcePath;
+    this.listener = listener;
+    this.failIfListenerFails = failIfListenerFails;
     this.logger = logger;
     this.serverPrefix = serverPrefix;
   }
@@ -82,25 +87,52 @@ synchronized CompileDir compile(Map<String, String> bindingProperties)
     }
 
     long startTime = System.currentTimeMillis();
-    CompileDir compileDir = makeCompileDir(++compilesDone);
+    int compileId = ++compilesDone;
+    CompileDir compileDir = makeCompileDir(compileId);
     TreeLogger compileLogger = makeCompileLogger(compileDir);
 
-    ModuleDef module = loadModule(compileLogger, bindingProperties);
-    String newModuleName = module.getName(); // includes any rename
-    moduleName.set(newModuleName);
+    boolean listenerFailed = false;
+    try {
+      listener.startedCompile(originalModuleName, compileId, compileDir);
+    } catch (Exception e) {
+      compileLogger.log(TreeLogger.Type.WARN, "listener threw exception", e);
+      listenerFailed = true;
+    }
 
+    boolean success = false;
+    try {
 
-    CompilerOptions options = new CompilerOptionsImpl(compileDir, newModuleName);
+      ModuleDef module = loadModule(compileLogger, bindingProperties);
+      String newModuleName = module.getName(); // includes any rename
+      moduleName.set(newModuleName);
+
+
+      CompilerOptions options = new CompilerOptionsImpl(compileDir, newModuleName);
+
+      success = new Compiler(options).run(compileLogger, module);
+      lastBuild.set(compileDir); // makes compile log available over HTTP
+
+    } finally {
+      try {
+        listener.finishedCompile(originalModuleName, compileId, success);
+      } catch (Exception e) {
+        compileLogger.log(TreeLogger.Type.WARN, "listener threw exception", e);
+        listenerFailed = true;
+      }
+    }
 
-    boolean success = new Compiler(options).run(compileLogger, module);
-    lastBuild.set(compileDir);
     if (!success) {
       compileLogger.log(TreeLogger.Type.ERROR, "Compiler returned " + success);
       throw new UnableToCompleteException();
     }
 
     long elapsedTime = System.currentTimeMillis() - startTime;
     compileLogger.log(TreeLogger.Type.INFO, "Compile completed in " + elapsedTime + " ms");
+
+    if (failIfListenerFails && listenerFailed) {
+      throw new UnableToCompleteException();
+    }
+
     return compileDir;
   }