or run

tessl search
Log in

Version

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
golangpkg:golang/github.com/Azure/azure-sdk-for-go/sdk/messaging/azservicebus@v1.10.0

docs

client.mderrors.mdindex.mdmessaging.mdreceiver.mdsender.mdsessions.md
tile.json

tessl/golang-github-com--azure--azure-sdk-for-go--sdk--messaging--azservicebus

tessl install tessl/golang-github-com--azure--azure-sdk-for-go--sdk--messaging--azservicebus@1.10.1

Client module for Azure Service Bus, a highly reliable cloud messaging service providing real-time and fault-tolerant communication between distributed senders and receivers.

sender.mddocs/

Sending Messages

The Sender type provides methods for sending messages to queues or topics, including support for batching, scheduling, and message cancellation.

Capabilities

Send Single Message

func (s *Sender) SendMessage(ctx context.Context, message *Message, options *SendMessageOptions) error

Sends a single message to the queue or topic. Returns ErrMessageTooLarge if the message exceeds the maximum link size, or an *Error with specific error code for other failures.

Example:

err := sender.SendMessage(context.Background(), &azservicebus.Message{
    Body:    []byte("Hello, Service Bus!"),
    Subject: to.Ptr("Greeting"),
}, nil)
if err != nil {
    panic(err)
}

Send AMQP Annotated Message

func (s *Sender) SendAMQPAnnotatedMessage(ctx context.Context, message *AMQPAnnotatedMessage, options *SendAMQPAnnotatedMessageOptions) error

Sends an AMQP annotated message for advanced use cases requiring full AMQP protocol control. Returns ErrMessageTooLarge if the message exceeds the maximum link size, or an *Error for other failures.

Example:

amqpMsg := &azservicebus.AMQPAnnotatedMessage{
    Body: azservicebus.AMQPAnnotatedMessageBody{
        Data: [][]byte{[]byte("payload")},
    },
    MessageAnnotations: map[any]any{
        "x-custom-annotation": "value",
    },
}

err := sender.SendAMQPAnnotatedMessage(context.Background(), amqpMsg, nil)

Create Message Batch

func (s *Sender) NewMessageBatch(ctx context.Context, options *MessageBatchOptions) (*MessageBatch, error)

Creates a new message batch sized for the Service Bus namespace's maximum message size. Use batches for efficient multi-message sending. Returns an *Error if the operation fails.

Example:

batch, err := sender.NewMessageBatch(context.Background(), nil)
if err != nil {
    panic(err)
}

Send Message Batch

func (s *Sender) SendMessageBatch(ctx context.Context, batch *MessageBatch, options *SendMessageBatchOptions) error

Sends a message batch created with NewMessageBatch. Returns an *Error if the operation fails.

Example:

batch, _ := sender.NewMessageBatch(ctx, nil)

for _, msg := range messages {
    err := batch.AddMessage(msg, nil)
    if errors.Is(err, azservicebus.ErrMessageTooLarge) {
        // Batch full, send it
        sender.SendMessageBatch(ctx, batch, nil)

        // Create new batch and retry
        batch, _ = sender.NewMessageBatch(ctx, nil)
        batch.AddMessage(msg, nil)
    }
}

// Send remaining messages
if batch.NumMessages() > 0 {
    sender.SendMessageBatch(ctx, batch, nil)
}

Schedule Messages

func (s *Sender) ScheduleMessages(ctx context.Context, messages []*Message, scheduledEnqueueTime time.Time, options *ScheduleMessagesOptions) ([]int64, error)

Schedules messages for future delivery. Returns sequence numbers for the scheduled messages, which can be used to cancel them before delivery. Messages that haven't been delivered can be cancelled using CancelScheduledMessages. Returns an *Error if the operation fails.

Example:

futureTime := time.Now().Add(time.Hour * 2)

sequenceNumbers, err := sender.ScheduleMessages(
    context.Background(),
    []*azservicebus.Message{
        {Body: []byte("Scheduled message 1")},
        {Body: []byte("Scheduled message 2")},
    },
    futureTime,
    nil,
)
if err != nil {
    panic(err)
}

fmt.Printf("Scheduled messages with sequence numbers: %v\n", sequenceNumbers)

Schedule AMQP Annotated Messages

func (s *Sender) ScheduleAMQPAnnotatedMessages(ctx context.Context, messages []*AMQPAnnotatedMessage, scheduledEnqueueTime time.Time, options *ScheduleAMQPAnnotatedMessagesOptions) ([]int64, error)

Schedules AMQP annotated messages for future delivery. Returns sequence numbers that can be used to cancel the scheduled messages. Returns an *Error if the operation fails.

Cancel Scheduled Messages

func (s *Sender) CancelScheduledMessages(ctx context.Context, sequenceNumbers []int64, options *CancelScheduledMessagesOptions) error

Cancels multiple scheduled messages using their sequence numbers (obtained from ScheduleMessages or ScheduleAMQPAnnotatedMessages). Only works for messages that haven't been delivered yet. Returns an *Error if the operation fails.

Example:

// Schedule messages
sequenceNumbers, _ := sender.ScheduleMessages(ctx, messages, futureTime, nil)

// Cancel them before delivery
err := sender.CancelScheduledMessages(context.Background(), sequenceNumbers, nil)
if err != nil {
    panic(err)
}

Close Sender

func (s *Sender) Close(ctx context.Context) error

Permanently closes the sender and releases resources. Always call Close when done with the sender.

Example:

sender, _ := client.NewSender("myqueue", nil)
defer sender.Close(context.Background())

Types

Sender

type Sender struct {
    // ... unexported fields
}

Sender is used to send messages and schedule them for future delivery.

SendMessageOptions

type SendMessageOptions struct {
    // Currently empty, reserved for future expansion
}

Options for sending a single message.

SendAMQPAnnotatedMessageOptions

type SendAMQPAnnotatedMessageOptions struct {
    // Currently empty, reserved for future expansion
}

Options for sending an AMQP annotated message.

SendMessageBatchOptions

type SendMessageBatchOptions struct {
    // Currently empty, reserved for future expansion
}

Options for sending a message batch.

ScheduleMessagesOptions

type ScheduleMessagesOptions struct {
    // Currently empty, reserved for future expansion
}

Options for scheduling messages.

ScheduleAMQPAnnotatedMessagesOptions

type ScheduleAMQPAnnotatedMessagesOptions struct {
    // Currently empty, reserved for future expansion
}

Options for scheduling AMQP annotated messages.

CancelScheduledMessagesOptions

type CancelScheduledMessagesOptions struct {
    // Currently empty, reserved for future expansion
}

Options for cancelling scheduled messages.