Files
go-sms-V2/cmd/cmppbench/main.go
T

332 lines
9.3 KiB
Go

// cmd/cmppbench/main.go CMPP 压力测试:随机 1[3-9] 手机号,大批量提交(默认 1 万条),
// 测每秒提交峰值 TPS 与延迟分布——为后续性能限流规则准备基线数据。
// 虚拟测试通道,不产生真实下发费用。
//
// 用法(压峰值): go run ./cmd/cmppbench -addr host:7890 -sp xx -secret xx \
//
// -count 10000 -links 4 -concurrency 8 -csv bench-1w.csv
//
// 限速阶梯(-rate N 条/s)配合递增 rate 可绘容量曲线、找网关限流拐点。
package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"log"
"math/rand"
"os"
"os/signal"
"sort"
"sync"
"sync/atomic"
"syscall"
"time"
"go-sms/internal/protocol/cmpp"
)
// rec 一笔提交的完整结果(CSV/统计数据源)。
type rec struct {
Ts time.Time // 发送时刻
Mobile string
MsgID uint64
Result uint8
Latency time.Duration // 提交→Submit_Resp
Err string
}
// Matency 延迟毫秒(rec 辅助)。
func (r rec) Matency() float64 { return float64(r.Latency.Microseconds()) / 1000 }
func main() {
log.SetFlags(log.LstdFlags)
addr := flag.String("addr", "", "网关地址 host:port(必填)")
sp := flag.String("sp", "", "企业代码 SourceAddr ≤6B(必填)")
secret := flag.String("secret", "", "共享密钥(必填)")
src := flag.String("src", "", "源号码 SrcID(默认=sp)")
service := flag.String("service", "TEST", "Service_Id ≤10B")
feeCode := flag.String("feecode", "", "FeeCode 6B(默认全 0)")
content := flag.String("content", "bench", "短信内容(ASCII 原样/中文 GBK)")
links := flag.Int("links", 4, "连接池连接数 1~16")
conc := flag.Int("concurrency", 8, "并发提交 goroutine 数(即最大在途窗口)")
count := flag.Int("count", 10000, "总提交条数")
rate := flag.Int("rate", 0, "限速 条/s(0=不限速压峰值)")
duration := flag.Duration("duration", 10*time.Minute, "安全兜底时长")
expectReceipt := flag.Int("expect-receipt", 0, "验收模式:等待收到≥N 条 CMPP Deliver 回执再退出(0=不等;超时=duration)")
receiptWait := flag.Duration("receipt-wait", 30*time.Second, "expect-receipt 等待窗口(发送完成后起算)")
csvPath := flag.String("csv", "", "CSV 输出路径(默认 bench-<时间戳>.csv)")
seed := flag.Int64("seed", 1, "随机种子(同种子号码序列可复现)")
flag.Parse()
if *addr == "" || *sp == "" || *secret == "" {
log.Fatal("[压测] -addr/-sp/-secret 必填")
}
srcID := *src
if srcID == "" {
srcID = *sp
}
body, msgFmt, err := cmpp.EncodeContent(*content)
if err != nil {
log.Fatalf("[压测] 内容编码: %v", err)
}
if len(body) > 140 {
log.Fatalf("[压测] 内容 %d 字节超 140(CMPP 2.0 Msg_Length 1B)", len(body))
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// Ctrl-C 可中断:已发部分照常输出汇总。
go func() {
sig := make(chan os.Signal, 1)
signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
<-sig
log.Println("[压测] 收到中断信号,停止发送并汇总已发部分")
cancel()
}()
pool := cmpp.NewPool(cmpp.Config{Addr: *addr, SourceAddr: *sp, Secret: *secret}, *links)
var deliverN atomic.Int64
pool.OnDeliver(func(d *cmpp.Deliver) { deliverN.Add(1) })
pool.Start(ctx)
// 等全部连接就绪(最多 15s)。
readyDeadline := time.Now().Add(15 * time.Second)
for pool.Healthy() < *links && time.Now().Before(readyDeadline) {
time.Sleep(100 * time.Millisecond)
}
if pool.Healthy() == 0 {
pool.Stop()
log.Fatal("[压测] 15s 内无连接就绪,退出")
}
log.Printf("[压测] 就绪 连接=%d/%d 并发=%d 总量=%d 限速=%d/s 内容=%d字节 fmt=0x%02x(纯 CMPP 2.0)",
pool.Healthy(), *links, *conc, *count, *rate, len(body), msgFmt)
// 限速令牌(rate>0):每秒放 rate 个。
var tokenCh chan struct{}
if *rate > 0 {
tokenCh = make(chan struct{}, *rate*2)
go func() {
t := time.NewTicker(time.Second)
defer t.Stop()
for i := 0; i < *rate; i++ {
select {
case tokenCh <- struct{}{}:
default:
}
}
for {
select {
case <-ctx.Done():
return
case <-t.C:
for i := 0; i < *rate; i++ {
select {
case tokenCh <- struct{}{}:
default:
}
}
}
}
}()
}
var (
issued atomic.Int64 // 已领取序号(1..count)
doneN atomic.Int64 // 已完成(含失败)
mu sync.Mutex
recs = make([]rec, 0, *count)
bucket = map[int64]int{} // 发送秒 → 条数(峰值 TPS 分桶)
startT = time.Now()
)
doneCh := make(chan struct{})
// 进度打点:每 5s。
go func() {
t := time.NewTicker(5 * time.Second)
defer t.Stop()
var last int64
for {
select {
case <-doneCh:
return
case <-t.C:
d := doneN.Load()
log.Printf("[进度] 完成 %d/%d(近5s %d/s) 健康=%d 回执=%d",
d, *count, (d-last)/5, pool.Healthy(), deliverN.Load())
last = d
}
}
}()
var wg sync.WaitGroup
for w := 0; w < *conc; w++ {
wg.Add(1)
go func(wid int) {
defer wg.Done()
rng := rand.New(rand.NewSource(*seed + int64(wid)))
for {
if ctx.Err() != nil {
return
}
if int(issued.Add(1)) > *count {
return
}
if tokenCh != nil {
select {
case <-tokenCh:
case <-ctx.Done():
return
}
}
mobile := randMobile(rng)
start := time.Now()
resp, err := pool.Submit(&cmpp.SubmitReq{
ServiceID: *service, MsgFmt: msgFmt, MsgSrc: *sp,
FeeType: "01", FeeCode: *feeCode, SrcID: srcID,
DestTerminalIDs: []string{mobile},
Content: body, RegisteredDelivery: 1,
})
lat := time.Since(start)
r := rec{Ts: start, Mobile: mobile, Latency: lat}
if err != nil {
r.Err = err.Error()
} else {
r.MsgID, r.Result = resp.MsgID, resp.Result
}
mu.Lock()
recs = append(recs, r)
bucket[start.Unix()]++
mu.Unlock()
doneN.Add(1)
}
}(w)
}
// 兜底:duration 到期停止发送。
go func() {
select {
case <-time.After(*duration):
log.Printf("[压测] 兜底时长 %s 到期,停止发送", *duration)
cancel()
case <-ctx.Done():
}
}()
wg.Wait()
// Day 61:-expect-receipt 验收模式:发送完成后保持连接等待 Deliver 回执
// (提交→上游→回执→平台终态→PushDeliver 全链端到端验收)。
if *expectReceipt > 0 {
deadline := time.Now().Add(*receiptWait)
for deliverN.Load() < int64(*expectReceipt) && time.Now().Before(deadline) {
time.Sleep(200 * time.Millisecond)
}
}
elapsed := time.Since(startT)
close(doneCh)
pool.Stop()
delivers := deliverN.Load()
if *expectReceipt > 0 && delivers < int64(*expectReceipt) {
log.Printf("[验收] 回执 %d 条 < 期望 %d 条(P0.5 全链验收失败)", delivers, *expectReceipt)
os.Exit(2)
}
if *expectReceipt > 0 {
log.Printf("[验收] 回执 %d 条 ≥ 期望 %d 条(P0.5 全链验收通过:Submit→上游→回执→终态→Deliver)", delivers, *expectReceipt)
}
// ---- 统计汇总 ----
mu.Lock()
total := len(recs)
var okN, failSend int
failResult := map[uint8]int{}
lats := make([]float64, 0, total)
peak := 0
for _, r := range recs {
if r.Err != "" {
failSend++
continue
}
if r.Result != 0 {
failResult[r.Result]++
continue
}
okN++
lats = append(lats, r.Matency())
}
for _, n := range bucket {
if n > peak {
peak = n
}
}
if *csvPath == "" {
*csvPath = fmt.Sprintf("bench-%s.csv", time.Now().Format("0102-150405"))
}
writeCSV(*csvPath, recs)
mu.Unlock()
avg := float64(total) / elapsed.Seconds()
sort.Float64s(lats)
pct := func(p float64) float64 {
if len(lats) == 0 {
return 0
}
i := int(float64(len(lats)) * p)
if i >= len(lats) {
i = len(lats) - 1
}
return lats[i]
}
maxMs := float64(0)
if len(lats) > 0 {
maxMs = lats[len(lats)-1]
}
failN := total - okN
summary := map[string]any{
"total": total, "ok": okN, "fail": failN,
"fail_send": failSend, "fail_result": failResult,
"peak_tps": peak, "avg_tps": round2(avg),
"p50_ms": round2(pct(0.50)), "p90_ms": round2(pct(0.90)),
"p99_ms": round2(pct(0.99)), "max_ms": round2(maxMs),
"deliver": delivers, "elapsed_s": round2(elapsed.Seconds()),
"links": *links, "concurrency": *conc, "rate_limit": *rate,
}
jb, _ := json.Marshal(summary)
log.Printf("[汇总] 总量=%d 成功=%d 失败=%d(发送错=%d result≠0=%v) 峰值TPS=%d 均值TPS=%.1f 延迟p50/p90/p99/max=%.1f/%.1f/%.1f/%.1fms 耗时=%s 回执=%d",
total, okN, failN, failSend, failResult, peak, avg,
pct(0.50), pct(0.90), pct(0.99), maxMs, elapsed.Round(time.Millisecond), delivers)
log.Printf("[摘要JSON] %s", jb)
log.Printf("[产物] CSV=%s(%d 行)", *csvPath, total)
}
// randMobile 随机 11 位手机号:1[3-9] + 10 位数字。
func randMobile(rng *rand.Rand) string {
b := make([]byte, 11)
b[0] = '1'
b[1] = byte('3' + rng.Intn(7))
for i := 2; i < 11; i++ {
b[i] = byte('0' + rng.Intn(10))
}
return string(b)
}
func writeCSV(path string, recs []rec) {
f, err := os.Create(path)
if err != nil {
log.Printf("[产物] CSV 创建失败: %v", err)
return
}
defer func() { _ = f.Close() }()
_, _ = f.WriteString("ts,mobile,msg_id,result,latency_ms,error\n")
for _, r := range recs {
errStr := r.Err
if errStr == "" && r.Result != 0 {
errStr = fmt.Sprintf("result=%d", r.Result)
}
_, _ = fmt.Fprintf(f, "%s,%s,%d,%d,%.3f,%s\n",
r.Ts.Format("15:04:05.000"), r.Mobile, r.MsgID, r.Result, r.Matency(), errStr)
}
}
func round2(v float64) float64 { return float64(int(v*100+0.5)) / 100 }