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
}
func (this *service) processIncoming(msg message.Message) error {
var err error = nil
// Log.Errorc(func() string{ return fmt.Sprintf("this.subs is: %v, count is %d, msg_type is %T", this.subs, len(this.subs), msg)})
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
// (*msg).SetPacketId(getRandPkgId())
// Log.Errorc(func() string{ return fmt.Sprintf("\n%T:%d==========\nmsg is %v\n=====================", *msg, msg.PacketId(), *msg)})
err = this.processPublish(msg)
case *message.PubackMessage:
// Log.Errorc(func() string{ return fmt.Sprintf("this.subs is: %v, count is %d, msg_type is %T", this.subs, len(this.subs), msg)})
// For PUBACK message, it means QoS 1, we should send to ack queue
// Log.Errorc(func() string{ return fmt.Sprintf("\n%T:%d==========\nmsg is %v\n=====================", *msg, msg.PacketId(), *msg)})
go processAck(msg.PacketId(), this)
// 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
// Log.Debugc(func() string { return fmt.Sprintf("(%s) receive pingreq.", this.cid()) })
resp := message.NewPingrespMessage()
_, err = this.writeMessage(resp)
case *message.PingrespMessage:
// Log.Debugc(func() string { return fmt.Sprintf("(%s) receive pingresp.", this.cid()) })
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 {
Log.Error("(%s) Error processing acked message: %v", this.cid(), err)
}
return err
}
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
}
func onCompleteFunc(msg, ack message.Message, err error) error {
jklog.L().Infoln("Received complete func")
jklog.L().Infoln("name: ", msg.Name())
return nil
}