《游戏服务端编程实践》16.2 配置中心与动态参数

// file: ch16/config/config.go
// tier: L1
// verify: go test ./ch16/config/

package config

import (
	"fmt"
	"strings"
	"sync"
	"sync/atomic"
	"time"
	"unicode/utf8"
)

// Config 是运行期可热更的参数集合。
//
// 该结构只包含标量字段，复制即快照。若以后加入 map 或 slice，
// 必须在 Apply 前深拷贝，否则旧快照会被调用方修改。
type Config struct {
	MaxPlayers        int
	ReservedSlots     int
	TickRate          int
	DropRate          float64
	EnableMatchmaking bool
	WelcomeMessage    string
	MaintenanceWindow string
}

// Validate 校验类型、范围与跨字段约束。
func Validate(cfg Config) error {
	if cfg.MaxPlayers < 1 || cfg.MaxPlayers > 100000 {
		return fmt.Errorf("config: max_players %d out of range [1,100000]", cfg.MaxPlayers)
	}
	if cfg.ReservedSlots < 0 || cfg.ReservedSlots >= cfg.MaxPlayers {
		return fmt.Errorf("config: reserved_slots %d must be in [0,max_players)", cfg.ReservedSlots)
	}
	if cfg.TickRate < 1 || cfg.TickRate > 120 {
		return fmt.Errorf("config: tick_rate %d out of range [1,120]", cfg.TickRate)
	}
	if cfg.DropRate < 0 || cfg.DropRate > 1 {
		return fmt.Errorf("config: drop_rate %.3f out of range [0,1]", cfg.DropRate)
	}
	if cfg.EnableMatchmaking && cfg.TickRate < 10 {
		return fmt.Errorf("config: matchmaking requires tick_rate >= 10, got %d", cfg.TickRate)
	}
	if cfg.MaintenanceWindow != "" {
		if _, _, err := parseWindow(cfg.MaintenanceWindow); err != nil {
			return fmt.Errorf("config: maintenance_window %q: %w", cfg.MaintenanceWindow, err)
		}
	}
	if utf8.RuneCountInString(cfg.WelcomeMessage) > 200 {
		return fmt.Errorf("config: welcome_message has %d runes, limit is 200",
			utf8.RuneCountInString(cfg.WelcomeMessage))
	}
	return nil
}

func parseWindow(raw string) (time.Time, time.Time, error) {
	parts := strings.Split(raw, "-")
	if len(parts) != 2 {
		return time.Time{}, time.Time{}, fmt.Errorf("want HH:MM-HH:MM")
	}
	start, err := time.Parse("15:04", strings.TrimSpace(parts[0]))
	if err != nil {
		return time.Time{}, time.Time{}, fmt.Errorf("bad start: %w", err)
	}
	end, err := time.Parse("15:04", strings.TrimSpace(parts[1]))
	if err != nil {
		return time.Time{}, time.Time{}, fmt.Errorf("bad end: %w", err)
	}
	return start, end, nil
}

// Snapshot 是不可变的配置版本。
type Snapshot struct {
	version uint64
	cfg     Config
}

// Version 返回单调递增的版本号。
func (s Snapshot) Version() uint64 { return s.version }

// Config 返回该版本的配置副本。
func (s Snapshot) Config() Config { return s.cfg }

type subscriber struct {
	mu     sync.Mutex
	ch     chan Snapshot
	closed bool
}

func (s *subscriber) push(v Snapshot) {
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.closed {
		return
	}
	select {
	case s.ch <- v:
	default:
		// 慢订阅者只保留最新版本，避免旧配置在队列里堆积。
		select {
		case <-s.ch:
		default:
		}
		select {
		case s.ch <- v:
		default:
		}
	}
}

func (s *subscriber) close() {
	s.mu.Lock()
	defer s.mu.Unlock()
	if !s.closed {
		s.closed = true
		close(s.ch)
	}
}

// Center 持有当前配置快照，并向订阅者推送变更。
type Center struct {
	mu       sync.Mutex
	current  atomic.Pointer[Snapshot]
	validate func(Config) error
	subs     map[uint64]*subscriber
	nextID   uint64
}

// New 用默认校验器创建配置中心，初始版本为 1。
func New(initial Config) (*Center, error) {
	return NewWithValidator(initial, Validate)
}

// NewWithValidator 允许调用方替换校验器，便于不同游戏类型复用。
func NewWithValidator(initial Config, validate func(Config) error) (*Center, error) {
	if validate == nil {
		validate = Validate
	}
	if err := validate(initial); err != nil {
		return nil, fmt.Errorf("config: invalid initial snapshot: %w", err)
	}
	c := &Center{
		validate: validate,
		subs:     make(map[uint64]*subscriber),
	}
	c.current.Store(&Snapshot{version: 1, cfg: initial})
	return c, nil
}

// Apply 校验并原子发布一个新版本，然后通知所有订阅者。
func (c *Center) Apply(cfg Config) (Snapshot, error) {
	if err := c.validate(cfg); err != nil {
		return Snapshot{}, err
	}

	c.mu.Lock()
	defer c.mu.Unlock()

	next := c.current.Load().version + 1
	snap := &Snapshot{version: next, cfg: cfg}
	c.current.Store(snap)
	for _, sub := range c.subs {
		sub.push(*snap)
	}
	return *snap, nil
}

// Snapshot 返回当前版本的不可变快照。
func (c *Center) Snapshot() Snapshot {
	return *c.current.Load()
}

// Config 返回当前配置的值拷贝。
func (c *Center) Config() Config {
	return c.current.Load().cfg
}

// Version 返回当前版本号。
func (c *Center) Version() uint64 {
	return c.current.Load().version
}

// Since 用于拉取兜底：版本落后时返回最新快照，否则 ok 为 false。
func (c *Center) Since(version uint64) (Snapshot, bool) {
	snap := c.Snapshot()
	if snap.version <= version {
		return Snapshot{}, false
	}
	return snap, true
}

// Subscribe 返回更新通道与取消函数。通道只保留最新版本。
func (c *Center) Subscribe() (<-chan Snapshot, func()) {
	c.mu.Lock()
	id := c.nextID
	c.nextID++
	sub := &subscriber{ch: make(chan Snapshot, 1)}
	c.subs[id] = sub
	c.mu.Unlock()

	var once sync.Once
	cancel := func() {
		once.Do(func() {
			c.mu.Lock()
			delete(c.subs, id)
			c.mu.Unlock()
			sub.close()
		})
	}
	return sub.ch, cancel
}

cd .local/checks/gs-practice-lab
gofmt -l ch16/config
go vet ./ch16/config/
go test ./ch16/config/ -count=1