feat: enhance error handling and add precondition checks for object o… (#1008)

crates/ecstore/src/erasure_coding/encode.rs

@@ -149,6 +149,12 @@ impl Erasure {
                         break;
                     }
                     Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => {
+                        // Check if the inner error is a checksum mismatch - if so, propagate it
+                        if let Some(inner) = e.get_ref() {
+                            if rustfs_rio::is_checksum_mismatch(inner) {
+                                return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, e.to_string()));
+                            }
+                        }
                         break;
                     }
                     Err(e) => {

crates/ecstore/src/error.rs

@@ -194,6 +194,12 @@ pub enum StorageError {
     #[error("Precondition failed")]
     PreconditionFailed,
 
+    #[error("Not modified")]
+    NotModified,
+
+    #[error("Invalid part number: {0}")]
+    InvalidPartNumber(usize),
+
     #[error("Invalid range specified: {0}")]
     InvalidRangeSpec(String),
 }
@@ -427,6 +433,8 @@ impl Clone for StorageError {
             StorageError::InsufficientReadQuorum(a, b) => StorageError::InsufficientReadQuorum(a.clone(), b.clone()),
             StorageError::InsufficientWriteQuorum(a, b) => StorageError::InsufficientWriteQuorum(a.clone(), b.clone()),
             StorageError::PreconditionFailed => StorageError::PreconditionFailed,
+            StorageError::NotModified => StorageError::NotModified,
+            StorageError::InvalidPartNumber(a) => StorageError::InvalidPartNumber(*a),
             StorageError::InvalidRangeSpec(a) => StorageError::InvalidRangeSpec(a.clone()),
         }
     }
@@ -496,6 +504,8 @@ impl StorageError {
             StorageError::PreconditionFailed => 0x3B,
             StorageError::EntityTooSmall(_, _, _) => 0x3C,
             StorageError::InvalidRangeSpec(_) => 0x3D,
+            StorageError::NotModified => 0x3E,
+            StorageError::InvalidPartNumber(_) => 0x3F,
         }
     }
 
@@ -566,6 +576,8 @@ impl StorageError {
             0x3B => Some(StorageError::PreconditionFailed),
             0x3C => Some(StorageError::EntityTooSmall(Default::default(), Default::default(), Default::default())),
             0x3D => Some(StorageError::InvalidRangeSpec(Default::default())),
+            0x3E => Some(StorageError::NotModified),
+            0x3F => Some(StorageError::InvalidPartNumber(Default::default())),
             _ => None,
         }
     }
@@ -679,6 +691,10 @@ pub fn is_err_data_movement_overwrite(err: &Error) -> bool {
     matches!(err, &StorageError::DataMovementOverwriteErr(_, _, _))
 }
 
+pub fn is_err_io(err: &Error) -> bool {
+    matches!(err, &StorageError::Io(_))
+}
+
 pub fn is_all_not_found(errs: &[Option<Error>]) -> bool {
     for err in errs.iter() {
         if let Some(err) = err {

crates/ecstore/src/store.rs

@@ -767,6 +767,12 @@ impl ECStore {
 
             def_pool = pinfo.clone();
             has_def_pool = true;
+            // https://docs.aws.amazon.com/AmazonS3/latest/userguide/conditional-deletes.html
+            if is_err_object_not_found(err) {
+                if let Err(err) = opts.precondition_check(&pinfo.object_info) {
+                    return Err(err.clone());
+                }
+            }
 
             if !is_err_object_not_found(err) && !is_err_version_not_found(err) {
                 return Err(err.clone());
@@ -1392,6 +1398,7 @@ impl StorageAPI for ECStore {
 
         let (info, _) = self.get_latest_object_info_with_idx(bucket, object.as_str(), opts).await?;
 
+        opts.precondition_check(&info)?;
         Ok(info)
     }
 

crates/ecstore/src/store_api.rs

@@ -356,6 +356,8 @@ impl HTTPRangeSpec {
 pub struct HTTPPreconditions {
     pub if_match: Option<String>,
     pub if_none_match: Option<String>,
+    pub if_modified_since: Option<OffsetDateTime>,
+    pub if_unmodified_since: Option<OffsetDateTime>,
 }
 
 #[derive(Debug, Default, Clone)]
@@ -456,6 +458,76 @@ impl ObjectOptions {
             ..Default::default()
         }
     }
+
+    pub fn precondition_check(&self, obj_info: &ObjectInfo) -> Result<()> {
+        let has_valid_mod_time = obj_info.mod_time.is_some_and(|t| t != OffsetDateTime::UNIX_EPOCH);
+
+        if let Some(part_number) = self.part_number {
+            if part_number > 1 && !obj_info.parts.is_empty() {
+                let part_found = obj_info.parts.iter().any(|pi| pi.number == part_number);
+                if !part_found {
+                    return Err(Error::InvalidPartNumber(part_number));
+                }
+            }
+        }
+
+        if let Some(pre) = &self.http_preconditions {
+            if let Some(if_none_match) = &pre.if_none_match {
+                if let Some(etag) = &obj_info.etag {
+                    if is_etag_equal(etag, if_none_match) {
+                        return Err(Error::NotModified);
+                    }
+                }
+            }
+
+            if has_valid_mod_time {
+                if let Some(if_modified_since) = &pre.if_modified_since {
+                    if let Some(mod_time) = &obj_info.mod_time {
+                        if !is_modified_since(mod_time, if_modified_since) {
+                            return Err(Error::NotModified);
+                        }
+                    }
+                }
+            }
+
+            if let Some(if_match) = &pre.if_match {
+                if let Some(etag) = &obj_info.etag {
+                    if !is_etag_equal(etag, if_match) {
+                        return Err(Error::PreconditionFailed);
+                    }
+                } else {
+                    return Err(Error::PreconditionFailed);
+                }
+            }
+            if has_valid_mod_time && pre.if_match.is_none() {
+                if let Some(if_unmodified_since) = &pre.if_unmodified_since {
+                    if let Some(mod_time) = &obj_info.mod_time {
+                        if is_modified_since(mod_time, if_unmodified_since) {
+                            return Err(Error::PreconditionFailed);
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+fn is_etag_equal(etag1: &str, etag2: &str) -> bool {
+    let e1 = etag1.trim_matches('"');
+    let e2 = etag2.trim_matches('"');
+    // Handle wildcard "*" - matches any ETag (per HTTP/1.1 RFC 7232)
+    if e2 == "*" {
+        return true;
+    }
+    e1 == e2
+}
+
+fn is_modified_since(mod_time: &OffsetDateTime, given_time: &OffsetDateTime) -> bool {
+    let mod_secs = mod_time.unix_timestamp();
+    let given_secs = given_time.unix_timestamp();
+    mod_secs > given_secs
 }
 
 #[derive(Debug, Default, Serialize, Deserialize)]

crates/rio/src/hash_reader.rs

@@ -499,17 +499,18 @@ impl AsyncRead for HashReader {
                         let content_hash = hasher.finalize();
 
                         if content_hash != expected_content_hash.raw {
+                            let expected_hex = hex_simd::encode_to_string(&expected_content_hash.raw, hex_simd::AsciiCase::Lower);
+                            let actual_hex = hex_simd::encode_to_string(content_hash, hex_simd::AsciiCase::Lower);
                             error!(
                                 "Content hash mismatch, type={:?}, encoded={:?}, expected={:?}, actual={:?}",
-                                expected_content_hash.checksum_type,
-                                expected_content_hash.encoded,
-                                hex_simd::encode_to_string(&expected_content_hash.raw, hex_simd::AsciiCase::Lower),
-                                hex_simd::encode_to_string(content_hash, hex_simd::AsciiCase::Lower)
+                                expected_content_hash.checksum_type, expected_content_hash.encoded, expected_hex, actual_hex
                             );
-                            return Poll::Ready(Err(std::io::Error::new(
-                                std::io::ErrorKind::InvalidData,
-                                "Content hash mismatch",
-                            )));
+                            // Use ChecksumMismatch error so that API layer can return BadDigest
+                            let checksum_err = crate::errors::ChecksumMismatch {
+                                want: expected_hex,
+                                got: actual_hex,
+                            };
+                            return Poll::Ready(Err(std::io::Error::new(std::io::ErrorKind::InvalidData, checksum_err)));
                         }
                     }
 

crates/utils/src/io.rs

@@ -41,6 +41,11 @@ pub async fn read_full<R: AsyncRead + Send + Sync + Unpin>(mut reader: R, mut bu
                 if total == 0 {
                     return Err(e);
                 }
+                // If the error is InvalidData (e.g., checksum mismatch), preserve it
+                // instead of wrapping it as UnexpectedEof, so proper error handling can occur
+                if e.kind() == std::io::ErrorKind::InvalidData {
+                    return Err(e);
+                }
                 return Err(std::io::Error::new(
                     std::io::ErrorKind::UnexpectedEof,
                     format!("read {total} bytes, error: {e}"),