client.go 6.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306
  1. package mqttreporter
  2. import (
  3. "context"
  4. "errors"
  5. "maps"
  6. "sync"
  7. "time"
  8. mqtt "github.com/eclipse/paho.mqtt.golang"
  9. "hnyfkj.com.cn/rtu/linux/baseapp"
  10. )
  11. const (
  12. MqttQos0 byte = 0 //// 消息最多送达一次
  13. MqttQos1 byte = 1 //// 消息至少送达一次
  14. MqttQos2 byte = 2 //// 消息恰好送达一次
  15. fastInterval = 1 * time.Second //// 快速检测时间间隔
  16. slowInterval = 5 * time.Second //// 慢速检测时间间隔
  17. )
  18. var (
  19. ErrNotStarted = errors.New("mqtt client not started")
  20. ErrNotConnected = errors.New("mqtt client not connected")
  21. ErrClosed = errors.New("mqtt client is closed, cannot perform operation")
  22. ErrBrokerEmpty = errors.New("mqtt broker is empty")
  23. ErrTopicEmpty = errors.New("mqtt topic is empty")
  24. ErrInvalidQoS = errors.New("mqtt qos is invalid")
  25. ErrNilHandler = errors.New("mqtt message handler is nil")
  26. )
  27. type ClientConfig struct {
  28. Broker string //////////////////// 连接服务器的地址
  29. ClientID string //////////////////// 客户端的唯一标识
  30. Username string //////////////////// 登录服务器的用户
  31. Password string //////////////////// 登录服务器的密码
  32. WillTopic string //////////////////// 遗嘱消息发送主题
  33. WillPayload string //////////////////// 遗嘱消息发送内容
  34. WillQos byte //////////////////// 遗嘱消息质量等级
  35. WillRetained bool //////////////////// 遗嘱消息是否保留
  36. }
  37. type subscription struct {
  38. qos byte
  39. handler mqtt.MessageHandler //////////// 订阅主题消息处理
  40. }
  41. type Client struct {
  42. client mqtt.Client
  43. config ClientConfig
  44. ctx context.Context
  45. cancel context.CancelFunc
  46. done chan struct{}
  47. mu sync.Mutex
  48. subMu sync.Mutex
  49. subs map[string]subscription ////// 订阅主题与处理回调
  50. started bool
  51. closed bool
  52. }
  53. func NewClient(config ClientConfig, ctx context.Context) (*Client, error) {
  54. if config.Broker == "" {
  55. return nil, ErrBrokerEmpty
  56. }
  57. if ctx == nil {
  58. ctx = context.Background()
  59. }
  60. ctx, cancel := context.WithCancel(ctx)
  61. opts := mqtt.NewClientOptions().
  62. AddBroker(config.Broker).
  63. SetUsername(config.Username).SetPassword(config.Password).SetClientID(config.ClientID).
  64. SetConnectRetry(false).SetAutoReconnect(false).SetCleanSession(true).
  65. SetKeepAlive(10 * time.Second).SetPingTimeout(5 * time.Second). // Ping心跳间隔, 超时时间
  66. SetOrderMatters(false)
  67. if config.WillTopic != "" { //////////////////////////////////////// 设置遗嘱消息 /////////
  68. if config.WillQos != MqttQos0 && config.WillQos != MqttQos1 && config.WillQos != MqttQos2 {
  69. cancel()
  70. return nil, ErrInvalidQoS
  71. }
  72. opts = opts.SetWill(config.WillTopic, config.WillPayload, config.WillQos, config.WillRetained)
  73. }
  74. opts.OnConnect = func(c mqtt.Client) {
  75. baseapp.Logger.Infof("[%s] 服务器连接成功", MODULE_NAME)
  76. }
  77. opts.OnConnectionLost = func(c mqtt.Client, err error) {
  78. baseapp.Logger.Warnf("[%s] 服务器连接丢失: %v!", MODULE_NAME, err)
  79. }
  80. return &Client{
  81. client: mqtt.NewClient(opts),
  82. config: config,
  83. ctx: ctx,
  84. cancel: cancel,
  85. done: make(chan struct{}),
  86. subs: make(map[string]subscription),
  87. }, nil
  88. }
  89. func (c *Client) Start() error {
  90. c.mu.Lock()
  91. defer c.mu.Unlock()
  92. if c.closed {
  93. return ErrClosed
  94. }
  95. if c.started {
  96. return nil
  97. }
  98. c.started = true
  99. go c.run()
  100. return nil
  101. }
  102. func (c *Client) run() {
  103. defer func() {
  104. if c.client.IsConnected() {
  105. c.client.Disconnect(250)
  106. }
  107. close(c.done)
  108. }()
  109. for {
  110. // 1, 是否退出
  111. if c.ctx.Err() != nil {
  112. return
  113. }
  114. // 2, 已连接时
  115. if c.client.IsConnected() {
  116. if !c.waitInterval(fastInterval) {
  117. return
  118. }
  119. continue
  120. }
  121. // 3, 尝试连接
  122. baseapp.Logger.Infof("[%s] 尝试连接服务器(%s)...", MODULE_NAME, c.config.Broker)
  123. if err := c.connect(); err != nil {
  124. if c.ctx.Err() != nil {
  125. return
  126. }
  127. baseapp.Logger.Errorf("[%s] 服务器连接失败: %v!!", MODULE_NAME, err)
  128. if !c.waitInterval(slowInterval) {
  129. return
  130. }
  131. continue
  132. }
  133. // 4, 重新订阅
  134. if err := c.resubscribe(); err != nil {
  135. if c.ctx.Err() != nil {
  136. return
  137. }
  138. baseapp.Logger.Errorf("[%s] 恢复订阅失败了: %v!!", MODULE_NAME, err)
  139. c.client.Disconnect(0)
  140. if !c.waitInterval(slowInterval) {
  141. return
  142. }
  143. continue
  144. }
  145. }
  146. }
  147. func (c *Client) waitInterval(d time.Duration) bool {
  148. timer := time.NewTimer(d)
  149. defer timer.Stop()
  150. select {
  151. case <-c.ctx.Done():
  152. return false
  153. case <-timer.C:
  154. return true
  155. }
  156. }
  157. func (c *Client) waitToken(token mqtt.Token) error {
  158. select {
  159. case <-c.ctx.Done():
  160. return c.ctx.Err()
  161. case <-token.Done():
  162. return token.Error()
  163. }
  164. }
  165. func (c *Client) connect() error {
  166. return c.waitToken(c.client.Connect())
  167. }
  168. func (c *Client) resubscribe() error {
  169. c.subMu.Lock()
  170. defer c.subMu.Unlock()
  171. c.mu.Lock()
  172. subs := make(map[string]subscription, len(c.subs))
  173. maps.Copy(subs, c.subs)
  174. c.mu.Unlock()
  175. for topic, sub := range subs {
  176. if c.ctx.Err() != nil {
  177. return c.ctx.Err()
  178. }
  179. if err := c.waitToken(c.client.Subscribe(topic, sub.qos, sub.handler)); err != nil {
  180. return err
  181. }
  182. }
  183. return nil
  184. }
  185. func (c *Client) IsConnected() bool {
  186. c.mu.Lock()
  187. defer c.mu.Unlock()
  188. return !c.closed && c.ctx.Err() == nil && c.client.IsConnected()
  189. }
  190. func (c *Client) checkStateLocked() error {
  191. switch {
  192. case c.closed:
  193. return ErrClosed
  194. case !c.started:
  195. return ErrNotStarted
  196. case c.ctx.Err() != nil:
  197. return c.ctx.Err()
  198. default:
  199. return nil
  200. }
  201. }
  202. func (c *Client) Publish(topic string, qos byte, retained bool, payload any) error {
  203. if topic == "" {
  204. return ErrTopicEmpty
  205. }
  206. if qos != MqttQos0 && qos != MqttQos1 && qos != MqttQos2 {
  207. return ErrInvalidQoS
  208. }
  209. c.mu.Lock()
  210. if err := c.checkStateLocked(); err != nil {
  211. c.mu.Unlock()
  212. return err
  213. }
  214. if !c.client.IsConnected() {
  215. c.mu.Unlock()
  216. return ErrNotConnected
  217. }
  218. token := c.client.Publish(topic, qos, retained, payload)
  219. c.mu.Unlock()
  220. return c.waitToken(token)
  221. }
  222. /*
  223. 消息回调需支持并发调用,并尽快返回,尽量避免耗时或阻塞操作, 此类类任务应交由独立的goroutine或通
  224. 过消息队列来处理,避免阻塞mqtt底层的消息处理。
  225. */
  226. func (c *Client) Subscribe(topic string, qos byte, handler mqtt.MessageHandler) error {
  227. if topic == "" {
  228. return ErrTopicEmpty
  229. }
  230. if qos != MqttQos0 && qos != MqttQos1 && qos != MqttQos2 {
  231. return ErrInvalidQoS
  232. }
  233. if handler == nil {
  234. return ErrNilHandler
  235. }
  236. c.subMu.Lock()
  237. defer c.subMu.Unlock()
  238. c.mu.Lock()
  239. if err := c.checkStateLocked(); err != nil {
  240. c.mu.Unlock()
  241. return err
  242. }
  243. c.subs[topic] = subscription{qos: qos, handler: handler} // 注意: 断线时也允许先登记订阅
  244. if !c.client.IsConnected() {
  245. c.mu.Unlock()
  246. return nil
  247. }
  248. token := c.client.Subscribe(topic, qos, handler)
  249. c.mu.Unlock()
  250. return c.waitToken(token)
  251. }
  252. func (c *Client) Close() {
  253. c.mu.Lock()
  254. if !c.closed {
  255. c.closed = true
  256. c.cancel()
  257. }
  258. started := c.started
  259. c.mu.Unlock()
  260. if started {
  261. <-c.done
  262. }
  263. }