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

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
}