修复已核验回滚事务终态并同步整改进度

This commit is contained in:
xuans committed 2026-10-01 10:46:30 +08:00
1 parent c96cd434a4
commit 8899f7af9e
5 files changed
+181 -6

No files matched your search

+4 -3
View File
@@ -457,10 +457,11 @@ func (s *Service) deployOne(ctx context.Context, server Server, artifact Artifac
closed = true
}
status := TransactionStatusCommitted
if retain || result.Status != "success" {
status = TransactionStatusRecoveryRequired
} else if result.Message != "" && result.Status == "failed" {
if !retain && result.Status == "failed" && result.FailureCode == FailureRecoveryPending {
status = TransactionStatusRolledBack
result.Message = publicFailureMessages[FailureRecoveryRestored]
} else if retain || result.Status != "success" {
status = TransactionStatusRecoveryRequired
}
finishTransaction(status, result.Message)
return result
@@ -0,0 +1,122 @@
package deployment
import (
"context"
"errors"
"testing"
)
type failedUnlockClient struct{ *memoryClient }
func (c *failedUnlockClient) Unlock(context.Context, string) error {
return errors.New("unlock failed")
}
func TestVerifiedRollbackJournalRetainsFailedFinalization(t *testing.T) {
for _, scenario := range []struct {
name string
configure func(*memoryClient) Client
wantCode FailureCode
}{
{"unlock", func(c *memoryClient) Client { return &failedUnlockClient{c} }, FailureLockRelease},
{"restore", func(c *memoryClient) Client { c.restoreError = true; return c }, FailureRollback},
} {
t.Run(scenario.name, func(t *testing.T) {
client, server := newMemoryClient(), testServer("failed-finalization")
seedVerifiedFiles(client, server)
journal := &memoryTransactionJournal{}
service := NewServiceWithJournal(fixedClientFactory{scenario.configure(client)}, journal)
ctx := WithTransactionContext(t.Context(), TransactionContext{TaskID: "task", AttemptID: "attempt", AttemptNumber: 1})
report, err := service.DeployVerified(ctx, []Target{{Server: server}}, testArtifact(t), Verification{
Verify: func(context.Context) error { return errors.New("verification failed") },
VerifyRecovery: func(context.Context) error { return nil },
})
if err == nil || report.RecoveryStatus != "failed" || report.Results[0].FailureCode != scenario.wantCode {
t.Fatalf("unexpected failure report: %+v, %v", report, err)
}
if len(journal.finished) != 1 || journal.finished[0].status != TransactionStatusRecoveryRequired {
t.Fatalf("failed finalization must retain recovery state: %+v", journal.finished)
}
assertVerifiedLocks(t, client, server, true)
})
}
}
func TestVerifiedPartialFailurePersistsRolledBackTarget(t *testing.T) {
client, first := newMemoryClient(), testServer("first")
second := testServer("second")
original := seedVerifiedFiles(client, first)
journal := &memoryTransactionJournal{}
service := NewServiceWithJournal(memoryFactory{
clients: map[string]*memoryClient{first.ID: client},
errors: map[string]error{second.ID: errors.New("connection failed")},
}, journal)
ctx := WithTransactionContext(t.Context(), TransactionContext{TaskID: "task", AttemptID: "attempt", AttemptNumber: 1})
report, err := service.DeployVerified(ctx, []Target{{Server: first}, {Server: second}}, testArtifact(t), Verification{
Verify: func(context.Context) error { t.Fatal("partial preparation must not verify deployment"); return nil },
VerifyRecovery: func(context.Context) error { assertVerifiedFiles(t, client, original); return nil },
})
if err == nil || report.Status != "failed" || report.RecoveryStatus != "success" {
t.Fatalf("unexpected partial failure report: %+v, %v", report, err)
}
if len(journal.finished) != 1 || journal.finished[0].status != TransactionStatusRolledBack {
t.Fatalf("restored target must be finalized as rolled back: %+v", journal.finished)
}
assertVerifiedLocks(t, client, first, false)
}
func TestVerifiedRollbackJournalMatchesRecoveryEvidence(t *testing.T) {
for _, scenario := range []struct {
name string
recoveryError error
wantStatus string
wantRecovery string
wantLocks bool
}{
{"verified", nil, TransactionStatusRolledBack, "success", false},
{"unverified", errors.New("recovery verification failed"), TransactionStatusRecoveryRequired, "unconfirmed", true},
} {
t.Run(scenario.name, func(t *testing.T) {
servers := []Server{testServer("first"), testServer("second")}
clients := map[string]*memoryClient{}
originals := map[string]map[string]memoryFile{}
for _, server := range servers {
clients[server.ID] = newMemoryClient()
originals[server.ID] = seedVerifiedFiles(clients[server.ID], server)
}
journal := &memoryTransactionJournal{}
service := NewServiceWithJournal(memoryFactory{clients: clients}, journal)
ctx := WithTransactionContext(t.Context(), TransactionContext{
TaskID: "task", AttemptID: "attempt", AttemptNumber: 1,
})
verificationError := errors.New("deployment verification failed")
report, err := service.DeployVerified(ctx, []Target{{Server: servers[0]}, {Server: servers[1]}}, testArtifact(t), Verification{
Verify: func(context.Context) error { return verificationError },
VerifyRecovery: func(context.Context) error {
for _, server := range servers {
assertVerifiedFiles(t, clients[server.ID], originals[server.ID])
assertVerifiedLocks(t, clients[server.ID], server, true)
}
return scenario.recoveryError
},
})
if !errors.Is(err, verificationError) || report.Status != "failed" || report.RecoveryStatus != scenario.wantRecovery {
t.Fatalf("unexpected report: %+v, error: %v", report, err)
}
if len(journal.finished) != len(servers) {
t.Fatalf("unexpected journal completion count: %d", len(journal.finished))
}
for _, record := range journal.finished {
if record.status != scenario.wantStatus {
t.Errorf("transaction %s: got %s, want %s", record.id, record.status, scenario.wantStatus)
}
if record.status == TransactionStatusRolledBack && record.message != publicFailureMessages[FailureRecoveryRestored] {
t.Errorf("rolled back transaction has stale message: %s", record.message)
}
}
for _, server := range servers {
assertVerifiedLocks(t, clients[server.ID], server, scenario.wantLocks)
}
})
}
}