Golang PublishMessage.Topic方法代码示例

// 判断消息是否已读
func (this *service) handlePendingMessage(msg *message.PublishMessage, pending_status *PendingStatus) {
	// 如果QOS=0,则无需等待直接返回
	if string(msg.Topic()) == OnlineStatusChannel {
		return
	}

	// 将msg按照pkt_id，存入pending队列
	pkt_id := msg.PacketId()
	//   pending_msg := NewPendingMessage(msg)

	select {
	case <-pending_status.Done:
	// 消息已成功接收，不再等待
	case <-time.After(time.Second * MsgPendingTime):
		// 重试一次
		Log.Debugc(func() string {
			return fmt.Sprintf("(%s) receive ack %d timeout. try to resend. topic: %s", this.cid(), msg.PacketId(), msg.Topic())
		})
		this.retryPublish(msg)

		select {
		case <-pending_status.Done:
			// 重发的消息已成功接收，不再等待
		case <-time.After(time.Second * MsgPendingTime):
			// 没有回ack，放到离线队列里
			Log.Debugc(func() string {
				return fmt.Sprintf("(%s) receive ack %d timeout. send msg to offline msg queue.topic: %s", this.cid(), msg.PacketId(), msg.Topic())
				//       return fmt.Sprintf("(%s) receive ack timeout. send msg to offline msg queue.topic: %s, payload: %s", this.cid(), msg.Topic(),msg.Payload())
			})
			OfflineTopicQueueProcessor <- msg
		}
	}
	PendingQueue[pkt_id] = nil
}

// onPublish() is called when the server receives a PUBLISH message AND have completed
// the ack cycle. This method will get the list of subscribers based on the publish
// topic, and publishes the message to the list of subscribers.
func (this *service) onPublish(msg *message.PublishMessage) error {
	if msg.Retain() {
		if err := this.topicsMgr.Retain(msg); err != nil {
			glog.Errorf("(%s) Error retaining message: %v", this.cid(), err)
		}
	}

	err := this.topicsMgr.Subscribers(msg.Topic(), msg.QoS(), &this.subs, &this.qoss)
	if err != nil {
		glog.Errorf("(%s) Error retrieving subscribers list: %v", this.cid(), err)
		return err
	}

	msg.SetRetain(false)

	//glog.Debugf("(%s) Publishing to topic %q and %d subscribers", this.cid(), string(msg.Topic()), len(this.subs))
	for _, s := range this.subs {
		if s != nil {
			fn, ok := s.(*OnPublishFunc)
			if !ok {
				glog.Errorf("Invalid onPublish Function")
				return fmt.Errorf("Invalid onPublish Function")
			} else {
				(*fn)(msg)
			}
		}
	}

	return nil
}

// Publish sends a single MQTT PUBLISH message to the server. On completion, the
// supplied OnCompleteFunc is called. For QOS 0 messages, onComplete is called
// immediately after the message is sent to the outgoing buffer. For QOS 1 messages,
// onComplete is called when PUBACK is received. For QOS 2 messages, onComplete is
// called after the PUBCOMP message is received.
func (this *Server) Publish(msg *message.PublishMessage, onComplete OnCompleteFunc) error {
	if err := this.checkConfiguration(); err != nil {
		return err
	}

	if msg.Retain() {
		if err := this.topicsMgr.Retain(msg); err != nil {
			glog.Errorf("Error retaining message: %v", err)
		}
	}

	if err := this.topicsMgr.Subscribers(msg.Topic(), msg.QoS(), &this.subs, &this.qoss); err != nil {
		return err
	}

	msg.SetRetain(false)

	//glog.Debugf("(server) Publishing to topic %q and %d subscribers", string(msg.Topic()), len(this.subs))
	for _, s := range this.subs {
		if s != nil {
			fn, ok := s.(*OnPublishFunc)
			if !ok {
				glog.Errorf("Invalid onPublish Function")
			} else {
				(*fn)(msg)
			}
		}
	}

	return nil
}

// Publish sends a single MQTT PUBLISH message to the server. On completion, the
// supplied OnCompleteFunc is called. For QOS 0 messages, onComplete is called
// immediately after the message is sent to the outgoing buffer. For QOS 1 messages,
// onComplete is called when PUBACK is received. For QOS 2 messages, onComplete is
// called after the PUBCOMP message is received.
func (this *Server) Publish(msg *message.PublishMessage, onComplete OnCompleteFunc) (err error) {
	if err = this.checkConfiguration(); err != nil {
		return err
	}

	if err = this.topicsMgr.Subscribers(msg.Topic(), msg.QoS(), &this.subs, &this.qoss); err != nil {
		//   if err = this.topicsMgr.Subscribers(msg.Topic(), msg.QoS(), &this.subs, &this.qoss); err != nil {
		return err
	}

	subs := _get_temp_subs()
	defer _return_temp_subs(subs)
	//   defer _return_tmp_msg(msg)

	Log.Debugc(func() string {
		return fmt.Sprintf("(server) Publishing to topic %s and %d subscribers", string(msg.Topic()), len(subs))
	})

	for _, s := range subs {
		if s != nil {
			fn, ok := s.(*OnPublishFunc)
			if !ok {
				Log.Error("Invalid onPublish Function")
			} else {
				err = (*fn)(msg)
			}
		}
	}

	return err
}

func pub(c *service.Client, msg *message.PublishMessage) error {
	log.Printf("on publish: topic=%s payload=%s\n", string(msg.Topic()), string(msg.Payload()))
	pub := message.NewPublishMessage()
	pub.SetTopic([]byte("a/b/c/response"))
	pub.SetQoS(0)
	pub.SetPayload([]byte("Hi MQTT Server"))
	return c.Publish(pub, nil)
}

// processPublish() is called when the server receives a PUBLISH message AND have completed
// the ack cycle. This method will get the list of subscribers based on the publish
// topic, and publishes the message to the list of subscribers.
func (this *service) postPublish(msg *message.PublishMessage) (err error) {
	//   if msg.Retain() {
	//     if err = this.topicsMgr.Retain(msg); err != nil {
	//       Log.Errorc(func() string{ return fmt.Sprintf("(%s) Error retaining message: %v", this.cid(), err)})
	//     }
	//   }

	//   var subs []interface{}
	topic := string(msg.Topic())

	if !IsOnline(topic) {
		Log.Debugc(func() string {
			return fmt.Sprintf("(%s) this client is offline, send %d to offline queue.", this.cid(), msg.PacketId())
		})
		OfflineTopicQueueProcessor <- msg
		return nil
	}

	subs := _get_temp_subs()
	defer _return_temp_subs(subs)

	err = this.topicsMgr.Subscribers(msg.Topic(), msg.QoS(), &subs, nil)
	if err != nil {
		Log.Errorc(func() string {
			return fmt.Sprintf("(%s) Error retrieving subscribers list: %v", this.cid(), err)
		})
		return err
	}

	//   Log.Errorc(func() string{ return fmt.Sprintf("(%s) Publishing to topic %q and %d subscribers", this.cid(), string(msg.Topic()), len(this.subs))})
	//   fmt.Printf("value: %v\n", config.GetModel())
	//   done := make(chan bool)
	pending_status := NewPendingStatus(topic, msg)
	pkt_id := msg.PacketId()
	PendingQueue[pkt_id] = pending_status

	go this.handlePendingMessage(msg, pending_status)

	for _, s := range subs {
		if s != nil {
			fn, ok := s.(*OnPublishFunc)
			if !ok {
				Log.Errorc(func() string {
					return fmt.Sprintf("Invalid onPublish Function: %T", s)
				})
				return fmt.Errorf("Invalid onPublish Function")
			} else {
				(*fn)(msg)
				//         Log.Errorc(func() string{ return fmt.Sprintf("OfflineTopicQueue[%s]: %v, len is: %d\n", msg.Topic(), OfflineTopicQueue[string(msg.Topic())], len(OfflineTopicQueue[string(msg.Topic())]))})
			}
		}
	}

	return nil
}

func (this *memTopics) Retain(msg *message.PublishMessage) error {
	this.rmu.Lock()
	defer this.rmu.Unlock()

	// So apparently, at least according to the MQTT Conformance/Interoperability
	// Testing, that a payload of 0 means delete the retain message.
	// https://eclipse.org/paho/clients/testing/
	if len(msg.Payload()) == 0 {
		return this.rroot.rremove(msg.Topic())
	}

	return this.rroot.rinsert(msg.Topic(), msg)
}

func (this *service) retryPublish(msg *message.PublishMessage) (err error) {
	//   if msg.Retain() {
	//     if err = this.topicsMgr.Retain(msg); err != nil {
	//       Log.Errorc(func() string{ return fmt.Sprintf("(%s) Error retaining message: %v", this.cid(), err)})
	//     }
	//   }

	//   var subs []interface{}
	topic := string(msg.Topic())

	subs := _get_temp_subs()
	defer _return_temp_subs(subs)

	err = this.topicsMgr.Subscribers(msg.Topic(), msg.QoS(), &subs, nil)
	if err != nil {
		Log.Errorc(func() string {
			return fmt.Sprintf("(%s) Error retrieving subscribers list: %v", this.cid(), err)
		})
		return err
	}

	pending_status := NewPendingStatus(topic, msg)
	pkt_id := msg.PacketId()
	PendingQueue[pkt_id] = pending_status

	for _, s := range subs {
		if s != nil {
			fn, ok := s.(*OnPublishFunc)
			if !ok {
				Log.Errorc(func() string {
					return fmt.Sprintf("Invalid onPublish Function: %T", s)
				})
				return fmt.Errorf("Invalid onPublish Function")
			} else {
				(*fn)(msg)
			}
		}
	}

	return nil
}

// 预投递publish类型的消息，如果是特殊频道特殊处理，否则正常处理
func (this *service) preDispatchPublish(msg *message.PublishMessage) (err error) {
	switch string(msg.Topic()) {
	case BroadCastChannel:
		go OnGroupPublish(msg, this)
	case SendChannel:
		go this.onReceiveBadge(msg)
	case ApnPushChannel:
		go onAPNsPush(msg, this)
	case ApnInvalidTokensChannel:
		go getInvalidApnTokens(this)
	case OnlineStatusChannel:
		go this.checkOnlineStatus(msg)
	default:
		msg.SetPacketId(getNextPktId())
		Log.Infoc(func() string {
			return fmt.Sprintf("(%s) process private message.pkt_id: %d, payload size: %d", this.cid(), msg.PacketId(), len(msg.Payload()))
		})
		go this.postPublish(msg)
	}
	return
}