332 lines
9.3 KiB
Go
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 }
|