411 lines
12 KiB
Go
411 lines
12 KiB
Go
package store
|
|
|
|
import (
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
var (
|
|
ErrPathNotFound = errors.New("semantic path does not exist")
|
|
ErrPathConflict = errors.New("destination semantic path already exists")
|
|
)
|
|
|
|
type pathRename struct {
|
|
OldPath string
|
|
NewPath string
|
|
ObjectUUID string
|
|
CreatedAt int64
|
|
IsPrimary int
|
|
}
|
|
|
|
func (s *Store) RenamePath(oldPath, newPath string) error {
|
|
domainUUID, err := s.defaultDomainUUID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = s.RenamePathsInDomain(domainUUID, oldPath, newPath, false)
|
|
return err
|
|
}
|
|
|
|
func (s *Store) RenamePathInDomain(domainUUID, oldPath, newPath string) error {
|
|
_, err := s.RenamePathsInDomain(domainUUID, oldPath, newPath, false)
|
|
return err
|
|
}
|
|
|
|
// RenamePathsInDomain performs rename as an atomic link/unlink operation.
|
|
// Page identity and Revision history remain stable while Path reachability
|
|
// changes. When a file-like basename changes, a new immutable Revision records
|
|
// the corresponding filename metadata.
|
|
func (s *Store) RenamePathsInDomain(
|
|
domainUUID, oldPath, newPath string,
|
|
recursive bool,
|
|
) (int, error) {
|
|
return s.renamePathsInDomain(domainUUID, oldPath, newPath, recursive, nil)
|
|
}
|
|
|
|
// RenamePathsInDomainChecked requires the exact store snapshot authorized by
|
|
// the caller. Trusted local tools can use RenamePathsInDomain without grants.
|
|
func (s *Store) RenamePathsInDomainChecked(domainUUID, oldPath, newPath string, recursive bool, snapshot *PathMutationSnapshot) (int, error) {
|
|
if snapshot == nil {
|
|
return 0, ErrPathSnapshotChanged
|
|
}
|
|
count, err := s.renamePathsInDomain(domainUUID, oldPath, newPath, recursive, snapshot)
|
|
return count, pathMutationTransactionError(err)
|
|
}
|
|
|
|
func (s *Store) renamePathsInDomain(domainUUID, oldPath, newPath string, recursive bool, snapshot *PathMutationSnapshot) (_ int, resultErr error) {
|
|
defer func() { resultErr = s.cityMutationError("rename paths", resultErr) }()
|
|
if err := s.ensureLocalDomain(domainUUID); err != nil {
|
|
return 0, err
|
|
}
|
|
oldPath = normalizePath(oldPath)
|
|
newPath = normalizePath(newPath)
|
|
if oldPath == "/" || newPath == "/" || oldPath == newPath {
|
|
return 0, ErrPathConflict
|
|
}
|
|
if recursive && strings.HasPrefix(newPath+"/", oldPath+"/") {
|
|
return 0, ErrPathConflict
|
|
}
|
|
|
|
tx, cancel, err := s.beginPathMutation(domainUUID)
|
|
defer cancel()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer tx.Rollback()
|
|
|
|
renames, err := s.listMutationPaths(tx, domainUUID, oldPath, recursive)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if snapshot != nil {
|
|
if err := snapshot.validate(domainUUID, oldPath, recursive, renames); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
if len(renames) == 0 {
|
|
return 0, ErrPathNotFound
|
|
}
|
|
for i := range renames {
|
|
renames[i].NewPath = newPath + strings.TrimPrefix(renames[i].OldPath, oldPath)
|
|
}
|
|
|
|
sourcePaths := make(map[string]bool, len(renames))
|
|
for _, item := range renames {
|
|
sourcePaths[item.OldPath] = true
|
|
}
|
|
for _, item := range renames {
|
|
var exists int
|
|
if err := tx.QueryRow(`
|
|
SELECT COUNT(*) FROM paths
|
|
WHERE domain_uuid = `+s.sqlParam(1)+` AND path = `+s.sqlParam(2)+`
|
|
`, domainUUID, item.NewPath).Scan(&exists); err != nil {
|
|
return 0, err
|
|
}
|
|
if exists > 0 && !sourcePaths[item.NewPath] {
|
|
return 0, ErrPathConflict
|
|
}
|
|
}
|
|
|
|
// Link all destinations before unlinking sources. Temporary source rows
|
|
// remain valid until the transaction commits.
|
|
for _, item := range renames {
|
|
if _, err := tx.Exec(`
|
|
INSERT INTO paths (
|
|
domain_uuid, path, object_uuid, created_at, is_primary
|
|
) VALUES (`+s.sqlValues(5)+`)
|
|
`, domainUUID, item.NewPath, item.ObjectUUID, item.CreatedAt, item.IsPrimary); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
if err := s.renameUserSpacePathPoliciesTx(tx, domainUUID, oldPath, newPath, recursive); err != nil {
|
|
return 0, err
|
|
}
|
|
for _, item := range renames {
|
|
if _, err := tx.Exec(`
|
|
DELETE FROM paths WHERE domain_uuid = `+s.sqlParam(1)+` AND path = `+s.sqlParam(2)+`
|
|
`, domainUUID, item.OldPath); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
if err := s.renameBrowserNavigationPathsTx(tx, domainUUID, oldPath, newPath, recursive); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
renamedObjects := map[string][2]string{}
|
|
for _, item := range renames {
|
|
oldName := filepath.Base(item.OldPath)
|
|
newName := filepath.Base(item.NewPath)
|
|
if oldName != newName && filepath.Ext(oldName) != "" {
|
|
renamedObjects[item.ObjectUUID] = [2]string{oldName, newName}
|
|
}
|
|
}
|
|
for objectUUID, names := range renamedObjects {
|
|
if err := s.cloneLatestRevisionFilenames(
|
|
tx,
|
|
domainUUID,
|
|
objectUUID,
|
|
names[0],
|
|
names[1],
|
|
); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
if recursive {
|
|
changed, err := s.renameCityPathPrefixesTx(tx, domainUUID, oldPath, newPath)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if changed > 0 {
|
|
if err := s.bumpTopologyVersion(tx, domainUUID, "system:path-rename", "city.paths.renamed", "path", oldPath); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
operationID := uuid.NewString()
|
|
payload, err := json.Marshal(map[string]any{
|
|
"operation_uuid": operationID, "old_path": oldPath, "new_path": newPath,
|
|
"recursive": recursive, "count": len(renames),
|
|
})
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if err := s.appendActivityOutboxIfAvailable(tx, ActivityOutboxEvent{
|
|
DomainUUID: domainUUID, EventType: "path.renamed", TargetKind: "path",
|
|
Payload: string(payload), IdempotencyKey: "path.renamed:" + operationID,
|
|
}); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return 0, err
|
|
}
|
|
s.InvalidatePathCaches()
|
|
return len(renames), nil
|
|
}
|
|
|
|
func cloneLatestRevisionFilenames(
|
|
tx *sql.Tx,
|
|
objectUUID, oldName, newName string,
|
|
) error {
|
|
rows, err := tx.Query(`
|
|
WITH ranked AS (
|
|
SELECT
|
|
uuid, object_uuid, body, document_hash, lang, content_type,
|
|
filename, message, created_at_ms, created_at,
|
|
ROW_NUMBER() OVER (
|
|
PARTITION BY COALESCE(NULLIF(lang, ''), 'und')
|
|
ORDER BY COALESCE(created_at_ms, created_at * 1000) DESC, rowid DESC
|
|
) AS rn
|
|
FROM revisions
|
|
WHERE object_uuid = ?
|
|
)
|
|
SELECT
|
|
COALESCE(body, ''), COALESCE(document_hash, ''),
|
|
COALESCE(NULLIF(lang, ''), 'und'),
|
|
COALESCE(NULLIF(content_type, ''), 'application/octet-stream'),
|
|
COALESCE(filename, ''), COALESCE(message, '')
|
|
FROM ranked WHERE rn = 1
|
|
`, objectUUID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
type latestRevision struct {
|
|
body, hash, lang, contentType, filename, message string
|
|
}
|
|
var revisions []latestRevision
|
|
for rows.Next() {
|
|
var revision latestRevision
|
|
if err := rows.Scan(
|
|
&revision.body,
|
|
&revision.hash,
|
|
&revision.lang,
|
|
&revision.contentType,
|
|
&revision.filename,
|
|
&revision.message,
|
|
); err != nil {
|
|
rows.Close()
|
|
return err
|
|
}
|
|
if revision.filename == "" || revision.filename == oldName {
|
|
revisions = append(revisions, revision)
|
|
}
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
rows.Close()
|
|
return err
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return err
|
|
}
|
|
now := time.Now()
|
|
for index, revision := range revisions {
|
|
createdAtMS := now.UnixMilli() + int64(index)
|
|
if _, err := tx.Exec(`
|
|
INSERT INTO revisions (
|
|
uuid, object_uuid, body, document_hash, lang, content_type,
|
|
filename, message, created_at_ms, created_at
|
|
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`,
|
|
uuid.NewString(),
|
|
objectUUID,
|
|
revision.body,
|
|
revision.hash,
|
|
revision.lang,
|
|
revision.contentType,
|
|
newName,
|
|
"rename filename: "+oldName+" -> "+newName,
|
|
createdAtMS,
|
|
createdAtMS/1000,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Store) RemovePath(path string) error {
|
|
domainUUID, err := s.defaultDomainUUID()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.RemovePathInDomain(domainUUID, path)
|
|
}
|
|
|
|
func (s *Store) RemovePathInDomain(domainUUID, path string) (resultErr error) {
|
|
defer func() { resultErr = s.sqlError("remove path", resultErr) }()
|
|
if err := s.ensureLocalDomain(domainUUID); err != nil {
|
|
return err
|
|
}
|
|
tx, cancel, err := s.beginPathMutation(domainUUID)
|
|
defer cancel()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
_, err = tx.Exec(`
|
|
DELETE FROM paths WHERE domain_uuid = `+s.sqlParam(1)+` AND path = `+s.sqlParam(2)+`
|
|
`, domainUUID, normalizePath(path))
|
|
if err == nil {
|
|
err = tx.Commit()
|
|
}
|
|
if err == nil {
|
|
s.InvalidatePathCaches()
|
|
}
|
|
return err
|
|
}
|
|
|
|
// CopyPathsInDomain duplicates a Page or a virtual-folder subtree. Document
|
|
// blobs remain content-addressed and are reused, while Object and Revision
|
|
// identities are newly allocated so later edits do not affect the source.
|
|
func (s *Store) CopyPathsInDomain(
|
|
domainUUID, sourcePath, destinationPath string,
|
|
recursive bool,
|
|
) (int, error) {
|
|
return s.copyPathsInDomain(domainUUID, sourcePath, destinationPath, recursive, nil)
|
|
}
|
|
|
|
func (s *Store) CopyPathsInDomainChecked(domainUUID, sourcePath, destinationPath string, recursive bool, snapshot *PathMutationSnapshot) (int, error) {
|
|
if snapshot == nil {
|
|
return 0, ErrPathSnapshotChanged
|
|
}
|
|
count, err := s.copyPathsInDomain(domainUUID, sourcePath, destinationPath, recursive, snapshot)
|
|
return count, pathMutationTransactionError(err)
|
|
}
|
|
|
|
func (s *Store) copyPathsInDomain(domainUUID, sourcePath, destinationPath string, recursive bool, snapshot *PathMutationSnapshot) (_ int, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("copy paths", resultErr) }()
|
|
if err := s.ensureLocalDomain(domainUUID); err != nil {
|
|
return 0, err
|
|
}
|
|
sourcePath = normalizePath(sourcePath)
|
|
destinationPath = normalizePath(destinationPath)
|
|
if sourcePath == "/" || destinationPath == "/" || sourcePath == destinationPath {
|
|
return 0, ErrPathConflict
|
|
}
|
|
if recursive && strings.HasPrefix(destinationPath+"/", sourcePath+"/") {
|
|
return 0, ErrPathConflict
|
|
}
|
|
tx, cancel, err := s.beginPathMutation(domainUUID)
|
|
defer cancel()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer tx.Rollback()
|
|
paths, err := s.listMutationPaths(tx, domainUUID, sourcePath, recursive)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if snapshot != nil {
|
|
if err := snapshot.validate(domainUUID, sourcePath, recursive, paths); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
if len(paths) == 0 {
|
|
return 0, ErrPathNotFound
|
|
}
|
|
for i := range paths {
|
|
paths[i].NewPath = destinationPath + strings.TrimPrefix(paths[i].OldPath, sourcePath)
|
|
}
|
|
for _, item := range paths {
|
|
var exists int
|
|
if err := tx.QueryRow(`SELECT COUNT(*) FROM paths WHERE domain_uuid=`+s.sqlParam(1)+` AND path=`+s.sqlParam(2),
|
|
domainUUID, item.NewPath).Scan(&exists); err != nil {
|
|
return 0, err
|
|
}
|
|
if exists != 0 {
|
|
return 0, ErrPathConflict
|
|
}
|
|
}
|
|
objectCopies := map[string]string{}
|
|
for _, item := range paths {
|
|
newObjectUUID := objectCopies[item.ObjectUUID]
|
|
if newObjectUUID == "" {
|
|
newObjectUUID = uuid.NewString()
|
|
objectCopies[item.ObjectUUID] = newObjectUUID
|
|
if _, err := tx.Exec(`
|
|
INSERT INTO objects (uuid, kind, created_at)
|
|
SELECT `+s.sqlParam(1)+`, kind, `+s.sqlParam(2)+` FROM objects WHERE uuid=`+s.sqlParam(3),
|
|
newObjectUUID, time.Now().Unix(), item.ObjectUUID); err != nil {
|
|
return 0, err
|
|
}
|
|
if s.sqlBackend == storePostgreSQL {
|
|
if err := s.copyNativeRevisionsTx(tx, domainUUID, item.ObjectUUID, newObjectUUID, item.NewPath); err != nil {
|
|
return 0, err
|
|
}
|
|
} else if _, err := tx.Exec(`
|
|
INSERT INTO revisions (
|
|
uuid, object_uuid, body, document_hash, lang, content_type,
|
|
filename, message, created_at_ms, created_at
|
|
)
|
|
SELECT lower(hex(randomblob(4))) || '-' || lower(hex(randomblob(2))) || '-4' ||
|
|
substr(lower(hex(randomblob(2))),2) || '-' ||
|
|
substr('89ab',abs(random()) % 4 + 1,1) ||
|
|
substr(lower(hex(randomblob(2))),2) || '-' || lower(hex(randomblob(6))),
|
|
?, body, document_hash, lang, content_type, filename,
|
|
message, created_at_ms, created_at
|
|
FROM revisions WHERE object_uuid=?`,
|
|
newObjectUUID, item.ObjectUUID); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
if _, err := tx.Exec(`
|
|
INSERT INTO paths(domain_uuid,path,object_uuid,created_at,is_primary)
|
|
VALUES(`+s.sqlValues(5)+`)`,
|
|
domainUUID, item.NewPath, newObjectUUID, time.Now().Unix(), item.IsPrimary); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
if err := tx.Commit(); err != nil {
|
|
return 0, err
|
|
}
|
|
s.InvalidatePathCaches()
|
|
return len(paths), nil
|
|
}
|