116 lines
4.4 KiB
Go
116 lines
4.4 KiB
Go
package metadata
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"mime"
|
|
|
|
"pageswiki/internal/documentrefs"
|
|
"pageswiki/internal/geduldh"
|
|
)
|
|
|
|
type SavedDocument struct {
|
|
Revision Revision
|
|
Payload []byte
|
|
}
|
|
|
|
// RestoreDocument preserves the historical immutable embedded references; it
|
|
// must not parse Asset provenance and rebind it to today's mutable Asset HEAD.
|
|
func (r *Repository) RestoreDocument(ctx context.Context, documents geduldh.Store, domain, revision, expected, message, actor string) (Revision, error) {
|
|
if documents == nil {
|
|
return Revision{}, ErrInvalid
|
|
}
|
|
v, err := r.GetRevision(ctx, domain, revision)
|
|
if err != nil {
|
|
return Revision{}, err
|
|
}
|
|
refs, err := r.revisionReferences(ctx, domain, revision)
|
|
if err != nil {
|
|
return Revision{}, err
|
|
}
|
|
for _, hash := range append([]string{v.DocumentHash}, refs...) {
|
|
if err := documents.Verify(ctx, hash); err != nil {
|
|
return Revision{}, fmt.Errorf("verify restored Document: %w", err)
|
|
}
|
|
}
|
|
v.Message = message
|
|
return r.appendRevision(ctx, domain, v, expected, refs, actor)
|
|
}
|
|
|
|
// SaveDocument freezes Domain-local Asset HEADs, verifies embedded payloads,
|
|
// persists the immutable Document, then atomically publishes Revision, refs and
|
|
// outbox. No SQL transaction/lock is held during filesystem or remote I/O.
|
|
// A failed metadata commit may leave an unreferenced immutable blob; it must
|
|
// never delete that blob (another writer may already reference the same hash).
|
|
// Concurrent GC needs a separate pin protocol before this pipeline is enabled
|
|
// in a deployment with background deletion. This is not an authorization API.
|
|
func (r *Repository) SaveDocument(ctx context.Context, documents geduldh.Store, domain string, v Revision, payload []byte, expected, actor string) (SavedDocument, error) {
|
|
return r.saveDocument(ctx, documents, domain, v, payload, &expected, actor)
|
|
}
|
|
|
|
// SaveDocumentUnconditionally preserves append-without-CAS semantics for import
|
|
// and legacy clients. Concurrent saves still append immutable revisions with
|
|
// monotonic timestamps; it must not be used to silently retry a failed CAS.
|
|
func (r *Repository) SaveDocumentUnconditionally(ctx context.Context, documents geduldh.Store, domain string, v Revision, payload []byte, actor string) (SavedDocument, error) {
|
|
return r.saveDocument(ctx, documents, domain, v, payload, nil, actor)
|
|
}
|
|
|
|
func (r *Repository) saveDocument(ctx context.Context, documents geduldh.Store, domain string, v Revision, payload []byte, expected *string, actor string) (SavedDocument, error) {
|
|
if documents == nil {
|
|
return SavedDocument{}, ErrInvalid
|
|
}
|
|
lang, err := normalizedLanguage(v.Language)
|
|
if err != nil {
|
|
return SavedDocument{}, err
|
|
}
|
|
v.Language = lang
|
|
if _, _, err := mime.ParseMediaType(v.ContentType); err != nil {
|
|
return SavedDocument{}, ErrInvalid
|
|
}
|
|
var bound bool
|
|
if err := r.database.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM objects o WHERE o.uuid=`+r.p(1)+` AND (`+r.objectDomainScope("o.uuid", r.p(2))+`))`, v.ObjectUUID, domain).Scan(&bound); err != nil {
|
|
return SavedDocument{}, r.failure(err)
|
|
}
|
|
if !bound {
|
|
return SavedDocument{}, ErrNotFound
|
|
}
|
|
// Fail stale saves before expensive payload work; repeat CAS in the commit
|
|
// transaction because a different writer may commit after this preflight.
|
|
head, err := r.Head(ctx, domain, v.ObjectUUID, v.Language)
|
|
if err != nil && !errors.Is(err, ErrNotFound) {
|
|
return SavedDocument{}, err
|
|
}
|
|
if expected != nil && head.UUID != *expected {
|
|
return SavedDocument{}, ErrConflict
|
|
}
|
|
frozen, refs, err := documentrefs.Freeze(ctx, payload, v.ContentType, func(ctx context.Context, address string) (string, error) {
|
|
a, err := r.GetAsset(ctx, domain, address)
|
|
if errors.Is(err, ErrNotFound) {
|
|
return "", documentrefs.ErrUnavailable
|
|
}
|
|
return a.HeadDocumentHash, err
|
|
})
|
|
if err != nil {
|
|
return SavedDocument{}, err
|
|
}
|
|
for _, hash := range refs {
|
|
if err := documents.Verify(ctx, hash); err != nil {
|
|
return SavedDocument{}, fmt.Errorf("verify embedded Document: %w", err)
|
|
}
|
|
}
|
|
sum := sha256.Sum256(frozen)
|
|
v.DocumentHash = hex.EncodeToString(sum[:])
|
|
if err := documents.PutIfAbsent(ctx, v.DocumentHash, int64(len(frozen)), bytes.NewReader(frozen)); err != nil {
|
|
return SavedDocument{}, fmt.Errorf("persist Document: %w", err)
|
|
}
|
|
created, err := r.appendRevisionExpected(ctx, domain, v, expected, refs, actor)
|
|
if err != nil {
|
|
return SavedDocument{}, err
|
|
}
|
|
return SavedDocument{Revision: created, Payload: frozen}, nil
|
|
}
|