PublishWithContext() does not warn on max message size overruns

[xf0e]

Describe the bug
Can't catch error at publishing message with max_message_size defined in RabbitMq. At publishing messages larger than configured RabbitMq max_message_size PublishWithContext() doesn't return any error. Albeit the message gets discarded in RabbitMq.

To Reproduce
Steps to reproduce the behavior:

1. Just compiled the example from amqp091-go and modified it to put a large file in the body of a message (see code below)
2. Run it
3. Program terminates without of error
4. Logs of RabbitMq contains now 2024-10-26 21:30:08.557637+02:00 [error] <0.4535.0> operation basic.publish caused a channel exception precondition_failed: message size 169150808 is larger than configured max size 134217728

Actual code:

package main

import (
	"context"
	amqp "github.com/rabbitmq/amqp091-go"
	"log"
	"os"
	"time"
	"unsafe"
)

func main() {
	// Connects opens an AMQP connection from the credentials in the URL.
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	if err != nil {
		log.Fatalf("connection.open: %s", err)
	}

	// This waits for a server acknowledgment which means the sockets will have
	// flushed all outbound publishings prior to returning.  It's important to
	// block on Close to not lose any publishings.
	defer conn.Close()

	c, err := conn.Channel()
	if err != nil {
		log.Fatalf("channel.open: %s", err)
	}

	// We declare our topology on both the publisher and consumer to ensure they
	// are the same.  This is part of AMQP being a programmable messaging model.
	//
	// See the Channel.Consume example for the complimentary declare.
	err = c.ExchangeDeclare("logs", "topic", true, false, false, false, nil)
	if err != nil {
		log.Fatalf("exchange.declare: %v", err)
	}

	// Prepare this message to be persistent.  Your publishing requirements may
	// be different.
	file, _ := os.ReadFile("large_file")

	msg := amqp.Publishing{
		DeliveryMode: amqp.Persistent,
		Timestamp:    time.Now(),
		ContentType:  "text/plain",
		Body:         []byte(file),
	}

	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	// This is not a mandatory delivery, so it will be dropped if there are no
	// queues bound to the logs exchange.
	err = c.PublishWithContext(ctx, "logs", "info", false, false, msg)
	if err != nil {
		// Since publish is asynchronous this can happen if the network connection
		// is reset or if the server has run out of resources.
		log.Fatalf("basic.publish: %v", err)
	}
}

[Zerpet]

This is expected behaviour. The function PublishWithContext() returns an error if, for any reason, fails to send the basic.publish frame. The client library does not have any information about rabbitmq server configuration, and it can't validate that a message size is lower than the configured max_message_size in the server.

As you can read in the error message, the channel is closed with an exception. In order to receive this error, you have to register a channel listener with Channel.NotifyClose(). If you want to observe PublishWithContext() returning an error, you can send a few more messages using the same channel. After the server closes the channel, you will receive an error directly from PublishWithContext().