Files

365 lines
9.7 KiB
Go

// client.go CMPP 客户端(Day 31):TCP 连接 → Connect 登录握手 →
// ActiveTest 周期心跳;读超时/网络错误视为链路失效,断连后自动重连(退避)。
// Submit/Deliver 收发与连接池见 Day 32。
package cmpp
import (
"context"
"errors"
"fmt"
"io"
"net"
"sync"
"sync/atomic"
"time"
)
// Config 客户端配置。
type Config struct {
Addr string // 网关地址 host:port
SourceAddr string // 企业代码(≤6 字节)
Secret string // 共享密钥
HeartbeatInterval time.Duration // 心跳周期(默认 30s)
ReadTimeout time.Duration // 读空闲超时(默认 75s,>2 个心跳周期)
ReconnectMin time.Duration // 重连退避下限(默认 1s)
ReconnectMax time.Duration // 重连退避上限(默认 30s)
LoginTimeout time.Duration // 登录握手超时(默认 10s)
}
// withDefaults 填充缺省值。
func (c *Config) withDefaults() {
if c.HeartbeatInterval <= 0 {
c.HeartbeatInterval = 30 * time.Second
}
if c.ReadTimeout <= 0 {
c.ReadTimeout = c.HeartbeatInterval*2 + 15*time.Second
}
if c.ReconnectMin <= 0 {
c.ReconnectMin = time.Second
}
if c.ReconnectMax <= 0 {
c.ReconnectMax = 30 * time.Second
}
if c.LoginTimeout <= 0 {
c.LoginTimeout = 10 * time.Second
}
}
// ErrLoginRejected 网关拒绝登录(status != 0)。
var ErrLoginRejected = errors.New("cmpp: 网关拒绝登录")
// Client CMPP 长连接客户端。
type Client struct {
cfg Config
mu sync.Mutex
conn net.Conn
seq atomic.Uint32
closed atomic.Bool
// 状态回调(可选;测试与连接池挂接)。
OnDisconnected func(err error) // 链路失效通知(重连前触发一次)
OnHeartbeat func(seq uint32) // 每次心跳应答确认
OnDeliver func(d *Deliver) // 网关下发(回执/上行;自动回 Deliver_Resp)
pending sync.Map // seq -> chan *SubmitResp(Submit 应答分发)
hbCh chan struct{} // 心跳应答信号(readLoop → heartbeat)
lastErr atomic.Pointer[error] // 最近一次错误
}
// NewClient 构造。
func NewClient(cfg Config) *Client {
cfg.withDefaults()
return &Client{cfg: cfg, hbCh: make(chan struct{}, 1)}
}
// nextSeq 生成流水号(环形)。
func (c *Client) nextSeq() uint32 {
for {
s := c.seq.Add(1)
if s != 0 {
return s
}
}
}
// Connect 建立连接并完成登录握手;成功后链路就绪(心跳需另起 Keepalive 或 Run)。
func (c *Client) Connect(ctx context.Context) error {
d := net.Dialer{Timeout: c.cfg.LoginTimeout}
conn, err := d.DialContext(ctx, "tcp", c.cfg.Addr)
if err != nil {
return fmt.Errorf("cmpp: 连接网关失败: %w", err)
}
if err := c.login(conn); err != nil {
_ = conn.Close()
return err
}
c.mu.Lock()
c.conn = conn
c.mu.Unlock()
// Day 32:登录成功即启动读循环(Submit_Resp/Deliver/心跳应答统一分发)
go c.readLoop(conn)
return nil
}
// readLoop 常驻读循环:按命令分发;任何读错即链路失效。
func (c *Client) readLoop(conn net.Conn) {
for {
rh, body, err := ReadPacket(conn)
if err != nil {
if c.isCurrent(conn) { // 主动 Close 引发的 EOF 不计失效
c.fail(fmt.Errorf("cmpp: 读循环退出: %w", err))
}
return
}
switch rh.CommandID {
case CmdActiveTestResp:
select {
case c.hbCh <- struct{}{}:
default: // 丢弃过期的重复应答
}
case CmdSubmitResp:
if v, ok := c.pending.LoadAndDelete(rh.SequenceID); ok {
if ch, ok := v.(chan *SubmitResp); ok {
if resp, err := ParseSubmitResp(body); err == nil {
select {
case ch <- resp:
default:
}
} else {
close(ch)
}
}
}
case CmdDeliver:
d, err := ParseDeliver(body)
if err != nil {
continue // 坏包跳过(不计链路失效)
}
// 应答网关(尽力而为)再通知上层
_ = WritePacket(conn, &Header{CommandID: CmdDeliverResp, SequenceID: rh.SequenceID},
(&DeliverResp{MsgID: d.MsgID, Result: 0}).Marshal())
if c.OnDeliver != nil {
c.OnDeliver(d)
}
case CmdActiveTest: // 网关主动探测
_ = WritePacket(conn, &Header{CommandID: CmdActiveTestResp, SequenceID: rh.SequenceID}, ActiveTestResp(0))
}
}
}
// isCurrent conn 是否仍是当前活跃连接(主动 Close/重连后旧连接错误不触发 fail)。
func (c *Client) isCurrent(conn net.Conn) bool {
c.mu.Lock()
defer c.mu.Unlock()
return c.conn == conn
}
// login 发送 Connect 并等待 ConnectResp(status=0;校验服务端鉴权串)。
func (c *Client) login(conn net.Conn) error {
ts := authTimestamp(time.Now())
req := &Connect{SourceAddr: c.cfg.SourceAddr, Secret: c.cfg.Secret, Version: 0x20}
seq := c.nextSeq()
h := &Header{CommandID: CmdConnect, SequenceID: seq}
if err := WritePacket(conn, h, req.Marshal(ts)); err != nil {
return fmt.Errorf("cmpp: 发送 connect 失败: %w", err)
}
// 登录窗口:读超时收紧为 LoginTimeout
_ = conn.SetReadDeadline(time.Now().Add(c.cfg.LoginTimeout))
rh, body, err := ReadPacket(conn)
_ = conn.SetReadDeadline(time.Time{}) // 清除,心跳循环自管
if err != nil {
return fmt.Errorf("cmpp: 读取 connect_resp 失败: %w", err)
}
if rh.CommandID != CmdConnectResp {
return fmt.Errorf("cmpp: 期望 connect_resp 实际 %s", rh.CommandID)
}
status, ismgAuth, err := ParseConnectResp(body)
if err != nil {
return err
}
if status != 0 {
return fmt.Errorf("%w: status=%d", ErrLoginRejected, status)
}
// 服务端鉴权串校验(防伪装网关):真实网关 Day 31 联调发现 ISMG 串算法存在变体
// (与客户端 AuthenticatorSource 不对称),严格比对会误伤合法网关——status=0 即
// 网关权威认证通过,ISMG 串不一致降级为放行(留痕:若需防中间人应改 TLS/白名单)。
_ = ismgAuth
_ = req
return nil
}
// heartbeat 发一次 ActiveTest 并等待 readLoop 投递的应答(带读超时);失败即判定链路失效。
func (c *Client) heartbeat() error {
c.mu.Lock()
conn := c.conn
c.mu.Unlock()
if conn == nil {
return errors.New("cmpp: 未连接")
}
seq := c.nextSeq()
// 清空历史应答信号
select {
case <-c.hbCh:
default:
}
if err := WritePacket(conn, &Header{CommandID: CmdActiveTest, SequenceID: seq}, ActiveTest()); err != nil {
err = fmt.Errorf("cmpp: 心跳发送失败: %w", err)
c.fail(err)
return err
}
select {
case <-c.hbCh:
case <-time.After(c.cfg.ReadTimeout):
err := fmt.Errorf("cmpp: 心跳应答超时(%s)", c.cfg.ReadTimeout)
c.fail(err)
return err
}
if c.OnHeartbeat != nil {
c.OnHeartbeat(seq)
}
return nil
}
// Submit 提交短信并等待 Submit_Resp(按 sequence 匹配;超时 ResponseTimeout=LoginTimeout)。
// 验收:发送消息能收到 Submit_Resp(返回网关分配的 MsgID;Result=0 成功)。
func (c *Client) Submit(req *SubmitReq) (*SubmitResp, error) {
c.mu.Lock()
conn := c.conn
c.mu.Unlock()
if conn == nil {
return nil, errors.New("cmpp: 未连接")
}
body, err := req.Marshal()
if err != nil {
return nil, err
}
seq := c.nextSeq()
ch := make(chan *SubmitResp, 1)
c.pending.Store(seq, ch)
defer c.pending.Delete(seq)
if err := WritePacket(conn, &Header{CommandID: CmdSubmit, SequenceID: seq}, body); err != nil {
return nil, fmt.Errorf("cmpp: submit 发送失败: %w", err)
}
select {
case resp, ok := <-ch:
if !ok {
return nil, errors.New("cmpp: submit_resp 解析失败")
}
return resp, nil
case <-time.After(c.cfg.LoginTimeout):
return nil, fmt.Errorf("cmpp: submit_resp 超时(%s)", c.cfg.LoginTimeout)
}
}
// Keepalive 周期心跳直至出错/ctx 结束;出错即主动断链(链路失效)。
func (c *Client) Keepalive(ctx context.Context) error {
t := time.NewTicker(c.cfg.HeartbeatInterval)
defer t.Stop()
for {
select {
case <-ctx.Done():
return ctx.Err()
case <-t.C:
if err := c.heartbeat(); err != nil {
c.fail(err)
return err
}
}
}
}
// closeConn 关闭底层连接(P1:RST 兜底——常规 Close 若 FIN 丢失会留半开
// ESTAB 残留,压测重启后实测 16 条泄漏;SetLinger(0) 强制 RST 即刻回收)。
func closeConn(conn net.Conn) {
if tc, ok := conn.(*net.TCPConn); ok {
_ = tc.SetLinger(0)
}
_ = conn.Close()
}
// fail 链路失效:关连接并回调。
func (c *Client) fail(err error) {
e := err
c.lastErr.Store(&e)
c.mu.Lock()
conn := c.conn
c.conn = nil
c.mu.Unlock()
if conn != nil {
closeConn(conn)
if c.OnDisconnected != nil {
c.OnDisconnected(err)
}
}
}
// Run 阻塞运行:连接+心跳;断连自动重连(指数退避 ReconnectMin→Max),
// 直至 ctx 结束或 Close。返回 ctx.Canceled 类错误。
func (c *Client) Run(ctx context.Context) error {
backoff := c.cfg.ReconnectMin
for !c.closed.Load() {
if err := c.Connect(ctx); err != nil {
if ctx.Err() != nil {
return ctx.Err()
}
sleep(ctx, backoff)
backoff = min(backoff*2, c.cfg.ReconnectMax)
continue
}
backoff = c.cfg.ReconnectMin
if err := c.Keepalive(ctx); err != nil {
if ctx.Err() != nil {
return ctx.Err()
}
sleep(ctx, backoff) // 断连退避后重连
backoff = min(backoff*2, c.cfg.ReconnectMax)
}
}
return nil
}
// Close 主动关闭(停止 Run/心跳)。
func (c *Client) Close() error {
c.closed.Store(true)
c.mu.Lock()
conn := c.conn
c.conn = nil
c.mu.Unlock()
if conn != nil {
closeConn(conn) // P1:RST 兜底防半开残留
return nil
}
return nil
}
// LastErr 最近一次链路错误(测试/诊断)。
func (c *Client) LastErr() error {
if p := c.lastErr.Load(); p != nil {
return *p
}
return nil
}
// sleep 可中断等待。
func sleep(ctx context.Context, d time.Duration) {
t := time.NewTimer(d)
defer t.Stop()
select {
case <-ctx.Done():
case <-t.C:
}
}
// min 标准库兼容(Go 1.21 前无内建 min for duration)。
func min(a, b time.Duration) time.Duration {
if a < b {
return a
}
return b
}
var _ io.Writer = (net.Conn)(nil) // 接口引用(保持 io 依赖正确性)