8d838d9cb4
build / build (push) Successful in 1m45s
执行时真实时钟与持久授权回读(撤销/过期即停并保留预备份)、写集合写前落盘、 租约与 attempt 身份、恢复队列与原发送身份分离、成功收尾必须释放维护后再登记终态。
255 lines
8.1 KiB
Go
255 lines
8.1 KiB
Go
package v071
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"knowledge-governance/internal/libraryrelease"
|
|
"knowledge-governance/internal/librarysnapshot"
|
|
)
|
|
|
|
func (t *ProductionLibraryTarget) planObjects(ctx context.Context, archive *librarysnapshot.Archive, manifest librarysnapshot.Manifest, set *libraryrelease.WriteSet) error {
|
|
objects := map[string]librarysnapshot.Part{}
|
|
for _, p := range manifest.Parts {
|
|
if p.Kind == "resource" {
|
|
if _, exists := objects[p.Name]; exists {
|
|
return errors.New("duplicate object resource identity")
|
|
}
|
|
objects[p.Name] = p
|
|
}
|
|
}
|
|
if len(objects) == 0 {
|
|
return nil
|
|
}
|
|
store, ok := t.config.Objects.(conditionalObjectStore)
|
|
if !ok {
|
|
return errors.New("target lacks conditional object effects")
|
|
}
|
|
if err := store.ConditionalCapability(ctx); err != nil {
|
|
return err
|
|
}
|
|
seen := map[string]bool{}
|
|
for _, part := range manifest.Parts {
|
|
if part.Kind != "database" || part.Name != "resources" {
|
|
continue
|
|
}
|
|
reader, err := archive.OpenPart(part)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var rows []map[string]json.RawMessage
|
|
err = json.NewDecoder(reader).Decode(&rows)
|
|
reader.Close()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, row := range rows {
|
|
var id string
|
|
if err := json.Unmarshal(row["id"], &id); err != nil {
|
|
return err
|
|
}
|
|
blob, exists := objects[id]
|
|
if !exists {
|
|
return errors.New("resource has no bound object blob")
|
|
}
|
|
if err := t.retargetRow("resources", row); err != nil {
|
|
return err
|
|
}
|
|
obj := libraryrelease.ObjectWrite{ResourceID: id, SHA256: blob.SHA256, Bytes: blob.Bytes}
|
|
if json.Unmarshal(row["provider"], &obj.Provider) != nil || json.Unmarshal(row["physical_path"], &obj.Locator) != nil {
|
|
return errors.New("resource locator missing")
|
|
}
|
|
rest := strings.TrimPrefix(obj.Locator, "storage://")
|
|
parts := strings.SplitN(rest, "/", 2)
|
|
if rest == obj.Locator || len(parts) != 2 {
|
|
return errors.New("object needs explicit backend/bucket/key")
|
|
}
|
|
obj.BackendID = parts[0]
|
|
physical := strings.TrimPrefix(parts[1], obj.Provider+"://")
|
|
location := strings.SplitN(physical, "/", 2)
|
|
if physical == parts[1] || len(location) != 2 || location[0] == "" || location[1] == "" {
|
|
return errors.New("invalid physical object identity")
|
|
}
|
|
obj.Bucket, obj.Key = location[0], location[1]
|
|
// Backend aliases cannot make a shared physical key look independent.
|
|
key := obj.Provider + "/" + obj.Bucket + "/" + obj.Key
|
|
if seen[key] {
|
|
return errors.New("duplicate physical object destination")
|
|
}
|
|
seen[key] = true
|
|
token := sha256.Sum256([]byte(set.JobID + "\x00" + set.Target + "\x00" + set.BackupSnapshotID + "\x00" + set.TargetSnapshotID + "\x00" + key))
|
|
obj.OwnerToken = hex.EncodeToString(token[:])
|
|
observation, err := store.ObserveObject(ctx, obj.Provider, obj.Locator)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
obj.Existing, obj.BeforeETag = observation.Exists, observation.ETag
|
|
obj.BeforeVersionID = observation.VersionID
|
|
if observation.Exists && (observation.SHA256 != obj.SHA256 || observation.Bytes != obj.Bytes) {
|
|
return errors.New("different existing object cannot be recoverably overwritten")
|
|
}
|
|
set.Objects = append(set.Objects, obj)
|
|
delete(objects, id)
|
|
}
|
|
}
|
|
if len(objects) != 0 {
|
|
return errors.New("object blob lacks resource identity")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (t *ProductionLibraryTarget) objectEffectPath(obj libraryrelease.ObjectWrite, phase string) string {
|
|
sum := sha256.Sum256([]byte(obj.Provider + "\x00" + obj.Bucket + "\x00" + obj.Key))
|
|
return filepath.Join(t.config.ArchiveRoot, "effects", t.activePlan.Digest, "objects", hex.EncodeToString(sum[:]), phase+".json")
|
|
}
|
|
|
|
func effectExists(path string) (bool, error) {
|
|
info, err := os.Lstat(path)
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
return false, nil
|
|
}
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if !info.Mode().IsRegular() {
|
|
return false, errors.New("effect evidence is not a regular file")
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func (t *ProductionLibraryTarget) recordObjectEffect(obj libraryrelease.ObjectWrite, phase string, observation objectObservation) error {
|
|
raw, err := json.Marshal(struct {
|
|
Plan string `json:"plan"`
|
|
Object libraryrelease.ObjectWrite `json:"object"`
|
|
Observation objectObservation `json:"observation"`
|
|
}{t.activePlan.Digest, obj, observation})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return persistImmutableJSON(t.objectEffectPath(obj, phase), raw)
|
|
}
|
|
|
|
func matchesObject(obj libraryrelease.ObjectWrite, observed objectObservation, owned bool) bool {
|
|
return observed.Exists && observed.Bytes == obj.Bytes && observed.SHA256 == obj.SHA256 && (!owned || (observed.Owner == obj.OwnerToken && observed.VersionID != "" && observed.VersionID != "null"))
|
|
}
|
|
|
|
func (t *ProductionLibraryTarget) applyPlannedObject(ctx context.Context, obj libraryrelease.ObjectWrite, body []byte) error {
|
|
store, ok := t.config.Objects.(conditionalObjectStore)
|
|
if !ok {
|
|
return errors.New("object effects capability missing")
|
|
}
|
|
if obj.Existing {
|
|
observed, err := store.ObserveObject(ctx, obj.Provider, obj.Locator)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !matchesObject(obj, observed, false) || observed.ETag != obj.BeforeETag || observed.VersionID != obj.BeforeVersionID {
|
|
return errors.New("read-only object changed since plan")
|
|
}
|
|
return nil
|
|
}
|
|
intended, err := effectExists(t.objectEffectPath(obj, "create-intent"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !intended {
|
|
if err := t.recordObjectEffect(obj, "create-intent", objectObservation{}); err != nil {
|
|
return err
|
|
}
|
|
err = store.CreateObject(ctx, obj.Provider, obj.Locator, bytes.NewReader(body), obj.Bytes, obj.OwnerToken)
|
|
if errors.Is(err, errObjectWriteRejected) {
|
|
if e := t.recordObjectEffect(obj, "create-rejected", objectObservation{}); e != nil {
|
|
return e
|
|
}
|
|
return err
|
|
}
|
|
// Even 2xx is not a receipt: observe the exact physical target independently.
|
|
}
|
|
observed, observeErr := store.ObserveObject(ctx, obj.Provider, obj.Locator)
|
|
if observeErr != nil {
|
|
return observeErr
|
|
}
|
|
if !matchesObject(obj, observed, true) {
|
|
return errors.New("object create unknown or conflicting; do not replay/delete without ownership proof")
|
|
}
|
|
return t.recordObjectEffect(obj, "created", observed)
|
|
}
|
|
|
|
func (t *ProductionLibraryTarget) restoreCreatedObjects(ctx context.Context) error {
|
|
if t.activePlan == nil {
|
|
return errors.New("object restoration requires adopted plan")
|
|
}
|
|
if len(t.activePlan.Objects) == 0 {
|
|
return nil
|
|
}
|
|
store, ok := t.config.Objects.(conditionalObjectStore)
|
|
if !ok {
|
|
return errors.New("object restoration capability missing")
|
|
}
|
|
for _, obj := range t.activePlan.Objects {
|
|
if obj.Existing {
|
|
continue
|
|
}
|
|
intent, err := effectExists(t.objectEffectPath(obj, "create-intent"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !intent {
|
|
continue
|
|
}
|
|
rejected, err := effectExists(t.objectEffectPath(obj, "create-rejected"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if rejected {
|
|
continue
|
|
}
|
|
observed, err := store.ObserveObject(ctx, obj.Provider, obj.Locator)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
created, err := effectExists(t.objectEffectPath(obj, "created"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !observed.Exists {
|
|
if !created {
|
|
return errors.New("unresolved create intent: absence is not proof no delayed write remains")
|
|
}
|
|
if err := t.recordObjectEffect(obj, "removed", objectObservation{}); err != nil {
|
|
return err
|
|
}
|
|
continue
|
|
}
|
|
if !matchesObject(obj, observed, true) {
|
|
return errors.New("created object now differs or has another owner; cleanup refused")
|
|
}
|
|
if err := t.recordObjectEffect(obj, "created", observed); err != nil {
|
|
return err
|
|
}
|
|
if err := t.recordObjectEffect(obj, "delete-intent", observed); err != nil {
|
|
return err
|
|
}
|
|
deleteErr := store.RemoveObject(ctx, obj.Provider, obj.Locator, observed)
|
|
after, err := store.ObserveObject(ctx, obj.Provider, obj.Locator)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if after.Exists {
|
|
return fmt.Errorf("conditional object cleanup not confirmed: %v", deleteErr)
|
|
}
|
|
if err := t.recordObjectEffect(obj, "removed", objectObservation{}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|