《MMO 服务器开发》4.2 粘性策略与发布期行为

// file: internal/gateway/ring.go
// tier: L1
// verify: go test ./internal/gateway/
package gateway

import (
	"encoding/binary"
	"sort"
	"strconv"
)

// hashBytes 是 FNV-1a 64 位散列，末尾再过一个 splitmix64 收尾函数。
// 收尾是必须的：玩家 ID 是 uint64，小号的高位全是 0，直接对 8 字节做 FNV
// 会让相邻 ID 的散列挤在一起（前导零字节对混合几乎无贡献），环上就退化成
// 「所有小号落同一个节点」。splitmix64 收尾把这点雪崩开。
func hashBytes(b []byte) uint64 {
	const (
		offset64 = 1469598103934665603
		prime64  = 1099511628211
	)
	h := uint64(offset64)
	for _, c := range b {
		h ^= uint64(c)
		h *= prime64
	}
	return mix64(h)
}

// mix64 是 splitmix64 的收尾混合，保证输出对输入的每一位都敏感。
func mix64(x uint64) uint64 {
	x ^= x >> 30
	x *= 0xbf58476d1ce4e5b9
	x ^= x >> 27
	x *= 0x94d049bb133111eb
	x ^= x >> 31
	return x
}

// hashPlayer 把玩家 ID 散成环上的一个点。
func hashPlayer(p PlayerID) uint64 {
	var b [8]byte
	binary.BigEndian.PutUint64(b[:], uint64(p))
	return hashBytes(b[:])
}

// vnodeCount 是每个物理节点的虚拟节点数。虚拟节点越多，环上各节点负责的
// 区间越均匀；160 是经验值，再往上收益递减。
const vnodeCount = 160

type ringPoint struct {
	h    uint64
	node NodeID
}

// Ring 是一致性哈希环。它把「玩家 → 网关」的映射做成纯函数：只要节点集合
// 不变，映射就稳定；节点增减时只有落在被增删节点区间上的玩家会迁移。
type Ring struct {
	points []ringPoint // 按 h 升序
	nodes  map[NodeID]struct{}
}

// NewRing 返回一个空环。
func NewRing() *Ring {
	return &Ring{nodes: make(map[NodeID]struct{})}
}

// Add 把一个物理节点挂到环上（同时挂 vnodeCount 个虚拟节点）。
func (r *Ring) Add(node NodeID) {
	if _, ok := r.nodes[node]; ok {
		return
	}
	r.nodes[node] = struct{}{}
	for i := 0; i < vnodeCount; i++ {
		h := hashBytes([]byte(string(node) + "#" + strconv.Itoa(i)))
		r.points = append(r.points, ringPoint{h: h, node: node})
	}
	sort.Slice(r.points, func(i, j int) bool { return r.points[i].h < r.points[j].h })
}

// Remove 把一个物理节点从环上摘掉（连同它的虚拟节点）。
func (r *Ring) Remove(node NodeID) {
	if _, ok := r.nodes[node]; !ok {
		return
	}
	delete(r.nodes, node)
	kept := r.points[:0]
	for _, p := range r.points {
		if p.node != node {
			kept = append(kept, p)
		}
	}
	r.points = kept
}

// Pick 返回玩家应落在的节点：环上第一个 hash ≥ hash(player) 的点，绕回到头。
func (r *Ring) Pick(p PlayerID) NodeID {
	if len(r.points) == 0 {
		return ""
	}
	h := hashPlayer(p)
	// 手写二分，找第一个 h >= player 的点。
	i := sort.Search(len(r.points), func(i int) bool { return r.points[i].h >= h })
	if i == len(r.points) {
		i = 0
	}
	return r.points[i].node
}

// Nodes 返回环上节点数。
func (r *Ring) Nodes() int { return len(r.nodes) }

// snippet: internal/gateway/ring_test.go 节选
// 摘掉 1/8 节点，统计迁移比例。
ring.Remove("gateway-03")
moved := 0
for i := 0; i < nPlayers; i++ {
	if ring.Pick(PlayerID(i)) != before[PlayerID(i)] {
		moved++
	}
}
// 对照：取模哈希 hash(player) % N，N 从 8 变 7。

// file: internal/gateway/ticket.go
// tier: L1
// verify: go test ./internal/gateway/
package gateway

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"encoding/binary"
	"errors"
)

// 重连票据的失败原因，客户端据此决定是「静默重连」还是「弹登录框」。
var (
	ErrTicketBadMAC  = errors.New("gateway: ticket mac mismatch")
	ErrTicketExpired = errors.New("gateway: ticket expired")
	ErrTicketFormat  = errors.New("gateway: ticket malformed")
)

// IssueTicket 签发一张重连票据。它把「玩家 → 目标节点」这一事实做成一条
// 带 HMAC 的短令牌：客户端拿着它直连目标网关，网关本地校验签名即可放行，
// 不必回查目录——这是「客户端重连票」粘性策略的关键。
func IssueTicket(key []byte, p PlayerID, node NodeID, exp int64) string {
	var head [16]byte
	binary.BigEndian.PutUint64(head[:8], uint64(p))
	binary.BigEndian.PutUint64(head[8:], uint64(exp))
	body := string(head[:]) + string(node)
	mac := hmac.New(sha256.New, key)
	mac.Write([]byte(body))
	sig := mac.Sum(nil)[:16]
	raw := string(head[:]) + string(node) + string(sig)
	return base64.RawURLEncoding.EncodeToString([]byte(raw))
}

// VerifyTicket 校验票据：先验签名，再看是否过期。返回玩家与目标节点。
// 解析从尾部切固定长度，不做分隔符扫描——签名是二进制，可能含任意字节，
// 用分隔符会切错位置。
func VerifyTicket(key []byte, tok string, now int64) (PlayerID, NodeID, error) {
	raw, err := base64.RawURLEncoding.DecodeString(tok)
	if err != nil {
		return 0, "", ErrTicketFormat
	}
	if len(raw) < 16+1+16 { // head(16) + 至少 1 字节节点名 + sig(16)
		return 0, "", ErrTicketFormat
	}
	sig := raw[len(raw)-16:]
	body := raw[:len(raw)-16]
	mac := hmac.New(sha256.New, key)
	mac.Write(body)
	if !hmac.Equal(sig, mac.Sum(nil)[:16]) {
		return 0, "", ErrTicketBadMAC
	}
	p := PlayerID(binary.BigEndian.Uint64(body[:8]))
	exp := int64(binary.BigEndian.Uint64(body[8:16]))
	node := NodeID(body[16:])
	if now > exp {
		return 0, "", ErrTicketExpired
	}
	return p, node, nil
}