450 lines
19 KiB
Go
450 lines
19 KiB
Go
package store
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"pageswiki/internal/metadata"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
var (
|
|
ErrAssetNotFound = errors.New("asset not found")
|
|
ErrAssetConflict = errors.New("asset HEAD conflict")
|
|
)
|
|
|
|
type Asset struct {
|
|
DomainUUID string `json:"domain_uuid"`
|
|
Address string `json:"address"`
|
|
ObjectUUID string `json:"object_uuid"`
|
|
HeadDocumentHash string `json:"head_document_hash"`
|
|
ContentType string `json:"content_type"`
|
|
Filename string `json:"filename"`
|
|
SizeBytes int64 `json:"size_bytes"`
|
|
CreatedAtMS int64 `json:"created_at_ms"`
|
|
UpdatedAtMS int64 `json:"updated_at_ms"`
|
|
ReferenceCount int `json:"reference_count"`
|
|
}
|
|
|
|
type AssetHistory struct {
|
|
ID int64 `json:"id"`
|
|
Action string `json:"action"`
|
|
DocumentHash string `json:"document_hash"`
|
|
ContentType string `json:"content_type"`
|
|
Filename string `json:"filename"`
|
|
SizeBytes int64 `json:"size_bytes"`
|
|
ActorUUID string `json:"actor_uuid"`
|
|
CreatedAtMS int64 `json:"created_at_ms"`
|
|
}
|
|
|
|
type AssetDependency struct {
|
|
DocumentHash string `json:"document_hash"`
|
|
RevisionUUID string `json:"revision_uuid"`
|
|
ObjectUUID string `json:"object_uuid"`
|
|
Path string `json:"path"`
|
|
CreatedAtMS int64 `json:"created_at_ms"`
|
|
}
|
|
|
|
func (s *Store) EnsureAssetsSchema() error {
|
|
if s.sqlBackend == storePostgreSQL {
|
|
// Native core migrations own these tables; never run SQLite adoption.
|
|
rows, err := s.DB.Query(`SELECT a.domain_uuid,a.address,a.object_uuid,a.head_document_hash,a.content_type,a.filename,a.size_bytes,a.created_at_ms,a.updated_at_ms,h.id,h.action,h.document_hash,h.actor_uuid FROM assets a JOIN asset_head_history h ON h.domain_uuid=a.domain_uuid AND h.address=a.address WHERE 1=0`)
|
|
if err != nil {
|
|
return s.sqlError("asset schema", err)
|
|
}
|
|
return rows.Close()
|
|
}
|
|
columns, err := assetTableColumns(s.DB, "assets")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(columns) == 0 {
|
|
if _, err = s.DB.Exec(assetTableSQL); err != nil {
|
|
return err
|
|
}
|
|
} else if !columns["domain_uuid"] {
|
|
tx, err := s.DB.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
if _, err = tx.Exec(`ALTER TABLE assets RENAME TO assets_legacy`); err != nil {
|
|
return err
|
|
}
|
|
if _, err = tx.Exec(assetTableSQL); err != nil {
|
|
return err
|
|
}
|
|
if _, err = tx.Exec(`
|
|
INSERT INTO assets(domain_uuid,address,object_uuid,head_document_hash,content_type,filename,size_bytes,created_at_ms,updated_at_ms)
|
|
SELECT COALESCE((SELECT uuid FROM domains WHERE name='default' ORDER BY id LIMIT 1),(SELECT uuid FROM domains ORDER BY id LIMIT 1)),address,object_uuid,head_document_hash,'application/octet-stream','',0,created_at_ms,updated_at_ms
|
|
FROM assets_legacy
|
|
`); err != nil {
|
|
return err
|
|
}
|
|
if _, err = tx.Exec(`DROP TABLE assets_legacy`); err != nil {
|
|
return err
|
|
}
|
|
if err = tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
} else if _, err = s.DB.Exec(assetTableSQL); err != nil {
|
|
return err
|
|
}
|
|
_, err = s.DB.Exec(`CREATE TABLE IF NOT EXISTS asset_head_history(
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,domain_uuid TEXT NOT NULL,address TEXT NOT NULL,
|
|
action TEXT NOT NULL DEFAULT 'put',
|
|
document_hash TEXT NOT NULL,content_type TEXT NOT NULL DEFAULT 'application/octet-stream',
|
|
filename TEXT NOT NULL DEFAULT '',size_bytes INTEGER NOT NULL DEFAULT 0,
|
|
actor_uuid TEXT NOT NULL DEFAULT '',created_at_ms INTEGER NOT NULL
|
|
)`)
|
|
_, _ = s.DB.Exec(`ALTER TABLE asset_head_history ADD COLUMN action TEXT NOT NULL DEFAULT 'put'`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = s.DB.Exec(`CREATE INDEX IF NOT EXISTS idx_asset_history_domain_address_hash ON asset_head_history(domain_uuid,address,document_hash)`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return err
|
|
}
|
|
|
|
const assetTableSQL = `CREATE TABLE IF NOT EXISTS assets(
|
|
domain_uuid TEXT NOT NULL,address TEXT NOT NULL,object_uuid TEXT NOT NULL,
|
|
head_document_hash TEXT,content_type TEXT NOT NULL DEFAULT 'application/octet-stream',
|
|
filename TEXT NOT NULL DEFAULT '',size_bytes INTEGER NOT NULL DEFAULT 0,
|
|
created_at_ms INTEGER NOT NULL,updated_at_ms INTEGER NOT NULL,
|
|
PRIMARY KEY(domain_uuid,address),UNIQUE(object_uuid)
|
|
)`
|
|
|
|
func assetTableColumns(db *sql.DB, table string) (map[string]bool, error) {
|
|
rows, err := db.Query(`PRAGMA table_info(` + table + `)`)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
out := map[string]bool{}
|
|
for rows.Next() {
|
|
var cid, notnull, pk int
|
|
var name, kind string
|
|
var defaultValue any
|
|
if err := rows.Scan(&cid, &name, &kind, ¬null, &defaultValue, &pk); err != nil {
|
|
return nil, err
|
|
}
|
|
out[name] = true
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func (s *Store) ListAssets(domainUUID string) (_ []Asset, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("list assets", resultErr) }()
|
|
rows, err := s.DB.Query(`SELECT a.domain_uuid,a.address,a.object_uuid,COALESCE(a.head_document_hash,''),a.content_type,a.filename,a.size_bytes,a.created_at_ms,a.updated_at_ms,(SELECT COUNT(DISTINCT x.revision_uuid) FROM revision_document_refs x JOIN revisions r ON r.uuid=x.revision_uuid WHERE x.document_hash IN (SELECT document_hash FROM asset_head_history h WHERE h.domain_uuid=a.domain_uuid AND h.address=a.address UNION SELECT a.head_document_hash) AND EXISTS(SELECT 1 FROM paths p WHERE p.domain_uuid=a.domain_uuid AND p.object_uuid=r.object_uuid)) FROM assets a WHERE a.domain_uuid=`+s.sqlParam(1)+` ORDER BY a.updated_at_ms DESC,a.address`, domainUUID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var assets []Asset
|
|
for rows.Next() {
|
|
var a Asset
|
|
if err := rows.Scan(&a.DomainUUID, &a.Address, &a.ObjectUUID, &a.HeadDocumentHash, &a.ContentType, &a.Filename, &a.SizeBytes, &a.CreatedAtMS, &a.UpdatedAtMS, &a.ReferenceCount); err != nil {
|
|
return nil, err
|
|
}
|
|
assets = append(assets, a)
|
|
}
|
|
return assets, rows.Err()
|
|
}
|
|
|
|
func (s *Store) GetAsset(domainUUID, address string) (_ *Asset, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("get asset", resultErr) }()
|
|
var a Asset
|
|
err := s.DB.QueryRow(`SELECT a.domain_uuid,a.address,a.object_uuid,COALESCE(a.head_document_hash,''),a.content_type,a.filename,a.size_bytes,a.created_at_ms,a.updated_at_ms,(SELECT COUNT(DISTINCT x.revision_uuid) FROM revision_document_refs x JOIN revisions r ON r.uuid=x.revision_uuid WHERE x.document_hash IN (SELECT document_hash FROM asset_head_history h WHERE h.domain_uuid=a.domain_uuid AND h.address=a.address UNION SELECT a.head_document_hash) AND EXISTS(SELECT 1 FROM paths p WHERE p.domain_uuid=a.domain_uuid AND p.object_uuid=r.object_uuid)) FROM assets a WHERE a.domain_uuid=`+s.sqlParam(1)+` AND a.address=`+s.sqlParam(2), domainUUID, address).Scan(&a.DomainUUID, &a.Address, &a.ObjectUUID, &a.HeadDocumentHash, &a.ContentType, &a.Filename, &a.SizeBytes, &a.CreatedAtMS, &a.UpdatedAtMS, &a.ReferenceCount)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, ErrAssetNotFound
|
|
}
|
|
return &a, err
|
|
}
|
|
|
|
func (s *Store) GetAssetByHeadHash(domainUUID, hash string) (_ *Asset, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("get asset hash", resultErr) }()
|
|
hash = strings.ToLower(strings.TrimSpace(hash))
|
|
if !validDocumentHash(hash) {
|
|
return nil, ErrAssetNotFound
|
|
}
|
|
var a Asset
|
|
err := s.DB.QueryRow(`SELECT a.domain_uuid,a.address,a.object_uuid,COALESCE(a.head_document_hash,''),a.content_type,a.filename,a.size_bytes,a.created_at_ms,a.updated_at_ms,(SELECT COUNT(DISTINCT x.revision_uuid) FROM revision_document_refs x JOIN revisions r ON r.uuid=x.revision_uuid WHERE x.document_hash IN (SELECT document_hash FROM asset_head_history h WHERE h.domain_uuid=a.domain_uuid AND h.address=a.address UNION SELECT a.head_document_hash) AND EXISTS(SELECT 1 FROM paths p WHERE p.domain_uuid=a.domain_uuid AND p.object_uuid=r.object_uuid)) FROM assets a WHERE a.domain_uuid=`+s.sqlParam(1)+` AND a.head_document_hash=`+s.sqlParam(2)+` LIMIT 1`, domainUUID, hash).Scan(&a.DomainUUID, &a.Address, &a.ObjectUUID, &a.HeadDocumentHash, &a.ContentType, &a.Filename, &a.SizeBytes, &a.CreatedAtMS, &a.UpdatedAtMS, &a.ReferenceCount)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, ErrAssetNotFound
|
|
}
|
|
return &a, err
|
|
}
|
|
|
|
func normalizeAssetAddress(address string) (string, error) {
|
|
address = strings.TrimSpace(address)
|
|
parts := strings.SplitN(address, ":", 3)
|
|
if len(parts) != 3 || parts[0] != "asset" || strings.TrimSpace(parts[1]) == "" || strings.TrimSpace(parts[2]) == "" {
|
|
return "", fmt.Errorf("invalid asset address")
|
|
}
|
|
return address, nil
|
|
}
|
|
|
|
func (s *Store) PutAsset(domainUUID, address string, payload []byte, contentType, filename, expectedHash, actorUUID string) (*Asset, bool, error) {
|
|
if s.ReadOnly {
|
|
return nil, false, ErrReadOnly
|
|
}
|
|
if s.sqlBackend == storePostgreSQL {
|
|
return s.putNativeAsset(domainUUID, address, payload, contentType, filename, expectedHash, actorUUID)
|
|
}
|
|
if s.DocumentRoot == "" {
|
|
return nil, false, errors.New("Asset writes require a configured Document Store")
|
|
}
|
|
address, err := normalizeAssetAddress(address)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
current, getErr := s.GetAsset(domainUUID, address)
|
|
if getErr != nil && !errors.Is(getErr, ErrAssetNotFound) {
|
|
return nil, false, getErr
|
|
}
|
|
if getErr == nil && expectedHash == "" {
|
|
return nil, false, ErrAssetConflict
|
|
}
|
|
if strings.TrimSpace(contentType) == "" {
|
|
contentType = "application/octet-stream"
|
|
}
|
|
filename = strings.TrimSpace(filename)
|
|
if expectedHash != "" && (getErr != nil || current.HeadDocumentHash != strings.Trim(expectedHash, "\"")) {
|
|
return nil, false, ErrAssetConflict
|
|
}
|
|
hash := revisionHash(string(payload))
|
|
if getErr == nil && current.HeadDocumentHash == hash && current.ContentType == contentType && current.Filename == filename {
|
|
return current, false, nil
|
|
}
|
|
if err := s.persistDocument(hash, string(payload)); err != nil {
|
|
return nil, false, err
|
|
}
|
|
if strings.TrimSpace(contentType) == "" {
|
|
contentType = "application/octet-stream"
|
|
}
|
|
filename = strings.TrimSpace(filename)
|
|
now := time.Now().UnixMilli()
|
|
tx, err := s.DB.Begin()
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
defer tx.Rollback()
|
|
if getErr != nil {
|
|
objectUUID := uuid.NewString()
|
|
if _, err = tx.Exec(`INSERT INTO objects(uuid,kind,created_at) VALUES(?,'asset',?)`, objectUUID, now/1000); err != nil {
|
|
return nil, false, err
|
|
}
|
|
_, err = tx.Exec(`INSERT INTO assets(domain_uuid,address,object_uuid,head_document_hash,content_type,filename,size_bytes,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?,?,?)`, domainUUID, address, objectUUID, hash, contentType, filename, len(payload), now, now)
|
|
} else {
|
|
var result sql.Result
|
|
result, err = tx.Exec(`UPDATE assets SET head_document_hash=?,content_type=?,filename=?,size_bytes=?,updated_at_ms=? WHERE domain_uuid=? AND address=? AND head_document_hash=?`, hash, contentType, filename, len(payload), now, domainUUID, address, current.HeadDocumentHash)
|
|
if err == nil {
|
|
if n, _ := result.RowsAffected(); n != 1 {
|
|
return nil, false, ErrAssetConflict
|
|
}
|
|
}
|
|
}
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
if _, err = tx.Exec(`INSERT INTO asset_head_history(domain_uuid,address,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms) VALUES(?,?,'put',?,?,?,?,?,?)`, domainUUID, address, hash, contentType, filename, len(payload), actorUUID, now); err != nil {
|
|
return nil, false, err
|
|
}
|
|
if err = tx.Commit(); err != nil {
|
|
return nil, false, err
|
|
}
|
|
a, err := s.GetAsset(domainUUID, address)
|
|
return a, true, err
|
|
}
|
|
|
|
func (s *Store) ListAssetHistory(domainUUID, address string) (_ []AssetHistory, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("asset history", resultErr) }()
|
|
rows, err := s.DB.Query(`SELECT id,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms FROM asset_head_history WHERE domain_uuid=`+s.sqlParam(1)+` AND address=`+s.sqlParam(2)+` ORDER BY id DESC LIMIT 100`, domainUUID, address)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var out []AssetHistory
|
|
for rows.Next() {
|
|
var x AssetHistory
|
|
if err := rows.Scan(&x.ID, &x.Action, &x.DocumentHash, &x.ContentType, &x.Filename, &x.SizeBytes, &x.ActorUUID, &x.CreatedAtMS); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, x)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func (s *Store) ListAssetDependencies(domainUUID, address string) (_ []AssetDependency, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("asset dependencies", resultErr) }()
|
|
rows, err := s.DB.Query(`
|
|
SELECT DISTINCT x.document_hash,r.uuid,r.object_uuid,p.path,
|
|
COALESCE(r.created_at_ms,COALESCE(r.created_at,0)*1000)
|
|
FROM (SELECT domain_uuid,address,document_hash FROM asset_head_history
|
|
UNION SELECT domain_uuid,address,head_document_hash FROM assets) h
|
|
JOIN revision_document_refs x ON x.document_hash=h.document_hash
|
|
JOIN revisions r ON r.uuid=x.revision_uuid
|
|
JOIN paths p ON p.domain_uuid=h.domain_uuid AND p.object_uuid=r.object_uuid
|
|
WHERE h.domain_uuid=`+s.sqlParam(1)+` AND h.address=`+s.sqlParam(2)+`
|
|
ORDER BY COALESCE(r.created_at_ms,COALESCE(r.created_at,0)*1000) DESC,p.path
|
|
LIMIT 500
|
|
`, domainUUID, address)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var out []AssetDependency
|
|
for rows.Next() {
|
|
var x AssetDependency
|
|
if err := rows.Scan(&x.DocumentHash, &x.RevisionUUID, &x.ObjectUUID, &x.Path, &x.CreatedAtMS); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, x)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func (s *Store) RestoreAssetHead(domainUUID, address string, historyID int64, expectedHash, actorUUID string) (*Asset, error) {
|
|
if s.ReadOnly {
|
|
return nil, ErrReadOnly
|
|
}
|
|
current, err := s.GetAsset(domainUUID, address)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if expectedHash == "" || current.HeadDocumentHash != strings.Trim(expectedHash, "\"") {
|
|
return nil, ErrAssetConflict
|
|
}
|
|
var historical AssetHistory
|
|
err = s.DB.QueryRow(`SELECT id,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms FROM asset_head_history WHERE domain_uuid=`+s.sqlParam(1)+` AND address=`+s.sqlParam(2)+` AND id=`+s.sqlParam(3), domainUUID, address, historyID).Scan(&historical.ID, &historical.Action, &historical.DocumentHash, &historical.ContentType, &historical.Filename, &historical.SizeBytes, &historical.ActorUUID, &historical.CreatedAtMS)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, ErrAssetNotFound
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if s.sqlBackend == storePostgreSQL {
|
|
if s.DocumentRoot == "" {
|
|
return nil, ErrDocumentStoreRequired
|
|
}
|
|
docs, err := s.documentStorage()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
|
defer cancel()
|
|
if err = docs.Verify(ctx, historical.DocumentHash); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
reader, err := s.OpenDocument(historical.DocumentHash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_ = reader.Close()
|
|
now := time.Now().UnixMilli()
|
|
tx, cancel, err := s.beginPathMutation(domainUUID)
|
|
defer cancel()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer tx.Rollback()
|
|
result, err := tx.Exec(`UPDATE assets SET head_document_hash=`+s.sqlParam(1)+`,content_type=`+s.sqlParam(2)+`,filename=`+s.sqlParam(3)+`,size_bytes=`+s.sqlParam(4)+`,updated_at_ms=`+s.sqlParam(5)+` WHERE domain_uuid=`+s.sqlParam(6)+` AND address=`+s.sqlParam(7)+` AND head_document_hash=`+s.sqlParam(8), historical.DocumentHash, historical.ContentType, historical.Filename, historical.SizeBytes, now, domainUUID, address, current.HeadDocumentHash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
affected, _ := result.RowsAffected()
|
|
if affected != 1 {
|
|
return nil, ErrAssetConflict
|
|
}
|
|
if _, err = tx.Exec(`INSERT INTO asset_head_history(domain_uuid,address,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,'restore',`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`)`, domainUUID, address, historical.DocumentHash, historical.ContentType, historical.Filename, historical.SizeBytes, actorUUID, now); err != nil {
|
|
return nil, err
|
|
}
|
|
if err = tx.Commit(); err != nil {
|
|
return nil, err
|
|
}
|
|
return s.GetAsset(domainUUID, address)
|
|
}
|
|
|
|
func (s *Store) DeleteAsset(domainUUID, address, expectedHash, actorUUID string) error {
|
|
if s.ReadOnly {
|
|
return ErrReadOnly
|
|
}
|
|
a, err := s.GetAsset(domainUUID, address)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if expectedHash == "" || a.HeadDocumentHash != strings.Trim(expectedHash, "\"") {
|
|
return ErrAssetConflict
|
|
}
|
|
now := time.Now().UnixMilli()
|
|
tx, cancel, err := s.beginPathMutation(domainUUID)
|
|
defer cancel()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
if _, err = tx.Exec(`INSERT INTO asset_head_history(domain_uuid,address,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,'delete',`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`)`, domainUUID, address, a.HeadDocumentHash, a.ContentType, a.Filename, a.SizeBytes, actorUUID, now); err != nil {
|
|
return err
|
|
}
|
|
result, err := tx.Exec(`DELETE FROM assets WHERE domain_uuid=`+s.sqlParam(1)+` AND address=`+s.sqlParam(2)+` AND head_document_hash=`+s.sqlParam(3), domainUUID, address, a.HeadDocumentHash)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n, _ := result.RowsAffected(); n != 1 {
|
|
return ErrAssetConflict
|
|
}
|
|
return tx.Commit()
|
|
}
|
|
|
|
func (s *Store) putNativeAsset(domain, address string, payload []byte, contentType, filename, expected, actor string) (*Asset, bool, error) {
|
|
if s.DocumentRoot == "" {
|
|
return nil, false, ErrDocumentStoreRequired
|
|
}
|
|
address, err := normalizeAssetAddress(address)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
if strings.TrimSpace(contentType) == "" {
|
|
contentType = "application/octet-stream"
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
|
defer cancel()
|
|
repo, err := metadata.NewApplication(s.DB, metadata.PostgreSQL)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
docs, err := s.documentStorage()
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
hash := revisionHash(string(payload))
|
|
previous, getErr := repo.GetAsset(ctx, domain, address)
|
|
if getErr != nil && !errors.Is(getErr, metadata.ErrNotFound) {
|
|
return nil, false, getErr
|
|
}
|
|
if previous.HeadDocumentHash != strings.Trim(expected, "\"") {
|
|
return nil, false, ErrAssetConflict
|
|
}
|
|
if err = docs.PutIfAbsent(ctx, hash, int64(len(payload)), bytes.NewReader(payload)); err != nil {
|
|
return nil, false, err
|
|
}
|
|
a, err := repo.PutAsset(ctx, metadata.Asset{DomainUUID: domain, Address: address, HeadDocumentHash: hash, ContentType: contentType, Filename: strings.TrimSpace(filename), SizeBytes: int64(len(payload))}, strings.Trim(expected, "\""), actor)
|
|
if errors.Is(err, metadata.ErrConflict) {
|
|
return nil, false, ErrAssetConflict
|
|
}
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
result, err := s.GetAsset(domain, address)
|
|
return result, a.UpdatedAtMS != previous.UpdatedAtMS, err
|
|
}
|