Fix incorrect part size in multipart copy

  The bug was using size (remaining bytes) instead of length (actual part size) when constructing PartInfo in the
  multipart copy loop. This would record wrong sizes for each part - especially problematic for the last part.

Author: Test User

.github/workflows/rust.yml

@@ -36,6 +36,7 @@ jobs:
           export ACCESS_KEY=minioadmin
           export SECRET_KEY=minioadmin
           export ENABLE_HTTPS=1
+          export SERVER_REGION=us-east-1
           export MINIO_SSL_CERT_FILE=./tests/public.crt
           MINIO_TEST_TOKIO_RUNTIME_FLAVOR="multi_thread" cargo test -- --nocapture
   test-current-thread:
@@ -49,6 +50,7 @@ jobs:
           export ACCESS_KEY=minioadmin
           export SECRET_KEY=minioadmin
           export ENABLE_HTTPS=1
+          export SERVER_REGION=us-east-1
           export MINIO_SSL_CERT_FILE=./tests/public.crt
           MINIO_TEST_TOKIO_RUNTIME_FLAVOR="current_thread" cargo test -- --nocapture
 

common/src/example.rs

@@ -52,7 +52,7 @@ pub fn create_bucket_notification_config_example() -> NotificationConfig {
             suffix_filter_rule: Some(SuffixFilterRule {
                 value: String::from("pg"),
             }),
-            queue: String::from("arn:minio:sqs::miniojavatest:webhook"),
+            queue: String::from("arn:minio:sqs:us-east-1:miniojavatest:webhook"),
         }]),
         ..Default::default()
     }

src/s3/builders/append_object.rs

@@ -61,8 +61,8 @@ pub struct AppendObject {
     #[builder(!default)] // force required
     data: Arc<SegmentedBytes>,
 
+    /// Value of `x-amz-write-offset-bytes`.
     #[builder(!default)] // force required
-    /// value of x-amz-write-offset-bytes
     offset_bytes: u64,
 }
 
@@ -141,7 +141,7 @@ pub struct AppendObjectContent {
     content_stream: ContentStream,
     #[builder(default)]
     part_count: Option<u16>,
-    /// Value of x-amz-write-offset-bytes
+    /// Value of `x-amz-write-offset-bytes`.
     #[builder(default)]
     offset_bytes: u64,
 }
@@ -243,7 +243,7 @@ impl AppendObjectContent {
         }
     }
 
-    /// multipart append
+    /// Performs multipart append.
     async fn send_mpa(
         &mut self,
         part_size: u64,

src/s3/builders/bucket_common.rs

@@ -18,7 +18,7 @@ use crate::s3::multimap_ext::Multimap;
 use std::marker::PhantomData;
 use typed_builder::TypedBuilder;
 
-/// Common parameters for bucket operations
+/// Common parameters for bucket operations.
 #[derive(Clone, Debug, TypedBuilder)]
 pub struct BucketCommon<T> {
     #[builder(!default)] // force required

src/s3/builders/bucket_exists.rs

@@ -21,10 +21,10 @@ use crate::s3::types::{S3Api, S3Request, ToS3Request};
 use crate::s3::utils::check_bucket_name;
 use http::Method;
 
-/// This struct constructs the parameters required for the [`Client::bucket_exists`](crate::s3::client::MinioClient::bucket_exists) method.
+/// Constructs the parameters for the [`Client::bucket_exists`](crate::s3::client::MinioClient::bucket_exists) method.
 ///
 /// See [Amazon S3: Working with Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucket.html)
-/// for more information about checking if a bucket exists.
+/// for more information.
 pub type BucketExists = BucketCommon<BucketExistsPhantomData>;
 
 #[doc(hidden)]

src/s3/builders/copy_object.rs

@@ -587,7 +587,7 @@ impl ComposeObjectInternal {
                     size -= o;
                 }
 
-                let mut offset = source.offset.unwrap_or_default();
+                let offset = source.offset.unwrap_or_default();
 
                 let mut headers = source.get_headers();
                 headers.add_multimap(ssec_headers.clone());
@@ -631,19 +631,15 @@ impl ComposeObjectInternal {
                         size,
                     });
                 } else {
-                    while size > 0 {
+                    let part_ranges = calculate_part_ranges(offset, size, MAX_PART_SIZE);
+                    for (part_offset, length) in part_ranges {
                         part_number += 1;
-
-                        let mut length = size;
-                        if length > MAX_PART_SIZE {
-                            length = MAX_PART_SIZE;
-                        }
-                        let end_bytes = offset + length - 1;
+                        let end_bytes = part_offset + length - 1;
 
                         let mut headers_copy = headers.clone();
                         headers_copy.add(
                             X_AMZ_COPY_SOURCE_RANGE,
-                            format!("bytes={offset}-{end_bytes}"),
+                            format!("bytes={part_offset}-{end_bytes}"),
                         );
 
                         let resp: UploadPartCopyResponse = match self
@@ -668,11 +664,8 @@ impl ComposeObjectInternal {
                         parts.push(PartInfo {
                             number: part_number,
                             etag,
-                            size,
+                            size: length,
                         });
-
-                        offset += length;
-                        size -= length;
                     }
                 }
             }
@@ -796,8 +789,8 @@ impl ComposeObject {
 
 // region: misc
 
+/// Source object information for [`compose_object`](MinioClient::compose_object).
 #[derive(Clone, Debug, Default)]
-/// Source object information for [compose_object](MinioClient::compose_object)
 pub struct ComposeSource {
     pub extra_headers: Option<Multimap>,
     pub extra_query_params: Option<Multimap>,
@@ -818,7 +811,7 @@ pub struct ComposeSource {
 }
 
 impl ComposeSource {
-    /// Returns a compose source with given bucket name and object name
+    /// Returns a compose source with given bucket name and object name.
     ///
     /// # Examples
     ///
@@ -927,8 +920,8 @@ impl ComposeSource {
     }
 }
 
+/// Base argument for object conditional read APIs.
 #[derive(Clone, Debug, TypedBuilder)]
-/// Base argument for object conditional read APIs
 pub struct CopySource {
     #[builder(default, setter(into))]
     pub extra_headers: Option<Multimap>,
@@ -1036,4 +1029,122 @@ fn into_headers_copy_object(
 
     map
 }
+
+/// Calculates part ranges (offset, length) for multipart copy operations.
+///
+/// Given a starting offset, total size, and maximum part size, returns a vector of
+/// (offset, length) tuples for each part. This is extracted as a separate function
+/// to enable unit testing without requiring actual S3 operations or multi-gigabyte files.
+///
+/// # Arguments
+/// * `start_offset` - Starting byte offset
+/// * `total_size` - Total bytes to copy
+/// * `max_part_size` - Maximum size per part (typically MAX_PART_SIZE = 5GB)
+///
+/// # Returns
+/// Vector of (offset, length) tuples for each part
+fn calculate_part_ranges(
+    start_offset: u64,
+    total_size: u64,
+    max_part_size: u64,
+) -> Vec<(u64, u64)> {
+    let mut ranges = Vec::new();
+    let mut offset = start_offset;
+    let mut remaining = total_size;
+
+    while remaining > 0 {
+        let length = remaining.min(max_part_size);
+        ranges.push((offset, length));
+        offset += length;
+        remaining -= length;
+    }
+
+    ranges
+}
+
 // endregion: misc
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_calculate_part_ranges_single_part() {
+        // Size <= max_part_size should return single part
+        let ranges = calculate_part_ranges(0, 1000, 5000);
+        assert_eq!(ranges, vec![(0, 1000)]);
+    }
+
+    #[test]
+    fn test_calculate_part_ranges_exact_multiple() {
+        // Size exactly divisible by max_part_size
+        let ranges = calculate_part_ranges(0, 10000, 5000);
+        assert_eq!(ranges, vec![(0, 5000), (5000, 5000)]);
+    }
+
+    #[test]
+    fn test_calculate_part_ranges_with_remainder() {
+        // Size with remainder
+        let ranges = calculate_part_ranges(0, 12000, 5000);
+        assert_eq!(ranges, vec![(0, 5000), (5000, 5000), (10000, 2000)]);
+    }
+
+    #[test]
+    fn test_calculate_part_ranges_with_start_offset() {
+        // Starting from non-zero offset
+        let ranges = calculate_part_ranges(1000, 12000, 5000);
+        assert_eq!(ranges, vec![(1000, 5000), (6000, 5000), (11000, 2000)]);
+    }
+
+    #[test]
+    fn test_calculate_part_ranges_zero_size() {
+        // Zero size edge case - returns empty
+        let ranges = calculate_part_ranges(0, 0, 5000);
+        assert!(ranges.is_empty());
+    }
+
+    #[test]
+    fn test_calculate_part_ranges_realistic() {
+        // Simulate 12GB file with 5GB max part size
+        let total_size: u64 = 12 * 1024 * 1024 * 1024; // 12 GB
+        let max_part_size: u64 = 5 * 1024 * 1024 * 1024; // 5 GB
+
+        let ranges = calculate_part_ranges(0, total_size, max_part_size);
+
+        assert_eq!(ranges.len(), 3);
+        assert_eq!(ranges[0], (0, max_part_size)); // 0-5GB
+        assert_eq!(ranges[1], (max_part_size, max_part_size)); // 5GB-10GB
+        assert_eq!(ranges[2], (2 * max_part_size, 2 * 1024 * 1024 * 1024)); // 10GB-12GB
+
+        // Verify total size matches
+        let total: u64 = ranges.iter().map(|(_, len)| len).sum();
+        assert_eq!(total, total_size);
+
+        // Verify offsets are contiguous
+        let mut expected_offset = 0;
+        for (offset, length) in &ranges {
+            assert_eq!(*offset, expected_offset);
+            expected_offset += length;
+        }
+    }
+
+    #[test]
+    fn test_calculate_part_ranges_each_part_correct_length() {
+        // This test catches the bug where `size` (remaining) was used instead of `length`
+        let ranges = calculate_part_ranges(0, 17000, 5000);
+
+        // Should be [(0,5000), (5000,5000), (10000,5000), (15000,2000)]
+        // NOT [(0,17000), (17000,12000), ...] which the buggy code would produce
+        assert_eq!(
+            ranges,
+            vec![(0, 5000), (5000, 5000), (10000, 5000), (15000, 2000)]
+        );
+
+        // Each non-final part should be exactly max_part_size
+        for (i, (_, length)) in ranges.iter().enumerate() {
+            if i < ranges.len() - 1 {
+                assert_eq!(*length, 5000, "Part {} should be max_part_size", i);
+            }
+        }
+    }
+}

src/s3/builders/delete_objects.rs

@@ -37,15 +37,16 @@ impl ValidKey for String {}
 impl ValidKey for &str {}
 impl ValidKey for &String {}
 
-/// Specify an object to be deleted. The object can be specified by key or by
-/// key and version_id via the From trait.
+/// Specifies an object to be deleted.
+///
+/// The object can be specified by key or by key and version_id via the `From` trait.
 #[derive(Debug, Clone, Default)]
 pub struct ObjectToDelete {
     key: String,
     version_id: Option<String>,
 }
 
-/// A key can be converted into a DeleteObject. The version_id is set to None.
+/// A key can be converted into a `DeleteObject` with `version_id` set to `None`.
 impl<K: ValidKey> From<K> for ObjectToDelete {
     fn from(key: K) -> Self {
         Self {
@@ -55,7 +56,7 @@ impl<K: ValidKey> From<K> for ObjectToDelete {
     }
 }
 
-/// A tuple of key and version_id can be converted into a DeleteObject.
+/// A tuple of key and version_id can be converted into a `DeleteObject`.
 impl<K: ValidKey> From<(K, &str)> for ObjectToDelete {
     fn from((key, version_id): (K, &str)) -> Self {
         Self {
@@ -65,7 +66,7 @@ impl<K: ValidKey> From<(K, &str)> for ObjectToDelete {
     }
 }
 
-/// A tuple of key and option version_id can be converted into a DeleteObject.
+/// A tuple of key and optional version_id can be converted into a `DeleteObject`.
 impl<K: ValidKey> From<(K, Option<&str>)> for ObjectToDelete {
     fn from((key, version_id): (K, Option<&str>)) -> Self {
         Self {
@@ -178,9 +179,10 @@ pub struct DeleteObjects {
     #[builder(default)]
     bypass_governance_mode: bool,
 
-    /// Enable verbose mode (defaults to false). If enabled, the response will
-    /// include the keys of objects that were successfully deleted. Otherwise,
-    /// only objects that encountered an error are returned.
+    /// Enables verbose mode (defaults to false).
+    ///
+    /// If enabled, the response will include the keys of objects that were successfully
+    /// deleted. Otherwise, only objects that encountered an error are returned.
     #[builder(default)]
     verbose_mode: bool,
 }
@@ -320,9 +322,10 @@ impl DeleteObjectsStreaming {
         self
     }
 
-    /// Enable verbose mode (defaults to false). If enabled, the response will
-    /// include the keys of objects that were successfully deleted. Otherwise
-    /// only objects that encountered an error are returned.
+    /// Enables verbose mode (defaults to false).
+    ///
+    /// If enabled, the response will include the keys of objects that were successfully
+    /// deleted. Otherwise, only objects that encountered an error are returned.
     pub fn verbose_mode(mut self, verbose_mode: bool) -> Self {
         self.verbose_mode = verbose_mode;
         self
@@ -338,7 +341,7 @@ impl DeleteObjectsStreaming {
         self
     }
 
-    /// Sets the region for the request
+    /// Sets the region for the request.
     pub fn region(mut self, region: Option<String>) -> Self {
         self.region = region;
         self

src/s3/builders/get_presigned_policy_form_data.rs

@@ -61,10 +61,10 @@ impl GetPresignedPolicyFormData {
 pub type GetPresignedPolicyFormDataBldr =
     GetPresignedPolicyFormDataBuilder<((MinioClient,), (PostPolicy,))>;
 
-/// Post policy information for presigned post policy form-data
+/// Post policy information for presigned POST policy form-data.
 ///
-/// Condition elements and respective condition for Post policy is available <a
-/// href="https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-HTTPPOSTConstructPolicy.html#sigv4-PolicyConditions">here</a>.
+/// See [Post Policy Conditions](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-HTTPPOSTConstructPolicy.html#sigv4-PolicyConditions)
+/// for condition elements and their usage.
 #[derive(Clone, Debug)]
 pub struct PostPolicy {
     pub region: Option<String>,
@@ -82,7 +82,7 @@ impl PostPolicy {
     const STARTS_WITH: &'static str = "starts-with";
     const ALGORITHM: &'static str = "AWS4-HMAC-SHA256";
 
-    /// Returns post policy with given bucket name and expiration
+    /// Returns a post policy with given bucket name and expiration.
     ///
     /// # Examples
     ///