Fixed it up abit...

Author: RealMangorage

build.gradle

@@ -25,7 +25,7 @@ plugins {
 apply plugin: 'maven-publish'
 
 group = 'org.mangorage'
-version = getLatestGitTag() + "." + getLatestGitVersion()
+version = getLatestGitTag() + "." + getLatestGitVersion() + "-beta"
 
 println("Version -> " + version)
 

src/main/java/org/mangorage/bootstrap/Bootstrap.java

@@ -30,7 +30,7 @@ public static void main(String[] args) throws IOException {
         JarHandler.safeHandle(Path.of("libraries"), Path.of("sorted-libraries"));
 
         List<Path> deleteFiles = List.of(
-                Path.of("sorted-libraries").resolve("okio-jvm-3.6.0.jar")
+                Path.of("sorted-libraries").resolve("okio-3.6.0.jar")
         );
 
         for (Path deleteFile : deleteFiles) {

src/main/java/org/mangorage/bootstrap/internal/ClassTransformers.java

@@ -4,16 +4,15 @@
 import org.mangorage.bootstrap.api.transformer.TransformResult;
 import org.mangorage.bootstrap.api.transformer.TransformerFlag;
 
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.atomic.AtomicReference;
 
 public final class ClassTransformers {
-    private final Map<String, Class<?>> classes = new HashMap<>(); // Transformed Class's
-    private final List<IClassTransformer> transformers = new ArrayList<>(); // Transformer's
+    private final Map<String, Class<?>> classes = new ConcurrentHashMap<>();
+    private final List<IClassTransformer> transformers = new CopyOnWriteArrayList<>(); // Transformer's
     private final ClassLoader loader;
 
     public ClassTransformers(ClassLoader loader) {
@@ -32,28 +31,13 @@ public boolean isEmpty() {
         return transformers.isEmpty();
     }
 
-    private byte[] getClassBytes(String clazz) {
-        try {
-            String className = clazz.replace('.', '/');
-            String classFileName = className + ".class";
+    public byte[] transform(String name, byte[] classData) {;
 
-            try (var is = loader.getResourceAsStream(classFileName)) {
-                if (is != null) return is.readAllBytes();
-            }
-        } catch (IOException e) {
-            return null;
-        }
-        return null;
-    }
-
-    public byte[] transform(String name) {
-        byte[] originalClassData = getClassBytes(name);
-
-        AtomicReference<TransformResult> result = new AtomicReference<>(TransformerFlag.NO_REWRITE.of(originalClassData));
+        AtomicReference<TransformResult> result = new AtomicReference<>(TransformerFlag.NO_REWRITE.of(classData));
         AtomicReference<IClassTransformer> _transformer = new AtomicReference<>();
 
         for (IClassTransformer transformer : transformers) {
-            result.set(transformer.transform(name, originalClassData));
+            result.set(transformer.transform(name, classData));
             if (result.get().flag() != TransformerFlag.NO_REWRITE) {
                 _transformer.set(transformer);
                 break;

src/main/java/org/mangorage/bootstrap/internal/LoadedModule.java

@@ -41,6 +41,10 @@ void addChild(LoadedModule module) {
         this.children.add(module);
     }
 
+    String name() {
+        return getModuleReference().descriptor().name();
+    }
+
     @Override
     public Optional<URI> find(String name) throws IOException {
         final var optional = getModuleReader().find(name);

src/main/java/org/mangorage/bootstrap/internal/MangoLoader.java

@@ -9,10 +9,10 @@
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.nio.ByteBuffer;
-import java.util.HashMap;
 import java.util.Map;
 import java.util.ServiceLoader;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 public final class MangoLoader extends URLClassLoader {
 
@@ -21,8 +21,10 @@ public final class MangoLoader extends URLClassLoader {
     }
 
     private ClassTransformers transformers = new ClassTransformers(this);
-    private final Map<String, LoadedModule> moduleMap = new HashMap<>();
-    private final Map<String, LoadedModule> localPackageToModule = new HashMap<>();
+    private final Map<String, LoadedModule> moduleMap = new ConcurrentHashMap<>();
+    private final Map<String, LoadedModule> localPackageToModule = new ConcurrentHashMap<>();
+
+
 
     public MangoLoader(URL[] urls, Set<ResolvedModule> modules, ClassLoader parent) {
         super(urls, parent);
@@ -76,46 +78,39 @@ void loadModuleConfiguration() {
                 });
     }
 
+    /**
+     * Loads the class with the specified binary name.
+     */
     @Override
-    protected Class<?> findClass(String name) throws ClassNotFoundException {
-        if (transformers == null || transformers.isEmpty())
-            return super.findClass(name);
+    protected Class<?> loadClass(String cn, boolean resolve) throws ClassNotFoundException
+    {
 
-        if (transformers.containsClass(name))
-            return transformers.getClazz(name);
+        synchronized (getClassLoadingLock(cn)) {
+            // check if already loaded
+            Class<?> c = findLoadedClass(cn);
 
-        byte[] originalBytes = getClassBytes(name);
+            if (c == null) {
 
-        if (originalBytes == null) {
-            throw new ClassNotFoundException("Failed to load original class bytes for " + name);
-        }
+                LoadedModule loadedModule = findLoadedModule(cn);
 
-        byte[] arr = transformers.transform(name);
-        if (arr != null) {
-            Class<?> clz = defineClass(name, arr);
-            transformers.add(name, clz);
-            return clz;
-        }
+                if (loadedModule != null) {
 
-        return super.findClass(name);
-    }
+                    // class is in module defined to this class loader
+                    c = defineClass(cn, loadedModule);
 
-    private byte[] getClassBytes(String clazz) {
-        try {
-            String className = clazz.replace('.', '/');
-            String classFileName = className + ".class";
-
-            try (var is = getResourceAsStream(classFileName)) {
-                if (is != null) return is.readAllBytes();
+                } else {
+                    return getParent().loadClass(cn);
+                }
             }
-        } catch (IOException e) {
-            return null;
-        }
-        return null;
-    }
 
-    private Class<?> defineClass(String name, byte[] bytes) {
-        return super.defineClass(name, bytes, 0, bytes.length);
+            if (c == null)
+                throw new ClassNotFoundException(cn);
+
+            if (resolve)
+                resolveClass(c);
+
+            return c;
+        }
     }
 
     @Override
@@ -131,6 +126,17 @@ protected URL findResource(String moduleName, String name) throws IOException {
         return null;
     }
 
+    @Override
+    protected Class<?> findClass(String cn) throws ClassNotFoundException {
+        Class<?> c = null;
+        LoadedModule loadedModule = findLoadedModule(cn);
+        if (loadedModule != null)
+            c = defineClass(cn, loadedModule);
+        if (c == null)
+            throw new ClassNotFoundException(cn);
+        return c;
+    }
+
     @Override
     protected Class<?> findClass(String moduleName, String name) {
         Class<?> c = null;
@@ -161,12 +167,24 @@ private Class<?> defineClass(String cn, LoadedModule loadedModule) {
                 return null;
             }
 
-            try {
-                return defineClass(cn, bb, loadedModule.getCodeSource());
-            } finally {
-                reader.release(bb);
-            }
+            if (transformers.containsClass(cn))
+                return transformers.getClazz(cn);
 
+            byte[] classbytes = bb.array();
+
+            byte[] classBytesModified = transformers.transform(cn, classbytes);
+
+            if (classBytesModified != null) {
+                Class<?> clz = defineClass(cn, classBytesModified, 0, classBytesModified.length, loadedModule.getCodeSource());
+                transformers.add(cn, clz);
+                return clz;
+            } else {
+                try {
+                    return defineClass(cn, bb, loadedModule.getCodeSource());
+                } finally {
+                    reader.release(bb);
+                }
+            }
         } catch (IOException ioe) {
             // TBD on how I/O errors should be propagated
             return null;