Load the CRC checksum from CRT using Class path loaders inst… (#5692)

* bugfix : Load the CRC checksum from CRT using Class path loaders instead of direct reference of crt related classes

* Handled PR comments

* Handled comment to make it private

Author: joviegas

.changes/next-release/bugfix-AWSSDKforJavav2-fef08e5.json

@@ -0,0 +1,6 @@
+{
+    "type": "bugfix",
+    "category": "AWS SDK for Java v2",
+    "contributor": "",
+    "description": "Load Checksum classes of CRT from Classloader instead of direct references of CRT classes."
+}

core/checksums/pom.xml

@@ -55,7 +55,7 @@
             <groupId>software.amazon.awssdk.crt</groupId>
             <artifactId>aws-crt</artifactId>
             <version>${awscrt.version}</version>
-            <optional>true</optional>
+            <scope>test</scope>
         </dependency>
 
         <dependency>

core/checksums/src/main/java/software/amazon/awssdk/checksums/SdkChecksum.java

@@ -19,8 +19,8 @@
 import java.util.zip.Checksum;
 import software.amazon.awssdk.annotations.SdkProtectedApi;
 import software.amazon.awssdk.checksums.internal.Crc32Checksum;
-import software.amazon.awssdk.checksums.internal.Crc32cProvider;
 import software.amazon.awssdk.checksums.internal.Crc64NvmeChecksum;
+import software.amazon.awssdk.checksums.internal.CrcChecksumProvider;
 import software.amazon.awssdk.checksums.internal.Md5Checksum;
 import software.amazon.awssdk.checksums.internal.Sha1Checksum;
 import software.amazon.awssdk.checksums.internal.Sha256Checksum;
@@ -39,7 +39,7 @@ public interface SdkChecksum extends Checksum {
     static SdkChecksum forAlgorithm(ChecksumAlgorithm algorithm) {
         switch (algorithm.algorithmId()) {
             case "CRC32C":
-                return Crc32cProvider.create();
+                return CrcChecksumProvider.crc32cImplementation();
             case "CRC32":
                 return new Crc32Checksum();
             case "SHA1":

core/checksums/src/main/java/software/amazon/awssdk/checksums/internal/Crc64NvmeChecksum.java

@@ -15,42 +15,50 @@
 
 package software.amazon.awssdk.checksums.internal;
 
-import static software.amazon.awssdk.utils.DependencyValidate.requireClass;
 import static software.amazon.awssdk.utils.NumericUtils.longToByte;
 
-import java.util.zip.Checksum;
 import software.amazon.awssdk.annotations.SdkInternalApi;
 import software.amazon.awssdk.checksums.SdkChecksum;
-import software.amazon.awssdk.crt.checksums.CRC64NVME;
 
 /**
  * Implementation of {@link SdkChecksum} to calculate an CRC64NVME checksum.
  */
 @SdkInternalApi
-public final class Crc64NvmeChecksum extends BaseCrcChecksum {
-    private static final String CRT_CRC64NVME_PATH = "software.amazon.awssdk.crt.checksums.CRC64NVME";
-    private static final String CRT_MODULE = "software.amazon.awssdk.crt:aws-crt";
+public final class Crc64NvmeChecksum implements SdkChecksum {
+
+    private final SdkChecksum sdkChecksum;
 
     public Crc64NvmeChecksum() {
-        super(getCrc64Nvme());
+        this.sdkChecksum = CrcChecksumProvider.crc64NvmeCrtImplementation();
     }
 
-    private static CRC64NVME getCrc64Nvme() {
-        requireClass(CRT_CRC64NVME_PATH, CRT_MODULE, "CRC64NVME");
-        return new CRC64NVME();
+    @Override
+    public byte[] getChecksumBytes() {
+        return longToByte(sdkChecksum.getValue());
     }
 
     @Override
-    public Checksum cloneChecksum(Checksum checksum) {
-        if (checksum instanceof CRC64NVME) {
-            return (Checksum) ((CRC64NVME) checksum).clone();
-        }
+    public void mark(int readLimit) {
+        this.sdkChecksum.mark(readLimit);
+    }
 
-        throw new IllegalStateException("Unsupported checksum");
+    @Override
+    public void update(int b) {
+        this.sdkChecksum.update(b);
     }
 
     @Override
-    public byte[] getChecksumBytes() {
-        return longToByte(getChecksum().getValue());
+    public void update(byte[] b, int off, int len) {
+        this.sdkChecksum.update(b, off, len);
+    }
+
+    @Override
+    public long getValue() {
+        return sdkChecksum.getValue();
+    }
+
+    @Override
+    public void reset() {
+        sdkChecksum.reset();
     }
 }

core/checksums/src/main/java/software/amazon/awssdk/checksums/internal/Crc32cProvider.java renamed to core/checksums/src/main/java/software/amazon/awssdk/checksums/internal/CrcChecksumProvider.java

@@ -18,23 +18,34 @@
 import java.util.zip.Checksum;
 import software.amazon.awssdk.annotations.SdkInternalApi;
 import software.amazon.awssdk.checksums.SdkChecksum;
-import software.amazon.awssdk.crt.checksums.CRC32C;
 
 /**
- * Utility class to provide different implementations of CRC32C checksum. This class supports the use of: 1. Java-based CRC32C
- * (Java 9+ when available) 2. CRT-based CRC32C (when available) 3. SDK-based CRC32C (as fallback)
+ * Utility class providing implementations of CRC checksums, specifically CRC32C and CRC64NVME.
+ *
+ * <p>Supports the following implementations for CRC32C:</p>
+ * <ul>
+ *     <li>Java-based CRC32C (Java 9+)</li>
+ *     <li>CRT-based CRC32C (using AWS CRT library)</li>
+ *     <li>SDK-based CRC32C (fallback)</li>
+ * </ul>
+ *
+ * <p>Only supports CRT-based implementation for CRC64NVME (using AWS CRT library).</p>
+ *
+ * <p>For internal use only ({@link SdkInternalApi}).</p>
  */
 @SdkInternalApi
-public final class Crc32cProvider {
+public final class CrcChecksumProvider {
 
 
     // Class paths for different CRC32C implementations
     private static final String CRT_CRC32C_CLASS_PATH = "software.amazon.awssdk.crt.checksums.CRC32C";
     private static final String JAVA_CRC32C_CLASS_PATH = "java.util.zip.CRC32C";
     private static final ConstructorCache CONSTRUCTOR_CACHE = new ConstructorCache();
+    private static final String CRT_CRC64NVME_PATH = "software.amazon.awssdk.crt.checksums.CRC64NVME";
+    private static final String CRT_MODULE = "software.amazon.awssdk.crt:aws-crt";
 
     // Private constructor to prevent instantiation
-    private Crc32cProvider() {
+    private CrcChecksumProvider() {
     }
 
     /**
@@ -44,7 +55,7 @@ private Crc32cProvider() {
      */
     static SdkChecksum createSdkBasedCrc32C() {
         SdkCrc32CChecksum sdkChecksum = SdkCrc32CChecksum.create();
-        return new CrcCloneOnMarkChecksum(sdkChecksum, checksumToClone -> ((SdkCrc32CChecksum) checksumToClone).clone());
+        return new CrcCloneOnMarkChecksum(sdkChecksum);
     }
 
     /**
@@ -54,7 +65,7 @@ static SdkChecksum createSdkBasedCrc32C() {
      *
      * @return An instance of {@link SdkChecksum}, based on the first available option.
      */
-    public static SdkChecksum create() {
+    public static SdkChecksum crc32cImplementation() {
         SdkChecksum checksum = createJavaCrc32C();
         if (checksum == null) {
             checksum = createCrtCrc32C();
@@ -65,14 +76,38 @@ public static SdkChecksum create() {
     static SdkChecksum createCrtCrc32C() {
         return CONSTRUCTOR_CACHE.getConstructor(CRT_CRC32C_CLASS_PATH).map(constructor -> {
             try {
-                return new CrcCloneOnMarkChecksum((Checksum) constructor.newInstance(), checksumToClone ->
-                    (Checksum) ((CRC32C) checksumToClone).clone());
-            } catch (ClassCastException | ReflectiveOperationException e) {
-                throw new IllegalStateException("Failed to instantiate " + JAVA_CRC32C_CLASS_PATH, e);
+                Checksum checksumInstance = (Checksum) constructor.newInstance();
+                return new CrcCloneOnMarkChecksum(checksumInstance);
+            } catch (ReflectiveOperationException e) {
+                throw new IllegalStateException("Failed to instantiate " + CRT_CRC32C_CLASS_PATH, e);
             }
         }).orElse(null);
     }
 
+    /**
+     * Creates an instance of the CRT-based CRC64NVME checksum using AWS's CRT library.
+     * <p>
+     * Attempts to load the `CRC64NVME` implementation specified by `CRT_CRC64NVME_PATH` and, if successful,
+     * wraps it in {@link CrcCloneOnMarkChecksum}. Throws a {@link RuntimeException} if `CRC64NVME` is unavailable.
+     * </p>
+     *
+     * @return An {@link SdkChecksum} instance for CRC64NVME.
+     * @throws IllegalStateException if instantiation fails.
+     * @throws RuntimeException if the `CRC64NVME` implementation is not available.
+     */
+    static SdkChecksum crc64NvmeCrtImplementation() {
+        return CONSTRUCTOR_CACHE.getConstructor(CRT_CRC64NVME_PATH).map(constructor -> {
+            try {
+                Checksum checksumInstance = (Checksum) constructor.newInstance();
+                return new CrcCloneOnMarkChecksum(checksumInstance);
+            } catch (ReflectiveOperationException e) {
+                throw new IllegalStateException("Failed to instantiate " + CRT_CRC32C_CLASS_PATH, e);
+            }
+        }).orElseThrow(() -> new RuntimeException(
+            "Could not load " + CRT_CRC64NVME_PATH + ". Add dependency on '" + CRT_MODULE
+            + "' module to enable CRC64NVME feature."));
+    }
+
     static SdkChecksum createJavaCrc32C() {
         return CONSTRUCTOR_CACHE.getConstructor(JAVA_CRC32C_CLASS_PATH).map(constructor -> {
             try {

core/checksums/src/main/java/software/amazon/awssdk/checksums/internal/CrcCloneOnMarkChecksum.java

@@ -17,7 +17,7 @@
 
 import static software.amazon.awssdk.utils.NumericUtils.longToByte;
 
-import java.util.function.Function;
+import java.lang.reflect.Method;
 import java.util.zip.Checksum;
 import software.amazon.awssdk.annotations.SdkInternalApi;
 
@@ -32,22 +32,31 @@
 @SdkInternalApi
 public final class CrcCloneOnMarkChecksum extends BaseCrcChecksum {
 
-    private final Function<Checksum, Checksum> cloneFunction;
-
-    public CrcCloneOnMarkChecksum(Checksum checksum, Function<Checksum, Checksum> cloneFunction) {
+    public CrcCloneOnMarkChecksum(Checksum checksum) {
         super(checksum);
-        this.cloneFunction = cloneFunction;
     }
 
     @Override
     Checksum cloneChecksum(Checksum checksum) {
-        // Use the function to clone the checksum
-        return cloneFunction.apply(checksum);
+        return cloneIfCloneable(checksum);
     }
 
     @Override
     public byte[] getChecksumBytes() {
         byte[] valueBytes = longToByte(getValue());
         return new byte[] { valueBytes[4], valueBytes[5], valueBytes[6], valueBytes[7] };
     }
-}
+
+    // Function to clone any Checksum that implements Cloneable
+    private Checksum cloneIfCloneable(Checksum checksum) {
+        if (checksum instanceof Cloneable) {
+            try {
+                Method cloneMethod = checksum.getClass().getMethod("clone");
+                return (Checksum) cloneMethod.invoke(checksum);
+            } catch (Exception e) {
+                throw new IllegalStateException("Failed to clone the checksum", e);
+            }
+        }
+        throw new UnsupportedOperationException("Checksum does not support cloning");
+    }
+}

core/checksums/src/test/java/software/amazon/awssdk/checksums/internal/CRTBasedCRC32CChecksumTest.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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 software.amazon.awssdk.checksums.internal;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import software.amazon.awssdk.checksums.SdkChecksum;
+import software.amazon.awssdk.utils.BinaryUtils;
+
+class Crc64NvmeChecksumTest {
+
+    private SdkChecksum sdkChecksum;
+    private static final String TEST_STRING = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+
+    @BeforeEach
+    public void setUp() {
+        sdkChecksum = new Crc64NvmeChecksum();
+    }
+
+    @Test
+    void validateCrcChecksumValues() {
+        byte[] bytes = TEST_STRING.getBytes(StandardCharsets.UTF_8);
+        sdkChecksum.update(bytes, 0, bytes.length);
+        assertEquals("0000000000000000000000008b8f30cfc6f16409", getAsString(sdkChecksum.getChecksumBytes()));
+    }
+
+    @Test
+    void validateEncodedBase64ForCrc() {
+        sdkChecksum.update("abc".getBytes(StandardCharsets.UTF_8));
+        String toBase64 = BinaryUtils.toBase64(sdkChecksum.getChecksumBytes());
+        assertEquals("BeXKuz/B+us=", toBase64);
+    }
+
+    @Test
+    void validateMarkAndResetForCrc() {
+        sdkChecksum.update("ab".getBytes(StandardCharsets.UTF_8));
+        sdkChecksum.mark(3);
+        sdkChecksum.update("xyz".getBytes(StandardCharsets.UTF_8));
+        sdkChecksum.reset();
+        sdkChecksum.update("c".getBytes(StandardCharsets.UTF_8));
+        String toBase64 = BinaryUtils.toBase64(sdkChecksum.getChecksumBytes());
+        assertEquals("BeXKuz/B+us=", toBase64);
+    }
+
+    @Test
+    void validateMarkForCrc() {
+        sdkChecksum.update("Hello ".getBytes(StandardCharsets.UTF_8));
+        sdkChecksum.mark(4);
+        sdkChecksum.update("world".getBytes(StandardCharsets.UTF_8));
+        String toBase64 = BinaryUtils.toBase64(sdkChecksum.getChecksumBytes());
+        assertEquals("OOJZ0D8xKts=", toBase64);
+    }
+
+    @Test
+    void validateSingleMarksForCrc() {
+        sdkChecksum.update("alpha".getBytes(StandardCharsets.UTF_8));
+        sdkChecksum.mark(3);
+        sdkChecksum.update("beta".getBytes(StandardCharsets.UTF_8));
+        sdkChecksum.reset();
+        String toBase64 = BinaryUtils.toBase64(sdkChecksum.getChecksumBytes());
+        assertEquals("Ehnh98TMQlQ=", toBase64);
+    }
+
+    @Test
+    void validateMultipleMarksForCrc() {
+        sdkChecksum.update("alpha".getBytes(StandardCharsets.UTF_8));
+        sdkChecksum.mark(3);
+        sdkChecksum.update("beta".getBytes(StandardCharsets.UTF_8));
+        sdkChecksum.mark(5);
+        sdkChecksum.update("gamma".getBytes(StandardCharsets.UTF_8));
+        sdkChecksum.reset();
+        sdkChecksum.update("delta".getBytes(StandardCharsets.UTF_8));
+        String toBase64 = BinaryUtils.toBase64(sdkChecksum.getChecksumBytes());
+        // Final checksum of "alphabetadelta"
+        assertEquals("ugWp+3k2NgA=", toBase64);
+    }
+
+    @Test
+    void validateResetWithoutMarkForCrc() {
+        sdkChecksum.update("beta".getBytes(StandardCharsets.UTF_8));
+        sdkChecksum.reset();
+        sdkChecksum.update("alpha".getBytes(StandardCharsets.UTF_8));
+        String toBase64 = BinaryUtils.toBase64(sdkChecksum.getChecksumBytes());
+        // Checksum of "alpha"
+        assertEquals("Ehnh98TMQlQ=", toBase64);
+    }
+
+    private String getAsString(byte[] checksumBytes) {
+        return String.format("%040x", new BigInteger(1, checksumBytes));
+    }
+}