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

rustfs/src/error.rs

@@ -192,6 +192,21 @@ impl From<ApiError> for S3Error {
 
 impl From<StorageError> for ApiError {
     fn from(err: StorageError) -> Self {
+        // Special handling for Io errors that may contain ChecksumMismatch
+        if let StorageError::Io(ref io_err) = err {
+            if let Some(inner) = io_err.get_ref() {
+                if inner.downcast_ref::<rustfs_rio::ChecksumMismatch>().is_some()
+                    || inner.downcast_ref::<rustfs_rio::BadDigest>().is_some()
+                {
+                    return ApiError {
+                        code: S3ErrorCode::BadDigest,
+                        message: ApiError::error_code_to_message(&S3ErrorCode::BadDigest),
+                        source: Some(Box::new(err)),
+                    };
+                }
+            }
+        }
+
         let code = match &err {
             StorageError::NotImplemented => S3ErrorCode::NotImplemented,
             StorageError::InvalidArgument(_, _, _) => S3ErrorCode::InvalidArgument,
@@ -239,6 +254,23 @@ impl From<StorageError> for ApiError {
 
 impl From<std::io::Error> for ApiError {
     fn from(err: std::io::Error) -> Self {
+        // Check if the error is a ChecksumMismatch (BadDigest)
+        if let Some(inner) = err.get_ref() {
+            if inner.downcast_ref::<rustfs_rio::ChecksumMismatch>().is_some() {
+                return ApiError {
+                    code: S3ErrorCode::BadDigest,
+                    message: ApiError::error_code_to_message(&S3ErrorCode::BadDigest),
+                    source: Some(Box::new(err)),
+                };
+            }
+            if inner.downcast_ref::<rustfs_rio::BadDigest>().is_some() {
+                return ApiError {
+                    code: S3ErrorCode::BadDigest,
+                    message: ApiError::error_code_to_message(&S3ErrorCode::BadDigest),
+                    source: Some(Box::new(err)),
+                };
+            }
+        }
         ApiError {
             code: S3ErrorCode::InternalError,
             message: err.to_string(),

rustfs/src/storage/ecfs.rs

@@ -1418,12 +1418,17 @@ impl S3 for FS {
                 ..Default::default()
             };
 
-            let opts = ObjectOptions {
-                version_id: object.version_id.map(|v| v.to_string()),
-                versioned: version_cfg.prefix_enabled(&object.object_name),
-                version_suspended: version_cfg.suspended(),
-                ..Default::default()
-            };
+            let metadata = extract_metadata(&req.headers);
+
+            let opts: ObjectOptions = del_opts(
+                &bucket,
+                &object.object_name,
+                object.version_id.map(|f| f.to_string()),
+                &req.headers,
+                metadata,
+            )
+            .await
+            .map_err(ApiError::from)?;
 
             let mut goi = ObjectInfo::default();
             let mut gerr = None;
@@ -1684,10 +1689,6 @@ impl S3 for FS {
             version_id,
             part_number,
             range,
-            if_none_match,
-            if_match,
-            if_modified_since,
-            if_unmodified_since,
             ..
         } = req.input.clone();
 
@@ -1880,35 +1881,6 @@ impl S3 for FS {
 
         let info = reader.object_info;
 
-        if let Some(match_etag) = if_none_match {
-            if info.etag.as_ref().is_some_and(|etag| etag == match_etag.as_str()) {
-                return Err(S3Error::new(S3ErrorCode::NotModified));
-            }
-        }
-
-        if let Some(modified_since) = if_modified_since {
-            // obj_time < givenTime + 1s
-            if info.mod_time.is_some_and(|mod_time| {
-                let give_time: OffsetDateTime = modified_since.into();
-                mod_time < give_time.add(time::Duration::seconds(1))
-            }) {
-                return Err(S3Error::new(S3ErrorCode::NotModified));
-            }
-        }
-
-        if let Some(match_etag) = if_match {
-            if info.etag.as_ref().is_some_and(|etag| etag != match_etag.as_str()) {
-                return Err(S3Error::new(S3ErrorCode::PreconditionFailed));
-            }
-        } else if let Some(unmodified_since) = if_unmodified_since {
-            if info.mod_time.is_some_and(|mod_time| {
-                let give_time: OffsetDateTime = unmodified_since.into();
-                mod_time > give_time.add(time::Duration::seconds(1))
-            }) {
-                return Err(S3Error::new(S3ErrorCode::PreconditionFailed));
-            }
-        }
-
         debug!(object_size = info.size, part_count = info.parts.len(), "GET object metadata snapshot");
         for part in &info.parts {
             debug!(
@@ -4194,6 +4166,13 @@ impl S3 for FS {
             ..
         } = req.input.clone();
 
+        if tagging.tag_set.len() > 10 {
+            // TOTO: Note that Amazon S3 limits the maximum number of tags to 10 tags per object.
+            // Reference: https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-tagging.html
+            // Reference: https://docs.aws.amazon.com/zh_cn/AmazonS3/latest/API/API_PutObjectTagging.html
+            // https://github.com/minio/mint/blob/master/run/core/aws-sdk-go-v2/main.go#L1647
+        }
+
         let Some(store) = new_object_layer_fn() else {
             return Err(S3Error::with_message(S3ErrorCode::InternalError, "Not init".to_string()));
         };

rustfs/src/storage/options.rs

@@ -93,6 +93,8 @@ pub async fn del_opts(
         .map(|v| v.to_str().unwrap() == "true")
         .unwrap_or_default();
 
+    fill_conditional_writes_opts_from_header(headers, &mut opts)?;
+
     Ok(opts)
 }
 
@@ -133,6 +135,8 @@ pub async fn get_opts(
     opts.version_suspended = version_suspended;
     opts.versioned = versioned;
 
+    fill_conditional_writes_opts_from_header(headers, &mut opts)?;
+
     Ok(opts)
 }