b4add6c9b0
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,不改写历史。
257 lines
8.3 KiB
Go
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 = ©
|
|
}
|
|
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
|
|
}
|