《MMO 服务器开发》1.3 本书范围与站内服务治理文章的分工

// file: internal/scope/scope.go
// tier: L1
// verify: go test ./internal/scope/
// Package scope encodes the division of labour behind volume three. Section 1.3
// explains it in prose: the site's existing architecture articles answer "what
// should the design be", volumes one and two already shipped the network kernel
// and the single-server gameplay systems, and this volume writes the cluster
// layer from scratch. This file makes that split queryable, so "who owns this
// topic" is an assertion a test can fail on rather than a rule nobody re-reads.
//
// It also pins the exclusion list. A topic like rendering or anti-cheat models
// is not "someone else's chapter": it is out of this series entirely, and the
// table says so rather than leaving the reader waiting for a chapter that will
// never come.
package scope

import "strings"

// Owner names which body of work owns a topic.
type Owner string

const (
	// OwnerPractice is the site's existing game-server architecture articles:
	// they answer "what should the design be, and why", with no runnable code.
	OwnerPractice Owner = "practice"
	// OwnerVol12 is volumes one and two already shipped: the network kernel and
	// the single-server gameplay systems.
	OwnerVol12 Owner = "vol1-vol2"
	// OwnerDist is this volume: the cluster and cross-server layer, built from
	// scratch with numbers.
	OwnerDist Owner = "vol3-dist"
	// OwnerExcluded is out of the series entirely: no volume here writes it.
	OwnerExcluded Owner = "excluded"
)

// Rule maps a topic keyword to its owner. First match wins, so order is
// priority: the excluded and already-shipped rules come before this volume's,
// so a broad keyword cannot silently steal a topic that belongs elsewhere.
type Rule struct {
	Keyword string
	Owner   Owner
}

// rules is the 1.3 split, in code.
var rules = []Rule{
	// Out of the series: no volume in this series writes these.
	{"引擎", OwnerExcluded},
	{"渲染", OwnerExcluded},
	{"客户端表现", OwnerExcluded},
	{"美术", OwnerExcluded},
	{"商业化", OwnerExcluded},
	{"云厂商控制台", OwnerExcluded},
	{"公网 DDoS", OwnerExcluded},
	{"机器学习反外挂", OwnerExcluded},
	// Architecture-only topics stay with the existing articles.
	{"分层方案", OwnerPractice},
	{"状态归属方案", OwnerPractice},
	{"选型对比", OwnerPractice},
	{"架构取舍", OwnerPractice},
	{"部署拓扑", OwnerPractice},
	// Wire and single-server gameplay belong to the shipped volumes.
	{"编解码", OwnerVol12},
	{"KCP", OwnerVol12},
	{"帧切分", OwnerVol12},
	{"时间轮", OwnerVol12},
	{"背包", OwnerVol12},
	{"公会仓库", OwnerVol12},
	// The cluster layer is this volume's job.
	{"服务发现", OwnerDist},
	{"健康检查", OwnerDist},
	{"RPC", OwnerDist},
	{"超时预算", OwnerDist},
	{"熔断", OwnerDist},
	{"网关集群", OwnerDist},
	{"会话粘性", OwnerDist},
	{"跨服", OwnerDist},
	{"分库分表", OwnerDist},
	{"雪花算法", OwnerDist},
	{"缓存一致", OwnerDist},
	{"分布式事务", OwnerDist},
	{"对账", OwnerDist},
	{"事件溯源", OwnerDist},
}

// OwnerOf returns the owner of a topic. A topic that matches no rule falls back
// to this volume: its job is exactly "the cluster layer nobody else wrote from
// scratch", so the default must point here, never away.
func OwnerOf(topic string) Owner {
	for _, r := range rules {
		if strings.Contains(topic, r.Keyword) {
			return r.Owner
		}
	}
	return OwnerDist
}

// Excluded lists, in reader-facing words, what this series does not cover. It
// is the exclusion table of section 1.3, kept next to the router so the two can
// never drift apart.
func Excluded() []string {
	return []string{
		"引擎与渲染",
		"客户端表现",
		"美术与内容管线",
		"商业化运营",
		"真实云厂商控制台操作",
		"真实公网 DDoS",
		"机器学习反外挂",
	}
}

// DeferredPaths returns the site paths this volume defers to for a given owner.
// Only section paths under /posts/ are ever returned: a bare single-segment
// path is a dead link once articles are flattened to /<slug>/.
func DeferredPaths(o Owner) []string {
	switch o {
	case OwnerPractice:
		return []string{"/posts/game/server/", "/posts/game/server/practice/"}
	case OwnerVol12:
		return []string{"/posts/books/网络与并发内核/", "/posts/books/单服架构与玩法系统/"}
	default:
		// This volume and the excluded list defer to nothing.
		return nil
	}
}

// file: internal/scope/scope_test.go
// tier: L1
// verify: go test ./internal/scope/
package scope

import (
	"strings"
	"testing"
)

func TestOwnerOfRoutesToPractice(t *testing.T) {
	for _, topic := range []string{"分层方案怎么写", "状态归属方案", "服务选型对比", "部署拓扑取舍"} {
		if got := OwnerOf(topic); got != OwnerPractice {
			t.Errorf("OwnerOf(%q) = %s, want practice", topic, got)
		}
	}
}

func TestOwnerOfRoutesToShippedVolumes(t *testing.T) {
	for _, topic := range []string{"KCP 重传", "帧切分", "时间轮级联", "公会仓库并发"} {
		if got := OwnerOf(topic); got != OwnerVol12 {
			t.Errorf("OwnerOf(%q) = %s, want vol1-vol2", topic, got)
		}
	}
}

func TestOwnerOfRoutesToThisVolume(t *testing.T) {
	for _, topic := range []string{"服务发现与健康检查", "RPC 超时预算", "网关集群会话粘性", "跨服匹配", "雪花算法时钟回拨"} {
		if got := OwnerOf(topic); got != OwnerDist {
			t.Errorf("OwnerOf(%q) = %s, want vol3-dist", topic, got)
		}
	}
}

func TestExcludedTopicsDoNotFallThroughToThisVolume(t *testing.T) {
	// The trap this guards: a topic like "渲染" must NOT be silently claimed by
	// this volume just because it matched no cluster keyword. It is out of the
	// series, and the router must say so.
	for _, topic := range []string{"引擎与渲染管线", "客户端表现优化", "美术资源管线", "商业化付费设计", "真实公网 DDoS 演练", "机器学习反外挂模型"} {
		if got := OwnerOf(topic); got != OwnerExcluded {
			t.Errorf("OwnerOf(%q) = %s, want excluded", topic, got)
		}
	}
}

func TestFallbackIsThisVolume(t *testing.T) {
	// A topic nobody else claimed is exactly what this volume is for.
	if got := OwnerOf("一个没人写过的话题 xyz"); got != OwnerDist {
		t.Fatalf("fallback = %s, want vol3-dist", got)
	}
}

func TestExcludedListCoversTheSevenTopics(t *testing.T) {
	want := []string{
		"引擎与渲染", "客户端表现", "美术与内容管线", "商业化运营",
		"真实云厂商控制台操作", "真实公网 DDoS", "机器学习反外挂",
	}
	got := Excluded()
	if len(got) != len(want) {
		t.Fatalf("Excluded() has %d entries, want %d", len(got), len(want))
	}
	for i := range want {
		if got[i] != want[i] {
			t.Errorf("Excluded()[%d] = %q, want %q", i, got[i], want[i])
		}
	}
}

func TestDeferredPathsAreSectionPaths(t *testing.T) {
	for _, o := range []Owner{OwnerPractice, OwnerVol12} {
		paths := DeferredPaths(o)
		if len(paths) == 0 {
			t.Fatalf("DeferredPaths(%s) is empty", o)
		}
		for _, p := range paths {
			if !strings.HasPrefix(p, "/posts/") || !strings.HasSuffix(p, "/") {
				t.Errorf("path %q must be a section path under /posts/ ending in /", p)
			}
		}
	}
	// This volume and the exclusion list defer to nothing.
	for _, o := range []Owner{OwnerDist, OwnerExcluded} {
		if got := DeferredPaths(o); got != nil {
			t.Fatalf("DeferredPaths(%s) = %v, want nil", o, got)
		}
	}
}

=== RUN   TestOwnerOfRoutesToPractice
--- PASS: TestOwnerOfRoutesToPractice (0.00s)
=== RUN   TestOwnerOfRoutesToShippedVolumes
--- PASS: TestOwnerOfRoutesToShippedVolumes (0.00s)
=== RUN   TestOwnerOfRoutesToThisVolume
--- PASS: TestOwnerOfRoutesToThisVolume (0.00s)
=== RUN   TestExcludedTopicsDoNotFallThroughToThisVolume
--- PASS: TestExcludedTopicsDoNotFallThroughToThisVolume (0.00s)
=== RUN   TestFallbackIsThisVolume
--- PASS: TestFallbackIsThisVolume (0.00s)
=== RUN   TestExcludedListCoversTheSevenTopics
--- PASS: TestExcludedListCoversTheSevenTopics (0.00s)
=== RUN   TestDeferredPathsAreSectionPaths
--- PASS: TestDeferredPathsAreSectionPaths (0.00s)
PASS
ok  	aegis/internal/scope	0.857s