MQTT paho - no error when failed to publish message

I am using the paho.mqtt.golang library to connect to a broker and publish message.

It's working fine except that I don't have errors when the publish failed.

The test I'm doing is as follow:

• I start the broker
• I run my code to connect to the broker. After connection the code waits for an input to proceed to publish
• I kill the broker
• I press enter to proceed to publish the message

I would expect an error with the token returned by the publish function if token.Error() != nil {...} but I got none.

Here is the code of the publish function:

func (handle Handler) Pub(ctx context.Context, topic, payload string, qos int, retained bool) error {
	token := handle.client.Publish(topic, byte(qos), retained, payload)
	go func(ctx context.Context) {
		log := logger.NewLogFromCtx(ctx)
		log.Debug("waiting for transaction to complete...")
		_ = token.Done()
		log.Debug("transaction Done!", zap.Any("token.Error()", token.Error()))
		if token.Error() != nil {
			log.Error("failed to publish MQTT message", zap.Error(token.Error()))
		}
	}(ctx)
	log := logger.NewLogFromCtx(ctx)
	log.Debug("Msg sent !")
	return nil
}

And here is the log:

Thu 27 May 17:40:25 CEST        INFO    logger/logging.go:32    logger initialized in development mode
[DEBUG][client]   Connect()
[DEBUG][store]    memorystore initialized
[DEBUG][client]   about to write new connect msg
[DEBUG][client]   socket connected to broker
[DEBUG][client]   Using MQTT 3.1.1 protocol
[DEBUG][net]      connect started
[DEBUG][net]      received connack
[DEBUG][client]   startCommsWorkers called
[DEBUG][client]   client is connected/reconnected
[DEBUG][net]      incoming started
[DEBUG][net]      startIncomingComms started
[DEBUG][net]      outgoing started
[DEBUG][net]      startComms started
[DEBUG][client]   startCommsWorkers done
[WARN][store]    memorystore wiped
[DEBUG][client]   exit startClient
Thu 27 May 17:40:25 CEST        INFO    mqtt_/client.go:68      successfully connected to MQTT broker   {"url": "tcp://127.0.0.1:1883", "in": "41.843622ms"}
press enter to publish...

At this point I'm connected to the broker, code is waiting for an input; I kill the broker:

[ERROR][client]   Connect comms goroutine - error triggered EOF
[DEBUG][client]   internalConnLost called
[DEBUG][client]   stopCommsWorkers called
[DEBUG][router]   matchAndDispatch exiting
[DEBUG][pinger]   keepalive stopped
[DEBUG][client]   startCommsWorkers output redirector finished
[DEBUG][net]      outgoing waiting for an outbound message
[DEBUG][net]      outgoing waiting for an outbound message
[DEBUG][net]      outgoing comms stopping
[DEBUG][net]      startComms closing outError
[DEBUG][client]   incoming comms goroutine done
[DEBUG][client]   stopCommsWorkers waiting for workers
[DEBUG][client]   stopCommsWorkers waiting for comms
[DEBUG][client]   stopCommsWorkers done
[DEBUG][client]   internalConnLost waiting on workers
[DEBUG][client]   internalConnLost workers stopped
[DEBUG][client]   internalConnLost complete
[DEBUG]Connection lost: EOF
[DEBUG][client]   enter reconnect
[DEBUG][client]   about to write new connect msg
[DEBUG][client]   socket connected to broker
[DEBUG][client]   Using MQTT 3.1.1 protocol
[DEBUG][net]      connect started
[ERROR][net]      connect got error EOF
[ERROR][client]   Connecting to tcp://127.0.0.1:1883 CONNACK was not CONN_ACCEPTED, but rather Connection Error
[DEBUG][client]   Reconnect failed, sleeping for 1 seconds: network Error : EOF

The connection is indeed lost. I press enter to proceed to publish:

[DEBUG][client]   enter Publish
[DEBUG][client]   storing publish message (reconnecting), topic: just/for/test
Thu 27 May 17:40:42 CEST        DEBUG   mqtt_/client.go:84      Msg sent !
Thu 27 May 17:40:42 CEST        DEBUG   mqtt_/client.go:76      waiting for transaction to complete...
Thu 27 May 17:40:42 CEST        DEBUG   mqtt_/client.go:78      transaction Done!       {"token.Error()": null}

There is nothing in the token.Error(). How can I check if the publish was successful ?

Here is my full code if you need more details.

Connect and publish to the broker:

type Handler struct {
	client MQTT.Client
	conf   config.Configuration
}

func InitMQTT() {
	MQTT.DEBUG = lg.New(os.Stdout, "[DEBUG]", 0)
	MQTT.WARN = lg.New(os.Stdout, "[WARN]", 0)
	MQTT.CRITICAL = lg.New(os.Stdout, "[CRIT]", 0)
	MQTT.ERROR = lg.New(os.Stdout, "[ERROR]", 0)
}

func NewClient(ctx context.Context, conf config.Configuration) (Handler, error) {
	start := time.Now()
	log := logger.NewLogFromCtx(ctx)
	brokerUrl := fmt.Sprintf("tcp://%s:%s", conf.GW_MQTT_BROKER_HOST_IP, conf.GW_MQTT_BROKER_PORT)
	hostname, _ := os.Hostname()
	clientId := hostname + strconv.Itoa(time.Now().Second())
	connOpts := MQTT.NewClientOptions()
	connOpts.AddBroker(brokerUrl)
	connOpts.SetClientID(clientId)
	connOpts.SetCleanSession(true)
	handler := Handler{conf: conf}
	handler.client = MQTT.NewClient(connOpts)
	if token := handler.client.Connect(); token.Wait() && token.Error() != nil {
		log.Error("failed to connect to MQTT broker", zap.Error(token.Error()))
		return Handler{}, token.Error()
	}
	log.Info("successfully connected to MQTT broker", zap.String("url", brokerUrl), zap.Duration("in", time.Since(start)))
	return handler, nil
}

func (handle Handler) Pub(ctx context.Context, topic, payload string, qos int, retained bool) error {
	token := handle.client.Publish(topic, byte(qos), retained, payload)
	go func(ctx context.Context) {
		log := logger.NewLogFromCtx(ctx)
		log.Debug("waiting for transaction to complete...")
		_ = token.Done()
		log.Debug("transaction Done!", zap.Any("token.Error", token.Error()))
		if token.Error() != nil {
			log.Error("failed to publish MQTT message", zap.Error(token.Error()))
		}
	}(ctx)
	log := logger.NewLogFromCtx(ctx)
	log.Debug("Msg sent !")
	return nil
}

And here is the main:

func main() {
	conf := config.GetConfig()
	err := logger.SetupLogging(conf.IS_DEV_ENV)
	if err != nil {
		panic(err)
	}
	ctx := context.Background()
	log := logger.NewLogFromCtx(ctx)

	mqtt.InitMQTT()
	mqttClient, _ := mqtt.NewClient(ctx, conf)

	reader := bufio.NewReader(os.Stdin)
	fmt.Print("press enter to publish...")
	text, _ := reader.ReadString('\n')
	mqttClient.Pub(ctx, "just/for/test", "test", 2, false)
}

From the docs:

// Wait will wait indefinitely for the Token to complete, ie the Publish
// to be sent and confirmed receipt from the broker.
Wait() bool

// Done is provided for use in select statements. Simple use cases may
// use Wait or WaitTimeout.
Done() <-chan struct{}

So _ = token.Done() really does nothing; the simplest wait to wait is to use token.Wait(). If you want to use token.Done() you need to wait on the channel returned; e.g. <- token.Done(). The reason that Done() exists is to make things simpler when you are waiting on more that one event (e.g. waiting for a context OR an mqtt operation to complete).