modify Dockerfile

Dockerfile

@@ -1,7 +1,6 @@
 FROM alpine
 COPY hmq /
-COPY broker.config /
+COPY ssl /ssl
-COPY tls /tls
 COPY conf /conf
 
 EXPOSE 1883

README.md

@@ -15,6 +15,7 @@ $ go run main.go
 ### broker.config
 ~~~
 {
+	"workerNum": 4096,
 	"port": "1883",
 	"host": "0.0.0.0",
 	"cluster": {

_config.yml

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

broker/broker.go

@@ -3,13 +3,16 @@ package broker
 import (
 	"crypto/tls"
 	"hmq/lib/acl"
-	"hmq/packets"
 	"net"
 	"net/http"
+	"runtime/debug"
 	"sync"
 	"sync/atomic"
 	"time"
 
+	"github.com/eclipse/paho.mqtt.golang/packets"
+	"github.com/shirou/gopsutil/mem"
+
 	"golang.org/x/net/websocket"
 
 	log "github.com/cihub/seelog"
@@ -18,6 +21,7 @@ import (
 type Broker struct {
 	id        string
 	cid       uint64
+	mu        sync.Mutex
 	config    *Config
 	tlsConfig *tls.Config
 	AclConfig *acl.ACLConfig
@@ -62,21 +66,49 @@ 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)
 	}
+
+	//connect on other node in cluster
 	if len(b.config.Cluster.Routes) > 0 {
 		b.ConnectToRouters()
 	}
+
+	//system montior
+	go StateMonitor()
+
+}
+
+func StateMonitor() {
+	v, _ := mem.VirtualMemory()
+	timeSticker := time.NewTicker(time.Second * 30)
+	for {
+		select {
+		case <-timeSticker.C:
+			if v.UsedPercent > 75 {
+				debug.FreeOSMemory()
+			}
+		}
+	}
 }
 
 func (b *Broker) StartWebsocketListening() {
@@ -84,7 +116,12 @@ func (b *Broker) StartWebsocketListening() {
 	hp := ":" + b.config.WsPort
 	log.Info("Start Webscoker Listening on ", hp, path)
 	http.Handle(path, websocket.Handler(b.wsHandler))
-	err := http.ListenAndServe(hp, nil)
+	var err error
+	if b.config.WsTLS {
+		err = http.ListenAndServeTLS(hp, b.config.TlsInfo.CertFile, b.config.TlsInfo.KeyFile, nil)
+	} else {
+		err = http.ListenAndServe(hp, nil)
+	}
 	if err != nil {
 		log.Error("ListenAndServe: " + err.Error())
 		return
@@ -199,12 +236,6 @@ func (b *Broker) StartClusterListening() {
 		tmpDelay = ACCEPT_MIN_SLEEP
 
 		go b.handleConnection(ROUTER, conn, idx)
-		if idx == 1 {
-			idx = 0
-		} else {
-			idx = idx + 1
-		}
-
 	}
 }
 
@@ -229,7 +260,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, ", err, " clientID = ", msg.ClientIdentifier)
 		return
 	}
 
@@ -257,6 +288,7 @@ func (b *Broker) handleConnection(typ int, conn net.Conn, idx uint64) {
 		conn:   conn,
 		info:   info,
 	}
+
 	c.init()
 
 	cid := c.info.clientID
@@ -268,64 +300,87 @@ 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...", " 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 {
+	go c.readLoop()
-		log.Warn("client or routers exist, close old...")
+	if typ == ROUTER {
-		ol, ok := old.(*client)
+		c.SendInfo()
-		if ok {
+		c.StartPing()
-			ol.Close()
-		}
 	}
-	c.readLoop(msgPool)
 }
 
 func (b *Broker) ConnectToRouters() {
-	for i := 0; i < len(b.config.Cluster.Routes); i++ {
+	for _, v := range b.config.Cluster.Routes {
-		url := b.config.Cluster.Routes[i]
+		go b.connectRouter(v, "")
-		go b.connectRouter(url, "")
 	}
 }
 
 func (b *Broker) connectRouter(url, remoteID string) {
+	var conn net.Conn
+	var err error
 	for {
-		conn, err := net.Dial("tcp", url)
+		conn, err = net.Dial("tcp", url)
 		if err != nil {
 			log.Error("Error trying to connect to route: ", err)
-			select {
+			log.Debug("Connect to route timeout ,retry...")
-			case <-time.After(DEFAULT_ROUTE_CONNECT):
+			time.Sleep(5 * time.Second)
-				log.Debug("Connect to route timeout ,retry...")
+			continue
-				continue
-			}
 		}
-		route := &route{
+		break
-			remoteID:  remoteID,
-			remoteUrl: url,
-		}
-		cid := GenUniqueId()
-		info := info{
-			clientID: cid,
-		}
-		c := &client{
-			typ:   REMOTE,
-			conn:  conn,
-			route: route,
-			info:  info,
-		}
-		b.remotes.Store(cid, c)
-		c.SendConnect()
-		c.SendInfo()
-		// s.createRemote(conn, route)
-		// msgPool := MSGPool[(MessagePoolNum + 1)].GetPool()
-		c.StartPing()
-		// c.readLoop(msgPool)
 	}
+	route := route{
+		remoteID:  remoteID,
+		remoteUrl: conn.RemoteAddr().String(),
+	}
+	cid := GenUniqueId()
+
+	info := info{
+		clientID:  cid,
+		keepalive: 60,
+	}
+
+	c := &client{
+		broker: b,
+		typ:    REMOTE,
+		conn:   conn,
+		route:  route,
+		info:   info,
+	}
+	c.init()
+	b.remotes.Store(cid, c)
+
+	c.mp = MSGPool[(MessagePoolNum + 1)].GetPool()
+
+	c.SendConnect()
+	c.SendInfo()
+
+	go c.readLoop()
+	go c.StartPing()
+
 }
 
 func (b *Broker) CheckRemoteExist(remoteID, url string) bool {
@@ -334,9 +389,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
 			}
@@ -359,14 +412,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 :", 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 {
@@ -381,7 +436,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)
@@ -408,7 +464,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
 	}
@@ -425,14 +480,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,12 +1,13 @@
 package broker
 
 import (
-	"hmq/packets"
 	"net"
 	"strings"
 	"sync"
 	"time"
 
+	"github.com/eclipse/paho.mqtt.golang/packets"
+
 	log "github.com/cihub/seelog"
 )
 
@@ -20,6 +21,10 @@ const (
 	//REMOTE is the router connect to other cluster
 	REMOTE = 2
 )
+const (
+	Connected    = 1
+	Disconnected = 2
+)
 
 type client struct {
 	typ    int
@@ -27,7 +32,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
 }
@@ -64,47 +73,68 @@ var (
 )
 
 func (c *client) init() {
-	typ := c.typ
+	c.smu.Lock()
-	if typ == ROUTER {
+	defer c.smu.Unlock()
-		c.rsubs = make(map[string]*subInfo)
+	c.status = Connected
-	} else if typ == CLIENT {
+	c.closed = make(chan int, 1)
-		c.subs = make(map[string]*subscription, 10)
+
-	}
+	c.rsubs = make(map[string]*subInfo)
+	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:
+			log.Error("Client exceeded timeout, disconnecting. clientID = ", c.info.clientID, " 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: ", err, " 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()
 }
 
@@ -114,53 +144,49 @@ func ProcessMessage(msg *Message) {
 	if ca == nil {
 		return
 	}
+	log.Debug("Recv message: ", ca.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.......", " clientID = ", c.info.clientID)
 	}
 }
 
 func (c *client) ProcessPublish(packet *packets.PublishPacket) {
+	if c.status == Disconnected {
+		return
+	}
+
 	topic := packet.TopicName
+	if topic == BrokerInfoTopic && c.typ != CLIENT {
+		c.ProcessInfo(packet)
+		return
+	}
 
 	if !c.CheckTopicAuth(PUB, topic) {
-		log.Error("Pub Topics Auth failed, ", topic)
+		log.Error("Pub Topics Auth failed, ", topic, " clientID = ", c.info.clientID)
 		return
 	}
 
@@ -171,21 +197,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, ", err, " clientID = ", c.info.clientID)
 			return
 		}
 		c.ProcessPublishMessage(packet)
 	case QosExactlyOnce:
 		return
 	default:
-		log.Error("publish with unknown qos")
+		log.Error("publish with unknown qos", " 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: ", err, " clientID = ", c.info.clientID)
 			}
 		}
 	}
@@ -193,6 +219,9 @@ func (c *client) ProcessPublish(packet *packets.PublishPacket) {
 }
 
 func (c *client) ProcessPublishMessage(packet *packets.PublishPacket) {
+	if c.status == Disconnected {
+		return
+	}
 
 	b := c.broker
 	if b == nil {
@@ -208,15 +237,15 @@ func (c *client) ProcessPublishMessage(packet *packets.PublishPacket) {
 	}
 
 	for _, sub := range r.psubs {
-		if sub.client.typ == ROUTER {
+		if sub.client.typ == REMOTE {
-			if typ == ROUTER {
+			if typ == REMOTE {
 				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,  ", err, " clientID = ", c.info.clientID)
 			}
 		}
 	}
@@ -228,8 +257,8 @@ func (c *client) ProcessPublishMessage(packet *packets.PublishPacket) {
 	if exist {
 		// log.Info("queue index : ", cnt)
 		for _, sub := range r.qsubs {
-			if sub.client.typ == ROUTER {
+			if sub.client.typ == REMOTE {
-				if c.typ == ROUTER {
+				if c.typ == REMOTE {
 					continue
 				}
 			}
@@ -242,7 +271,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, ", err, " clientID = ", c.info.clientID)
 					}
 				}
 
@@ -277,6 +306,10 @@ func getQueueSubscribeNum(qsubs []*subscription) int {
 }
 
 func (c *client) ProcessSubscribe(packet *packets.SubscribePacket) {
+	if c.status == Disconnected {
+		return
+	}
+
 	b := c.broker
 	if b == nil {
 		return
@@ -292,7 +325,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: ", topic, " clientID = ", c.info.clientID)
 			retcodes = append(retcodes, QosFailure)
 			continue
 		}
@@ -326,7 +359,7 @@ func (c *client) ProcessSubscribe(packet *packets.SubscribePacket) {
 				retcodes = append(retcodes, qoss[i])
 				continue
 			}
-		case ROUTER:
+		case REMOTE:
 			if subinfo, exist := c.rsubs[topic]; !exist {
 				sinfo := &subInfo{sub: sub, num: 1}
 				c.rsubs[topic] = sinfo
@@ -339,7 +372,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: ", err, " clientID = ", c.info.clientID)
 			retcodes = append(retcodes, QosFailure)
 		} else {
 			retcodes = append(retcodes, qoss[i])
@@ -349,7 +382,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, ", err, " clientID = ", c.info.clientID)
 		return
 	}
 	//broadcast subscribe message
@@ -361,7 +394,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: ", packet, " clientID = ", c.info.clientID)
 			if packet != nil {
 				c.WriterPacket(packet)
 			}
@@ -370,6 +403,9 @@ func (c *client) ProcessSubscribe(packet *packets.SubscribePacket) {
 }
 
 func (c *client) ProcessUnSubscribe(packet *packets.UnsubscribePacket) {
+	if c.status == Disconnected {
+		return
+	}
 	b := c.broker
 	if b == nil {
 		return
@@ -378,29 +414,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]
-		case ROUTER:
+			if ok {
+				c.unsubscribe(sub)
+			}
+		case REMOTE:
 			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)
-		}
 
 	}
 
@@ -409,7 +441,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, ", err, " clientID = ", c.info.clientID)
 		return
 	}
 	// //process ubsubscribe message
@@ -432,15 +464,36 @@ func (c *client) unsubscribe(sub *subscription) {
 }
 
 func (c *client) ProcessPing() {
+	if c.status == Disconnected {
+		return
+	}
 	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, ", err, " 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 {
@@ -448,7 +501,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, ", err, " clientID = ", c.info.clientID)
 			}
 		}
 		if c.typ == CLIENT {
@@ -457,14 +510,22 @@ func (c *client) Close() {
 		if c.info.willMsg != nil {
 			b.PublishMessage(c.info.willMsg)
 		}
-	}
+
-	if c.conn != nil {
+		//do reconnect
-		c.conn.Close()
+		if c.typ == REMOTE {
-		c.conn = nil
+			localUrl := c.info.localIP + ":" + c.broker.config.Cluster.Port
+			if c.route.remoteUrl != localUrl {
+				b.connectRouter(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/config.go

@@ -11,7 +11,7 @@ import (
 )
 
 const (
-	CONFIGFILE = "hmq.config"
+	CONFIGFILE = "conf/hmq.config"
 )
 
 type Config struct {

broker/dispatcher.go

@@ -1,9 +1,5 @@
 package broker
 
-// const (
-// 	WorkNum = 4096
-// )
-
 var WorkNum int
 
 type Dispatcher struct {
@@ -31,7 +27,7 @@ func NewDispatcher() *Dispatcher {
 }
 
 func (d *Dispatcher) dispatch() {
-	for i := 0; i < MessagePoolNum; i++ {
+	for i := 0; i < (MessagePoolNum + 2); i++ {
 		go func(idx int) {
 			for {
 				select {

broker/info.go

@@ -2,14 +2,18 @@ package broker
 
 import (
 	"fmt"
-	"hmq/packets"
 	"time"
 
+	"github.com/eclipse/paho.mqtt.golang/packets"
+
 	simplejson "github.com/bitly/go-simplejson"
 	log "github.com/cihub/seelog"
 )
 
 func (c *client) SendInfo() {
+	if c.status == Disconnected {
+		return
+	}
 	url := c.info.localIP + ":" + c.broker.config.Cluster.Port
 
 	infoMsg := NewInfo(c.broker.id, url, false)
@@ -18,7 +22,6 @@ func (c *client) SendInfo() {
 		log.Error("send info message error, ", err)
 		return
 	}
-	// log.Info("send info success")
 }
 
 func (c *client) StartPing() {
@@ -30,6 +33,11 @@ func (c *client) StartPing() {
 			err := c.WriterPacket(ping)
 			if err != nil {
 				log.Error("ping error: ", err)
+				c.Close()
+			}
+		case _, ok := <-c.closed:
+			if !ok {
+				return
 			}
 		}
 	}
@@ -37,6 +45,9 @@ func (c *client) StartPing() {
 
 func (c *client) SendConnect() {
 
+	if c.status != Connected {
+		return
+	}
 	m := packets.NewControlPacket(packets.Connect).(*packets.ConnectPacket)
 
 	m.CleanSession = true
@@ -47,7 +58,7 @@ func (c *client) SendConnect() {
 		log.Error("send connect message error, ", err)
 		return
 	}
-	// log.Info("send connet success")
+	log.Info("send connect success")
 }
 
 func NewInfo(sid, url string, isforword bool) *packets.PublishPacket {
@@ -92,17 +103,21 @@ func (c *client) ProcessInfo(packet *packets.PublishPacket) {
 		return
 	}
 
+	b.mu.Lock()
 	exist := b.CheckRemoteExist(rid, rurl)
 	if !exist {
-		go b.connectRouter(rurl, rid)
+		b.connectRouter(rurl, rid)
 	}
-	// log.Info("isforword: ", isForward)
+	b.mu.Unlock()
+
 	if !isForward {
-		route := &route{
+		if c.typ == ROUTER {
-			remoteUrl: rurl,
+			route := route{
-			remoteID:  rid,
+				remoteUrl: rurl,
+				remoteID:  rid,
+			}
+			c.route = route
 		}
-		c.route = route
 
 		go b.SendLocalSubsToRouter(c)
 		// log.Info("BroadcastInfoMessage starting... ")

broker/msgpool.go

@@ -1,8 +1,9 @@
 package broker
 
 import (
-	"hmq/packets"
 	"sync"
+
+	"github.com/eclipse/paho.mqtt.golang/packets"
 )
 
 const (

broker/retain.go

@@ -1,8 +1,9 @@
 package broker
 
 import (
-	"hmq/packets"
 	"sync"
+
+	"github.com/eclipse/paho.mqtt.golang/packets"
 )
 
 type RetainList struct {

broker/sublist.go

@@ -241,7 +241,6 @@ func (s *Sublist) Match(topic string) *SublistResult {
 	}
 
 	s.Unlock()
-	// log.Info("SublistResult: ", result)
 	return result
 }
 
@@ -294,7 +293,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
 		}
 	}

main.go

@@ -9,15 +9,31 @@ import (
 	log "github.com/cihub/seelog"
 )
 
+func init() {
+	testConfig := `
+<seelog type="sync">
+	<outputs formatid="main">
+		<console/>
+	</outputs>
+	<formats>
+		<format id="main" format="Time:%Date %Time%tfile:%File%tlevel:%LEVEL%t%Msg%n"/>
+	</formats>
+</seelog>`
+
+	logger, err := log.LoggerFromConfigAsBytes([]byte(testConfig))
+	if err != nil {
+		panic(err)
+	}
+	log.ReplaceLogger(logger)
+}
+
 func main() {
 	runtime.GOMAXPROCS(runtime.NumCPU())
-	runtime.GC()
 	config, er := broker.LoadConfig()
 	if er != nil {
 		log.Error("Load Config file error: ", er)
 		return
 	}
-	broker.StartDispatcher()
 
 	b, err := broker.NewBroker(config)
 	if err != nil {

packets/connack.go

@@ -1,51 +0,0 @@
-package packets
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-)
-
-//ConnackPacket is an internal representation of the fields of the
-//Connack MQTT packet
-type ConnackPacket struct {
-	FixedHeader
-	SessionPresent bool
-	ReturnCode     byte
-}
-
-func (ca *ConnackPacket) String() string {
-	str := fmt.Sprintf("%s", ca.FixedHeader)
-	str += " "
-	str += fmt.Sprintf("sessionpresent: %t returncode: %d", ca.SessionPresent, ca.ReturnCode)
-	return str
-}
-
-func (ca *ConnackPacket) Write(w io.Writer) error {
-	var body bytes.Buffer
-	var err error
-
-	body.WriteByte(boolToByte(ca.SessionPresent))
-	body.WriteByte(ca.ReturnCode)
-	ca.FixedHeader.RemainingLength = 2
-	packet := ca.FixedHeader.pack()
-	packet.Write(body.Bytes())
-	_, err = packet.WriteTo(w)
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (ca *ConnackPacket) Unpack(b io.Reader) error {
-	ca.SessionPresent = 1&decodeByte(b) > 0
-	ca.ReturnCode = decodeByte(b)
-
-	return nil
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (ca *ConnackPacket) Details() Details {
-	return Details{Qos: 0, MessageID: 0}
-}

packets/connect.go

@@ -1,126 +0,0 @@
-package packets
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-)
-
-//ConnectPacket is an internal representation of the fields of the
-//Connect MQTT packet
-type ConnectPacket struct {
-	FixedHeader
-	ProtocolName    string
-	ProtocolVersion byte
-	CleanSession    bool
-	WillFlag        bool
-	WillQos         byte
-	WillRetain      bool
-	UsernameFlag    bool
-	PasswordFlag    bool
-	ReservedBit     byte
-	Keepalive       uint16
-
-	ClientIdentifier string
-	WillTopic        string
-	WillMessage      []byte
-	Username         string
-	Password         []byte
-}
-
-func (c *ConnectPacket) String() string {
-	str := fmt.Sprintf("%s", c.FixedHeader)
-	str += " "
-	str += fmt.Sprintf("protocolversion: %d protocolname: %s cleansession: %t willflag: %t WillQos: %d WillRetain: %t Usernameflag: %t Passwordflag: %t keepalive: %d clientId: %s willtopic: %s willmessage: %s Username: %s Password: %s", c.ProtocolVersion, c.ProtocolName, c.CleanSession, c.WillFlag, c.WillQos, c.WillRetain, c.UsernameFlag, c.PasswordFlag, c.Keepalive, c.ClientIdentifier, c.WillTopic, c.WillMessage, c.Username, c.Password)
-	return str
-}
-
-func (c *ConnectPacket) Write(w io.Writer) error {
-	var body bytes.Buffer
-	var err error
-
-	body.Write(encodeString(c.ProtocolName))
-	body.WriteByte(c.ProtocolVersion)
-	body.WriteByte(boolToByte(c.CleanSession)<<1 | boolToByte(c.WillFlag)<<2 | c.WillQos<<3 | boolToByte(c.WillRetain)<<5 | boolToByte(c.PasswordFlag)<<6 | boolToByte(c.UsernameFlag)<<7)
-	body.Write(encodeUint16(c.Keepalive))
-	body.Write(encodeString(c.ClientIdentifier))
-	if c.WillFlag {
-		body.Write(encodeString(c.WillTopic))
-		body.Write(encodeBytes(c.WillMessage))
-	}
-	if c.UsernameFlag {
-		body.Write(encodeString(c.Username))
-	}
-	if c.PasswordFlag {
-		body.Write(encodeBytes(c.Password))
-	}
-	c.FixedHeader.RemainingLength = body.Len()
-	packet := c.FixedHeader.pack()
-	packet.Write(body.Bytes())
-	_, err = packet.WriteTo(w)
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (c *ConnectPacket) Unpack(b io.Reader) error {
-	c.ProtocolName = decodeString(b)
-	c.ProtocolVersion = decodeByte(b)
-	options := decodeByte(b)
-	c.ReservedBit = 1 & options
-	c.CleanSession = 1&(options>>1) > 0
-	c.WillFlag = 1&(options>>2) > 0
-	c.WillQos = 3 & (options >> 3)
-	c.WillRetain = 1&(options>>5) > 0
-	c.PasswordFlag = 1&(options>>6) > 0
-	c.UsernameFlag = 1&(options>>7) > 0
-	c.Keepalive = decodeUint16(b)
-	c.ClientIdentifier = decodeString(b)
-	if c.WillFlag {
-		c.WillTopic = decodeString(b)
-		c.WillMessage = decodeBytes(b)
-	}
-	if c.UsernameFlag {
-		c.Username = decodeString(b)
-	}
-	if c.PasswordFlag {
-		c.Password = decodeBytes(b)
-	}
-
-	return nil
-}
-
-//Validate performs validation of the fields of a Connect packet
-func (c *ConnectPacket) Validate() byte {
-	if c.PasswordFlag && !c.UsernameFlag {
-		return ErrRefusedBadUsernameOrPassword
-	}
-	if c.ReservedBit != 0 {
-		//Bad reserved bit
-		return ErrProtocolViolation
-	}
-	if (c.ProtocolName == "MQIsdp" && c.ProtocolVersion != 3) || (c.ProtocolName == "MQTT" && c.ProtocolVersion != 4) {
-		//Mismatched or unsupported protocol version
-		return ErrRefusedBadProtocolVersion
-	}
-	if c.ProtocolName != "MQIsdp" && c.ProtocolName != "MQTT" {
-		//Bad protocol name
-		return ErrProtocolViolation
-	}
-	if len(c.ClientIdentifier) > 65535 || len(c.Username) > 65535 || len(c.Password) > 65535 {
-		//Bad size field
-		return ErrProtocolViolation
-	}
-	if len(c.ClientIdentifier) == 0 && !c.CleanSession {
-		//Bad client identifier
-		return ErrRefusedIDRejected
-	}
-	return Accepted
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (c *ConnectPacket) Details() Details {
-	return Details{Qos: 0, MessageID: 0}
-}

packets/disconnect.go

@@ -1,36 +0,0 @@
-package packets
-
-import (
-	"fmt"
-	"io"
-)
-
-//DisconnectPacket is an internal representation of the fields of the
-//Disconnect MQTT packet
-type DisconnectPacket struct {
-	FixedHeader
-}
-
-func (d *DisconnectPacket) String() string {
-	str := fmt.Sprintf("%s", d.FixedHeader)
-	return str
-}
-
-func (d *DisconnectPacket) Write(w io.Writer) error {
-	packet := d.FixedHeader.pack()
-	_, err := packet.WriteTo(w)
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (d *DisconnectPacket) Unpack(b io.Reader) error {
-	return nil
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (d *DisconnectPacket) Details() Details {
-	return Details{Qos: 0, MessageID: 0}
-}

packets/packets.go

@@ -1,322 +0,0 @@
-package packets
-
-import (
-	"bytes"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-)
-
-//ControlPacket defines the interface for structs intended to hold
-//decoded MQTT packets, either from being read or before being
-//written
-type ControlPacket interface {
-	Write(io.Writer) error
-	Unpack(io.Reader) error
-	String() string
-	Details() Details
-}
-
-//PacketNames maps the constants for each of the MQTT packet types
-//to a string representation of their name.
-var PacketNames = map[uint8]string{
-	1:  "CONNECT",
-	2:  "CONNACK",
-	3:  "PUBLISH",
-	4:  "PUBACK",
-	5:  "PUBREC",
-	6:  "PUBREL",
-	7:  "PUBCOMP",
-	8:  "SUBSCRIBE",
-	9:  "SUBACK",
-	10: "UNSUBSCRIBE",
-	11: "UNSUBACK",
-	12: "PINGREQ",
-	13: "PINGRESP",
-	14: "DISCONNECT",
-}
-
-//Below are the constants assigned to each of the MQTT packet types
-const (
-	Connect     = 1
-	Connack     = 2
-	Publish     = 3
-	Puback      = 4
-	Pubrec      = 5
-	Pubrel      = 6
-	Pubcomp     = 7
-	Subscribe   = 8
-	Suback      = 9
-	Unsubscribe = 10
-	Unsuback    = 11
-	Pingreq     = 12
-	Pingresp    = 13
-	Disconnect  = 14
-)
-
-//Below are the const definitions for error codes returned by
-//Connect()
-const (
-	Accepted                        = 0x00
-	ErrRefusedBadProtocolVersion    = 0x01
-	ErrRefusedIDRejected            = 0x02
-	ErrRefusedServerUnavailable     = 0x03
-	ErrRefusedBadUsernameOrPassword = 0x04
-	ErrRefusedNotAuthorised         = 0x05
-	ErrNetworkError                 = 0xFE
-	ErrProtocolViolation            = 0xFF
-)
-
-//ConnackReturnCodes is a map of the error codes constants for Connect()
-//to a string representation of the error
-var ConnackReturnCodes = map[uint8]string{
-	0:   "Connection Accepted",
-	1:   "Connection Refused: Bad Protocol Version",
-	2:   "Connection Refused: Client Identifier Rejected",
-	3:   "Connection Refused: Server Unavailable",
-	4:   "Connection Refused: Username or Password in unknown format",
-	5:   "Connection Refused: Not Authorised",
-	254: "Connection Error",
-	255: "Connection Refused: Protocol Violation",
-}
-
-//ConnErrors is a map of the errors codes constants for Connect()
-//to a Go error
-var ConnErrors = map[byte]error{
-	Accepted:                        nil,
-	ErrRefusedBadProtocolVersion:    errors.New("Unnacceptable protocol version"),
-	ErrRefusedIDRejected:            errors.New("Identifier rejected"),
-	ErrRefusedServerUnavailable:     errors.New("Server Unavailable"),
-	ErrRefusedBadUsernameOrPassword: errors.New("Bad user name or password"),
-	ErrRefusedNotAuthorised:         errors.New("Not Authorized"),
-	ErrNetworkError:                 errors.New("Network Error"),
-	ErrProtocolViolation:            errors.New("Protocol Violation"),
-}
-
-//ReadPacket takes an instance of an io.Reader (such as net.Conn) and attempts
-//to read an MQTT packet from the stream. It returns a ControlPacket
-//representing the decoded MQTT packet and an error. One of these returns will
-//always be nil, a nil ControlPacket indicating an error occurred.
-func ReadPacket(r io.Reader) (cp ControlPacket, err error) {
-	var fh FixedHeader
-	b := make([]byte, 1)
-
-	_, err = io.ReadFull(r, b)
-	if err != nil {
-		return nil, err
-	}
-	fh.unpack(b[0], r)
-	cp = NewControlPacketWithHeader(fh)
-	if cp == nil {
-		return nil, errors.New("Bad data from client")
-	}
-	packetBytes := make([]byte, fh.RemainingLength)
-	_, err = io.ReadFull(r, packetBytes)
-	if err != nil {
-		return nil, err
-	}
-	err = cp.Unpack(bytes.NewBuffer(packetBytes))
-	return cp, err
-}
-
-//NewControlPacket is used to create a new ControlPacket of the type specified
-//by packetType, this is usually done by reference to the packet type constants
-//defined in packets.go. The newly created ControlPacket is empty and a pointer
-//is returned.
-func NewControlPacket(packetType byte) (cp ControlPacket) {
-	switch packetType {
-	case Connect:
-		cp = &ConnectPacket{FixedHeader: FixedHeader{MessageType: Connect}}
-	case Connack:
-		cp = &ConnackPacket{FixedHeader: FixedHeader{MessageType: Connack}}
-	case Disconnect:
-		cp = &DisconnectPacket{FixedHeader: FixedHeader{MessageType: Disconnect}}
-	case Publish:
-		cp = &PublishPacket{FixedHeader: FixedHeader{MessageType: Publish}}
-	case Puback:
-		cp = &PubackPacket{FixedHeader: FixedHeader{MessageType: Puback}}
-	case Pubrec:
-		cp = &PubrecPacket{FixedHeader: FixedHeader{MessageType: Pubrec}}
-	case Pubrel:
-		cp = &PubrelPacket{FixedHeader: FixedHeader{MessageType: Pubrel, Qos: 1}}
-	case Pubcomp:
-		cp = &PubcompPacket{FixedHeader: FixedHeader{MessageType: Pubcomp}}
-	case Subscribe:
-		cp = &SubscribePacket{FixedHeader: FixedHeader{MessageType: Subscribe, Qos: 1}}
-	case Suback:
-		cp = &SubackPacket{FixedHeader: FixedHeader{MessageType: Suback}}
-	case Unsubscribe:
-		cp = &UnsubscribePacket{FixedHeader: FixedHeader{MessageType: Unsubscribe, Qos: 1}}
-	case Unsuback:
-		cp = &UnsubackPacket{FixedHeader: FixedHeader{MessageType: Unsuback}}
-	case Pingreq:
-		cp = &PingreqPacket{FixedHeader: FixedHeader{MessageType: Pingreq}}
-	case Pingresp:
-		cp = &PingrespPacket{FixedHeader: FixedHeader{MessageType: Pingresp}}
-	default:
-		return nil
-	}
-	return cp
-}
-
-//NewControlPacketWithHeader is used to create a new ControlPacket of the type
-//specified within the FixedHeader that is passed to the function.
-//The newly created ControlPacket is empty and a pointer is returned.
-func NewControlPacketWithHeader(fh FixedHeader) (cp ControlPacket) {
-	switch fh.MessageType {
-	case Connect:
-		cp = &ConnectPacket{FixedHeader: fh}
-	case Connack:
-		cp = &ConnackPacket{FixedHeader: fh}
-	case Disconnect:
-		cp = &DisconnectPacket{FixedHeader: fh}
-	case Publish:
-		cp = &PublishPacket{FixedHeader: fh}
-	case Puback:
-		cp = &PubackPacket{FixedHeader: fh}
-	case Pubrec:
-		cp = &PubrecPacket{FixedHeader: fh}
-	case Pubrel:
-		cp = &PubrelPacket{FixedHeader: fh}
-	case Pubcomp:
-		cp = &PubcompPacket{FixedHeader: fh}
-	case Subscribe:
-		cp = &SubscribePacket{FixedHeader: fh}
-	case Suback:
-		cp = &SubackPacket{FixedHeader: fh}
-	case Unsubscribe:
-		cp = &UnsubscribePacket{FixedHeader: fh}
-	case Unsuback:
-		cp = &UnsubackPacket{FixedHeader: fh}
-	case Pingreq:
-		cp = &PingreqPacket{FixedHeader: fh}
-	case Pingresp:
-		cp = &PingrespPacket{FixedHeader: fh}
-	default:
-		return nil
-	}
-	return cp
-}
-
-//Details struct returned by the Details() function called on
-//ControlPackets to present details of the Qos and MessageID
-//of the ControlPacket
-type Details struct {
-	Qos       byte
-	MessageID uint16
-}
-
-//FixedHeader is a struct to hold the decoded information from
-//the fixed header of an MQTT ControlPacket
-type FixedHeader struct {
-	MessageType     byte
-	Dup             bool
-	Qos             byte
-	Retain          bool
-	RemainingLength int
-}
-
-func (fh FixedHeader) String() string {
-	return fmt.Sprintf("%s: dup: %t qos: %d retain: %t rLength: %d", PacketNames[fh.MessageType], fh.Dup, fh.Qos, fh.Retain, fh.RemainingLength)
-}
-
-func boolToByte(b bool) byte {
-	switch b {
-	case true:
-		return 1
-	default:
-		return 0
-	}
-}
-
-func (fh *FixedHeader) pack() bytes.Buffer {
-	var header bytes.Buffer
-	header.WriteByte(fh.MessageType<<4 | boolToByte(fh.Dup)<<3 | fh.Qos<<1 | boolToByte(fh.Retain))
-	header.Write(encodeLength(fh.RemainingLength))
-	return header
-}
-
-func (fh *FixedHeader) unpack(typeAndFlags byte, r io.Reader) {
-	fh.MessageType = typeAndFlags >> 4
-	fh.Dup = (typeAndFlags>>3)&0x01 > 0
-	fh.Qos = (typeAndFlags >> 1) & 0x03
-	fh.Retain = typeAndFlags&0x01 > 0
-	fh.RemainingLength = decodeLength(r)
-}
-
-func decodeByte(b io.Reader) byte {
-	num := make([]byte, 1)
-	b.Read(num)
-	return num[0]
-}
-
-func decodeUint16(b io.Reader) uint16 {
-	num := make([]byte, 2)
-	b.Read(num)
-	return binary.BigEndian.Uint16(num)
-}
-
-func encodeUint16(num uint16) []byte {
-	bytes := make([]byte, 2)
-	binary.BigEndian.PutUint16(bytes, num)
-	return bytes
-}
-
-func encodeString(field string) []byte {
-	fieldLength := make([]byte, 2)
-	binary.BigEndian.PutUint16(fieldLength, uint16(len(field)))
-	return append(fieldLength, []byte(field)...)
-}
-
-func decodeString(b io.Reader) string {
-	fieldLength := decodeUint16(b)
-	field := make([]byte, fieldLength)
-	b.Read(field)
-	return string(field)
-}
-
-func decodeBytes(b io.Reader) []byte {
-	fieldLength := decodeUint16(b)
-	field := make([]byte, fieldLength)
-	b.Read(field)
-	return field
-}
-
-func encodeBytes(field []byte) []byte {
-	fieldLength := make([]byte, 2)
-	binary.BigEndian.PutUint16(fieldLength, uint16(len(field)))
-	return append(fieldLength, field...)
-}
-
-func encodeLength(length int) []byte {
-	var encLength []byte
-	for {
-		digit := byte(length % 128)
-		length /= 128
-		if length > 0 {
-			digit |= 0x80
-		}
-		encLength = append(encLength, digit)
-		if length == 0 {
-			break
-		}
-	}
-	return encLength
-}
-
-func decodeLength(r io.Reader) int {
-	var rLength uint32
-	var multiplier uint32
-	b := make([]byte, 1)
-	for multiplier < 27 { //fix: Infinite '(digit & 128) == 1' will cause the dead loop
-		io.ReadFull(r, b)
-		digit := b[0]
-		rLength |= uint32(digit&127) << multiplier
-		if (digit & 128) == 0 {
-			break
-		}
-		multiplier += 7
-	}
-	return int(rLength)
-}

packets/packets_test.go

@@ -1,159 +0,0 @@
-package packets
-
-import (
-	"bytes"
-	"testing"
-)
-
-func TestPacketNames(t *testing.T) {
-	if PacketNames[1] != "CONNECT" {
-		t.Errorf("PacketNames[1] is %s, should be %s", PacketNames[1], "CONNECT")
-	}
-	if PacketNames[2] != "CONNACK" {
-		t.Errorf("PacketNames[2] is %s, should be %s", PacketNames[2], "CONNACK")
-	}
-	if PacketNames[3] != "PUBLISH" {
-		t.Errorf("PacketNames[3] is %s, should be %s", PacketNames[3], "PUBLISH")
-	}
-	if PacketNames[4] != "PUBACK" {
-		t.Errorf("PacketNames[4] is %s, should be %s", PacketNames[4], "PUBACK")
-	}
-	if PacketNames[5] != "PUBREC" {
-		t.Errorf("PacketNames[5] is %s, should be %s", PacketNames[5], "PUBREC")
-	}
-	if PacketNames[6] != "PUBREL" {
-		t.Errorf("PacketNames[6] is %s, should be %s", PacketNames[6], "PUBREL")
-	}
-	if PacketNames[7] != "PUBCOMP" {
-		t.Errorf("PacketNames[7] is %s, should be %s", PacketNames[7], "PUBCOMP")
-	}
-	if PacketNames[8] != "SUBSCRIBE" {
-		t.Errorf("PacketNames[8] is %s, should be %s", PacketNames[8], "SUBSCRIBE")
-	}
-	if PacketNames[9] != "SUBACK" {
-		t.Errorf("PacketNames[9] is %s, should be %s", PacketNames[9], "SUBACK")
-	}
-	if PacketNames[10] != "UNSUBSCRIBE" {
-		t.Errorf("PacketNames[10] is %s, should be %s", PacketNames[10], "UNSUBSCRIBE")
-	}
-	if PacketNames[11] != "UNSUBACK" {
-		t.Errorf("PacketNames[11] is %s, should be %s", PacketNames[11], "UNSUBACK")
-	}
-	if PacketNames[12] != "PINGREQ" {
-		t.Errorf("PacketNames[12] is %s, should be %s", PacketNames[12], "PINGREQ")
-	}
-	if PacketNames[13] != "PINGRESP" {
-		t.Errorf("PacketNames[13] is %s, should be %s", PacketNames[13], "PINGRESP")
-	}
-	if PacketNames[14] != "DISCONNECT" {
-		t.Errorf("PacketNames[14] is %s, should be %s", PacketNames[14], "DISCONNECT")
-	}
-}
-
-func TestPacketConsts(t *testing.T) {
-	if Connect != 1 {
-		t.Errorf("Const for Connect is %d, should be %d", Connect, 1)
-	}
-	if Connack != 2 {
-		t.Errorf("Const for Connack is %d, should be %d", Connack, 2)
-	}
-	if Publish != 3 {
-		t.Errorf("Const for Publish is %d, should be %d", Publish, 3)
-	}
-	if Puback != 4 {
-		t.Errorf("Const for Puback is %d, should be %d", Puback, 4)
-	}
-	if Pubrec != 5 {
-		t.Errorf("Const for Pubrec is %d, should be %d", Pubrec, 5)
-	}
-	if Pubrel != 6 {
-		t.Errorf("Const for Pubrel is %d, should be %d", Pubrel, 6)
-	}
-	if Pubcomp != 7 {
-		t.Errorf("Const for Pubcomp is %d, should be %d", Pubcomp, 7)
-	}
-	if Subscribe != 8 {
-		t.Errorf("Const for Subscribe is %d, should be %d", Subscribe, 8)
-	}
-	if Suback != 9 {
-		t.Errorf("Const for Suback is %d, should be %d", Suback, 9)
-	}
-	if Unsubscribe != 10 {
-		t.Errorf("Const for Unsubscribe is %d, should be %d", Unsubscribe, 10)
-	}
-	if Unsuback != 11 {
-		t.Errorf("Const for Unsuback is %d, should be %d", Unsuback, 11)
-	}
-	if Pingreq != 12 {
-		t.Errorf("Const for Pingreq is %d, should be %d", Pingreq, 12)
-	}
-	if Pingresp != 13 {
-		t.Errorf("Const for Pingresp is %d, should be %d", Pingresp, 13)
-	}
-	if Disconnect != 14 {
-		t.Errorf("Const for Disconnect is %d, should be %d", Disconnect, 14)
-	}
-}
-
-func TestConnackConsts(t *testing.T) {
-	if Accepted != 0x00 {
-		t.Errorf("Const for Accepted is %d, should be %d", Accepted, 0)
-	}
-	if ErrRefusedBadProtocolVersion != 0x01 {
-		t.Errorf("Const for RefusedBadProtocolVersion is %d, should be %d", ErrRefusedBadProtocolVersion, 1)
-	}
-	if ErrRefusedIDRejected != 0x02 {
-		t.Errorf("Const for RefusedIDRejected is %d, should be %d", ErrRefusedIDRejected, 2)
-	}
-	if ErrRefusedServerUnavailable != 0x03 {
-		t.Errorf("Const for RefusedServerUnavailable is %d, should be %d", ErrRefusedServerUnavailable, 3)
-	}
-	if ErrRefusedBadUsernameOrPassword != 0x04 {
-		t.Errorf("Const for RefusedBadUsernameOrPassword is %d, should be %d", ErrRefusedBadUsernameOrPassword, 4)
-	}
-	if ErrRefusedNotAuthorised != 0x05 {
-		t.Errorf("Const for RefusedNotAuthorised is %d, should be %d", ErrRefusedNotAuthorised, 5)
-	}
-}
-
-func TestConnectPacket(t *testing.T) {
-	connectPacketBytes := bytes.NewBuffer([]byte{16, 52, 0, 4, 77, 81, 84, 84, 4, 204, 0, 0, 0, 0, 0, 4, 116, 101, 115, 116, 0, 12, 84, 101, 115, 116, 32, 80, 97, 121, 108, 111, 97, 100, 0, 8, 116, 101, 115, 116, 117, 115, 101, 114, 0, 8, 116, 101, 115, 116, 112, 97, 115, 115})
-	packet, err := ReadPacket(connectPacketBytes)
-	if err != nil {
-		t.Fatalf("Error reading packet: %s", err.Error())
-	}
-	cp := packet.(*ConnectPacket)
-	if cp.ProtocolName != "MQTT" {
-		t.Errorf("Connect Packet ProtocolName is %s, should be %s", cp.ProtocolName, "MQTT")
-	}
-	if cp.ProtocolVersion != 4 {
-		t.Errorf("Connect Packet ProtocolVersion is %d, should be %d", cp.ProtocolVersion, 4)
-	}
-	if cp.UsernameFlag != true {
-		t.Errorf("Connect Packet UsernameFlag is %t, should be %t", cp.UsernameFlag, true)
-	}
-	if cp.Username != "testuser" {
-		t.Errorf("Connect Packet Username is %s, should be %s", cp.Username, "testuser")
-	}
-	if cp.PasswordFlag != true {
-		t.Errorf("Connect Packet PasswordFlag is %t, should be %t", cp.PasswordFlag, true)
-	}
-	if string(cp.Password) != "testpass" {
-		t.Errorf("Connect Packet Password is %s, should be %s", string(cp.Password), "testpass")
-	}
-	if cp.WillFlag != true {
-		t.Errorf("Connect Packet WillFlag is %t, should be %t", cp.WillFlag, true)
-	}
-	if cp.WillTopic != "test" {
-		t.Errorf("Connect Packet WillTopic is %s, should be %s", cp.WillTopic, "test")
-	}
-	if cp.WillQos != 1 {
-		t.Errorf("Connect Packet WillQos is %d, should be %d", cp.WillQos, 1)
-	}
-	if cp.WillRetain != false {
-		t.Errorf("Connect Packet WillRetain is %t, should be %t", cp.WillRetain, false)
-	}
-	if string(cp.WillMessage) != "Test Payload" {
-		t.Errorf("Connect Packet WillMessage is %s, should be %s", string(cp.WillMessage), "Test Payload")
-	}
-}

packets/pingreq.go

@@ -1,36 +0,0 @@
-package packets
-
-import (
-	"fmt"
-	"io"
-)
-
-//PingreqPacket is an internal representation of the fields of the
-//Pingreq MQTT packet
-type PingreqPacket struct {
-	FixedHeader
-}
-
-func (pr *PingreqPacket) String() string {
-	str := fmt.Sprintf("%s", pr.FixedHeader)
-	return str
-}
-
-func (pr *PingreqPacket) Write(w io.Writer) error {
-	packet := pr.FixedHeader.pack()
-	_, err := packet.WriteTo(w)
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (pr *PingreqPacket) Unpack(b io.Reader) error {
-	return nil
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (pr *PingreqPacket) Details() Details {
-	return Details{Qos: 0, MessageID: 0}
-}

packets/pingresp.go

@@ -1,36 +0,0 @@
-package packets
-
-import (
-	"fmt"
-	"io"
-)
-
-//PingrespPacket is an internal representation of the fields of the
-//Pingresp MQTT packet
-type PingrespPacket struct {
-	FixedHeader
-}
-
-func (pr *PingrespPacket) String() string {
-	str := fmt.Sprintf("%s", pr.FixedHeader)
-	return str
-}
-
-func (pr *PingrespPacket) Write(w io.Writer) error {
-	packet := pr.FixedHeader.pack()
-	_, err := packet.WriteTo(w)
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (pr *PingrespPacket) Unpack(b io.Reader) error {
-	return nil
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (pr *PingrespPacket) Details() Details {
-	return Details{Qos: 0, MessageID: 0}
-}

packets/puback.go

@@ -1,44 +0,0 @@
-package packets
-
-import (
-	"fmt"
-	"io"
-)
-
-//PubackPacket is an internal representation of the fields of the
-//Puback MQTT packet
-type PubackPacket struct {
-	FixedHeader
-	MessageID uint16
-}
-
-func (pa *PubackPacket) String() string {
-	str := fmt.Sprintf("%s", pa.FixedHeader)
-	str += " "
-	str += fmt.Sprintf("MessageID: %d", pa.MessageID)
-	return str
-}
-
-func (pa *PubackPacket) Write(w io.Writer) error {
-	var err error
-	pa.FixedHeader.RemainingLength = 2
-	packet := pa.FixedHeader.pack()
-	packet.Write(encodeUint16(pa.MessageID))
-	_, err = packet.WriteTo(w)
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (pa *PubackPacket) Unpack(b io.Reader) error {
-	pa.MessageID = decodeUint16(b)
-
-	return nil
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (pa *PubackPacket) Details() Details {
-	return Details{Qos: pa.Qos, MessageID: pa.MessageID}
-}

packets/pubcomp.go

@@ -1,44 +0,0 @@
-package packets
-
-import (
-	"fmt"
-	"io"
-)
-
-//PubcompPacket is an internal representation of the fields of the
-//Pubcomp MQTT packet
-type PubcompPacket struct {
-	FixedHeader
-	MessageID uint16
-}
-
-func (pc *PubcompPacket) String() string {
-	str := fmt.Sprintf("%s", pc.FixedHeader)
-	str += " "
-	str += fmt.Sprintf("MessageID: %d", pc.MessageID)
-	return str
-}
-
-func (pc *PubcompPacket) Write(w io.Writer) error {
-	var err error
-	pc.FixedHeader.RemainingLength = 2
-	packet := pc.FixedHeader.pack()
-	packet.Write(encodeUint16(pc.MessageID))
-	_, err = packet.WriteTo(w)
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (pc *PubcompPacket) Unpack(b io.Reader) error {
-	pc.MessageID = decodeUint16(b)
-
-	return nil
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (pc *PubcompPacket) Details() Details {
-	return Details{Qos: pc.Qos, MessageID: pc.MessageID}
-}

packets/publish.go

@@ -1,80 +0,0 @@
-package packets
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-)
-
-//PublishPacket is an internal representation of the fields of the
-//Publish MQTT packet
-type PublishPacket struct {
-	FixedHeader
-	TopicName string
-	MessageID uint16
-	Payload   []byte
-}
-
-func (p *PublishPacket) String() string {
-	str := fmt.Sprintf("%s", p.FixedHeader)
-	str += " "
-	str += fmt.Sprintf("topicName: %s MessageID: %d", p.TopicName, p.MessageID)
-	str += " "
-	str += fmt.Sprintf("payload: %s", string(p.Payload))
-	return str
-}
-
-func (p *PublishPacket) Write(w io.Writer) error {
-	var body bytes.Buffer
-	var err error
-
-	body.Write(encodeString(p.TopicName))
-	if p.Qos > 0 {
-		body.Write(encodeUint16(p.MessageID))
-	}
-	p.FixedHeader.RemainingLength = body.Len() + len(p.Payload)
-	packet := p.FixedHeader.pack()
-	packet.Write(body.Bytes())
-	packet.Write(p.Payload)
-	_, err = w.Write(packet.Bytes())
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (p *PublishPacket) Unpack(b io.Reader) error {
-	var payloadLength = p.FixedHeader.RemainingLength
-	p.TopicName = decodeString(b)
-	if p.Qos > 0 {
-		p.MessageID = decodeUint16(b)
-		payloadLength -= len(p.TopicName) + 4
-	} else {
-		payloadLength -= len(p.TopicName) + 2
-	}
-	if payloadLength < 0 {
-		return fmt.Errorf("Error upacking publish, payload length < 0")
-	}
-	p.Payload = make([]byte, payloadLength)
-	_, err := b.Read(p.Payload)
-
-	return err
-}
-
-//Copy creates a new PublishPacket with the same topic and payload
-//but an empty fixed header, useful for when you want to deliver
-//a message with different properties such as Qos but the same
-//content
-func (p *PublishPacket) Copy() *PublishPacket {
-	newP := NewControlPacket(Publish).(*PublishPacket)
-	newP.TopicName = p.TopicName
-	newP.Payload = p.Payload
-
-	return newP
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (p *PublishPacket) Details() Details {
-	return Details{Qos: p.Qos, MessageID: p.MessageID}
-}

packets/pubrec.go

@@ -1,44 +0,0 @@
-package packets
-
-import (
-	"fmt"
-	"io"
-)
-
-//PubrecPacket is an internal representation of the fields of the
-//Pubrec MQTT packet
-type PubrecPacket struct {
-	FixedHeader
-	MessageID uint16
-}
-
-func (pr *PubrecPacket) String() string {
-	str := fmt.Sprintf("%s", pr.FixedHeader)
-	str += " "
-	str += fmt.Sprintf("MessageID: %d", pr.MessageID)
-	return str
-}
-
-func (pr *PubrecPacket) Write(w io.Writer) error {
-	var err error
-	pr.FixedHeader.RemainingLength = 2
-	packet := pr.FixedHeader.pack()
-	packet.Write(encodeUint16(pr.MessageID))
-	_, err = packet.WriteTo(w)
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (pr *PubrecPacket) Unpack(b io.Reader) error {
-	pr.MessageID = decodeUint16(b)
-
-	return nil
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (pr *PubrecPacket) Details() Details {
-	return Details{Qos: pr.Qos, MessageID: pr.MessageID}
-}

packets/pubrel.go

@@ -1,44 +0,0 @@
-package packets
-
-import (
-	"fmt"
-	"io"
-)
-
-//PubrelPacket is an internal representation of the fields of the
-//Pubrel MQTT packet
-type PubrelPacket struct {
-	FixedHeader
-	MessageID uint16
-}
-
-func (pr *PubrelPacket) String() string {
-	str := fmt.Sprintf("%s", pr.FixedHeader)
-	str += " "
-	str += fmt.Sprintf("MessageID: %d", pr.MessageID)
-	return str
-}
-
-func (pr *PubrelPacket) Write(w io.Writer) error {
-	var err error
-	pr.FixedHeader.RemainingLength = 2
-	packet := pr.FixedHeader.pack()
-	packet.Write(encodeUint16(pr.MessageID))
-	_, err = packet.WriteTo(w)
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (pr *PubrelPacket) Unpack(b io.Reader) error {
-	pr.MessageID = decodeUint16(b)
-
-	return nil
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (pr *PubrelPacket) Details() Details {
-	return Details{Qos: pr.Qos, MessageID: pr.MessageID}
-}

packets/suback.go

@@ -1,52 +0,0 @@
-package packets
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-)
-
-//SubackPacket is an internal representation of the fields of the
-//Suback MQTT packet
-type SubackPacket struct {
-	FixedHeader
-	MessageID   uint16
-	ReturnCodes []byte
-}
-
-func (sa *SubackPacket) String() string {
-	str := fmt.Sprintf("%s", sa.FixedHeader)
-	str += " "
-	str += fmt.Sprintf("MessageID: %d", sa.MessageID)
-	return str
-}
-
-func (sa *SubackPacket) Write(w io.Writer) error {
-	var body bytes.Buffer
-	var err error
-	body.Write(encodeUint16(sa.MessageID))
-	body.Write(sa.ReturnCodes)
-	sa.FixedHeader.RemainingLength = body.Len()
-	packet := sa.FixedHeader.pack()
-	packet.Write(body.Bytes())
-	_, err = packet.WriteTo(w)
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (sa *SubackPacket) Unpack(b io.Reader) error {
-	var qosBuffer bytes.Buffer
-	sa.MessageID = decodeUint16(b)
-	qosBuffer.ReadFrom(b)
-	sa.ReturnCodes = qosBuffer.Bytes()
-
-	return nil
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (sa *SubackPacket) Details() Details {
-	return Details{Qos: 0, MessageID: sa.MessageID}
-}

packets/subscribe.go

@@ -1,62 +0,0 @@
-package packets
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-)
-
-//SubscribePacket is an internal representation of the fields of the
-//Subscribe MQTT packet
-type SubscribePacket struct {
-	FixedHeader
-	MessageID uint16
-	Topics    []string
-	Qoss      []byte
-}
-
-func (s *SubscribePacket) String() string {
-	str := fmt.Sprintf("%s", s.FixedHeader)
-	str += " "
-	str += fmt.Sprintf("MessageID: %d topics: %s", s.MessageID, s.Topics)
-	return str
-}
-
-func (s *SubscribePacket) Write(w io.Writer) error {
-	var body bytes.Buffer
-	var err error
-
-	body.Write(encodeUint16(s.MessageID))
-	for i, topic := range s.Topics {
-		body.Write(encodeString(topic))
-		body.WriteByte(s.Qoss[i])
-	}
-	s.FixedHeader.RemainingLength = body.Len()
-	packet := s.FixedHeader.pack()
-	packet.Write(body.Bytes())
-	_, err = packet.WriteTo(w)
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (s *SubscribePacket) Unpack(b io.Reader) error {
-	s.MessageID = decodeUint16(b)
-	payloadLength := s.FixedHeader.RemainingLength - 2
-	for payloadLength > 0 {
-		topic := decodeString(b)
-		s.Topics = append(s.Topics, topic)
-		qos := decodeByte(b)
-		s.Qoss = append(s.Qoss, qos)
-		payloadLength -= 2 + len(topic) + 1 //2 bytes of string length, plus string, plus 1 byte for Qos
-	}
-
-	return nil
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (s *SubscribePacket) Details() Details {
-	return Details{Qos: 1, MessageID: s.MessageID}
-}

packets/unsuback.go

@@ -1,44 +0,0 @@
-package packets
-
-import (
-	"fmt"
-	"io"
-)
-
-//UnsubackPacket is an internal representation of the fields of the
-//Unsuback MQTT packet
-type UnsubackPacket struct {
-	FixedHeader
-	MessageID uint16
-}
-
-func (ua *UnsubackPacket) String() string {
-	str := fmt.Sprintf("%s", ua.FixedHeader)
-	str += " "
-	str += fmt.Sprintf("MessageID: %d", ua.MessageID)
-	return str
-}
-
-func (ua *UnsubackPacket) Write(w io.Writer) error {
-	var err error
-	ua.FixedHeader.RemainingLength = 2
-	packet := ua.FixedHeader.pack()
-	packet.Write(encodeUint16(ua.MessageID))
-	_, err = packet.WriteTo(w)
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (ua *UnsubackPacket) Unpack(b io.Reader) error {
-	ua.MessageID = decodeUint16(b)
-
-	return nil
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (ua *UnsubackPacket) Details() Details {
-	return Details{Qos: 0, MessageID: ua.MessageID}
-}

packets/unsubscribe.go

@@ -1,55 +0,0 @@
-package packets
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-)
-
-//UnsubscribePacket is an internal representation of the fields of the
-//Unsubscribe MQTT packet
-type UnsubscribePacket struct {
-	FixedHeader
-	MessageID uint16
-	Topics    []string
-}
-
-func (u *UnsubscribePacket) String() string {
-	str := fmt.Sprintf("%s", u.FixedHeader)
-	str += " "
-	str += fmt.Sprintf("MessageID: %d", u.MessageID)
-	return str
-}
-
-func (u *UnsubscribePacket) Write(w io.Writer) error {
-	var body bytes.Buffer
-	var err error
-	body.Write(encodeUint16(u.MessageID))
-	for _, topic := range u.Topics {
-		body.Write(encodeString(topic))
-	}
-	u.FixedHeader.RemainingLength = body.Len()
-	packet := u.FixedHeader.pack()
-	packet.Write(body.Bytes())
-	_, err = packet.WriteTo(w)
-
-	return err
-}
-
-//Unpack decodes the details of a ControlPacket after the fixed
-//header has been read
-func (u *UnsubscribePacket) Unpack(b io.Reader) error {
-	u.MessageID = decodeUint16(b)
-	var topic string
-	for topic = decodeString(b); topic != ""; topic = decodeString(b) {
-		u.Topics = append(u.Topics, topic)
-	}
-
-	return nil
-}
-
-//Details returns a Details struct containing the Qos and
-//MessageID of this ControlPacket
-func (u *UnsubscribePacket) Details() Details {
-	return Details{Qos: 1, MessageID: u.MessageID}
-}