《游戏服务端架构·品类、状态与拓扑》5.2 网关的职责边界与横向扩展

healthy -> draining -> removed

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

import (
	"crypto/sha256"
	"encoding/binary"
	"errors"
	"fmt"
	"sort"
)

var (
	ErrNoNodes       = errors.New("gateway: no nodes")
	ErrEmptyNode     = errors.New("gateway: empty node id")
	ErrDuplicateNode = errors.New("gateway: duplicate node id")
	ErrNodeNotFound  = errors.New("gateway: node not found")
	ErrNoTarget      = errors.New("gateway: no route target")
)

// Node is a gateway process. Draining keeps existing sessions but refuses new
// routes, so a deploy can move traffic before the process exits.
type Node struct {
	ID       string
	Draining bool
}

// Table is an immutable membership list plus mutable drain flags. Rendezvous
// hashing needs no ring or virtual nodes: a key belongs to the node with the
// highest hash(key, nodeID), and removing a node only moves that node's keys.
type Table struct {
	nodes []Node
}

// New validates membership and sorts it, so two replicas that load the same
// configuration produce the same routes regardless of input order.
func New(nodes []Node) (*Table, error) {
	seen := make(map[string]bool, len(nodes))
	out := make([]Node, 0, len(nodes))
	for _, n := range nodes {
		if n.ID == "" {
			return nil, ErrEmptyNode
		}
		if seen[n.ID] {
			return nil, fmt.Errorf("%w: %s", ErrDuplicateNode, n.ID)
		}
		seen[n.ID] = true
		out = append(out, n)
	}
	if len(out) == 0 {
		return nil, ErrNoNodes
	}
	sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
	return &Table{nodes: out}, nil
}

// Nodes returns a copy for diagnostics.
func (t *Table) Nodes() []Node { return append([]Node(nil), t.nodes...) }

// Drain marks a node unavailable for new routes. It is idempotent.
func (t *Table) Drain(id string) error {
	for i := range t.nodes {
		if t.nodes[i].ID == id {
			t.nodes[i].Draining = true
			return nil
		}
	}
	return fmt.Errorf("%w: %s", ErrNodeNotFound, id)
}

// Remove takes a node out of membership entirely, for permanent loss.
func (t *Table) Remove(id string) error {
	for i := range t.nodes {
		if t.nodes[i].ID == id {
			t.nodes = append(t.nodes[:i], t.nodes[i+1:]...)
			return nil
		}
	}
	return fmt.Errorf("%w: %s", ErrNodeNotFound, id)
}

// rendezvous must avalanche: FNV over nearly identical node IDs clusters
// keys on one node, so the score uses a digest of key and node together.
func rendezvous(key, node string) uint64 {
	sum := sha256.Sum256([]byte(key + "\x00" + node))
	return binary.BigEndian.Uint64(sum[:8])
}

// Pick routes a new connection to a live, non-draining node.
func (t *Table) Pick(key string) (Node, error) { return t.pick(key, "") }

// Reroute picks the best node other than failed. It is used when the previous
// owner died and the session layer has already invalidated the old binding.
func (t *Table) Reroute(key, failed string) (Node, error) { return t.pick(key, failed) }

func (t *Table) pick(key, exclude string) (Node, error) {
	var best Node
	var bestScore uint64
	found := false
	for _, n := range t.nodes {
		if n.Draining || n.ID == exclude {
			continue
		}
		s := rendezvous(key, n.ID)
		if !found || s > bestScore || (s == bestScore && n.ID < best.ID) {
			best, bestScore, found = n, s, true
		}
	}
	if !found {
		return Node{}, ErrNoTarget
	}
	return best, nil
}

// Healthy reports how many nodes can still accept new routes.
func (t *Table) Healthy() int {
	count := 0
	for _, n := range t.nodes {
		if !n.Draining {
			count++
		}
	}
	return count
}

$ cd .local/checks/gsarch-lab
$ gofmt -l internal/gateway
$ go vet ./internal/gateway/
$ go test -count=1 ./internal/gateway/ -v
...
PASS
ok  	gsarchlab/internal/gateway	0.568s