170 lines
3.7 KiB
Go
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
|
|
}
|