RPC with inline client

[vitalvas]

Hello,

I'm trying to use a library to implement RPC (client-server architecture, mqtt is used as a transport instead of http).
I encountered the following problem - the "server.Publish" function does not have the ability to set Properties.

An example of what I need with paho.golang:

requestID := uuid.New().String()

publish := &paho.Publish{
  Topic: "agent/myagent/request",
  Payload: []byte("{'name':'test'}"),
  Properties: &paho.PublishProperties{
    ContentType: "application/json",
    CorrelationData: []byte(requestID),
    ResponseTopic: fmt.Sprintf("agent/myagent/response/%s", requestID),
  },
}

[thedevop]

You can use server.InjectPacket to have full control over the packet properties. In fact, server.Publish just creates the packet and calls InjectPacket.

server/server.go

Lines 753 to 768 in 830de14

	func (s *Server) Publish(topic string, payload []byte, retain bool, qos byte) error {
	if !s.Options.InlineClient {
	return ErrInlineClientNotEnabled
	}
	return s.InjectPacket(s.inlineClient, packets.Packet{
	FixedHeader: packets.FixedHeader{
	Type: packets.Publish,
	Qos: qos,
	Retain: retain,
	},
	TopicName: topic,
	Payload: payload,
	PacketID: uint16(qos), // we never process the inbound qos, but we need a packet id for validity checks.
	})
	}

[vitalvas]

Yes, but s.inlineClient is a private variable. I don't want to implement a custom client for this.

Maybe add a new publish function like it is implemented in paho.golang?

[thedevop]

You do not need to use that inlineClient to publish. In fact, prior to introduction of inlineClient for subscription, a new inlineClient is created for every call to Publish.

	cl := s.NewClient(nil, "local", "inline", true)

	return s.InjectPacket(cl, packets.Packet{

[vitalvas]

My suggestion is to do something like this:

type PublishRequest struct {
        Retain     bool
        Qos        byte
	Topic      string
	Payload    []byte
	Properties packets.Properties
}

func (s *Server) PublishV2(request *PublishRequest) error {
	if !s.Options.InlineClient {
		return ErrInlineClientNotEnabled
	}

	return s.InjectPacket(s.inlineClient, packets.Packet{
		FixedHeader: packets.FixedHeader{
			Type:   packets.Publish,
			Retain: request.Retain,
			Qos:    request.Qos,
		},
		TopicName:  request.Topic,
		Payload:    request.Payload,
		PacketID:   uint16(request.Qos),
		Properties: request.Properties,
	})
}

[TheCount]

@vitalvas Given @thedevop's explanation, I don't think we need a PublishV2. However, some additional documentation or even an example might be helpful. Along the lines:

• Publish is a convenience function, use InjectPacket for more complex stuff … (this is actually already in the docs),
• NewClient accepts nil connections for inline clients …
• InjectPackage accepts inline clients, see [NewClient] …