8d838d9cb4
build / build (push) Successful in 1m45s
执行时真实时钟与持久授权回读(撤销/过期即停并保留预备份)、写集合写前落盘、 租约与 attempt 身份、恢复队列与原发送身份分离、成功收尾必须释放维护后再登记终态。
134 lines
5.5 KiB
Go
134 lines
5.5 KiB
Go
package v071
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"io"
|
|
"strings"
|
|
|
|
"github.com/aws/aws-sdk-go-v2/aws"
|
|
"github.com/aws/aws-sdk-go-v2/service/s3"
|
|
smithyhttp "github.com/aws/smithy-go/transport/http"
|
|
)
|
|
|
|
type objectObservation struct {
|
|
VersionID string `json:"version_id,omitempty"`
|
|
Exists bool `json:"exists"`
|
|
ETag string `json:"etag,omitempty"`
|
|
SHA256 string `json:"sha256,omitempty"`
|
|
Bytes int64 `json:"bytes"`
|
|
Owner string `json:"owner,omitempty"`
|
|
}
|
|
|
|
// No fallback to blind Put/Delete is allowed when conditional effects are absent.
|
|
type conditionalObjectStore interface {
|
|
ConditionalCapability(context.Context) error
|
|
ObserveObject(context.Context, string, string) (objectObservation, error)
|
|
CreateObject(context.Context, string, string, io.Reader, int64, string) error
|
|
RemoveObject(context.Context, string, string, objectObservation) error
|
|
}
|
|
|
|
var errObjectWriteRejected = errors.New("object write definitively rejected before send")
|
|
|
|
func (s *S3ObjectStore) ConditionalCapability(ctx context.Context) error {
|
|
if s.provider != "minio" && s.provider != "s3" {
|
|
return errors.New("object provider has no verified conditional create/version-delete adapter")
|
|
}
|
|
status, err := s.client.GetBucketVersioning(ctx, &s3.GetBucketVersioningInput{Bucket: aws.String(s.bucket)})
|
|
if err != nil || string(status.Status) != "Enabled" {
|
|
return errors.New("object effects require verified bucket versioning; never enable a business bucket implicitly")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Bind the supplied logical locator to the configured physical bucket. Legacy
|
|
// Open/Put intentionally accept bare keys; the new contract does not infer them.
|
|
func (s *S3ObjectStore) conditionalKey(provider, locator string) (string, error) {
|
|
if provider != s.provider || !validObjectKey(locator) {
|
|
return "", errors.New("conditional object provider/locator mismatch")
|
|
}
|
|
rest := strings.TrimPrefix(locator, "storage://")
|
|
parts := strings.SplitN(rest, "/", 2)
|
|
if rest == locator || len(parts) != 2 || parts[0] == "" {
|
|
return "", errors.New("conditional object requires explicit backend")
|
|
}
|
|
expected := provider + "://" + s.bucket + "/"
|
|
if !strings.HasPrefix(parts[1], expected) {
|
|
return "", errors.New("conditional object bucket/provider mismatch")
|
|
}
|
|
key := strings.TrimPrefix(parts[1], expected)
|
|
if key == "" {
|
|
return "", errors.New("empty conditional object key")
|
|
}
|
|
return key, nil
|
|
}
|
|
|
|
func (s *S3ObjectStore) ObserveObject(ctx context.Context, provider, locator string) (objectObservation, error) {
|
|
key, err := s.conditionalKey(provider, locator)
|
|
if err != nil {
|
|
return objectObservation{}, err
|
|
}
|
|
obj, err := s.client.GetObject(ctx, &s3.GetObjectInput{Bucket: aws.String(s.bucket), Key: aws.String(key)})
|
|
if err != nil {
|
|
var response *smithyhttp.ResponseError
|
|
if errors.As(err, &response) && response.HTTPStatusCode() == 404 {
|
|
return objectObservation{}, nil
|
|
}
|
|
return objectObservation{}, errors.New("object observation unavailable")
|
|
}
|
|
defer obj.Body.Close()
|
|
if obj.ContentLength == nil || *obj.ContentLength < 0 || *obj.ContentLength > s.maxObjectBytes || obj.ETag == nil || *obj.ETag == "" {
|
|
return objectObservation{}, errors.New("incomplete object observation")
|
|
}
|
|
hash := sha256.New()
|
|
size, err := io.Copy(hash, io.LimitReader(obj.Body, s.maxObjectBytes+1))
|
|
if err != nil || size != *obj.ContentLength {
|
|
return objectObservation{}, errors.New("object observation body incomplete")
|
|
}
|
|
return objectObservation{VersionID: aws.ToString(obj.VersionId), Exists: true, ETag: *obj.ETag, SHA256: hex.EncodeToString(hash.Sum(nil)), Bytes: size, Owner: obj.Metadata["kg-release-owner"]}, nil
|
|
}
|
|
|
|
func (s *S3ObjectStore) CreateObject(ctx context.Context, provider, locator string, body io.Reader, size int64, owner string) error {
|
|
if err := s.ConditionalCapability(ctx); err != nil {
|
|
return err
|
|
}
|
|
key, err := s.conditionalKey(provider, locator)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if size < 0 || size > s.maxObjectBytes || len(owner) != 64 {
|
|
return errObjectWriteRejected
|
|
}
|
|
// A durable intent represents one network attempt. Automatic retries could
|
|
// remain in flight after compensation, so ambiguity is reconciled by reads.
|
|
_, err = s.client.PutObject(ctx, &s3.PutObjectInput{Bucket: aws.String(s.bucket), Key: aws.String(key), Body: body, ContentLength: aws.Int64(size), IfNoneMatch: aws.String("*"), Metadata: map[string]string{"kg-release-owner": owner}}, func(o *s3.Options) { o.RetryMaxAttempts = 1 })
|
|
if err != nil {
|
|
return errors.New("conditional object create outcome unknown")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *S3ObjectStore) RemoveObject(ctx context.Context, provider, locator string, expected objectObservation) error {
|
|
if err := s.ConditionalCapability(ctx); err != nil {
|
|
return err
|
|
}
|
|
key, err := s.conditionalKey(provider, locator)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if expected.ETag == "" || expected.VersionID == "" || expected.VersionID == "null" {
|
|
return errors.New("deletion requires an immutable object version")
|
|
}
|
|
before, err := s.client.HeadObject(ctx, &s3.HeadObjectInput{Bucket: aws.String(s.bucket), Key: aws.String(key), VersionId: aws.String(expected.VersionID)})
|
|
if err != nil || aws.ToString(before.ETag) != expected.ETag || before.Metadata["kg-release-owner"] != expected.Owner {
|
|
return errors.New("exact object version no longer matches receipt")
|
|
}
|
|
_, err = s.client.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: aws.String(s.bucket), Key: aws.String(key), VersionId: aws.String(expected.VersionID)}, func(o *s3.Options) { o.RetryMaxAttempts = 1 })
|
|
if err != nil {
|
|
return errors.New("conditional object delete outcome unknown")
|
|
}
|
|
return nil
|
|
}
|