Skip to content

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

:bug: Serialize history replay with queued editing transactions https://github.com/siyuan-note/siyuan/issues/20933

Daniel98353ab648d4
diff --git a/kernel/api/contract_block_transaction_test.go b/kernel/api/contract_block_transaction_test.go
index 0f7ec5380a..941cc94a4f 100644
--- a/kernel/api/contract_block_transaction_test.go
+++ b/kernel/api/contract_block_transaction_test.go
@@ -156,6 +156,7 @@ func TestAPIContractHeadingTransactions(t *testing.T) {
testAPIContractMindmapMigration(t, engine, box.ID, docID)
testAPIContractListConversion(t, engine, docID)
testAPIContractTransactionCompletion(t, engine, docID, paragraphID)
+ testAPIContractHistoryQueueOrder(t, engine, docID, paragraphID)
for _, entry := range []struct {
path, id, scope string
code int
diff --git a/kernel/api/contract_transaction_completion_test.go b/kernel/api/contract_transaction_completion_test.go
index 5a2502444c..fedf901d0c 100644
--- a/kernel/api/contract_transaction_completion_test.go
+++ b/kernel/api/contract_transaction_completion_test.go
@@ -167,3 +167,50 @@ func testAPIContractTransactionCompletion(t *testing.T, engine *gin.Engine, docI
}
t.Logf("isolated editing request Server-Timing: %s", recorder.Header().Get("Server-Timing"))
}
+
+func testAPIContractHistoryQueueOrder(t *testing.T, engine *gin.Engine, docID, paragraphID string) {
+ t.Helper()
+ model.FlushTxQueue()
+ model.GlobalUndoLog.Clear("")
+ defer model.GlobalUndoLog.Clear("")
+ engine.POST("/api/transactions/undo", performUndo)
+ engine.POST("/api/transactions/redo", performRedo)
+ dom := func(content string) string {
+ return fmt.Sprintf(`<div data-node-id="%s" data-type="NodeParagraph"><div contenteditable="true">%s</div></div>`, paragraphID, content)
+ }
+ first := &model.Transaction{
+ DoOperations: []*model.Operation{{Action: "update", ID: paragraphID, Data: dom("First")}},
+ UndoOperations: []*model.Operation{{Action: "update", ID: paragraphID, Data: dom("Original")}},
+ }
+ first.MarkFromAPI()
+ if err := model.PerformTxSync(first); err != nil {
+ t.Fatal(err)
+ }
+ second := &model.Transaction{
+ DoOperations: []*model.Operation{{Action: "update", ID: paragraphID, Data: dom("Second")}},
+ UndoOperations: []*model.Operation{{Action: "update", ID: paragraphID, Data: dom("First")}},
+ }
+ second.MarkFromAPI()
+ queued := []*model.Transaction{second}
+ model.PerformTransactions(&queued)
+ for _, replay := range []struct{ action, want string }{{"undo", "First"}, {"redo", "Second"}} {
+ path := "/api/transactions/" + replay.action
+ recorder := httptest.NewRecorder()
+ engine.ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, path,
+ strings.NewReader(`{"rootID":"`+docID+`","app":"contract","session":"contract"}`)))
+ requireAPIContract(t, http.MethodPost, path, recorder)
+ var result struct {
+ Code int `json:"code"`
+ Data struct {
+ Failed bool `json:"failed"`
+ } `json:"data"`
+ }
+ if err := json.Unmarshal(recorder.Body.Bytes(), &result); err != nil || result.Code != 0 || result.Data.Failed {
+ t.Fatalf("history action failed: %s %v", recorder.Body.String(), err)
+ }
+ tree, err := model.LoadTreeByBlockID(paragraphID)
+ if err != nil || treenode.GetNodeInTree(tree, paragraphID).Text() != replay.want {
+ t.Fatalf("%s selected history before the queued edit: %v", replay.action, err)
+ }
+ }
+}
diff --git a/kernel/api/transaction.go b/kernel/api/transaction.go
index ba800e3328..47526fdd10 100644
--- a/kernel/api/transaction.go
+++ b/kernel/api/transaction.go
@@ -263,104 +263,110 @@ var undoState = contractHandler(apicontract.UndoState, func(c *gin.Context, requ
// 跨文档撤销:发起窗口无法本地乐观应用(锚点分散),广播含发起方(Broadcast)刷新其 DOM。
// 逆操作失败时回滚栈状态(UndoRollback)并返回 data.failed=true,前端镜像不动。
var performUndo = contractHandler(apicontract.PerformUndo, func(c *gin.Context, request apicontract.TransactionHistoryRequest) apicontract.Response[apicontract.TransactionHistoryResult] {
- entry := model.GlobalUndoLog.Undo(request.RootID)
- if nil == entry {
- // 栈空,无可撤销
- return apicontract.Success(apicontract.EmptyTransactionHistory())
- }
-
- tx := &model.Transaction{
- Timestamp: time.Now().UnixMilli(),
- DoOperations: entry.UndoOperationsForReplay(),
- UndoOperations: entry.DoOperationsForReplay(),
- }
- if err := holdBlockSwapReplayRequests(c, tx, entry.MutatedRootIDs()); err != nil {
- model.GlobalUndoLog.UndoRollback(entry, request.RootID)
- return apicontract.Success(apicontract.FailedTransactionHistory("undo failed: " + err.Error()))
- }
- tx.MarkReplay()
- // 重放前解决剪切后粘贴造成的块 ID 冲突(已存在的 ID 换新,避免重复)
- model.ResolveReplayDuplicateIds(tx)
+ return model.WithTransactionHistory(func(execute func(*model.Transaction) error) apicontract.Response[apicontract.TransactionHistoryResult] {
+ entry := model.GlobalUndoLog.Undo(request.RootID)
+ if nil == entry {
+ // 栈空,无可撤销
+ return apicontract.Success(apicontract.EmptyTransactionHistory())
+ }
- if err := model.PerformTxSync(tx); nil != err {
- // 逆操作执行失败,回滚执行栈。返回 code=0 + data.failed=true(而非 code=-1),
- // 否则前端 processMessage 拦截导致 fetchPost 回调不执行、isUndoing 永不复位。
- model.GlobalUndoLog.UndoRollback(entry, request.RootID)
- return apicontract.Success(apicontract.FailedTransactionHistory("undo failed: " + err.Error()))
- }
+ tx := &model.Transaction{
+ Timestamp: time.Now().UnixMilli(),
+ DoOperations: entry.UndoOperationsForReplay(),
+ UndoOperations: entry.DoOperationsForReplay(),
+ }
+ if err := holdBlockSwapReplayRequests(c, tx, entry.MutatedRootIDs()); err != nil {
+ model.GlobalUndoLog.UndoRollback(entry, request.RootID)
+ return apicontract.Success(apicontract.FailedTransactionHistory("undo failed: " + err.Error()))
+ }
+ tx.MarkReplay()
+ // 重放前解决剪切后粘贴造成的块 ID 冲突(已存在的 ID 换新,避免重复)
+ model.ResolveReplayDuplicateIds(tx)
+
+ if err := execute(tx); nil != err {
+ // 逆操作执行失败,回滚执行栈。返回 code=0 + data.failed=true(而非 code=-1),
+ // 否则前端 processMessage 拦截导致 fetchPost 回调不执行、isUndoing 永不复位。
+ model.GlobalUndoLog.UndoRollback(entry, request.RootID)
+ return apicontract.Success(apicontract.FailedTransactionHistory("undo failed: " + err.Error()))
+ }
- // 成功:联动从其他关联栈移除该 entry
- model.GlobalUndoLog.UndoCommit(entry, request.RootID)
+ // 成功:联动从其他关联栈移除该 entry
+ model.GlobalUndoLog.UndoCommit(entry, request.RootID)
- crossDoc := len(entry.MutatedRootIDs()) > 1
- pushUndoTransactions(request.App, request.Session, []*model.Transaction{tx}, true, crossDoc)
+ crossDoc := len(entry.MutatedRootIDs()) > 1
+ pushUndoTransactions(request.App, request.Session, []*model.Transaction{tx}, true, crossDoc)
- canUndo, canRedo, _ := model.GlobalUndoLog.State(request.RootID)
- // 返回重放后(已解决 ID 冲突)的 tx 操作,前端乐观应用与 kernel 落盘一致
- operations, err := transactionOperationContracts(tx.DoOperations)
- if err != nil {
- return apicontract.Failure[apicontract.TransactionHistoryResult](-1, err.Error())
- }
- undoOperations, err := transactionOperationContracts(tx.UndoOperations)
- if err != nil {
- return apicontract.Failure[apicontract.TransactionHistoryResult](-1, err.Error())
- }
- return apicontract.Success(apicontract.AppliedTransactionHistory(apicontract.TransactionHistoryApplied{
- DoOperations: operations, UndoOperations: undoOperations, MutatedRootIDs: entry.MutatedRootIDs(), CanUndo: canUndo, CanRedo: canRedo, IsUndo: true,
- }))
+ canUndo, canRedo, _ := model.GlobalUndoLog.State(request.RootID)
+ // 返回重放后(已解决 ID 冲突)的 tx 操作,前端乐观应用与 kernel 落盘一致
+ operations, err := transactionOperationContracts(tx.DoOperations)
+ if err != nil {
+ return apicontract.Failure[apicontract.TransactionHistoryResult](-1, err.Error())
+ }
+ undoOperations, err := transactionOperationContracts(tx.UndoOperations)
+ if err != nil {
+ return apicontract.Failure[apicontract.TransactionHistoryResult](-1, err.Error())
+ }
+ return apicontract.Success(apicontract.AppliedTransactionHistory(apicontract.TransactionHistoryApplied{
+ DoOperations: operations, UndoOperations: undoOperations, MutatedRootIDs: entry.MutatedRootIDs(), CanUndo: canUndo, CanRedo: canRedo, IsUndo: true,
+ }))
+ })
})
// performRedo 重做指定文档最近一次撤销的操作。
var performRedo = contractHandler(apicontract.PerformRedo, func(c *gin.Context, request apicontract.TransactionHistoryRequest) apicontract.Response[apicontract.TransactionHistoryResult] {
- entry := model.GlobalUndoLog.Redo(request.RootID)
- if nil == entry {
- return apicontract.Success(apicontract.EmptyTransactionHistory())
- }
-
- tx := &model.Transaction{
- Timestamp: time.Now().UnixMilli(),
- DoOperations: entry.DoOperationsForReplay(),
- UndoOperations: entry.UndoOperationsForReplay(),
- }
- if err := holdBlockSwapReplayRequests(c, tx, entry.MutatedRootIDs()); err != nil {
- model.GlobalUndoLog.RedoRollback(entry, request.RootID)
- return apicontract.Success(apicontract.FailedTransactionHistory("redo failed: " + err.Error()))
- }
- tx.MarkReplay()
- // 重放前解决剪切后粘贴造成的块 ID 冲突(已存在的 ID 换新,避免重复)
- model.ResolveReplayDuplicateIds(tx)
+ return model.WithTransactionHistory(func(execute func(*model.Transaction) error) apicontract.Response[apicontract.TransactionHistoryResult] {
+ entry := model.GlobalUndoLog.Redo(request.RootID)
+ if nil == entry {
+ return apicontract.Success(apicontract.EmptyTransactionHistory())
+ }
- if err := model.PerformTxSync(tx); nil != err {
- // 重做失败,回滚执行栈。返回 code=0 + data.failed=true(避免前端 isUndoing 死锁)。
- model.GlobalUndoLog.RedoRollback(entry, request.RootID)
- return apicontract.Success(apicontract.FailedTransactionHistory("redo failed: " + err.Error()))
- }
+ tx := &model.Transaction{
+ Timestamp: time.Now().UnixMilli(),
+ DoOperations: entry.DoOperationsForReplay(),
+ UndoOperations: entry.UndoOperationsForReplay(),
+ }
+ if err := holdBlockSwapReplayRequests(c, tx, entry.MutatedRootIDs()); err != nil {
+ model.GlobalUndoLog.RedoRollback(entry, request.RootID)
+ return apicontract.Success(apicontract.FailedTransactionHistory("redo failed: " + err.Error()))
+ }
+ tx.MarkReplay()
+ // 重放前解决剪切后粘贴造成的块 ID 冲突(已存在的 ID 换新,避免重复)
+ model.ResolveReplayDuplicateIds(tx)
+
+ if err := execute(tx); nil != err {
+ // 重做失败,回滚执行栈。返回 code=0 + data.failed=true(避免前端 isUndoing 死锁)。
+ model.GlobalUndoLog.RedoRollback(entry, request.RootID)
+ return apicontract.Success(apicontract.FailedTransactionHistory("redo failed: " + err.Error()))
+ }
- // 成功:联动把 entry 重新挂到其他关联栈
- model.GlobalUndoLog.RedoCommit(entry, request.RootID)
+ // 成功:联动把 entry 重新挂到其他关联栈
+ model.GlobalUndoLog.RedoCommit(entry, request.RootID)
- crossDoc := len(entry.MutatedRootIDs()) > 1
- pushUndoTransactions(request.App, request.Session, []*model.Transaction{tx}, true, crossDoc)
+ crossDoc := len(entry.MutatedRootIDs()) > 1
+ pushUndoTransactions(request.App, request.Session, []*model.Transaction{tx}, true, crossDoc)
- canUndo, canRedo, _ := model.GlobalUndoLog.State(request.RootID)
- // 返回重放后(已解决 ID 冲突)的 tx 操作,前端乐观应用与 kernel 落盘一致
- operations, err := transactionOperationContracts(tx.DoOperations)
- if err != nil {
- return apicontract.Failure[apicontract.TransactionHistoryResult](-1, err.Error())
- }
- undoOperations, err := transactionOperationContracts(tx.UndoOperations)
- if err != nil {
- return apicontract.Failure[apicontract.TransactionHistoryResult](-1, err.Error())
- }
- return apicontract.Success(apicontract.AppliedTransactionHistory(apicontract.TransactionHistoryApplied{
- DoOperations: operations, UndoOperations: undoOperations, MutatedRootIDs: entry.MutatedRootIDs(), CanUndo: canUndo, CanRedo: canRedo, IsUndo: false,
- }))
+ canUndo, canRedo, _ := model.GlobalUndoLog.State(request.RootID)
+ // 返回重放后(已解决 ID 冲突)的 tx 操作,前端乐观应用与 kernel 落盘一致
+ operations, err := transactionOperationContracts(tx.DoOperations)
+ if err != nil {
+ return apicontract.Failure[apicontract.TransactionHistoryResult](-1, err.Error())
+ }
+ undoOperations, err := transactionOperationContracts(tx.UndoOperations)
+ if err != nil {
+ return apicontract.Failure[apicontract.TransactionHistoryResult](-1, err.Error())
+ }
+ return apicontract.Success(apicontract.AppliedTransactionHistory(apicontract.TransactionHistoryApplied{
+ DoOperations: operations, UndoOperations: undoOperations, MutatedRootIDs: entry.MutatedRootIDs(), CanUndo: canUndo, CanRedo: canRedo, IsUndo: false,
+ }))
+ })
})
// clearHistory 清理撤销日志。rootID 非空时清该文档栈并联动移除其他栈相关条目;为空时清空全部。
var clearHistory = contractHandler(apicontract.ClearHistory, func(c *gin.Context, request apicontract.TransactionClearHistoryRequest) apicontract.Response[apicontract.Null] {
- model.GlobalUndoLog.Clear(request.RootID)
- return apicontract.Success(apicontract.Null{})
+ return model.WithTransactionHistory(func(_ func(*model.Transaction) error) apicontract.Response[apicontract.Null] {
+ model.GlobalUndoLog.Clear(request.RootID)
+ return apicontract.Success(apicontract.Null{})
+ })
})
// pushUndoTransactions 广播 undo/redo 重放事务。
diff --git a/kernel/model/transaction.go b/kernel/model/transaction.go
index b302b672a8..bd47371cf9 100644
--- a/kernel/model/transaction.go
+++ b/kernel/model/transaction.go
@@ -96,6 +96,26 @@ func PerformTxSync(tx *Transaction) (err error) {
return performTxSyncLocked(tx)
}
+// WithTransactionHistory drains already queued edits before selecting a history entry.
+// Selection, replay, stack finalization and its broadcast share the transaction execution lock.
+// The callback must use execute instead of re-entering PerformTxSync.
+func WithTransactionHistory[T any](action func(execute func(*Transaction) error) T) T {
+ flushLock.Lock()
+ isFlushing.Store(true)
+ defer func() {
+ isFlushing.Store(false)
+ flushLock.Unlock()
+ }()
+ for _, queued := range takeQueuedTransactions() {
+ flushTx(queued)
+ }
+ return action(func(tx *Transaction) error {
+ completion := tx.prepareCommitWait()
+ defer close(completion.done)
+ return performTxSyncLocked(tx)
+ })
+}
+
func performTxSyncLocked(tx *Transaction) (err error) {
// 初始化事务互斥锁(异步路径 PerformTransactions 在入队前初始化,同步路径这里补上)
if nil == tx.m {
diff --git a/kernel/model/transaction_history_order_fts5_test.go b/kernel/model/transaction_history_order_fts5_test.go
new file mode 100644
index 0000000000..86de0c473d
--- /dev/null
+++ b/kernel/model/transaction_history_order_fts5_test.go
@@ -0,0 +1,63 @@
+//go:build fts5
+
+package model
+
+import (
+ "fmt"
+ "testing"
+
+ "github.com/siyuan-note/siyuan/kernel/treenode"
+)
+
+func TestTransactionHistoryDrainsQueuedEditsBeforeSelection(t *testing.T) {
+ fixture := setupStructureTransactionTest(t)
+ setupFoldTransactionDatabase(t, fixture)
+ previousLog := GlobalUndoLog
+ GlobalUndoLog = newUndoLog(64)
+ t.Cleanup(func() { GlobalUndoLog = previousLog })
+ dom := func(text string) string {
+ return fmt.Sprintf(`<div data-node-id="%s" data-type="NodeParagraph"><div contenteditable="true">%s</div></div>`, fixture.childID, text)
+ }
+ first := &Transaction{fromAPI: true, DoOperations: []*Operation{{Action: "update", ID: fixture.childID, Data: dom("First")}},
+ UndoOperations: []*Operation{{Action: "update", ID: fixture.childID, Data: dom("")}}}
+ if err := PerformTxSync(first); err != nil {
+ t.Fatal(err)
+ }
+ second := &Transaction{fromAPI: true, DoOperations: []*Operation{{Action: "update", ID: fixture.childID, Data: dom("Second")}},
+ UndoOperations: []*Operation{{Action: "update", ID: fixture.childID, Data: dom("First")}}}
+ flushLock.Lock()
+ queued := []*Transaction{second}
+ PerformTransactions(&queued)
+ flushLock.Unlock()
+ WithTransactionHistory(func(execute func(*Transaction) error) bool {
+ entry := GlobalUndoLog.Undo(fixture.sourceID)
+ if entry == nil || entry.UndoOperationsForReplay()[0].Data != dom("First") {
+ t.Fatal("history selected an entry before the queued edit")
+ }
+ tx := &Transaction{isReplay: true, DoOperations: entry.UndoOperationsForReplay()}
+ if err := execute(tx); err != nil {
+ t.Fatal(err)
+ }
+ GlobalUndoLog.UndoCommit(entry, fixture.sourceID)
+ return true
+ })
+ tree, err := LoadTreeByBlockID(fixture.childID)
+ if err != nil || treenode.GetNodeInTree(tree, fixture.childID).Text() != "First" {
+ t.Fatalf("undo did not restore the state before the latest queued edit: %v", err)
+ }
+ WithTransactionHistory(func(execute func(*Transaction) error) bool {
+ entry := GlobalUndoLog.Redo(fixture.sourceID)
+ if entry == nil {
+ t.Fatal("queued edit lost its redo entry")
+ }
+ if err := execute(&Transaction{isReplay: true, DoOperations: entry.DoOperationsForReplay()}); err != nil {
+ t.Fatal(err)
+ }
+ GlobalUndoLog.RedoCommit(entry, fixture.sourceID)
+ return true
+ })
+ tree, err = LoadTreeByBlockID(fixture.childID)
+ if err != nil || treenode.GetNodeInTree(tree, fixture.childID).Text() != "Second" {
+ t.Fatalf("redo did not restore the queued edit: %v", err)
+ }
+}