Files
knowledge-governance/internal/releaseadapter/v071/gateway_object_store.go
T
姚章浩 b4add6c9b0 fix(library): 收口 B1-R1/B2-R1/B5-R1 并让恢复链经过正式队列终态
B1-R1: 演练写集改为受限 restore-drill(V2 信封/contract 1/schema 摘要,零对象、零索引、零本地映射,来源身份必填)。B2-R1: verify 作业先建不可变 operation 并携带 operation_id,同 job recover 的网关 claim 同时携带原 operation 与 recovery 身份。B5-R1: 前端按 scope 世代与动作序号丢弃迟到响应,不污染新 scope 或父级旧回调。harness 的 recovery 改由生产 jobs.Worker.RunOnce 消费并读回 jobs 终态;原失败窗口作业保持 failed,不改写历史。
2026-11-03 13:02:42 +08:00

257 lines
8.3 KiB
Go

package v071
import (
"context"
"encoding/json"
"errors"
"io"
"os"
"path/filepath"
"strings"
"knowledge-governance/internal/libraryrelease"
"knowledge-governance/internal/objectgateway"
)
// GatewayObjectStore has no write credentials or direct-write fallback. The
// separate reader must be deployed with read-only rights (audit prerequisite).
type GatewayObjectStore struct {
Automatic bool
Claim objectgateway.Claim
frozen *libraryrelease.WriteSet
authorization objectgateway.Grant
Client *objectgateway.Client
Provider, Bucket, GrantDirectory string
requests map[string]objectgateway.Request
owners map[string]string
}
func (s *GatewayObjectStore) ConditionalCapability(ctx context.Context) error {
if s.Client == nil || s.Provider == "" || s.Bucket == "" || (!s.Automatic && !filepath.IsAbs(s.GrantDirectory)) {
return errors.New("object gateway configuration/grant directory missing")
}
if s.Automatic {
return s.Client.ReadyForAcquisition(ctx)
}
return s.Client.Ready(ctx)
}
// ObjectGatewayPlan derives the controller allowlist from the verified original
// write set. Existing shared objects remain read-only, never write-authorized.
func ObjectGatewayPlan(set libraryrelease.WriteSet) (objectgateway.Plan, error) {
if err := set.Verify(); err != nil {
return objectgateway.Plan{}, err
}
p := objectgateway.Plan{Digest: set.Digest, Owner: objectgateway.Digest([]byte(set.JobID))}
for _, obj := range set.Objects {
if !obj.Existing {
p.Objects = append(p.Objects, objectgateway.ObjectBinding{Operation: gatewayCreateOperation(set.Digest, obj.OwnerToken), Key: obj.Key, SHA256: obj.SHA256, Bytes: obj.Bytes})
}
}
return p, nil
}
func gatewayCreateOperation(plan, owner string) string {
return objectgateway.Digest([]byte(plan + "\x00" + owner + "\x00create"))
}
// OwnedAttemptClaim 暴露本装配冻结的 attempt claim:受限演练计划/回放必须与它一致。
func (s *GatewayObjectStore) OwnedAttemptClaim() (objectgateway.Claim, bool) {
return s.Claim, s.Automatic
}
func (s *GatewayObjectStore) BindObjectPlan(set libraryrelease.WriteSet) error {
if !validLowerSHA256(set.Digest) || set.JobID == "" {
return errors.New("gateway frozen plan identity missing")
}
if _, e := ObjectGatewayPlan(set); e != nil {
return e
}
if s.frozen != nil && s.frozen.Digest != set.Digest {
return errors.New("gateway store cannot replace frozen identity")
}
if s.Automatic {
if s.frozen == nil {
copy := set
s.frozen = &copy
}
return nil
}
path := filepath.Join(s.GrantDirectory, set.Digest+".json")
info, e := os.Lstat(path)
if e != nil || !info.Mode().IsRegular() || info.Size() > 4096 || info.Mode().Perm()&0022 != 0 {
return errors.New("gateway controller grant unavailable")
}
raw, e := os.ReadFile(path)
if e != nil {
return errors.New("gateway controller grant unavailable")
}
var grant objectgateway.Grant
if json.Unmarshal(raw, &grant) != nil || grant.Epoch < 1 || grant.Plan != set.Digest || grant.Owner != objectgateway.Digest([]byte(set.JobID)) {
return errors.New("gateway controller grant differs from frozen job/plan")
}
return s.bindGrant(context.Background(), set, grant)
}
func (s *GatewayObjectStore) EnsureObjectGrant(ctx context.Context) error {
if !s.Automatic || s.requests != nil {
return nil
}
if s.frozen == nil || s.Claim.JobID != s.frozen.JobID {
return errors.New("gateway active attempt/frozen plan missing")
}
claim := s.Claim
claim.PlanDigest = s.frozen.Digest
grant, e := s.Client.Acquire(ctx, claim)
if e != nil {
return e
}
return s.bindGrant(ctx, *s.frozen, grant)
}
func (s *GatewayObjectStore) bindGrant(ctx context.Context, set libraryrelease.WriteSet, grant objectgateway.Grant) error {
requests := map[string]objectgateway.Request{}
owners := map[string]string{}
for _, obj := range set.Objects {
if obj.Provider != s.Provider || obj.Bucket != s.Bucket {
return errors.New("gateway plan target mismatch")
}
if obj.Existing {
continue
}
req := objectgateway.Request{Grant: grant, Operation: gatewayCreateOperation(set.Digest, obj.OwnerToken), Key: obj.Key, Action: "create", SHA256: obj.SHA256, Bytes: obj.Bytes}
original, e := s.Client.Resolve(ctx, req)
if e != nil {
return e
}
requests[obj.Key] = original
owners[obj.Key] = obj.OwnerToken
}
s.authorization = grant
s.requests = requests
s.owners = owners
return nil
}
func (s *GatewayObjectStore) key(provider, locator string) (string, error) {
if provider != s.Provider || !validObjectKey(locator) {
return "", errors.New("gateway provider/locator mismatch")
}
parts := strings.SplitN(strings.TrimPrefix(locator, "storage://"), "/", 2)
if !strings.HasPrefix(locator, "storage://") || len(parts) != 2 || parts[0] == "" {
return "", errors.New("gateway explicit locator required")
}
prefix := s.Provider + "://" + s.Bucket + "/"
if !strings.HasPrefix(parts[1], prefix) {
return "", errors.New("gateway bucket mismatch")
}
key := strings.TrimPrefix(parts[1], prefix)
if key == "" {
return "", errors.New("gateway key missing")
}
return key, nil
}
func (s *GatewayObjectStore) ObserveObject(ctx context.Context, provider, locator string) (objectObservation, error) {
if s.frozen != nil {
if e := s.EnsureObjectGrant(ctx); e != nil {
return objectObservation{}, e
}
}
key, e := s.key(provider, locator)
if e != nil {
return objectObservation{}, e
}
v, exists, e := s.Client.Observe(ctx, key, "")
if e != nil {
return objectObservation{}, e
}
if !exists {
return objectObservation{}, nil
}
o := fromGateway(v)
if req, ok := s.requests[key]; ok && v.Owner == req.Claim() {
o.Owner = s.owners[key]
}
return o, nil
}
func (s *GatewayObjectStore) CreateObject(ctx context.Context, provider, locator string, body io.Reader, size int64, owner string) error {
if e := s.EnsureObjectGrant(ctx); e != nil {
return e
}
key, e := s.key(provider, locator)
if e != nil {
return e
}
r, ok := s.requests[key]
if !ok || owner != s.owners[key] || size != r.Bytes {
return errObjectWriteRejected
}
raw, e := io.ReadAll(io.LimitReader(body, size+1))
if e != nil || int64(len(raw)) != size || objectgateway.Digest(raw) != r.SHA256 {
return errObjectWriteRejected
}
receipt, e := s.Client.ExecuteAuthorized(ctx, s.authorization, r, raw)
if e != nil {
return e
}
if receipt.State == "rejected" {
return errObjectWriteRejected
}
if receipt.State != "committed" {
return errors.New("gateway create not committed")
}
return nil
}
func (s *GatewayObjectStore) RemoveObject(ctx context.Context, provider, locator string, want objectObservation) error {
if e := s.EnsureObjectGrant(ctx); e != nil {
return e
}
key, e := s.key(provider, locator)
if e != nil {
return e
}
create, ok := s.requests[key]
if !ok || want.Owner != s.owners[key] {
return errors.New("gateway cleanup lacks frozen ownership")
}
receipt, e := s.Client.Reconcile(ctx, create)
if e != nil {
return e
}
raw := want
raw.Owner = create.Claim()
if receipt.State != "committed" || receipt.Version != toGateway(raw) {
return errors.New("gateway cleanup receipt mismatch")
}
req := create
req.Grant = s.authorization
req.Operation = objectgateway.Digest([]byte(create.Operation + "\x00delete"))
req.Action = "delete"
req.CreatedBy = create.Operation
req.Version = receipt.Version
original, e := s.Client.Resolve(ctx, req)
if e != nil {
return e
}
deleted, e := s.Client.ExecuteAuthorized(ctx, s.authorization, original, nil)
if e != nil {
return e
}
if deleted.State != "removed" {
return errors.New("gateway deletion not confirmed")
}
return nil
}
func (s *GatewayObjectStore) Put(context.Context, string, string, io.Reader, int64) error {
return errors.New("gateway refuses unplanned Put; frozen object plan required")
}
func (s *GatewayObjectStore) Copy(context.Context, string, string, string) error {
return errors.New("gateway refuses unplanned Copy; frozen object plan required")
}
func (s *GatewayObjectStore) Stat(ctx context.Context, provider, locator string) (int64, string, error) {
o, e := s.ObserveObject(ctx, provider, locator)
if e != nil {
return 0, "", e
}
if !o.Exists {
return 0, "", errors.New("gateway object absent")
}
return o.Bytes, o.SHA256, nil
}