《游戏服务端架构·核心系统与契约》2.2 网关路由与连接归属

// file: internal/gwroute/owner.go
// tier: L1
// verify: go test ./internal/gwroute/

// Package gwroute assigns accounts to gateway nodes with weighted rendezvous
// hashing and tracks which node currently owns each account's connection.
package gwroute

import "sort"

// RemoveNode forgets a drained node and drops its ownership records. The
// returned accounts must reconnect and claim on the recomputed node.
func (r *Router) RemoveNode(id string) ([]string, error) {
	r.mu.Lock()
	defer r.mu.Unlock()
	if err := r.removeLocked(id); err != nil {
		return nil, err
	}
	var orphaned []string
	for account, own := range r.owners {
		if own.NodeID == id {
			delete(r.owners, account)
			orphaned = append(orphaned, account)
		}
	}
	sort.Strings(orphaned)
	return orphaned, nil
}

// Failover removes a failed node and reassigns its accounts server-side.
// Ownership tokens change, so messages from the old connection are fenced.
func (r *Router) Failover(id string) (map[string]Owner, error) {
	r.mu.Lock()
	defer r.mu.Unlock()
	if _, err := r.indexLocked(id); err != nil {
		return nil, err
	}
	if len(r.nodes) == 1 {
		return nil, ErrNoNodes
	}
	if err := r.removeLocked(id); err != nil {
		return nil, err
	}
	moved := map[string]Owner{}
	for account, own := range r.owners {
		if own.NodeID != id {
			continue
		}
		target, _ := r.pickLocked(account)
		r.seq++
		next := Owner{NodeID: target, Token: r.seq, Since: r.now()}
		r.owners[account] = next
		moved[account] = next
	}
	return moved, nil
}

// Owner reports the current claim, if any.
func (r *Router) Owner(accountID string) (Owner, bool) {
	r.mu.Lock()
	defer r.mu.Unlock()
	o, ok := r.owners[accountID]
	return o, ok
}

// Validate is the check every message passes before the gateway forwards it.
func (r *Router) Validate(accountID, nodeID string, token uint64) error {
	r.mu.Lock()
	defer r.mu.Unlock()
	o, ok := r.owners[accountID]
	if !ok {
		return ErrNoOwner
	}
	if o.NodeID != nodeID {
		return ErrNotOwner
	}
	if o.Token != token {
		return ErrStaleToken
	}
	return nil
}

func (r *Router) Nodes() []string {
	r.mu.Lock()
	defer r.mu.Unlock()
	ids := make([]string, len(r.nodes))
	for idx, n := range r.nodes {
		ids[idx] = n.id
	}
	return ids
}

// file: internal/gwroute/failover_test.go
// tier: L1
package gwroute

import (
	"errors"
	"fmt"
	"testing"
)

func TestFailoverReassigns(t *testing.T) {
	tests := []struct {
		name      string
		fail      string
		wantErr   error
		wantMoved bool
	}{
		{"failed non-last node", "gw-b", nil, true},
		{"unknown node", "gw-x", ErrUnknownNode, false},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			r := newTestRouter(t)
			before := map[string]Owner{}
			for n := 0; n < 300; n++ {
				acct := fmt.Sprintf("acc-%d", n)
				owner, err := r.Assign(acct)
				if err != nil {
					t.Fatalf("Assign(%s): %v", acct, err)
				}
				before[acct] = owner
			}
			moved, err := r.Failover(tc.fail)
			if !errors.Is(err, tc.wantErr) {
				t.Fatalf("got %v, want %v", err, tc.wantErr)
			}
			if err != nil {
				return
			}
			if tc.wantMoved && len(moved) == 0 {
				t.Fatal("failover moved no accounts")
			}
			for acct, owner := range moved {
				if owner.NodeID == tc.fail {
					t.Fatalf("%s still points at failed node", acct)
				}
				picked, err := r.Pick(acct)
				if err != nil || picked != owner.NodeID {
					t.Fatalf("%s picked %q, owner says %q (%v)", acct, picked, owner.NodeID, err)
				}
				if err := r.Validate(acct, owner.NodeID, owner.Token); err != nil {
					t.Fatalf("%s new ownership rejected: %v", acct, err)
				}
			}
			for acct, owner := range before {
				if owner.NodeID == tc.fail {
					continue
				}
				now, ok := r.Owner(acct)
				if !ok || now.NodeID != owner.NodeID || now.Token != owner.Token {
					t.Fatalf("%s ownership changed although it was not on %s", acct, tc.fail)
				}
			}
		})
	}

	single := New(nil)
	if err := single.AddNode("only", 1); err != nil {
		t.Fatalf("AddNode: %v", err)
	}
	if _, err := single.Failover("only"); !errors.Is(err, ErrNoNodes) {
		t.Fatalf("last-node failover error = %v, want ErrNoNodes", err)
	}
	if len(single.Nodes()) != 1 {
		t.Fatal("failed failover must not remove the last node")
	}
}

$ cd .local/checks/gsarch-lab
$ gofmt -l internal/gwroute
$ go vet ./internal/gwroute/...
$ go test -count=1 ./internal/gwroute/...
ok  	gsarchlab/internal/gwroute