The correct error is PreconditionFailed with status code 412 (StatusPreconditionFailed).
As for the description, the exact AWS message is:

At least one of the pre-conditions you specified did not hold

let's stick to what AWS returns.

This intention is right but not the approach.
In the current version the function checkIfAbsent implements checkIfAbsent by doing Get to the object and then Put. This is not gonna work because the Get->Put operation is not atomic.
The idea of the feature is that AWS implements this and provide atomicity out of the box.

Instead, our S3 Gateway should only forward the request to AWS and let them handle the precondition check.
Example implementation:

1. add additional field to opts := block.PutOpts{StorageClass: storageClass, IfNoneMatch} (one line above) that check if the header exist and sets it.
2. let the ops propagate down to the blockstore adapter and then use it when calling PutObject as an option. We have a challenge here see below 👇 .

Challenge with PutObject call:

Our AWS SDK is outdated, so it does not contain the built-in option in the new version IfNoneMatch.

We have 2 options:

a. Upgrade the AWS SDK (preferable) after verifying there no breaking changes (separate PR)
b. Use the request middleware options that the current AWS SDK version provides to propagate the header.

• in AWS SDK introduces in service/s3/v1.60.0

NOTE: Same should apply for Multipart Uploads

• Use lowercase for variable names
• Be explicit in variable name

For future generations, please add comment explaining this, something or exactly like this otherwise it's confusing, since this does not actually the verify core part, it's more optimization (since not atomicity here)

I find this function confusing because:
It does 3 different things:

• It checks and validates the the header value
• Get's the value from catalog.
• Returns allowOverride indicator for the real code somewhere else that checks if absent.

Now that is confusing because it's a "lie" - it only's only partially checking ifAbsent as optimization, since the real check performed later and also does input validation.

I would prefer something much more explicit like a function that extracts the header and validates it, then inline check if object exist:

// checkIfAbsent sets allowOverwrite and validates the header value if set 
allowOverwrite, err := o.checkIfAbsent(req)
if err != nil { 
    // ...
}
if !allowOverwrite { 
    // first check if object exist as optimization to save resources 
    _, err := o.Catalog.GetEntry(req.Context(), o.Repository.Name, o.Reference, o.Path, catalog.GetEntryParams{}) 
    // hadle if err != nil ...
}