Files
go-sms-V2/internal/protocol/cmpp/pool.go
T

170 lines
3.7 KiB
Go

// pool.go CMPP 连接池(Day 32):N 条长连接并行,各自 Run(登录+心跳+自动重连);
// Submit 轮询选路,失败自动换下一连接;Deliver 统一经 OnDeliver 透传。
package cmpp
import (
"context"
"errors"
"sync"
"sync/atomic"
)
// ErrPoolEmpty 池中无可用连接。
var ErrPoolEmpty = errors.New("cmpp: 连接池无可用连接")
// Pool 连接池。
type Pool struct {
cfg Config
clients []*Client
rr atomic.Uint32 // 轮询游标
mu sync.Mutex
started bool
cancel context.CancelFunc
deliverHook func(d *Deliver) // Start 前注入的下发回调
dropHook func(i int, e error) // Start 前注入的断连回调(Day 40:通道日志/告警事件源)
}
// NewPool 构造 size 条连接(1~64)。
// P1 压测优化(09-27):上限 16→64——conn_count=50 此前被静默截断,
// 华为云实测 32 条并发连接可稳定承载;64 为防呆上限。
func NewPool(cfg Config, size int) *Pool {
if size < 1 {
size = 1
}
if size > 64 {
size = 64
}
return &Pool{cfg: cfg, clients: make([]*Client, size)}
}
// OnDeliver 注入下发回调(须在 Start 前调用,池内全部连接生效)。
func (p *Pool) OnDeliver(fn func(d *Deliver)) {
p.mu.Lock()
p.deliverHook = fn
p.mu.Unlock()
for _, c := range p.clients {
if c != nil {
c.OnDeliver = fn
}
}
}
// OnDisconnected 注入断连回调(Day 40,须在 Start 前调用;i 为池内连接序号,0 起)。
// 每条连接失效(网络断/读错/心跳超时)重连前触发一次——通道日志 disconnect 与链路告警的事件源。
func (p *Pool) OnDisconnected(fn func(i int, err error)) {
p.mu.Lock()
p.dropHook = fn
p.mu.Unlock()
for i, c := range p.clients {
if c != nil {
p.hookDrop(i, c)
}
}
}
// hookDrop 为单条连接包装当前 dropHook(捕获池内序号)。
func (p *Pool) hookDrop(i int, c *Client) {
p.mu.Lock()
hook := p.dropHook
p.mu.Unlock()
if hook == nil {
c.OnDisconnected = nil
return
}
c.OnDisconnected = func(err error) { hook(i, err) }
}
// Start 启动全部连接(各连接独立 Run:登录+心跳+断线重连)。
func (p *Pool) Start(ctx context.Context) {
p.mu.Lock()
if p.started {
p.mu.Unlock()
return
}
p.started = true
runCtx, cancel := context.WithCancel(ctx)
p.cancel = cancel
hook := p.deliverHook
p.mu.Unlock()
for i, c := range p.clients {
if c != nil {
continue
}
c = NewClient(p.cfg)
if hook != nil {
c.OnDeliver = hook
}
p.hookDrop(i, c)
p.clients[i] = c
go func(c *Client) { _ = c.Run(runCtx) }(c)
}
}
// Stop 停止全部连接。
func (p *Pool) Stop() {
p.mu.Lock()
cancel := p.cancel
p.started = false
clients := append([]*Client(nil), p.clients...)
p.mu.Unlock()
if cancel != nil {
cancel()
}
for _, c := range clients {
if c != nil {
_ = c.Close()
}
}
}
// healthy 取所有当前已连接的客户端快照。
func (p *Pool) healthy() []*Client {
var out []*Client
for _, c := range p.clients {
if c == nil {
continue
}
c.mu.Lock()
ok := c.conn != nil
c.mu.Unlock()
if ok {
out = append(out, c)
}
}
return out
}
// Healthy 当前可用连接数(测试/监控)。
func (p *Pool) Healthy() int { return len(p.healthy()) }
// Size 池内连接总数(状态视图用)。
func (p *Pool) Size() int {
n := 0
for _, c := range p.clients {
if c != nil {
n++
}
}
return n
}
// Submit 池化提交:轮询选择健康连接;一条失败(发送错/超时)自动换下一条。
func (p *Pool) Submit(req *SubmitReq) (*SubmitResp, error) {
conns := p.healthy()
if len(conns) == 0 {
return nil, ErrPoolEmpty
}
var lastErr error
for i := 0; i < len(conns); i++ {
c := conns[(int(p.rr.Add(1))+i)%len(conns)]
resp, err := c.Submit(req)
if err == nil {
return resp, nil
}
lastErr = err
}
return nil, lastErr
}