Merge branch 'master' of https://github.com/fhmq/hmq

delete debug message body

.gitignore

@@ -1,3 +1,4 @@
 hmq
 log
 log/*
+*.test

Dockerfile

@@ -1,6 +1,5 @@
 FROM alpine
 COPY hmq /
-COPY hmq.config /
 COPY ssl /ssl
 COPY conf /conf
 

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -3,16 +3,59 @@ Free and High Performance MQTT Broker
 
 ## About
 Golang MQTT Broker, Version 3.1.1, and Compatible
-for [eclipse paho client](https://github.com/eclipse?utf8=%E2%9C%93&q=mqtt&type=&language=)
+for [eclipse paho client](https://github.com/eclipse?utf8=%E2%9C%93&q=mqtt&type=&language=) and mosquitto-client
+
+Download: [click here](https://github.com/fhmq/hmq/releases)
 
 ## RUNNING
 ```bash
-$ git clone https://github.com/fhmq/hmq.git
+$ go get github.com/fhmq/hmq
-$ cd hmq
+$ cd $GOPATH/github.com/fhmq/hmq
 $ go run main.go
 ```
 
-### broker.config
+## Usage of hmq:
+~~~
+Usage of ./hmq:
+  -w int
+        worker num to process message, perfer (client num)/10. (default 1024)
+  -worker int
+        worker num to process message, perfer (client num)/10. (default 1024)
+  -h string
+        Network host to listen on. (default "0.0.0.0")
+  -host string
+        Network host to listen on. (default "0.0.0.0")
+  -p string
+        Port to listen on. (default "1883")
+  -port string
+        Port to listen on. (default "1883")
+  -c string
+        config file for hmq
+  -config string
+        config file for hmq
+  -cluster string
+        Cluster ip from which members can connect.
+  -cluster_listen string
+        Cluster ip from which members can connect.
+  -cluster_port string
+        Cluster port from which members can connect.
+  -cp string
+        Cluster port from which members can connect.
+  -r string
+        Router who maintenance cluster info
+  -router string
+        Router who maintenance cluster info
+  -ws_path string
+        path for ws to listen on
+  -ws_port string
+        port for ws to listen on
+  -wspath string
+        path for ws to listen on
+  -wsport string
+        port for ws to listen on
+~~~
+
+### hmq.config
 ~~~
 {
 	"workerNum": 4096,
@@ -20,9 +63,9 @@ $ go run main.go
 	"host": "0.0.0.0",
 	"cluster": {
 		"host": "0.0.0.0",
-		"port": "1993",
+		"port": "1993"
-		"routers": ["10.10.0.11:1993","10.10.0.12:1993"]
 	},
+	"router": "127.0.0.1:9888",
 	"wsPort": "1888",
 	"wsPath": "/ws",
 	"wsTLS": true,
@@ -59,6 +102,13 @@ $ go run main.go
 
 * Flexible  ACL
 
+### Cluster
+```bash
+ 1, start router for hmq  (https://github.com/fhmq/router.git)
+ 2, config router in hmq.config  ("router": "127.0.0.1:9888")
+ 
+```
+
 ### QUEUE SUBSCRIBE
 ~~~
 | Prefix        | Examples                        |
@@ -129,4 +179,4 @@ Client -> | Rule1 | --nomatch--> | Rule2 | --nomatch--> | Rule3 | -->
 
 ## License
 
-* Apache License Version 2.0
+* Apache License Version 2.0

_config.yml

@@ -1 +0,0 @@
-theme: jekyll-theme-slate

broker/auth.go

@@ -1,10 +1,13 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
 package broker
 
 import (
-	"hmq/lib/acl"
 	"strings"
 
-	log "github.com/cihub/seelog"
+	"github.com/fhmq/hmq/lib/acl"
+	"go.uber.org/zap"
+
 	"github.com/fsnotify/fsnotify"
 )
 
@@ -40,10 +43,10 @@ func (b *Broker) handleFsEvent(event fsnotify.Event) error {
 	case b.config.AclConf:
 		if event.Op&fsnotify.Write == fsnotify.Write ||
 			event.Op&fsnotify.Create == fsnotify.Create {
-			log.Info("text:handling acl config change event:", event)
+			log.Info("text:handling acl config change event:", zap.String("filename", event.Name))
 			aclconfig, err := acl.AclConfigLoad(event.Name)
 			if err != nil {
-				log.Error("aclconfig change failed, load acl conf error: ", err)
+				log.Error("aclconfig change failed, load acl conf error: ", zap.Error(err))
 				return err
 			}
 			b.AclConfig = aclconfig
@@ -56,14 +59,14 @@ func (b *Broker) StartAclWatcher() {
 	go func() {
 		wch, e := fsnotify.NewWatcher()
 		if e != nil {
-			log.Error("start monitor acl config file error,", e)
+			log.Error("start monitor acl config file error,", zap.Error(e))
 			return
 		}
 		defer wch.Close()
 
 		for _, i := range watchList {
 			if err := wch.Add(i); err != nil {
-				log.Error("start monitor acl config file error,", err)
+				log.Error("start monitor acl config file error,", zap.Error(err))
 				return
 			}
 		}
@@ -73,7 +76,7 @@ func (b *Broker) StartAclWatcher() {
 			case evt := <-wch.Events:
 				b.handleFsEvent(evt)
 			case err := <-wch.Errors:
-				log.Error("error:", err.Error())
+				log.Error("error:", zap.Error(err))
 			}
 		}
 	}()

broker/broker.go

@@ -1,8 +1,9 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
 package broker
 
 import (
 	"crypto/tls"
-	"hmq/lib/acl"
 	"net"
 	"net/http"
 	"runtime/debug"
@@ -10,23 +11,32 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/fhmq/hmq/lib/acl"
+
 	"github.com/eclipse/paho.mqtt.golang/packets"
 	"github.com/shirou/gopsutil/mem"
+	"go.uber.org/zap"
 
 	"golang.org/x/net/websocket"
 
-	log "github.com/cihub/seelog"
+	"github.com/fhmq/hmq/logger"
+)
+
+var (
+	log = logger.Get().Named("Broker")
 )
 
 type Broker struct {
 	id        string
 	cid       uint64
+	mu        sync.Mutex
 	config    *Config
 	tlsConfig *tls.Config
 	AclConfig *acl.ACLConfig
 	clients   sync.Map
 	routes    sync.Map
 	remotes   sync.Map
+	nodes     map[string]interface{}
 	sl        *Sublist
 	rl        *RetainList
 	queues    map[string]int
@@ -38,12 +48,13 @@ func NewBroker(config *Config) (*Broker, error) {
 		config: config,
 		sl:     NewSublist(),
 		rl:     NewRetainList(),
+		nodes:  make(map[string]interface{}),
 		queues: make(map[string]int),
 	}
 	if b.config.TlsPort != "" {
 		tlsconfig, err := NewTLSConfig(b.config.TlsInfo)
 		if err != nil {
-			log.Error("new tlsConfig error: ", err)
+			log.Error("new tlsConfig error", zap.Error(err))
 			return nil, err
 		}
 		b.tlsConfig = tlsconfig
@@ -51,7 +62,7 @@ func NewBroker(config *Config) (*Broker, error) {
 	if b.config.Acl {
 		aclconfig, err := acl.AclConfigLoad(b.config.AclConf)
 		if err != nil {
-			log.Error("Load acl conf error: ", err)
+			log.Error("Load acl conf error", zap.Error(err))
 			return nil, err
 		}
 		b.AclConfig = aclconfig
@@ -65,35 +76,47 @@ func (b *Broker) Start() {
 		log.Error("broker is null")
 		return
 	}
+	StartDispatcher()
+
+	//listen clinet over tcp
 	if b.config.Port != "" {
 		go b.StartClientListening(false)
 	}
+
+	//listen for cluster
 	if b.config.Cluster.Port != "" {
 		go b.StartClusterListening()
 	}
+
+	//listen for websocket
 	if b.config.WsPort != "" {
 		go b.StartWebsocketListening()
 	}
+
+	//listen client over tls
 	if b.config.TlsPort != "" {
 		go b.StartClientListening(true)
 	}
-	if len(b.config.Cluster.Routes) > 0 {
+
-		b.ConnectToRouters()
+	//connect on other node in cluster
+	if b.config.Router != "" {
+		b.ConnectToDiscovery()
 	}
+
+	//system monitor
 	go StateMonitor()
 
 }
 
 func StateMonitor() {
 	v, _ := mem.VirtualMemory()
-	timeSticker := time.NewTicker(time.Second * 5)
+	timeSticker := time.NewTicker(time.Second * 30)
 	for {
 		select {
 		case <-timeSticker.C:
-			if v.UsedPercent > 0.8 {
+			if v.UsedPercent > 75 {
 				debug.FreeOSMemory()
 			}
-			// fmt.Printf("Total: %v, Free:%v, UsedPercent:%f%%\n", v.Total, v.Free, v.UsedPercent)
 		}
 	}
 }
@@ -101,7 +124,7 @@ func StateMonitor() {
 func (b *Broker) StartWebsocketListening() {
 	path := b.config.WsPath
 	hp := ":" + b.config.WsPort
-	log.Info("Start Webscoker Listening on ", hp, path)
+	log.Info("Start Websocket Listening on ", zap.String("hp", hp), zap.String("path", path))
 	http.Handle(path, websocket.Handler(b.wsHandler))
 	var err error
 	if b.config.WsTLS {
@@ -129,14 +152,14 @@ func (b *Broker) StartClientListening(Tls bool) {
 	if Tls {
 		hp = b.config.TlsHost + ":" + b.config.TlsPort
 		l, err = tls.Listen("tcp", hp, b.tlsConfig)
-		log.Info("Start TLS Listening client on ", hp)
+		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 ", hp)
+		log.Info("Start Listening client on ", zap.String("hp", hp))
 	}
 	if err != nil {
-		log.Error("Error listening on ", err)
+		log.Error("Error listening on ", zap.Error(err))
 		return
 	}
 	tmpDelay := 10 * ACCEPT_MIN_SLEEP
@@ -145,14 +168,14 @@ func (b *Broker) StartClientListening(Tls bool) {
 		if err != nil {
 			if ne, ok := err.(net.Error); ok && ne.Temporary() {
 				log.Error("Temporary Client Accept Error(%v), sleeping %dms",
-					ne, tmpDelay/time.Millisecond)
+					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", err)
+				log.Error("Accept error: %v", zap.Error(err))
 			}
 			continue
 		}
@@ -171,7 +194,7 @@ func (b *Broker) Handshake(conn net.Conn) bool {
 
 	// Force handshake
 	if err := nc.Handshake(); err != nil {
-		log.Error("TLS handshake error, ", err)
+		log.Error("TLS handshake error, ", zap.Error(err))
 		return false
 	}
 	nc.SetReadDeadline(time.Time{})
@@ -194,11 +217,11 @@ func TlsTimeout(conn *tls.Conn) {
 
 func (b *Broker) StartClusterListening() {
 	var hp string = b.config.Cluster.Host + ":" + b.config.Cluster.Port
-	log.Info("Start Listening cluster on ", hp)
+	log.Info("Start Listening cluster on ", zap.String("hp", hp))
 
 	l, e := net.Listen("tcp", hp)
 	if e != nil {
-		log.Error("Error listening on ", e)
+		log.Error("Error listening on ", zap.Error(e))
 		return
 	}
 
@@ -209,26 +232,20 @@ func (b *Broker) StartClusterListening() {
 		if err != nil {
 			if ne, ok := err.(net.Error); ok && ne.Temporary() {
 				log.Error("Temporary Client Accept Error(%v), sleeping %dms",
-					ne, tmpDelay/time.Millisecond)
+					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", err)
+				log.Error("Accept error: %v", zap.Error(err))
 			}
 			continue
 		}
 		tmpDelay = ACCEPT_MIN_SLEEP
 
 		go b.handleConnection(ROUTER, conn, idx)
-		if idx == 1 {
-			idx = 0
-		} else {
-			idx = idx + 1
-		}
-
 	}
 }
 
@@ -236,7 +253,7 @@ func (b *Broker) handleConnection(typ int, conn net.Conn, idx uint64) {
 	//process connect packet
 	packet, err := packets.ReadPacket(conn)
 	if err != nil {
-		log.Error("read connect packet error: ", err)
+		log.Error("read connect packet error: ", zap.Error(err))
 		return
 	}
 	if packet == nil {
@@ -253,7 +270,7 @@ func (b *Broker) handleConnection(typ int, conn net.Conn, idx uint64) {
 	connack.SessionPresent = msg.CleanSession
 	err = connack.Write(conn)
 	if err != nil {
-		log.Error("send connack error, ", err)
+		log.Error("send connack error, ", zap.Error(err), zap.String("clientID", msg.ClientIdentifier))
 		return
 	}
 
@@ -281,6 +298,7 @@ func (b *Broker) handleConnection(typ int, conn net.Conn, idx uint64) {
 		conn:   conn,
 		info:   info,
 	}
+
 	c.init()
 
 	cid := c.info.clientID
@@ -292,64 +310,172 @@ func (b *Broker) handleConnection(typ int, conn net.Conn, idx uint64) {
 	switch typ {
 	case CLIENT:
 		msgPool = MSGPool[idx%MessagePoolNum].GetPool()
+		c.mp = msgPool
 		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 {
+				msg := &Message{client: c, packet: DisconnectdPacket}
+				ol.mp.queue <- msg
+			}
+		}
 		b.clients.Store(cid, c)
 	case ROUTER:
 		msgPool = MSGPool[(MessagePoolNum + idx)].GetPool()
+		c.mp = msgPool
 		old, exist = b.routes.Load(cid)
+		if exist {
+			log.Warn("router exist, close old...")
+			ol, ok := old.(*client)
+			if ok {
+				msg := &Message{client: c, packet: DisconnectdPacket}
+				ol.mp.queue <- msg
+			}
+		}
 		b.routes.Store(cid, c)
 	}
 
-	if exist {
+	c.readLoop()
-		log.Warn("client or routers exist, close old...")
-		ol, ok := old.(*client)
-		if ok {
-			ol.Close()
-		}
-	}
-	c.readLoop(msgPool)
 }
 
-func (b *Broker) ConnectToRouters() {
+func (b *Broker) ConnectToDiscovery() {
-	for i := 0; i < len(b.config.Cluster.Routes); i++ {
-		url := b.config.Cluster.Routes[i]
-		go b.connectRouter(url, "")
-	}
-}
-
-func (b *Broker) connectRouter(url, remoteID string) {
 	var conn net.Conn
 	var err error
+	var tempDelay time.Duration = 0
 	for {
-		conn, err = net.Dial("tcp", url)
+		conn, err = net.Dial("tcp", b.config.Router)
 		if err != nil {
-			log.Error("Error trying to connect to route: ", err)
+			log.Error("Error trying to connect to route: ", zap.Error(err))
-			select {
+			log.Debug("Connect to route timeout ,retry...")
-			case <-time.After(DEFAULT_ROUTE_CONNECT):
+
-				log.Debug("Connect to route timeout ,retry...")
+			if 0 == tempDelay {
-				continue
+				tempDelay = 1 * time.Second
+			} else {
+				tempDelay *= 2
 			}
+
+			if max := 20 * time.Second; tempDelay > max {
+				tempDelay = max
+			}
+			time.Sleep(tempDelay)
+			continue
 		}
+		break
 	}
-	route := &route{
+	log.Debug("connect to router success :", zap.String("Router", b.config.Router))
-		remoteID:  remoteID,
+
-		remoteUrl: url,
+	cid := b.id
+	info := info{
+		clientID:  cid,
+		keepalive: 60,
+	}
+
+	c := &client{
+		typ:    CLUSTER,
+		broker: b,
+		conn:   conn,
+		info:   info,
+	}
+
+	c.init()
+
+	c.SendConnect()
+	c.SendInfo()
+
+	c.mp = &MSGPool[(MessagePoolNum + 2)]
+	go c.readLoop()
+	go c.StartPing()
+}
+
+func (b *Broker) connectRouter(id, addr string) {
+	var conn net.Conn
+	var err error
+	var timeDelay time.Duration = 0
+	retryTimes := 0
+	max := 32 * time.Second
+	for {
+
+		if !b.checkNodeExist(id, addr) {
+			return
+		}
+
+		conn, err = net.Dial("tcp", addr)
+		if err != nil {
+			log.Error("Error trying to connect to route: ", zap.Error(err))
+
+			if retryTimes > 50 {
+				return
+			}
+
+			log.Debug("Connect to route timeout ,retry...")
+
+			if 0 == timeDelay {
+				timeDelay = 1 * time.Second
+			} else {
+				timeDelay *= 2
+			}
+
+			if timeDelay > max {
+				timeDelay = max
+			}
+			time.Sleep(timeDelay)
+			retryTimes++
+			continue
+		}
+		break
+	}
+	route := route{
+		remoteID:  id,
+		remoteUrl: addr,
 	}
 	cid := GenUniqueId()
+
 	info := info{
-		clientID: cid,
+		clientID:  cid,
+		keepalive: 60,
 	}
+
 	c := &client{
-		typ:   REMOTE,
+		broker: b,
-		conn:  conn,
+		typ:    REMOTE,
-		route: route,
+		conn:   conn,
-		info:  info,
+		route:  route,
+		info:   info,
 	}
 	c.init()
 	b.remotes.Store(cid, c)
+
+	c.mp = MSGPool[(MessagePoolNum + 1)].GetPool()
+
 	c.SendConnect()
-	c.SendInfo()
+	// c.SendInfo()
-	c.StartPing()
+
+	go c.readLoop()
+	go c.StartPing()
+
+}
+
+func (b *Broker) checkNodeExist(id, url string) bool {
+	if id == b.id {
+		return false
+	}
+
+	for k, v := range b.nodes {
+		if k == id {
+			return true
+		}
+
+		//skip
+		l, ok := v.(string)
+		if ok {
+			if url == l {
+				return true
+			}
+		}
+
+	}
+	return false
 }
 
 func (b *Broker) CheckRemoteExist(remoteID, url string) bool {
@@ -358,9 +484,7 @@ func (b *Broker) CheckRemoteExist(remoteID, url string) bool {
 		v, ok := value.(*client)
 		if ok {
 			if v.route.remoteUrl == url {
-				// if v.route.remoteID == "" || v.route.remoteID != remoteID {
 				v.route.remoteID = remoteID
-				// }
 				exist = true
 				return false
 			}
@@ -383,14 +507,16 @@ func (b *Broker) SendLocalSubsToRouter(c *client) {
 		}
 		return true
 	})
-	err := c.WriterPacket(subInfo)
+	if len(subInfo.Topics) > 0 {
-	if err != nil {
+		err := c.WriterPacket(subInfo)
-		log.Error("Send localsubs To Router error :", err)
+		if err != nil {
+			log.Error("Send localsubs To Router error :", zap.Error(err))
+		}
 	}
 }
 
 func (b *Broker) BroadcastInfoMessage(remoteID string, msg *packets.PublishPacket) {
-	b.remotes.Range(func(key, value interface{}) bool {
+	b.routes.Range(func(key, value interface{}) bool {
 		r, ok := value.(*client)
 		if ok {
 			if r.route.remoteID == remoteID {
@@ -405,7 +531,8 @@ func (b *Broker) BroadcastInfoMessage(remoteID string, msg *packets.PublishPacke
 }
 
 func (b *Broker) BroadcastSubOrUnsubMessage(packet packets.ControlPacket) {
-	b.remotes.Range(func(key, value interface{}) bool {
+
+	b.routes.Range(func(key, value interface{}) bool {
 		r, ok := value.(*client)
 		if ok {
 			r.WriterPacket(packet)
@@ -432,7 +559,6 @@ func (b *Broker) removeClient(c *client) {
 func (b *Broker) PublishMessage(packet *packets.PublishPacket) {
 	topic := packet.TopicName
 	r := b.sl.Match(topic)
-	// log.Info("psubs num: ", len(r.psubs))
 	if len(r.psubs) == 0 {
 		return
 	}
@@ -441,7 +567,7 @@ func (b *Broker) PublishMessage(packet *packets.PublishPacket) {
 		if sub != nil {
 			err := sub.client.WriterPacket(packet)
 			if err != nil {
-				log.Error("process message for psub error,  ", err)
+				log.Error("process message for psub error,  ", zap.Error(err))
 			}
 		}
 	}
@@ -449,14 +575,12 @@ func (b *Broker) PublishMessage(packet *packets.PublishPacket) {
 
 func (b *Broker) BroadcastUnSubscribe(subs map[string]*subscription) {
 
-	ubsub := packets.NewControlPacket(packets.Unsubscribe).(*packets.UnsubscribePacket)
+	unsub := packets.NewControlPacket(packets.Unsubscribe).(*packets.UnsubscribePacket)
 	for topic, _ := range subs {
-		// topic := sub.topic
+		unsub.Topics = append(unsub.Topics, topic)
-		// if sub.queue {
-		// 	topic = "$queue/" + sub.topic
-		// }
-		ubsub.Topics = append(ubsub.Topics, topic)
 	}
-	b.BroadcastSubOrUnsubMessage(ubsub)
 
+	if len(unsub.Topics) > 0 {
+		b.BroadcastSubOrUnsubMessage(unsub)
+	}
 }

broker/client.go

@@ -1,3 +1,5 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
 package broker
 
 import (
@@ -7,19 +9,19 @@ import (
 	"time"
 
 	"github.com/eclipse/paho.mqtt.golang/packets"
-
+	"go.uber.org/zap"
-	log "github.com/cihub/seelog"
 )
 
 const (
 	// special pub topic for cluster info BrokerInfoTopic
-	BrokerInfoTopic = "broker001info/brokerinfo"
+	BrokerInfoTopic = "broker000100101info"
 	// CLIENT is an end user.
 	CLIENT = 0
 	// ROUTER is another router in the cluster.
 	ROUTER = 1
 	//REMOTE is the router connect to other cluster
-	REMOTE = 2
+	REMOTE  = 2
+	CLUSTER = 3
 )
 const (
 	Connected    = 1
@@ -32,9 +34,11 @@ type client struct {
 	broker *Broker
 	conn   net.Conn
 	info   info
-	route  *route
+	route  route
 	status int
+	closed chan int
 	smu    sync.RWMutex
+	mp     *MessagePool
 	subs   map[string]*subscription
 	rsubs  map[string]*subInfo
 }
@@ -74,47 +78,69 @@ func (c *client) init() {
 	c.smu.Lock()
 	defer c.smu.Unlock()
 	c.status = Connected
-	typ := c.typ
+	c.closed = make(chan int, 1)
-	if typ == ROUTER {
+
-		c.rsubs = make(map[string]*subInfo)
+	c.rsubs = make(map[string]*subInfo)
-	} else if typ == CLIENT {
+	c.subs = make(map[string]*subscription, 10)
-		c.subs = make(map[string]*subscription, 10)
-	}
 	c.info.localIP = strings.Split(c.conn.LocalAddr().String(), ":")[0]
 	c.info.remoteIP = strings.Split(c.conn.RemoteAddr().String(), ":")[0]
 }
 
-func (c *client) readLoop(msgPool *MessagePool) {
+func (c *client) keepAlive(ch chan int) {
+	defer close(ch)
+	keepalive := time.Duration(c.info.keepalive*3/2) * time.Second
+	timer := time.NewTimer(keepalive)
+	msgPool := c.mp
+
+	for {
+		select {
+		case <-ch:
+			timer.Reset(keepalive)
+		case <-timer.C:
+			if c.typ == REMOTE || c.typ == CLUSTER {
+				timer.Reset(keepalive)
+				continue
+			}
+			log.Error("Client exceeded timeout, disconnecting. ", zap.String("ClientID", c.info.clientID), zap.Uint16("keepalive", c.info.keepalive))
+			msg := &Message{client: c, packet: DisconnectdPacket}
+			msgPool.queue <- msg
+			timer.Stop()
+			return
+		case _, ok := <-c.closed:
+			if !ok {
+				return
+			}
+		}
+	}
+}
+
+func (c *client) readLoop() {
 	nc := c.conn
+	msgPool := c.mp
 	if nc == nil || msgPool == nil {
 		return
 	}
 
-	lastIn := uint16(time.Now().Unix())
+	ch := make(chan int, 1000)
-	var nowTime uint16
+	go c.keepAlive(ch)
+
 	for {
-		nowTime = uint16(time.Now().Unix())
-		if 0 != c.info.keepalive && nowTime-lastIn > c.info.keepalive*3/2 {
-			log.Errorf("Client %s has exceeded timeout, disconnecting.\n", c.info.clientID)
-			msg := &Message{client: c, packet: DisconnectdPacket}
-			msgPool.queue <- msg
-			return
-		}
 		packet, err := packets.ReadPacket(nc)
 		if err != nil {
-			log.Error("read packet error: ", err)
+			log.Error("read packet error: ", zap.Error(err), zap.String("ClientID", c.info.clientID))
-			msg := &Message{client: c, packet: DisconnectdPacket}
+			break
-			msgPool.queue <- msg
-			return
 		}
-		// log.Info("recv buf: ", packet)
+
-		lastIn = uint16(time.Now().Unix())
+		ch <- 1
+
 		msg := &Message{
 			client: c,
 			packet: packet,
 		}
 		msgPool.queue <- msg
 	}
+	msg := &Message{client: c, packet: DisconnectdPacket}
+	msgPool.queue <- msg
 	msgPool.Reduce()
 }
 
@@ -124,45 +150,33 @@ func ProcessMessage(msg *Message) {
 	if ca == nil {
 		return
 	}
+	log.Debug("Recv message from client,", zap.String("ClientID", c.info.clientID))
 	switch ca.(type) {
 	case *packets.ConnackPacket:
-		// log.Info("Recv conack message..........")
+
 	case *packets.ConnectPacket:
-		// log.Info("Recv connect message..........")
 	case *packets.PublishPacket:
-		// log.Info("Recv publish message..........")
 		packet := ca.(*packets.PublishPacket)
 		c.ProcessPublish(packet)
 	case *packets.PubackPacket:
-		//log.Info("Recv publish  ack message..........")
 	case *packets.PubrecPacket:
-		//log.Info("Recv publish rec message..........")
 	case *packets.PubrelPacket:
-		//log.Info("Recv publish rel message..........")
 	case *packets.PubcompPacket:
-		//log.Info("Recv publish  ack message..........")
 	case *packets.SubscribePacket:
-		// log.Info("Recv subscribe message.....")
 		packet := ca.(*packets.SubscribePacket)
 		c.ProcessSubscribe(packet)
 	case *packets.SubackPacket:
-		// log.Info("Recv suback message.....")
 	case *packets.UnsubscribePacket:
-		// log.Info("Recv unsubscribe message.....")
 		packet := ca.(*packets.UnsubscribePacket)
 		c.ProcessUnSubscribe(packet)
 	case *packets.UnsubackPacket:
-		//log.Info("Recv unsuback message.....")
 	case *packets.PingreqPacket:
-		// log.Info("Recv PINGREQ message..........")
 		c.ProcessPing()
 	case *packets.PingrespPacket:
-		//log.Info("Recv PINGRESP message..........")
 	case *packets.DisconnectPacket:
-		// log.Info("Recv DISCONNECT message.......")
 		c.Close()
 	default:
-		log.Info("Recv Unknow message.......")
+		log.Info("Recv Unknow message.......", zap.String("ClientID", c.info.clientID))
 	}
 }
 
@@ -172,8 +186,13 @@ func (c *client) ProcessPublish(packet *packets.PublishPacket) {
 	}
 
 	topic := packet.TopicName
+	if topic == BrokerInfoTopic && c.typ == CLUSTER {
+		c.ProcessInfo(packet)
+		return
+	}
+
 	if !c.CheckTopicAuth(PUB, topic) {
-		log.Error("Pub Topics Auth failed, ", topic)
+		log.Error("Pub Topics Auth failed, ", zap.String("topic", topic), zap.String("ClientID", c.info.clientID))
 		return
 	}
 
@@ -184,21 +203,21 @@ func (c *client) ProcessPublish(packet *packets.PublishPacket) {
 		puback := packets.NewControlPacket(packets.Puback).(*packets.PubackPacket)
 		puback.MessageID = packet.MessageID
 		if err := c.WriterPacket(puback); err != nil {
-			log.Error("send puback error, ", err)
+			log.Error("send puback error, ", zap.Error(err), zap.String("ClientID", c.info.clientID))
 			return
 		}
 		c.ProcessPublishMessage(packet)
 	case QosExactlyOnce:
 		return
 	default:
-		log.Error("publish with unknown qos")
+		log.Error("publish with unknown qos", zap.String("ClientID", c.info.clientID))
 		return
 	}
 	if packet.Retain {
 		if b := c.broker; b != nil {
 			err := b.rl.Insert(topic, packet)
 			if err != nil {
-				log.Error("Insert Retain Message error: ", err)
+				log.Error("Insert Retain Message error: ", zap.Error(err), zap.String("ClientID", c.info.clientID))
 			}
 		}
 	}
@@ -225,14 +244,14 @@ func (c *client) ProcessPublishMessage(packet *packets.PublishPacket) {
 
 	for _, sub := range r.psubs {
 		if sub.client.typ == ROUTER {
-			if typ == ROUTER {
+			if typ != CLIENT {
 				continue
 			}
 		}
 		if sub != nil {
 			err := sub.client.WriterPacket(packet)
 			if err != nil {
-				log.Error("process message for psub error,  ", err)
+				log.Error("process message for psub error,  ", zap.Error(err), zap.String("ClientID", c.info.clientID))
 			}
 		}
 	}
@@ -245,7 +264,7 @@ func (c *client) ProcessPublishMessage(packet *packets.PublishPacket) {
 		// log.Info("queue index : ", cnt)
 		for _, sub := range r.qsubs {
 			if sub.client.typ == ROUTER {
-				if c.typ == ROUTER {
+				if typ != CLIENT {
 					continue
 				}
 			}
@@ -258,7 +277,7 @@ func (c *client) ProcessPublishMessage(packet *packets.PublishPacket) {
 				if sub != nil {
 					err := sub.client.WriterPacket(packet)
 					if err != nil {
-						log.Error("send publish error, ", err)
+						log.Error("send publish error, ", zap.Error(err), zap.String("ClientID", c.info.clientID))
 					}
 				}
 
@@ -312,7 +331,7 @@ func (c *client) ProcessSubscribe(packet *packets.SubscribePacket) {
 		t := topic
 		//check topic auth for client
 		if !c.CheckTopicAuth(SUB, topic) {
-			log.Error("Sub topic Auth failed: ", topic)
+			log.Error("Sub topic Auth failed: ", zap.String("topic", topic), zap.String("ClientID", c.info.clientID))
 			retcodes = append(retcodes, QosFailure)
 			continue
 		}
@@ -359,7 +378,7 @@ func (c *client) ProcessSubscribe(packet *packets.SubscribePacket) {
 		}
 		err := b.sl.Insert(sub)
 		if err != nil {
-			log.Error("Insert subscription error: ", err)
+			log.Error("Insert subscription error: ", zap.Error(err), zap.String("ClientID", c.info.clientID))
 			retcodes = append(retcodes, QosFailure)
 		} else {
 			retcodes = append(retcodes, qoss[i])
@@ -369,7 +388,7 @@ func (c *client) ProcessSubscribe(packet *packets.SubscribePacket) {
 
 	err := c.WriterPacket(suback)
 	if err != nil {
-		log.Error("send suback error, ", err)
+		log.Error("send suback error, ", zap.Error(err), zap.String("ClientID", c.info.clientID))
 		return
 	}
 	//broadcast subscribe message
@@ -381,7 +400,7 @@ func (c *client) ProcessSubscribe(packet *packets.SubscribePacket) {
 	for _, t := range topics {
 		packets := b.rl.Match(t)
 		for _, packet := range packets {
-			log.Info("process retain  message: ", packet)
+			log.Info("process retain  message: ", zap.Any("packet", packet), zap.String("ClientID", c.info.clientID))
 			if packet != nil {
 				c.WriterPacket(packet)
 			}
@@ -401,29 +420,25 @@ func (c *client) ProcessUnSubscribe(packet *packets.UnsubscribePacket) {
 	topics := packet.Topics
 
 	for _, t := range topics {
-		var sub *subscription
+
-		ok := false
 		switch typ {
 		case CLIENT:
-			sub, ok = c.subs[t]
+			sub, ok := c.subs[t]
+			if ok {
+				c.unsubscribe(sub)
+			}
 		case ROUTER:
 			subinfo, ok := c.rsubs[t]
 			if ok {
 				subinfo.num = subinfo.num - 1
 				if subinfo.num < 1 {
-					sub = subinfo.sub
 					delete(c.rsubs, t)
+					c.unsubscribe(subinfo.sub)
 				} else {
 					c.rsubs[t] = subinfo
-					sub = nil
 				}
-			} else {
-				return
 			}
 		}
-		if ok {
-			go c.unsubscribe(sub)
-		}
 
 	}
 
@@ -432,7 +447,7 @@ func (c *client) ProcessUnSubscribe(packet *packets.UnsubscribePacket) {
 
 	err := c.WriterPacket(unsuback)
 	if err != nil {
-		log.Error("send unsuback error, ", err)
+		log.Error("send unsuback error, ", zap.Error(err), zap.String("ClientID", c.info.clientID))
 		return
 	}
 	// //process ubsubscribe message
@@ -461,19 +476,30 @@ func (c *client) ProcessPing() {
 	resp := packets.NewControlPacket(packets.Pingresp).(*packets.PingrespPacket)
 	err := c.WriterPacket(resp)
 	if err != nil {
-		log.Error("send PingResponse error, ", err)
+		log.Error("send PingResponse error, ", zap.Error(err), zap.String("ClientID", c.info.clientID))
 		return
 	}
 }
 
 func (c *client) Close() {
 	c.smu.Lock()
+	if c.status == Disconnected {
+		c.smu.Unlock()
+		return
+	}
+	//wait for message complete
+	time.Sleep(1 * time.Second)
 	c.status = Disconnected
+
 	if c.conn != nil {
 		c.conn.Close()
 		c.conn = nil
 	}
+
 	c.smu.Unlock()
+
+	close(c.closed)
+
 	b := c.broker
 	subs := c.subs
 	if b != nil {
@@ -481,7 +507,7 @@ func (c *client) Close() {
 		for _, sub := range subs {
 			err := b.sl.Remove(sub)
 			if err != nil {
-				log.Error("closed client but remove sublist error, ", err)
+				log.Error("closed client but remove sublist error, ", zap.Error(err), zap.String("ClientID", c.info.clientID))
 			}
 		}
 		if c.typ == CLIENT {
@@ -490,10 +516,23 @@ func (c *client) Close() {
 		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 {
+	if packet == nil {
+		return nil
+	}
+
 	c.mu.Lock()
 	err := packet.Write(c.conn)
 	c.mu.Unlock()

broker/comm.go

@@ -1,3 +1,5 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
 package broker
 
 import (

broker/config.go

@@ -1,17 +1,17 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
 package broker
 
 import (
 	"crypto/tls"
 	"crypto/x509"
 	"encoding/json"
+	"errors"
+	"flag"
 	"fmt"
 	"io/ioutil"
 
-	log "github.com/cihub/seelog"
+	"go.uber.org/zap"
-)
-
-const (
-	CONFIGFILE = "hmq.config"
 )
 
 type Config struct {
@@ -19,6 +19,7 @@ type Config struct {
 	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"`
@@ -30,9 +31,8 @@ type Config struct {
 }
 
 type RouteInfo struct {
-	Host   string   `json:"host"`
+	Host string `json:"host"`
-	Port   string   `json:"port"`
+	Port string `json:"port"`
-	Routes []string `json:"routes"`
 }
 
 type TLSInfo struct {
@@ -42,11 +42,60 @@ type TLSInfo struct {
 	KeyFile  string `json:"keyFile"`
 }
 
-func LoadConfig() (*Config, error) {
+var DefaultConfig *Config = &Config{
+	Worker: 4096,
+	Host:   "0.0.0.0",
+	Port:   "1883",
+	Acl:    false,
+}
 
-	content, err := ioutil.ReadFile(CONFIGFILE)
+func ConfigureConfig() (*Config, error) {
+	config := &Config{}
+	var (
+		configFile string
+	)
+	flag.IntVar(&config.Worker, "w", 1024, "worker num to process message, perfer (client num)/10.")
+	flag.IntVar(&config.Worker, "worker", 1024, "worker num to process message, perfer (client num)/10.")
+	flag.StringVar(&config.Port, "port", "1883", "Port to listen on.")
+	flag.StringVar(&config.Port, "p", "1883", "Port to listen on.")
+	flag.StringVar(&config.Host, "host", "0.0.0.0", "Network host to listen on.")
+	flag.StringVar(&config.Host, "h", "0.0.0.0", "Network host to listen on.")
+	flag.StringVar(&config.Cluster.Host, "cluster", "", "Cluster ip from which members can connect.")
+	flag.StringVar(&config.Cluster.Host, "cluster_listen", "", "Cluster ip from which members can connect.")
+	flag.StringVar(&config.Cluster.Port, "cp", "", "Cluster port from which members can connect.")
+	flag.StringVar(&config.Cluster.Port, "cluster_port", "", "Cluster port from which members can connect.")
+	flag.StringVar(&config.Router, "r", "", "Router who maintenance cluster info")
+	flag.StringVar(&config.Router, "router", "", "Router who maintenance cluster info")
+	flag.StringVar(&config.WsPort, "wsport", "", "port for ws to listen on")
+	flag.StringVar(&config.WsPort, "ws_port", "", "port for ws to listen on")
+	flag.StringVar(&config.WsPath, "wspath", "", "path for ws to listen on")
+	flag.StringVar(&config.WsPath, "ws_path", "", "path for ws to listen on")
+	flag.StringVar(&configFile, "config", "", "config file for hmq")
+	flag.StringVar(&configFile, "c", "", "config file for hmq")
+	flag.Parse()
+
+	if configFile != "" {
+		tmpConfig, e := LoadConfig(configFile)
+		if e != nil {
+			return nil, e
+		} else {
+			config = tmpConfig
+		}
+	}
+
+	if err := config.check(); err != nil {
+		return nil, err
+	}
+
+	return config, nil
+
+}
+
+func LoadConfig(filename string) (*Config, error) {
+
+	content, err := ioutil.ReadFile(filename)
 	if err != nil {
-		log.Error("Read config file error: ", err)
+		log.Error("Read config file error: ", zap.Error(err))
 		return nil, err
 	}
 	// log.Info(string(content))
@@ -54,10 +103,15 @@ func LoadConfig() (*Config, error) {
 	var config Config
 	err = json.Unmarshal(content, &config)
 	if err != nil {
-		log.Error("Unmarshal config file error: ", err)
+		log.Error("Unmarshal config file error: ", zap.Error(err))
 		return nil, err
 	}
 
+	return &config, nil
+}
+
+func (config *Config) check() error {
+
 	if config.Worker == 0 {
 		config.Worker = 1024
 	}
@@ -75,29 +129,33 @@ func LoadConfig() (*Config, error) {
 			config.Cluster.Host = "0.0.0.0"
 		}
 	}
+	if config.Router != "" {
+		if config.Cluster.Port == "" {
+			return errors.New("cluster port is null")
+		}
+	}
 
 	if config.TlsPort != "" {
 		if config.TlsInfo.CertFile == "" || config.TlsInfo.KeyFile == "" {
 			log.Error("tls config error, no cert or key file.")
-			return nil, err
+			return errors.New("tls config error, no cert or key file.")
 		}
 		if config.TlsHost == "" {
 			config.TlsHost = "0.0.0.0"
 		}
 	}
-
+	return nil
-	return &config, nil
 }
 
 func NewTLSConfig(tlsInfo TLSInfo) (*tls.Config, error) {
 
 	cert, err := tls.LoadX509KeyPair(tlsInfo.CertFile, tlsInfo.KeyFile)
 	if err != nil {
-		return nil, fmt.Errorf("error parsing X509 certificate/key pair: %v", err)
+		return nil, fmt.Errorf("error parsing X509 certificate/key pair: %v", zap.Error(err))
 	}
 	cert.Leaf, err = x509.ParseCertificate(cert.Certificate[0])
 	if err != nil {
-		return nil, fmt.Errorf("error parsing certificate: %v", err)
+		return nil, fmt.Errorf("error parsing certificate: %v", zap.Error(err))
 	}
 
 	// Create TLSConfig

broker/dispatcher.go

@@ -1,9 +1,7 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
 package broker
 
-// const (
-// 	WorkNum = 4096
-// )
-
 var WorkNum int
 
 type Dispatcher struct {
@@ -31,15 +29,13 @@ func NewDispatcher() *Dispatcher {
 }
 
 func (d *Dispatcher) dispatch() {
-	for i := 0; i < MessagePoolNum; i++ {
+	for i := 0; i < (MessagePoolNum + 3); i++ {
 		go func(idx int) {
 			for {
 				select {
 				case msg := <-MSGPool[idx].queue:
-					go func(msg *Message) {
+					msgChannel := <-d.WorkerPool
-						msgChannel := <-d.WorkerPool
+					msgChannel <- msg
-						msgChannel <- msg
-					}(msg)
 				}
 			}
 		}(i)

broker/info.go

@@ -1,3 +1,5 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
 package broker
 
 import (
@@ -5,9 +7,9 @@ import (
 	"time"
 
 	"github.com/eclipse/paho.mqtt.golang/packets"
+	"go.uber.org/zap"
 
 	simplejson "github.com/bitly/go-simplejson"
-	log "github.com/cihub/seelog"
 )
 
 func (c *client) SendInfo() {
@@ -19,28 +21,33 @@ func (c *client) SendInfo() {
 	infoMsg := NewInfo(c.broker.id, url, false)
 	err := c.WriterPacket(infoMsg)
 	if err != nil {
-		log.Error("send info message error, ", err)
+		log.Error("send info message error, ", zap.Error(err))
 		return
 	}
-	// log.Info("send info success")
 }
 
 func (c *client) StartPing() {
-	timeTicker := time.NewTicker(time.Second * 30)
+	timeTicker := time.NewTicker(time.Second * 50)
 	ping := packets.NewControlPacket(packets.Pingreq).(*packets.PingreqPacket)
 	for {
 		select {
 		case <-timeTicker.C:
 			err := c.WriterPacket(ping)
 			if err != nil {
-				log.Error("ping error: ", err)
+				log.Error("ping error: ", zap.Error(err))
+				c.Close()
+			}
+		case _, ok := <-c.closed:
+			if !ok {
+				return
 			}
 		}
 	}
 }
 
 func (c *client) SendConnect() {
-	if c.status == Disconnected {
+
+	if c.status != Connected {
 		return
 	}
 	m := packets.NewControlPacket(packets.Connect).(*packets.ConnectPacket)
@@ -50,10 +57,10 @@ func (c *client) SendConnect() {
 	m.Keepalive = uint16(60)
 	err := c.WriterPacket(m)
 	if err != nil {
-		log.Error("send connect message error, ", err)
+		log.Error("send connect message error, ", zap.Error(err))
 		return
 	}
-	// log.Info("send connet success")
+	log.Info("send connect success")
 }
 
 func NewInfo(sid, url string, isforword bool) *packets.PublishPacket {
@@ -61,7 +68,7 @@ func NewInfo(sid, url string, isforword bool) *packets.PublishPacket {
 	pub.Qos = 0
 	pub.TopicName = BrokerInfoTopic
 	pub.Retain = false
-	info := fmt.Sprintf(`{"remoteID":"%s","url":"%s","isForward":%t}`, sid, url, isforword)
+	info := fmt.Sprintf(`{"brokerID":"%s","brokerUrl":"%s"}`, sid, url)
 	// log.Info("new info", string(info))
 	pub.Payload = []byte(info)
 	return pub
@@ -74,47 +81,36 @@ func (c *client) ProcessInfo(packet *packets.PublishPacket) {
 		return
 	}
 
-	log.Info("recv remoteInfo: ", string(packet.Payload))
+	log.Info("recv remoteInfo: ", zap.String("payload", string(packet.Payload)))
 
-	js, e := simplejson.NewJson(packet.Payload)
+	js, err := simplejson.NewJson(packet.Payload)
-	if e != nil {
+	if err != nil {
-		log.Warn("parse info message err", e)
+		log.Warn("parse info message err", zap.Error(err))
 		return
 	}
 
-	rid := js.Get("remoteID").MustString()
+	routes, err := js.Get("data").Map()
-	rurl := js.Get("url").MustString()
+	if routes == nil {
-	isForward := js.Get("isForward").MustBool()
+		log.Error("receive info message error, ", zap.Error(err))
-
-	if rid == "" {
-		log.Error("receive info message error with remoteID is null")
 		return
 	}
 
-	if rid == b.id {
+	b.nodes = routes
-		if !isForward {
+
-			c.Close() //close connet self
+	b.mu.Lock()
+	for rid, rurl := range routes {
+		if rid == b.id {
+			continue
 		}
-		return
-	}
 
-	exist := b.CheckRemoteExist(rid, rurl)
+		url, ok := rurl.(string)
-	if !exist {
+		if ok {
-		go b.connectRouter(rurl, rid)
+			exist := b.CheckRemoteExist(rid, url)
-	}
+			if !exist {
-	// log.Info("isforword: ", isForward)
+				b.connectRouter(rid, url)
-	if !isForward {
+			}
-		route := &route{
-			remoteUrl: rurl,
-			remoteID:  rid,
 		}
-		c.route = route
 
-		go b.SendLocalSubsToRouter(c)
-		// log.Info("BroadcastInfoMessage starting... ")
-		infoMsg := NewInfo(rid, rurl, true)
-		b.BroadcastInfoMessage(rid, infoMsg)
 	}
-
+	b.mu.Unlock()
-	return
 }

broker/msgpool.go

@@ -1,3 +1,5 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
 package broker
 
 import (
@@ -30,8 +32,8 @@ type MessagePool struct {
 }
 
 func InitMessagePool() {
-	MSGPool = make([]MessagePool, (MessagePoolNum + 2))
+	MSGPool = make([]MessagePool, (MessagePoolNum + 3))
-	for i := 0; i < (MessagePoolNum + 2); i++ {
+	for i := 0; i < (MessagePoolNum + 3); i++ {
 		MSGPool[i].Init(MessagePoolUser, MessagePoolMessageNum)
 	}
 }

broker/sublist.go

@@ -1,10 +1,12 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
 package broker
 
 import (
 	"errors"
 	"sync"
 
-	log "github.com/cihub/seelog"
+	"go.uber.org/zap"
 )
 
 // A result structure better optimized for queue subs.
@@ -209,7 +211,7 @@ func (s *Sublist) Match(topic string) *SublistResult {
 
 	tokens, err := PublishTopicCheckAndSpilt(topic)
 	if err != nil {
-		log.Error("\tserver/sublist.go: ", err)
+		log.Error("\tserver/sublist.go: ", zap.Error(err))
 		return nil
 	}
 
@@ -241,7 +243,6 @@ func (s *Sublist) Match(topic string) *SublistResult {
 	}
 
 	s.Unlock()
-	// log.Info("SublistResult: ", result)
 	return result
 }
 
@@ -294,7 +295,6 @@ func removeSubFromList(sub *subscription, sl []*subscription) ([]*subscription,
 			sl[i] = sl[last]
 			sl[last] = nil
 			sl = sl[:last]
-			// log.Info("removeSubFromList success")
 			return shrinkAsNeeded(sl), true
 		}
 	}

broker/worker.go

@@ -1,3 +1,5 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
 package broker
 
 type Worker struct {

conf/hmq.config

@@ -4,9 +4,9 @@
 	"host": "0.0.0.0",
 	"cluster": {
 		"host": "0.0.0.0",
-		"port": "1993",
+		"port": "1993"
-		"routes": []
 	},
+	"router": "127.0.0.1:9888",
 	"tlsPort": "8883",
 	"tlsHost": "0.0.0.0",
 	"wsPort": "1888",

lib/acl/acl.go

@@ -1,3 +1,5 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
 package acl
 
 import (

lib/acl/aclcheck.go

@@ -1,3 +1,4 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>*/
 package acl
 
 import "strings"

lib/acl/spilt.go

@@ -1,3 +1,5 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
 package acl
 
 import (

logger/logger.go

@@ -0,0 +1,51 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
+
+package logger
+
+import (
+	"go.uber.org/zap"
+)
+
+var (
+	// env can be setup at build time with Go Linker. Value could be prod or whatever else for dev env
+	env      string
+	instance *zap.Logger
+	logCfg   zap.Config
+)
+
+// NewDevLogger return a logger for dev builds
+func NewDevLogger() (*zap.Logger, error) {
+	logCfg := zap.NewDevelopmentConfig()
+	return logCfg.Build()
+}
+
+// NewProdLogger return a logger for production builds
+func NewProdLogger() (*zap.Logger, error) {
+	logCfg := zap.NewProductionConfig()
+	logCfg.DisableStacktrace = true
+	logCfg.Level = zap.NewAtomicLevelAt(zap.InfoLevel)
+	return logCfg.Build()
+}
+
+func init() {
+	var err error
+	var log *zap.Logger
+	if env == "prod" {
+		log, err = NewProdLogger()
+	} else {
+		log, err = NewDevLogger()
+	}
+	if err != nil {
+		panic("Unable to create a logger.")
+	}
+	defer log.Sync()
+
+	log.Debug("Logger initialization succeeded")
+	instance = log.Named("hmq")
+}
+
+// Get return a *zap.Logger instance
+func Get() *zap.Logger {
+	return instance
+}

logger/logger_test.go

@@ -0,0 +1,33 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+ */
+package logger
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"go.uber.org/zap"
+)
+
+func TestGet(t *testing.T) {
+	var l *zap.Logger
+	logger := Get()
+
+	assert.NotNil(t, logger)
+	assert.IsType(t, l, logger)
+}
+
+func TestNewDevLogger(t *testing.T) {
+	logger, err := NewDevLogger()
+
+	assert.Nil(t, err)
+	assert.True(t, logger.Core().Enabled(zap.DebugLevel))
+}
+
+func TestNewProdLogger(t *testing.T) {
+	logger, err := NewProdLogger()
+
+	assert.Nil(t, err)
+	assert.False(t, logger.Core().Enabled(zap.DebugLevel))
+}

main.go

@@ -1,33 +1,42 @@
+/* Copyright (c) 2018, joy.zhou <chowyu08@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+*/
 package main
 
 import (
-	"hmq/broker"
 	"os"
 	"os/signal"
 	"runtime"
 
-	log "github.com/cihub/seelog"
+	"github.com/fhmq/hmq/broker"
+	"github.com/fhmq/hmq/logger"
+	"go.uber.org/zap"
+)
+
+var (
+	log = logger.Get().Named("Main")
 )
 
 func main() {
 	runtime.GOMAXPROCS(runtime.NumCPU())
-	runtime.GC()
+	config, err := broker.ConfigureConfig()
-	config, er := broker.LoadConfig()
+	if err != nil {
-	if er != nil {
+		log.Error("configure broker config error: ", zap.Error(err))
-		log.Error("Load Config file error: ", er)
 		return
 	}
-	broker.StartDispatcher()
 
 	b, err := broker.NewBroker(config)
 	if err != nil {
-		log.Error("New Broker error: ", er)
+		log.Error("New Broker error: ", zap.Error(err))
 		return
 	}
 	b.Start()
 
 	s := waitForSignal()
-	log.Infof("signal got: %v ,broker closed.", s)
+	log.Info("signal received, broker closed.", zap.Any("signal", s))
 }
 
 func waitForSignal() os.Signal {