better error print for jooby run

jknack · jknack · commit cc516696b572 · 2019-07-29T08:40:20.000-03:00
diff --git a/modules/jooby-maven-plugin/src/main/java/io/jooby/maven/RunMojo.java b/modules/jooby-maven-plugin/src/main/java/io/jooby/maven/RunMojo.java
@@ -160,7 +160,7 @@ public class RunMojo extends AbstractMojo {
       joobyRun.start();
     } catch (MojoExecutionException | MojoFailureException x) {
       throw x;
-    } catch (Exception x) {
+    } catch (Throwable x) {
       throw new MojoFailureException("jooby-run resulted in exception", x);
     }
   }
diff --git a/modules/jooby-netty/src/main/java/io/jooby/netty/Netty.java b/modules/jooby-netty/src/main/java/io/jooby/netty/Netty.java
@@ -128,7 +128,6 @@ public class Netty extends Server.Base {
   }
 
   @Nonnull @Override public synchronized Server stop() {
-    System.out.println("ssss");
     fireStop(applications);
     if (acceptor != null) {
       acceptor.shutdownGracefully();
diff --git a/modules/jooby-run/pom.xml b/modules/jooby-run/pom.xml
@@ -16,6 +16,7 @@
     <dependency>
       <groupId>io.jooby</groupId>
       <artifactId>jooby</artifactId>
+      <version>${jooby.version}</version>
       <!-- Scope MUST BE provided. See io.jooby.run.ServerRef -->
       <scope>provided</scope>
     </dependency>
diff --git a/modules/jooby-run/src/main/java/io/jooby/run/JoobyRun.java b/modules/jooby-run/src/main/java/io/jooby/run/JoobyRun.java
@@ -15,6 +15,7 @@
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
 import java.nio.file.ClosedWatchServiceException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -65,25 +66,73 @@ private static class AppModule {
       this.contextClassLoader = contextClassLoader;
     }
 
-    public void start() {
+    public Exception start() {
       try {
-        System.setProperty("___jooby_run_hook__", SERVER_REF);
-        // Track the number of restarts
-        System.setProperty("joobyRun.counter", Integer.toString(counter++));
-
         module = loader.loadModule(conf.getProjectName());
         ModuleClassLoader classLoader = module.getClassLoader();
         Thread.currentThread().setContextClassLoader(classLoader);
 
+        if (counter == 0) {
+          // main class must exists
+          module.getClassLoader().loadClass(conf.getMainClass());
+        }
+
+        System.setProperty("___jooby_run_hook__", SERVER_REF);
+        // Track the number of restarts
+        System.setProperty("joobyRun.counter", Integer.toString(counter++));
+
         module.run(conf.getMainClass(),
             new String[]{"server.port=" + conf.getPort(), "server.join=false"});
-
-      } catch (Exception x) {
-        logger.error("execution of {} resulted in exception", conf.getMainClass(),
-            withoutReflection(x));
+      } catch (ClassNotFoundException x) {
+        String message = x.getMessage();
+        if (message.trim().startsWith(conf.getMainClass())) {
+          logger.error(
+              "Application class: '{}' not found. Possible solutions:\n  1) Make sure class exists\n  2) Class name is correct (no typo)",
+              conf.getMainClass());
+          // We must exit the JVM, due it is impossible to guess the main application.
+          return new ClassNotFoundException(conf.getMainClass());
+        } else {
+          printErr(x);
+        }
+      } catch (Throwable x) {
+        printErr(x);
       } finally {
         Thread.currentThread().setContextClassLoader(contextClassLoader);
       }
+      // In theory: application started successfully, then something went wrong. Still, users
+      // can fix the problem and recompile.
+      return null;
+    }
+
+    private void printErr(Throwable source) {
+      Throwable cause = withoutReflection(source);
+      System.out.println("CAUSE " + cause);
+      StackTraceElement[] stackTrace = cause.getStackTrace();
+      int truncateAt = stackTrace.length;
+      for (int i = 0; i < stackTrace.length; i++) {
+        StackTraceElement it = stackTrace[i];
+        if (it.getClassName().equals("org.jboss.modules.Module")) {
+          truncateAt = i;
+        }
+      }
+      if (truncateAt != stackTrace.length) {
+        StackTraceElement[] cleanstack = new StackTraceElement[truncateAt];
+        System.arraycopy(stackTrace, 0, cleanstack, 0, truncateAt);
+        cause.setStackTrace(cleanstack);
+      }
+      logger.error("execution of {} resulted in exception", conf.getMainClass(), cause);
+
+      // is fatal?
+      if (isFatal(source) || isFatal(cause)) {
+        sneakyThrow0(source);
+      }
+    }
+
+    private boolean isFatal(Throwable cause) {
+      return cause instanceof InterruptedException
+          || cause instanceof LinkageError
+          || cause instanceof ThreadDeath
+          || cause instanceof VirtualMachineError;
     }
 
     public void restart() {
@@ -97,10 +146,13 @@ public void close() {
     }
 
     private Throwable withoutReflection(Throwable cause) {
-      while (cause instanceof ReflectiveOperationException) {
-        cause = cause.getCause();
+      Throwable it = cause;
+      Throwable prev = cause;
+      while (it instanceof InvocationTargetException) {
+        prev = it;
+        it = it.getCause();
       }
-      return cause;
+      return it == null ? prev : it;
     }
 
     private void unloadModule() {
@@ -192,9 +244,9 @@ public boolean addResource(Path path) {
   /**
    * Start the application.
    *
-   * @throws Exception If something goes wrong.
+   * @throws Throwable If something goes wrong.
    */
-  public void start() throws Exception {
+  public void start() throws Throwable {
     this.watcher = newWatcher();
     try {
       logger.debug("project: {}", toString());
@@ -205,8 +257,14 @@ public void start() throws Exception {
       ExtModuleLoader loader = new ExtModuleLoader(finders);
       module = new AppModule(logger, loader, Thread.currentThread().getContextClassLoader(),
           options);
-      module.start();
-      watcher.watch();
+      Exception error = module.start();
+      if (error == null) {
+        watcher.watch();
+      } else {
+        // exit
+        shutdown();
+        throw error;
+      }
     } catch (ClosedWatchServiceException expected) {
       logger.trace("Watcher.close resulted in exception", expected);
     }
@@ -277,4 +335,9 @@ private void onFileChange(DirectoryChangeEvent.EventType kind, Path path) {
       }
     }
   }
+
+  @SuppressWarnings("unchecked")
+  private static <E extends Throwable> void sneakyThrow0(final Throwable x) throws E {
+    throw (E) x;
+  }
 }
diff --git a/pom.xml b/pom.xml
@@ -287,6 +287,12 @@
         <version>${jooby.version}</version>
       </dependency>
 
+      <dependency>
+        <groupId>io.jooby</groupId>
+        <artifactId>jooby-run</artifactId>
+        <version>${jooby.version}</version>
+      </dependency>
+
       <dependency>
         <groupId>io.jooby</groupId>
         <artifactId>jooby-gradle-plugin</artifactId>

Original file line number	Diff line number	Diff line change
`@@ -160,7 +160,7 @@ public class RunMojo extends AbstractMojo {`
`160`	`160`	`joobyRun.start();`
`161`	`161`	`} catch (MojoExecutionException \| MojoFailureException x) {`
`162`	`162`	`throw x;`
`163`		`- } catch (Exception x) {`
	`163`	`+ } catch (Throwable x) {`
`164`	`164`	`throw new MojoFailureException("jooby-run resulted in exception", x);`
`165`	`165`	`}`
`166`	`166`	`}`
Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,6 @@ public class Netty extends Server.Base {`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`@Nonnull @Override public synchronized Server stop() {`
`131`		`- System.out.println("ssss");`
`132`	`131`	`fireStop(applications);`
`133`	`132`	`if (acceptor != null) {`
`134`	`133`	`acceptor.shutdownGracefully();`