《游戏服务端编程实践》5.2.1 玩家绑定与连接会话

// file: ch05/forward/binding.go
// tier: L1
// verify: go test ./ch05/forward/

package forward

import (
	"errors"
	"sync"
)

// Conn 是网关侧连接；Write 由网络层注入，nil 表示只绑定不发送。
type Conn struct {
	ID        string
	GatewayID string
	Write     func(msg []byte) error
}

type Binding struct {
	AccountID uint64
	PlayerID  uint64
	Conn      *Conn
	Version   uint64
}

// Replaced 记录一次顶替：Binding 是旧绑定，NoticeErr 是通知旧连接的失败。
type Replaced struct {
	Binding   *Binding
	NoticeErr error
}

var (
	ErrNilConn      = errors.New("nil conn")
	ErrConnBound    = errors.New("conn already bound")
	ErrPlayerOnline = errors.New("player already online, use Rebind")
	ErrInvalidOwner = errors.New("account and player are required")
)

// Binder 以 playerID 为连接键；accountID 只用于审计，同一账号允许多个角色在线。
type Binder struct {
	mu       sync.RWMutex
	byConn   map[string]*Binding
	byPlayer map[uint64]*Binding
	versions map[uint64]uint64
	notify   func(old *Binding) error
}

func NewBinder(notify func(old *Binding) error) *Binder {
	return &Binder{byConn: map[string]*Binding{}, byPlayer: map[uint64]*Binding{}, versions: map[uint64]uint64{}, notify: notify}
}

func validate(conn *Conn, accountID, playerID uint64) error {
	if conn == nil || conn.ID == "" {
		return ErrNilConn
	}
	if accountID == 0 || playerID == 0 {
		return ErrInvalidOwner
	}
	return nil
}

// Bind 只用于首次上线；已有绑定必须走 Rebind，避免误顶掉在线连接。
func (b *Binder) Bind(conn *Conn, accountID, playerID uint64) (*Binding, error) {
	if err := validate(conn, accountID, playerID); err != nil {
		return nil, err
	}
	b.mu.Lock()
	defer b.mu.Unlock()
	if _, ok := b.byConn[conn.ID]; ok {
		return nil, ErrConnBound
	}
	if _, ok := b.byPlayer[playerID]; ok {
		return nil, ErrPlayerOnline
	}
	b.versions[playerID]++
	binding := &Binding{AccountID: accountID, PlayerID: playerID, Conn: conn, Version: b.versions[playerID]}
	b.byConn[conn.ID], b.byPlayer[playerID] = binding, binding
	out := *binding
	return &out, nil
}

// Rebind 让新连接顶替旧连接并递增版本；通知旧连接失败不影响新绑定生效。
func (b *Binder) Rebind(conn *Conn, accountID, playerID uint64) (*Replaced, error) {
	if err := validate(conn, accountID, playerID); err != nil {
		return nil, err
	}
	b.mu.Lock()
	if cur, ok := b.byConn[conn.ID]; ok {
		same := cur.AccountID == accountID && cur.PlayerID == playerID
		b.mu.Unlock()
		if same {
			return nil, nil // 同一连接重复注册是幂等的
		}
		return nil, ErrConnBound
	}
	b.versions[playerID]++
	binding := &Binding{AccountID: accountID, PlayerID: playerID, Conn: conn, Version: b.versions[playerID]}
	old := b.byPlayer[playerID]
	if old != nil {
		delete(b.byConn, old.Conn.ID)
	}
	b.byConn[conn.ID], b.byPlayer[playerID] = binding, binding
	var oldCopy *Binding
	if old != nil {
		snapshot := *old
		oldCopy = &snapshot
	}
	b.mu.Unlock()
	res := &Replaced{Binding: oldCopy}
	if oldCopy != nil && b.notify != nil {
		res.NoticeErr = b.notify(oldCopy)
	}
	return res, nil
}

// Unbind 只在 connID 与 version 仍是当前绑定时解绑，迟到回调不会删掉新连接。
func (b *Binder) Unbind(connID string, version uint64) bool {
	b.mu.Lock()
	defer b.mu.Unlock()
	cur, ok := b.byConn[connID]
	if !ok || cur.Version != version {
		return false
	}
	delete(b.byConn, connID)
	if b.byPlayer[cur.PlayerID] == cur {
		delete(b.byPlayer, cur.PlayerID)
	}
	return true
}

func (b *Binder) Lookup(playerID uint64) (*Binding, bool) {
	b.mu.RLock()
	defer b.mu.RUnlock()
	binding, ok := b.byPlayer[playerID]
	if !ok {
		return nil, false
	}
	out := *binding
	return &out, true
}

func (b *Binder) LookupConn(connID string) (*Binding, bool) {
	b.mu.RLock()
	defer b.mu.RUnlock()
	binding, ok := b.byConn[connID]
	if !ok {
		return nil, false
	}
	out := *binding
	return &out, true
}

// file: ch05/forward/binding_test.go
// tier: L1
// verify: go test ./ch05/forward/

package forward

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

func newConn(id string) *Conn { return &Conn{ID: id, GatewayID: "gw-1"} }

func TestRebindSupersedesOldConn(t *testing.T) {
	b := NewBinder(nil)
	first, err := b.Bind(newConn("c1"), 100, 42)
	if err != nil {
		t.Fatal(err)
	}
	res, err := b.Rebind(newConn("c2"), 100, 42)
	if err != nil {
		t.Fatal(err)
	}
	if res.Binding == nil || res.Binding.Conn.ID != "c1" || res.Binding.Version != first.Version {
		t.Fatalf("replaced=%+v", res.Binding)
	}
	cur, ok := b.Lookup(42)
	if !ok || cur.Conn.ID != "c2" || cur.Version != first.Version+1 {
		t.Fatalf("current=%+v", cur)
	}
	if _, ok := b.LookupConn("c1"); ok {
		t.Fatal("old conn still resolvable")
	}
	if b.Unbind("c1", first.Version) {
		t.Fatal("stale unbind must not remove new binding")
	}
	if cur, ok := b.Lookup(42); !ok || cur.Conn.ID != "c2" {
		t.Fatalf("stale unbind broke new binding: %+v", cur)
	}
	if _, err := b.Bind(newConn("c3"), 100, 42); !errors.Is(err, ErrPlayerOnline) {
		t.Fatalf("error=%v, want ErrPlayerOnline", err)
	}
}

func TestRebindReportsOldConnWriteFailure(t *testing.T) {
	writeErr := errors.New("old conn closed")
	notified := 0
	b := NewBinder(func(old *Binding) error {
		notified++
		return fmt.Errorf("notify %s: %w", old.Conn.ID, writeErr)
	})
	if _, err := b.Bind(newConn("c1"), 100, 42); err != nil {
		t.Fatal(err)
	}
	res, err := b.Rebind(newConn("c2"), 100, 42)
	if err != nil {
		t.Fatalf("rebind must succeed: %v", err)
	}
	if !errors.Is(res.NoticeErr, writeErr) || notified != 1 {
		t.Fatalf("notice=%v notified=%d", res.NoticeErr, notified)
	}
	if cur, _ := b.Lookup(42); cur == nil || cur.Conn.ID != "c2" {
		t.Fatalf("current=%+v, want c2", cur)
	}
}

func TestConcurrentRebindKeepsSingleWinner(t *testing.T) {
	b := NewBinder(nil)
	if _, err := b.Bind(newConn("c0"), 100, 42); err != nil {
		t.Fatal(err)
	}
	const n = 32
	var wg sync.WaitGroup
	versions := make(chan uint64, n)
	for i := 0; i < n; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			res, err := b.Rebind(newConn(fmt.Sprintf("c%d", i+1)), 100, 42)
			if err != nil || res == nil || res.Binding == nil {
				t.Errorf("rebind %d: %+v %v", i, res, err)
				return
			}
			versions <- res.Binding.Version
		}(i)
	}
	wg.Wait()
	close(versions)
	seen := map[uint64]bool{}
	for v := range versions {
		if seen[v] {
			t.Fatalf("duplicate version %d", v)
		}
		seen[v] = true
	}
	if len(seen) != n {
		t.Fatalf("versions=%d, want %d", len(seen), n)
	}
	cur, ok := b.Lookup(42)
	if !ok || cur.Version != uint64(n+1) {
		t.Fatalf("current=%+v, want version %d", cur, n+1)
	}
	b.mu.RLock()
	connCount := len(b.byConn)
	b.mu.RUnlock()
	if connCount != 1 {
		t.Fatalf("indexed conns=%d, want 1", connCount)
	}
}

cd .local/checks/gs-practice-lab && gofmt -l ch05/forward && go vet ./ch05/forward/ && go test ./ch05/forward/ -count=1 -race

ok  	gspractice/ch05/forward	1.626s