func (this *Ackqueue) insert(pktid uint16, msg message.Message, onComplete interface{}) error {
if this.full() {
this.grow()
}
if _, ok := this.emap[pktid]; !ok {
// message length
ml := msg.Len()
// ackmsg
am := ackmsg{
Mtype: msg.Type(),
State: message.RESERVED,
Pktid: msg.PacketId(),
Msgbuf: make([]byte, ml),
OnComplete: onComplete,
}
if _, err := msg.Encode(am.Msgbuf); err != nil {
return err
}
this.ring[this.tail] = am
this.emap[pktid] = this.tail
this.tail = this.increment(this.tail)
this.count++
} else {
// If packet w/ pktid already exist, then this must be a PUBLISH message
// Other message types should never send with the same packet ID
pm, ok := msg.(*message.PublishMessage)
if !ok {
return fmt.Errorf("ack/insert: duplicate packet ID for %s message", msg.Name())
}
// If this is a publish message, then the DUP flag must be set. This is the
// only scenario in which we will receive duplicate messages.
if pm.Dup() {
return fmt.Errorf("ack/insert: duplicate packet ID for PUBLISH message, but DUP flag is not set")
}
// Since it's a dup, there's really nothing we need to do. Moving on...
}
return nil
}
// Wait() copies the message into a waiting queue, and waits for the corresponding
// ack message to be received.
func (this *Ackqueue) Wait(msg message.Message, onComplete interface{}) error {
this.mu.Lock()
defer this.mu.Unlock()
switch msg := msg.(type) {
case *message.PublishMessage:
if msg.QoS() == message.QosAtMostOnce {
//return fmt.Errorf("QoS 0 messages don't require ack")
return errWaitMessage
}
this.insert(msg.PacketId(), msg, onComplete)
case *message.SubscribeMessage:
this.insert(msg.PacketId(), msg, onComplete)
case *message.UnsubscribeMessage:
this.insert(msg.PacketId(), msg, onComplete)
case *message.PingreqMessage:
this.ping = ackmsg{
Mtype: message.PINGREQ,
State: message.RESERVED,
OnComplete: onComplete,
}
default:
return errWaitMessage
}
return nil
}
// Ack() takes the ack message supplied and updates the status of messages waiting.
func (this *Ackqueue) Ack(msg message.Message) error {
this.mu.Lock()
defer this.mu.Unlock()
switch msg.Type() {
case message.PUBACK, message.PUBREC, message.PUBREL, message.PUBCOMP, message.SUBACK, message.UNSUBACK:
// Check to see if the message w/ the same packet ID is in the queue
i, ok := this.emap[msg.PacketId()]
if ok {
// If message w/ the packet ID exists, update the message state and copy
// the ack message
this.ring[i].State = msg.Type()
ml := msg.Len()
this.ring[i].Ackbuf = make([]byte, ml)
_, err := msg.Encode(this.ring[i].Ackbuf)
if err != nil {
return err
}
//glog.Debugf("Acked: %v", msg)
//} else {
//glog.Debugf("Cannot ack %s message with packet ID %d", msg.Type(), msg.PacketId())
}
case message.PINGRESP:
if this.ping.Mtype == message.PINGREQ {
this.ping.State = message.PINGRESP
}
default:
return errAckMessage
}
return nil
}
func (this *service) processIncoming(msg message.Message) error {
var err error = nil
switch msg := msg.(type) {
case *message.PublishMessage:
// For PUBLISH message, we should figure out what QoS it is and process accordingly
// If QoS == 0, we should just take the next step, no ack required
// If QoS == 1, we should send back PUBACK, then take the next step
// If QoS == 2, we need to put it in the ack queue, send back PUBREC
err = this.processPublish(msg)
case *message.PubackMessage:
// For PUBACK message, it means QoS 1, we should send to ack queue
this.sess.Pub1ack.Ack(msg)
this.processAcked(this.sess.Pub1ack)
case *message.PubrecMessage:
// For PUBREC message, it means QoS 2, we should send to ack queue, and send back PUBREL
if err = this.sess.Pub2out.Ack(msg); err != nil {
break
}
resp := message.NewPubrelMessage()
resp.SetPacketId(msg.PacketId())
_, err = this.writeMessage(resp)
case *message.PubrelMessage:
// For PUBREL message, it means QoS 2, we should send to ack queue, and send back PUBCOMP
if err = this.sess.Pub2in.Ack(msg); err != nil {
break
}
this.processAcked(this.sess.Pub2in)
resp := message.NewPubcompMessage()
resp.SetPacketId(msg.PacketId())
_, err = this.writeMessage(resp)
case *message.PubcompMessage:
// For PUBCOMP message, it means QoS 2, we should send to ack queue
if err = this.sess.Pub2out.Ack(msg); err != nil {
break
}
this.processAcked(this.sess.Pub2out)
case *message.SubscribeMessage:
// For SUBSCRIBE message, we should add subscriber, then send back SUBACK
return this.processSubscribe(msg)
case *message.SubackMessage:
// For SUBACK message, we should send to ack queue
this.sess.Suback.Ack(msg)
this.processAcked(this.sess.Suback)
case *message.UnsubscribeMessage:
// For UNSUBSCRIBE message, we should remove subscriber, then send back UNSUBACK
return this.processUnsubscribe(msg)
case *message.UnsubackMessage:
// For UNSUBACK message, we should send to ack queue
this.sess.Unsuback.Ack(msg)
this.processAcked(this.sess.Unsuback)
case *message.PingreqMessage:
// For PINGREQ message, we should send back PINGRESP
resp := message.NewPingrespMessage()
_, err = this.writeMessage(resp)
case *message.PingrespMessage:
this.sess.Pingack.Ack(msg)
this.processAcked(this.sess.Pingack)
case *message.DisconnectMessage:
// For DISCONNECT message, we should quit
this.sess.Cmsg.SetWillFlag(false)
return errDisconnect
default:
return fmt.Errorf("(%s) invalid message type %s.", this.cid(), msg.Name())
}
if err != nil {
glog.Debugf("(%s) Error processing acked message: %v", this.cid(), err)
}
return err
}
