PR feedback

Author: ldematte

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/dependencies/patches/PatcherInfo.java

@@ -16,12 +16,23 @@
 import java.util.HexFormat;
 import java.util.function.Function;
 
-public record PatcherInfo(String jarEntryName, byte[] classSha256, Function<ClassWriter, ClassVisitor> visitorFactory) {
+public final class PatcherInfo {
+    private final String jarEntryName;
+    private final byte[] classSha256;
+    private final Function<ClassWriter, ClassVisitor> visitorFactory;
+
+    private PatcherInfo(String jarEntryName, byte[] classSha256, Function<ClassWriter, ClassVisitor> visitorFactory) {
+        this.jarEntryName = jarEntryName;
+        this.classSha256 = classSha256;
+        this.visitorFactory = visitorFactory;
+    }
+
     /**
      * Creates a patcher info entry, linking a jar entry path name and its SHA256 digest to a patcher factory (a factory to create an ASM
      * visitor)
-     * @param jarEntryName the jar entry path, as a string
-     * @param classSha256 the SHA256 digest of the class bytes, as a HEX string
+     *
+     * @param jarEntryName   the jar entry path, as a string
+     * @param classSha256    the SHA256 digest of the class bytes, as a HEX string
      * @param visitorFactory the factory to create an ASM visitor from a ASM writer
      */
     public static PatcherInfo classPatcher(String jarEntryName, String classSha256, Function<ClassWriter, ClassVisitor> visitorFactory) {
@@ -31,4 +42,16 @@ public static PatcherInfo classPatcher(String jarEntryName, String classSha256,
     boolean matches(byte[] otherClassSha256) {
         return Arrays.equals(this.classSha256, otherClassSha256);
     }
+
+    public String jarEntryName() {
+        return jarEntryName;
+    }
+
+    public byte[] classSha256() {
+        return classSha256;
+    }
+
+    public ClassVisitor createVisitor(ClassWriter classWriter) {
+        return visitorFactory.apply(classWriter);
+    }
 }

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/dependencies/patches/Utils.java

@@ -18,6 +18,7 @@
 import java.io.InputStream;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Enumeration;
 import java.util.HexFormat;
@@ -43,9 +44,26 @@ public class Utils {
         }
     }
 
+    private record MismatchInfo(String jarEntryName, String expectedClassSha256, String foundClassSha256) {
+        @Override
+        public String toString() {
+            return "[class='"
+                + jarEntryName
+                + '\''
+                + ", expected='"
+                + expectedClassSha256
+                + '\''
+                + ", found='"
+                + foundClassSha256
+                + '\''
+                + ']';
+        }
+    }
+
     /**
-     * Patches the classes in the input JAR file, using the collection of patchers. If the patcher info specify a SHA256 digest, and
-     * the class to patch does not match it, an IllegalArgumentException is thrown.
+     * Patches the classes in the input JAR file, using the collection of patchers. Each patcher specifies a target class (its jar entry
+     * name) and the SHA256 digest on the class bytes.
+     * This digest is checked against the class bytes in the JAR, and if it does not match, an IllegalArgumentException is thrown.
      * If the input file does not contain all the classes to patch specified in the patcher info collection, an IllegalArgumentException
      * is also thrown.
      * @param inputFile the JAR file to patch
@@ -54,6 +72,7 @@ public class Utils {
      */
     public static void patchJar(File inputFile, File outputFile, Collection<PatcherInfo> patchers) {
         var classPatchers = patchers.stream().collect(Collectors.toMap(PatcherInfo::jarEntryName, Function.identity()));
+        var mismatchedClasses = new ArrayList<MismatchInfo>();
         try (JarFile jarFile = new JarFile(inputFile); JarOutputStream jos = new JarOutputStream(new FileOutputStream(outputFile))) {
             Enumeration<JarEntry> entries = jarFile.entries();
             while (entries.hasMoreElements()) {
@@ -67,27 +86,20 @@ public static void patchJar(File inputFile, File outputFile, Collection<PatcherI
                     byte[] classToPatch = jarFile.getInputStream(entry).readAllBytes();
                     var classSha256 = SHA_256.digest(classToPatch);
 
-                    if (classPatcher.matches(classSha256) == false) {
-                        throw new IllegalArgumentException(
-                            String.format(
-                                Locale.ROOT,
-                                """
-                                    Error patching JAR [%s]: SHA256 digest mismatch for class [%s] (expected: [%s], \
-                                    found: [%s]). This JAR was updated to a version that contains a different class, \
-                                    for which this patcher was not designed for. Please check if the patcher still \
-                                    applies correctly to this class, and update its SHA256 digest.""",
-                                inputFile.getName(),
+                    if (classPatcher.matches(classSha256)) {
+                        ClassReader classReader = new ClassReader(classToPatch);
+                        ClassWriter classWriter = new ClassWriter(classReader, COMPUTE_MAXS | COMPUTE_FRAMES);
+                        classReader.accept(classPatcher.createVisitor(classWriter), 0);
+                        jos.write(classWriter.toByteArray());
+                    } else {
+                        mismatchedClasses.add(
+                            new MismatchInfo(
                                 classPatcher.jarEntryName(),
                                 HexFormat.of().formatHex(classPatcher.classSha256()),
                                 HexFormat.of().formatHex(classSha256)
                             )
                         );
                     }
-
-                    ClassReader classReader = new ClassReader(classToPatch);
-                    ClassWriter classWriter = new ClassWriter(classReader, COMPUTE_MAXS | COMPUTE_FRAMES);
-                    classReader.accept(classPatcher.visitorFactory().apply(classWriter), 0);
-                    jos.write(classWriter.toByteArray());
                 } else {
                     // Read the entry's data and write it to the new JAR
                     try (InputStream is = jarFile.getInputStream(entry)) {
@@ -100,6 +112,20 @@ public static void patchJar(File inputFile, File outputFile, Collection<PatcherI
             throw new RuntimeException(ex);
         }
 
+        if (mismatchedClasses.isEmpty() == false) {
+            throw new IllegalArgumentException(
+                String.format(
+                    Locale.ROOT,
+                    """
+                        Error patching JAR [%s]: SHA256 digest mismatch (%s). This JAR was updated to a version that contains different \
+                        classes, for which this patcher was not designed. Please check if the patcher still \
+                        applies correctly, and update the SHA256 digest(s).""",
+                    inputFile.getName(),
+                    mismatchedClasses.stream().map(MismatchInfo::toString).collect(Collectors.joining())
+                )
+            );
+        }
+
         if (classPatchers.isEmpty() == false) {
             throw new IllegalArgumentException(
                 String.format(