《MMO 服务器开发》1.3 一个 MMO 服务端最少要有哪些零件

// file: internal/overview/checklist.go
// tier: L1
// verify: go test ./internal/overview/
// Package overview also models the "minimum parts" question from section 1.3:
// what does an MMO server need before it can boot at all? The checklist turns
// that prose list into data a test can check, so the roadmap and the code
// cannot drift apart.
package overview

import (
	"fmt"
	"sort"
	"strings"
)

// Status is how far a part has been built.
type Status int

const (
	// Missing means the part does not exist yet.
	Missing Status = iota
	// Stubbed means there is a placeholder with no real behaviour.
	Stubbed
	// Ready means the part works and is covered by a test.
	Ready
)

func (s Status) String() string {
	switch s {
	case Missing:
		return "missing"
	case Stubbed:
		return "stubbed"
	case Ready:
		return "ready"
	}
	return "unknown"
}

// Part is one building block of an MMO server. Tier records which chapter of
// volume one is meant to build it, so the checklist doubles as a roadmap.
type Part struct {
	ID       string // stable key, e.g. "codec"
	Name     string // human label, e.g. "协议编解码"
	Tier     string // owning chapter, e.g. "第 3–4 章"
	Required bool   // without it the server cannot boot
	Status   Status
}

// Checklist is an ordered, addressable set of parts.
type Checklist struct {
	order []string
	byID  map[string]*Part
}

// NewChecklist returns an empty checklist.
func NewChecklist() *Checklist { return &Checklist{byID: map[string]*Part{}} }

// Add inserts a part, rejecting duplicate or empty IDs so the roadmap cannot
// silently contain the same block twice.
func (c *Checklist) Add(p Part) error {
	if p.ID == "" {
		return fmt.Errorf("overview: part with empty ID")
	}
	if _, ok := c.byID[p.ID]; ok {
		return fmt.Errorf("overview: duplicate part %q", p.ID)
	}
	cp := p
	c.byID[p.ID] = &cp
	c.order = append(c.order, p.ID)
	return nil
}

// Set updates the status of an existing part.
func (c *Checklist) Set(id string, s Status) error {
	p, ok := c.byID[id]
	if !ok {
		return fmt.Errorf("overview: unknown part %q", id)
	}
	p.Status = s
	return nil
}

// Get returns a copy of a part by ID.
func (c *Checklist) Get(id string) (Part, bool) {
	p, ok := c.byID[id]
	if !ok {
		return Part{}, false
	}
	return *p, true
}

// Blockers lists the required parts that are not Ready, in insertion order.
func (c *Checklist) Blockers() []Part {
	var out []Part
	for _, id := range c.order {
		if p := c.byID[id]; p.Required && p.Status != Ready {
			out = append(out, *p)
		}
	}
	return out
}

// Ready reports whether every required part is Ready.
func (c *Checklist) Ready() bool { return len(c.Blockers()) == 0 }

// Report renders the checklist as a fixed-width table, required parts first.
func (c *Checklist) Report() string {
	parts := make([]Part, 0, len(c.order))
	for _, id := range c.order {
		parts = append(parts, *c.byID[id])
	}
	sort.SliceStable(parts, func(i, j int) bool {
		return parts[i].Required && !parts[j].Required
	})
	var b strings.Builder
	b.WriteString("part            tier         status   req\n")
	b.WriteString("------------------------------------------\n")
	for _, p := range parts {
		req := "no"
		if p.Required {
			req = "yes"
		}
		fmt.Fprintf(&b, "%-15s %-12s %-8s %s\n", p.ID, p.Tier, p.Status, req)
	}
	return b.String()
}

// AegisChecklist is the ten parts a minimal MMO server needs, wired to the
// chapter of volume one meant to build each one. It is the machine-readable
// version of the parts table in section 1.3.
func AegisChecklist() *Checklist {
	c := NewChecklist()
	for _, p := range []Part{
		{ID: "codec", Name: "协议编解码", Tier: "第 3–4 章", Required: true},
		{ID: "session", Name: "连接与会话", Tier: "第 6–7 章", Required: true},
		{ID: "gateway", Name: "网关", Tier: "第 7 章", Required: true},
		{ID: "router", Name: "消息路由", Tier: "第 8 章", Required: true},
		{ID: "timer", Name: "定时器", Tier: "第 9 章", Required: true},
		{ID: "actor", Name: "Actor/邮箱", Tier: "第 10 章", Required: true},
		{ID: "idempotency", Name: "幂等", Tier: "第 11 章", Required: false},
		{ID: "sync", Name: "同步模型", Tier: "第 12–13 章", Required: true},
		{ID: "guard", Name: "安全防护", Tier: "第 15–16 章", Required: false},
		{ID: "loadtest", Name: "压测工具", Tier: "第 17 章", Required: false},
	} {
		// IDs are unique constants, so Add cannot fail here.
		_ = c.Add(p)
	}
	return c
}

// file: internal/overview/checklist_test.go
// tier: L1
// verify: go test ./internal/overview/
package overview

import (
	"strings"
	"testing"
)

func TestAegisChecklistHasTenParts(t *testing.T) {
	c := AegisChecklist()
	if got := len(c.order); got != 10 {
		t.Fatalf("parts = %d, want 10", got)
	}
	for _, id := range []string{"codec", "session", "gateway", "router", "timer", "actor", "idempotency", "sync", "guard", "loadtest"} {
		if _, ok := c.Get(id); !ok {
			t.Fatalf("missing part %q", id)
		}
	}
}

func TestBlockedUntilRequiredPartsDone(t *testing.T) {
	c := AegisChecklist()
	if c.Ready() {
		t.Fatal("fresh checklist should not be ready")
	}
	// Optional parts being Ready must not unblock the checklist.
	for _, id := range []string{"idempotency", "guard", "loadtest"} {
		if err := c.Set(id, Ready); err != nil {
			t.Fatalf("Set(%s): %v", id, err)
		}
	}
	if c.Ready() {
		t.Fatal("checklist must still be blocked by required parts")
	}
	blockers := c.Blockers()
	if len(blockers) != 7 {
		t.Fatalf("blockers = %d, want 7", len(blockers))
	}
	for _, b := range blockers {
		if !b.Required {
			t.Fatalf("blocker %q is not required", b.ID)
		}
	}
}

func TestReadyWhenAllRequiredDone(t *testing.T) {
	c := AegisChecklist()
	for _, id := range []string{"codec", "session", "gateway", "router", "timer", "actor", "sync"} {
		if err := c.Set(id, Ready); err != nil {
			t.Fatalf("Set(%s): %v", id, err)
		}
	}
	if !c.Ready() {
		t.Fatalf("checklist should be ready, blockers=%v", c.Blockers())
	}
}

func TestRejectsDuplicateAndUnknown(t *testing.T) {
	c := NewChecklist()
	if err := c.Add(Part{ID: "codec", Required: true}); err != nil {
		t.Fatalf("first Add: %v", err)
	}
	if err := c.Add(Part{ID: "codec"}); err == nil {
		t.Fatal("expected duplicate error, got nil")
	}
	if err := c.Set("nope", Ready); err == nil {
		t.Fatal("expected unknown-part error, got nil")
	}
}

func TestReportPutsRequiredFirst(t *testing.T) {
	c := AegisChecklist()
	_ = c.Set("loadtest", Ready) // optional, but ready
	report := c.Report()
	ic := strings.Index(report, "codec")
	il := strings.Index(report, "loadtest")
	if ic < 0 || il < 0 || ic > il {
		t.Fatalf("expected required part first, report=\n%s", report)
	}
}

--- PASS: TestAegisChecklistHasTenParts (0.00s)
--- PASS: TestBlockedUntilRequiredPartsDone (0.00s)
--- PASS: TestReadyWhenAllRequiredDone (0.00s)
--- PASS: TestRejectsDuplicateAndUnknown (0.00s)
--- PASS: TestReportPutsRequiredFirst (0.00s)
PASS
ok  	aegis/internal/overview	0.324s