《MMO 服务器开发》11.1 跨服战场端到端

 玩家A(服1)            玩家B(服2)
    │ 报名                 │ 报名
    ▼                      ▼
 gateway-1 ───┐     ┌─── gateway-2        第 4 章：网关按服号维护路由目录
    │         │     │        │
    │ signup  ▼     ▼ signup │
    └───────►  hub  ◄───────┘              第 6 章：跨服报名与匹配队列
               │
               │ 匹配成队 + 分配实例
               ▼
            battle-0  ◄── 两个服的玩家被路由到同一个实例
               │
               │ 战斗结果（按服号回传奖励）
               ▼
              hub ── 幂等结算 ──► gateway-1 / gateway-2   第 10 章：补偿与幂等

// file: internal/battlecluster/hub.go
// tier: L1
// verify: go test ./internal/battlecluster/
package battlecluster

import (
	"errors"
	"sync"
)

// ErrDuplicateSettlement is returned when a battle result is reported twice.
var ErrDuplicateSettlement = errors.New("battlecluster: battle already settled")

// Hub is the cross-server coordinator. It holds the signup queues, matches
// players into a team, allocates a battle instance, and turns a battle result
// into per-server settlements. It is the piece that decides "which server's
// reward goes where".
type Hub struct {
	mu         sync.Mutex
	teamSize   int
	queues     map[string][]SignedPlayer // battle type -> waiting players
	battleAddr []string                  // battle instance addresses
	rr         int                       // round-robin cursor over battleAddr
	nextID     BattleID
	settled    map[BattleID]bool // idempotency keys
	minted     int64             // total gold the hub has ordered settled
}

// NewHub builds a hub with a fixed team size and a pool of battle addresses.
func NewHub(teamSize int, battleAddrs []string) *Hub {
	return &Hub{
		teamSize:   teamSize,
		queues:     make(map[string][]SignedPlayer),
		battleAddr: append([]string(nil), battleAddrs...),
		settled:    make(map[BattleID]bool),
	}
}

// Signup records a player's cross-server request. If enough players of the same
// battle type are now waiting, it forms a match, allocates a battle instance by
// round-robin, and returns it. The bool is true exactly when a match formed.
func (h *Hub) Signup(req SignupReq) (MatchFound, bool) {
	h.mu.Lock()
	defer h.mu.Unlock()

	p := SignedPlayer{ServerID: req.ServerID, PlayerID: req.PlayerID}
	h.queues[req.Battle] = append(h.queues[req.Battle], p)
	if len(h.queues[req.Battle]) < h.teamSize {
		return MatchFound{}, false
	}

	team := h.queues[req.Battle][:h.teamSize]
	h.queues[req.Battle] = h.queues[req.Battle][h.teamSize:]

	h.nextID++
	addr := h.battleAddr[h.rr%len(h.battleAddr)]
	h.rr++
	return MatchFound{
		BattleID: h.nextID,
		Addr:     addr,
		Players:  append([]SignedPlayer(nil), team...),
	}, true
}

// Report turns a battle result into settlements. It is idempotent: reporting the
// same BattleID twice returns ErrDuplicateSettlement and no settlements, so a
// retried report can never double-pay.
func (h *Hub) Report(res BattleResult) ([]SettleReward, error) {
	h.mu.Lock()
	defer h.mu.Unlock()

	if h.settled[res.BattleID] {
		return nil, ErrDuplicateSettlement
	}
	h.settled[res.BattleID] = true

	out := make([]SettleReward, 0, len(res.Rewards))
	for _, r := range res.Rewards {
		h.minted += r.Gold
		out = append(out, SettleReward{BattleID: res.BattleID, Reward: r})
	}
	return out, nil
}

// Minted is the total gold the hub has ordered settled across all battles. It is
// the reference side of the conservation check: what gateways credited must
// equal what the hub minted.
func (h *Hub) Minted() int64 {
	h.mu.Lock()
	defer h.mu.Unlock()
	return h.minted
}

// file: internal/battlecluster/e2e_test.go
// tier: L2
// verify: go test -run TestEndToEndCrossServerBattle ./internal/battlecluster/
package battlecluster

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

type nodeProc struct {
	cmd  *exec.Cmd
	addr string
}

// build builds one cmd package into dir and returns the binary path.
func build(t *testing.T, dir, pkg string) string {
	t.Helper()
	out := filepath.Join(dir, filepath.Base(pkg))
	cmd := exec.Command("go", "build", "-o", out, pkg)
	cmd.Env = append(os.Environ(), "GOPROXY=https://goproxy.cn,direct", "GOTOOLCHAIN=auto")
	if b, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("build %s: %v\n%s", pkg, err, b)
	}
	return out
}

// start runs a binary and reads its first stdout line for the listen address.
func start(t *testing.T, bin string, args ...string) *nodeProc {
	t.Helper()
	cmd := exec.Command(bin, args...)
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		t.Fatal(err)
	}
	cmd.Stderr = os.Stderr
	if err := cmd.Start(); err != nil {
		t.Fatal(err)
	}
	p := &nodeProc{cmd: cmd}
	if sc := bufio.NewScanner(stdout); sc.Scan() {
		if f := strings.Fields(sc.Text()); len(f) >= 2 && f[0] == "LISTEN" {
			p.addr = f[1]
		}
	}
	t.Cleanup(func() { _ = cmd.Process.Kill() })
	return p
}

// inspect dials a gateway's control endpoint and reads its state snapshot.
func inspect(t *testing.T, addr string) InspectReply {
	t.Helper()
	c, err := net.Dial("tcp", addr)
	if err != nil {
		t.Fatal(err)
	}
	peer := NewPeer(c, nil, nil)
	defer peer.Close()
	var out InspectReply
	if err := peer.Call(CmdInspectState, nil, &out, 2*time.Second); err != nil {
		t.Fatal(err)
	}
	return out
}

func TestEndToEndCrossServerBattle(t *testing.T) {
	dir := t.TempDir()
	hub := start(t, build(t, dir, "aegis/cmd/hub"))
	gw1 := start(t, build(t, dir, "aegis/cmd/gateway"), "-hub", hub.addr, "-server", "1")
	gw2 := start(t, build(t, dir, "aegis/cmd/gateway"), "-hub", hub.addr, "-server", "2")
	_ = start(t, build(t, dir, "aegis/cmd/battle"), "-hub", hub.addr, "-id", "battle-0")
	time.Sleep(300 * time.Millisecond) // let registrations land

	p1, p2 := dial(t, gw1.addr), dial(t, gw2.addr)
	defer p1.Close()
	defer p2.Close()

	var r1, r2 SignupReply
	_ = p1.Call(CmdCrossSignupReq, SignupReq{ServerID: 1, PlayerID: 11, Battle: "arena"}, &r1, 2*time.Second)
	_ = p2.Call(CmdCrossSignupReq, SignupReq{ServerID: 2, PlayerID: 22, Battle: "arena"}, &r2, 2*time.Second)
	if !r1.Queued || r2.Match == nil {
		t.Fatalf("match not formed: r1=%+v r2=%+v", r1, r2)
	}

	// Wait for both settlements to land.
	var s1, s2 InspectReply
	deadline := time.Now().Add(5 * time.Second)
	for time.Now().Before(deadline) {
		s1, s2 = inspect(t, gw1.addr), inspect(t, gw2.addr)
		if s1.Total > 0 && s2.Total > 0 {
			break
		}
		time.Sleep(50 * time.Millisecond)
	}

	// 1) Both servers routed their player into the SAME battle instance.
	if s1.Routes[11] == "" || s1.Routes[11] != s2.Routes[22] {
		t.Fatalf("players not routed to one instance: %q vs %q", s1.Routes[11], s2.Routes[22])
	}
	// 2) Each reward landed on its own server, and nowhere else.
	if s1.Balances[11] <= 0 || s2.Balances[22] <= 0 || s1.Balances[22] != 0 || s2.Balances[11] != 0 {
		t.Fatalf("reward on wrong server: %+v / %+v", s1.Balances, s2.Balances)
	}
	// 3) Conservation: credited total equals what the battle minted.
	if want := ParticipationGold*2 + WinnerBonusGold; s1.Total+s2.Total != want {
		t.Fatalf("conservation broken: %d != %d", s1.Total+s2.Total, want)
	}

	// 4) Idempotency: replay the same battle result to the hub, ledger holds.
	replay := BattleResult{BattleID: r2.Match.BattleID, Winner: 1,
		Rewards: []Reward{{ServerID: 1, PlayerID: 11, Gold: 99999}}}
	var ok map[string]bool
	if err := dial(t, hub.addr).Call(CmdBattleResult, replay, &ok, 2*time.Second); err != nil {
		t.Fatal(err)
	}
	if got := inspect(t, gw1.addr).Total; got != s1.Total {
		t.Fatalf("replay changed gw1 ledger: %d != %d", got, s1.Total)
	}
}

func dial(t *testing.T, addr string) *Peer {
	t.Helper()
	c, err := net.Dial("tcp", addr)
	if err != nil {
		t.Fatal(err)
	}
	return NewPeer(c, nil, nil)
}

=== RUN   TestEndToEndCrossServerBattle
--- PASS: TestEndToEndCrossServerBattle (5.38s)
PASS
ok  	aegis/internal/battlecluster	5.4s