[#8890] Delegate parsing jar files into ModulePath

Author: youngjin.kim2

bootstraps/bootstrap-java9-internal/src/main/java/com/navercorp/pinpoint/bootstrap/java9/module/InternalModules.java

@@ -19,13 +19,8 @@
 import jdk.internal.loader.BootLoader;
 import jdk.internal.module.Modules;
 
-import java.lang.module.Configuration;
 import java.lang.module.ModuleDescriptor;
-import java.lang.module.ModuleFinder;
 import java.net.URI;
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
 
 final class InternalModules {
 
@@ -52,17 +47,7 @@ static Module defineModule(ClassLoader loader,
                                       ModuleDescriptor descriptor,
                                       URI uri)
     {
-        final String moduleName = descriptor.name();
-        final ModuleLayer parent = ModuleLayer.boot();
-
-        final ModuleFinder before = new SingleModuleFinder(descriptor, uri);
-        final Configuration cf = parent.configuration().resolve(before, ModuleFinder.of(), Set.of(moduleName));
-        final Module module = ModuleLayer.defineModules(cf, List.of(parent), name -> loader)
-                .layer()
-                .findModule(moduleName)
-                .orElse(null);
-
-        return Objects.requireNonNull(module, moduleName);
+        return Modules.defineModule(loader, descriptor, uri);
     }
 
 

bootstraps/bootstrap-java9/src/main/java/com/navercorp/pinpoint/bootstrap/java9/module/ConcatInputStream.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2022 NAVER Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.navercorp.pinpoint.bootstrap.java9.module;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Iterator;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Supplier;
+
+/**
+ * @author youngjin.kim2
+ */
+public class ConcatInputStream extends InputStream {
+
+    private final Iterator<Supplier<Optional<InputStream>>> it;
+    private byte[] current;
+    private int cursor = 0;
+
+    public ConcatInputStream(Iterable<Supplier<Optional<InputStream>>> children) {
+        this.it = children.iterator();
+    }
+
+    @Override
+    public int read() throws IOException {
+        if (Objects.isNull(current) || cursor >= current.length) {
+            if (!augment()) {
+                return -1;
+            }
+        }
+        return current[cursor++];
+    }
+
+    private boolean augment() throws IOException {
+        while (it.hasNext()) {
+            final Optional<InputStream> stream = it.next().get();
+            if (!stream.isPresent()) {
+                continue;
+            }
+
+            current = stream.get().readAllBytes();
+            cursor = 0;
+            return true;
+        }
+
+        return false;
+    }
+}

bootstraps/bootstrap-java9/src/main/java/com/navercorp/pinpoint/bootstrap/java9/module/FixedReaderModuleReference.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2022 NAVER Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.navercorp.pinpoint.bootstrap.java9.module;
+
+import java.lang.module.ModuleDescriptor;
+import java.lang.module.ModuleReader;
+import java.lang.module.ModuleReference;
+import java.net.URI;
+
+/**
+ * @author youngjin.kim2
+ */
+class FixedReaderModuleReference extends ModuleReference {
+
+    private final ModuleReader moduleReader;
+
+    public FixedReaderModuleReference(ModuleDescriptor desc, URI uri, ModuleReader moduleReader) {
+        super(desc, uri);
+        this.moduleReader = moduleReader;
+    }
+
+    @Override
+    public ModuleReader open() {
+        return moduleReader;
+    }
+
+}

bootstraps/bootstrap-java9/src/main/java/com/navercorp/pinpoint/bootstrap/java9/module/JarCleaner.java

@@ -0,0 +1,142 @@
+/*
+ * Copyright 2022 NAVER Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.navercorp.pinpoint.bootstrap.java9.module;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Enumeration;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.jar.Attributes;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.Manifest;
+import java.util.zip.ZipOutputStream;
+
+/**
+ * Some libraries may contains illegal automatic module name.
+ * @author youngjin.kim2
+ */
+public class JarCleaner {
+
+    private static final String AUTOMATIC_MODULE_NAME = "Automatic-Module-Name";
+    private static final String cleanModuleNamePrefix = "pinpoint.dep";
+
+    private static final AtomicInteger tempCounter = new AtomicInteger(0);
+
+    /**
+     * Re-produces new jar file which has exactly same content in same entries,
+     * but only value of automatic-module-name in manifest.mf is replaced with "pinpoint.dep[\d]*".
+     * <br><br>
+     * Some of libraries may have illegal `Automatic-Module-Name` in their `MANIFEST.MF`, and this
+     * method prevents that those attributes ruins validation in loading modules by replacing the
+     * attribute
+     * <br><br>
+     * CAUTION: The original jarFile in `uri` is removed, and replaced with new one in success.
+     *
+     * @param uri the location of original jar file
+     */
+    public static void clean(URI uri) {
+        try {
+            doCleanByURI(uri);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static void doCleanByURI(URI uri) throws IOException {
+        if (!uri.toString().endsWith(".jar")) {
+            return;
+        }
+
+        try (final JarFile jarFile = new JarFile(new File(uri))) {
+            if (isDirty(jarFile)) {
+                rewriteAutomaticModuleName(jarFile, uri);
+            }
+        }
+    }
+
+    private static boolean isDirty(JarFile jarFile) throws IOException {
+        final Manifest manifest = jarFile.getManifest();
+        if (Objects.isNull(manifest)) {
+            return true;
+        }
+
+        final Attributes attrs = manifest.getMainAttributes();
+        if (Objects.isNull(attrs)) {
+            return true;
+        }
+
+        final String moduleName = attrs.getValue(AUTOMATIC_MODULE_NAME);
+        if (Objects.isNull(moduleName)) {
+            return true;
+        }
+
+        return !moduleName.startsWith(cleanModuleNamePrefix);
+    }
+
+    private static void rewriteAutomaticModuleName(JarFile jarFile, URI uri) throws IOException {
+        final Path outPath = Files.createTempFile("pinpoint_tmp_", ".jar");
+        final ZipOutputStream outStream = new ZipOutputStream(Files.newOutputStream(outPath.toFile().toPath()));
+
+        final Enumeration<JarEntry> entries = jarFile.entries();
+        while (entries.hasMoreElements()) {
+            final JarEntry entry = entries.nextElement();
+
+            final InputStream inputStream = jarFile.getInputStream(entry);
+            final byte[] bytes = transform(entry.getName(), inputStream.readAllBytes());
+            inputStream.close();
+
+            outStream.putNextEntry(new JarEntry(entry.getName()));
+            outStream.write(bytes);
+            outStream.closeEntry();
+        }
+
+        outStream.close();
+        if (!outPath.toFile().renameTo(new File(uri))) {
+            throw new RuntimeException("Failed to rename lib jar");
+        }
+    }
+
+    private static byte[] transform(String name, byte[] bytes) {
+        if (!name.contains("MANIFEST.MF")) {
+            return bytes;
+        }
+
+        final String raw = new String(bytes);
+        final String[] lines = raw.replaceAll("\r", "").split("\n");
+
+        final StringBuilder builder = new StringBuilder();
+        for (final String line: lines) {
+            if (line.isEmpty() || line.toLowerCase().startsWith(AUTOMATIC_MODULE_NAME.toLowerCase())) {
+                continue;
+            }
+            builder.append(line).append("\r\n");
+        }
+        builder.append(AUTOMATIC_MODULE_NAME).append(": ").append(nextModuleName())
+                .append("\r\n\r\n");
+        return builder.toString().getBytes();
+    }
+
+    private static String nextModuleName() {
+        return cleanModuleNamePrefix + tempCounter.incrementAndGet();
+    }
+
+}

bootstraps/bootstrap-java9/src/main/java/com/navercorp/pinpoint/bootstrap/java9/module/MergedModuleReader.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2022 NAVER Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.navercorp.pinpoint.bootstrap.java9.module;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.module.ModuleReader;
+import java.lang.module.ModuleReference;
+import java.net.URI;
+import java.util.*;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+class MergedModuleReader implements ModuleReader {
+
+    private final Set<String> entries = new HashSet<>();
+    private final Map<String, Set<ModuleReference>> nameToModuleRefs = new HashMap<>();
+
+    public MergedModuleReader(Iterable<ModuleReference> moduleRefs) throws IOException {
+        for (final ModuleReference ref : moduleRefs) {
+            try (final ModuleReader reader = ref.open()) {
+                reader.list().forEach(name -> {
+                    entries.add(name);
+                    nameToModuleRefs.computeIfAbsent(name, k -> new HashSet<>()).add(ref);
+                });
+            }
+        }
+    }
+
+    @Override
+    public Optional<URI> find(String name) throws IOException {
+        for (final ModuleReference ref : nameToModuleRefs.get(name)) {
+            try (final ModuleReader subModuleFinder = ref.open()) {
+                final Optional<URI> result = subModuleFinder.find(name);
+                if (result.isPresent()) {
+                    return result;
+                }
+            }
+        }
+        return Optional.empty();
+    }
+
+    @Override
+    public Stream<String> list() throws IOException {
+        return entries.stream();
+    }
+
+    @Override
+    public void close() throws IOException {
+    }
+
+    @Override
+    public Optional<InputStream> open(String name) throws IOException {
+        if (!entries.contains(name)) {
+            return Optional.empty();
+        }
+
+        return Optional.of(buildInputStream(name));
+    }
+
+    private InputStream buildInputStream(String name) {
+        final List<Supplier<Optional<InputStream>>> children = new ArrayList<>();
+        for (final ModuleReference ref: nameToModuleRefs.get(name)) {
+            children.add(() -> {
+                try {
+                    return ref.open().open(name);
+                } catch (IOException e) {
+                    throw new RuntimeException("Failed to open child", e);
+                }
+            });
+        }
+        return new ConcatInputStream(children);
+    }
+
+}