Files
knowledge-governance/internal/releaseadapter/v071/library_object_store.go
T
姚章浩 8d838d9cb4
build / build (push) Successful in 1m45s
feat(library): 整库发布身份、写集合与收尾边界
执行时真实时钟与持久授权回读(撤销/过期即停并保留预备份)、写集合写前落盘、
租约与 attempt 身份、恢复队列与原发送身份分离、成功收尾必须释放维护后再登记终态。
2026-11-01 11:35:10 +08:00

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
}