client.go 6.6 KB

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