An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作
TypeScript agentic-aiai-agentknowledge-baselocal-firstmarkdownmcpmindmapnote-takingself-hostedsiyuanworkspace
: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.goindex 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.gonew file mode 100644index 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.gonew file mode 100644index 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")+ }+}