《MMO 服务器开发》17.3 机器人客户端与第一组承载数字

// file: cmd/bot/main.go
// tier: B
// verify: go build ./cmd/bot/

// Command bot 是 aegis 自带的机器人客户端。站内没有 k6/wrk/hey，所以自己写。
//
// 两种模式：
//
//	-mode=bench  压测：N 个连接错峰建立，各自登录进世界后连发请求，汇总 QPS 与分位延迟
//	-mode=smoke  冒烟：3 个客户端登录进世界、各自移动，断言「彼此都能看见」
//
// 压测必须错峰连接：macOS 的 kern.ipc.somaxconn 默认只有 128，一次性 dial
// 上千条会被内核直接 RST。
package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"math"
	"os"
	"sort"
	"sync"
	"time"

	"aegis/internal/proto"
)

// Result 是一次压测的汇总，直接落 JSON 供书稿引用。
type Result struct {
	Conns     int     `json:"conns"`
	Requests  int     `json:"requests"`
	Failed    int     `json:"failed_conns"`
	ElapsedMs int64   `json:"elapsed_ms"`
	QPS       float64 `json:"qps"`
	P50Ms     float64 `json:"p50_ms"`
	P90Ms     float64 `json:"p90_ms"`
	P99Ms     float64 `json:"p99_ms"`
	MaxMs     float64 `json:"max_ms"`
	MeanMs    float64 `json:"mean_ms"`
}

func main() {
	addr := flag.String("addr", "127.0.0.1:19001", "网关地址")
	mode := flag.String("mode", "bench", "bench|smoke")
	conns := flag.Int("conns", 200, "并发连接数（bench）")
	reqs := flag.Int("reqs", 10, "每个连接的请求数（bench）")
	stagger := flag.Duration("stagger", 2*time.Second, "连接建立摊开的总时长")
	timeout := flag.Duration("timeout", 15*time.Second, "单次请求读超时")
	out := flag.String("out", "", "结果 JSON 输出路径，留空则打印")
	flag.Parse()

	switch *mode {
	case "smoke":
		if err := runSmoke(*addr, *timeout); err != nil {
			log.Fatalf("smoke failed: %v", err)
		}
	case "bench":
		res := runBench(*addr, *conns, *reqs, *stagger, *timeout)
		buf, _ := json.MarshalIndent(res, "", "  ")
		if *out != "" {
			if err := os.WriteFile(*out, append(buf, '\n'), 0o644); err != nil {
				log.Fatalf("write %s: %v", *out, err)
			}
			fmt.Printf("wrote %s\n", *out)
		}
		fmt.Println(string(buf))
		fmt.Printf("conns=%d reqs=%d ok=%d failed=%d qps=%.0f p50=%.2fms p99=%.2fms\n",
			res.Conns, res.Requests, res.Conns-res.Failed, res.Failed, res.QPS, res.P50Ms, res.P99Ms)
		if res.Failed > 0 {
			os.Exit(1)
		}
	default:
		fmt.Fprintf(os.Stderr, "unknown mode %q\n", *mode)
		os.Exit(2)
	}
}

func runBench(addr string, conns, reqs int, stagger, timeout time.Duration) Result {
	var (
		mu     sync.Mutex
		allLat []float64
		failed int
		step   = stagger / time.Duration(max(conns, 1))
		start  = time.Now()
		wg     sync.WaitGroup
	)
	for i := 0; i < conns; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			time.Sleep(time.Duration(i) * step) // 错峰，绕开 accept backlog 上限
			lat, err := runBot(addr, reqs, timeout)
			mu.Lock()
			defer mu.Unlock()
			if err != nil {
				failed++
				return
			}
			allLat = append(allLat, lat...)
		}(i)
	}
	wg.Wait()
	elapsed := time.Since(start)

	res := Result{Conns: conns, Requests: conns * reqs, Failed: failed, ElapsedMs: elapsed.Milliseconds()}
	sort.Float64s(allLat)
	if len(allLat) > 0 {
		var sum float64
		for _, v := range allLat {
			sum += v
		}
		res.MeanMs = sum / float64(len(allLat))
		res.P50Ms = pct(allLat, 0.50)
		res.P90Ms = pct(allLat, 0.90)
		res.P99Ms = pct(allLat, 0.99)
		res.MaxMs = allLat[len(allLat)-1]
	}
	if res.ElapsedMs > 0 {
		res.QPS = float64(len(allLat)) / (float64(res.ElapsedMs) / 1000.0)
	}
	return res
}

// runBot 走真实路径：dial -> 登录 -> 进世界 -> reqs 次心跳往返，返回每次 RTT。
func runBot(addr string, reqs int, timeout time.Duration) ([]float64, error) {
	c, err := dial(addr, timeout)
	if err != nil {
		return nil, err
	}
	defer c.Close()
	name := fmt.Sprintf("bot-%d-%d", os.Getpid(), time.Now().UnixNano())
	if _, err := c.call(proto.CmdLoginReq, []byte(name), proto.CmdLoginResp); err != nil {
		return nil, err
	}
	if _, err := c.call(proto.CmdEnterWorldReq, nil, proto.CmdEnterWorldResp); err != nil {
		return nil, err
	}
	lat := make([]float64, 0, reqs)
	for i := 0; i < reqs; i++ {
		begin := time.Now()
		if _, err := c.call(proto.CmdHeartbeatReq, nil, proto.CmdHeartbeatResp); err != nil {
			return lat, err
		}
		lat = append(lat, float64(time.Since(begin).Microseconds())/1000.0)
	}
	return lat, nil
}

func pct(sorted []float64, p float64) float64 {
	if len(sorted) == 0 {
		return 0
	}
	idx := int(math.Ceil(p*float64(len(sorted)))) - 1
	if idx < 0 {
		idx = 0
	}
	if idx >= len(sorted) {
		idx = len(sorted) - 1
	}
	return sorted[idx]
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

conns=1000, stagger=5s  →  step = 5ms
机器人 0   在 0ms      发起
机器人 1   在 5ms      发起
机器人 2   在 10ms     发起
...
机器人 999 在 4995ms   发起

{
  "conns": 100,
  "requests": 20000,
  "failed_conns": 0,
  "elapsed_ms": 6330,
  "qps": 3159.55766192733,
  "p50_ms": 26.102,
  "p90_ms": 29.779,
  "p99_ms": 123.732,
  "max_ms": 148.119,
  "mean_ms": 26.834263349999954
}