Merge pull request #217 from fhmq/dependabot/go_modules/github.com/eclipse/paho.mqtt.golang-1.5.1

Bump github.com/eclipse/paho.mqtt.golang from 1.5.0 to 1.5.1

.github/workflows/go.yml

@@ -0,0 +1,28 @@
+# This workflow will build a golang project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-go
+
+name: Go
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Set up Go
+      uses: actions/setup-go@v3
+      with:
+        go-version: 1.21
+
+    - name: Build
+      run: go build -v ./...
+
+    - name: Test
+      run: go test -v ./...

.github/workflows/macos.yml

@@ -0,0 +1,18 @@
+name: MacOS build
+
+on: [push, pull_request]
+
+jobs:
+
+  build:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set up Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: 1.21
+
+    - name: Build
+      run: go build -v ./...

.github/workflows/ubuntu.yml

@@ -0,0 +1,18 @@
+name: Ubuntu build
+
+on: [push, pull_request]
+
+jobs:
+    
+    build:
+      runs-on: ubuntu-latest
+      steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.21
+
+      - name: Build
+        run: go build -v ./...

.github/workflows/windows.yml

@@ -0,0 +1,18 @@
+name: Windows build
+
+on: [push, pull_request]
+
+jobs:
+    
+    build:
+      runs-on: windows-latest
+      steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.21
+
+      - name: Build
+        run: go build -v ./...

.gitignore

@@ -1,4 +1,13 @@
 hmq
 log
 log/*
-*.test
+*.test
+# ide
+.idea
+.vscode/settings.json
+.pre-commit-config.yaml
+hmq.exe
+*.sw*
+*.swo
+*.swp
+*.swn

.vscode/settings.json

@@ -1,8 +0,0 @@
-{
-    "go.lintFlags": [
-        "--disable=all",
-        "--enable=errcheck,varcheck,deadcode",
-        "--enable=varcheck",
-        "--enable=deadcode"
-    ]
-}

Dockerfile

@@ -1,12 +1,12 @@
-FROM golang:1.12 as builder
+FROM golang:1.18 as builder
 WORKDIR /go/src/github.com/fhmq/hmq
 COPY . .
 RUN CGO_ENABLED=0 go build -o hmq -a -ldflags '-extldflags "-static"' .
 
 
-FROM alpine:3.8
+FROM alpine:3.17.3
 WORKDIR /
 COPY --from=builder /go/src/github.com/fhmq/hmq/hmq .
 EXPOSE 1883
 
-CMD ["/hmq"]
+ENTRYPOINT ["/hmq"]

README.md

@@ -1,3 +1,4 @@
+
 Free and High Performance MQTT Broker 
 ============
 
@@ -135,7 +136,7 @@ Other Version Of Cluster Based On gRPC: [click here](https://github.com/fhmq/rhm
 
 ## Reference
 
-* Surgermq.(https://github.com/surgemq/surgemq)
+* Surgermq.(https://github.com/zentures/surgemq)
 
 ## Benchmark Tool
 

broker/bridge.go

@@ -5,11 +5,13 @@ import (
 	"go.uber.org/zap"
 )
 
-func (b *Broker) Publish(e *bridge.Elements) {
+func (b *Broker) Publish(e *bridge.Elements) bool {
 	if b.bridgeMQ != nil {
-		err := b.bridgeMQ.Publish(e)
+		cost, err := b.bridgeMQ.Publish(e)
 		if err != nil {
 			log.Error("send message to mq error.", zap.Error(err))
 		}
+		return cost
 	}
+	return false
 }

broker/broker.go

@@ -2,22 +2,24 @@ package broker
 
 import (
 	"crypto/tls"
+	encJson "encoding/json"
+	"errors"
 	"fmt"
 	"net"
 	"net/http"
+	"os"
 	"sync"
 	"time"
 
-	"github.com/fhmq/hmq/plugins/bridge"
-
-	"github.com/fhmq/hmq/plugins/auth"
-
 	"github.com/fhmq/hmq/broker/lib/sessions"
 	"github.com/fhmq/hmq/broker/lib/topics"
+	"github.com/fhmq/hmq/plugins/auth"
+	"github.com/fhmq/hmq/plugins/bridge"
+	"github.com/fhmq/hmq/pool"
 
 	"github.com/eclipse/paho.mqtt.golang/packets"
-	"github.com/fhmq/hmq/pool"
 	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
 	"golang.org/x/net/websocket"
 )
 
@@ -57,6 +59,43 @@ func newMessagePool() []chan *Message {
 	return pool
 }
 
+func getAdditionalLogFields(clientIdentifier string, conn net.Conn, additionalFields ...zapcore.Field) []zapcore.Field {
+	var wsConn *websocket.Conn = nil
+	var wsEnabled bool
+	result := []zapcore.Field{}
+
+	switch conn.(type) {
+	case *websocket.Conn:
+		wsEnabled = true
+		wsConn = conn.(*websocket.Conn)
+	case *net.TCPConn:
+		wsEnabled = false
+	}
+
+	// add optional fields
+	if len(additionalFields) > 0 {
+		result = append(result, additionalFields...)
+	}
+
+	// add client ID
+	result = append(result, zap.String("clientID", clientIdentifier))
+
+	// add remote connection address
+	if !wsEnabled && conn != nil {
+		if conn.RemoteAddr() != nil {
+			result = append(result, zap.String("addr", conn.RemoteAddr().String()))
+		}
+	} else if wsEnabled && wsConn != nil {
+		if wsConn.Request() != nil {
+			result = append(result, zap.String("addr", wsConn.Request().RemoteAddr))
+		} else {
+			result = append(result, zap.String("addr", wsConn.RemoteAddr().String()))
+		}
+	}
+
+	return result
+}
+
 func NewBroker(config *Config) (*Broker, error) {
 	if config == nil {
 		config = DefaultConfig
@@ -92,8 +131,8 @@ func NewBroker(config *Config) (*Broker, error) {
 		b.tlsConfig = tlsconfig
 	}
 
-	b.auth = auth.NewAuth(b.config.Plugin.Auth)
-	b.bridgeMQ = bridge.NewBridgeMQ(b.config.Plugin.Bridge)
+	b.auth = b.config.Plugin.Auth
+	b.bridgeMQ = b.config.Plugin.Bridge
 
 	return b, nil
 }
@@ -110,7 +149,6 @@ func (b *Broker) SubmitWork(clientId string, msg *Message) {
 			ProcessMessage(msg)
 		})
 	}
-
 }
 
 func (b *Broker) Start() {
@@ -123,47 +161,57 @@ func (b *Broker) Start() {
 		go InitHTTPMoniter(b)
 	}
 
-	//listen clinet over tcp
+	// listen client over tcp
 	if b.config.Port != "" {
 		go b.StartClientListening(false)
 	}
 
-	//listen for cluster
+	// listen client over unix
+	if b.config.Port == "" && b.config.UnixFilePath != "" {
+		go b.StartUnixSocketClientListening(b.config.UnixFilePath, true)
+	}
+	// listen client over windows pipe
+	if b.config.Port == "" && b.config.UnixFilePath == "" && b.config.WindowsPipeName != "" {
+		go b.StartPipeSocketListening(b.config.WindowsPipeName, true)
+	}
+
+	// listen for cluster
 	if b.config.Cluster.Port != "" {
 		go b.StartClusterListening()
 	}
 
-	//listen for websocket
+	// listen for websocket
 	if b.config.WsPort != "" {
 		go b.StartWebsocketListening()
 	}
 
-	//listen client over tls
+	// listen client over tls
 	if b.config.TlsPort != "" {
 		go b.StartClientListening(true)
 	}
 
-	//connect on other node in cluster
+	// connect on other node in cluster
 	if b.config.Router != "" {
 		go b.processClusterInfo()
 		b.ConnectToDiscovery()
 	}
-
 }
 
 func (b *Broker) StartWebsocketListening() {
 	path := b.config.WsPath
 	hp := ":" + b.config.WsPort
 	log.Info("Start Websocket Listener on:", zap.String("hp", hp), zap.String("path", path))
-	http.Handle(path, websocket.Handler(b.wsHandler))
+	ws := &websocket.Server{Handler: websocket.Handler(b.wsHandler)}
+	mux := http.NewServeMux()
+	mux.Handle(path, ws)
 	var err error
 	if b.config.WsTLS {
-		err = http.ListenAndServeTLS(hp, b.config.TlsInfo.CertFile, b.config.TlsInfo.KeyFile, nil)
+		err = http.ListenAndServeTLS(hp, b.config.TlsInfo.CertFile, b.config.TlsInfo.KeyFile, mux)
 	} else {
-		err = http.ListenAndServe(hp, nil)
+		err = http.ListenAndServe(hp, mux)
 	}
 	if err != nil {
-		log.Error("ListenAndServe:" + err.Error())
+		log.Error("ListenAndServe" + err.Error())
 		return
 	}
 }
@@ -171,46 +219,121 @@ func (b *Broker) StartWebsocketListening() {
 func (b *Broker) wsHandler(ws *websocket.Conn) {
 	// io.Copy(ws, ws)
 	ws.PayloadType = websocket.BinaryFrame
-	b.handleConnection(CLIENT, ws)
+	err := b.handleConnection(CLIENT, ws)
+	if err != nil {
+		ws.Close()
+	}
 }
 
 func (b *Broker) StartClientListening(Tls bool) {
-	var hp string
 	var err error
 	var l net.Listener
-	if Tls {
-		hp = b.config.TlsHost + ":" + b.config.TlsPort
-		l, err = tls.Listen("tcp", hp, b.tlsConfig)
-		log.Info("Start TLS Listening client on ", zap.String("hp", hp))
-	} else {
-		hp := b.config.Host + ":" + b.config.Port
-		l, err = net.Listen("tcp", hp)
-		log.Info("Start Listening client on ", zap.String("hp", hp))
-	}
-	if err != nil {
+	// Retry listening indefinitely so that specifying IP addresses
+	// (e.g. --host=10.0.0.217) starts working once the IP address is actually
+	// configured on the interface.
+	for {
+		if Tls {
+			hp := b.config.TlsHost + ":" + b.config.TlsPort
+			l, err = tls.Listen("tcp", hp, b.tlsConfig)
+			log.Info("Start TLS Listening client on ", zap.String("hp", hp))
+		} else {
+			hp := b.config.Host + ":" + b.config.Port
+			l, err = net.Listen("tcp", hp)
+			log.Info("Start Listening client on ", zap.String("hp", hp))
+		}
+
+		if err == nil {
+			break // successfully listening
+		}
+
 		log.Error("Error listening on ", zap.Error(err))
-		return
+		time.Sleep(1 * time.Second)
 	}
+
 	tmpDelay := 10 * ACCEPT_MIN_SLEEP
 	for {
 		conn, err := l.Accept()
 		if err != nil {
 			if ne, ok := err.(net.Error); ok && ne.Temporary() {
-				log.Error("Temporary Client Accept Error(%v), sleeping %dms",
-					zap.Error(ne), zap.Duration("sleeping", tmpDelay/time.Millisecond))
+				log.Error(
+					"Temporary Client Accept Error(%v), sleeping %dms",
+					zap.Error(ne),
+					zap.Duration("sleeping", tmpDelay/time.Millisecond),
+				)
+
 				time.Sleep(tmpDelay)
 				tmpDelay *= 2
 				if tmpDelay > ACCEPT_MAX_SLEEP {
 					tmpDelay = ACCEPT_MAX_SLEEP
 				}
 			} else {
-				log.Error("Accept error: %v", zap.Error(err))
+				log.Error("Accept error", zap.Error(err))
 			}
 			continue
 		}
-		tmpDelay = ACCEPT_MIN_SLEEP
-		go b.handleConnection(CLIENT, conn)
 
+		tmpDelay = ACCEPT_MIN_SLEEP
+		go func() {
+			err := b.handleConnection(CLIENT, conn)
+			if err != nil {
+				conn.Close()
+			}
+		}()
+	}
+}
+
+func (b *Broker) StartUnixSocketClientListening(socketPath string, unixSocket bool) {
+	var err error
+	var l net.Listener
+	for {
+		if unixSocket {
+			if FileExist(socketPath) {
+				err = os.Remove(socketPath)
+				if err != nil {
+					log.Error("Remove Unix socketPath ", zap.Error(err))
+				}
+			}
+			conn, _ := net.ResolveUnixAddr("unix", socketPath)
+			l, err = net.ListenUnix("unix", conn)
+			log.Info("Start Listening client on Unix socket", zap.String("socketPath", socketPath))
+		}
+		if err == nil {
+			break // successfully listening
+		}
+
+		log.Error("Error listening on ", zap.Error(err))
+		time.Sleep(1 * time.Second)
+	}
+
+	tmpDelay := 10 * ACCEPT_MIN_SLEEP
+	for {
+		conn, err := l.Accept()
+		if err != nil {
+			if ne, ok := err.(net.Error); ok && ne.Temporary() {
+				log.Error(
+					"Temporary Client Accept Error(%v), sleeping %dms",
+					zap.Error(ne),
+					zap.Duration("sleeping", tmpDelay/time.Millisecond),
+				)
+
+				time.Sleep(tmpDelay)
+				tmpDelay *= 2
+				if tmpDelay > ACCEPT_MAX_SLEEP {
+					tmpDelay = ACCEPT_MAX_SLEEP
+				}
+			} else {
+				log.Error("Accept error", zap.Error(err))
+			}
+			continue
+		}
+
+		tmpDelay = ACCEPT_MIN_SLEEP
+		go func() {
+			err := b.handleConnection(CLIENT, conn)
+			if err != nil {
+				conn.Close()
+			}
+		}()
 	}
 }
 
@@ -220,7 +343,7 @@ func (b *Broker) StartClusterListening() {
 
 	l, e := net.Listen("tcp", hp)
 	if e != nil {
-		log.Error("Error listening on ", zap.Error(e))
+		log.Error("Error listening on", zap.Error(e))
 		return
 	}
 
@@ -229,70 +352,82 @@ func (b *Broker) StartClusterListening() {
 		conn, err := l.Accept()
 		if err != nil {
 			if ne, ok := err.(net.Error); ok && ne.Temporary() {
-				log.Error("Temporary Client Accept Error(%v), sleeping %dms",
-					zap.Error(ne), zap.Duration("sleeping", tmpDelay/time.Millisecond))
+				log.Error(
+					"Temporary Client Accept Error(%v), sleeping %dms",
+					zap.Error(ne),
+					zap.Duration("sleeping", tmpDelay/time.Millisecond),
+				)
+
 				time.Sleep(tmpDelay)
 				tmpDelay *= 2
 				if tmpDelay > ACCEPT_MAX_SLEEP {
 					tmpDelay = ACCEPT_MAX_SLEEP
 				}
 			} else {
-				log.Error("Accept error: %v", zap.Error(err))
+				log.Error("Accept error", zap.Error(err))
 			}
 			continue
 		}
 		tmpDelay = ACCEPT_MIN_SLEEP
 
-		go b.handleConnection(ROUTER, conn)
+		go func() {
+			err := b.handleConnection(ROUTER, conn)
+			if err != nil {
+				conn.Close()
+			}
+		}()
 	}
 }
 
-func (b *Broker) handleConnection(typ int, conn net.Conn) {
-	//process connect packet
-	packet, err := packets.ReadPacket(conn)
-	if err != nil {
-		log.Error("read connect packet error: ", zap.Error(err))
+func (b *Broker) DisConnClientByClientId(clientId string) {
+	cli, loaded := b.clients.LoadAndDelete(clientId)
+	if !loaded {
 		return
 	}
-	if packet == nil {
-		log.Error("received nil packet")
+	conn, success := cli.(*client)
+	if !success {
 		return
 	}
+	conn.Close()
+}
+
+func (b *Broker) handleConnection(typ int, conn net.Conn) error {
+	// process connect packet
+	packet, err := packets.ReadPacket(conn)
+	if err != nil {
+		return errors.New(fmt.Sprintf("read connect packet error:%v", err))
+	}
+	if packet == nil {
+		return errors.New("received nil packet")
+	}
 	msg, ok := packet.(*packets.ConnectPacket)
 	if !ok {
-		log.Error("received msg that was not Connect")
-		return
+		return errors.New("received msg that was not Connect")
 	}
 
-	log.Info("read connect from ", zap.String("clientID", msg.ClientIdentifier))
+	log.Info("read connect from ", getAdditionalLogFields(msg.ClientIdentifier, conn)...)
 
 	connack := packets.NewControlPacket(packets.Connack).(*packets.ConnackPacket)
 	connack.SessionPresent = msg.CleanSession
 	connack.ReturnCode = msg.Validate()
 
 	if connack.ReturnCode != packets.Accepted {
-		err = connack.Write(conn)
-		if err != nil {
-			log.Error("send connack error, ", zap.Error(err), zap.String("clientID", msg.ClientIdentifier))
-			return
+		if err := connack.Write(conn); err != nil {
+			return fmt.Errorf("send connack error:%v,clientID:%v,conn:%v", err, msg.ClientIdentifier, conn)
 		}
-		return
+		return fmt.Errorf("connect packet validate failed with connack.ReturnCode%v", connack.ReturnCode)
 	}
 
-	if typ == CLIENT && !b.CheckConnectAuth(string(msg.ClientIdentifier), string(msg.Username), string(msg.Password)) {
+	if typ == CLIENT && !b.CheckConnectAuth(msg.ClientIdentifier, msg.Username, string(msg.Password)) {
 		connack.ReturnCode = packets.ErrRefusedNotAuthorised
-		err = connack.Write(conn)
-		if err != nil {
-			log.Error("send connack error, ", zap.Error(err), zap.String("clientID", msg.ClientIdentifier))
-			return
+		if err := connack.Write(conn); err != nil {
+			return fmt.Errorf("send connack error:%v,clientID:%v,conn:%v", err, msg.ClientIdentifier, conn)
 		}
-		return
+		return fmt.Errorf("connect packet CheckConnectAuth failed with connack.ReturnCode%v", connack.ReturnCode)
 	}
 
-	err = connack.Write(conn)
-	if err != nil {
-		log.Error("send connack error, ", zap.Error(err), zap.String("clientID", msg.ClientIdentifier))
-		return
+	if err := connack.Write(conn); err != nil {
+		return fmt.Errorf("send connack error:%v,clientID:%v,conn:%v", err, msg.ClientIdentifier, conn)
 	}
 
 	willmsg := packets.NewControlPacket(packets.Publish).(*packets.PublishPacket)
@@ -322,44 +457,54 @@ func (b *Broker) handleConnection(typ int, conn net.Conn) {
 
 	c.init()
 
-	err = b.getSession(c, msg, connack)
-	if err != nil {
-		log.Error("get session error: ", zap.String("clientID", c.info.clientID))
-		return
+	if err := b.getSession(c, msg, connack); err != nil {
+		return fmt.Errorf("get session error:%v,clientID:%v,conn:%v", err, msg.ClientIdentifier, conn)
 	}
 
 	cid := c.info.clientID
 
-	var exist bool
+	var exists bool
 	var old interface{}
 
 	switch typ {
 	case CLIENT:
-		old, exist = b.clients.Load(cid)
-		if exist {
-			log.Warn("client exist, close old...", zap.String("clientID", c.info.clientID))
-			ol, ok := old.(*client)
-			if ok {
+		old, exists = b.clients.Load(cid)
+		if exists {
+			if ol, ok := old.(*client); ok {
+				log.Warn("client exists, close old client", getAdditionalLogFields(ol.info.clientID, ol.conn)...)
 				ol.Close()
 			}
 		}
 		b.clients.Store(cid, c)
 
-		b.OnlineOfflineNotification(cid, true)
+		pubPack := PubPacket{}
+		if willmsg != nil {
+			pubPack.TopicName = info.willMsg.TopicName
+			pubPack.Payload = info.willMsg.Payload
+		}
+
+		pubInfo := Info{
+			ClientID:  info.clientID,
+			Username:  info.username,
+			Password:  info.password,
+			Keepalive: info.keepalive,
+			WillMsg:   pubPack,
+		}
+
+		b.OnlineOfflineNotification(pubInfo, true, c.lastMsgTime)
 		{
 			b.Publish(&bridge.Elements{
-				ClientID:  string(msg.ClientIdentifier),
-				Username:  string(msg.Username),
+				ClientID:  msg.ClientIdentifier,
+				Username:  msg.Username,
 				Action:    bridge.Connect,
 				Timestamp: time.Now().Unix(),
 			})
 		}
 	case ROUTER:
-		old, exist = b.routes.Load(cid)
-		if exist {
-			log.Warn("router exist, close old...")
-			ol, ok := old.(*client)
-			if ok {
+		old, exists = b.routes.Load(cid)
+		if exists {
+			if ol, ok := old.(*client); ok {
+				log.Warn("router exists, close old router", getAdditionalLogFields(ol.info.clientID, ol.conn)...)
 				ol.Close()
 			}
 		}
@@ -367,6 +512,7 @@ func (b *Broker) handleConnection(typ int, conn net.Conn) {
 	}
 
 	c.readLoop()
+	return nil
 }
 
 func (b *Broker) ConnectToDiscovery() {
@@ -376,10 +522,10 @@ func (b *Broker) ConnectToDiscovery() {
 	for {
 		conn, err = net.Dial("tcp", b.config.Router)
 		if err != nil {
-			log.Error("Error trying to connect to route: ", zap.Error(err))
-			log.Debug("Connect to route timeout ,retry...")
+			log.Error("Error trying to connect to route", zap.Error(err))
+			log.Debug("Connect to route timeout, retry...")
 
-			if 0 == tempDelay {
+			if tempDelay == 0 {
 				tempDelay = 1 * time.Second
 			} else {
 				tempDelay *= 2
@@ -393,7 +539,7 @@ func (b *Broker) ConnectToDiscovery() {
 		}
 		break
 	}
-	log.Debug("connect to router success :", zap.String("Router", b.config.Router))
+	log.Debug("connect to router success", zap.String("Router", b.config.Router))
 
 	cid := b.id
 	info := info{
@@ -426,7 +572,6 @@ func (b *Broker) processClusterInfo() {
 		}
 		ProcessMessage(msg)
 	}
-
 }
 
 func (b *Broker) connectRouter(id, addr string) {
@@ -443,15 +588,15 @@ func (b *Broker) connectRouter(id, addr string) {
 
 		conn, err = net.Dial("tcp", addr)
 		if err != nil {
-			log.Error("Error trying to connect to route: ", zap.Error(err))
+			log.Error("Error trying to connect to route", zap.Error(err))
 
 			if retryTimes > 50 {
 				return
 			}
 
-			log.Debug("Connect to route timeout ,retry...")
+			log.Debug("Connect to route timeout, retry...")
 
-			if 0 == timeDelay {
+			if timeDelay == 0 {
 				timeDelay = 1 * time.Second
 			} else {
 				timeDelay *= 2
@@ -489,10 +634,8 @@ func (b *Broker) connectRouter(id, addr string) {
 
 	c.SendConnect()
 
-	// mpool := b.messagePool[fnv1a.HashString64(cid)%MessagePoolNum]
 	go c.readLoop()
 	go c.StartPing()
-
 }
 
 func (b *Broker) checkNodeExist(id, url string) bool {
@@ -505,7 +648,7 @@ func (b *Broker) checkNodeExist(id, url string) bool {
 			return true
 		}
 
-		//skip
+		// skip
 		l, ok := v.(string)
 		if ok {
 			if url == l {
@@ -518,71 +661,70 @@ func (b *Broker) checkNodeExist(id, url string) bool {
 }
 
 func (b *Broker) CheckRemoteExist(remoteID, url string) bool {
-	exist := false
+	exists := false
 	b.remotes.Range(func(key, value interface{}) bool {
 		v, ok := value.(*client)
 		if ok {
 			if v.route.remoteUrl == url {
 				v.route.remoteID = remoteID
-				exist = true
+				exists = true
 				return false
 			}
 		}
 		return true
 	})
-	return exist
+	return exists
 }
 
 func (b *Broker) SendLocalSubsToRouter(c *client) {
 	subInfo := packets.NewControlPacket(packets.Subscribe).(*packets.SubscribePacket)
 	b.clients.Range(func(key, value interface{}) bool {
 		client, ok := value.(*client)
-		if ok {
-			subs := client.subMap
-			for _, sub := range subs {
-				subInfo.Topics = append(subInfo.Topics, sub.topic)
-				subInfo.Qoss = append(subInfo.Qoss, sub.qos)
-			}
+		if !ok {
+			return true
 		}
+
+		client.subMapMu.RLock()
+		defer client.subMapMu.RUnlock()
+
+		subs := client.subMap
+		for _, sub := range subs {
+			subInfo.Topics = append(subInfo.Topics, sub.topic)
+			subInfo.Qoss = append(subInfo.Qoss, sub.qos)
+		}
+
 		return true
 	})
 	if len(subInfo.Topics) > 0 {
-		err := c.WriterPacket(subInfo)
-		if err != nil {
-			log.Error("Send localsubs To Router error :", zap.Error(err))
+		if err := c.WriterPacket(subInfo); err != nil {
+			log.Error("Send localsubs To Router error", zap.Error(err))
 		}
 	}
 }
 
 func (b *Broker) BroadcastInfoMessage(remoteID string, msg *packets.PublishPacket) {
 	b.routes.Range(func(key, value interface{}) bool {
-		r, ok := value.(*client)
-		if ok {
+		if r, ok := value.(*client); ok {
 			if r.route.remoteID == remoteID {
 				return true
 			}
 			r.WriterPacket(msg)
 		}
 		return true
-
 	})
-	// log.Info("BroadcastInfoMessage success ")
 }
 
 func (b *Broker) BroadcastSubOrUnsubMessage(packet packets.ControlPacket) {
-
 	b.routes.Range(func(key, value interface{}) bool {
-		r, ok := value.(*client)
-		if ok {
+		if r, ok := value.(*client); ok {
 			r.WriterPacket(packet)
 		}
 		return true
 	})
-	// log.Info("BroadcastSubscribeMessage remotes: ", s.remotes)
 }
 
 func (b *Broker) removeClient(c *client) {
-	clientId := string(c.info.clientID)
+	clientId := c.info.clientID
 	typ := c.typ
 	switch typ {
 	case CLIENT:
@@ -592,7 +734,6 @@ func (b *Broker) removeClient(c *client) {
 	case REMOTE:
 		b.remotes.Delete(clientId)
 	}
-	// log.Info("delete client ,", clientId)
 }
 
 func (b *Broker) PublishMessage(packet *packets.PublishPacket) {
@@ -602,38 +743,80 @@ func (b *Broker) PublishMessage(packet *packets.PublishPacket) {
 	err := b.topicsMgr.Subscribers([]byte(packet.TopicName), packet.Qos, &subs, &qoss)
 	b.mu.Unlock()
 	if err != nil {
-		log.Error("search sub client error,  ", zap.Error(err))
+		log.Error("search sub client error", zap.Error(err))
 		return
 	}
 
 	for _, sub := range subs {
 		s, ok := sub.(*subscription)
 		if ok {
-			err := s.client.WriterPacket(packet)
-			if err != nil {
-				log.Error("write message error,  ", zap.Error(err))
+			if err := s.client.WriterPacket(packet); err != nil {
+				log.Error("write message error", zap.Error(err))
 			}
 		}
 	}
 }
 
-func (b *Broker) BroadcastUnSubscribe(subs map[string]*subscription) {
-
-	unsub := packets.NewControlPacket(packets.Unsubscribe).(*packets.UnsubscribePacket)
-	for topic, _ := range subs {
-		unsub.Topics = append(unsub.Topics, topic)
+func (b *Broker) PublishMessageByClientId(packet *packets.PublishPacket, clientId string) error {
+	cli, loaded := b.clients.LoadAndDelete(clientId)
+	if !loaded {
+		return fmt.Errorf("clientId %s not connected", clientId)
 	}
-
-	if len(unsub.Topics) > 0 {
-		b.BroadcastSubOrUnsubMessage(unsub)
+	conn, success := cli.(*client)
+	if !success {
+		return fmt.Errorf("clientId %s loaded fail", clientId)
 	}
+	return conn.WriterPacket(packet)
 }
 
-func (b *Broker) OnlineOfflineNotification(clientID string, online bool) {
+func (b *Broker) BroadcastUnSubscribe(topicsToUnSubscribeFrom []string) {
+	if len(topicsToUnSubscribeFrom) == 0 {
+		return
+	}
+
+	unsub := packets.NewControlPacket(packets.Unsubscribe).(*packets.UnsubscribePacket)
+	unsub.Topics = append(unsub.Topics, topicsToUnSubscribeFrom...)
+	b.BroadcastSubOrUnsubMessage(unsub)
+}
+
+type OnlineOfflineMsg struct {
+	ClientID    string `json:"clientID"`
+	Online      bool   `json:"online"`
+	Timestamp   string `json:"timestamp"`
+	ClientInfo  Info   `json:"info"`
+	LastMsgTime int64  `json:"lastMsg"`
+}
+
+func (b *Broker) OnlineOfflineNotification(info Info, online bool, lastMsg int64) {
 	packet := packets.NewControlPacket(packets.Publish).(*packets.PublishPacket)
-	packet.TopicName = "$SYS/broker/connection/clients/" + clientID
+	packet.TopicName = "$SYS/broker/connection/clients/" + info.ClientID
 	packet.Qos = 0
-	packet.Payload = []byte(fmt.Sprintf(`{"clientID":"%s","online":%v,"timestamp":"%s"}`, clientID, online, time.Now().UTC().Format(time.RFC3339)))
+
+	msg := OnlineOfflineMsg{
+		ClientID:    info.ClientID,
+		Online:      online,
+		Timestamp:   time.Now().UTC().Format(time.RFC3339),
+		ClientInfo:  info,
+		LastMsgTime: lastMsg,
+	}
+
+	if b, err := encJson.Marshal(msg); err != nil {
+		// This is a TERRIBLE situation, falling back to legacy format to not break API Contract
+		packet.Payload = []byte(fmt.Sprintf(`{"clientID":"%s","online":%v,"timestamp":"%s"}`, info.ClientID, online, time.Now().UTC().Format(time.RFC3339)))
+	} else {
+		packet.Payload = b
+	}
 
 	b.PublishMessage(packet)
 }
+
+func FileExist(name string) bool {
+	_, err := os.Stat(name)
+	if err == nil {
+		return true
+	} else if os.IsNotExist(err) {
+		return false
+	} else {
+		panic(err)
+	}
+}

broker/client.go

@@ -1,6 +1,7 @@
 package broker
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"math/rand"
@@ -10,17 +11,19 @@ import (
 	"strings"
 	"sync"
 	"time"
+	"unicode/utf8"
 
+	"github.com/eapache/queue"
+	"github.com/eclipse/paho.mqtt.golang/packets"
 	"github.com/fhmq/hmq/broker/lib/sessions"
 	"github.com/fhmq/hmq/broker/lib/topics"
 	"github.com/fhmq/hmq/plugins/bridge"
-
-	"github.com/eclipse/paho.mqtt.golang/packets"
 	"go.uber.org/zap"
+	"golang.org/x/net/websocket"
 )
 
 const (
-	// special pub topic for cluster info BrokerInfoTopic
+	// BrokerInfoTopic special pub topic for cluster info
 	BrokerInfoTopic = "broker000100101info"
 	// CLIENT is an end user.
 	CLIENT = 0
@@ -40,29 +43,57 @@ const (
 	Disconnected = 2
 )
 
+const (
+	awaitRelTimeout int64 = 20
+	retryInterval   int64 = 20
+)
+
 var (
 	groupCompile = regexp.MustCompile(_GroupTopicRegexp)
 )
 
 type client struct {
-	typ         int
-	mu          sync.Mutex
-	broker      *Broker
-	conn        net.Conn
-	info        info
-	route       route
-	status      int
-	ctx         context.Context
-	cancelFunc  context.CancelFunc
-	session     *sessions.Session
-	subMap      map[string]*subscription
-	topicsMgr   *topics.Manager
-	subs        []interface{}
-	qoss        []byte
-	rmsgs       []*packets.PublishPacket
-	routeSubMap map[string]uint64
+	typ            int
+	mu             sync.Mutex
+	broker         *Broker
+	conn           net.Conn
+	info           info
+	route          route
+	status         int
+	ctx            context.Context
+	cancelFunc     context.CancelFunc
+	session        *sessions.Session
+	subMap         map[string]*subscription
+	subMapMu       sync.RWMutex
+	topicsMgr      *topics.Manager
+	subs           []interface{}
+	qoss           []byte
+	rmsgs          []*packets.PublishPacket
+	routeSubMap    map[string]uint64
+	routeSubMapMu  sync.Mutex
+	awaitingRel    map[uint16]int64
+	awaitingRelMu  sync.RWMutex
+	maxAwaitingRel int
+	inflight       map[uint16]*inflightElem
+	inflightMu     sync.RWMutex
+	mqueue         *queue.Queue
+	retryTimer     *time.Timer
+	retryTimerLock sync.Mutex
+	lastMsgTime    int64
 }
 
+type InflightStatus uint8
+
+const (
+	Publish InflightStatus = 0
+	Pubrel  InflightStatus = 1
+)
+
+type inflightElem struct {
+	status    InflightStatus
+	packet    *packets.PublishPacket
+	timestamp int64
+}
 type subscription struct {
 	client    *client
 	topic     string
@@ -81,23 +112,49 @@ type info struct {
 	remoteIP  string
 }
 
+type PubPacket struct {
+	TopicName string `json:"topicName"`
+	Payload   []byte `json:"payload"`
+}
+
+type Info struct {
+	ClientID  string    `json:"clientId"`
+	Username  string    `json:"username"`
+	Password  []byte    `json:"password"`
+	Keepalive uint16    `json:"keepalive"`
+	WillMsg   PubPacket `json:"willMsg"`
+}
+
 type route struct {
 	remoteID  string
 	remoteUrl string
 }
 
 var (
-	DisconnectdPacket = packets.NewControlPacket(packets.Disconnect).(*packets.DisconnectPacket)
-	r                 = rand.New(rand.NewSource(time.Now().UnixNano()))
+	DisconnectedPacket = packets.NewControlPacket(packets.Disconnect).(*packets.DisconnectPacket)
+	r                  = rand.New(rand.NewSource(time.Now().UnixNano()))
 )
 
 func (c *client) init() {
+	c.lastMsgTime = time.Now().Unix() //mark the connection packet time as last time messaged
 	c.status = Connected
 	c.info.localIP, _, _ = net.SplitHostPort(c.conn.LocalAddr().String())
-	c.info.remoteIP, _, _ = net.SplitHostPort(c.conn.RemoteAddr().String())
+	remoteAddr := c.conn.RemoteAddr()
+	remoteNetwork := remoteAddr.Network()
+	c.info.remoteIP = ""
+	if remoteNetwork != "websocket" {
+		c.info.remoteIP, _, _ = net.SplitHostPort(remoteAddr.String())
+	} else {
+		ws := c.conn.(*websocket.Conn)
+		c.info.remoteIP, _, _ = net.SplitHostPort(ws.Request().RemoteAddr)
+	}
 	c.ctx, c.cancelFunc = context.WithCancel(context.Background())
 	c.subMap = make(map[string]*subscription)
 	c.topicsMgr = c.broker.topicsMgr
+	c.routeSubMap = make(map[string]uint64)
+	c.awaitingRel = make(map[uint16]int64)
+	c.inflight = make(map[uint16]*inflightElem)
+	c.mqueue = queue.New()
 }
 
 func (c *client) readLoop() {
@@ -116,14 +173,16 @@ func (c *client) readLoop() {
 			return
 		default:
 			//add read timeout
-			if err := nc.SetReadDeadline(time.Now().Add(timeOut)); err != nil {
-				log.Error("set read timeout error: ", zap.Error(err), zap.String("ClientID", c.info.clientID))
-				msg := &Message{
-					client: c,
-					packet: DisconnectdPacket,
+			if keepAlive > 0 {
+				if err := nc.SetReadDeadline(time.Now().Add(timeOut)); err != nil {
+					log.Error("set read timeout error: ", zap.Error(err), zap.String("ClientID", c.info.clientID))
+					msg := &Message{
+						client: c,
+						packet: DisconnectedPacket,
+					}
+					b.SubmitWork(c.info.clientID, msg)
+					return
 				}
-				b.SubmitWork(c.info.clientID, msg)
-				return
 			}
 
 			packet, err := packets.ReadPacket(nc)
@@ -131,12 +190,20 @@ func (c *client) readLoop() {
 				log.Error("read packet error: ", zap.Error(err), zap.String("ClientID", c.info.clientID))
 				msg := &Message{
 					client: c,
-					packet: DisconnectdPacket,
+					packet: DisconnectedPacket,
 				}
 				b.SubmitWork(c.info.clientID, msg)
 				return
 			}
 
+			// if packet is disconnect from client, then need to break the read packet loop and clear will msg.
+			if _, isDisconnect := packet.(*packets.DisconnectPacket); isDisconnect {
+				c.info.willMsg = nil
+				c.cancelFunc()
+			} else {
+				c.lastMsgTime = time.Now().Unix()
+			}
+
 			msg := &Message{
 				client: c,
 				packet: packet,
@@ -147,6 +214,63 @@ func (c *client) readLoop() {
 
 }
 
+// extractPacketFields function reads a control packet and extracts only the fields
+// that needs to pass on UTF-8 validation
+func extractPacketFields(msgPacket packets.ControlPacket) []string {
+	var fields []string
+
+	// Get packet type
+	switch msgPacket.(type) {
+	case *packets.ConnackPacket:
+	case *packets.ConnectPacket:
+	case *packets.PublishPacket:
+		packet := msgPacket.(*packets.PublishPacket)
+		fields = append(fields, packet.TopicName)
+		break
+
+	case *packets.SubscribePacket:
+	case *packets.SubackPacket:
+	case *packets.UnsubscribePacket:
+		packet := msgPacket.(*packets.UnsubscribePacket)
+		fields = append(fields, packet.Topics...)
+		break
+	}
+
+	return fields
+}
+
+// validatePacketFields function checks if any of control packets fields has ill-formed
+// UTF-8 string
+func validatePacketFields(msgPacket packets.ControlPacket) (validFields bool) {
+
+	// Extract just fields that needs validation
+	fields := extractPacketFields(msgPacket)
+
+	for _, field := range fields {
+
+		// Perform the basic UTF-8 validation
+		if !utf8.ValidString(field) {
+			validFields = false
+			return
+		}
+
+		// A UTF-8 encoded string MUST NOT include an encoding of the null
+		// character U+0000
+		// If a receiver (Server or Client) receives a Control Packet containing U+0000
+		// it MUST close the Network Connection
+		// http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.pdf page 14
+		if bytes.ContainsAny([]byte(field), "\u0000") {
+			validFields = false
+			return
+		}
+	}
+
+	// All fields have been validated successfully
+	validFields = true
+
+	return
+}
+
 func ProcessMessage(msg *Message) {
 	c := msg.client
 	ca := msg.packet
@@ -158,16 +282,77 @@ func ProcessMessage(msg *Message) {
 		log.Debug("Recv message:", zap.String("message type", reflect.TypeOf(msg.packet).String()[9:]), zap.String("ClientID", c.info.clientID))
 	}
 
+	// Perform field validation
+	if !validatePacketFields(ca) {
+
+		// http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.pdf
+		// Page 14
+		//
+		// If a Server or Client receives a Control Packet
+		// containing ill-formed UTF-8 it MUST close the Network Connection
+
+		_ = c.conn.Close()
+
+		// Update client status
+		//c.status = Disconnected
+
+		log.Error("Client disconnected due to malformed packet", zap.String("ClientID", c.info.clientID))
+
+		return
+	}
+
 	switch ca.(type) {
 	case *packets.ConnackPacket:
 	case *packets.ConnectPacket:
 	case *packets.PublishPacket:
 		packet := ca.(*packets.PublishPacket)
+
 		c.ProcessPublish(packet)
 	case *packets.PubackPacket:
+		packet := ca.(*packets.PubackPacket)
+		c.inflightMu.Lock()
+		if _, found := c.inflight[packet.MessageID]; found {
+			delete(c.inflight, packet.MessageID)
+		} else {
+			log.Error("Duplicated PUBACK PacketId", zap.Uint16("MessageID", packet.MessageID))
+		}
+		c.inflightMu.Unlock()
 	case *packets.PubrecPacket:
+		packet := ca.(*packets.PubrecPacket)
+		c.inflightMu.RLock()
+		ielem, found := c.inflight[packet.MessageID]
+		c.inflightMu.RUnlock()
+		if found {
+			if ielem.status == Publish {
+				ielem.status = Pubrel
+				ielem.timestamp = time.Now().Unix()
+			} else if ielem.status == Pubrel {
+				log.Error("Duplicated PUBREC PacketId", zap.Uint16("MessageID", packet.MessageID))
+			}
+		} else {
+			log.Error("The PUBREC PacketId is not found.", zap.Uint16("MessageID", packet.MessageID))
+		}
+
+		pubrel := packets.NewControlPacket(packets.Pubrel).(*packets.PubrelPacket)
+		pubrel.MessageID = packet.MessageID
+		if err := c.WriterPacket(pubrel); err != nil {
+			log.Error("send pubrel error, ", zap.Error(err), zap.String("ClientID", c.info.clientID))
+			return
+		}
 	case *packets.PubrelPacket:
+		packet := ca.(*packets.PubrelPacket)
+		_ = c.pubRel(packet.MessageID)
+		pubcomp := packets.NewControlPacket(packets.Pubcomp).(*packets.PubcompPacket)
+		pubcomp.MessageID = packet.MessageID
+		if err := c.WriterPacket(pubcomp); err != nil {
+			log.Error("send pubcomp error, ", zap.Error(err), zap.String("ClientID", c.info.clientID))
+			return
+		}
 	case *packets.PubcompPacket:
+		packet := ca.(*packets.PubcompPacket)
+		c.inflightMu.Lock()
+		delete(c.inflight, packet.MessageID)
+		c.inflightMu.Unlock()
 	case *packets.SubscribePacket:
 		packet := ca.(*packets.SubscribePacket)
 		c.ProcessSubscribe(packet)
@@ -245,8 +430,8 @@ func (c *client) processClientPublish(packet *packets.PublishPacket) {
 		return
 	}
 
-	//publish kafka
-	c.broker.Publish(&bridge.Elements{
+	//publish to bridge mq
+	cost := c.broker.Publish(&bridge.Elements{
 		ClientID:  c.info.clientID,
 		Username:  c.info.username,
 		Action:    bridge.Publish,
@@ -255,6 +440,10 @@ func (c *client) processClientPublish(packet *packets.PublishPacket) {
 		Topic:     topic,
 	})
 
+	if cost {
+		return
+	}
+
 	switch packet.Qos {
 	case QosAtMostOnce:
 		c.ProcessPublishMessage(packet)
@@ -267,6 +456,17 @@ func (c *client) processClientPublish(packet *packets.PublishPacket) {
 		}
 		c.ProcessPublishMessage(packet)
 	case QosExactlyOnce:
+		if err := c.registerPublishPacketId(packet.MessageID); err != nil {
+			return
+		} else {
+			pubrec := packets.NewControlPacket(packets.Pubrec).(*packets.PubrecPacket)
+			pubrec.MessageID = packet.MessageID
+			if err := c.WriterPacket(pubrec); err != nil {
+				log.Error("send pubrec error, ", zap.Error(err), zap.String("ClientID", c.info.clientID))
+				return
+			}
+			c.ProcessPublishMessage(packet)
+		}
 		return
 	default:
 		log.Error("publish with unknown qos", zap.String("ClientID", c.info.clientID))
@@ -295,7 +495,6 @@ func (c *client) ProcessPublishMessage(packet *packets.PublishPacket) {
 		return
 	}
 
-	// fmt.Println("psubs num: ", len(c.subs))
 	if len(c.subs) == 0 {
 		return
 	}
@@ -332,6 +531,8 @@ func (c *client) ProcessSubscribe(packet *packets.SubscribePacket) {
 	case CLIENT:
 		c.processClientSubscribe(packet)
 	case ROUTER:
+		fallthrough
+	case REMOTE:
 		c.processRouterSubscribe(packet)
 	}
 }
@@ -345,14 +546,15 @@ func (c *client) processClientSubscribe(packet *packets.SubscribePacket) {
 	if b == nil {
 		return
 	}
-	topics := packet.Topics
+
+	subTopics := packet.Topics
 	qoss := packet.Qoss
 
 	suback := packets.NewControlPacket(packets.Suback).(*packets.SubackPacket)
 	suback.MessageID = packet.MessageID
 	var retcodes []byte
 
-	for i, topic := range topics {
+	for i, topic := range subTopics {
 		t := topic
 		//check topic auth for client
 		if !b.CheckTopicAuth(SUB, c.info.clientID, c.info.username, c.info.remoteIP, topic) {
@@ -382,10 +584,12 @@ func (c *client) processClientSubscribe(packet *packets.SubscribePacket) {
 			topic = substr[2]
 		}
 
+		c.subMapMu.Lock()
 		if oldSub, exist := c.subMap[t]; exist {
-			c.topicsMgr.Unsubscribe([]byte(oldSub.topic), oldSub)
+			_ = c.topicsMgr.Unsubscribe([]byte(oldSub.topic), oldSub)
 			delete(c.subMap, t)
 		}
+		c.subMapMu.Unlock()
 
 		sub := &subscription{
 			topic:     topic,
@@ -402,12 +606,13 @@ func (c *client) processClientSubscribe(packet *packets.SubscribePacket) {
 			continue
 		}
 
+		c.subMapMu.Lock()
 		c.subMap[t] = sub
+		c.subMapMu.Unlock()
 
-		c.session.AddTopic(t, qoss[i])
+		_ = c.session.AddTopic(t, qoss[i])
 		retcodes = append(retcodes, rqos)
-		c.topicsMgr.Retained([]byte(topic), &c.rmsgs)
-
+		_ = c.topicsMgr.Retained([]byte(topic), &c.rmsgs)
 	}
 
 	suback.ReturnCodes = retcodes
@@ -439,14 +644,15 @@ func (c *client) processRouterSubscribe(packet *packets.SubscribePacket) {
 	if b == nil {
 		return
 	}
-	topics := packet.Topics
+
+	subTopics := packet.Topics
 	qoss := packet.Qoss
 
 	suback := packets.NewControlPacket(packets.Suback).(*packets.SubackPacket)
 	suback.MessageID = packet.MessageID
 	var retcodes []byte
 
-	for i, topic := range topics {
+	for i, topic := range subTopics {
 		t := topic
 		groupName := ""
 		share := false
@@ -476,8 +682,13 @@ func (c *client) processRouterSubscribe(packet *packets.SubscribePacket) {
 			continue
 		}
 
+		c.subMapMu.Lock()
 		c.subMap[t] = sub
+		c.subMapMu.Unlock()
+
+		c.routeSubMapMu.Lock()
 		addSubMap(c.routeSubMap, topic)
+		c.routeSubMapMu.Unlock()
 		retcodes = append(retcodes, rqos)
 	}
 
@@ -507,20 +718,24 @@ func (c *client) processRouterUnSubscribe(packet *packets.UnsubscribePacket) {
 	if b == nil {
 		return
 	}
-	topics := packet.Topics
 
-	for _, topic := range topics {
-		sub, exist := c.subMap[topic]
-		if exist {
-			retainNum := delSubMap(c.routeSubMap, topic)
-			if retainNum > 0 {
+	unSubTopics := packet.Topics
+
+	for _, topic := range unSubTopics {
+		c.subMapMu.Lock()
+		if sub, exist := c.subMap[topic]; exist {
+			c.routeSubMapMu.Lock()
+			if retainNum := delSubMap(c.routeSubMap, topic); retainNum > 0 {
+				c.routeSubMapMu.Unlock()
+				c.subMapMu.Unlock()
 				continue
 			}
+			c.routeSubMapMu.Unlock()
 
-			c.topicsMgr.Unsubscribe([]byte(sub.topic), sub)
+			_ = c.topicsMgr.Unsubscribe([]byte(sub.topic), sub)
 			delete(c.subMap, topic)
 		}
-
+		c.subMapMu.Unlock()
 	}
 
 	unsuback := packets.NewControlPacket(packets.Unsuback).(*packets.UnsubackPacket)
@@ -541,9 +756,10 @@ func (c *client) processClientUnSubscribe(packet *packets.UnsubscribePacket) {
 	if b == nil {
 		return
 	}
-	topics := packet.Topics
 
-	for _, topic := range topics {
+	unSubTopics := packet.Topics
+
+	for _, topic := range unSubTopics {
 		{
 			//publish kafka
 
@@ -557,12 +773,14 @@ func (c *client) processClientUnSubscribe(packet *packets.UnsubscribePacket) {
 
 		}
 
+		c.subMapMu.Lock()
 		sub, exist := c.subMap[topic]
 		if exist {
-			c.topicsMgr.Unsubscribe([]byte(sub.topic), sub)
-			c.session.RemoveTopic(topic)
+			_ = c.topicsMgr.Unsubscribe([]byte(sub.topic), sub)
+			_ = c.session.RemoveTopic(topic)
 			delete(c.subMap, topic)
 		}
+		c.subMapMu.Unlock()
 
 	}
 
@@ -610,44 +828,77 @@ func (c *client) Close() {
 		Timestamp: time.Now().Unix(),
 	})
 
+	c.mu.Lock()
 	if c.conn != nil {
-		c.conn.Close()
+		_ = c.conn.Close()
 		c.conn = nil
 	}
+	c.mu.Unlock()
 
-	subs := c.subMap
+	if b == nil {
+		return
+	}
 
-	if b != nil {
-		b.removeClient(c)
-		for _, sub := range subs {
-			err := b.topicsMgr.Unsubscribe([]byte(sub.topic), sub)
-			if err != nil {
-				log.Error("unsubscribe error, ", zap.Error(err), zap.String("ClientID", c.info.clientID))
-			}
+	b.removeClient(c)
+
+	c.subMapMu.RLock()
+	defer c.subMapMu.RUnlock()
+
+	unSubTopics := make([]string, 0)
+	for topic, sub := range c.subMap {
+		unSubTopics = append(unSubTopics, topic)
+
+		// guard against race condition where a client gets Close() but wasn't initialized yet fully
+		if sub == nil || b.topicsMgr == nil {
+			continue
 		}
 
-		if c.typ == CLIENT {
-			b.BroadcastUnSubscribe(subs)
-			//offline notification
-			b.OnlineOfflineNotification(c.info.clientID, false)
-		}
-
-		if c.info.willMsg != nil {
-			b.PublishMessage(c.info.willMsg)
-		}
-
-		if c.typ == CLUSTER {
-			b.ConnectToDiscovery()
-		}
-
-		//do reconnect
-		if c.typ == REMOTE {
-			go b.connectRouter(c.route.remoteID, c.route.remoteUrl)
+		if err := b.topicsMgr.Unsubscribe([]byte(sub.topic), sub); err != nil {
+			log.Error("unsubscribe error, ", zap.Error(err), zap.String("ClientID", c.info.clientID))
 		}
 	}
+
+	if c.typ == CLIENT {
+		b.BroadcastUnSubscribe(unSubTopics)
+
+		var pubPack = PubPacket{}
+		if c.info.willMsg != nil {
+			pubPack.TopicName = c.info.willMsg.TopicName
+			pubPack.Payload = c.info.willMsg.Payload
+		}
+
+		pubInfo := Info{
+			ClientID:  c.info.clientID,
+			Username:  c.info.username,
+			Password:  c.info.password,
+			Keepalive: c.info.keepalive,
+			WillMsg:   pubPack,
+		}
+		//offline notification
+		b.OnlineOfflineNotification(pubInfo, false, c.lastMsgTime)
+	}
+
+	if c.info.willMsg != nil {
+		b.PublishMessage(c.info.willMsg)
+	}
+
+	if c.typ == CLUSTER {
+		b.ConnectToDiscovery()
+	}
+
+	//do reconnect
+	if c.typ == REMOTE {
+		go b.connectRouter(c.route.remoteID, c.route.remoteUrl)
+	}
+
 }
 
 func (c *client) WriterPacket(packet packets.ControlPacket) error {
+	defer func() {
+		if err := recover(); err != nil {
+			log.Error("recover error, ", zap.Any("recover", err))
+		}
+	}()
 	if c.status == Disconnected {
 		return nil
 	}
@@ -655,13 +906,68 @@ func (c *client) WriterPacket(packet packets.ControlPacket) error {
 	if packet == nil {
 		return nil
 	}
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
 	if c.conn == nil {
-		c.Close()
 		return errors.New("connect lost ....")
 	}
 
-	c.mu.Lock()
-	err := packet.Write(c.conn)
-	c.mu.Unlock()
-	return err
+	return packet.Write(c.conn)
+}
+
+func (c *client) registerPublishPacketId(packetId uint16) error {
+	if c.isAwaitingFull() {
+		log.Error("Dropped qos2 packet for too many awaiting_rel", zap.Uint16("id", packetId))
+		return errors.New("DROPPED_QOS2_PACKET_FOR_TOO_MANY_AWAITING_REL")
+	}
+
+	c.awaitingRelMu.Lock()
+	defer c.awaitingRelMu.Unlock()
+	if _, found := c.awaitingRel[packetId]; found {
+		return errors.New("RC_PACKET_IDENTIFIER_IN_USE")
+	}
+	c.awaitingRel[packetId] = time.Now().Unix()
+	time.AfterFunc(time.Duration(awaitRelTimeout)*time.Second, c.expireAwaitingRel)
+	return nil
+}
+
+func (c *client) isAwaitingFull() bool {
+	c.awaitingRelMu.RLock()
+	defer c.awaitingRelMu.RUnlock()
+	if c.maxAwaitingRel == 0 {
+		return false
+	}
+	if len(c.awaitingRel) < c.maxAwaitingRel {
+		return false
+	}
+	return true
+}
+
+func (c *client) expireAwaitingRel() {
+	c.awaitingRelMu.Lock()
+	defer c.awaitingRelMu.Unlock()
+	if len(c.awaitingRel) == 0 {
+		return
+	}
+	now := time.Now().Unix()
+	for packetId, Timestamp := range c.awaitingRel {
+		if now-Timestamp >= awaitRelTimeout {
+			log.Error("Dropped qos2 packet for await_rel_timeout", zap.Uint16("id", packetId))
+			delete(c.awaitingRel, packetId)
+		}
+	}
+}
+
+func (c *client) pubRel(packetId uint16) error {
+	c.awaitingRelMu.Lock()
+	defer c.awaitingRelMu.Unlock()
+	if _, found := c.awaitingRel[packetId]; found {
+		delete(c.awaitingRel, packetId)
+	} else {
+		log.Error("The PUBREL PacketId is not found", zap.Uint16("id", packetId))
+		return errors.New("RC_PACKET_IDENTIFIER_NOT_FOUND")
+	}
+	return nil
 }

broker/comm.go

@@ -1,15 +1,14 @@
 package broker
 
 import (
-	"encoding/json"
 	"reflect"
 	"time"
 
-	"github.com/tidwall/gjson"
+	jsoniter "github.com/json-iterator/go"
 	"go.uber.org/zap"
 
 	"github.com/eclipse/paho.mqtt.golang/packets"
-	uuid "github.com/satori/go.uuid"
+	uuid "github.com/google/uuid"
 )
 
 const (
@@ -114,7 +113,11 @@ func delSubMap(m map[string]uint64, topic string) uint64 {
 }
 
 func GenUniqueId() string {
-	return uuid.NewV4().String()
+	id, err := uuid.NewRandom()
+	if err != nil {
+		log.Error("uuid.NewRandom() returned an error: " + err.Error())
+	}
+	return id.String()
 }
 
 func wrapPublishPacket(packet *packets.PublishPacket) *packets.PublishPacket {
@@ -130,26 +133,110 @@ func wrapPublishPacket(packet *packets.PublishPacket) *packets.PublishPacket {
 
 func unWrapPublishPacket(packet *packets.PublishPacket) *packets.PublishPacket {
 	p := packet.Copy()
-	if gjson.GetBytes(p.Payload, "payload").Exists() {
-		p.Payload = []byte(gjson.GetBytes(p.Payload, "payload").String())
+	if payload := jsoniter.Get(p.Payload, "payload").ToString(); payload != "" {
+		p.Payload = []byte(payload)
 	}
 	return p
 }
 
 func publish(sub *subscription, packet *packets.PublishPacket) {
-	// var p *packets.PublishPacket
-	// if sub.client.info.username != "root" {
-	// 	p = unWrapPublishPacket(packet)
-	// } else {
-	// 	p = wrapPublishPacket(packet)
-	// }
-	// err := sub.client.WriterPacket(p)
-	// if err != nil {
-	// 	log.Error("process message for psub error,  ", zap.Error(err))
-	// }
-
-	err := sub.client.WriterPacket(packet)
-	if err != nil {
-		log.Error("process message for psub error,  ", zap.Error(err))
+	switch packet.Qos {
+	case QosAtMostOnce:
+		err := sub.client.WriterPacket(packet)
+		if err != nil {
+			log.Error("process message for psub error,  ", zap.Error(err))
+		}
+	case QosAtLeastOnce, QosExactlyOnce:
+		sub.client.inflightMu.Lock()
+		sub.client.inflight[packet.MessageID] = &inflightElem{status: Publish, packet: packet, timestamp: time.Now().Unix()}
+		sub.client.inflightMu.Unlock()
+		err := sub.client.WriterPacket(packet)
+		if err != nil {
+			log.Error("process message for psub error,  ", zap.Error(err))
+		}
+		sub.client.ensureRetryTimer()
+	default:
+		log.Error("publish with unknown qos", zap.String("ClientID", sub.client.info.clientID))
+		return
 	}
 }
+
+// timer for retry delivery
+func (c *client) ensureRetryTimer(interval ...int64) {
+
+	c.retryTimerLock.Lock()
+	defer c.retryTimerLock.Unlock()
+
+	if c.retryTimer != nil {
+		return
+	}
+
+	if len(interval) > 1 {
+		return
+	}
+	timerInterval := retryInterval
+	if len(interval) == 1 {
+		timerInterval = interval[0]
+	}
+
+	c.retryTimer = time.AfterFunc(time.Duration(timerInterval)*time.Second, c.retryDelivery)
+
+	return
+}
+
+func (c *client) resetRetryTimer() {
+	// lock mutex before reading retryTimer
+	c.retryTimerLock.Lock()
+	defer c.retryTimerLock.Unlock()
+
+	if c.retryTimer == nil {
+		return
+	}
+
+	// reset timer
+	c.retryTimer = nil
+}
+
+func (c *client) retryDelivery() {
+	c.resetRetryTimer()
+	c.inflightMu.RLock()
+	ilen := len(c.inflight)
+
+	c.mu.Lock()
+	if c.conn == nil || ilen == 0 { //Reset timer when client offline OR inflight is empty
+		c.inflightMu.RUnlock()
+		c.mu.Unlock()
+		return
+	}
+	c.mu.Unlock()
+
+	// copy the to be retried elements out of the map to only hold the lock for a short time and use the new slice later to iterate
+	// through them
+	toRetryEle := make([]*inflightElem, 0, ilen)
+	for _, infEle := range c.inflight {
+		toRetryEle = append(toRetryEle, infEle)
+	}
+	c.inflightMu.RUnlock()
+	now := time.Now().Unix()
+
+	for _, infEle := range toRetryEle {
+		age := now - infEle.timestamp
+		if age >= retryInterval {
+			if infEle.status == Publish {
+				c.WriterPacket(infEle.packet)
+				infEle.timestamp = now
+			} else if infEle.status == Pubrel {
+				pubrel := packets.NewControlPacket(packets.Pubrel).(*packets.PubrelPacket)
+				pubrel.MessageID = infEle.packet.MessageID
+				c.WriterPacket(pubrel)
+				infEle.timestamp = now
+			}
+		} else {
+			if age < 0 {
+				age = 0
+			}
+			c.ensureRetryTimer(retryInterval - age)
+		}
+	}
+	c.ensureRetryTimer()
+}

broker/config.go

@@ -3,7 +3,6 @@ package broker
 import (
 	"crypto/tls"
 	"crypto/x509"
-	"encoding/json"
 	"errors"
 	"flag"
 	"fmt"
@@ -11,27 +10,39 @@ import (
 	"os"
 
 	"github.com/fhmq/hmq/logger"
+	"github.com/fhmq/hmq/plugins/auth"
+	"github.com/fhmq/hmq/plugins/bridge"
+	jsoniter "github.com/json-iterator/go"
 	"go.uber.org/zap"
 )
 
+var json = jsoniter.ConfigCompatibleWithStandardLibrary
+
 type Config struct {
-	Worker   int       `json:"workerNum"`
-	HTTPPort string    `json:"httpPort"`
-	Host     string    `json:"host"`
-	Port     string    `json:"port"`
-	Cluster  RouteInfo `json:"cluster"`
-	Router   string    `json:"router"`
-	TlsHost  string    `json:"tlsHost"`
-	TlsPort  string    `json:"tlsPort"`
-	WsPath   string    `json:"wsPath"`
-	WsPort   string    `json:"wsPort"`
-	WsTLS    bool      `json:"wsTLS"`
-	TlsInfo  TLSInfo   `json:"tlsInfo"`
-	Debug    bool      `json:"debug"`
-	Plugin   Plugins   `json:"plugins"`
+	Worker          int       `json:"workerNum"`
+	HTTPPort        string    `json:"httpPort"`
+	Host            string    `json:"host"`
+	Port            string    `json:"port"`
+	Cluster         RouteInfo `json:"cluster"`
+	Router          string    `json:"router"`
+	TlsHost         string    `json:"tlsHost"`
+	TlsPort         string    `json:"tlsPort"`
+	WsPath          string    `json:"wsPath"`
+	WsPort          string    `json:"wsPort"`
+	WsTLS           bool      `json:"wsTLS"`
+	TlsInfo         TLSInfo   `json:"tlsInfo"`
+	Debug           string    `json:"debug"`
+	Plugin          Plugins   `json:"plugins"`
+	UnixFilePath    string    `json:"unixFilePath"`
+	WindowsPipeName string    `json:"windowsPipeName"`
 }
 
 type Plugins struct {
+	Auth   auth.Auth
+	Bridge bridge.BridgeMQ
+}
+
+type NamedPlugins struct {
 	Auth   string
 	Bridge string
 }
@@ -76,11 +87,12 @@ func ConfigureConfig(args []string) (*Config, error) {
 	fs.BoolVar(&help, "help", false, "Show this message.")
 	fs.IntVar(&config.Worker, "w", 1024, "worker num to process message, perfer (client num)/10.")
 	fs.IntVar(&config.Worker, "worker", 1024, "worker num to process message, perfer (client num)/10.")
-	fs.StringVar(&config.HTTPPort, "httpport", "8080", "Port to listen on.")
-	fs.StringVar(&config.HTTPPort, "hp", "8080", "Port to listen on.")
-	fs.StringVar(&config.Port, "port", "1883", "Port to listen on.")
-	fs.StringVar(&config.Port, "p", "1883", "Port to listen on.")
-	fs.StringVar(&config.Host, "host", "0.0.0.0", "Network host to listen on")
+	fs.StringVar(&config.HTTPPort, "httpport", "", "Port to listen on.")
+	fs.StringVar(&config.HTTPPort, "hp", "", "Port to listen on.")
+	fs.StringVar(&config.Port, "port", "8090", "Port to listen on.")
+	fs.StringVar(&config.Port, "p", "8090", "Port to listen on.")
+	fs.StringVar(&config.UnixFilePath, "unixfilepath", "", "unix sock to listen on.")
+	fs.StringVar(&config.Host, "host", "127.0.0.1", "Network host to listen on")
 	fs.StringVar(&config.Cluster.Port, "cp", "", "Cluster port from which members can connect.")
 	fs.StringVar(&config.Cluster.Port, "clusterport", "", "Cluster port from which members can connect.")
 	fs.StringVar(&config.Router, "r", "", "Router who maintenance cluster info")
@@ -91,8 +103,8 @@ func ConfigureConfig(args []string) (*Config, error) {
 	fs.StringVar(&config.WsPath, "wspath", "", "path for ws to listen on")
 	fs.StringVar(&configFile, "config", "", "config file for hmq")
 	fs.StringVar(&configFile, "c", "", "config file for hmq")
-	fs.BoolVar(&config.Debug, "debug", false, "enable Debug logging.")
-	fs.BoolVar(&config.Debug, "d", false, "enable Debug logging.")
+	fs.StringVar(&config.Debug, "debug", "info", "enable Debug logging.")
+	fs.StringVar(&config.Debug, "d", "info", "enable Debug logging.")
 
 	fs.Bool("D", true, "enable Debug logging.")
 
@@ -108,7 +120,7 @@ func ConfigureConfig(args []string) (*Config, error) {
 	fs.Visit(func(f *flag.Flag) {
 		switch f.Name {
 		case "D":
-			config.Debug = true
+			config.Debug = "debug"
 		}
 	})
 
@@ -121,7 +133,15 @@ func ConfigureConfig(args []string) (*Config, error) {
 		}
 	}
 
-	if config.Debug {
+	//Set the debug level of logs
+	switch config.Debug {
+	case "debug":
+		log = logger.Debug().Named("broker")
+	case "info":
+		log = logger.Prod().Named("broker")
+	case "release":
+		log = logger.Release().Named("broker")
+	default:
 		log = logger.Debug().Named("broker")
 	}
 
@@ -152,6 +172,17 @@ func LoadConfig(filename string) (*Config, error) {
 	return &config, nil
 }
 
+func (p *Plugins) UnmarshalJSON(b []byte) error {
+	var named NamedPlugins
+	err := json.Unmarshal(b, &named)
+	if err != nil {
+		return err
+	}
+	p.Auth = auth.NewAuth(named.Auth)
+	p.Bridge = bridge.NewBridgeMQ(named.Bridge)
+	return nil
+}
+
 func (config *Config) check() error {
 
 	if config.Worker == 0 {
@@ -216,7 +247,7 @@ func NewTLSConfig(tlsInfo TLSInfo) (*tls.Config, error) {
 			return nil, err
 		}
 		pool := x509.NewCertPool()
-		ok := pool.AppendCertsFromPEM([]byte(rootPEM))
+		ok := pool.AppendCertsFromPEM(rootPEM)
 		if !ok {
 			return nil, fmt.Errorf("failed to parse root ca certificate")
 		}

broker/http.go

@@ -4,22 +4,61 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
+const (
+	CONNECTIONS	= "api/v1/connections"
+)
+
+type ConnClient struct {
+	Info				`json:"info"`
+	LastMsgTime	int64		`json:"lastMsg"`
+}
+
+type resp struct {
+	Code	int		`json:"code,omitempty"`
+	Clients	[]ConnClient	`json:"clients,omitempty"`
+}
+
 func InitHTTPMoniter(b *Broker) {
 	gin.SetMode(gin.ReleaseMode)
 	router := gin.Default()
-	router.DELETE("api/v1/connections/:clientid", func(c *gin.Context) {
+	router.DELETE(CONNECTIONS + "/:clientid", func(c *gin.Context) {
 		clientid := c.Param("clientid")
 		cli, ok := b.clients.Load(clientid)
 		if ok {
-			conn, succss := cli.(*client)
-			if succss {
+			conn, success := cli.(*client)
+			if success {
 				conn.Close()
 			}
 		}
-		resp := map[string]int{
-			"code": 0,
-		}
-		c.JSON(200, &resp)
+		r := resp{Code: 0}
+		c.JSON(200, &r)
+	})
+	router.GET(CONNECTIONS, func(c *gin.Context) {
+		conns := make([]ConnClient, 0)
+		b.clients.Range(func (k, v interface{}) bool {
+			cl, _ := v.(*client)
+			var pubPack = PubPacket{}
+			if cl.info.willMsg != nil {
+				pubPack.TopicName = cl.info.willMsg.TopicName
+				pubPack.Payload = cl.info.willMsg.Payload
+			}
+
+			msg := ConnClient{
+				Info: Info{
+					ClientID: cl.info.clientID,
+					Username: cl.info.username,
+					Password: cl.info.password,
+					Keepalive: cl.info.keepalive,
+					WillMsg: pubPack,
+				},
+				LastMsgTime: cl.lastMsgTime,
+			}
+
+			conns = append(conns, msg)
+			return true
+		})
+		r := resp{Clients: conns}
+		c.JSON(200, &r)
 	})
 
 	router.Run(":" + b.config.HTTPPort)

broker/info.go

@@ -15,7 +15,7 @@ func (c *client) SendInfo() {
 	}
 	url := c.info.localIP + ":" + c.broker.config.Cluster.Port
 
-	infoMsg := NewInfo(c.broker.id, url, false)
+	infoMsg := NewInfo(c.broker.id, url)
 	err := c.WriterPacket(infoMsg)
 	if err != nil {
 		log.Error("send info message error, ", zap.Error(err))
@@ -46,6 +46,8 @@ func (c *client) SendConnect() {
 		return
 	}
 	m := packets.NewControlPacket(packets.Connect).(*packets.ConnectPacket)
+	m.ProtocolName = "MQIsdp"
+	m.ProtocolVersion = 3
 
 	m.CleanSession = true
 	m.ClientIdentifier = c.info.clientID
@@ -58,13 +60,12 @@ func (c *client) SendConnect() {
 	log.Info("send connect success")
 }
 
-func NewInfo(sid, url string, isforword bool) *packets.PublishPacket {
+func NewInfo(sid, url string) *packets.PublishPacket {
 	pub := packets.NewControlPacket(packets.Publish).(*packets.PublishPacket)
 	pub.Qos = 0
 	pub.TopicName = BrokerInfoTopic
 	pub.Retain = false
 	info := fmt.Sprintf(`{"brokerID":"%s","brokerUrl":"%s"}`, sid, url)
-	// log.Info("new info", string(info))
 	pub.Payload = []byte(info)
 	return pub
 }

broker/lib/sessions/session.go

@@ -55,7 +55,7 @@ func (this *Session) Init(msg *packets.ConnectPacket) error {
 
 	this.topics = make(map[string]byte, 1)
 
-	this.id = string(msg.ClientIdentifier)
+	this.id = msg.ClientIdentifier
 
 	this.initted = true
 

broker/lib/topics/memtopics.go

@@ -78,7 +78,7 @@ func (this *memTopics) Unsubscribe(topic []byte, sub interface{}) error {
 	return this.sroot.sremove(topic, sub)
 }
 
-// Returned values will be invalidated by the next Subscribers call
+// Subscribers Returned values will be invalidated by the next Subscribers call
 func (this *memTopics) Subscribers(topic []byte, qos byte, subs *[]interface{}, qoss *[]byte) error {
 	if !ValidQos(qos) {
 		return fmt.Errorf("Invalid QoS %d", qos)

broker/pipe_socket_darwin.go

@@ -0,0 +1,11 @@
+package broker
+
+import (
+	"fmt"
+)
+
+// StartPipeSocketListening We use the open source npipe library
+// to jump over pipe communication in mac
+func (b *Broker) StartPipeSocketListening(pipeName string, usePipe bool) {
+	fmt.Println("macos system")
+}

broker/pipe_socket_linux.go

@@ -0,0 +1,6 @@
+package broker
+
+// StartPipeSocketListening We use the open source npipe library to
+// jump over pipe communication in linux
+func (b *Broker) StartPipeSocketListening(pipeName string, usePipe bool) {
+}

broker/pipe_socket_windows.go

@@ -0,0 +1,61 @@
+package broker
+
+import (
+	"fmt"
+	"github.com/natefinch/npipe"
+	"go.uber.org/zap"
+	"net"
+	"time"
+)
+
+// StartPipeSocketListening We use the open source npipe library to support pipe communication in windows
+func (b *Broker) StartPipeSocketListening(pipeName string, usePipe bool) {
+	var err error
+	var ln *npipe.PipeListener
+
+	for {
+		if usePipe {
+			fmt.Println(pipeName)
+			ln, err = npipe.Listen(pipeName)
+			log.Info("Start Listening client on ", zap.String("pipeName", pipeName))
+		}
+		if err == nil {
+			break // successfully listening
+		}
+		log.Error("Error listening on ", zap.Error(err))
+		time.Sleep(1 * time.Second)
+	}
+
+	tmpDelay := 10 * ACCEPT_MIN_SLEEP
+
+	for {
+		conn, err := ln.Accept()
+		if err != nil {
+			if ne, ok := err.(net.Error); ok && ne.Temporary() {
+				log.Error(
+					"Temporary Client Accept Error(%v), sleeping %dms",
+					zap.Error(ne),
+					zap.Duration("sleeping", tmpDelay/time.Millisecond),
+				)
+
+				time.Sleep(tmpDelay)
+				tmpDelay *= 2
+				if tmpDelay > ACCEPT_MAX_SLEEP {
+					tmpDelay = ACCEPT_MAX_SLEEP
+				}
+			} else {
+				log.Error("Accept error", zap.Error(err))
+			}
+			continue
+		}
+
+		tmpDelay = ACCEPT_MIN_SLEEP
+		go func() {
+			err := b.handleConnection(CLIENT, conn)
+			fmt.Println("handleConnection,", err)
+			if err != nil {
+				conn.Close()
+			}
+		}()
+	}
+}

conf/hmq.config

@@ -2,13 +2,11 @@
 	"workerNum": 4096,
 	"port": "1883",
 	"host": "0.0.0.0",
-	"debug": true,
 	"cluster": {
 		"host": "0.0.0.0",
 		"port": "1993"
 	},
 	"httpPort": "8080",
-	"router": "127.0.0.1:9888",
 	"tlsPort": "8883",
 	"tlsHost": "0.0.0.0",
 	"wsPort": "1888",
@@ -21,7 +19,7 @@
 		"keyFile": "ssl/server/key.pem"
 	},
 	"plugins": {
-		"auth": "authhttp",
-		"bridge": "kafka"
+		"auth": "mock",
+		"bridge": "csvlog"
 	}
 }

deploy/deploy.yaml

@@ -14,7 +14,7 @@ spec:
     spec:
       containers:
         - name: mqtt-broker
-          image: uhub.service.ucloud.cn/uiot_core_hub/hmq:v0.1.0
+          image: hmq:v0.1.0
           ports:
             - containerPort: 1883
             - containerPort: 8080

go.mod

@@ -1,27 +1,65 @@
 module github.com/fhmq/hmq
 
-go 1.12
+go 1.25.2
 
 require (
-	github.com/Shopify/sarama v1.26.1
-	github.com/bitly/go-simplejson v0.5.0
-	github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 // indirect
-	github.com/eclipse/paho.mqtt.golang v1.2.0
-	github.com/gin-gonic/gin v1.4.0
-	github.com/golang/protobuf v1.3.2 // indirect
-	github.com/kr/pretty v0.1.0 // indirect
+	github.com/Shopify/sarama v1.38.1
+	github.com/bitly/go-simplejson v0.5.1
+	github.com/cespare/xxhash/v2 v2.3.0
+	github.com/eapache/queue v1.1.0
+	github.com/eclipse/paho.mqtt.golang v1.5.1
+	github.com/gin-gonic/gin v1.10.1
+	github.com/google/uuid v1.3.0
+	github.com/json-iterator/go v1.1.12
+	github.com/natefinch/npipe v0.0.0-20160621034901-c1b8fa8bdcce
 	github.com/patrickmn/go-cache v2.1.0+incompatible
-	github.com/pkg/errors v0.8.1 // indirect
-	github.com/satori/go.uuid v1.2.0
-	github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e
-	github.com/stretchr/testify v1.3.0
-	github.com/tidwall/gjson v1.3.0
-	go.uber.org/atomic v1.4.0 // indirect
-	go.uber.org/multierr v1.1.0 // indirect
-	go.uber.org/zap v1.10.0
-	golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4 // indirect
-	golang.org/x/net v0.0.0-20190724013045-ca1201d0de80
-	golang.org/x/sys v0.0.0-20190730183949-1393eb018365 // indirect
-	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
-	gopkg.in/jcmturner/goidentity.v3 v3.0.0 // indirect
+	github.com/stretchr/testify v1.10.0
+	go.uber.org/zap v1.27.0
+	golang.org/x/net v0.47.0
+)
+
+require (
+	github.com/bytedance/sonic v1.11.6 // indirect
+	github.com/bytedance/sonic/loader v0.1.1 // indirect
+	github.com/cloudwego/base64x v0.1.4 // indirect
+	github.com/cloudwego/iasm v0.2.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/eapache/go-resiliency v1.3.0 // indirect
+	github.com/eapache/go-xerial-snappy v0.0.0-20230111030713-bf00bc1b83b6 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.20.0 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/hashicorp/errwrap v1.0.0 // indirect
+	github.com/hashicorp/go-multierror v1.1.1 // indirect
+	github.com/hashicorp/go-uuid v1.0.3 // indirect
+	github.com/jcmturner/aescts/v2 v2.0.0 // indirect
+	github.com/jcmturner/dnsutils/v2 v2.0.0 // indirect
+	github.com/jcmturner/gofork v1.7.6 // indirect
+	github.com/jcmturner/gokrb5/v8 v8.4.3 // indirect
+	github.com/jcmturner/rpc/v2 v2.0.3 // indirect
+	github.com/klauspost/compress v1.15.14 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+	github.com/pierrec/lz4/v4 v4.1.17 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect
+	github.com/rogpeppe/go-internal v1.12.0 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.12 // indirect
+	go.uber.org/multierr v1.10.0 // indirect
+	golang.org/x/arch v0.8.0 // indirect
+	golang.org/x/crypto v0.45.0 // indirect
+	golang.org/x/sys v0.38.0 // indirect
+	golang.org/x/text v0.31.0 // indirect
+	google.golang.org/protobuf v1.34.1 // indirect
+	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,119 +1,178 @@
-github.com/DataDog/zstd v1.3.6-0.20190409195224-796139022798 h1:2T/jmrHeTezcCM58lvEQXs0UpQJCo5SoGAcg+mbSTIg=
-github.com/DataDog/zstd v1.3.6-0.20190409195224-796139022798/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo=
-github.com/Shopify/sarama v1.23.0 h1:slvlbm7bxyp7sKQbUwha5BQdZTqurhRoI+zbKorVigQ=
-github.com/Shopify/sarama v1.23.0/go.mod h1:XLH1GYJnLVE0XCr6KdJGVJRTwY30moWNJ4sERjXX6fs=
-github.com/Shopify/toxiproxy v2.1.4+incompatible h1:TKdv8HiTLgE5wdJuEML90aBgNWsokNbMijUGhmcoBJc=
-github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
-github.com/bitly/go-simplejson v0.5.0 h1:6IH+V8/tVMab511d5bn4M7EwGXZf9Hj6i2xSwkNEM+Y=
-github.com/bitly/go-simplejson v0.5.0/go.mod h1:cXHtHw4XUPsvGaxgjIAn8PhEWG9NfngEKAMDJEczWVA=
-github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 h1:DDGfHa7BWjL4YnC6+E63dPcxHo2sUxDIu8g3QgEJdRY=
-github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4=
-github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/Shopify/sarama v1.38.1 h1:lqqPUPQZ7zPqYlWpTh+LQ9bhYNu2xJL6k1SJN4WVe2A=
+github.com/Shopify/sarama v1.38.1/go.mod h1:iwv9a67Ha8VNa+TifujYoWGxWnu2kNVAQdSdZ4X2o5g=
+github.com/Shopify/toxiproxy/v2 v2.5.0 h1:i4LPT+qrSlKNtQf5QliVjdP08GyAH8+BUIc9gT0eahc=
+github.com/Shopify/toxiproxy/v2 v2.5.0/go.mod h1:yhM2epWtAmel9CB8r2+L+PCmhH6yH2pITaPAo7jxJl0=
+github.com/bitly/go-simplejson v0.5.1 h1:xgwPbetQScXt1gh9BmoJ6j9JMr3TElvuIyjR8pgdoow=
+github.com/bitly/go-simplejson v0.5.1/go.mod h1:YOPVLzCfwK14b4Sff3oP1AmGhI9T9Vsg84etUnlyp+Q=
+github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc0=
+github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
+github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
+github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
+github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
+github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
+github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/eapache/go-resiliency v1.1.0 h1:1NtRmCAqadE2FN4ZcN6g90TP3uk8cg9rn9eNK2197aU=
-github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
-github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21 h1:YEetp8/yCZMuEPMUDHG0CW/brkkEp8mzqk2+ODEitlw=
-github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
+github.com/eapache/go-resiliency v1.3.0 h1:RRL0nge+cWGlxXbUzJ7yMcq6w2XBEr19dCN6HECGaT0=
+github.com/eapache/go-resiliency v1.3.0/go.mod h1:5yPzW0MIvSe0JDsv0v+DvcjEv2FyD6iZYSs1ZI+iQho=
+github.com/eapache/go-xerial-snappy v0.0.0-20230111030713-bf00bc1b83b6 h1:8yY/I9ndfrgrXUbOGObLHKBR4Fl3nZXwM2c7OYTT8hM=
+github.com/eapache/go-xerial-snappy v0.0.0-20230111030713-bf00bc1b83b6/go.mod h1:YvSRo5mw33fLEx1+DlK6L2VV43tJt5Eyel9n9XBcR+0=
 github.com/eapache/queue v1.1.0 h1:YOEu7KNc61ntiQlcEeUIoDTJ2o8mQznoNvUhiigpIqc=
 github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
-github.com/eclipse/paho.mqtt.golang v1.2.0 h1:1F8mhG9+aO5/xpdtFkW4SxOJB67ukuDC3t2y2qayIX0=
-github.com/eclipse/paho.mqtt.golang v1.2.0/go.mod h1:H9keYFcgq3Qr5OUJm/JZI/i6U7joQ8SYLhZwfeOo6Ts=
-github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3 h1:t8FVkw33L+wilf2QiWkw0UV77qRpcH/JHPKGpKa2E8g=
-github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s=
-github.com/gin-gonic/gin v1.4.0 h1:3tMoCCfM7ppqsR0ptz/wi1impNpT7/9wQtMZ8lr1mCQ=
-github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM=
-github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
-github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/hashicorp/go-uuid v1.0.1 h1:fv1ep09latC32wFoVwnqcnKJGnMSdBanPczbHAYm1BE=
-github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
-github.com/jcmturner/gofork v0.0.0-20190328161633-dc7c13fece03 h1:FUwcHNlEqkqLjLBdCp5PRlCFijNjvcYANOZXzCfXwCM=
-github.com/jcmturner/gofork v0.0.0-20190328161633-dc7c13fece03/go.mod h1:MK8+TM0La+2rjBD4jE12Kj1pCCxK7d2LK/UM3ncEo0o=
-github.com/json-iterator/go v1.1.6 h1:MrUvLMLTMxbqFJ9kzlvat/rYZqZnW3u4wkLzWTaFwKs=
-github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/mattn/go-isatty v0.0.7 h1:UvyT9uN+3r7yLEYSlJsbQGdsaB/a0DlgWP3pql6iwOc=
-github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/eclipse/paho.mqtt.golang v1.5.1 h1:/VSOv3oDLlpqR2Epjn1Q7b2bSTplJIeV2ISgCl2W7nE=
+github.com/eclipse/paho.mqtt.golang v1.5.1/go.mod h1:1/yJCneuyOoCOzKSsOTUc0AJfpsItBGWvYpBLimhArU=
+github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw=
+github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
+github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
+github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.10.1 h1:T0ujvqyCSqRopADpgPgiTT63DUQVSfojyME59Ei63pQ=
+github.com/gin-gonic/gin v1.10.1/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.20.0 h1:K9ISHbSaI0lyB2eWMPJo+kOS/FBExVwjEviJTixqxL8=
+github.com/go-playground/validator/v10 v10.20.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
+github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/securecookie v1.1.1/go.mod h1:ra0sb63/xPlUeL+yeDciTfxMRAA+MP+HVt/4epWDjd4=
+github.com/gorilla/sessions v1.2.1/go.mod h1:dk2InVEVJ0sfLlnXv9EAgkf6ecYs/i80K/zI+bUmuGM=
+github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
+github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
+github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-uuid v1.0.3 h1:2gKiV6YVmrJ1i2CKKa9obLvRieoRGviZFL26PcT/Co8=
+github.com/hashicorp/go-uuid v1.0.3/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/jcmturner/aescts/v2 v2.0.0 h1:9YKLH6ey7H4eDBXW8khjYslgyqG2xZikXP0EQFKrle8=
+github.com/jcmturner/aescts/v2 v2.0.0/go.mod h1:AiaICIRyfYg35RUkr8yESTqvSy7csK90qZ5xfvvsoNs=
+github.com/jcmturner/dnsutils/v2 v2.0.0 h1:lltnkeZGL0wILNvrNiVCR6Ro5PGU/SeBvVO/8c/iPbo=
+github.com/jcmturner/dnsutils/v2 v2.0.0/go.mod h1:b0TnjGOvI/n42bZa+hmXL+kFJZsFT7G4t3HTlQ184QM=
+github.com/jcmturner/gofork v1.7.6 h1:QH0l3hzAU1tfT3rZCnW5zXl+orbkNMMRGJfdJjHVETg=
+github.com/jcmturner/gofork v1.7.6/go.mod h1:1622LH6i/EZqLloHfE7IeZ0uEJwMSUyQ/nDd82IeqRo=
+github.com/jcmturner/goidentity/v6 v6.0.1 h1:VKnZd2oEIMorCTsFBnJWbExfNN7yZr3EhJAxwOkZg6o=
+github.com/jcmturner/goidentity/v6 v6.0.1/go.mod h1:X1YW3bgtvwAXju7V3LCIMpY0Gbxyjn/mY9zx4tFonSg=
+github.com/jcmturner/gokrb5/v8 v8.4.3 h1:iTonLeSJOn7MVUtyMT+arAn5AKAPrkilzhGw8wE/Tq8=
+github.com/jcmturner/gokrb5/v8 v8.4.3/go.mod h1:dqRwJGXznQrzw6cWmyo6kH+E7jksEQG/CyVWsJEsJO0=
+github.com/jcmturner/rpc/v2 v2.0.3 h1:7FXXj8Ti1IaVFpSAziCZWNzbNuZmnvw/i6CqLNdWfZY=
+github.com/jcmturner/rpc/v2 v2.0.3/go.mod h1:VUJYCIDm3PVOEHw8sgt091/20OJjskO/YJki3ELg/Hc=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/compress v1.15.14 h1:i7WCKDToww0wA+9qrUZ1xOjp218vfFo3nTU6UHp+gOc=
+github.com/klauspost/compress v1.15.14/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
+github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
+github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
+github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
-github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/natefinch/npipe v0.0.0-20160621034901-c1b8fa8bdcce h1:TqjP/BTDrwN7zP9xyXVuLsMBXYMt6LLYi55PlrIcq8U=
+github.com/natefinch/npipe v0.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:ifHPsLndGGzvgzcaXUvzmt6LxKT4pJ+uzEhtnMt+f7A=
 github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc=
 github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
-github.com/pierrec/lz4 v0.0.0-20190327172049-315a67e90e41 h1:GeinFsrjWz97fAxVUEd748aV0cYL+I6k44gFJTCVvpU=
-github.com/pierrec/lz4 v0.0.0-20190327172049-315a67e90e41/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc=
-github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA=
+github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
+github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
+github.com/pierrec/lz4/v4 v4.1.17 h1:kV4Ip+/hUBC+8T6+2EgburRtkE9ef4nbY3f4dFhGjMc=
+github.com/pierrec/lz4/v4 v4.1.17/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a h1:9ZKAASQSHhDYGoxY8uLVpewe1GDZ2vu2Tr/vTdVAkFQ=
-github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
-github.com/satori/go.uuid v1.2.0 h1:0uYX9dsZ2yD7q2RtLRtPSdGDWzjeM3TbMJP9utgA0ww=
-github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
-github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e h1:uO75wNGioszjmIzcY/tvdDYKRLVvzggtAmmJkn9j4GQ=
-github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e/go.mod h1:tm/wZFQ8e24NYaBGIlnO2WGCAi67re4HHuOm0sftE/M=
+github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 h1:N/ElC8H3+5XpJzTSTfLsJV/mx9Q9g7kxmchpfZyxgzM=
+github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
+github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/tidwall/gjson v1.3.0 h1:kfpsw1W3trbg4Xm6doUtqSl9+LhLB6qJ9PkltVAQZYs=
-github.com/tidwall/gjson v1.3.0/go.mod h1:P256ACg0Mn+j1RXIDXoss50DeIABTYK1PULOJHhxOls=
-github.com/tidwall/match v1.0.1 h1:PnKP62LPNxHKTwvHHZZzdOAOCtsJTjo6dZLCwpKm5xc=
-github.com/tidwall/match v1.0.1/go.mod h1:LujAq0jyVjBy028G1WhWfIzbpQfMO8bBZ6Tyb0+pL9E=
-github.com/tidwall/pretty v1.0.0 h1:HsD+QiTn7sK6flMKIvNmpqz1qrpP3Ps6jOKIKMooyg4=
-github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
-github.com/ugorji/go v1.1.4 h1:j4s+tAvLfL3bZyefP2SEWmhBzmuIlH/eqNuPdFPgngw=
-github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
-github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c/go.mod h1:lB8K/P019DLNhemzwFU4jHLhdvlE6uDZjXFejJXr49I=
-github.com/xdg/stringprep v1.0.0/go.mod h1:Jhud4/sHMO4oL310DaZAKk9ZaJ08SJfe+sJh0HrGL1Y=
-go.uber.org/atomic v1.4.0 h1:cxzIVoETapQEqDhQu3QfnvXAV4AlzcvUCxkVUFw3+EU=
-go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/multierr v1.1.0 h1:HoEmRHQPVSqub6w2z2d2EOVs2fjyFRGyofhKuyDq0QI=
-go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
-go.uber.org/zap v1.10.0 h1:ORx85nbTijNz8ljznvCMR1ZBIPKFn3jQrag10X2AsuM=
-go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
+github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ=
+go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
+go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
+golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190404164418-38d8ce5564a5/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
-golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4 h1:HuIa8hRrWRSrqYzx1qI49NNxhdi2PrY7gxVSq1JjLDc=
-golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c h1:uOCk1iQW6Vc18bnC13MfzScl+wdKBmM9Y9kU7Z83/lw=
-golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190724013045-ca1201d0de80 h1:Ao/3l156eZf2AW5wK8a7/smtodRU+gha3+BeqJ69lRk=
-golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a h1:1BGLXjeY4akVXGgbC9HugT3Jv3hCI0z56oJR5vAMgBU=
+golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
+golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
+golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220725212005-46097bf591d3/go.mod h1:AaygXjzTFtRAg2ttMY5RMuhpJ3cNnI0XpyFJD1iQRSM=
+golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
+golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
+golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I=
+golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190730183949-1393eb018365 h1:SaXEMXhWzMJThc05vu6uh61Q245r4KaWMrsTedk0FDc=
-golang.org/x/sys v0.0.0-20190730183949-1393eb018365/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
+golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=
+google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/go-playground/assert.v1 v1.2.1 h1:xoYuJVE7KT85PYWrN730RguIQO0ePzVRfFMXadIrXTM=
-gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE=
-gopkg.in/go-playground/validator.v8 v8.18.2 h1:lFB4DoMU6B626w8ny76MV7VX6W2VHct2GVOI3xgiMrQ=
-gopkg.in/go-playground/validator.v8 v8.18.2/go.mod h1:RX2a/7Ha8BgOhfk7j780h4/u/RRjR0eouCJSH80/M2Y=
-gopkg.in/jcmturner/aescts.v1 v1.0.1 h1:cVVZBK2b1zY26haWB4vbBiZrfFQnfbTVrE3xZq6hrEw=
-gopkg.in/jcmturner/aescts.v1 v1.0.1/go.mod h1:nsR8qBOg+OucoIW+WMhB3GspUQXq9XorLnQb9XtvcOo=
-gopkg.in/jcmturner/dnsutils.v1 v1.0.1 h1:cIuC1OLRGZrld+16ZJvvZxVJeKPsvd5eUIvxfoN5hSM=
-gopkg.in/jcmturner/dnsutils.v1 v1.0.1/go.mod h1:m3v+5svpVOhtFAP/wSz+yzh4Mc0Fg7eRhxkJMWSIz9Q=
-gopkg.in/jcmturner/goidentity.v3 v3.0.0 h1:1duIyWiTaYvVx3YX2CYtpJbUFd7/UuPYCfgXtQ3VTbI=
-gopkg.in/jcmturner/goidentity.v3 v3.0.0/go.mod h1:oG2kH0IvSYNIu80dVAyu/yoefjq1mNfM5bm88whjWx4=
-gopkg.in/jcmturner/gokrb5.v7 v7.2.3 h1:hHMV/yKPwMnJhPuPx7pH2Uw/3Qyf+thJYlisUc44010=
-gopkg.in/jcmturner/gokrb5.v7 v7.2.3/go.mod h1:l8VISx+WGYp+Fp7KRbsiUuXTTOnxIc3Tuvyavf11/WM=
-gopkg.in/jcmturner/rpc.v1 v1.1.0 h1:QHIUxTX1ISuAv9dD2wJ9HWQVuWDX/Zc0PfeC2tjc4rU=
-gopkg.in/jcmturner/rpc.v1 v1.1.0/go.mod h1:YIdkC4XfD6GXbzje11McwsDuOlZQSb9W4vfLvuNnlv8=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce h1:+JknDZhAj8YMt7GC73Ei8pv4MzjDUNPHgQWJdtMAaDU=
+gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:5AcXVHNjg+BDxry382+8OKon8SEWiKktQR07RKPsv1c=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

logger/logger.go

@@ -38,6 +38,15 @@ func NewProdLogger() (*zap.Logger, error) {
 	return logCfg.Build()
 }
 
+// NewReleaseLogger return a logger for production builds
+func NewReleaseLogger() (*zap.Logger, error) {
+	logCfg := zap.NewProductionConfig()
+	logCfg.DisableStacktrace = true
+	logCfg.Level = zap.NewAtomicLevelAt(zap.ErrorLevel)
+	logCfg.EncoderConfig = encoderCfg
+	return logCfg.Build()
+}
+
 func Prod() *zap.Logger {
 
 	l, _ := NewProdLogger()
@@ -54,6 +63,14 @@ func Debug() *zap.Logger {
 	return instance
 }
 
+func Release() *zap.Logger {
+
+	l, _ := NewReleaseLogger()
+	instance = l
+
+	return instance
+}
+
 func Get() *zap.Logger {
 	if instance == nil {
 		l, _ := NewProdLogger()

main.go

@@ -1,29 +1,30 @@
 package main
 
 import (
-	"log"
 	"os"
 	"os/signal"
-	"runtime"
 
 	"github.com/fhmq/hmq/broker"
+	"github.com/fhmq/hmq/logger"
+	"go.uber.org/zap"
 )
 
+var log = logger.Get()
+
 func main() {
-	runtime.GOMAXPROCS(runtime.NumCPU())
 	config, err := broker.ConfigureConfig(os.Args[1:])
 	if err != nil {
-		log.Fatal("configure broker config error: ", err)
+		log.Fatal("configure broker config error", zap.Error(err))
 	}
 
 	b, err := broker.NewBroker(config)
 	if err != nil {
-		log.Fatal("New Broker error: ", err)
+		log.Fatal("New Broker error: ", zap.Error(err))
 	}
 	b.Start()
 
 	s := waitForSignal()
-	log.Println("signal received, broker closed.", s)
+	log.Info("signal received, broker closed.", zap.Any("signal", s))
 }
 
 func waitForSignal() os.Signal {

plugins/auth/authfile/acl.go

@@ -19,5 +19,5 @@ func (a *aclAuth) CheckConnect(clientID, username, password string) bool {
 }
 
 func (a *aclAuth) CheckACL(action, clientID, username, ip, topic string) bool {
-	return checkTopicAuth(a.config, action, username, ip, clientID, topic)
+	return checkTopicAuth(a.config, action, ip, username, clientID, topic)
 }

plugins/auth/authfile/acl_test.go

@@ -0,0 +1,23 @@
+//+build test
+
+package acl
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestOrigAcls(t *testing.T) {
+	pwd, _ := os.Getwd()
+	os.Chdir("../../../")
+	aclOrig := Init()
+	os.Chdir(pwd)
+
+	// rule: allow      ip          127.0.0.1      2         $SYS/#
+	origAllowed := aclOrig.CheckACL(PUB, "dummyClientID", "dummyUser", "127.0.0.1", "$SYS/something")
+	assert.True(t, origAllowed)
+	origAllowed = aclOrig.CheckACL(SUB, "dummyClientID", "dummyUser", "127.0.0.1", "$SYS/something")
+	assert.False(t, origAllowed)
+}

plugins/auth/authfile/aclconfig.go

@@ -37,14 +37,14 @@ func AclConfigLoad(file string) (*ACLConfig, error) {
 		File: file,
 		Info: make([]*AuthInfo, 0, 4),
 	}
-	err := aclconifg.Prase()
+	err := aclconifg.Parse()
 	if err != nil {
 		return nil, err
 	}
 	return aclconifg, err
 }
 
-func (c *ACLConfig) Prase() error {
+func (c *ACLConfig) Parse() error {
 	f, err := os.Open(c.File)
 	defer f.Close()
 	if err != nil {

plugins/auth/authhttp/authhttp.go

@@ -56,7 +56,7 @@ func Init() *authHTTP {
 	return &authHTTP{client: httpClient}
 }
 
-//CheckAuth check mqtt connect
+// CheckConnect check mqtt connect
 func (a *authHTTP) CheckConnect(clientID, username, password string) bool {
 	action := "connect"
 	{

plugins/bridge/CSVLog.md

@@ -0,0 +1,50 @@
+# CSVLog Plugin For HMQ
+This is a bridge implementation for HMQ that allows messages to be logged to a CSV file at runtime.
+
+It can be used for debugging/monitoring purposes, for integration with other systems/platforms, or as an audit trail of messages.
+
+The plugin allows you to define 0, 1, or more filters which determine which messages get bridged. Where no filters are defined the plugin bridges every message. Where one or more filters exist, the plugin applies  the filter/s and only brdiges messages that match the filter spec.
+
+The plugin allows you provide a filename for the output file, and also supports three special filenames {LOG},{STDOUT}, and {NULL}. {LOG} results in messages being bridged to the log, {STDOUT} bridges them to Std out, and {NULL} simply skips and returns without an error.
+
+## Configuration
+The configiration settings for CSVLog are defined by the struct csvBridgeConfig.
+```
+type csvBridgeConfig struct {
+	FileName          string   `json:"fileName"`
+	LogFileMaxSizeMB  int64    `json:"logFileMaxSizeMB"`
+	LogFileMaxFiles   int64    `json:"logFileMaxFiles"`
+	WriteIntervalSecs int64    `json:"writeIntervalSecs"`
+	CommandTopic      string   `json:"commandTopic"`
+	Filters           []string `json:"filters"`
+}
+```
+| Setting | Description |
+| ----------- | ----------- |
+| FileName | A complete filename for the output file, or {LOG} to send bridged messages to the log, {STDOUT} to send bridged messages to STDOUT, or {NULL} to not bridge anything at all |
+| LogFileMaxSizeMB | The size in megabytes at which the log file is rotated |
+| LogFileMaxFiles | The maximum number of rotated logfiles to retain before they're deleted |
+| WriteIntervalSecs | The delay before flushing any pending writes to the file |
+| CommandTopic | The name of a topic to which commands relating to CSVLog will be sent eg "bridge/CSVLOG/command" |
+| Filters | An array of filter specifications which are used to determine which messages are bridged, if there are no filters specified the filter is assumed to be "#" which bridges everything. Filters are specified the same way that topic acls are described|
+
+## Filters
+
+Filters use the same syntax as for ACL permissions.
+
+So a filter can name a specific topic..
+
+"animals/cats" will bridge messages sent to the "animals/cats" topic. 
+
+A filter can use the + or # wildcards so
+
+"animals/cats/+" will bridge messages sent to "animals/cats/breeds", "animals/cats/colours" but not "animals/cats/breeds/longhair"
+
+"animals/cats/#" will bridge messages sent to "animals/cats/breeds", "animals/cats/colours", "animals/cats/breeds/longhair", etc
+
+## Commands
+Currently two commands can be sent to the CSVLog bridge:
+
+ROTATEFILE - Triggers an immediate rotation of the log file
+
+REALOADCONFIG - Triggers a reload of the CSVLog config file

plugins/bridge/bridge.go

@@ -32,17 +32,21 @@ type Elements struct {
 
 const (
 	//Kafka plugin name
-	Kafka = "kafka"
+	Kafka  = "kafka"
+	CSVLog = "csvlog"
 )
 
 type BridgeMQ interface {
-	Publish(e *Elements) error
+	// Publish return true to cost the message
+	Publish(e *Elements) (bool, error)
 }
 
 func NewBridgeMQ(name string) BridgeMQ {
 	switch name {
 	case Kafka:
 		return InitKafka()
+	case CSVLog:
+		return InitCSVLog()
 	default:
 		return &mockMQ{}
 	}

plugins/bridge/csvlog.go

@@ -0,0 +1,414 @@
+package bridge
+
+/*
+Copyright (c) 2021, Gary Barnett @thinkovation. Released under the Apache 2 License
+
+CSVLog is a bridge plugin for HMQ that implements CSV logging of messages. See CSVLog.md for more information
+
+*/
+
+import (
+	"encoding/csv"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+type csvBridgeConfig struct {
+	FileName          string   `json:"fileName"`
+	LogFileMaxSizeMB  int64    `json:"logFileMaxSizeMB"`
+	LogFileMaxFiles   int64    `json:"logFileMaxFiles"`
+	WriteIntervalSecs int64    `json:"writeIntervalSecs"`
+	CommandTopic      string   `json:"commandTopic"`
+	Filters           []string `json:"filters"`
+}
+
+type csvLog struct {
+	config  csvBridgeConfig
+	buffer  []string
+	msgchan chan (*Elements)
+
+	sync.RWMutex
+}
+
+// rotateLog performs a log rotation - copying the current logfile to the base file name plus a timestamp
+func (c *csvLog) rotateLog(withPrune bool) error {
+	c.Lock()
+	filename := c.config.FileName
+	c.Unlock()
+
+	basename := strings.TrimSuffix(filename, filepath.Ext(filename))
+	newpath := basename + time.Now().Format("-20060102T150405") + filepath.Ext(filename)
+	renameError := os.Rename(filename, newpath)
+	if renameError != nil {
+		return renameError
+	}
+	outfile, _ := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	outfile.Close()
+	// Whenever we rotate a logfile we prune
+	if withPrune {
+		c.logFilePrune()
+
+	}
+	return nil
+
+}
+
+// writeToLog takes an array of elements and writes them to the logfile (or to log or stdout) spefified in
+// the configuration
+func (c *csvLog) writeToLog(els []Elements) error {
+
+	c.RLock()
+	fname := c.config.FileName
+	c.RUnlock()
+	if fname == "" {
+		fname = "CSVLOG.CSV"
+	}
+
+	if fname == "{LOG}" {
+		for _, value := range els {
+			t := time.Unix(value.Timestamp, 0)
+			log.Info(t.Format("2006-01-02T15:04:05") + " " + value.ClientID + " " + value.Username + " " + value.Action + " " + value.Topic + " " + value.Payload)
+		}
+		return nil
+	}
+	if fname == "{STDOUT}" {
+		for _, value := range els {
+			t := time.Unix(value.Timestamp, 0)
+			fmt.Println(t.Format("2006-01-02T15:04:05") + " " + value.ClientID + " " + value.Username + " " + value.Action + " " + value.Topic + " " + value.Payload)
+		}
+		return nil
+	}
+
+	var mbsize int64
+	fileStat, fileStatErr := os.Stat(fname)
+	if fileStatErr != nil {
+		log.Warn("Could not get CSVLog info. Received Err " + fileStatErr.Error())
+		mbsize = 0
+	} else {
+		mbsize = fileStat.Size() / 1024 / 1024
+	}
+	if mbsize > c.config.LogFileMaxSizeMB && c.config.LogFileMaxSizeMB != 0 {
+		rotateErr := c.rotateLog(true)
+		if rotateErr != nil {
+			log.Warn("Unable to rotate outputfile")
+		}
+	}
+	outfile, outfileOpenError := os.OpenFile(fname, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	defer outfile.Close()
+	if outfileOpenError != nil {
+		log.Warn("Could not open CSV Log file to write")
+		return errors.New("Could not write to CSV Log File")
+	}
+
+	writer := csv.NewWriter(outfile)
+	defer writer.Flush()
+
+	for _, value := range els {
+		t := time.Unix(value.Timestamp, 0)
+		var outrow = []string{t.Format("2006-01-02T15:04:05"), value.ClientID, value.Username, value.Action, value.Topic, value.Payload}
+		writeOutRowError := writer.Write(outrow)
+		if writeOutRowError != nil {
+			log.Warn("Could not write msg to CSV Log")
+		}
+	}
+	return nil
+
+}
+
+// Worker should be invoked as a goroutine - It listens on the csvlog message channel for incoming messages
+// for performance we batch messages into an outqueue and write them in bulk when a timer expires
+func (c *csvLog) Worker() {
+	log.Info("Running CSVLog worker")
+	var outqueue []Elements
+
+	for true {
+		c.RLock()
+		waitInterval := c.config.WriteIntervalSecs
+		c.RUnlock()
+
+		timer := time.NewTimer(time.Second * time.Duration(waitInterval))
+
+		select {
+
+		case p := <-c.msgchan:
+			c.RLock()
+
+			oktopublish := false
+
+			// Check to see if any filters are defined. If there are none we assume we're logging everything
+			if len(c.config.Filters) != 0 {
+				// We pick up a Read lock here to parse the c.config.Filters string array
+				// as it's a read lock, and write locks will be rare
+				// it feels as if this will be fine.
+				// If there is contention, it _might_ make sense to quickly lock c, get
+				// the filters and release the lock, then process the filters with no locks
+				// but I think it's unlikely
+
+				for _, filt := range c.config.Filters {
+					if topicMatch(p.Topic, filt) {
+						oktopublish = true
+						break
+
+					}
+
+				}
+
+			} else {
+				oktopublish = true
+			}
+			if oktopublish {
+				var el Elements
+				el.Action = p.Action
+				el.ClientID = p.ClientID
+				el.Payload = p.Payload
+				el.Size = p.Size
+				el.Timestamp = p.Timestamp
+				el.Topic = p.Topic
+				el.Username = p.Username
+				outqueue = append(outqueue, el)
+			}
+			c.RUnlock()
+			break
+		case <-timer.C:
+			if len(outqueue) > 0 {
+				writeResult := c.writeToLog(outqueue)
+				if writeResult != nil {
+					log.Warn("Trouble writing to CSV Log")
+				}
+				outqueue = nil
+
+			}
+			break
+		}
+
+	}
+}
+
+// LoadCSVLogConfig loads the configuration file - it currently looks in
+// "./plugins/csvlog/csvlogconfig.json" (following the example of the default location of the kafka plugin config file)
+// if it doesn't find it there it looks in two further places - the current directory and
+// an "assets" folder under the current directory (This is for compatibility with a couple of deployed)
+// implementations.
+func LoadCSVLogConfig() csvBridgeConfig {
+	// Check to see if the CSVLOGCONFFILE environment variable is set and if so
+	// check that it does actually point to a file
+	csvLogConfigFile := os.Getenv("CSVLOGCONFFILE")
+	if csvLogConfigFile != "" {
+		if _, err := os.Stat(csvLogConfigFile); os.IsNotExist(err) {
+			csvLogConfigFile = ""
+		}
+	}
+	// If csvLogConfigFile is blank look in the plugins directory,
+	// then the current directory for the csvLogConfigFile. If it's still not found we use a default config
+	// If the file does not exist, we use default parameters
+	if csvLogConfigFile == "" {
+		csvLogConfigFile = "./plugins/csvlog/csvlogconfig.json"
+	}
+	if _, err := os.Stat(csvLogConfigFile); os.IsNotExist(err) {
+
+		if _, err := os.Stat("csvlogconfig.json"); os.IsNotExist(err) {
+			csvLogConfigFile = ""
+		} else {
+			csvLogConfigFile = "csvlogconfig.json"
+		}
+	}
+
+	var configUnmarshalErr error
+	var config csvBridgeConfig
+	if csvLogConfigFile != "" {
+		log.Info("Trying to load config file from " + csvLogConfigFile)
+		content, err := ioutil.ReadFile(csvLogConfigFile)
+		if err != nil {
+			log.Info("Read config file error: ", zap.Error(err))
+		}
+		configUnmarshalErr = json.Unmarshal(content, &config)
+	}
+
+	if configUnmarshalErr != nil || config.FileName == "" {
+		log.Warn("Unable to load csvlog config file, so using default settings")
+		config.FileName = "/var/log/csvlog.log"
+		config.CommandTopic = "CSVLOG/command"
+		config.WriteIntervalSecs = 10
+		config.LogFileMaxSizeMB = 1
+		config.LogFileMaxFiles = 4
+
+	}
+	return config
+
+}
+
+// InitCSVLog initialises a CSVLOG plugin
+// It does this by loading a config file if one can be found. The default filename follows the same
+// convention as the kafka plugin - ie it's in "./plugins/csvlog/csvlogconfig.json" but an
+// environment var - CSVLOGCONFFILE - can be set to provide a different location.
+//
+// Once the config is set the worker is started
+func InitCSVLog() *csvLog {
+	log.Info("Trying to init CSVLOG")
+
+	c := &csvLog{config: LoadCSVLogConfig()}
+	c.msgchan = make(chan *Elements, 200)
+	//Start the csvlog worker
+	go c.Worker()
+	return c
+
+}
+
+// topicMatch accepts a topic name and a filter string, it then evaluates the
+// topic against the filter string and returns true if there is a match.
+//
+// The CSV bridge can be configured with 0, 1 or more filters - Where there are no
+// filters specified, every message will be re-published. Where there are filters, any message
+// that passes any of the filter tests will be re-published.
+func topicMatch(topic string, filter string) bool {
+	if topic == filter || filter == "#" {
+		return true
+	}
+	topicComponents := strings.Split(topic, "/")
+	filterComponents := strings.Split(filter, "/")
+	currentpos := 0
+	filterComponentsLength := len(filterComponents)
+	currentFilterComponent := ""
+	if filterComponentsLength > 0 {
+		currentFilterComponent = filterComponents[currentpos]
+	}
+	for _, topicVal := range topicComponents {
+		if currentFilterComponent == "" {
+			return false
+		}
+		if currentFilterComponent == "#" {
+			return true
+		}
+		if currentFilterComponent != "+" && currentFilterComponent != topicVal {
+			return false
+		}
+		currentpos++
+		if filterComponentsLength > currentpos {
+			currentFilterComponent = filterComponents[currentpos]
+		} else {
+			currentFilterComponent = ""
+		}
+	}
+	return true
+}
+
+// logFilePrune checks the number of rotated logfiles and prunes them
+func (c *csvLog) logFilePrune() error {
+
+	// List the rotated files
+	c.RLock()
+	filename := c.config.FileName
+	maxfiles := c.config.LogFileMaxFiles
+	c.RUnlock()
+	if maxfiles == 0 {
+		return nil
+	}
+
+	fileExt := filepath.Ext(filename)
+	fileDir := filepath.Dir(filename)
+	baseFileName := strings.TrimSuffix(filepath.Base(filename), fileExt)
+
+	files, err := ioutil.ReadDir(fileDir)
+	if err != nil {
+		return err
+	}
+
+	var foundFiles []string
+	for _, file := range files {
+		if strings.HasPrefix(file.Name(), baseFileName+"-") {
+
+			foundFiles = append(foundFiles, file.Name())
+
+		}
+	}
+	if len(foundFiles) >= int(maxfiles) {
+		fmt.Println("Found ", len(foundFiles), " files")
+		sort.Strings(foundFiles)
+		for i := 0; i < len(foundFiles)-int(maxfiles); i++ {
+			fileDeleteError := os.Remove(fileDir + "//" + foundFiles[i])
+			log.Info("Pruning logfile " + fileDir + "//" + foundFiles[i])
+			if fileDeleteError != nil {
+				log.Warn("Could not delete file " + fileDir + "//" + foundFiles[i])
+
+			}
+
+		}
+
+	}
+
+	return nil
+
+}
+
+// Publish implements the bridge interface - it accepts an Element then checks to see if that element is a
+// message published to the admin topic for the plugin
+//
+func (c *csvLog) Publish(e *Elements) (bool, error) {
+	// A short-lived lock on c allows us to
+	// get the Command topic then release the lock
+	// This then allows us to process the command - which may
+	// take its a write lock on c (to update values) and then
+	// return here where we'll pick up a
+	// read lock to iterate over the c.config.filters
+	// We're trying to minimise the time spent in this function
+	// and to limit the overall time spent in any write locks.
+	c.RLock()
+	//CSVLOG allows you to configure a CommandTopic which is a topic to which commands affecting the behaviour of CSVLog can be sent
+	//The simplest would be a message with a payload of "RELOAD" which will reload the configuration allowing configuration changes to be
+	//made at runtime without restarting the broker
+	CommandTopic := c.config.CommandTopic
+	OutFile := c.config.FileName
+	c.RUnlock()
+	// If the outfile is set to "{NULL}" we don't do anything with the message - we just return nil
+	// This feature is here to allow CSVLOG to be enabled/disabled at runtime
+	if OutFile == "{NULL}" {
+		return false, nil
+	}
+
+	if e.Topic == CommandTopic {
+
+		log.Info("CSVLOG Command Received")
+
+		// Process Command
+		// These are going to be rare ocurrences, so in this implementation
+		// we will process the command here - but if we _really_ want to
+		// squeeze delays out, we could have a worker sitting on a
+		// command channel processing any commands.
+		if e.Payload == "RELOADCONFIG" {
+			newConfig := LoadCSVLogConfig()
+			c.Lock()
+			c.config = newConfig
+			c.Unlock()
+
+		}
+		if e.Payload == "ROTATEFILE" {
+
+			c.rotateLog(true)
+
+		}
+		if e.Payload == "ROTATEFILENOPRUNE" {
+
+			c.rotateLog(false)
+
+		}
+		// We could return without doing anything more here, but
+		// for now we move ahead with the filter processing on the
+		// basis that unless we either filter for "all" (with #) or
+		// filter for the CommandTopic, they won't be logged - but we
+		// may have a reason for wanting to track commands too
+	}
+	// Push the message into the channel and return
+	// the channel is buffered and is read by a goroutine so this should block for the shortest possible time
+	c.msgchan <- e
+	return false, nil
+}

plugins/bridge/csvlog_test.go

@@ -0,0 +1,36 @@
+package bridge
+
+import (
+	"fmt"
+	"testing"
+)
+
+//Test_topicMatch is here to double check the topic matching logic
+func Test_topicMatch(t *testing.T) {
+
+	tests := []struct {
+		name   string
+		topic  string
+		filter string
+		want   bool
+	}{
+		// Some sample test cases
+		{name: "Simple", topic: "test", filter: "test", want: true},
+		{name: "Simple", topic: "test/cat", filter: "test/+", want: true},
+		{name: "Simple", topic: "test/cat/breed", filter: "test/+", want: false},
+		{name: "Simple", topic: "test/cat", filter: "test/#", want: true},
+		{name: "Simple", topic: "test/cat/banana", filter: "test/#", want: true},
+		{name: "Simple", topic: "test/cat/banana", filter: "test/+", want: false},
+		{name: "Simple", topic: "test/dog/banana", filter: "test/cat/+", want: false},
+		{name: "Simple", topic: "test/cat/banana", filter: "test/+/banana", want: true},
+	}
+
+	for _, tt := range tests {
+		fmt.Println(tt)
+		t.Run(tt.name, func(t *testing.T) {
+			if got := topicMatch(tt.topic, tt.filter); got != tt.want {
+				t.Errorf("topicMatch() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

plugins/bridge/kafka.go

@@ -11,7 +11,7 @@ import (
 	"go.uber.org/zap"
 )
 
-type kafakConfig struct {
+type kafkaConfig struct {
 	Addr             []string          `json:"addr"`
 	ConnectTopic     string            `json:"onConnect"`
 	SubscribeTopic   string            `json:"onSubscribe"`
@@ -22,11 +22,11 @@ type kafakConfig struct {
 }
 
 type kafka struct {
-	kafakConfig kafakConfig
+	kafkaConfig kafkaConfig
 	kafkaClient sarama.AsyncProducer
 }
 
-//Init init kafak client
+// InitKafka Init kafka client
 func InitKafka() *kafka {
 	log.Info("start connect kafka....")
 	content, err := ioutil.ReadFile("./plugins/kafka/kafka.json")
@@ -34,12 +34,12 @@ func InitKafka() *kafka {
 		log.Fatal("Read config file error: ", zap.Error(err))
 	}
 	// log.Info(string(content))
-	var config kafakConfig
+	var config kafkaConfig
 	err = json.Unmarshal(content, &config)
 	if err != nil {
 		log.Fatal("Unmarshal config file error: ", zap.Error(err))
 	}
-	c := &kafka{kafakConfig: config}
+	c := &kafka{kafkaConfig: config}
 	c.connect()
 	return c
 }
@@ -48,7 +48,7 @@ func InitKafka() *kafka {
 func (k *kafka) connect() {
 	conf := sarama.NewConfig()
 	conf.Version = sarama.V1_1_1_0
-	kafkaClient, err := sarama.NewAsyncProducer(k.kafakConfig.Addr, conf)
+	kafkaClient, err := sarama.NewAsyncProducer(k.kafkaConfig.Addr, conf)
 	if err != nil {
 		log.Fatal("create kafka async producer failed: ", zap.Error(err))
 	}
@@ -63,8 +63,8 @@ func (k *kafka) connect() {
 }
 
 //Publish publish to kafka
-func (k *kafka) Publish(e *Elements) error {
-	config := k.kafakConfig
+func (k *kafka) Publish(e *Elements) (bool, error) {
+	config := k.kafkaConfig
 	key := e.ClientID
 	topics := make(map[string]bool)
 	switch e.Action {
@@ -96,10 +96,10 @@ func (k *kafka) Publish(e *Elements) error {
 			topics[config.DisconnectTopic] = true
 		}
 	default:
-		return errors.New("error action: " + e.Action)
+		return false, errors.New("error action: " + e.Action)
 	}
 
-	return k.publish(topics, key, e)
+	return false, k.publish(topics, key, e)
 
 }
 

plugins/bridge/mock.go

@@ -2,6 +2,6 @@ package bridge
 
 type mockMQ struct{}
 
-func (m *mockMQ) Publish(e *Elements) error {
-	return nil
+func (m *mockMQ) Publish(e *Elements) (bool, error) {
+	return false, nil
 }

pool/fixpool.go

@@ -1,7 +1,7 @@
 package pool
 
 import (
-	"github.com/segmentio/fasthash/fnv1a"
+	"github.com/cespare/xxhash/v2"
 )
 
 type WorkerPool struct {
@@ -29,7 +29,7 @@ func New(maxWorkers int) *WorkerPool {
 }
 
 func (p *WorkerPool) Submit(uid string, task func()) {
-	idx := fnv1a.HashString64(uid) % uint64(p.maxWorkers)
+	idx := xxhash.Sum64([]byte(uid)) % uint64(p.maxWorkers)
 	if task != nil {
 		p.taskQueue[idx] <- task
 	}
@@ -43,16 +43,14 @@ func (p *WorkerPool) dispatch() {
 }
 
 func startWorker(taskChan chan func()) {
-	go func() {
-		var task func()
-		var ok bool
-		for {
-			task, ok = <-taskChan
-			if !ok {
-				break
-			}
-			// Execute the task.
-			task()
+	var task func()
+	var ok bool
+	for {
+		task, ok = <-taskChan
+		if !ok {
+			break
 		}
-	}()
+		// Execute the task.
+		task()
+	}
 }

pool/pool.go

@@ -1,166 +0,0 @@
-package pool
-
-// import "time"
-
-// const (
-// 	// This value is the size of the queue that workers register their
-// 	// availability to the dispatcher.  There may be hundreds of workers, but
-// 	// only a small channel is needed to register some of the workers.
-// 	readyQueueSize = 64
-
-// 	// If worker pool receives no new work for this period of time, then stop
-// 	// a worker goroutine.
-// 	idleTimeoutSec = 5
-// )
-
-// type WorkerPool struct {
-// 	maxWorkers   int
-// 	timeout      time.Duration
-// 	taskQueue    chan func()
-// 	readyWorkers chan chan func()
-// 	stoppedChan  chan struct{}
-// }
-
-// func New(maxWorkers int) *WorkerPool {
-// 	// There must be at least one worker.
-// 	if maxWorkers < 1 {
-// 		maxWorkers = 1
-// 	}
-
-// 	// taskQueue is unbuffered since items are always removed immediately.
-// 	pool := &WorkerPool{
-// 		taskQueue:    make(chan func()),
-// 		maxWorkers:   maxWorkers,
-// 		readyWorkers: make(chan chan func(), readyQueueSize),
-// 		timeout:      time.Second * idleTimeoutSec,
-// 		stoppedChan:  make(chan struct{}),
-// 	}
-
-// 	// Start the task dispatcher.
-// 	go pool.dispatch()
-
-// 	return pool
-// }
-
-// func (p *WorkerPool) Stop() {
-// 	if p.Stopped() {
-// 		return
-// 	}
-// 	close(p.taskQueue)
-// 	<-p.stoppedChan
-// }
-
-// func (p *WorkerPool) Stopped() bool {
-// 	select {
-// 	case <-p.stoppedChan:
-// 		return true
-// 	default:
-// 	}
-// 	return false
-// }
-
-// func (p *WorkerPool) Submit(task func()) {
-// 	if task != nil {
-// 		p.taskQueue <- task
-// 	}
-// }
-
-// func (p *WorkerPool) SubmitWait(task func()) {
-// 	if task == nil {
-// 		return
-// 	}
-// 	doneChan := make(chan struct{})
-// 	p.taskQueue <- func() {
-// 		task()
-// 		close(doneChan)
-// 	}
-// 	<-doneChan
-// }
-
-// func (p *WorkerPool) dispatch() {
-// 	defer close(p.stoppedChan)
-// 	timeout := time.NewTimer(p.timeout)
-// 	var workerCount int
-// 	var task func()
-// 	var ok bool
-// 	var workerTaskChan chan func()
-// 	startReady := make(chan chan func())
-// Loop:
-// 	for {
-// 		timeout.Reset(p.timeout)
-// 		select {
-// 		case task, ok = <-p.taskQueue:
-// 			if !ok {
-// 				break Loop
-// 			}
-// 			// Got a task to do.
-// 			select {
-// 			case workerTaskChan = <-p.readyWorkers:
-// 				// A worker is ready, so give task to worker.
-// 				workerTaskChan <- task
-// 			default:
-// 				// No workers ready.
-// 				// Create a new worker, if not at max.
-// 				if workerCount < p.maxWorkers {
-// 					workerCount++
-// 					go func(t func()) {
-// 						startWorker(startReady, p.readyWorkers)
-// 						// Submit the task when the new worker.
-// 						taskChan := <-startReady
-// 						taskChan <- t
-// 					}(task)
-// 				} else {
-// 					// Start a goroutine to submit the task when an existing
-// 					// worker is ready.
-// 					go func(t func()) {
-// 						taskChan := <-p.readyWorkers
-// 						taskChan <- t
-// 					}(task)
-// 				}
-// 			}
-// 		case <-timeout.C:
-// 			// Timed out waiting for work to arrive.  Kill a ready worker.
-// 			if workerCount > 0 {
-// 				select {
-// 				case workerTaskChan = <-p.readyWorkers:
-// 					// A worker is ready, so kill.
-// 					close(workerTaskChan)
-// 					workerCount--
-// 				default:
-// 					// No work, but no ready workers.  All workers are busy.
-// 				}
-// 			}
-// 		}
-// 	}
-
-// 	// Stop all remaining workers as they become ready.
-// 	for workerCount > 0 {
-// 		workerTaskChan = <-p.readyWorkers
-// 		close(workerTaskChan)
-// 		workerCount--
-// 	}
-// }
-
-// func startWorker(startReady, readyWorkers chan chan func()) {
-// 	go func() {
-// 		taskChan := make(chan func())
-// 		var task func()
-// 		var ok bool
-// 		// Register availability on starReady channel.
-// 		startReady <- taskChan
-// 		for {
-// 			// Read task from dispatcher.
-// 			task, ok = <-taskChan
-// 			if !ok {
-// 				// Dispatcher has told worker to stop.
-// 				break
-// 			}
-
-// 			// Execute the task.
-// 			task()
-
-// 			// Register availability on readyWorkers channel.
-// 			readyWorkers <- taskChan
-// 		}
-// 	}()
-// }