Improved watch goal (still having problems with generated repo)

Author: adrienlauer

src/license/THIRD-PARTY.properties

@@ -13,7 +13,7 @@
 # Please fill the missing licenses for dependencies :
 #
 #
-#Wed Nov 29 15:23:13 CET 2017
+#Wed Nov 29 22:13:09 CET 2017
 classworlds--classworlds--1.1-alpha-2=
 commons-collections--commons-collections--3.1=
 dom4j--dom4j--1.6.1=

src/main/java/org/seedstack/maven/SeedStackUtils.java

@@ -8,6 +8,7 @@
 
 package org.seedstack.maven;
 
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import org.apache.maven.plugin.MojoExecutionException;
 
@@ -34,7 +35,7 @@ public static Object getSeedLauncher() throws Exception {
             }
             return getLauncherMethod.invoke(null);
         } catch (Exception e) {
-            throw new MojoExecutionException("Cannot launch SeedStack application", e);
+            throw new MojoExecutionException("Cannot launch SeedStack application", unwrapException(e));
         }
     }
 
@@ -50,18 +51,27 @@ public static Object getToolLauncher(String tool) throws MojoExecutionException
             }
             return getLauncherMethod.invoke(null, tool);
         } catch (Exception e) {
-            throw new MojoExecutionException("Cannot launch SeedStack tool", e);
+            throw new MojoExecutionException("Cannot launch SeedStack tool", unwrapException(e));
         }
     }
 
     public static void launch(Object seedLauncher, String[] args) throws Exception {
-        Method launchMethod = seedLauncher.getClass().getMethod("launch", String[].class);
-        launchMethod.invoke(seedLauncher, new Object[]{args});
+        try {
+            Method launchMethod = seedLauncher.getClass().getMethod("launch", String[].class);
+            launchMethod.invoke(seedLauncher, new Object[]{args});
+        } catch (Exception e) {
+            throw new MojoExecutionException("Cannot launch SeedStack application", unwrapException(e));
+
+        }
     }
 
     public static void shutdown(Object seedLauncher) throws Exception {
-        Method shutdownMethod = seedLauncher.getClass().getMethod("shutdown");
-        shutdownMethod.invoke(seedLauncher);
+        try {
+            Method shutdownMethod = seedLauncher.getClass().getMethod("shutdown");
+            shutdownMethod.invoke(seedLauncher);
+        } catch (Exception e) {
+            throw new MojoExecutionException("Cannot shutdown SeedStack application", unwrapException(e));
+        }
     }
 
     public static void refresh(Object seedLauncher) throws Exception {
@@ -70,8 +80,21 @@ public static void refresh(Object seedLauncher) throws Exception {
             refreshMethod = seedLauncher.getClass().getMethod("refresh");
         } catch (NoSuchMethodException e) {
             throw new MojoExecutionException("Application refresh is not supported before Seed 3.4.0", e);
+        }
+        try {
+            refreshMethod.invoke(seedLauncher);
+        } catch (Exception e) {
+            throw new MojoExecutionException("Unable to refresh SeedStack application", unwrapException(e));
+        }
+    }
 
+    private static Throwable unwrapException(Exception e) {
+        Throwable t;
+        if (e instanceof InvocationTargetException) {
+            t = ((InvocationTargetException) e).getTargetException();
+        } else {
+            t = e;
         }
-        refreshMethod.invoke(seedLauncher);
+        return t;
     }
 }

src/main/java/org/seedstack/maven/WatchMojo.java

@@ -128,7 +128,7 @@ public void run() {
     URLClassLoader getClassLoader(final URL[] classPathUrls) {
         reloadingClassLoader = AccessController.doPrivileged(new PrivilegedAction<ReloadingClassLoader>() {
             public ReloadingClassLoader run() {
-                return new ReloadingClassLoader(getLog(), classPathUrls);
+                return new ReloadingClassLoader(getLog(), classPathUrls, compileSourceRoots);
             }
         });
         return reloadingClassLoader;
@@ -189,6 +189,9 @@ private void refresh(Set<FileEvent> fileEvents) {
                         reloadingClassLoader.invalidateAllClasses();
                     }
 
+                    // Invalidate generated classes
+                    reloadingClassLoader.invalidateClassesFromPackage("org.seedstack.business.__generated");
+
                     // Recompile the sources
                     recompile();
 
@@ -276,7 +279,7 @@ private Set<String> collectClassNames(File classFile) throws MojoExecutionExcept
             try (FileInputStream is = new FileInputStream(classFile)) {
                 ClassReader classReader = new ClassReader(is);
                 classReader.accept(new ClassNameCollector(classNames), 0);
-            } catch (IOException e) {
+            } catch (Exception e) {
                 throw new MojoExecutionException("Unable to analyze class file " + classFile.getAbsolutePath());
             }
             return classNames;

src/main/java/org/seedstack/maven/classloader/ApplicationConfig.java

@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2013-2016, The SeedStack authors <http://seedstack.org>
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+package org.seedstack.maven.classloader;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.security.CodeSigner;
+import java.security.CodeSource;
+import java.security.SecureClassLoader;
+import sun.misc.Resource;
+
+class DisposableClassLoader extends SecureClassLoader {
+    private final ReloadingClassLoader reloadingClassLoader;
+    private final Resource res;
+    private final String name;
+
+    DisposableClassLoader(ReloadingClassLoader reloadingClassLoader, String name, Resource res) {
+        this.reloadingClassLoader = reloadingClassLoader;
+        this.name = name;
+        this.res = res;
+    }
+
+    @Override
+    public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+        if (this.name.equals(name)) {
+            synchronized (getClassLoadingLock(name)) {
+                // First, check if the class has already been loaded
+                Class<?> c = findLoadedClass(name);
+                if (c == null) {
+                    try {
+                        ByteBuffer byteBuffer = res.getByteBuffer();
+                        if (byteBuffer != null) {
+                            // Use (direct) ByteBuffer:
+                            CodeSigner[] signers = res.getCodeSigners();
+                            CodeSource cs = new CodeSource(res.getURL(), signers);
+                            c = defineClass(name, byteBuffer, cs);
+                        } else {
+                            byte[] b = res.getBytes();
+                            // must read certificates AFTER reading bytes.
+                            CodeSigner[] signers = res.getCodeSigners();
+                            CodeSource cs = new CodeSource(res.getURL(), signers);
+                            c = defineClass(name, b, 0, b.length, cs);
+                        }
+                    } catch (IOException e) {
+                        throw new ClassNotFoundException(name, e);
+                    }
+                    if (resolve) {
+                        resolveClass(c);
+                    }
+                }
+                return c;
+            }
+        } else {
+            return reloadingClassLoader.loadClass(name, resolve);
+        }
+    }
+
+
+}