365 lines
9.7 KiB
Go
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 依赖正确性)
|