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 }