Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

:bug: Roll back relocated documents when history cleanup fails https://github.com/siyuan-note/siyuan/issues/20950

Daniel706bb9c085b6
diff --git a/kernel/model/history.go b/kernel/model/history.go
index 790e37cfa0..06290bf9f0 100644
--- a/kernel/model/history.go
+++ b/kernel/model/history.go
@@ -44,7 +44,6 @@ import (
"github.com/siyuan-note/siyuan/kernel/av"
"github.com/siyuan-note/siyuan/kernel/cache"
"github.com/siyuan-note/siyuan/kernel/conf"
- "github.com/siyuan-note/siyuan/kernel/filesys"
"github.com/siyuan-note/siyuan/kernel/search"
"github.com/siyuan-note/siyuan/kernel/sql"
"github.com/siyuan-note/siyuan/kernel/task"
@@ -278,6 +277,10 @@ func GetDocHistoryContent(historyPath, keyword string, highlight bool) (id, root
}
func RollbackDocHistory(historyPath string) (err error) {
+ return rollbackDocHistory(historyPath, removeIndexRepairSourceIfUnchanged)
+}
+
+func rollbackDocHistory(historyPath string, removeOldDoc func(string, []byte) error) (err error) {
historyPath, err = validateHistoryPath(historyPath)
if err != nil {
return
@@ -470,7 +473,7 @@ func RollbackDocHistory(historyPath string) (err error) {
return
}
}
- if _, err = filesys.WriteTree(tree); err != nil {
+ if err = writeHistoryDocument(tree, workingDoc, removeOldDoc); err != nil {
return
}
invalidateDocumentHistory(tree.ID)
@@ -478,11 +481,6 @@ func RollbackDocHistory(historyPath string) (err error) {
invalidateDocumentHistory(workingDoc.RootID)
}
if workingDoc != nil {
- if workingDoc.Type == "d" && workingDoc.Path != tree.Path {
- if err = filelock.Remove(filepath.Join(util.DataDir, boxID, workingDoc.Path)); err != nil {
- return
- }
- }
treenode.RemoveBlockTreesByRootID(boxID, rootID)
}
sql.RemoveTreeQueue(boxID, rootID)
diff --git a/kernel/model/history_document.go b/kernel/model/history_document.go
new file mode 100644
index 0000000000..eada846caf
--- /dev/null
+++ b/kernel/model/history_document.go
@@ -0,0 +1,84 @@
+package model
+
+import (
+ "bytes"
+ "errors"
+ "os"
+ "path/filepath"
+
+ "github.com/88250/lute/parse"
+ "github.com/siyuan-note/filelock"
+ "github.com/siyuan-note/siyuan/kernel/cache"
+ "github.com/siyuan-note/siyuan/kernel/filesys"
+ "github.com/siyuan-note/siyuan/kernel/sql"
+ "github.com/siyuan-note/siyuan/kernel/treenode"
+ "github.com/siyuan-note/siyuan/kernel/util"
+)
+
+// A relocated restore commits only after the previous source has been removed.
+// On failure, restore the target's authenticated before-image and original index
+// before the caller rolls back the database mutation and releases its leases.
+func writeHistoryDocument(tree *parse.Tree, workingDoc *treenode.BlockTree, removeOldDoc func(string, []byte) error) error {
+ if workingDoc == nil || workingDoc.Type != "d" || workingDoc.BoxID != tree.Box || workingDoc.Path == tree.Path {
+ _, err := filesys.WriteTree(tree)
+ return err
+ }
+ _, originalSource, err := filesys.LoadTreeSnapshot(tree.Box, workingDoc.Path, util.NewLute())
+ if err != nil {
+ return err
+ }
+ _, before, err := filesys.LoadTreeSnapshot(tree.Box, tree.Path, util.NewLute())
+ if os.IsNotExist(err) {
+ before, err = nil, nil
+ }
+ if err != nil {
+ return err
+ }
+ var written []byte
+ err = filesys.RecordTreeWrites(tree, before, func(data []byte) error {
+ written = bytes.Clone(data)
+ return nil
+ }, func() error {
+ _, writeErr := filesys.WriteTree(tree)
+ return writeErr
+ })
+ if err == nil {
+ err = removeOldDoc(filepath.Join(util.DataDir, tree.Box, workingDoc.Path), originalSource)
+ }
+ if err == nil {
+ return nil
+ }
+ var rollbackErr error
+ if written != nil {
+ filename := filepath.Join(util.DataDir, tree.Box, tree.Path)
+ current, readErr := filelock.ReadFile(filename)
+ if os.IsNotExist(readErr) {
+ current, readErr = nil, nil
+ }
+ rollbackErr = readErr
+ if readErr == nil && !bytes.Equal(current, before) {
+ if before == nil {
+ rollbackErr = removeIndexRepairSourceIfUnchanged(filename, written)
+ } else {
+ rollbackErr = util.WriteFileIfUnchanged(filename, written, before)
+ }
+ }
+ }
+ cache.RemoveTreeDataInBox(tree.ID, tree.Box)
+ cache.RemoveDocIALInBox(tree.Path, tree.Box)
+ if rollbackErr == nil {
+ originalTree, _, readErr := filesys.LoadTreeSnapshot(tree.Box, workingDoc.Path, util.NewLute())
+ rollbackErr = readErr
+ if readErr == nil {
+ rollbackErr = treenode.ReplaceBlockTree(originalTree)
+ if rollbackErr == nil {
+ rollbackErr = treenode.FinishDocumentMetadataRecovery(tree.Box, tree.ID, tree.ID != originalTree.ID && before == nil)
+ }
+ sql.UpsertTreeQueue(originalTree)
+ }
+ }
+ if rollbackErr != nil {
+ util.MarkIndexFixDirty()
+ }
+ return errors.Join(err, rollbackErr)
+}
diff --git a/kernel/model/history_document_fts5_test.go b/kernel/model/history_document_fts5_test.go
new file mode 100644
index 0000000000..98e67df8d4
--- /dev/null
+++ b/kernel/model/history_document_fts5_test.go
@@ -0,0 +1,240 @@
+//go:build fts5 && sqlcipher
+
+package model
+
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+ "os"
+ "path/filepath"
+ "testing"
+
+ "github.com/88250/lute/ast"
+ "github.com/88250/lute/parse"
+ "github.com/siyuan-note/siyuan/kernel/av"
+ "github.com/siyuan-note/siyuan/kernel/cache"
+ "github.com/siyuan-note/siyuan/kernel/conf"
+ "github.com/siyuan-note/siyuan/kernel/filesys"
+ "github.com/siyuan-note/siyuan/kernel/sql"
+ "github.com/siyuan-note/siyuan/kernel/treenode"
+ "github.com/siyuan-note/siyuan/kernel/util"
+)
+
+func TestHistoryDocumentRelocationFailureRollsBack(t *testing.T) {
+ for _, encrypted := range []bool{false, true} {
+ t.Run(map[bool]string{false: "plain", true: "encrypted"}[encrypted], func(t *testing.T) {
+ fixture, historicalAV, _ := setupAttributeViewDeletedBlockTest(t, "container")
+ boxID, avBoxID := fixture.box.ID, ""
+ if encrypted {
+ var trees []*parse.Tree
+ for _, id := range []string{fixture.sourceID, fixture.targetID} {
+ tree, err := LoadTreeByBlockID(id)
+ if err != nil {
+ t.Fatal(err)
+ }
+ trees = append(trees, tree)
+ treenode.RemoveBlockTreesByRootID(boxID, id)
+ }
+ dek := bytes.Repeat([]byte{0x75}, 32)
+ prepareUnlockedEncryptedBoxTest(t, boxID, dek)
+ encryptDocumentTestSources(t, dek, trees...)
+ boxConf := conf.NewBoxConf()
+ boxConf.Encrypted = true
+ boxConf.BoxCrypt = &conf.BoxEncryption{Spec: boxEncryptionSpec}
+ if err := encryptBoxMetadata(boxID, boxConf, dek); err != nil {
+ t.Fatal(err)
+ }
+ data, err := json.Marshal(boxConf)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err = os.WriteFile(filepath.Join(util.DataDir, boxID, ".siyuan", "conf.json"), data, 0600); err != nil {
+ t.Fatal(err)
+ }
+ mountedEncryptedBoxes.Store(boxID, true)
+ if err = treenode.OpenEncryptedBlockTreeDB(boxID, dek); err != nil {
+ t.Fatal(err)
+ }
+ if err = sql.OpenEncryptedDB(boxID, dek); err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() {
+ sql.CloseEncryptedDB(boxID)
+ treenode.CloseEncryptedBlockTreeDB(boxID)
+ mountedEncryptedBoxes.Delete(boxID)
+ av.SetAVBoxID(historicalAV.ID, "")
+ })
+ for _, tree := range trees {
+ treenode.UpsertBlockTree(tree)
+ }
+ avBoxID = boxID
+ av.SetAVBoxID(historicalAV.ID, boxID)
+ if err = av.SaveAttributeView(historicalAV); err != nil {
+ t.Fatal(err)
+ }
+ if err = os.Remove(boundAttributeViewHistoryPath(util.DataDir, "", historicalAV.ID)); err != nil {
+ t.Fatal(err)
+ }
+ }
+ tree, err := LoadTreeByBlockID(fixture.sourceID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ originalPath := filepath.Join(util.DataDir, boxID, tree.Path)
+ if err = os.Remove(originalPath); err != nil {
+ t.Fatal(err)
+ }
+ // A missing parent index is an existing supported root-level recovery path.
+ parentID := ast.NewNodeID()
+ parent := treenode.NewTree(boxID, "/"+parentID+".sy", "/Parent", "Parent")
+ if _, err = filesys.WriteTree(parent); err != nil {
+ t.Fatal(err)
+ }
+ treenode.RemoveBlockTreesByRootID(boxID, parentID)
+ tree.Path = "/" + parentID + "/" + tree.ID + ".sy"
+ node := &ast.Node{Type: ast.NodeAttributeView, ID: ast.NewNodeID(), AttributeViewID: historicalAV.ID}
+ node.SetIALAttr("id", node.ID)
+ tree.Root.AppendChild(node)
+ cache.RemoveTreeDataInBox(tree.ID, boxID)
+ if _, err = filesys.WriteTree(tree); err != nil {
+ t.Fatal(err)
+ }
+ treenode.UpsertBlockTree(tree)
+ oldPath := filepath.Join(util.DataDir, boxID, tree.Path)
+ snapshot, err := os.ReadFile(oldPath)
+ if err != nil {
+ t.Fatal(err)
+ }
+ originalWorkspace := util.WorkspaceDir
+ util.WorkspaceDir = filepath.Dir(util.HistoryDir)
+ t.Cleanup(func() { util.WorkspaceDir = originalWorkspace })
+ historyRoot := filepath.Join(util.HistoryDir, "2026-10-26-120000-update")
+ historyPath := filepath.Join(historyRoot, boxID, tree.ID+".sy")
+ for filename, source := range map[string]string{historyPath: oldPath, boundAttributeViewHistoryPath(historyRoot, avBoxID, historicalAV.ID): boundAttributeViewHistoryPath(util.DataDir, avBoxID, historicalAV.ID)} {
+ data, err := os.ReadFile(source)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err = os.MkdirAll(filepath.Dir(filename), 0755); err != nil {
+ t.Fatal(err)
+ }
+ if err = os.WriteFile(filename, data, 0600); err != nil {
+ t.Fatal(err)
+ }
+ }
+ tree.Root.SetIALAttr("title", "Current document")
+ if _, err = filesys.WriteTree(tree); err != nil {
+ t.Fatal(err)
+ }
+ treenode.UpsertBlockTree(tree)
+ currentSource, err := os.ReadFile(oldPath)
+ if err != nil {
+ t.Fatal(err)
+ }
+ currentAV, err := cloneAttributeViewForFieldMutation(historicalAV)
+ if err != nil {
+ t.Fatal(err)
+ }
+ currentAV.Name = "Current database"
+ if err = av.SaveAttributeView(currentAV); err != nil {
+ t.Fatal(err)
+ }
+ readAV := func() *av.AttributeView {
+ view, err := av.ParseAttributeViewForIndexInBox(historicalAV.ID, avBoxID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return view
+ }
+ seedDocumentHistory(t, fixture.sourceID, fixture.targetID)
+ relative, err := filepath.Rel(util.WorkspaceDir, historyPath)
+ if err != nil {
+ t.Fatal(err)
+ }
+ failure := errors.New("injected old document removal failure")
+ observed := false
+ err = rollbackDocHistory(relative, func(filename string, original []byte) error {
+ observed = true
+ if filename != oldPath || !bytes.Equal(original, currentSource) {
+ t.Fatal("wrong cleanup source")
+ }
+ if _, err := os.Stat(originalPath); err != nil {
+ t.Fatal("restore did not publish the new document before cleanup")
+ }
+ assertAttributeViewFieldsTest(t, historicalAV, readAV())
+ return failure
+ })
+ if !observed || !errors.Is(err, failure) {
+ t.Fatalf("restore did not reach the injected failure: %v", err)
+ }
+ if _, err = os.Stat(originalPath); !os.IsNotExist(err) {
+ t.Fatal("failed restoration retained the newly written document")
+ }
+ if data, err := os.ReadFile(oldPath); err != nil || !bytes.Equal(data, currentSource) {
+ t.Fatal("failed restoration changed the original document")
+ }
+ if bt := treenode.GetBlockTreeInBox(tree.ID, boxID); bt == nil || bt.Path != tree.Path {
+ t.Fatal("failed restoration retained the new metadata path")
+ }
+ assertAttributeViewFieldsTest(t, currentAV, readAV())
+ if undo, redo, _ := GlobalUndoLog.State(tree.ID); !undo || !redo {
+ t.Fatal("failed restoration discarded current undo history")
+ }
+ if data, err := os.ReadFile(historyPath); err != nil || !bytes.Equal(data, snapshot) {
+ t.Fatal("failed restoration changed history")
+ }
+ if err = RollbackDocHistory(relative); err != nil {
+ t.Fatalf("restoration could not be retried: %v", err)
+ }
+ sql.FlushQueue()
+ if _, err = os.Stat(oldPath); !os.IsNotExist(err) {
+ t.Fatal("successful retry retained the old path")
+ }
+ assertAttributeViewFieldsTest(t, historicalAV, readAV())
+ requireDocumentHistoryCleared(t, fixture.sourceID, fixture.targetID)
+ if data, err := os.ReadFile(originalPath); err != nil || encrypted && !util.IsCiphertext(data) {
+ t.Fatal("restored document is missing or exposed as plaintext")
+ }
+ })
+ }
+}
+
+func TestHistoryDocumentRestoresExistingDestination(t *testing.T) {
+ fixture := setupStructureTransactionTest(t)
+ setupFoldTransactionDatabase(t, fixture)
+ tree, err := LoadTreeByBlockID(fixture.sourceID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ destination := filepath.Join(util.DataDir, tree.Box, tree.Path)
+ before, err := os.ReadFile(destination)
+ if err != nil {
+ t.Fatal(err)
+ }
+ parentID := ast.NewNodeID()
+ parent := treenode.NewTree(tree.Box, "/"+parentID+".sy", "/Parent", "Parent")
+ if _, err = filesys.WriteTree(parent); err != nil {
+ t.Fatal(err)
+ }
+ oldPath := "/" + parentID + "/" + tree.ID + ".sy"
+ tree.Path = oldPath
+ tree.Root.SetIALAttr("title", "Current source")
+ if _, err = filesys.WriteTree(tree); err != nil {
+ t.Fatal(err)
+ }
+ treenode.UpsertBlockTree(tree)
+ workingDoc := treenode.GetBlockTree(tree.ID)
+ tree.Path = fixture.sourcePath
+ tree.Root.SetIALAttr("title", "Historical source")
+ failure := errors.New("injected relocation cleanup failure")
+ if err = writeHistoryDocument(tree, workingDoc, func(string, []byte) error { return failure }); !errors.Is(err, failure) {
+ t.Fatalf("cleanup error was not returned: %v", err)
+ }
+ if data, err := os.ReadFile(destination); err != nil || !bytes.Equal(data, before) {
+ t.Fatal("rollback did not preserve the previous destination")
+ }
+ if bt := treenode.GetBlockTree(tree.ID); bt == nil || bt.Path != oldPath {
+ t.Fatal("rollback did not restore the original source index")
+ }
+}