《MMO 服务器开发》9.1 《晨曦大陆》玩法装配

              +----------------------------------------------+
   阶段 0     | 中间件探活（未通过则不启动任何节点）         |
              | redis :26379   etcd :32379   nats :34222     |
              +-----------------------+----------------------+
                                      | 三个端口全部可达
   阶段 1     +---------------+       |
              | world-01      |<------+ 世界状态快照 / 全局时间
              +-------+-------+       |
                      | 注册          |
              +-------+-------+       |
              | scene-01      |<------+ 地图实例 / AOI / 玩法循环
              +-------+-------+       |
                      | 注册          |
              +-------+-------+       |
              | battle-01     |<------+ 副本战斗 / 结算
              +-------+-------+       |
                      | 注册          |
   阶段 2     +-------+-------+       |
              | gateway-01    |<------+ 连接接入 / 路由 / 会话（最后起）
              +---------------+ 

// file: internal/dawnrealm/assembly.go
// tier: L1
// verify: go test ./internal/dawnrealm/
package dawnrealm

import (
	"errors"
	"fmt"
	"sort"
)

// EntityID is shared across the volumes: the high 16 bits are the scene or
// instance number, the low 48 bits are a per-instance sequence.
type EntityID uint64

// PlayerID is the globally unique character id.
type PlayerID uint64

// Role is one daemon role in the 《晨曦大陆》 deployment. Middleware roles are
// probed for connectivity; node roles are started as child processes.
type Role string

const (
	// Middleware preconditions, probed before any node starts.
	RoleRedis Role = "redis"
	RoleEtcd  Role = "etcd"
	RoleNATS  Role = "nats"

	// Node daemons, started in dependency order.
	RoleGateway Role = "gateway"
	RoleScene   Role = "scene"
	RoleWorld   Role = "world"
	RoleBattle  Role = "battle"
)

// IsMiddleware reports whether the role is a precondition rather than a daemon.
func (r Role) IsMiddleware() bool {
	switch r {
	case RoleRedis, RoleEtcd, RoleNATS:
		return true
	default:
		return false
	}
}

// Node is one entry in the assembly: a daemon to bring up, or a middleware
// endpoint to probe first.
type Node struct {
	Role    Role   `json:"role"`
	ID      string `json:"id"`
	Addr    string `json:"addr"`
	Depends []Role `json:"depends,omitempty"`
	Health  string `json:"health,omitempty"`
}

// Assembly is the ordered startup plan for one 《晨曦大陆》 world.
type Assembly struct {
	Nodes []Node `json:"nodes"`
}

// DefaultAssembly is the four-daemon topology the book uses: gateway accepts
// player connections, scene runs the map instances, world holds the shared
// world state, battle runs instanced combat. The gateway depends on the scene
// and world registries, the scene depends on the world snapshot.
func DefaultAssembly(basePort int) Assembly {
	return Assembly{Nodes: []Node{
		{Role: RoleGateway, ID: "gateway-01", Addr: fmt.Sprintf("127.0.0.1:%d", basePort)},
		{Role: RoleScene, ID: "scene-01", Addr: fmt.Sprintf("127.0.0.1:%d", basePort+1), Depends: []Role{RoleWorld}},
		{Role: RoleWorld, ID: "world-01", Addr: fmt.Sprintf("127.0.0.1:%d", basePort+2)},
		{Role: RoleBattle, ID: "battle-01", Addr: fmt.Sprintf("127.0.0.1:%d", basePort+3), Depends: []Role{RoleScene}},
	}}
}

// Plan returns the nodes in an order that starts every dependency before its
// dependents. It fails on a missing dependency or a cycle, so a mis-declared
// assembly is caught before anything is started.
func (a Assembly) Plan() ([]Node, error) {
	byRole := make(map[Role]Node, len(a.Nodes))
	for _, n := range a.Nodes {
		if _, dup := byRole[n.Role]; dup {
			return nil, fmt.Errorf("dawnrealm: duplicate role %q", n.Role)
		}
		byRole[n.Role] = n
	}
	for _, n := range a.Nodes {
		for _, d := range n.Depends {
			if _, ok := byRole[d]; !ok {
				return nil, fmt.Errorf("dawnrealm: %s depends on unknown role %q", n.Role, d)
			}
		}
	}

	// Deterministic order: iterate roles sorted, then stable topological sort.
	order := make([]Node, 0, len(a.Nodes))
	done := make(map[Role]bool, len(a.Nodes))
	var visit func(Role, map[Role]bool) error
	visit = func(r Role, onStack map[Role]bool) error {
		if done[r] {
			return nil
		}
		if onStack[r] {
			return fmt.Errorf("dawnrealm: dependency cycle at %q", r)
		}
		onStack[r] = true
		n := byRole[r]
		deps := append([]Role(nil), n.Depends...)
		sort.Slice(deps, func(i, j int) bool { return deps[i] < deps[j] })
		for _, d := range deps {
			if err := visit(d, onStack); err != nil {
				return err
			}
		}
		delete(onStack, r)
		done[r] = true
		order = append(order, n)
		return nil
	}

	roles := make([]Role, 0, len(a.Nodes))
	for r := range byRole {
		roles = append(roles, r)
	}
	sort.Slice(roles, func(i, j int) bool { return roles[i] < roles[j] })
	for _, r := range roles {
		if err := visit(r, map[Role]bool{}); err != nil {
			return nil, err
		}
	}
	return order, nil
}

// ErrHealthGate is returned when a node never becomes healthy within the gate.
var ErrHealthGate = errors.New("dawnrealm: health gate not satisfied")

// snippet: cmd/dawnrealm/main.go 的 up 子命令
deps := dawnrealm.GateDeps{
	Prober:  dawnrealm.TCPProber{Timeout: time.Second},
	Checker: dawnrealm.HTTPChecker{Timeout: *timeout, Poll: 20 * time.Millisecond},
	Start:   start, // 每个节点 = exec 自身 "node" 子命令
}
if err := dawnrealm.BringUp(ctx, asm, mw, deps); err != nil {
	for _, c := range children {
		_ = c.Process.Kill() // 失败即整体回滚
	}
	return 1
}

// file: internal/dawnrealm/orchestrate_test.go
// tier: L2
// verify: go test -run TestLaunchAssembly -v ./internal/dawnrealm/
package dawnrealm

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

// moduleRoot walks up from this test file to the module root.
func moduleRoot(t *testing.T) string {
	t.Helper()
	_, file, _, ok := runtime.Caller(0)
	if !ok {
		t.Fatal("cannot locate test file")
	}
	return filepath.Join(filepath.Dir(file), "..", "..")
}

// TestLaunchAssembly builds cmd/dawnrealm and runs `up` for real: it probes
// the middleware containers, starts the four daemons as child processes,
// health-gates each, then smoke-checks every node. Exit code 0 means the whole
// assembly came up and answered.
func TestLaunchAssembly(t *testing.T) {
	root := moduleRoot(t)
	bin := filepath.Join(t.TempDir(), "dawnrealm")

	build := exec.Command("go", "build", "-o", bin, "aegis/cmd/dawnrealm")
	build.Dir = root
	if out, err := build.CombinedOutput(); err != nil {
		t.Fatalf("build: %v\n%s", err, out)
	}

	up := exec.Command(bin, "up", "-base", "9210", "-timeout", "5s")
	up.Dir = root
	out, err := up.CombinedOutput()
	got := string(out)
	if err != nil {
		t.Fatalf("dawnrealm up failed: %v\n%s", err, got)
	}
	for _, want := range []string{"gateway-01", "scene-01", "world-01", "battle-01", "smoke passed"} {
		if !strings.Contains(got, want) {
			t.Fatalf("output missing %q:\n%s", want, got)
		}
	}
}

smoke world-01    world ok
smoke scene-01    scene ok
smoke battle-01   battle ok
smoke gateway-01  gateway ok
assembly up: 4 nodes healthy, smoke passed