Merge pull request #13 from Simplix-Softworks/shading

Hotfix

Author: KotlinFactory

simplixcore-common/simplixcore-common-api/src/main/java/dev/simplix/core/common/inject/SimplixInstaller.java

@@ -29,7 +29,10 @@
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 import java.util.logging.Logger;
-import lombok.*;
+import lombok.AllArgsConstructor;
+import lombok.Cleanup;
+import lombok.NonNull;
+import lombok.SneakyThrows;
 import org.jetbrains.annotations.Nullable;
 import org.reflections.Reflections;
 
@@ -51,12 +54,12 @@ public class SimplixInstaller {
       .registerTypeAdapter(UpdatePolicy.class, new UpdatePolicyDeserializer())
       .create();
   private final Timer updateTimer = new Timer("UpdateTimer");
+  private final org.slf4j.Logger log;
   private Platform platform;
   private Injector bossInjector;
   private DependencyLoader dependencyLoader;
   private LibraryLoader libraryLoader;
   private Updater updater;
-  private final org.slf4j.Logger log;
 
   public SimplixInstaller(org.slf4j.Logger logger) {
     this.log = logger;
@@ -103,13 +106,31 @@ public Optional<DependencyLoadingException> register(
       @NonNull Class<?> owner,
       @NonNull Consumer<Exception> onException,
       @NonNull Module... modules) {
+    return register(owner, onException, false, modules);
+  }
+
+  /**
+   * This will register a class annotated with {@link SimplixApplication}.
+   *
+   * @param owner       The main class of the application
+   * @param onException Will accept the exception if some exception occurs while installing
+   * @param isLibrary   Defines whether the application is a library or not
+   * @param modules     Pre-constructed modules which shall be available in the injection context
+   * @throws IllegalArgumentException when the owner class is not annotated with {@link
+   *                                  SimplixApplication}
+   */
+  public Optional<DependencyLoadingException> register(
+      @NonNull Class<?> owner,
+      @NonNull Consumer<Exception> onException,
+      boolean isLibrary,
+      @NonNull Module... modules) {
     if (!owner.isAnnotationPresent(SimplixApplication.class)) {
       throw new IllegalArgumentException("Owner class must be annotated with @SimplixApplication");
     }
     SimplixApplication application = owner.getAnnotation(SimplixApplication.class);
     if (this.toInstall.containsKey(application.name())) {
       log.debug(SIMPLIX_BOOTSTRAP + application.name() + " is already registered. Please check " +
-               "for unnecessary double registration of your application.");
+                "for unnecessary double registration of your application.");
       return Optional.empty();
     }
     Set<String> basePackages = determineBasePackages(owner);
@@ -126,6 +147,7 @@ public Optional<DependencyLoadingException> register(
         new InstallationContext(owner, new Reflections(basePackages, owner.getClassLoader()),
             info, detectReferencedModules(owner, modules, application.name()), onException));
     final Optional<DependencyLoadingException> optionalDependencyLoadingException = processRemoteDependencies(
+        isLibrary,
         owner,
         info);
     if (this.bossInjector != null) {
@@ -384,10 +406,14 @@ private boolean installApplication(
    * @throws JsonParseException If the dependencies.json file is formatted invalidly
    */
   @SneakyThrows
-  private Optional<DependencyManifest> loadDependencies(@NonNull Class<?> appOwner)
+  private Optional<DependencyManifest> loadDependencies(
+      boolean isLibrary,
+      @NonNull Class<?> appOwner)
       throws JsonParseException {
     @Cleanup
-    InputStream inputStream = appOwner.getResourceAsStream("/dependencies.json");
+    InputStream inputStream = isLibrary
+        ? appOwner.getResourceAsStream("/library-dependencies.json")
+        : appOwner.getResourceAsStream("/dependencies.json");
 
     if (inputStream == null) {
       return Optional.empty();
@@ -425,10 +451,11 @@ public Optional<DependencyLoadingException> earlyLoadDependencies(
     this.platform = platform;
     ApplicationInfo tempInfo = new ApplicationInfo(appClass.getSimpleName(),
         "1.0", new String[0], new File("."), new String[0]);
-    return processRemoteDependencies(appClass, tempInfo);
+    return processRemoteDependencies(false, appClass, tempInfo);
   }
 
   private Optional<DependencyLoadingException> processRemoteDependencies(
+      boolean isLibrary,
       @NonNull Class<?> appOwner,
       @NonNull ApplicationInfo info) {
     if (this.dependencyLoader == null) {
@@ -441,7 +468,7 @@ private Optional<DependencyLoadingException> processRemoteDependencies(
     Optional<DependencyManifest> optionalDependencies;
 
     try {
-      optionalDependencies = loadDependencies(appOwner);
+      optionalDependencies = loadDependencies(isLibrary, appOwner);
     } catch (JsonParseException jsonParseException) {
       log.error(
           SIMPLIX_BOOTSTRAP + info.name() + ": Cannot parse dependencies.json",
@@ -462,10 +489,10 @@ private Optional<DependencyLoadingException> processRemoteDependencies(
         continue;
       }
       log.debug(SIMPLIX_BOOTSTRAP
-               + info.name()
-               + ": Load dependency "
-               + dependency
-               + " from repository...");
+                + info.name()
+                + ": Load dependency "
+                + dependency
+                + " from repository...");
       dependency.applicationName(info.name());
       dependency.applicationClass(appOwner);
       final Optional<DependencyLoadingException> load = this.dependencyLoader.load(
@@ -646,9 +673,9 @@ private void detectComponents(
         }
         simplixModule.components().put(componentClass, component);
         log.debug(SIMPLIX_BOOTSTRAP
-                 + context.applicationInfo.name()
-                 + ": Detected "
-                 + componentClass.getName());
+                  + context.applicationInfo.name()
+                  + ": Detected "
+                  + componentClass.getName());
       } catch (Throwable throwable) {
         if (suppressWarning(componentClass, "exception:*")
             || suppressWarning(
@@ -731,6 +758,7 @@ static final class InstallationContext {
     private final Module[] modules;
     private final Consumer<Exception> onException;
 
+
   }
 
 }

simplixcore-common/simplixcore-common-implementation/src/main/java/dev/simplix/core/common/libloader/SimpleLibraryLoader.java

@@ -17,6 +17,7 @@
 import java.util.Set;
 import java.util.function.Function;
 import lombok.NonNull;
+import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 
 public class SimpleLibraryLoader implements LibraryLoader {
@@ -25,6 +26,7 @@ public class SimpleLibraryLoader implements LibraryLoader {
   private final Gson gson = new GsonBuilder().create();
   private final Set<File> files = new HashSet<>();
   private Method addMethod;
+
   public SimpleLibraryLoader(@NonNull Logger log) {
     this.log = log;
     try {
@@ -64,7 +66,7 @@ public void loadLibrary(File file) {
   }
 
   @Override
-  public void loadLibraryEncapsulated(@NonNull File file, Class<?> owner) {
+  public void loadLibraryEncapsulated(@NonNull File file, @NotNull Class<?> owner) {
     try {
       if (files.contains(file)) {
         return;
@@ -77,10 +79,13 @@ public void loadLibraryEncapsulated(@NonNull File file, Class<?> owner) {
         loadLibrary(file);
         return;
       }
+
       addUrlToClassLoader((URLClassLoader) classLoader, file);
+      checkAndLoadSimplixApplication(file, classLoader);
+
       log.info("[Simplix | LibLoader] Loaded encapsulated library " + file.getName() +
                " for application " + owner.getSimpleName());
-      checkAndLoadSimplixApplication(file, classLoader);
+
     } catch (Exception ex) {
       log.info("[Simplix | LibLoader] Unable to load encapsulated library " + file.getName() +
                " for application " + owner.getSimpleName(), ex);
@@ -104,10 +109,15 @@ private void checkAndLoadSimplixApplication(@NonNull File file, ClassLoader clas
       try {
         Class<?> mainClass = classLoader.loadClass(libraryDescription.mainClass());
         if (mainClass.isAnnotationPresent(SimplixApplication.class)) {
-          SimplixInstaller.instance().register(mainClass);
+          SimplixInstaller.instance().register(mainClass, exception -> {
+            log.error("Could not install library: "
+                      + mainClass.getSimpleName()
+                      + " due to "
+                      + exception.getMessage());
+          }, true);
           log.debug("[Simplix | LibLoader] "
-                   + libraryDescription.name()
-                   + " was registered as a SimplixApplication");
+                    + libraryDescription.name()
+                    + " was registered as a SimplixApplication");
           log.debug("[Simplix | LibLoader] Application class = "
                     + mainClass.getName()
                     + " hashCode = "