《MMO 服务器开发》5.3 崩溃恢复与状态重建

// file: internal/scheduler/state.go
// tier: L1
// verify: go test ./internal/scheduler/
package scheduler

import (
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"sort"
)

// EntityID 沿用全卷共享类型：高 16 位是场景 / 实例号，低 48 位是实例内序号。
type EntityID uint64

// Vec2 是服务器侧逻辑坐标，与全卷共享类型一致。
type Vec2 struct{ X, Y float64 }

// EntityState 是场景内一个实体的最小可恢复状态。真实项目里还有 buff、
// 仇恨、技能 CD，但「能不能重建」只取决于有没有把所有会变的状态记进事件。
type EntityState struct {
	ID  EntityID `json:"id"`
	Pos Vec2     `json:"pos"`
	HP  int32    `json:"hp"`
}

// EventKind 是事件类型。
type EventKind uint8

const (
	EvSpawn   EventKind = iota // 实体进入场景
	EvMove                     // 移动
	EvDamage                   // 扣血
	EvDespawn                  // 离开场景
)

// Event 是一条可重放的事件：带全局递增的 Seq。事件的粒度是恢复的关键——
// 它必须记下所有会改变状态的动作，漏一个，重建出来的状态就永远对不上。
type Event struct {
	Seq    uint64    `json:"seq"`
	Kind   EventKind `json:"kind"`
	Entity EntityID  `json:"entity"`
	Pos    Vec2      `json:"pos"`
	Delta  int32     `json:"delta,omitempty"`
}

// SceneState 是一张地图实例的内存状态：一批实体 + 已应用的事件序号。
// Seq 是恢复的锚点——快照记到哪个 Seq，重放就从它的下一个开始。
type SceneState struct {
	Instance InstanceID
	Seq      uint64
	Entities map[EntityID]EntityState
}

func NewSceneState(inst InstanceID) *SceneState {
	return &SceneState{Instance: inst, Entities: make(map[EntityID]EntityState)}
}

// sorted 按 ID 升序返回实体，保证任何派生结果（哈希、快照）都是确定的。
func (s *SceneState) sorted() []EntityState {
	ents := make([]EntityState, 0, len(s.Entities))
	for _, e := range s.Entities {
		ents = append(ents, e)
	}
	sort.Slice(ents, func(i, j int) bool { return ents[i].ID < ents[j].ID })
	return ents
}

// Hash 是状态的指纹，用来断言「重建出来的状态和崩溃前逐字节一致」。
func (s *SceneState) Hash() string {
	b, _ := json.Marshal(struct {
		Instance InstanceID
		Seq      uint64
		Entities []EntityState
	}{s.Instance, s.Seq, s.sorted()})
	sum := sha256.Sum256(b)
	return hex.EncodeToString(sum[:8])
}

// Apply 把一条事件应用到状态上。Seq 必须严格递增：不连续或重复一律拒绝，
// 这样重放时任何缺口都会立刻报错，而不是静默算出一个错的状态。
func (s *SceneState) Apply(e Event) error {
	if e.Seq != s.Seq+1 {
		return fmt.Errorf("event gap: state at seq %d, got %d", s.Seq, e.Seq)
	}
	switch e.Kind {
	case EvSpawn:
		s.Entities[e.Entity] = EntityState{ID: e.Entity, Pos: e.Pos, HP: 100}
	case EvMove:
		ent, ok := s.Entities[e.Entity]
		if !ok {
			return fmt.Errorf("move unknown entity %d", e.Entity)
		}
		ent.Pos = e.Pos
		s.Entities[e.Entity] = ent
	case EvDamage:
		ent, ok := s.Entities[e.Entity]
		if !ok {
			return fmt.Errorf("damage unknown entity %d", e.Entity)
		}
		if ent.HP -= e.Delta; ent.HP < 0 {
			ent.HP = 0
		}
		s.Entities[e.Entity] = ent
	case EvDespawn:
		delete(s.Entities, e.Entity)
	}
	s.Seq = e.Seq
	return nil
}

// file: internal/scheduler/snapshot.go
// tier: L1
// verify: go test ./internal/scheduler/ -run TestRecoverPicksLatestValidSnapshot
package scheduler

import (
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"path/filepath"
	"sort"
)

// Snapshot 是某个 Seq 处的状态快照。Checksum 覆盖 Instance/Seq/Entities：
// 恢复时先校验，损坏的快照直接丢弃、退回到更早的一个，而不是拿着半截
// 数据继续重放。
type Snapshot struct {
	Instance InstanceID    `json:"instance"`
	Seq      uint64        `json:"seq"`
	Entities []EntityState `json:"entities"`
	Checksum string        `json:"checksum"`
}

func checksum(s Snapshot) string {
	b, _ := json.Marshal(struct {
		Instance InstanceID
		Seq      uint64
		Entities []EntityState
	}{s.Instance, s.Seq, s.Entities})
	sum := sha256.Sum256(b)
	return hex.EncodeToString(sum[:])
}

// Recover 从 dir 里恢复一份状态：先选最新的、校验和正确的快照，再把事件
// 日志里 Seq 大于快照的所有事件重放上去。选最新可用快照而不是固定一份，
// 是为了在「快照写坏」和「重放代价」之间自动取平衡。
func Recover(dir string) (*SceneState, error) {
	snaps, err := loadSnapshots(dir)
	if err != nil {
		return nil, err
	}
	if len(snaps) == 0 {
		return nil, fmt.Errorf("no snapshot in %s", dir)
	}
	sort.Slice(snaps, func(i, j int) bool { return snaps[i].Seq < snaps[j].Seq })

	var base Snapshot
	for i := len(snaps) - 1; i >= 0; i-- { // 从最新往前找第一个校验通过的
		if checksum(snaps[i]) == snaps[i].Checksum {
			base = snaps[i]
			break
		}
	}
	if base.Checksum == "" {
		return nil, fmt.Errorf("all snapshots in %s are corrupt", dir)
	}

	st := NewSceneState(base.Instance)
	st.Seq = base.Seq
	for _, e := range base.Entities {
		st.Entities[e.ID] = e
	}
	events, err := loadEvents(filepath.Join(dir, "events.jsonl"))
	if err != nil {
		return nil, err
	}
	for _, e := range events {
		if e.Seq <= st.Seq { // 快照已包含，跳过
			continue
		}
		if err := st.Apply(e); err != nil {
			return nil, err
		}
	}
	return st, nil
}

// file: internal/scheduler/recovery_test.go
// tier: L2
// verify: go test ./internal/scheduler/ -run TestCrashRebuild
package scheduler

import (
	"bufio"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
)

// buildCmd 把 cmd/ 下的一个包编译到临时目录，返回二进制路径。
func buildCmd(t *testing.T, pkg string) string {
	t.Helper()
	bin := filepath.Join(t.TempDir(), "bin")
	cmd := exec.Command("go", "build", "-o", bin, pkg)
	cmd.Dir = "../.." // 从 internal/scheduler 回到 module 根
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("build %s: %v\n%s", pkg, err, out)
	}
	return bin
}

// TestCrashRebuild 真跑「杀掉进程 → 重建 → 断言一致」：起一个持有状态的
// 真进程，读它报告的状态指纹，SIGKILL 杀掉，再从快照 + 事件重放，断言
// 重建出来的状态与崩溃前逐字节相同。
func TestCrashRebuild(t *testing.T) {
	dir := t.TempDir()
	want := writeFixture(t, dir) // 造现场，返回真值指纹

	cmd := exec.Command(buildCmd(t, "./cmd/scenestate"), "-dir", dir)
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		t.Fatal(err)
	}
	if err := cmd.Start(); err != nil {
		t.Fatal(err)
	}

	sc := bufio.NewScanner(stdout)
	var live string
	for sc.Scan() {
		if line := sc.Text(); strings.HasPrefix(line, "STATE hash=") {
			live = strings.TrimPrefix(strings.Fields(strings.TrimPrefix(line, "STATE "))[0], "hash=")
			break
		}
	}
	if live == "" {
		t.Fatal("child never reported state")
	}
	if live != want {
		t.Fatalf("live state %s != ground truth %s", live, want)
	}

	// 模拟崩溃：SIGKILL，不给它任何落盘或优雅退出的机会。
	if err := cmd.Process.Kill(); err != nil {
		t.Fatal(err)
	}
	_ = cmd.Wait()

	st, err := Recover(dir)
	if err != nil {
		t.Fatalf("recover: %v", err)
	}
	if st.Hash() != live {
		t.Fatalf("rebuilt state %s != pre-crash %s", st.Hash(), live)
	}
}