// 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 依赖正确性)