1
package checkpoint
2

3
// LogEntry WAL 日志条目
4
type LogEntry struct {
5
    ID        int
6
    Operation string
7
    Key       string
8
    Value     any
9
}
10

11
// stateSnapshot 检查点快照
12
type stateSnapshot struct {
13
    state       map[string]any
14
    walPosition int // 快照对应的 WAL 位置
15
}
16

17
// CheckpointableStore 带检查点的可恢复存储
18
type CheckpointableStore struct {
19
    state      map[string]any
20
    wal        []LogEntry
21
    nextID     int
22
    checkpoint *stateSnapshot
23
}
24

25
func NewStore() *CheckpointableStore {
26
    return &CheckpointableStore{
27
        state:  make(map[string]any),
28
        nextID: 1,
29
    }
30
}
31

32
// Apply 执行操作并记录到 WAL
33
func (s *CheckpointableStore) Apply(operation, key string, value any) {
34
    entry := LogEntry{ID: s.nextID, Operation: operation, Key: key, Value: value}
35
    s.nextID++
36
    s.wal = append(s.wal, entry)
37
    s.executeOp(entry)
38
}
39

40
// Get 读取当前状态
41
func (s *CheckpointableStore) Get(key string) (any, bool) {
42
    v, ok := s.state[key]
43
    return v, ok
44
}
45

46
// TakeCheckpoint 创建检查点：快照当前状态和 WAL 位置
47
func (s *CheckpointableStore) TakeCheckpoint() {
48
    snap := make(map[string]any, len(s.state))
49
    for k, v := range s.state {
50
        snap[k] = v
51
    }
52
    s.checkpoint = &stateSnapshot{state: snap, walPosition: len(s.wal)}
53
}
54

55
// SimulateCrash 模拟崩溃：清空内存状态
56
func (s *CheckpointableStore) SimulateCrash() {
57
    s.state = make(map[string]any)
58
}
59

60
// Recover 从检查点 + WAL 恢复，返回重放的条目数
61
func (s *CheckpointableStore) Recover() int {
62
    if s.checkpoint != nil {
63
        s.state = make(map[string]any, len(s.checkpoint.state))
64
        for k, v := range s.checkpoint.state {
65
            s.state[k] = v
66
        }
67
        replayed := 0
68
        for i := s.checkpoint.walPosition; i < len(s.wal); i++ {
69
            s.executeOp(s.wal[i])
70
            replayed++
71
        }
72
        return replayed
73
    }
74
    // 无检查点：重放整个 WAL
75
    s.state = make(map[string]any)
76
    for _, entry := range s.wal {
77
        s.executeOp(entry)
78
    }
79
    return len(s.wal)
80
}
81

82
func (s *CheckpointableStore) executeOp(entry LogEntry) {
83
    switch entry.Operation {
84
    case "SET":
85
        s.state[entry.Key] = entry.Value
86
    case "DELETE":
87
        delete(s.state, entry.Key)
88
    }
89
}

1
// WAL 日志条目
2
interface LogEntry {
3
  id: number;
4
  operation: string;
5
  data: { key: string; value: unknown };
6
}
7

8
// 带检查点的可恢复存储
9
class CheckpointableStore {
10
  private state = new Map<string, unknown>();
11
  private wal: LogEntry[] = [];
12
  private nextId = 1;
13
  private checkpoint: { state: Map<string, unknown>; walPosition: number } | null = null;
14

15
  // 执行操作并记录到 WAL
16
  apply(operation: string, key: string, value: unknown): void {
17
    const entry: LogEntry = { id: this.nextId++, operation, data: { key, value } };
18
    this.wal.push(entry);
19
    this.executeOp(entry);
20
  }
21

22
  get(key: string): unknown {
23
    return this.state.get(key);
24
  }
25

26
  // 创建检查点
27
  takeCheckpoint(): void {
28
    this.checkpoint = {
29
      state: new Map(this.state), // 浅拷贝当前状态
30
      walPosition: this.wal.length,
31
    };
32
  }
33

34
  // 模拟崩溃
35
  simulateCrash(): void {
36
    this.state = new Map();
37
  }
38

39
  // 从检查点 + WAL 恢复
40
  recover(): number {
41
    if (this.checkpoint) {
42
      this.state = new Map(this.checkpoint.state);
43
      let replayed = 0;
44
      for (let i = this.checkpoint.walPosition; i < this.wal.length; i++) {
45
        this.executeOp(this.wal[i]!);
46
        replayed++;
47
      }
48
      return replayed;
49
    }
50
    // 无检查点：重放整个 WAL
51
    this.state = new Map();
52
    for (const entry of this.wal) this.executeOp(entry);
53
    return this.wal.length;
54
  }
55

56
  private executeOp(entry: LogEntry): void {
57
    const { key, value } = entry.data;
58
    if (entry.operation === "SET") this.state.set(key, value);
59
    else if (entry.operation === "DELETE") this.state.delete(key);
60
  }
61
}