diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/MigrationGuide.md b/sdk/servicebus/Azure.Messaging.ServiceBus/MigrationGuide.md index 9192ce33fc50..7099c6f4140e 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/MigrationGuide.md +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/MigrationGuide.md @@ -63,27 +63,27 @@ In the interest of simplifying the API surface we've made a single top level cli ### Sending messages -The v4 client allowed for sending a single message or a list of messages, which had the potential to fail unexpectedly if the maximum allowable size was exceeded. v7 aims to prevent this by asking that you first create a batch of messages using `CreateBatchAsync` and then attempt to add messages to that using `TryAdd()`. If the batch accepts a message, you can be confident that it will not violate size constraints when calling Send to send the batch. v7 still allows sending a single message. +The v4 client allowed for sending a single message or a list of messages, which had the potential to fail unexpectedly if the maximum allowable size was exceeded. v7 aims to prevent this by allowing you to first create a batch of messages using `CreateMessageBatchAsync` and then attempt to add messages to that using `TryAddMessage()`. If the batch accepts a message, you can be confident that it will not violate size constraints when calling Send to send the batch. v7 still allows sending a single message and sending an `IEnumerable` of messages, though using the `IEnumerable` overload has the same risks as V4. | In v4 | Equivalent in v7 | Sample | |------------------------------------------------|------------------------------------------------------------------|--------| -| `QueueClient.SendAsync(Message)` or `MessageSender.SendAsync(Message)` | `ServiceBusSender.SendAsync(ServiceBusMessage)` | [Send a message](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample01_HelloWorld.md#sending-and-receiving-a-message) | -| `QueueClient.SendAsync(IList)` or `MessageSender.SendAsync(IList)` | `messageBatch = ServiceBusSender.CreateBatchAsync()` `messageBatch.TryAdd(ServiceBusMessage)` `ServiceBusSender.SendAsync(messageBatch)` | [Send a batch of messages](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample01_HelloWorld.md#sending-and-receiving-a-batch-of-messages) | +| `QueueClient.SendAsync(Message)` or `MessageSender.SendAsync(Message)` | `ServiceBusSender.SendMessageAsync(ServiceBusMessage)` | [Send a message](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample01_HelloWorld.md#sending-and-receiving-a-message) | +| `QueueClient.SendAsync(IList)` or `MessageSender.SendAsync(IList)` | `messageBatch = ServiceBusSender.CreateMessageBatchAsync()` `messageBatch.TryAddMessage(ServiceBusMessage)` `ServiceBusSender.SendMessagesAsync(messageBatch)` or `ServiceBusSender.SendMessagesAsync(IEnumerable)` | [Send a batch of messages](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample01_HelloWorld.md#sending-and-receiving-a-batch-of-messages) | ### Receiving messages | In v4 | Equivalent in v7 | Sample | |------------------------------------------------|------------------------------------------------------------------|--------| -| `MessageReceiver.ReceiveAsync()` | `ServiceBusReceiver.ReceiveAsync()` | [Receive a message](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample01_HelloWorld.md#sending-and-receiving-a-message) | -| `MessageReceiver.ReceiveAsync()` | `ServiceBusReceiver.ReceiveBatchAsync()` | [Receive a batch of messages](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample01_HelloWorld.md#sending-and-receiving-a-batch-of-messages) | +| `MessageReceiver.ReceiveAsync()` | `ServiceBusReceiver.ReceiveMessageAsync()` | [Receive a message](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample01_HelloWorld.md#sending-and-receiving-a-message) | +| `MessageReceiver.ReceiveAsync()` | `ServiceBusReceiver.ReceiveMessagesAsync()` | [Receive a batch of messages](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample01_HelloWorld.md#sending-and-receiving-a-batch-of-messages) | | `QueueClient.RegisterMessageHandler()` or `MessageReceiver.RegisterMessageHandler()` | `ServiceBusProcessor.ProcessMessageAsync += MessageHandler` `ServiceBusProcessor.ProcessErrorAsync += ErrorHandler` `ServiceBusProcessor.StartProcessingAsync()` | [Receive messages using processor](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample04_Processor.md) | ### Working with sessions | In v4 | Equivalent in v7 | Sample | |------------------------------------------------|------------------------------------------------------------------|--------| -| `MessageSender.SendAsync(new Message{SessionId = "sessionId"})` | `ServiceBusSender.SendAsync(new ServiceBusMessage{SessionId = "sessionId"})` | [Send a message to session](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample03_SendReceiveSessions.md) | -| `IMessageSession.ReceiveAsync()` | `ServiceBusSessionReceiver.ReceiveAsync()` | [Receive a message from session](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample03_SendReceiveSessions.md) | +| `MessageSender.SendAsync(new Message{SessionId = "sessionId"})` | `ServiceBusSender.SendMessageAsync(new ServiceBusMessage{SessionId = "sessionId"})` | [Send a message to session](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample03_SendReceiveSessions.md) | +| `IMessageSession.ReceiveAsync()` | `ServiceBusSessionReceiver.ReceiveMessageAsync()` | [Receive a message from session](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample03_SendReceiveSessions.md) | | `IMessageSession.RegisterMessageHandler()` | `ServiceBusSessionProcessor.ProcessMessageAsync += MessageHandler` `ServiceBusSessionProcessor.ProcessErrorAsync += ErrorHandler` `ServiceBusSessionProcessor.StartProcessingAsync()` | [Receive messages from session processor](https://github.com/Azure/azure-sdk-for-net/blob/master/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample05_SessionProcessor.md) | ## Migration samples @@ -92,7 +92,7 @@ The v4 client allowed for sending a single message or a list of messages, which In v4, `QueueClient`/`MessageSender`/`MessageReceiver` would be created directly, after which user would call `SendAsync()` method via `QueueClient`/`MessageSender` to send a message and `ReceiveAsync()` method via `MessageReceiver` to receive a message. -In v7, user would initialize the `ServiceBusClient` and call `CreateSender()` method to create a `ServiceBusSender` and `CreateReceiver()` method to create a `ServiceBusReceiver`. To send a message, user would call `SendAsync()` via `ServiceBusSender` and to receive a message, user would call `ReceiveAsync()` via `ServiceBusReceiver`. +In v7, user would initialize the `ServiceBusClient` and call `CreateSender()` method to create a `ServiceBusSender` and `CreateReceiver()` method to create a `ServiceBusReceiver`. To send a message, user would call `SendMessageAsync()` via `ServiceBusSender` and to receive a message, user would call `ReceiveMessageAsync()` via `ServiceBusReceiver`. In v4: @@ -140,13 +140,13 @@ ServiceBusSender sender = client.CreateSender(queueName); ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message -await sender.SendAsync(message); +await sender.SendMessageAsync(message); // create a receiver that we can use to receive the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties -ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // get the message body as a string string body = receivedMessage.Body.ToString(); @@ -160,15 +160,15 @@ In v4, `QueueClient`/`MessageSender`/`MessageReceiver` would be created directly In v7, user would initialize the `ServiceBusClient` and call `CreateSender()` method to create a `ServiceBusSender` and `CreateReceiver()` method to create a `ServiceBusReceiver`. There are two ways of sending several messages at once. -The first way uses the `SendAsync`overload that accepts an IEnumerable of `ServiceBusMessage`. With this method, we will +The first way uses the `SendMessagesAsync`overload that accepts an IEnumerable of `ServiceBusMessage`. With this method, we will attempt to fit all of the supplied messages in a single message batch that we will send to the service. If the messages are too large to fit in a single batch, the operation will throw an exception. The second way of doing this is using safe-batching. With safe-batching, you can create a `ServiceBusMessageBatch` object, -which will allow you to attempt to add messages one at a time to the batch using the `TryAdd` method. If the message cannot -fit in the batch, `TryAdd` will return false. If the `ServiceBusMessageBatch` accepts a message, user can be confident that -it will not violate size constraints when calling `SendAsync()` via `ServiceBusSender`. To receive a batch of messages, -user would call `ReceiveBatchAsync()` method via `ServiceBusReceiver`. +which will allow you to attempt to add messages one at a time to the batch using the `TryAddMessage` method. If the message cannot +fit in the batch, `TryAddMessage` will return false. If the `ServiceBusMessageBatch` accepts a message, user can be confident that +it will not violate size constraints when calling `SendMessagesAsync()` via `ServiceBusSender`. To receive a set of messages, a +user would call `ReceiveMessagesAsync()` method via `ServiceBusReceiver`. In v4: @@ -223,18 +223,18 @@ IList messages = new List(); messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); // send the messages -await sender.SendAsync(messages); +await sender.SendMessagesAsync(messages); ``` Or using the safe-batching feature: ```C# Snippet:ServiceBusSendAndReceiveSafeBatch -ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync(); -messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); -messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); +ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync(); +messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); +messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); // send the message batch -await sender.SendAsync(messageBatch); +await sender.SendMessagesAsync(messageBatch); ``` And to receive a batch: @@ -243,7 +243,7 @@ And to receive a batch: ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties -IList receivedMessages = await receiver.ReceiveBatchAsync(maxMessages: 2); +IList receivedMessages = await receiver.ReceiveMessagesAsync(maxMessages: 2); foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages) { diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/README.md b/sdk/servicebus/Azure.Messaging.ServiceBus/README.md index 751fec3dfc73..4553a094dc68 100755 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/README.md +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/README.md @@ -116,13 +116,13 @@ ServiceBusSender sender = client.CreateSender(queueName); ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message -await sender.SendAsync(message); +await sender.SendMessageAsync(message); // create a receiver that we can use to receive the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties -ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // get the message body as a string string body = receivedMessage.Body.ToString(); @@ -131,7 +131,7 @@ Console.WriteLine(body); ### Send and receive a batch of messages -There are two ways of sending several messages at once. The first way uses the `SendAsync` +There are two ways of sending several messages at once. The first way uses the `SendMessagesAsync` overload that accepts an IEnumerable of `ServiceBusMessage`. With this method, we will attempt to fit all of the supplied messages in a single message batch that we will send to the service. If the messages are too large to fit in a single batch, the operation will throw an exception. @@ -141,19 +141,19 @@ IList messages = new List(); messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); // send the messages -await sender.SendAsync(messages); +await sender.SendMessagesAsync(messages); ``` The second way of doing this is using safe-batching. With safe-batching, you can create a `ServiceBusMessageBatch` object, which will allow you to attempt to add messages one at a time to the batch using the `TryAdd` method. If the message cannot fit in the batch, `TryAdd` will return false. ```C# Snippet:ServiceBusSendAndReceiveSafeBatch -ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync(); -messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); -messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); +ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync(); +messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); +messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); // send the message batch -await sender.SendAsync(messageBatch); +await sender.SendMessagesAsync(messageBatch); ``` ### Complete a message @@ -173,16 +173,16 @@ ServiceBusSender sender = client.CreateSender(queueName); ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message -await sender.SendAsync(message); +await sender.SendMessageAsync(message); // create a receiver that we can use to receive and settle the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties -ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // complete the message, thereby deleting it from the service -await receiver.CompleteAsync(receivedMessage); +await receiver.CompleteMessageAsync(receivedMessage); ``` ### Abandon a message @@ -190,24 +190,24 @@ await receiver.CompleteAsync(receivedMessage); Abandoning a message releases our receiver's lock, which allows the message to be received by this or other receivers. ```C# Snippet:ServiceBusAbandonMessage -ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // abandon the message, thereby releasing the lock and allowing it to be received again by this or other receivers -await receiver.AbandonAsync(receivedMessage); +await receiver.AbandonMessageAsync(receivedMessage); ``` ### Defer a message -Deferring a message will prevent it from being received again using the `ReceiveAsync` or `ReceiveBatchAsync` methods. -Instead, there are separate methods, `ReceiveDeferredMessageAsync` and `ReceiveDeferredMessageBatchAsync` +Deferring a message will prevent it from being received again using the `ReceiveMessageAsync` or `ReceiveMessagesAsync` methods. +Instead, there are separate methods, `ReceiveDeferredMessageAsync` and `ReceiveDeferredMessagesAsync` for receiving deferred messages. ```C# Snippet:ServiceBusDeferMessage -ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // defer the message, thereby preventing the message from being received again without using // the received deferred message API. -await receiver.DeferAsync(receivedMessage); +await receiver.DeferMessageAsync(receivedMessage); // receive the deferred message by specifying the service set sequence number of the original // received message @@ -221,14 +221,14 @@ by the service after they have been received a certain number of times. Applicat their requirements. When a message is dead lettered it is actually moved to a subqueue of the original queue. ```C# Snippet:ServiceBusDeadLetterMessage -ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // deadletter the message, thereby preventing the message from being received again without receiving from the dead letter queue. -await receiver.DeadLetterAsync(receivedMessage); +await receiver.DeadLetterMessageAsync(receivedMessage); // receive the dead lettered message with receiver scoped to the dead letter queue. ServiceBusReceiver dlqReceiver = client.CreateDeadLetterReceiver(queueName); -ServiceBusReceivedMessage dlqMessage = await dlqReceiver.ReceiveAsync(); +ServiceBusReceivedMessage dlqMessage = await dlqReceiver.ReceiveMessageAsync(); ``` ### Using the Processor @@ -249,12 +249,12 @@ await using var client = new ServiceBusClient(connectionString); ServiceBusSender sender = client.CreateSender(queueName); // create a message batch that we can send -ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync(); -messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); -messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); +ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync(); +messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); +messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); // send the message batch -await sender.SendAsync(messageBatch); +await sender.SendMessagesAsync(messageBatch); // get the options to use for configuring the processor var options = new ServiceBusProcessorOptions diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/api/Azure.Messaging.ServiceBus.netstandard2.0.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/api/Azure.Messaging.ServiceBus.netstandard2.0.cs index bdb3f5d5b0e9..2ea384f342ea 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/api/Azure.Messaging.ServiceBus.netstandard2.0.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/api/Azure.Messaging.ServiceBus.netstandard2.0.cs @@ -1,8 +1,8 @@ namespace Azure.Messaging.ServiceBus { - public partial class CreateBatchOptions + public partial class CreateMessageBatchOptions { - public CreateBatchOptions() { } + public CreateMessageBatchOptions() { } public long? MaxSizeInBytes { get { throw null; } set { } } [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] public override bool Equals(object obj) { throw null; } @@ -177,7 +177,7 @@ internal ServiceBusMessageBatch() { } public long MaxSizeInBytes { get { throw null; } } public long SizeInBytes { get { throw null; } } public void Dispose() { } - public bool TryAdd(Azure.Messaging.ServiceBus.ServiceBusMessage message) { throw null; } + public bool TryAddMessage(Azure.Messaging.ServiceBus.ServiceBusMessage message) { throw null; } } public partial class ServiceBusProcessor { @@ -255,29 +255,27 @@ protected ServiceBusReceiver() { } public bool IsDisposed { get { throw null; } } public int PrefetchCount { get { throw null; } } public Azure.Messaging.ServiceBus.ReceiveMode ReceiveMode { get { throw null; } } - public virtual System.Threading.Tasks.Task AbandonAsync(Azure.Messaging.ServiceBus.ServiceBusReceivedMessage message, System.Collections.Generic.IDictionary propertiesToModify = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task AbandonAsync(string lockToken, System.Collections.Generic.IDictionary propertiesToModify = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task CompleteAsync(Azure.Messaging.ServiceBus.ServiceBusReceivedMessage message, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task CompleteAsync(string lockToken, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task DeadLetterAsync(Azure.Messaging.ServiceBus.ServiceBusReceivedMessage message, System.Collections.Generic.IDictionary propertiesToModify = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task DeadLetterAsync(Azure.Messaging.ServiceBus.ServiceBusReceivedMessage message, string deadLetterReason, string deadLetterErrorDescription = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task DeadLetterAsync(string lockToken, System.Collections.Generic.IDictionary propertiesToModify = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task DeadLetterAsync(string lockToken, string deadLetterReason, string deadLetterErrorDescription = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task DeferAsync(Azure.Messaging.ServiceBus.ServiceBusReceivedMessage message, System.Collections.Generic.IDictionary propertiesToModify = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task DeferAsync(string lockToken, System.Collections.Generic.IDictionary propertiesToModify = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task AbandonMessageAsync(Azure.Messaging.ServiceBus.ServiceBusReceivedMessage message, System.Collections.Generic.IDictionary propertiesToModify = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task AbandonMessageAsync(string lockToken, System.Collections.Generic.IDictionary propertiesToModify = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task CompleteMessageAsync(Azure.Messaging.ServiceBus.ServiceBusReceivedMessage message, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task CompleteMessageAsync(string lockToken, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task DeadLetterMessageAsync(Azure.Messaging.ServiceBus.ServiceBusReceivedMessage message, System.Collections.Generic.IDictionary propertiesToModify = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task DeadLetterMessageAsync(Azure.Messaging.ServiceBus.ServiceBusReceivedMessage message, string deadLetterReason, string deadLetterErrorDescription = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task DeadLetterMessageAsync(string lockToken, System.Collections.Generic.IDictionary propertiesToModify = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task DeadLetterMessageAsync(string lockToken, string deadLetterReason, string deadLetterErrorDescription = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task DeferMessageAsync(Azure.Messaging.ServiceBus.ServiceBusReceivedMessage message, System.Collections.Generic.IDictionary propertiesToModify = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task DeferMessageAsync(string lockToken, System.Collections.Generic.IDictionary propertiesToModify = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } public virtual System.Threading.Tasks.ValueTask DisposeAsync() { throw null; } [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] public override bool Equals(object obj) { throw null; } [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] public override int GetHashCode() { throw null; } - public virtual System.Threading.Tasks.Task PeekAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task PeekAtAsync(long sequenceNumber, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task> PeekBatchAsync(int maxMessages, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task> PeekBatchAtAsync(long sequenceNumber, int maxMessages, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task ReceiveAsync(System.TimeSpan? maxWaitTime = default(System.TimeSpan?), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task> ReceiveBatchAsync(int maxMessages, System.TimeSpan? maxWaitTime = default(System.TimeSpan?), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task PeekMessageAsync(long? fromSequenceNumber = default(long?), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task> PeekMessagesAsync(int maxMessages, long? fromSequenceNumber = default(long?), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } public virtual System.Threading.Tasks.Task ReceiveDeferredMessageAsync(long sequenceNumber, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task> ReceiveDeferredMessageBatchAsync(System.Collections.Generic.IEnumerable sequenceNumbers, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task> ReceiveDeferredMessagesAsync(System.Collections.Generic.IEnumerable sequenceNumbers, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task ReceiveMessageAsync(System.TimeSpan? maxWaitTime = default(System.TimeSpan?), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task> ReceiveMessagesAsync(int maxMessages, System.TimeSpan? maxWaitTime = default(System.TimeSpan?), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } public virtual System.Threading.Tasks.Task RenewMessageLockAsync(Azure.Messaging.ServiceBus.ServiceBusReceivedMessage message, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } public virtual System.Threading.Tasks.Task RenewMessageLockAsync(string lockToken, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] @@ -330,17 +328,19 @@ protected ServiceBusSender() { } public bool IsDisposed { get { throw null; } } public string ViaEntityPath { get { throw null; } } public virtual System.Threading.Tasks.Task CancelScheduledMessageAsync(long sequenceNumber, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.ValueTask CreateBatchAsync(Azure.Messaging.ServiceBus.CreateBatchOptions options, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.ValueTask CreateBatchAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task CancelScheduledMessagesAsync(System.Collections.Generic.IEnumerable sequenceNumbers, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.ValueTask CreateMessageBatchAsync(Azure.Messaging.ServiceBus.CreateMessageBatchOptions options, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.ValueTask CreateMessageBatchAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } public virtual System.Threading.Tasks.ValueTask DisposeAsync() { throw null; } [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] public override bool Equals(object obj) { throw null; } [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] public override int GetHashCode() { throw null; } public virtual System.Threading.Tasks.Task ScheduleMessageAsync(Azure.Messaging.ServiceBus.ServiceBusMessage message, System.DateTimeOffset scheduledEnqueueTime, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task SendAsync(Azure.Messaging.ServiceBus.ServiceBusMessage message, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task SendAsync(Azure.Messaging.ServiceBus.ServiceBusMessageBatch messageBatch, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } - public virtual System.Threading.Tasks.Task SendAsync(System.Collections.Generic.IEnumerable messages, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task ScheduleMessagesAsync(System.Collections.Generic.IEnumerable messages, System.DateTimeOffset scheduledEnqueueTime, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task SendMessageAsync(Azure.Messaging.ServiceBus.ServiceBusMessage message, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task SendMessagesAsync(Azure.Messaging.ServiceBus.ServiceBusMessageBatch messageBatch, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } + public virtual System.Threading.Tasks.Task SendMessagesAsync(System.Collections.Generic.IEnumerable messages, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; } [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] public override string ToString() { throw null; } } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample01_HelloWorld.md b/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample01_HelloWorld.md index 05fb96de2be6..a3d5b3d7a0da 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample01_HelloWorld.md +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample01_HelloWorld.md @@ -20,13 +20,13 @@ ServiceBusSender sender = client.CreateSender(queueName); ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message -await sender.SendAsync(message); +await sender.SendMessageAsync(message); // create a receiver that we can use to receive the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties -ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // get the message body as a string string body = receivedMessage.Body.ToString(); @@ -35,7 +35,7 @@ Console.WriteLine(body); ### Send and receive a batch of messages -There are two ways of sending several messages at once. The first way uses the `SendAsync` +There are two ways of sending several messages at once. The first way uses the `SendMessagesAsync` overload that accepts an IEnumerable of `ServiceBusMessage`. With this method, we will attempt to fit all of the supplied messages in a single message batch that we will send to the service. If the messages are too large to fit in a single batch, the operation will throw an exception. @@ -45,19 +45,19 @@ IList messages = new List(); messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); // send the messages -await sender.SendAsync(messages); +await sender.SendMessagesAsync(messages); ``` The second way of doing this is using safe-batching. With safe-batching, you can create a `ServiceBusMessageBatch` object, which will allow you to attempt to messages one at a time to the batch using TryAdd. If the message cannot fit in the batch, TryAdd will return false. ```C# Snippet:ServiceBusSendAndReceiveSafeBatch -ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync(); -messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); -messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); +ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync(); +messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); +messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); // send the message batch -await sender.SendAsync(messageBatch); +await sender.SendMessagesAsync(messageBatch); ``` ## Peeking a message @@ -65,7 +65,7 @@ await sender.SendAsync(messageBatch); It's also possible to simply peek a message. Peeking a message does not require the message to be locked. ```C# Snippet:ServiceBusPeek -ServiceBusReceivedMessage peekedMessage = await receiver.PeekAsync(); +ServiceBusReceivedMessage peekedMessage = await receiver.PeekMessageAsync(); ``` ### Schedule a message diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample02_MessageSettlement.md b/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample02_MessageSettlement.md index c2fec449b11c..fe7bd16440f4 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample02_MessageSettlement.md +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample02_MessageSettlement.md @@ -18,35 +18,35 @@ ServiceBusSender sender = client.CreateSender(queueName); ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message -await sender.SendAsync(message); +await sender.SendMessageAsync(message); // create a receiver that we can use to receive and settle the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties -ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // complete the message, thereby deleting it from the service -await receiver.CompleteAsync(receivedMessage); +await receiver.CompleteMessageAsync(receivedMessage); ``` ### Abandon a message ```C# Snippet:ServiceBusAbandonMessage -ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // abandon the message, thereby releasing the lock and allowing it to be received again by this or other receivers -await receiver.AbandonAsync(receivedMessage); +await receiver.AbandonMessageAsync(receivedMessage); ``` ### Defer a message ```C# Snippet:ServiceBusDeferMessage -ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // defer the message, thereby preventing the message from being received again without using // the received deferred message API. -await receiver.DeferAsync(receivedMessage); +await receiver.DeferMessageAsync(receivedMessage); // receive the deferred message by specifying the service set sequence number of the original // received message @@ -56,14 +56,14 @@ ServiceBusReceivedMessage deferredMessage = await receiver.ReceiveDeferredMessag ### Dead letter a message ```C# Snippet:ServiceBusDeadLetterMessage -ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // deadletter the message, thereby preventing the message from being received again without receiving from the dead letter queue. -await receiver.DeadLetterAsync(receivedMessage); +await receiver.DeadLetterMessageAsync(receivedMessage); // receive the dead lettered message with receiver scoped to the dead letter queue. ServiceBusReceiver dlqReceiver = client.CreateDeadLetterReceiver(queueName); -ServiceBusReceivedMessage dlqMessage = await dlqReceiver.ReceiveAsync(); +ServiceBusReceivedMessage dlqMessage = await dlqReceiver.ReceiveMessageAsync(); ``` ## Source diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample03_SendReceiveSessions.md b/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample03_SendReceiveSessions.md index 8c3b231505a0..20141f219b07 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample03_SendReceiveSessions.md +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample03_SendReceiveSessions.md @@ -23,14 +23,14 @@ ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello }; // send the message -await sender.SendAsync(message); +await sender.SendMessageAsync(message); // create a session receiver that we can use to receive the message. Since we don't specify a // particular session, we will get the next available session from the service. ServiceBusSessionReceiver receiver = await client.CreateSessionReceiverAsync(queueName); // the received message is a different type as it contains some service set properties -ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); Console.WriteLine(receivedMessage.SessionId); // we can also set arbitrary session state using this receiver @@ -53,7 +53,7 @@ ServiceBusSessionReceiver receiver = await client.CreateSessionReceiverAsync( }); // the received message is a different type as it contains some service set properties -ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); Console.WriteLine(receivedMessage.SessionId); ``` diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample04_Processor.md b/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample04_Processor.md index debf9d495a4b..5a4831a72cc6 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample04_Processor.md +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample04_Processor.md @@ -14,12 +14,12 @@ await using var client = new ServiceBusClient(connectionString); ServiceBusSender sender = client.CreateSender(queueName); // create a message batch that we can send -ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync(); -messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); -messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); +ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync(); +messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); +messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); // send the message batch -await sender.SendAsync(messageBatch); +await sender.SendMessagesAsync(messageBatch); // get the options to use for configuring the processor var options = new ServiceBusProcessorOptions @@ -87,20 +87,20 @@ await using var client = new ServiceBusClient(connectionString); ServiceBusSender sender = client.CreateSender(queueName); // create a message batch that we can send -ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync(); -messageBatch.TryAdd( +ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync(); +messageBatch.TryAddMessage( new ServiceBusMessage(Encoding.UTF8.GetBytes("First")) { SessionId = "Session1" }); -messageBatch.TryAdd( +messageBatch.TryAddMessage( new ServiceBusMessage(Encoding.UTF8.GetBytes("Second")) { SessionId = "Session2" }); // send the message batch -await sender.SendAsync(messageBatch); +await sender.SendMessagesAsync(messageBatch); // get the options to use for configuring the processor var options = new ServiceBusSessionProcessorOptions diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample05_SessionProcessor.md b/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample05_SessionProcessor.md index 29d562261523..3debda253da2 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample05_SessionProcessor.md +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample05_SessionProcessor.md @@ -17,20 +17,20 @@ await using var client = new ServiceBusClient(connectionString); ServiceBusSender sender = client.CreateSender(queueName); // create a message batch that we can send -ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync(); -messageBatch.TryAdd( +ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync(); +messageBatch.TryAddMessage( new ServiceBusMessage(Encoding.UTF8.GetBytes("First")) { SessionId = "Session1" }); -messageBatch.TryAdd( +messageBatch.TryAddMessage( new ServiceBusMessage(Encoding.UTF8.GetBytes("Second")) { SessionId = "Session2" }); // send the message batch -await sender.SendAsync(messageBatch); +await sender.SendMessagesAsync(messageBatch); // get the options to use for configuring the processor var options = new ServiceBusSessionProcessorOptions diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample06_Transactions.md b/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample06_Transactions.md index 39358fe66758..f5786adc1c4c 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample06_Transactions.md +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/samples/Sample06_Transactions.md @@ -11,13 +11,13 @@ string queueName = ""; await using var client = new ServiceBusClient(connectionString); ServiceBusSender sender = client.CreateSender(queueName); -await sender.SendAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); +await sender.SendMessageAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); ServiceBusReceiver receiver = client.CreateReceiver(queueName); -ServiceBusReceivedMessage firstMessage = await receiver.ReceiveAsync(); +ServiceBusReceivedMessage firstMessage = await receiver.ReceiveMessageAsync(); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await sender.SendAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); - await receiver.CompleteAsync(firstMessage); + await sender.SendMessageAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); + await receiver.CompleteMessageAsync(firstMessage); ts.Complete(); } ``` @@ -33,7 +33,7 @@ string queueB = ""; await using var client = new ServiceBusClient(connectionString); ServiceBusSender senderA = client.CreateSender(queueA); -await senderA.SendAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); +await senderA.SendMessageAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); ServiceBusSender senderBViaA = client.CreateSender(queueB, new ServiceBusSenderOptions { @@ -41,11 +41,11 @@ ServiceBusSender senderBViaA = client.CreateSender(queueB, new ServiceBusSenderO }); ServiceBusReceiver receiverA = client.CreateReceiver(queueA); -ServiceBusReceivedMessage firstMessage = await receiverA.ReceiveAsync(); +ServiceBusReceivedMessage firstMessage = await receiverA.ReceiveMessageAsync(); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await receiverA.CompleteAsync(firstMessage); - await senderBViaA.SendAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); + await receiverA.CompleteMessageAsync(firstMessage); + await senderBViaA.SendMessageAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); ts.Complete(); } ``` diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpMessageBatch.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpMessageBatch.cs index c6bb97fe2c04..068cc1bb1717 100755 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpMessageBatch.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpMessageBatch.cs @@ -60,7 +60,7 @@ internal class AmqpMessageBatch : TransportMessageBatch /// The set of options to apply to the batch. /// /// - private CreateBatchOptions Options { get; } + private CreateMessageBatchOptions Options { get; } /// /// The set of messages that have been added to the batch. @@ -74,7 +74,7 @@ internal class AmqpMessageBatch : TransportMessageBatch /// /// The set of options to apply to the batch. /// - public AmqpMessageBatch(CreateBatchOptions options) + public AmqpMessageBatch(CreateMessageBatchOptions options) { Argument.AssertNotNull(options, nameof(options)); Argument.AssertNotNull(options.MaxSizeInBytes, nameof(options.MaxSizeInBytes)); @@ -98,7 +98,7 @@ public AmqpMessageBatch(CreateBatchOptions options) /// /// true if the message was added; otherwise, false. /// - public override bool TryAdd(ServiceBusMessage message) + public override bool TryAddMessage(ServiceBusMessage message) { Argument.AssertNotNull(message, nameof(message)); Argument.AssertNotDisposed(_disposed, nameof(ServiceBusMessageBatch)); diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpReceiver.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpReceiver.cs index 08b9f29b3e31..7e285e9340c5 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpReceiver.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpReceiver.cs @@ -196,7 +196,7 @@ private static void CloseLink(RequestResponseAmqpLink link) } /// - /// Receives a batch of from the entity using mode. + /// Receives a list of from the entity using mode. /// /// /// The maximum number of messages that will be received. @@ -204,7 +204,7 @@ private static void CloseLink(RequestResponseAmqpLink link) /// An optional instance to signal the request to cancel the operation. /// /// List of messages received. Returns an empty list if no message is found. - public override async Task> ReceiveBatchAsync( + public override async Task> ReceiveMessagesAsync( int maxMessages, TimeSpan? maxWaitTime, CancellationToken cancellationToken) @@ -212,7 +212,7 @@ public override async Task> ReceiveBatchAsync( IList messages = null; await _retryPolicy.RunOperation(async (timeout) => { - messages = await ReceiveBatchAsyncInternal( + messages = await ReceiveMessagesAsyncInternal( maxMessages, maxWaitTime, timeout, @@ -225,18 +225,18 @@ await _retryPolicy.RunOperation(async (timeout) => } /// - /// Receives a batch of from the Service Bus entity. + /// Receives a list of from the Service Bus entity. /// /// - /// The maximum number of messages to receive in this batch. + /// The maximum number of messages to receive. /// An optional specifying the maximum time to wait for the first message before returning an empty list if no messages have been received. /// If not specified, the will be used. /// The per-try timeout specified in the RetryOptions. /// An optional instance to signal the request to cancel the operation. /// - /// The batch of from the Service Bus entity this receiver is associated with. If no messages are present, an empty list is returned. + /// The list of from the Service Bus entity this receiver is associated with. If no messages are present, an empty list is returned. /// - private async Task> ReceiveBatchAsyncInternal( + private async Task> ReceiveMessagesAsyncInternal( int maxMessages, TimeSpan? maxWaitTime, TimeSpan timeout, @@ -449,8 +449,9 @@ private void ThrowLockLostException() /// /// A lock token can be found in , /// only when is set to . - /// In order to receive this message again in the future, you will need to save the - /// and receive it using ReceiveDeferredMessageBatchAsync(IEnumerable, CancellationToken). + /// In order to receive this message again in the future, you will need to save + /// the + /// and receive it using . /// Deferring messages does not impact message's expiration, meaning that deferred messages can still expire. /// This operation can only be performed on messages that were received by this receiver. /// @@ -777,7 +778,7 @@ private static Outcome GetModifiedOutcome( } /// - /// Fetches the next batch of active messages without changing the state of the receiver or the message source. + /// Fetches a list of active messages without changing the state of the receiver or the message source. /// /// /// The sequence number from where to read the message. @@ -785,13 +786,14 @@ private static Outcome GetModifiedOutcome( /// An optional instance to signal the request to cancel the operation. /// /// - /// The first call to PeekBatchBySequenceAsync(long, int, CancellationToken) fetches the first active message for this receiver. Each subsequent call - /// fetches the subsequent message in the entity. - /// Unlike a received message, peeked message will not have lock token associated with it, and hence it cannot be Completed/Abandoned/Deferred/Deadlettered/Renewed. - /// Also, unlike , this method will fetch even Deferred messages (but not Deadlettered message) + /// The first call to (long, int, CancellationToken) fetches the first active message for this receiver. + /// Each subsequent call fetches the subsequent message in the entity. + /// Unlike a received message, peeked message will not have lock token associated with it, + /// and hence it cannot be Completed/Abandoned/Deferred/Deadlettered/Renewed. + /// Also, unlike , this method will fetch even Deferred messages (but not Deadlettered message) /// /// - public override async Task> PeekBatchAtAsync( + public override async Task> PeekMessagesAsync( long? sequenceNumber, int messageCount = 1, CancellationToken cancellationToken = default) @@ -802,7 +804,7 @@ public override async Task> PeekBatchAtAsync( await _retryPolicy.RunOperation( async (timeout) => - messages = await PeekBatchAtInternalAsync( + messages = await PeekMessagesInternalAsync( seqNumber, messageCount, timeout, @@ -822,7 +824,7 @@ await _retryPolicy.RunOperation( /// /// /// - private async Task> PeekBatchAtInternalAsync( + private async Task> PeekMessagesInternalAsync( long sequenceNumber, int messageCount, TimeSpan timeout, @@ -1138,7 +1140,7 @@ internal async Task SetStateInternal( /// Messages identified by sequence number are returned. Returns null if no messages are found. /// Throws if the messages have not been deferred. /// - public override async Task> ReceiveDeferredMessageBatchAsync( + public override async Task> ReceiveDeferredMessagesAsync( IList sequenceNumbers, CancellationToken cancellationToken = default) { diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpSender.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpSender.cs index 08aad1f9a506..1b45249b9aa1 100755 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpSender.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Amqp/AmqpSender.cs @@ -158,14 +158,14 @@ public AmqpSender( /// /// An with the requested . /// - public override async ValueTask CreateBatchAsync( - CreateBatchOptions options, + public override async ValueTask CreateMessageBatchAsync( + CreateMessageBatchOptions options, CancellationToken cancellationToken) { TransportMessageBatch messageBatch = null; Task createBatchTask = _retryPolicy.RunOperation(async (timeout) => { - messageBatch = await CreateBatchInternalAsync( + messageBatch = await CreateMessageBatchInternalAsync( options, timeout).ConfigureAwait(false); }, @@ -175,8 +175,8 @@ public override async ValueTask CreateBatchAsync( return messageBatch; } - internal async ValueTask CreateBatchInternalAsync( - CreateBatchOptions options, + internal async ValueTask CreateMessageBatchInternalAsync( + CreateMessageBatchOptions options, TimeSpan timeout) { Argument.AssertNotNull(options, nameof(options)); @@ -361,106 +361,105 @@ public override async Task CloseAsync(CancellationToken cancellationToken) /// /// /// - /// + /// /// /// - public override async Task ScheduleMessageAsync( - ServiceBusMessage message, + public override async Task ScheduleMessagesAsync( + IList messages, CancellationToken cancellationToken = default) { - long sequenceNumber = 0; - Task scheduleTask = _retryPolicy.RunOperation(async (timeout) => + long[] seqNumbers = null; + await _retryPolicy.RunOperation(async (timeout) => { - sequenceNumber = await ScheduleMessageInternalAsync( - message, + seqNumbers = await ScheduleMessageInternalAsync( + messages, timeout, cancellationToken).ConfigureAwait(false); }, _connectionScope, - cancellationToken); - await scheduleTask.ConfigureAwait(false); - return sequenceNumber; + cancellationToken).ConfigureAwait(false); + return seqNumbers ?? Array.Empty(); } /// /// /// - /// + /// /// /// /// - internal async Task ScheduleMessageInternalAsync( - ServiceBusMessage message, + internal async Task ScheduleMessageInternalAsync( + IList messages, TimeSpan timeout, CancellationToken cancellationToken = default) { var sendLink = default(SendingAmqpLink); try { - using (AmqpMessage amqpMessage = AmqpMessageConverter.SBMessageToAmqpMessage(message)) - { - var request = AmqpRequestMessage.CreateRequest( - ManagementConstants.Operations.ScheduleMessageOperation, - timeout, - null); + var request = AmqpRequestMessage.CreateRequest( + ManagementConstants.Operations.ScheduleMessageOperation, + timeout, + null); - if (_sendLink.TryGetOpenedObject(out sendLink)) - { - request.AmqpMessage.ApplicationProperties.Map[ManagementConstants.Request.AssociatedLinkName] = sendLink.Name; - } + if (_sendLink.TryGetOpenedObject(out sendLink)) + { + request.AmqpMessage.ApplicationProperties.Map[ManagementConstants.Request.AssociatedLinkName] = sendLink.Name; + } + List entries = new List(); + foreach (ServiceBusMessage message in messages) + { + using AmqpMessage amqpMessage = AmqpMessageConverter.SBMessageToAmqpMessage(message); + var entry = new AmqpMap(); ArraySegment[] payload = amqpMessage.GetPayload(); var buffer = new BufferListStream(payload); ArraySegment value = buffer.ReadBytes((int)buffer.Length); + entry[ManagementConstants.Properties.Message] = value; + entry[ManagementConstants.Properties.MessageId] = message.MessageId; - var entry = new AmqpMap(); + if (!string.IsNullOrWhiteSpace(message.SessionId)) { - entry[ManagementConstants.Properties.Message] = value; - entry[ManagementConstants.Properties.MessageId] = message.MessageId; - - if (!string.IsNullOrWhiteSpace(message.SessionId)) - { - entry[ManagementConstants.Properties.SessionId] = message.SessionId; - } - - if (!string.IsNullOrWhiteSpace(message.PartitionKey)) - { - entry[ManagementConstants.Properties.PartitionKey] = message.PartitionKey; - } - - if (!string.IsNullOrWhiteSpace(message.ViaPartitionKey)) - { - entry[ManagementConstants.Properties.ViaPartitionKey] = message.ViaPartitionKey; - } + entry[ManagementConstants.Properties.SessionId] = message.SessionId; } - request.Map[ManagementConstants.Properties.Messages] = new List { entry }; + if (!string.IsNullOrWhiteSpace(message.PartitionKey)) + { + entry[ManagementConstants.Properties.PartitionKey] = message.PartitionKey; + } + if (!string.IsNullOrWhiteSpace(message.ViaPartitionKey)) + { + entry[ManagementConstants.Properties.ViaPartitionKey] = message.ViaPartitionKey; + } - AmqpResponseMessage amqpResponseMessage = await ManagementUtilities.ExecuteRequestResponseAsync( - _connectionScope, - _managementLink, - request, - timeout).ConfigureAwait(false); + entries.Add(entry); + } - cancellationToken.ThrowIfCancellationRequested(); + request.Map[ManagementConstants.Properties.Messages] = entries; - if (amqpResponseMessage.StatusCode == AmqpResponseStatusCode.OK) - { - var sequenceNumbers = amqpResponseMessage.GetValue(ManagementConstants.Properties.SequenceNumbers); - if (sequenceNumbers == null || sequenceNumbers.Length < 1) - { - throw new ServiceBusException(true, "Could not schedule message successfully."); - } + AmqpResponseMessage amqpResponseMessage = await ManagementUtilities.ExecuteRequestResponseAsync( + _connectionScope, + _managementLink, + request, + timeout).ConfigureAwait(false); - return sequenceNumbers[0]; + cancellationToken.ThrowIfCancellationRequested(); - } - else + if (amqpResponseMessage.StatusCode == AmqpResponseStatusCode.OK) + { + var sequenceNumbers = amqpResponseMessage.GetValue(ManagementConstants.Properties.SequenceNumbers); + if (sequenceNumbers == null || sequenceNumbers.Length < 1) { - throw amqpResponseMessage.ToMessagingContractException(); + throw new ServiceBusException(true, "Could not schedule message successfully."); } + + return sequenceNumbers; + + } + else + { + throw amqpResponseMessage.ToMessagingContractException(); } } catch (Exception exception) @@ -479,17 +478,17 @@ internal async Task ScheduleMessageInternalAsync( /// /// /// - /// + /// /// /// - public override async Task CancelScheduledMessageAsync( - long sequenceNumber, + public override async Task CancelScheduledMessagesAsync( + long[] sequenceNumbers, CancellationToken cancellationToken = default) { Task cancelMessageTask = _retryPolicy.RunOperation(async (timeout) => { await CancelScheduledMessageInternalAsync( - sequenceNumber, + sequenceNumbers, timeout, cancellationToken).ConfigureAwait(false); }, @@ -501,12 +500,12 @@ await CancelScheduledMessageInternalAsync( /// /// /// - /// + /// /// /// /// internal async Task CancelScheduledMessageInternalAsync( - long sequenceNumber, + long[] sequenceNumbers, TimeSpan timeout, CancellationToken cancellationToken = default) { @@ -523,7 +522,7 @@ internal async Task CancelScheduledMessageInternalAsync( request.AmqpMessage.ApplicationProperties.Map[ManagementConstants.Request.AssociatedLinkName] = sendLink.Name; } - request.Map[ManagementConstants.Properties.SequenceNumbers] = new[] { sequenceNumber }; + request.Map[ManagementConstants.Properties.SequenceNumbers] = sequenceNumbers; AmqpResponseMessage amqpResponseMessage = await ManagementUtilities.ExecuteRequestResponseAsync( _connectionScope, diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportMessageBatch.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportMessageBatch.cs index d62f29e372c3..69c3410ef655 100755 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportMessageBatch.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportMessageBatch.cs @@ -43,7 +43,7 @@ internal abstract class TransportMessageBatch : IDisposable /// /// true if the message was added; otherwise, false. /// - public abstract bool TryAdd(ServiceBusMessage message); + public abstract bool TryAddMessage(ServiceBusMessage message); /// /// Clears the batch, removing all messages and resetting the diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportReceiver.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportReceiver.cs index dbc798c2d656..2e19ef4f9859 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportReceiver.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportReceiver.cs @@ -46,7 +46,7 @@ internal abstract class TransportReceiver /// An optional instance to signal the request to cancel the operation. /// /// List of messages received. Returns an empty list if no message is found. - public abstract Task> ReceiveBatchAsync( + public abstract Task> ReceiveMessagesAsync( int maximumMessageCount, TimeSpan? maxWaitTime, CancellationToken cancellationToken); @@ -117,10 +117,10 @@ public abstract Task DeferAsync( /// The first call to PeekBatchBySequenceAsync(long, int, CancellationToken) fetches the first active message for this receiver. Each subsequent call /// fetches the subsequent message in the entity. /// Unlike a received message, peeked message will not have lock token associated with it, and hence it cannot be Completed/Abandoned/Deferred/Deadlettered/Renewed. - /// Also, unlike , this method will fetch even Deferred messages (but not Deadlettered messages). + /// Also, unlike , this method will fetch even Deferred messages (but not Deadlettered messages). /// /// - public abstract Task> PeekBatchAtAsync( + public abstract Task> PeekMessagesAsync( long? sequenceNumber, int messageCount = 1, CancellationToken cancellationToken = default); @@ -179,7 +179,7 @@ public abstract Task DeadLetterAsync( /// Messages identified by sequence number are returned. Returns null if no messages are found. /// Throws if the messages have not been deferred. /// - public abstract Task> ReceiveDeferredMessageBatchAsync( + public abstract Task> ReceiveDeferredMessagesAsync( IList sequenceNumbers, CancellationToken cancellationToken = default); diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportSender.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportSender.cs index c07e9a3737a6..4ab3ca58457d 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportSender.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Core/TransportSender.cs @@ -41,10 +41,10 @@ internal abstract class TransportSender /// /// An with the requested . /// - /// + /// /// - public abstract ValueTask CreateBatchAsync( - CreateBatchOptions options, + public abstract ValueTask CreateMessageBatchAsync( + CreateMessageBatchOptions options, CancellationToken cancellationToken); /// @@ -76,21 +76,21 @@ public abstract Task SendBatchAsync( /// /// /// - /// + /// /// /// - public abstract Task ScheduleMessageAsync( - ServiceBusMessage message, + public abstract Task ScheduleMessagesAsync( + IList messages, CancellationToken cancellationToken = default); /// /// /// - /// + /// /// /// - public abstract Task CancelScheduledMessageAsync( - long sequenceNumber, + public abstract Task CancelScheduledMessagesAsync( + long[] sequenceNumbers, CancellationToken cancellationToken = default); /// diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/ServiceBusEventSource.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/ServiceBusEventSource.cs index e92af188469f..210e79477da5 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/ServiceBusEventSource.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Diagnostics/ServiceBusEventSource.cs @@ -264,19 +264,19 @@ public virtual void ReceiveMessageException( } } - [Event(ReceiveDeferredMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: ReceiveDeferredMessageAsync start. MessageCount = {1}, LockTokens = {2}")] + [Event(ReceiveDeferredMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: ReceiveDeferredMessageAsync start. MessageCount = {1}, SequenceNumbers = {2}")] public void ReceiveDeferredMessageStartCore(string identifier, int messageCount, string sequenceNumbers) { WriteEvent(ReceiveDeferredMessageStartEvent, identifier, messageCount, sequenceNumbers); } [NonEvent] - public virtual void ReceiveDeferredMessageStart(string identifier, int messageCount, IEnumerable sequenceNumbers) + public virtual void ReceiveDeferredMessageStart(string identifier, IList sequenceNumbers) { if (IsEnabled()) { var formattedSequenceNumbers = StringUtility.GetFormattedSequenceNumbers(sequenceNumbers); - ReceiveDeferredMessageStartCore(identifier, messageCount, formattedSequenceNumbers); + ReceiveDeferredMessageStartCore(identifier, sequenceNumbers.Count, formattedSequenceNumbers); } } @@ -329,17 +329,17 @@ public virtual void PeekMessageException(string identifier, string exception) #endregion #region Scheduling - [Event(ScheduleMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: ScheduleMessageAsync start. ScheduleTimeUtc = {1}")] - public virtual void ScheduleMessageStart(string identifier, string scheduledEnqueueTime) + [Event(ScheduleMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: ScheduleMessageAsync start. MessageCount = {1}, ScheduleTimeUtc = {2}")] + public virtual void ScheduleMessagesStart(string identifier, int messageCount, string scheduledEnqueueTime) { if (IsEnabled()) { - WriteEvent(ScheduleMessageStartEvent, identifier, scheduledEnqueueTime); + WriteEvent(ScheduleMessageStartEvent, identifier, messageCount, scheduledEnqueueTime); } } [Event(ScheduleMessageCompleteEvent, Level = EventLevel.Informational, Message = "{0}: ScheduleMessageAsync done.")] - public virtual void ScheduleMessageComplete(string identifier) + public virtual void ScheduleMessagesComplete(string identifier) { if (IsEnabled()) { @@ -348,7 +348,7 @@ public virtual void ScheduleMessageComplete(string identifier) } [Event(ScheduleMessageExceptionEvent, Level = EventLevel.Error, Message = "{0}: ScheduleMessageAsync Exception: {1}.")] - public virtual void ScheduleMessageException(string identifier, string exception) + public virtual void ScheduleMessagesException(string identifier, string exception) { if (IsEnabled()) { @@ -356,17 +356,27 @@ public virtual void ScheduleMessageException(string identifier, string exception } } - [Event(CancelScheduledMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: CancelScheduledMessageAsync start. SequenceNumber = {1}")] - public virtual void CancelScheduledMessageStart(string identifier, long sequenceNumber) + [NonEvent] + public virtual void CancelScheduledMessagesStart(string identifier, long[] sequenceNumbers) + { + if (IsEnabled()) + { + var formattedSequenceNumbers = StringUtility.GetFormattedSequenceNumbers(sequenceNumbers); + CancelScheduledMessagesStartCore(identifier, sequenceNumbers.Length, formattedSequenceNumbers); + } + } + + [Event(CancelScheduledMessageStartEvent, Level = EventLevel.Informational, Message = "{0}: CancelScheduledMessageAsync start. MessageCount = {1}, SequenceNumbers = {2}")] + public virtual void CancelScheduledMessagesStartCore(string identifier, int messageCount, string sequenceNumbers) { if (IsEnabled()) { - WriteEvent(CancelScheduledMessageStartEvent, identifier, sequenceNumber); + WriteEvent(CancelScheduledMessageStartEvent, identifier, messageCount, sequenceNumbers); } } [Event(CancelScheduledMessageCompleteEvent, Level = EventLevel.Informational, Message = "{0}: CancelScheduledMessageAsync done.")] - public virtual void CancelScheduledMessageComplete(string identifier) + public virtual void CancelScheduledMessagesComplete(string identifier) { if (IsEnabled()) { @@ -375,7 +385,7 @@ public virtual void CancelScheduledMessageComplete(string identifier) } [Event(CancelScheduledMessageExceptionEvent, Level = EventLevel.Error, Message = "{0}: CancelScheduledMessageAsync Exception: {1}.")] - public virtual void CancelScheduledMessageException(string identifier, string exception) + public virtual void CancelScheduledMessagesException(string identifier, string exception) { if (IsEnabled()) { diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ProcessMessageEventArgs.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ProcessMessageEventArgs.cs index 7acc9bceace4..7113e376c99f 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ProcessMessageEventArgs.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ProcessMessageEventArgs.cs @@ -53,7 +53,7 @@ public async Task AbandonAsync( IDictionary propertiesToModify = default, CancellationToken cancellationToken = default) { - await _receiver.AbandonAsync(message, propertiesToModify, cancellationToken) + await _receiver.AbandonMessageAsync(message, propertiesToModify, cancellationToken) .ConfigureAwait(false); message.IsSettled = true; } @@ -68,7 +68,7 @@ public async Task CompleteAsync( ServiceBusReceivedMessage message, CancellationToken cancellationToken = default) { - await _receiver.CompleteAsync( + await _receiver.CompleteMessageAsync( message, cancellationToken) .ConfigureAwait(false); @@ -89,7 +89,7 @@ public async Task DeadLetterAsync( string deadLetterErrorDescription = default, CancellationToken cancellationToken = default) { - await _receiver.DeadLetterAsync( + await _receiver.DeadLetterMessageAsync( message, deadLetterReason, deadLetterErrorDescription, @@ -110,7 +110,7 @@ public async Task DeadLetterAsync( IDictionary propertiesToModify = default, CancellationToken cancellationToken = default) { - await _receiver.DeadLetterAsync( + await _receiver.DeadLetterMessageAsync( message, propertiesToModify, cancellationToken) @@ -130,7 +130,7 @@ public async Task DeferAsync( IDictionary propertiesToModify = default, CancellationToken cancellationToken = default) { - await _receiver.DeferAsync( + await _receiver.DeferMessageAsync( message, propertiesToModify, cancellationToken) diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ProcessSessionMessageEventArgs.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ProcessSessionMessageEventArgs.cs index 6718671e50eb..db6bdf5ff644 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ProcessSessionMessageEventArgs.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ProcessSessionMessageEventArgs.cs @@ -105,7 +105,7 @@ public async Task AbandonAsync( IDictionary propertiesToModify = default, CancellationToken cancellationToken = default) { - await _sessionReceiver.AbandonAsync(message, propertiesToModify, cancellationToken) + await _sessionReceiver.AbandonMessageAsync(message, propertiesToModify, cancellationToken) .ConfigureAwait(false); message.IsSettled = true; } @@ -126,7 +126,7 @@ public async Task CompleteAsync( ServiceBusReceivedMessage message, CancellationToken cancellationToken = default) { - await _sessionReceiver.CompleteAsync( + await _sessionReceiver.CompleteMessageAsync( message, cancellationToken) .ConfigureAwait(false); @@ -155,7 +155,7 @@ public async Task DeadLetterAsync( string deadLetterErrorDescription = default, CancellationToken cancellationToken = default) { - await _sessionReceiver.DeadLetterAsync( + await _sessionReceiver.DeadLetterMessageAsync( message, deadLetterReason, deadLetterErrorDescription, @@ -184,7 +184,7 @@ public async Task DeadLetterAsync( IDictionary propertiesToModify = default, CancellationToken cancellationToken = default) { - await _sessionReceiver.DeadLetterAsync( + await _sessionReceiver.DeadLetterMessageAsync( message, propertiesToModify, cancellationToken) @@ -202,7 +202,7 @@ await _sessionReceiver.DeadLetterAsync( /// A lock token can be found in , /// only when is set to . /// In order to receive this message again in the future, you will need to save the - /// and receive it using . + /// and receive it using . /// Deferring messages does not impact message's expiration, meaning that deferred messages can still expire. /// This operation can only be performed on messages that were received by this receiver. /// @@ -213,7 +213,7 @@ public async Task DeferAsync( IDictionary propertiesToModify = default, CancellationToken cancellationToken = default) { - await _sessionReceiver.DeferAsync( + await _sessionReceiver.DeferMessageAsync( message, propertiesToModify, cancellationToken) diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ReceiverManager.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ReceiverManager.cs index b102ac674b44..4395df919daf 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ReceiverManager.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ReceiverManager.cs @@ -84,7 +84,7 @@ public virtual async Task ReceiveAndProcessMessagesAsync(CancellationToken cance while (!cancellationToken.IsCancellationRequested) { errorSource = ServiceBusErrorSource.Receive; - ServiceBusReceivedMessage message = await Receiver.ReceiveAsync( + ServiceBusReceivedMessage message = await Receiver.ReceiveMessageAsync( _maxReceiveWaitTime, cancellationToken).ConfigureAwait(false); if (message == null) @@ -170,7 +170,7 @@ private async Task ProcessOneMessage( // don't pass the processor cancellation token // as we want in flight autocompletion to be able // to finish - await Receiver.CompleteAsync( + await Receiver.CompleteMessageAsync( message.LockToken, CancellationToken.None) .ConfigureAwait(false); @@ -202,7 +202,7 @@ await RaiseExceptionReceived( // don't pass the processor cancellation token // as we want in flight abandon to be able // to finish even if user stopped processing - await Receiver.AbandonAsync( + await Receiver.AbandonMessageAsync( message.LockToken, cancellationToken: CancellationToken.None) .ConfigureAwait(false); diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ServiceBusProcessor.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ServiceBusProcessor.cs index 1a6611cf09e7..a463acf29362 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ServiceBusProcessor.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ServiceBusProcessor.cs @@ -386,7 +386,7 @@ internal event Func SessionInitializingAsync /// /// Optional event that can be set to be notified when a session is about to be closed for processing. - /// This means that the most recent ReceiveAsync call timed out so there are currently no messages + /// This means that the most recent call timed out so there are currently no messages /// available to be received for the session. /// [SuppressMessage("Usage", "AZC0002:Ensure all service methods take an optional CancellationToken parameter.", Justification = "Guidance does not apply; this is an event.")] diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ServiceBusSessionProcessor.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ServiceBusSessionProcessor.cs index 2da4fd6e0593..907f49790e65 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ServiceBusSessionProcessor.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/ServiceBusSessionProcessor.cs @@ -172,8 +172,8 @@ public event Func SessionInitializingAsync /// /// Optional event that can be set to be notified when a session is about to be closed for processing. - /// This means that the most recent ReceiveAsync call timed out so there are currently no messages - /// available to be received for the session. + /// This means that the most recent call timed out, + /// so there are currently no messages available to be received for the session. /// [SuppressMessage("Usage", "AZC0002:Ensure all service methods take an optional CancellationToken parameter.", Justification = "Guidance does not apply; this is an event.")] [SuppressMessage("Usage", "AZC0003:DO make service methods virtual.", Justification = "This member follows the standard .NET event pattern; override via the associated On<> method.")] diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/SessionReceiverManager.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/SessionReceiverManager.cs index f9ed4d6e8813..83b0439e383d 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/SessionReceiverManager.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Processor/SessionReceiverManager.cs @@ -232,7 +232,7 @@ public override async Task ReceiveAndProcessMessagesAsync( while (!cancellationToken.IsCancellationRequested) { errorSource = ServiceBusErrorSource.Receive; - ServiceBusReceivedMessage message = await _receiver.ReceiveAsync( + ServiceBusReceivedMessage message = await _receiver.ReceiveMessageAsync( _maxReceiveWaitTime, cancellationToken).ConfigureAwait(false); if (message == null) diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Receiver/ServiceBusReceiver.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Receiver/ServiceBusReceiver.cs index d1a960bc43fb..987cad7c79e8 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Receiver/ServiceBusReceiver.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Receiver/ServiceBusReceiver.cs @@ -157,17 +157,19 @@ internal ServiceBusReceiver( protected ServiceBusReceiver() { } /// - /// Receives a batch of from the entity using mode. defaults to PeekLock mode. - /// This method doesn't guarantee to return exact `maxMessages` messages, even if there are `maxMessages` messages available in the queue or topic. + /// Receives a list of from the entity using mode. + /// defaults to PeekLock mode. + /// This method doesn't guarantee to return exact `maxMessages` messages, + /// even if there are `maxMessages` messages available in the queue or topic. /// /// /// The maximum number of messages that will be received. - /// An optional specifying the maximum time to wait for the first message before returning an empty list if no messages have been received. + /// An optional specifying the maximum time to wait for the first message before returning an empty list if no messages are available. /// If not specified, the will be used. /// An optional instance to signal the request to cancel the operation. /// /// List of messages received. Returns an empty list if no message is found. - public virtual async Task> ReceiveBatchAsync( + public virtual async Task> ReceiveMessagesAsync( int maxMessages, TimeSpan? maxWaitTime = default, CancellationToken cancellationToken = default) @@ -190,7 +192,7 @@ public virtual async Task> ReceiveBatchAsync( try { - messages = await InnerReceiver.ReceiveBatchAsync( + messages = await InnerReceiver.ReceiveMessagesAsync( maxMessages, maxWaitTime, cancellationToken).ConfigureAwait(false); @@ -209,18 +211,21 @@ public virtual async Task> ReceiveBatchAsync( } /// - /// Receives a from the entity using mode. defaults to PeekLock mode + /// Receives a from the entity using mode. + /// defaults to PeekLock mode. /// - /// An optional specifying the maximum time to wait for a message before returning a null if no messages are available. + /// An optional specifying the maximum time to wait for a message before returning + /// null if no messages are available. /// If not specified, the will be used. - /// An optional instance to signal the request to cancel the operation. + /// An optional instance to signal the request to cancel the + /// operation. /// /// The message received. Returns null if no message is found. - public virtual async Task ReceiveAsync( + public virtual async Task ReceiveMessageAsync( TimeSpan? maxWaitTime = default, CancellationToken cancellationToken = default) { - IEnumerable result = await ReceiveBatchAsync( + IEnumerable result = await ReceiveMessagesAsync( maxMessages: 1, maxWaitTime: maxWaitTime, cancellationToken: cancellationToken) @@ -234,47 +239,26 @@ public virtual async Task ReceiveAsync( } /// - /// Fetches the next active message without changing the state of the receiver or the message source. + /// Fetches the next active without changing the state of the receiver or the message source. /// - /// - /// An optional instance to signal the request to cancel the operation. + /// An optional sequence number from where to peek the + /// message. This corresponds to the . + /// An optional instance to signal the request to cancel the + /// operation. /// /// - /// The first call to fetches the first active message for this receiver. Each subsequent call fetches the subsequent message in the entity. - /// Unlike a received message, peeked message will not have a lock token associated with it, and hence it cannot be Completed/Abandoned/Deferred/Deadlettered/Renewed. - /// Also, unlike , this method will fetch even Deferred messages (but not Deadlettered message). + /// The first call to fetches the first active message for this receiver. Each subsequent call fetches the subsequent message in the entity. + /// Unlike a received message, a peeked message will not have a lock token associated with it, and hence it cannot be Completed/Abandoned/Deferred/Deadlettered/Renewed. + /// Also, unlike , this method will fetch even Deferred messages (but not Deadlettered message). /// /// /// The that represents the next message to be read. Returns null when nothing to peek. - public virtual async Task PeekAsync(CancellationToken cancellationToken = default) - { - IEnumerable result = await PeekBatchAtInternalAsync( - sequenceNumber: null, - maxMessages: 1, - cancellationToken: cancellationToken) - .ConfigureAwait(false); - - foreach (ServiceBusReceivedMessage message in result) - { - return message; - } - return null; - } - - /// - /// Fetch the next message without changing the state of the receiver or the message source. - /// - /// - /// The sequence number from where to peek the message. - /// An optional instance to signal the request to cancel the operation. - /// - /// - public virtual async Task PeekAtAsync( - long sequenceNumber, + public virtual async Task PeekMessageAsync( + long? fromSequenceNumber = default, CancellationToken cancellationToken = default) { - IEnumerable result = await PeekBatchAtAsync( - sequenceNumber: sequenceNumber, + IEnumerable result = await PeekMessagesInternalAsync( + sequenceNumber: fromSequenceNumber, maxMessages: 1, cancellationToken: cancellationToken) .ConfigureAwait(false); @@ -286,54 +270,38 @@ public virtual async Task PeekAtAsync( return null; } - /// - /// Fetches the next batch of active messages without changing the state of the receiver or the message source. - /// + /// Fetches a list of active messages without changing the state of the receiver or the message source. /// /// The maximum number of messages that will be fetched. - /// An optional instance to signal the request to cancel the operation. + /// An optional sequence number from where to peek the + /// message. This corresponds to the . + /// An optional instance to signal the request to cancel + /// the operation. /// /// - /// The first call to fetches the first active message for this receiver. Each subsequent call - /// fetches the subsequent message in the entity. - /// Unlike a received message, peeked message will not have lock token associated with it, and hence it cannot be Completed/Abandoned/Deferred/Deadlettered/Renewed. - /// Also, unlike , this method will fetch even Deferred messages (but not Deadlettered messages). + /// Unlike a received message, a peeked message will not have a lock token associated with it, and hence it cannot be + /// Completed/Abandoned/Deferred/Deadlettered/Renewed. + /// Also, unlike , this method will fetch even Deferred messages (but not Deadlettered messages). /// /// /// An of messages that were peeked. - public virtual async Task> PeekBatchAsync( + public virtual async Task> PeekMessagesAsync( int maxMessages, + long? fromSequenceNumber = default, CancellationToken cancellationToken = default) => - await PeekBatchAtInternalAsync( - sequenceNumber: null, + await PeekMessagesInternalAsync( + sequenceNumber: fromSequenceNumber, maxMessages: maxMessages, cancellationToken: cancellationToken).ConfigureAwait(false); /// - /// Fetches the next batch of active messages without changing the state of the receiver or the message source. + /// Fetches a list of active messages without changing the state of the receiver or the message source. /// /// The sequence number from where to peek the message. /// The maximum number of messages that will be fetched. /// An optional instance to signal the request to cancel the operation. /// An of messages that were peeked. - public virtual async Task> PeekBatchAtAsync( - long sequenceNumber, - int maxMessages, - CancellationToken cancellationToken = default) => - await PeekBatchAtInternalAsync( - sequenceNumber: sequenceNumber, - maxMessages: maxMessages, - cancellationToken: cancellationToken) - .ConfigureAwait(false); - - /// - /// Fetches the next batch of active messages without changing the state of the receiver or the message source. - /// - /// The sequence number from where to peek the message. - /// The maximum number of messages that will be fetched. - /// An optional instance to signal the request to cancel the operation. - /// An of messages that were peeked. - private async Task> PeekBatchAtInternalAsync( + private async Task> PeekMessagesInternalAsync( long? sequenceNumber, int maxMessages, CancellationToken cancellationToken) @@ -349,7 +317,7 @@ private async Task> PeekBatchAtInternalAsync( IList messages = new List(); try { - messages = await InnerReceiver.PeekBatchAtAsync( + messages = await InnerReceiver.PeekMessagesAsync( sequenceNumber, maxMessages, cancellationToken) @@ -389,12 +357,12 @@ internal async Task OpenLinkAsync(CancellationToken cancellationToken) => /// /// /// A task to be resolved on when the operation has completed. - public virtual async Task CompleteAsync( + public virtual async Task CompleteMessageAsync( ServiceBusReceivedMessage message, CancellationToken cancellationToken = default) { Argument.AssertNotNull(message, nameof(message)); - await CompleteAsync(message.LockToken, cancellationToken).ConfigureAwait(false); + await CompleteMessageAsync(message.LockToken, cancellationToken).ConfigureAwait(false); } /// @@ -410,7 +378,7 @@ public virtual async Task CompleteAsync( /// /// /// A task to be resolved on when the operation has completed. - public virtual async Task CompleteAsync( + public virtual async Task CompleteMessageAsync( string lockToken, CancellationToken cancellationToken = default) { @@ -459,13 +427,13 @@ await InnerReceiver.CompleteAsync( /// /// /// A task to be resolved on when the operation has completed. - public virtual async Task AbandonAsync( + public virtual async Task AbandonMessageAsync( ServiceBusReceivedMessage message, IDictionary propertiesToModify = null, CancellationToken cancellationToken = default) { Argument.AssertNotNull(message, nameof(message)); - await AbandonAsync( + await AbandonMessageAsync( message.LockToken, propertiesToModify, cancellationToken).ConfigureAwait(false); @@ -486,7 +454,7 @@ await AbandonAsync( /// /// /// A task to be resolved on when the operation has completed. - public virtual async Task AbandonAsync( + public virtual async Task AbandonMessageAsync( string lockToken, IDictionary propertiesToModify = null, CancellationToken cancellationToken = default) @@ -533,13 +501,13 @@ await InnerReceiver.AbandonAsync( /// to create a receiver for the queue or subscription. /// This operation can only be performed when is set to . /// - public virtual async Task DeadLetterAsync( + public virtual async Task DeadLetterMessageAsync( ServiceBusReceivedMessage message, IDictionary propertiesToModify = null, CancellationToken cancellationToken = default) { Argument.AssertNotNull(message, nameof(message)); - await DeadLetterAsync( + await DeadLetterMessageAsync( lockToken: message.LockToken, propertiesToModify: propertiesToModify, cancellationToken: cancellationToken).ConfigureAwait(false); @@ -560,7 +528,7 @@ await DeadLetterAsync( /// to create a receiver for the queue or subscription. /// This operation can only be performed when is set to . /// - public virtual async Task DeadLetterAsync( + public virtual async Task DeadLetterMessageAsync( string lockToken, IDictionary propertiesToModify = null, CancellationToken cancellationToken = default) => @@ -585,14 +553,14 @@ await DeadLetterInternalAsync( /// You can use EntityNameHelper.FormatDeadLetterPath(string) to help with this. /// This operation can only be performed on messages that were received by this receiver. /// - public virtual async Task DeadLetterAsync( + public virtual async Task DeadLetterMessageAsync( ServiceBusReceivedMessage message, string deadLetterReason, string deadLetterErrorDescription = default, CancellationToken cancellationToken = default) { Argument.AssertNotNull(message, nameof(message)); - await DeadLetterAsync( + await DeadLetterMessageAsync( lockToken: message.LockToken, deadLetterReason: deadLetterReason, deadLetterErrorDescription: deadLetterErrorDescription, @@ -615,7 +583,7 @@ await DeadLetterAsync( /// You can use EntityNameHelper.FormatDeadLetterPath(string) to help with this. /// This operation can only be performed on messages that were received by this receiver. /// - public virtual async Task DeadLetterAsync( + public virtual async Task DeadLetterMessageAsync( string lockToken, string deadLetterReason, string deadLetterErrorDescription = null, @@ -688,20 +656,21 @@ await InnerReceiver.DeadLetterAsync( /// /// A lock token can be found in , /// only when is set to . - /// In order to receive this message again in the future, you will need to save the + /// In order to receive this message again in the future, you will need to save the + /// /// and receive it using . /// Deferring messages does not impact message's expiration, meaning that deferred messages can still expire. /// This operation can only be performed on messages that were received by this receiver. /// /// /// A task to be resolved on when the operation has completed. - public virtual async Task DeferAsync( + public virtual async Task DeferMessageAsync( ServiceBusReceivedMessage message, IDictionary propertiesToModify = null, CancellationToken cancellationToken = default) { Argument.AssertNotNull(message, nameof(message)); - await DeferAsync( + await DeferMessageAsync( message.LockToken, propertiesToModify, cancellationToken).ConfigureAwait(false); @@ -716,14 +685,15 @@ await DeferAsync( /// /// A lock token can be found in , /// only when is set to . - /// In order to receive this message again in the future, you will need to save the + /// In order to receive this message again in the future, you will need to save the + /// /// and receive it using . /// Deferring messages does not impact message's expiration, meaning that deferred messages can still expire. /// This operation can only be performed on messages that were received by this receiver. /// /// /// A task to be resolved on when the operation has completed. - public virtual async Task DeferAsync( + public virtual async Task DeferMessageAsync( string lockToken, IDictionary propertiesToModify = null, CancellationToken cancellationToken = default) @@ -778,40 +748,34 @@ private static void ThrowIfLockTokenIsEmpty(string lockToken) } /// - /// Receives a specific deferred message identified by . + /// Receives a deferred message identified by . /// /// - /// The sequence number of the message that will be received. + /// The sequence number of the message to receive. This corresponds to + /// the . /// An optional instance to signal the request to cancel the operation. /// - /// Message identified by sequence number . Returns null if no such message is found. + /// The deferred message identified by the specified sequence number. Returns null if no message is found. /// Throws if the message has not been deferred. - /// - /// + /// + /// public virtual async Task ReceiveDeferredMessageAsync( long sequenceNumber, - CancellationToken cancellationToken = default) - { - IEnumerable result = await ReceiveDeferredMessageBatchAsync(sequenceNumbers: new long[] { sequenceNumber }).ConfigureAwait(false); - foreach (ServiceBusReceivedMessage message in result) - { - return message; - } - return null; - } + CancellationToken cancellationToken = default) => + (await ReceiveDeferredMessagesAsync(new long[] { sequenceNumber }, cancellationToken).ConfigureAwait(false))[0]; /// - /// Receives a of deferred messages identified by . + /// Receives a of deferred messages identified by . /// /// - /// An containing the sequence numbers to receive. /// An optional instance to signal the request to cancel the operation. + /// An containing the sequence numbers to receive. /// /// Messages identified by sequence number are returned. Returns null if no messages are found. /// Throws if the messages have not been deferred. - /// - /// - public virtual async Task> ReceiveDeferredMessageBatchAsync( + /// + /// + public virtual async Task> ReceiveDeferredMessagesAsync( IEnumerable sequenceNumbers, CancellationToken cancellationToken = default) { @@ -820,7 +784,7 @@ public virtual async Task> ReceiveDeferredMessa cancellationToken.ThrowIfCancellationRequested(); var sequenceNumbersList = sequenceNumbers.ToList(); - Logger.ReceiveDeferredMessageStart(Identifier, sequenceNumbersList.Count, sequenceNumbersList); + Logger.ReceiveDeferredMessageStart(Identifier, sequenceNumbersList); using DiagnosticScope scope = _scopeFactory.CreateScope(DiagnosticProperty.ReceiveDeferredActivityName); scope.AddAttribute( DiagnosticProperty.SequenceNumbersAttribute, @@ -830,7 +794,7 @@ public virtual async Task> ReceiveDeferredMessa IList deferredMessages = null; try { - deferredMessages = await InnerReceiver.ReceiveDeferredMessageBatchAsync( + deferredMessages = await InnerReceiver.ReceiveDeferredMessagesAsync( sequenceNumbersList, cancellationToken).ConfigureAwait(false); } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/CreateBatchOptions.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/CreateMessageBatchOptions.cs similarity index 90% rename from sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/CreateBatchOptions.cs rename to sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/CreateMessageBatchOptions.cs index c0784d726bcc..41d1871e9fe7 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/CreateBatchOptions.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/CreateMessageBatchOptions.cs @@ -12,7 +12,7 @@ namespace Azure.Messaging.ServiceBus /// behaves and is sent to the Queue/Topic. /// /// - public class CreateBatchOptions + public class CreateMessageBatchOptions { /// The requested maximum size to allow for the batch, in bytes. private long? _maxSizeInBytes = null; @@ -71,13 +71,13 @@ public long? MaxSizeInBytes public override string ToString() => base.ToString(); /// - /// Creates a new copy of the current , cloning its attributes into a new instance. + /// Creates a new copy of the current , cloning its attributes into a new instance. /// /// - /// A new copy of . + /// A new copy of . /// - internal CreateBatchOptions Clone() => - new CreateBatchOptions + internal CreateMessageBatchOptions Clone() => + new CreateMessageBatchOptions { _maxSizeInBytes = MaxSizeInBytes }; diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/ServiceBusMessageBatch.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/ServiceBusMessageBatch.cs index b54c5232fa63..44631ebc0869 100755 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/ServiceBusMessageBatch.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/ServiceBusMessageBatch.cs @@ -12,8 +12,8 @@ namespace Azure.Messaging.ServiceBus /// A set of with size constraints known up-front, /// intended to be sent to the Queue/Topic as a single batch. /// A can be created using - /// . - /// Messages can be added to the batch using the method on the batch. + /// . + /// Messages can be added to the batch using the method on the batch. /// /// public sealed class ServiceBusMessageBatch : IDisposable @@ -80,12 +80,12 @@ internal ServiceBusMessageBatch(TransportMessageBatch transportBatch) /// /// true if the message was added; otherwise, false. /// - public bool TryAdd(ServiceBusMessage message) + public bool TryAddMessage(ServiceBusMessage message) { lock (_syncGuard) { AssertNotLocked(); - return InnerBatch.TryAdd(message); + return InnerBatch.TryAddMessage(message); } } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/ServiceBusSender.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/ServiceBusSender.cs index fb388e529e1c..00fed9ac9cd9 100755 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/ServiceBusSender.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/src/Sender/ServiceBusSender.cs @@ -142,18 +142,18 @@ protected ServiceBusSender() /// /// Sends a message to the associated entity of Service Bus. /// + /// /// - /// A messsage to send. /// An optional instance to signal the request to cancel the operation. /// /// A task to be resolved on when the operation has completed. /// - public virtual async Task SendAsync( + public virtual async Task SendMessageAsync( ServiceBusMessage message, CancellationToken cancellationToken = default) { Argument.AssertNotNull(message, nameof(message)); - await SendAsync( + await SendMessagesAsync( new ServiceBusMessage[] { message }, cancellationToken).ConfigureAwait(false); } @@ -162,7 +162,7 @@ await SendAsync( /// Sends a set of messages to the associated Service Bus entity using a batched approach. /// If the size of the messages exceed the maximum size of a single batch, /// an exception will be triggered and the send will fail. In order to ensure that the messages - /// being sent will fit in a batch, use instead. + /// being sent will fit in a batch, use instead. /// /// /// The set of messages to send. @@ -170,7 +170,7 @@ await SendAsync( /// /// A task to be resolved on when the operation has completed. /// - public virtual async Task SendAsync( + public virtual async Task SendMessagesAsync( IEnumerable messages, CancellationToken cancellationToken = default) { @@ -245,7 +245,7 @@ private void InstrumentMessages(IEnumerable messages) /// /// Creates a size-constraint batch to which may be added using - /// a . If a message would exceed the maximum + /// a . If a message would exceed the maximum /// allowable size of the batch, the batch will not allow adding the message and signal that /// scenario using it return value. /// @@ -257,9 +257,9 @@ private void InstrumentMessages(IEnumerable messages) /// /// An with the default batch options. /// - /// + /// /// - public virtual ValueTask CreateBatchAsync(CancellationToken cancellationToken = default) => CreateBatchAsync(null, cancellationToken); + public virtual ValueTask CreateMessageBatchAsync(CancellationToken cancellationToken = default) => CreateMessageBatchAsync(null, cancellationToken); /// /// Creates a size-constraint batch to which may be added using a try-based pattern. If a message would @@ -275,20 +275,20 @@ private void InstrumentMessages(IEnumerable messages) /// /// An with the requested . /// - /// + /// /// - public virtual async ValueTask CreateBatchAsync( - CreateBatchOptions options, + public virtual async ValueTask CreateMessageBatchAsync( + CreateMessageBatchOptions options, CancellationToken cancellationToken = default) { Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusSender)); - options = options?.Clone() ?? new CreateBatchOptions(); + options = options?.Clone() ?? new CreateMessageBatchOptions(); cancellationToken.ThrowIfCancellationRequested(); Logger.CreateMessageBatchStart(Identifier); ServiceBusMessageBatch batch; try { - TransportMessageBatch transportBatch = await _innerSender.CreateBatchAsync(options, cancellationToken).ConfigureAwait(false); + TransportMessageBatch transportBatch = await _innerSender.CreateMessageBatchAsync(options, cancellationToken).ConfigureAwait(false); batch = new ServiceBusMessageBatch(transportBatch); } catch (Exception ex) @@ -307,11 +307,11 @@ public virtual async ValueTask CreateBatchAsync( /// the associated Service Bus entity. /// /// - /// The batch of messages to send. A batch may be created using . + /// The batch of messages to send. A batch may be created using . /// An optional instance to signal the request to cancel the operation. /// A task to be resolved on when the operation has completed. /// - public virtual async Task SendAsync( + public virtual async Task SendMessagesAsync( ServiceBusMessageBatch messageBatch, CancellationToken cancellationToken = default) { @@ -348,11 +348,16 @@ public virtual async Task SendAsync( /// Schedules a message to appear on Service Bus at a later time. /// /// - /// The message to schedule. + /// The to schedule. /// The UTC time at which the message should be available for processing /// An optional instance to signal the request to cancel the operation. /// - /// Although the message will not be available to be received until the scheduledEnqueueTime, it can still be peeked before that time. + /// Although the message will not be available to be received until the scheduledEnqueueTime, it can still be peeked before that time. + /// Messages can also be scheduled by setting and + /// using , + /// , or + /// . + /// /// The sequence number of the message that was scheduled. public virtual async Task ScheduleMessageAsync( ServiceBusMessage message, @@ -360,31 +365,73 @@ public virtual async Task ScheduleMessageAsync( CancellationToken cancellationToken = default) { Argument.AssertNotNull(message, nameof(message)); + long[] sequenceNumbers = await ScheduleMessagesAsync( + new ServiceBusMessage[] { message }, + scheduledEnqueueTime, + cancellationToken) + .ConfigureAwait(false); + // if there isn't one sequence number in the array, an + // exception should have been thrown by this point. + return sequenceNumbers[0]; + } + + + + /// + /// Schedules a set of messages to appear on Service Bus at a later time. + /// + /// + /// The set of messages to schedule. + /// The UTC time at which the message should be available for processing + /// An optional instance to signal the request to cancel the operation. + /// + /// Although the message will not be available to be received until the scheduledEnqueueTime, it can still be peeked before that time. + /// Messages can also be scheduled by setting and + /// using , + /// , or + /// . + /// + /// The sequence number of the message that was scheduled. + public virtual async Task ScheduleMessagesAsync( + IEnumerable messages, + DateTimeOffset scheduledEnqueueTime, + CancellationToken cancellationToken = default) + { + Argument.AssertNotNullOrEmpty(messages, nameof(messages)); Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusSender)); cancellationToken.ThrowIfCancellationRequested(); - Logger.ScheduleMessageStart(Identifier, scheduledEnqueueTime.ToString(CultureInfo.InvariantCulture)); + var messageList = messages.ToList(); + + Logger.ScheduleMessagesStart( + Identifier, + messageList.Count, + scheduledEnqueueTime.ToString(CultureInfo.InvariantCulture)); + using DiagnosticScope scope = CreateDiagnosticScope( - new ServiceBusMessage[] { message }, + messages, DiagnosticProperty.ScheduleActivityName); scope.Start(); - long sequenceNumber; + long[] sequenceNumbers = null; try { - message.ScheduledEnqueueTime = scheduledEnqueueTime.UtcDateTime; - sequenceNumber = await _innerSender.ScheduleMessageAsync(message, cancellationToken).ConfigureAwait(false); + foreach (ServiceBusMessage message in messageList) + { + message.ScheduledEnqueueTime = scheduledEnqueueTime.UtcDateTime; + } + sequenceNumbers = await _innerSender.ScheduleMessagesAsync(messageList, cancellationToken).ConfigureAwait(false); } catch (Exception exception) { - Logger.ScheduleMessageException(Identifier, exception.ToString()); + Logger.ScheduleMessagesException(Identifier, exception.ToString()); scope.Failed(exception); throw; } cancellationToken.ThrowIfCancellationRequested(); - Logger.ScheduleMessageComplete(Identifier); - scope.AddAttribute(DiagnosticProperty.SequenceNumbersAttribute, sequenceNumber); - return sequenceNumber; + Logger.ScheduleMessagesComplete(Identifier); + scope.AddAttribute(DiagnosticProperty.SequenceNumbersAttribute, sequenceNumbers); + return sequenceNumbers; } /// @@ -394,29 +441,43 @@ public virtual async Task ScheduleMessageAsync( /// An optional instance to signal the request to cancel the operation. public virtual async Task CancelScheduledMessageAsync( long sequenceNumber, + CancellationToken cancellationToken = default) => + await CancelScheduledMessagesAsync( + new long[] { sequenceNumber }, + cancellationToken) + .ConfigureAwait(false); + + /// + /// Cancels a set of messages that were scheduled. + /// + /// The set of of the messages to be cancelled. + /// An optional instance to signal the request to cancel the operation. + public virtual async Task CancelScheduledMessagesAsync( + IEnumerable sequenceNumbers, CancellationToken cancellationToken = default) { Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusSender)); cancellationToken.ThrowIfCancellationRequested(); - Logger.CancelScheduledMessageStart(Identifier, sequenceNumber); + var sequenceNumberList = sequenceNumbers.ToArray(); + Logger.CancelScheduledMessagesStart(Identifier, sequenceNumberList); using DiagnosticScope scope = _scopeFactory.CreateScope( DiagnosticProperty.CancelActivityName, DiagnosticProperty.ClientKind); - scope.AddAttribute(DiagnosticProperty.SequenceNumbersAttribute, sequenceNumber); + scope.AddAttribute(DiagnosticProperty.SequenceNumbersAttribute, sequenceNumbers); scope.Start(); try { - await _innerSender.CancelScheduledMessageAsync(sequenceNumber, cancellationToken).ConfigureAwait(false); + await _innerSender.CancelScheduledMessagesAsync(sequenceNumberList, cancellationToken).ConfigureAwait(false); } catch (Exception ex) { - Logger.CancelScheduledMessageException(Identifier, ex.ToString()); + Logger.CancelScheduledMessagesException(Identifier, ex.ToString()); throw; } cancellationToken.ThrowIfCancellationRequested(); - Logger.CancelScheduledMessageComplete(Identifier); + Logger.CancelScheduledMessagesComplete(Identifier); } /// diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Amqp/AmqpMessageBatchTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Amqp/AmqpMessageBatchTests.cs index 1f10da89a56f..e4f3ac6f3c59 100755 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Amqp/AmqpMessageBatchTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Amqp/AmqpMessageBatchTests.cs @@ -36,7 +36,7 @@ public void ConstructorValidatesTheOptions() [Test] public void ConstructorValidatesTheMaximumSize() { - Assert.That(() => new AmqpMessageBatch(new CreateBatchOptions { MaxSizeInBytes = null }), Throws.ArgumentNullException); + Assert.That(() => new AmqpMessageBatch(new CreateMessageBatchOptions { MaxSizeInBytes = null }), Throws.ArgumentNullException); } /// @@ -47,40 +47,40 @@ public void ConstructorValidatesTheMaximumSize() public void ConstructorSetsTheMaximumSize() { var maximumSize = 9943; - var options = new CreateBatchOptions { MaxSizeInBytes = maximumSize }; + var options = new CreateMessageBatchOptions { MaxSizeInBytes = maximumSize }; var batch = new AmqpMessageBatch(options); Assert.That(batch.MaxSizeInBytes, Is.EqualTo(maximumSize)); } /// - /// Verifies functionality of the + /// Verifies functionality of the /// method. /// /// [Test] public void TryAddValidatesTheMessage() { - var batch = new AmqpMessageBatch(new CreateBatchOptions { MaxSizeInBytes = 25 }); - Assert.That(() => batch.TryAdd(null), Throws.ArgumentNullException); + var batch = new AmqpMessageBatch(new CreateMessageBatchOptions { MaxSizeInBytes = 25 }); + Assert.That(() => batch.TryAddMessage(null), Throws.ArgumentNullException); } /// - /// Verifies functionality of the + /// Verifies functionality of the /// method. /// /// [Test] public void TryAddValidatesNotDisposed() { - var batch = new AmqpMessageBatch(new CreateBatchOptions { MaxSizeInBytes = 25 }); + var batch = new AmqpMessageBatch(new CreateMessageBatchOptions { MaxSizeInBytes = 25 }); batch.Dispose(); - Assert.That(() => batch.TryAdd(new ServiceBusMessage(new byte[0])), Throws.InstanceOf()); + Assert.That(() => batch.TryAddMessage(new ServiceBusMessage(new byte[0])), Throws.InstanceOf()); } /// - /// Verifies functionality of the + /// Verifies functionality of the /// method. /// /// @@ -88,14 +88,14 @@ public void TryAddValidatesNotDisposed() public void TryAddDoesNotAcceptAMessageBiggerThanTheMaximumSize() { var maximumSize = 50; - var options = new CreateBatchOptions { MaxSizeInBytes = maximumSize }; + var options = new CreateMessageBatchOptions { MaxSizeInBytes = maximumSize }; var batch = new AmqpMessageBatch(options); - Assert.That(batch.TryAdd(new ServiceBusMessage(new byte[50])), Is.False, "A message of the maximum size is too large due to the reserved overhead."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(new byte[50])), Is.False, "A message of the maximum size is too large due to the reserved overhead."); } /// - /// Verifies functionality of the + /// Verifies functionality of the /// method. /// /// @@ -103,15 +103,15 @@ public void TryAddDoesNotAcceptAMessageBiggerThanTheMaximumSize() public void TryAddAcceptsAMessageSmallerThanTheMaximumSize() { var maximumSize = 50; - var options = new CreateBatchOptions { MaxSizeInBytes = maximumSize }; + var options = new CreateMessageBatchOptions { MaxSizeInBytes = maximumSize }; var batch = new AmqpMessageBatch(options); - Assert.That(batch.TryAdd(new ServiceBusMessage(new byte[0])), Is.True); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(new byte[0])), Is.True); } /// - /// Verifies functionality of the + /// Verifies functionality of the /// method. /// /// @@ -119,7 +119,7 @@ public void TryAddAcceptsAMessageSmallerThanTheMaximumSize() public void TryAddAcceptMessagesUntilTheMaximumSizeIsReached() { var maximumSize = 100; - var options = new CreateBatchOptions { MaxSizeInBytes = maximumSize }; + var options = new CreateMessageBatchOptions { MaxSizeInBytes = maximumSize }; var messages = new AmqpMessage[3]; var batch = new AmqpMessageBatch(options); @@ -128,24 +128,24 @@ public void TryAddAcceptMessagesUntilTheMaximumSizeIsReached() { if (index == messages.Length - 1) { - Assert.That(batch.TryAdd(new ServiceBusMessage(new byte[10])), Is.False, "The final addition should not fit in the available space."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(new byte[10])), Is.False, "The final addition should not fit in the available space."); } else { - Assert.That(batch.TryAdd(new ServiceBusMessage(new byte[10])), Is.True, $"The addition for index: { index } should fit and be accepted."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(new byte[10])), Is.True, $"The addition for index: { index } should fit and be accepted."); } } } /// - /// Verifies functionality of the + /// Verifies functionality of the /// method. /// /// [Test] public void TryAddSetsTheCount() { - var options = new CreateBatchOptions { MaxSizeInBytes = 5000 }; + var options = new CreateMessageBatchOptions { MaxSizeInBytes = 5000 }; var messages = new AmqpMessage[5]; for (var index = 0; index < messages.Length; ++index) @@ -159,7 +159,7 @@ public void TryAddSetsTheCount() for (var index = 0; index < messages.Length; ++index) { - Assert.That(batch.TryAdd(new ServiceBusMessage(new byte[0])), Is.True, $"The addition for index: { index } should fit and be accepted."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(new byte[0])), Is.True, $"The addition for index: { index } should fit and be accepted."); } Assert.That(batch.Count, Is.EqualTo(messages.Length), "The count should have been set when the batch was updated."); @@ -173,7 +173,7 @@ public void TryAddSetsTheCount() [Test] public void AsEnumerableValidatesTheTypeParameter() { - var options = new CreateBatchOptions { MaxSizeInBytes = 5000 }; + var options = new CreateMessageBatchOptions { MaxSizeInBytes = 5000 }; var batch = new AmqpMessageBatch(options); Assert.That(() => batch.AsEnumerable(), Throws.InstanceOf()); @@ -188,7 +188,7 @@ public void AsEnumerableValidatesTheTypeParameter() public void AsEnumerableReturnsTheMessages() { var maximumSize = 5000; - var options = new CreateBatchOptions { MaxSizeInBytes = maximumSize }; + var options = new CreateMessageBatchOptions { MaxSizeInBytes = maximumSize }; var batchMessages = new ServiceBusMessage[5]; var batch = new AmqpMessageBatch(options); @@ -196,7 +196,7 @@ public void AsEnumerableReturnsTheMessages() for (var index = 0; index < batchMessages.Length; ++index) { batchMessages[index] = new ServiceBusMessage(new byte[0]); - batch.TryAdd(batchMessages[index]); + batch.TryAddMessage(batchMessages[index]); } IEnumerable batchEnumerable = batch.AsEnumerable(); @@ -219,7 +219,7 @@ public void AsEnumerableReturnsTheMessages() [Test] public void ClearClearsTheCount() { - var options = new CreateBatchOptions { MaxSizeInBytes = 5000 }; + var options = new CreateMessageBatchOptions { MaxSizeInBytes = 5000 }; var messages = new AmqpMessage[5]; for (var index = 0; index < messages.Length; ++index) @@ -233,7 +233,7 @@ public void ClearClearsTheCount() for (var index = 0; index < messages.Length; ++index) { - Assert.That(batch.TryAdd(new ServiceBusMessage(new byte[0])), Is.True, $"The addition for index: { index } should fit and be accepted."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(new byte[0])), Is.True, $"The addition for index: { index } should fit and be accepted."); } Assert.That(batch.Count, Is.EqualTo(messages.Length), "The count should have been set when the batch was updated."); @@ -250,7 +250,7 @@ public void ClearClearsTheCount() [Test] public void ClearClearsTheSize() { - var options = new CreateBatchOptions { MaxSizeInBytes = 5000 }; + var options = new CreateMessageBatchOptions { MaxSizeInBytes = 5000 }; var messages = new AmqpMessage[5]; for (var index = 0; index < messages.Length; ++index) @@ -264,7 +264,7 @@ public void ClearClearsTheSize() for (var index = 0; index < messages.Length; ++index) { - Assert.That(batch.TryAdd(new ServiceBusMessage(new byte[0])), Is.True, $"The addition for index: { index } should fit and be accepted."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(new byte[0])), Is.True, $"The addition for index: { index } should fit and be accepted."); } Assert.That(batch.SizeInBytes, Is.GreaterThan(0), "The size should have been set when the batch was updated."); @@ -281,7 +281,7 @@ public void ClearClearsTheSize() [Test] public void DisposeClearsTheCount() { - var options = new CreateBatchOptions { MaxSizeInBytes = 5000 }; + var options = new CreateMessageBatchOptions { MaxSizeInBytes = 5000 }; var messages = new AmqpMessage[5]; for (var index = 0; index < messages.Length; ++index) @@ -295,7 +295,7 @@ public void DisposeClearsTheCount() for (var index = 0; index < messages.Length; ++index) { - Assert.That(batch.TryAdd(new ServiceBusMessage(new byte[0])), Is.True, $"The addition for index: { index } should fit and be accepted."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(new byte[0])), Is.True, $"The addition for index: { index } should fit and be accepted."); } Assert.That(batch.Count, Is.EqualTo(messages.Length), "The count should have been set when the batch was updated."); @@ -312,7 +312,7 @@ public void DisposeClearsTheCount() [Test] public void DisposeClearsTheSize() { - var options = new CreateBatchOptions { MaxSizeInBytes = 5000 }; + var options = new CreateMessageBatchOptions { MaxSizeInBytes = 5000 }; var messages = new AmqpMessage[5]; for (var index = 0; index < messages.Length; ++index) @@ -326,7 +326,7 @@ public void DisposeClearsTheSize() for (var index = 0; index < messages.Length; ++index) { - Assert.That(batch.TryAdd(new ServiceBusMessage(new byte[0])), Is.True, $"The addition for index: { index } should fit and be accepted."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(new byte[0])), Is.True, $"The addition for index: { index } should fit and be accepted."); } Assert.That(batch.SizeInBytes, Is.GreaterThan(0), "The size should have been set when the batch was updated."); diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Amqp/AmqpReceiverTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Amqp/AmqpReceiverTests.cs index 05631822566f..6ad090d02b2c 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Amqp/AmqpReceiverTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Amqp/AmqpReceiverTests.cs @@ -122,7 +122,7 @@ public void ReceiveAsyncRespectsTheCancellationTokenIfSetWhenCalled() AmqpReceiver receiver = CreateReceiver(); - Assert.That(async () => await receiver.ReceiveBatchAsync( + Assert.That(async () => await receiver.ReceiveMessagesAsync( 100, default, cancellationSource.Token), Throws.InstanceOf()); @@ -166,7 +166,7 @@ public void ReceiveAsyncAppliesTheRetryPolicy(ServiceBusRetryOptions retryOption .Throws(retriableException); var receiver = new AmqpReceiver(entityName, ReceiveMode.PeekLock, prefetchCount, mockScope.Object, retryPolicy, "someIdentifier", sessionId, isSession); - Assert.That(async () => await receiver.ReceiveBatchAsync( + Assert.That(async () => await receiver.ReceiveMessagesAsync( 100, default, cancellationSource.Token), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.GeneralError)); @@ -220,7 +220,7 @@ public void ReceiveAsyncConsidersOperationCanceledExceptionAsRetriable(ServiceBu .Throws(retriableException); var receiver = new AmqpReceiver(entityName, ReceiveMode.PeekLock, prefetchCount, mockScope.Object, retryPolicy, "someIdentifier", sessionId, isSession); - Assert.That(async () => await receiver.ReceiveBatchAsync( + Assert.That(async () => await receiver.ReceiveMessagesAsync( 100, default, cancellationSource.Token), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.ServiceTimeout)); @@ -283,7 +283,7 @@ public void ReceiveAsyncAppliesTheRetryPolicyForAmqpErrors(ServiceBusRetryOption var receiver = new AmqpReceiver(entityName, ReceiveMode.PeekLock, prefetchCount, mockScope.Object, retryPolicy, "someIdentifier", sessionId, isSession); - Assert.That(async () => await receiver.ReceiveBatchAsync( + Assert.That(async () => await receiver.ReceiveMessagesAsync( 100, default, cancellationSource.Token), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.ServiceBusy)); @@ -340,7 +340,7 @@ public void ReceiveAsyncDetectsAnEmbeddedErrorForOperationCanceled() .Throws(exception); var receiver = new AmqpReceiver(entityName, ReceiveMode.PeekLock, prefetchCount, mockScope.Object, retryPolicy, "someIdentifier", sessionId, isSession); - Assert.That(async () => await receiver.ReceiveBatchAsync( + Assert.That(async () => await receiver.ReceiveMessagesAsync( 100, default, cancellationSource.Token), Throws.InstanceOf()); @@ -394,7 +394,7 @@ public void ReceiveAsyncDetectsAnEmbeddedAmqpErrorForOperationCanceled() .Throws(exception); var receiver = new AmqpReceiver(entityName, ReceiveMode.PeekLock, prefetchCount, mockScope.Object, retryPolicy, "someIdentifier", sessionId, isSession); - Assert.That(async () => await receiver.ReceiveBatchAsync( + Assert.That(async () => await receiver.ReceiveMessagesAsync( 100, default, cancellationSource.Token), Throws.InstanceOf()); @@ -447,7 +447,7 @@ public void ReceiveAsyncDoesntRetryOnTaskCanceled() .Throws(exception); var receiver = new AmqpReceiver(entityName, ReceiveMode.PeekLock, prefetchCount, mockScope.Object, retryPolicy, "someIdentifier", sessionId, isSession); - Assert.That(async () => await receiver.ReceiveBatchAsync( + Assert.That(async () => await receiver.ReceiveMessagesAsync( 100, default, cancellationSource.Token), Throws.InstanceOf()); diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Client/ServiceBusClientLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Client/ServiceBusClientLiveTests.cs index e89a16c13b9c..9c1ada3a6bba 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Client/ServiceBusClientLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Client/ServiceBusClientLiveTests.cs @@ -23,7 +23,7 @@ public async Task GetChildClientFromClosedParentClientThrows(bool useSessions) var sender = client.CreateSender(scope.QueueName); var message = GetMessage(useSessions ? "sessionId" : null); - await sender.SendAsync(message); + await sender.SendMessageAsync(message); await sender.DisposeAsync(); ServiceBusReceiver receiver; if (!useSessions) @@ -34,7 +34,7 @@ public async Task GetChildClientFromClosedParentClientThrows(bool useSessions) { receiver = await client.CreateSessionReceiverAsync(scope.QueueName); } - var receivedMessage = await receiver.ReceiveAsync().ConfigureAwait(false); + var receivedMessage = await receiver.ReceiveMessageAsync().ConfigureAwait(false); Assert.AreEqual(message.Body.ToString(), receivedMessage.Body.ToString()); await client.DisposeAsync(); @@ -67,7 +67,7 @@ public async Task GetChildClientFromParentSucceedsOnOpenConnection(bool useSessi var sender = client.CreateSender(scope.QueueName); var message = GetMessage(useSessions ? "sessionId" : null); - await sender.SendAsync(message); + await sender.SendMessageAsync(message); await sender.DisposeAsync(); ServiceBusReceiver receiver; if (!useSessions) @@ -78,7 +78,7 @@ public async Task GetChildClientFromParentSucceedsOnOpenConnection(bool useSessi { receiver = await client.CreateSessionReceiverAsync(scope.QueueName); } - var receivedMessage = await receiver.ReceiveAsync().ConfigureAwait(false); + var receivedMessage = await receiver.ReceiveMessageAsync().ConfigureAwait(false); Assert.AreEqual(message.Body.ToString(), receivedMessage.Body.ToString()); if (!useSessions) diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/DiagnosticScopeLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/DiagnosticScopeLiveTests.cs index a3157b43731d..5b359b9b3740 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/DiagnosticScopeLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/DiagnosticScopeLiveTests.cs @@ -33,7 +33,7 @@ public async Task SenderReceiverActivities(bool useSessions) } int numMessages = 5; var msgs = GetMessages(numMessages, sessionId); - await sender.SendAsync(msgs); + await sender.SendMessagesAsync(msgs); Activity[] sendActivities = AssertSendActivities(useSessions, sender, msgs, listener); ServiceBusReceiver receiver = null; @@ -51,7 +51,7 @@ public async Task SenderReceiverActivities(bool useSessions) while (remaining > 0) { // loop in case we don't receive all messages in one attempt - var received = await receiver.ReceiveBatchAsync(remaining); + var received = await receiver.ReceiveMessagesAsync(remaining); receivedMsgs.AddRange(received); (string Key, object Value, DiagnosticListener) receiveStart = listener.Events.Dequeue(); Assert.AreEqual(DiagnosticProperty.ReceiveActivityName + ".Start", receiveStart.Key); @@ -91,7 +91,7 @@ public async Task SenderReceiverActivities(bool useSessions) var msgIndex = 0; var completed = receivedMsgs[msgIndex]; - await receiver.CompleteAsync(completed); + await receiver.CompleteMessageAsync(completed); (string Key, object Value, DiagnosticListener) completeStart = listener.Events.Dequeue(); Assert.AreEqual(DiagnosticProperty.CompleteActivityName + ".Start", completeStart.Key); Activity completeActivity = (Activity)completeStart.Value; @@ -101,7 +101,7 @@ public async Task SenderReceiverActivities(bool useSessions) Assert.AreEqual(DiagnosticProperty.CompleteActivityName + ".Stop", completeStop.Key); var deferred = receivedMsgs[++msgIndex]; - await receiver.DeferAsync(deferred); + await receiver.DeferMessageAsync(deferred); (string Key, object Value, DiagnosticListener) deferStart = listener.Events.Dequeue(); Assert.AreEqual(DiagnosticProperty.DeferActivityName + ".Start", deferStart.Key); Activity deferActivity = (Activity)deferStart.Value; @@ -111,7 +111,7 @@ public async Task SenderReceiverActivities(bool useSessions) Assert.AreEqual(DiagnosticProperty.DeferActivityName + ".Stop", deferStop.Key); var deadLettered = receivedMsgs[++msgIndex]; - await receiver.DeadLetterAsync(deadLettered); + await receiver.DeadLetterMessageAsync(deadLettered); (string Key, object Value, DiagnosticListener) deadLetterStart = listener.Events.Dequeue(); Assert.AreEqual(DiagnosticProperty.DeadLetterActivityName + ".Start", deadLetterStart.Key); Activity deadLetterActivity = (Activity)deadLetterStart.Value; @@ -121,7 +121,7 @@ public async Task SenderReceiverActivities(bool useSessions) Assert.AreEqual(DiagnosticProperty.DeadLetterActivityName + ".Stop", deadletterStop.Key); var abandoned = receivedMsgs[++msgIndex]; - await receiver.AbandonAsync(abandoned); + await receiver.AbandonMessageAsync(abandoned); (string Key, object Value, DiagnosticListener) abandonStart = listener.Events.Dequeue(); Assert.AreEqual(DiagnosticProperty.AbandonActivityName + ".Start", abandonStart.Key); Activity abandonActivity = (Activity)abandonStart.Value; @@ -253,12 +253,12 @@ public async Task SenderReceiverActivities(bool useSessions) } // send a batch - var batch = await sender.CreateBatchAsync(); + var batch = await sender.CreateMessageBatchAsync(); for (int i = 0; i < numMessages; i++) { - batch.TryAdd(GetMessage(sessionId)); + batch.TryAddMessage(GetMessage(sessionId)); } - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); AssertSendActivities(useSessions, sender, batch.AsEnumerable(), listener); }; } @@ -273,7 +273,7 @@ public async Task ProcessorActivities() ServiceBusSender sender = client.CreateSender(scope.QueueName); var messageCt = 2; var msgs = GetMessages(messageCt); - await sender.SendAsync(msgs); + await sender.SendMessagesAsync(msgs); Activity[] sendActivities = AssertSendActivities(false, sender, msgs, listener); ServiceBusProcessor processor = client.CreateProcessor(scope.QueueName, new ServiceBusProcessorOptions @@ -326,7 +326,7 @@ public async Task SessionProcessorActivities() ServiceBusSender sender = client.CreateSender(scope.QueueName); var messageCt = 2; var msgs = GetMessages(messageCt, "sessionId"); - await sender.SendAsync(msgs); + await sender.SendMessagesAsync(msgs); Activity[] sendActivities = AssertSendActivities(false, sender, msgs, listener); ServiceBusSessionProcessor processor = client.CreateSessionProcessor(scope.QueueName, diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceLiveTests.cs index 5fd5d12ebb77..730e0b42b317 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceLiveTests.cs @@ -42,13 +42,13 @@ public async Task LogsEvents() ServiceBusSender sender = client.CreateSender(scope.QueueName); _listener.EventsById(ServiceBusEventSource.ClientCreateStartEvent).Where(e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.FullyQualifiedNamespace) && e.Payload.Contains(sender.EntityPath)); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); _listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchStartEvent, e => e.Payload.Contains(sender.Identifier)); _listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchCompleteEvent, e => e.Payload.Contains(sender.Identifier)); IEnumerable messages = AddMessages(batch, messageCount).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); _listener.SingleEventById(ServiceBusEventSource.CreateSendLinkStartEvent, e => e.Payload.Contains(sender.Identifier)); _listener.SingleEventById(ServiceBusEventSource.CreateSendLinkCompleteEvent, e => e.Payload.Contains(sender.Identifier)); _listener.SingleEventById(ServiceBusEventSource.SendMessageStartEvent, e => e.Payload.Contains(sender.Identifier)); @@ -67,7 +67,7 @@ public async Task LogsEvents() var remainingMessages = messageCount; while (remainingMessages > 0) { - foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages)) + foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); @@ -82,7 +82,7 @@ public async Task LogsEvents() Assert.AreEqual(0, remainingMessages); messageEnum.Reset(); - foreach (var item in await receiver.PeekBatchAsync(messageCount)) + foreach (var item in await receiver.PeekMessagesAsync(messageCount)) { messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); @@ -126,13 +126,13 @@ public async Task LogsSessionEvents() ServiceBusSender sender = client.CreateSender(scope.QueueName); _listener.SingleEventById(ServiceBusEventSource.ClientCreateStartEvent, e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.FullyQualifiedNamespace) && e.Payload.Contains(sender.EntityPath)); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); _listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchStartEvent, e => e.Payload.Contains(sender.Identifier)); _listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchCompleteEvent, e => e.Payload.Contains(sender.Identifier)); IEnumerable messages = AddMessages(batch, messageCount, "sessionId").AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); _listener.SingleEventById(ServiceBusEventSource.CreateSendLinkStartEvent, e => e.Payload.Contains(sender.Identifier)); _listener.SingleEventById(ServiceBusEventSource.CreateSendLinkCompleteEvent, e => e.Payload.Contains(sender.Identifier)); _listener.SingleEventById(ServiceBusEventSource.SendMessageStartEvent, e => e.Payload.Contains(sender.Identifier)); @@ -143,7 +143,7 @@ public async Task LogsSessionEvents() // can't use a non-session receiver for session queue Assert.That( - async () => await receiver.ReceiveAsync(), + async () => await receiver.ReceiveMessageAsync(), Throws.InstanceOf()); _listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkStartEvent, e => e.Payload.Contains(receiver.Identifier)); @@ -156,10 +156,10 @@ public async Task LogsSessionEvents() _listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkStartEvent, e => e.Payload.Contains(sessionReceiver.Identifier)); _listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkCompleteEvent, e => e.Payload.Contains(sessionReceiver.Identifier)); - var msg = await sessionReceiver.ReceiveAsync(); + var msg = await sessionReceiver.ReceiveMessageAsync(); _listener.SingleEventById(ServiceBusEventSource.ReceiveMessageStartEvent, e => e.Payload.Contains(sessionReceiver.Identifier)); - msg = await sessionReceiver.PeekAsync(); + msg = await sessionReceiver.PeekMessageAsync(); _listener.SingleEventById(ServiceBusEventSource.CreateManagementLinkStartEvent, e => e.Payload.Contains(sessionReceiver.Identifier)); _listener.SingleEventById(ServiceBusEventSource.CreateManagementLinkCompleteEvent, e => e.Payload.Contains(sessionReceiver.Identifier)); _listener.SingleEventById(ServiceBusEventSource.PeekMessageStartEvent, e => e.Payload.Contains(sessionReceiver.Identifier)); @@ -196,7 +196,7 @@ public async Task LogsTransactionEvents() using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await sender.SendAsync(message); + await sender.SendMessageAsync(message); ts.Complete(); } // Adding delay since transaction Commit/Rollback is an asynchronous operation. diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceTests.cs index 52fdd6735393..e56229d3c017 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Diagnostics/EventSourceTests.cs @@ -27,7 +27,7 @@ public async Task SendSingleMessageLogsEvents() { Logger = mockLogger.Object }; - await sender.SendAsync(GetMessage()); + await sender.SendMessageAsync(GetMessage()); mockLogger .Verify( @@ -53,7 +53,7 @@ public async Task SendListOfMessageLogsEvents() { Logger = mockLogger.Object }; - await sender.SendAsync(GetMessages(5)); + await sender.SendMessagesAsync(GetMessages(5)); mockLogger .Verify( @@ -87,7 +87,7 @@ public void SendMessageExceptionLogsEvents() .Throws(new Exception()); Assert.That( - async () => await sender.SendAsync(GetMessage()), + async () => await sender.SendMessageAsync(GetMessage()), Throws.InstanceOf()); mockLogger .Verify( @@ -121,13 +121,13 @@ public async Task SendBatchOfMessagesLogsEvents() .Returns(3); mockTransportSender.Setup( - sender => sender.CreateBatchAsync( - It.IsAny(), + sender => sender.CreateMessageBatchAsync( + It.IsAny(), It.IsAny())) .Returns(new ValueTask(mockTransportBatch.Object)); - var batch = await sender.CreateBatchAsync(); - await sender.SendAsync(batch); + var batch = await sender.CreateMessageBatchAsync(); + await sender.SendMessagesAsync(batch); mockLogger .Verify( log => log.CreateMessageBatchStart( @@ -162,18 +162,25 @@ public async Task ScheduleMessageLogsEvents() { Logger = mockLogger.Object }; + mockTransportSender.Setup( + sender => sender.ScheduleMessagesAsync( + It.IsAny>(), + It.IsAny())) + .Returns(Task.FromResult(new long[] { 1 })); + var scheduleTime = DateTimeOffset.UtcNow.AddMinutes(1); await sender.ScheduleMessageAsync(GetMessage(), scheduleTime); mockLogger .Verify( - log => log.ScheduleMessageStart( + log => log.ScheduleMessagesStart( sender.Identifier, + 1, scheduleTime.ToString(CultureInfo.InvariantCulture)), Times.Once); mockLogger .Verify( - log => log.ScheduleMessageComplete( + log => log.ScheduleMessagesComplete( sender.Identifier), Times.Once); } @@ -191,8 +198,8 @@ public void ScheduleMessageExceptionLogsEvents() }; mockTransportSender.Setup( - sender => sender.ScheduleMessageAsync( - It.IsAny(), + sender => sender.ScheduleMessagesAsync( + It.IsAny>(), It.IsAny())) .Throws(new Exception()); @@ -203,13 +210,14 @@ public void ScheduleMessageExceptionLogsEvents() mockLogger .Verify( - log => log.ScheduleMessageStart( + log => log.ScheduleMessagesStart( sender.Identifier, + 1, scheduleTime.ToString(CultureInfo.InvariantCulture)), Times.Once); mockLogger .Verify( - log => log.ScheduleMessageException( + log => log.ScheduleMessagesException( sender.Identifier, It.IsAny()), Times.Once); @@ -226,18 +234,18 @@ public async Task CancelScheduleMessageLogsEvents() { Logger = mockLogger.Object }; - var sequenceNumber = 1; - await sender.CancelScheduledMessageAsync(sequenceNumber); + long[] sequenceNumbers = new long[] { 1 }; + await sender.CancelScheduledMessagesAsync(sequenceNumbers: sequenceNumbers); mockLogger .Verify( - log => log.CancelScheduledMessageStart( + log => log.CancelScheduledMessagesStart( sender.Identifier, - sequenceNumber), + sequenceNumbers), Times.Once); mockLogger .Verify( - log => log.CancelScheduledMessageComplete( + log => log.CancelScheduledMessagesComplete( sender.Identifier), Times.Once); } @@ -253,27 +261,27 @@ public void CancelScheduleMessageExceptionLogsEvents() { Logger = mockLogger.Object }; - var sequenceNumber = 1; + long[] sequenceNumbers = new long[] { 1 }; mockTransportSender.Setup( - sender => sender.CancelScheduledMessageAsync( - sequenceNumber, + sender => sender.CancelScheduledMessagesAsync( + It.IsAny(), It.IsAny())) .Throws(new Exception()); Assert.That( - async () => await sender.CancelScheduledMessageAsync(sequenceNumber), + async () => await sender.CancelScheduledMessagesAsync(sequenceNumbers: sequenceNumbers), Throws.InstanceOf()); mockLogger .Verify( - log => log.CancelScheduledMessageStart( + log => log.CancelScheduledMessagesStart( sender.Identifier, - sequenceNumber), + sequenceNumbers), Times.Once); mockLogger .Verify( - log => log.CancelScheduledMessageException( + log => log.CancelScheduledMessagesException( sender.Identifier, It.IsAny()), Times.Once); @@ -287,7 +295,7 @@ public async Task ReceiveSingleMessageLogsEvents() var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( - transportReceiver => transportReceiver.ReceiveBatchAsync( + transportReceiver => transportReceiver.ReceiveMessagesAsync( 1, It.IsAny(), It.IsAny())) @@ -300,7 +308,7 @@ public async Task ReceiveSingleMessageLogsEvents() }; - await receiver.ReceiveAsync(); + await receiver.ReceiveMessageAsync(); mockLogger .Verify( @@ -325,7 +333,7 @@ public async Task ReceiveBatchOfMessagesLogsEvents() var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( - transportReceiver => transportReceiver.ReceiveBatchAsync( + transportReceiver => transportReceiver.ReceiveMessagesAsync( maxMessages, It.IsAny(), It.IsAny())) @@ -338,7 +346,7 @@ public async Task ReceiveBatchOfMessagesLogsEvents() Logger = mockLogger.Object }; - var msgs = await receiver.ReceiveBatchAsync(maxMessages: maxMessages); + var msgs = await receiver.ReceiveMessagesAsync(maxMessages: maxMessages); mockLogger .Verify( @@ -364,7 +372,7 @@ public void ReceiveMessageExceptionLogsEvents() var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( - transportReceiver => transportReceiver.ReceiveBatchAsync( + transportReceiver => transportReceiver.ReceiveMessagesAsync( 1, It.IsAny(), It.IsAny())) @@ -375,7 +383,7 @@ public void ReceiveMessageExceptionLogsEvents() }; Assert.That( - async () => await receiver.ReceiveAsync(), + async () => await receiver.ReceiveMessageAsync(), Throws.InstanceOf()); mockLogger @@ -402,7 +410,7 @@ public async Task PeekSingleMessageLogsEvents(bool specifySeqNumber) var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( - transportReceiver => transportReceiver.PeekBatchAtAsync( + transportReceiver => transportReceiver.PeekMessagesAsync( It.IsAny(), It.IsAny(), It.IsAny())) @@ -415,20 +423,13 @@ public async Task PeekSingleMessageLogsEvents(bool specifySeqNumber) }; var seqNumber = 5; - if (specifySeqNumber) - { - await receiver.PeekAtAsync(seqNumber); - } - else - { - await receiver.PeekAsync(); - } + await receiver.PeekMessageAsync(specifySeqNumber ? seqNumber : (long?)null); mockLogger .Verify( log => log.PeekMessageStart( receiver.Identifier, - specifySeqNumber ? (long?) seqNumber : null, + specifySeqNumber ? (long?)seqNumber : null, 1), Times.Once); mockLogger @@ -450,7 +451,7 @@ public async Task PeekBatchOfMessagesLogsEvents(bool specifySeqNumber) var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( - transportReceiver => transportReceiver.PeekBatchAtAsync( + transportReceiver => transportReceiver.PeekMessagesAsync( It.IsAny(), maxMessages, It.IsAny())) @@ -465,14 +466,7 @@ public async Task PeekBatchOfMessagesLogsEvents(bool specifySeqNumber) var seqNumber = 5; IList msgs; - if (specifySeqNumber) - { - msgs = await receiver.PeekBatchAtAsync(seqNumber, maxMessages); - } - else - { - msgs = await receiver.PeekBatchAsync(maxMessages: maxMessages); - } + msgs = await receiver.PeekMessagesAsync(maxMessages, specifySeqNumber ? seqNumber : (long?)null); mockLogger .Verify( @@ -499,7 +493,7 @@ public void PeekMessageExceptionLogsEvents() var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( - transportReceiver => transportReceiver.PeekBatchAtAsync( + transportReceiver => transportReceiver.PeekMessagesAsync( It.IsAny(), 1, It.IsAny())) @@ -510,7 +504,7 @@ public void PeekMessageExceptionLogsEvents() }; Assert.That( - async () => await receiver.PeekAsync(), + async () => await receiver.PeekMessageAsync(), Throws.InstanceOf()); mockLogger @@ -541,7 +535,7 @@ public async Task CompleteMessageLogsEvents() }; var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; - await receiver.CompleteAsync(msg); + await receiver.CompleteMessageAsync(msg); mockLogger .Verify( @@ -576,7 +570,7 @@ public void CompleteMessageExceptionLogsEvents() var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; Assert.That( - async () => await receiver.CompleteAsync(msg), + async () => await receiver.CompleteMessageAsync(msg), Throws.InstanceOf()); mockLogger @@ -606,7 +600,7 @@ public async Task DeferMessageLogsEvents() }; var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; - await receiver.DeferAsync(msg); + await receiver.DeferMessageAsync(msg); mockLogger .Verify( @@ -641,7 +635,7 @@ public void DeferMessageExceptionLogsEvents() var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; Assert.That( - async () => await receiver.DeferAsync(msg), + async () => await receiver.DeferMessageAsync(msg), Throws.InstanceOf()); mockLogger @@ -671,7 +665,7 @@ public async Task DeadLetterMessageLogsEvents() }; var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; - await receiver.DeadLetterAsync(msg); + await receiver.DeadLetterMessageAsync(msg); mockLogger .Verify( @@ -708,7 +702,7 @@ public void DeadLetterMessageExceptionLogsEvents() var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; Assert.That( - async () => await receiver.DeadLetterAsync(msg), + async () => await receiver.DeadLetterMessageAsync(msg), Throws.InstanceOf()); mockLogger @@ -738,7 +732,7 @@ public async Task AbandonMessageLogsEvents() }; var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; - await receiver.AbandonAsync(msg); + await receiver.AbandonMessageAsync(msg); mockLogger .Verify( @@ -773,7 +767,7 @@ public void AbandonMessageExceptionLogsEvents() var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; Assert.That( - async () => await receiver.AbandonAsync(msg), + async () => await receiver.AbandonMessageAsync(msg), Throws.InstanceOf()); mockLogger @@ -1043,11 +1037,11 @@ public async Task StartStopProcessingLogsEvents() var mockTransportReceiver = new Mock(); var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( - transportReceiver => transportReceiver.ReceiveBatchAsync( + transportReceiver => transportReceiver.ReceiveMessagesAsync( 1, It.IsAny(), It.IsAny())) - .Returns(Task.FromResult((IList) new List() { new ServiceBusReceivedMessage() })); + .Returns(Task.FromResult((IList)new List() { new ServiceBusReceivedMessage() })); var processor = new ServiceBusProcessor(mockConnection.Object, "queueName", false, new ServiceBusProcessorOptions { MaxAutoLockRenewalDuration = TimeSpan.Zero, @@ -1133,7 +1127,7 @@ public async Task StopProcessingExceptionLogsEvents() var mockTransportReceiver = new Mock(); var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( - transportReceiver => transportReceiver.ReceiveBatchAsync( + transportReceiver => transportReceiver.ReceiveMessagesAsync( 1, It.IsAny(), It.IsAny())) diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Infrastructure/ServiceBusTestBase.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Infrastructure/ServiceBusTestBase.cs index 4210727af151..7f22db9b0ffe 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Infrastructure/ServiceBusTestBase.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Infrastructure/ServiceBusTestBase.cs @@ -26,7 +26,7 @@ protected ServiceBusMessageBatch AddMessages(ServiceBusMessageBatch batch, int c { for (int i = 0; i < count; i++) { - Assert.That(() => batch.TryAdd(GetMessage(sessionId, partitionKey)), Is.True, "A message was rejected by the batch; all messages should be accepted."); + Assert.That(() => batch.TryAddMessage(GetMessage(sessionId, partitionKey)), Is.True, "A message was rejected by the batch; all messages should be accepted."); } return batch; diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/ManagementClient/ServiceBusManagementClientLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/ManagementClient/ServiceBusManagementClientLiveTests.cs index 8ddf2e0233ca..f794daed5a68 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/ManagementClient/ServiceBusManagementClientLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/ManagementClient/ServiceBusManagementClientLiveTests.cs @@ -303,13 +303,13 @@ public async Task GetQueueRuntimeInfo() // Changing Last Accessed Time ServiceBusSender sender = sbClient.CreateSender(queueName); - await sender.SendAsync(new ServiceBusMessage() { MessageId = "1" }); - await sender.SendAsync(new ServiceBusMessage() { MessageId = "2" }); - await sender.SendAsync(new ServiceBusMessage() { MessageId = "3", ScheduledEnqueueTime = DateTime.UtcNow.AddDays(1) }); + await sender.SendMessageAsync(new ServiceBusMessage() { MessageId = "1" }); + await sender.SendMessageAsync(new ServiceBusMessage() { MessageId = "2" }); + await sender.SendMessageAsync(new ServiceBusMessage() { MessageId = "3", ScheduledEnqueueTime = DateTime.UtcNow.AddDays(1) }); ServiceBusReceiver receiver = sbClient.CreateReceiver(queueName); - ServiceBusReceivedMessage msg = await receiver.ReceiveAsync(); - await receiver.DeadLetterAsync(msg.LockToken); + ServiceBusReceivedMessage msg = await receiver.ReceiveMessageAsync(); + await receiver.DeadLetterMessageAsync(msg.LockToken); List runtimeInfoList = new List(); await foreach (QueueRuntimeInfo queueRuntimeInfo in mgmtClient.GetQueuesRuntimeInfoAsync()) @@ -368,13 +368,13 @@ public async Task GetSubscriptionRuntimeInfoTest() // Changing Last Accessed Time ServiceBusSender sender = sbClient.CreateSender(topicName); - await sender.SendAsync(new ServiceBusMessage() { MessageId = "1" }); - await sender.SendAsync(new ServiceBusMessage() { MessageId = "2" }); - await sender.SendAsync(new ServiceBusMessage() { MessageId = "3", ScheduledEnqueueTime = DateTime.UtcNow.AddDays(1) }); + await sender.SendMessageAsync(new ServiceBusMessage() { MessageId = "1" }); + await sender.SendMessageAsync(new ServiceBusMessage() { MessageId = "2" }); + await sender.SendMessageAsync(new ServiceBusMessage() { MessageId = "3", ScheduledEnqueueTime = DateTime.UtcNow.AddDays(1) }); ServiceBusReceiver receiver = sbClient.CreateReceiver(topicName, subscriptionName); - ServiceBusReceivedMessage msg = await receiver.ReceiveAsync(); - await receiver.DeadLetterAsync(msg.LockToken); + ServiceBusReceivedMessage msg = await receiver.ReceiveMessageAsync(); + await receiver.DeadLetterMessageAsync(msg.LockToken); List runtimeInfoList = new List(); await foreach (SubscriptionRuntimeInfo subscriptionRuntimeInfo in mgmtClient.GetSubscriptionsRuntimeInfoAsync(topicName)) @@ -574,19 +574,19 @@ await mgmtClient.CreateQueueAsync( await using var sbClient = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = sbClient.CreateSender(queueName); - await sender.SendAsync(new ServiceBusMessage() { MessageId = "mid" }); + await sender.SendMessageAsync(new ServiceBusMessage() { MessageId = "mid" }); ServiceBusReceiver receiver = sbClient.CreateReceiver(destinationName); - ServiceBusReceivedMessage msg = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage msg = await receiver.ReceiveMessageAsync(); Assert.NotNull(msg); Assert.AreEqual("mid", msg.MessageId); - await receiver.DeadLetterAsync(msg.LockToken); + await receiver.DeadLetterMessageAsync(msg.LockToken); receiver = sbClient.CreateReceiver(dlqDestinationName); - msg = await receiver.ReceiveAsync(); + msg = await receiver.ReceiveMessageAsync(); Assert.NotNull(msg); Assert.AreEqual("mid", msg.MessageId); - await receiver.CompleteAsync(msg.LockToken); + await receiver.CompleteMessageAsync(msg.LockToken); await mgmtClient.DeleteQueueAsync(queueName); await mgmtClient.DeleteQueueAsync(destinationName); diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Message/MessageLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Message/MessageLiveTests.cs index 6f0cf39885c8..e536911b545d 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Message/MessageLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Message/MessageLiveTests.cs @@ -44,8 +44,8 @@ public async Task MessagePropertiesShouldSupportValidPropertyTypes() msg.Properties.Add("DateTimeOffset", DateTimeOffset.UtcNow); msg.Properties.Add("TimeSpan", TimeSpan.FromMinutes(5)); - await sender.SendAsync(msg); - var receivedMsg = await receiver.ReceiveAsync(); + await sender.SendMessageAsync(msg); + var receivedMsg = await receiver.ReceiveMessageAsync(); Assert.IsInstanceOf(typeof(byte), receivedMsg.Properties["byte"]); Assert.IsInstanceOf(typeof(sbyte), receivedMsg.Properties["sbyte"]); @@ -80,10 +80,10 @@ public async Task CanSendMessageWithMaxSize() var maxPayload = Enumerable.Repeat(0x20, maxMessageSize).ToArray(); var maxSizeMessage = new ServiceBusMessage(maxPayload); - await client.CreateSender(scope.QueueName).SendAsync(maxSizeMessage); + await client.CreateSender(scope.QueueName).SendMessageAsync(maxSizeMessage); var receiver = client.CreateReceiver(scope.QueueName); - var receivedMaxSizeMessage = await receiver.ReceiveAsync(); - await receiver.CompleteAsync(receivedMaxSizeMessage.LockToken); + var receivedMaxSizeMessage = await receiver.ReceiveMessageAsync(); + await receiver.CompleteMessageAsync(receivedMaxSizeMessage.LockToken); Assert.AreEqual(maxPayload, receivedMaxSizeMessage.Body.AsBytes().ToArray()); } } @@ -109,7 +109,7 @@ public async Task CreateFromReceivedMessageCopiesProperties() msg.SessionId = "key"; msg.TimeToLive = TimeSpan.FromSeconds(60); msg.To = "to"; - await sender.SendAsync(msg); + await sender.SendMessageAsync(msg); var receiver = await client.CreateSessionReceiverAsync( scope.QueueName, @@ -117,7 +117,7 @@ public async Task CreateFromReceivedMessageCopiesProperties() { ReceiveMode = ReceiveMode.ReceiveAndDelete }); - var received = await receiver.ReceiveAsync(); + var received = await receiver.ReceiveMessageAsync(); AssertMessagesEqual(msg, received); var toSend = new ServiceBusMessage(received); AssertMessagesEqual(toSend, received); @@ -161,10 +161,10 @@ public async Task SendJsonBodyMessage() var body = BinaryData.FromSerializable(testBody, serializer); var msg = new ServiceBusMessage(body); - await sender.SendAsync(msg); + await sender.SendMessageAsync(msg); var receiver = client.CreateReceiver(scope.QueueName); - var received = await receiver.ReceiveAsync(); + var received = await receiver.ReceiveMessageAsync(); var receivedBody = received.Body.Deserialize(serializer); Assert.AreEqual(testBody.A, receivedBody.A); Assert.AreEqual(testBody.B, receivedBody.B); diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/ProcessorLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/ProcessorLiveTests.cs index 2a7a6c06b7a4..56507f7ad27f 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/ProcessorLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/ProcessorLiveTests.cs @@ -29,11 +29,11 @@ public async Task ProcessMessages(int numThreads, bool autoComplete) // use double the number of threads so we can make sure we test that we don't // retrieve more messages than expected when there are more messages available - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); var messageSendCt = numThreads * 2; ServiceBusMessageBatch messageBatch = AddMessages(batch, messageSendCt); - await sender.SendAsync(messageBatch); + await sender.SendMessagesAsync(messageBatch); var options = new ServiceBusProcessorOptions { @@ -101,11 +101,11 @@ public async Task UserSettlingWithAutoCompleteDoesNotThrow(int numThreads) // use double the number of threads so we can make sure we test that we don't // retrieve more messages than expected when there are more messages available - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); var messageSendCt = numThreads * 2; ServiceBusMessageBatch messageBatch = AddMessages(batch, messageSendCt); - await sender.SendAsync(messageBatch); + await sender.SendMessagesAsync(messageBatch); var options = new ServiceBusProcessorOptions { @@ -182,11 +182,11 @@ public async Task AutoLockRenewalWorks(int numThreads) await using var client = GetClient(); ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); var messageSendCt = numThreads; ServiceBusMessageBatch messageBatch = AddMessages(batch, messageSendCt); - await sender.SendAsync(messageBatch); + await sender.SendMessagesAsync(messageBatch); var options = new ServiceBusProcessorOptions { @@ -250,11 +250,11 @@ public async Task MaxAutoLockRenewalDurationRespected(int numThreads, int autoLo await using var client = GetClient(); ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); var messageSendCt = numThreads; ServiceBusMessageBatch messageBatch = AddMessages(batch, messageSendCt); - await sender.SendAsync(messageBatch); + await sender.SendMessagesAsync(messageBatch); var options = new ServiceBusProcessorOptions { @@ -313,10 +313,10 @@ public async Task CanStopProcessingFromHandler(int numThreads) await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); int numMessages = 100; - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); ServiceBusMessageBatch messageBatch = AddMessages(batch, numMessages); - await sender.SendAsync(messageBatch); + await sender.SendMessagesAsync(messageBatch); var options = new ServiceBusProcessorOptions { MaxConcurrentCalls = numThreads, @@ -348,7 +348,7 @@ Task ProcessMessage(ProcessMessageEventArgs args) await tcs.Task; var receiver = GetNoRetryClient().CreateReceiver(scope.QueueName); - var receivedMessages = await receiver.ReceiveBatchAsync(numMessages); + var receivedMessages = await receiver.ReceiveMessagesAsync(numMessages); // can't assert on the exact amount processed due to threads that // are already in flight when calling StopProcessingAsync, but we can at least verify that there are remaining messages Assert.IsTrue(receivedMessages.Count > 0); @@ -463,7 +463,7 @@ public async Task StopProcessingDoesNotCancelAutoCompletion() { await using var client = GetClient(); var sender = client.CreateSender(scope.QueueName); - await sender.SendAsync(GetMessage()); + await sender.SendMessageAsync(GetMessage()); var processor = client.CreateProcessor(scope.QueueName, new ServiceBusProcessorOptions { AutoComplete = true @@ -482,7 +482,7 @@ Task ProcessMessage(ProcessMessageEventArgs args) await tcs.Task; await processor.StopProcessingAsync(); var receiver = client.CreateReceiver(scope.QueueName); - var msg = await receiver.ReceiveAsync(); + var msg = await receiver.ReceiveMessageAsync(); Assert.IsNull(msg); } } @@ -502,7 +502,7 @@ public async Task UserCallbackThrowingCausesMessageToBeAbandonedIfNotSettled(str { await using var client = GetClient(); var sender = client.CreateSender(scope.QueueName); - await sender.SendAsync(GetMessage()); + await sender.SendMessageAsync(GetMessage()); var processor = client.CreateProcessor(scope.QueueName, new ServiceBusProcessorOptions { AutoComplete = true @@ -548,7 +548,7 @@ Task ExceptionHandler(ProcessErrorEventArgs args) await tcs.Task; await processor.StopProcessingAsync(); var receiver = client.CreateReceiver(scope.QueueName); - var msg = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5)); + var msg = await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(5)); if (settleMethod == "" || settleMethod == "Abandon") { // if the message is abandoned (whether by user callback or diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/ProcessorTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/ProcessorTests.cs index c0f92ebd32a2..8e4c53ec2b84 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/ProcessorTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/ProcessorTests.cs @@ -208,34 +208,34 @@ public void UserSettledPropertySetCorrectlyOnException() var mockReceiver = new Mock(); mockReceiver - .Setup(receiver => receiver.AbandonAsync( + .Setup(receiver => receiver.AbandonMessageAsync( It.IsAny(), It.IsAny>(), It.IsAny())) .Throws(new Exception()); mockReceiver - .Setup(receiver => receiver.DeferAsync( + .Setup(receiver => receiver.DeferMessageAsync( It.IsAny(), It.IsAny>(), It.IsAny())) .Throws(new Exception()); mockReceiver - .Setup(receiver => receiver.CompleteAsync( + .Setup(receiver => receiver.CompleteMessageAsync( It.IsAny(), It.IsAny())) .Throws(new Exception()); mockReceiver - .Setup(receiver => receiver.DeadLetterAsync( + .Setup(receiver => receiver.DeadLetterMessageAsync( It.IsAny(), It.IsAny>(), It.IsAny())) .Throws(new Exception()); mockReceiver - .Setup(receiver => receiver.DeadLetterAsync( + .Setup(receiver => receiver.DeadLetterMessageAsync( It.IsAny(), It.IsAny(), It.IsAny(), diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/SessionProcessorLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/SessionProcessorLiveTests.cs index ab3822af38bb..e1179513c605 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/SessionProcessorLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/SessionProcessorLiveTests.cs @@ -112,7 +112,7 @@ public async Task ProcessSessionMessage(int numThreads, bool autoComplete) for (int i = 0; i < numThreads; i++) { var sessionId = Guid.NewGuid().ToString(); - await sender.SendAsync(GetMessage(sessionId)); + await sender.SendMessageAsync(GetMessage(sessionId)); sessions.TryAdd(sessionId, null); } var options = new ServiceBusSessionProcessorOptions @@ -205,7 +205,7 @@ public async Task UserSettlingWithAutoCompleteDoesNotThrow(int numThreads) for (int i = 0; i < numThreads; i++) { var sessionId = Guid.NewGuid().ToString(); - await sender.SendAsync(GetMessage(sessionId)); + await sender.SendMessageAsync(GetMessage(sessionId)); sessions.TryAdd(sessionId, true); } var options = new ServiceBusSessionProcessorOptions @@ -302,7 +302,7 @@ public async Task ProcessConsumesAllMessages(int numThreads, bool autoComplete) for (int i = 0; i < numThreads; i++) { var sessionId = Guid.NewGuid().ToString(); - await sender.SendAsync(GetMessage(sessionId)); + await sender.SendMessageAsync(GetMessage(sessionId)); sessions.TryAdd(sessionId, true); } @@ -475,7 +475,7 @@ public async Task ProcessSessionMessageUsingNamedSessionId(int numThreads, bool for (int i = 0; i < numThreads; i++) { sessionId = Guid.NewGuid().ToString(); - await sender.SendAsync(GetMessage(sessionId)); + await sender.SendMessageAsync(GetMessage(sessionId)); sessions.TryAdd(sessionId, true); } @@ -545,14 +545,14 @@ public async Task AutoLockRenewalWorks(int numThreads) await using var client = GetClient(); ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); var messageSendCt = numThreads; for (int i = 0; i < numThreads; i++) { AddMessages(batch, 1, Guid.NewGuid().ToString()); } - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); var options = new ServiceBusSessionProcessorOptions { @@ -614,14 +614,14 @@ public async Task MaxAutoLockRenewalDurationRespected(int numThreads, int autoLo await using var client = GetClient(); ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); var messageSendCt = numThreads; for (int i = 0; i < numThreads; i++) { AddMessages(batch, 1, Guid.NewGuid().ToString()); } - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); var options = new ServiceBusSessionProcessorOptions { @@ -693,7 +693,7 @@ public async Task StopProcessingDoesNotCancelAutoCompletion() { await using var client = GetClient(); var sender = client.CreateSender(scope.QueueName); - await sender.SendAsync(GetMessage("sessionId")); + await sender.SendMessageAsync(GetMessage("sessionId")); var processor = client.CreateSessionProcessor(scope.QueueName, new ServiceBusSessionProcessorOptions { AutoComplete = true @@ -733,7 +733,7 @@ public async Task UserCallbackThrowingCausesMessageToBeAbandonedIfNotSettled(str { await using var client = GetClient(); var sender = client.CreateSender(scope.QueueName); - await sender.SendAsync(GetMessage("sessionId")); + await sender.SendMessageAsync(GetMessage("sessionId")); var processor = client.CreateSessionProcessor(scope.QueueName); var tcs = new TaskCompletionSource(); @@ -779,7 +779,7 @@ Task ExceptionHandler(ProcessErrorEventArgs args) if (settleMethod == "" || settleMethod == "Abandon") { var receiver = await client.CreateSessionReceiverAsync(scope.QueueName); - var msg = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5)); + var msg = await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(5)); Assert.IsNotNull(msg); } else @@ -813,18 +813,18 @@ public async Task ProcessMessagesFromMultipleNamedSessions(int numThreads, int s { var sessionId = Guid.NewGuid().ToString(); sessionIds.Add(sessionId); - await sender.SendAsync(GetMessage(sessionId)); + await sender.SendMessageAsync(GetMessage(sessionId)); sessions.TryAdd(sessionId, true); } // sending 2 more messages and not specifying these sessionIds when creating a processor, // to make sure that these messages will not be received. var sessionId1 = Guid.NewGuid().ToString(); - await sender.SendAsync(GetMessage(sessionId1)); + await sender.SendMessageAsync(GetMessage(sessionId1)); sessions.TryAdd(sessionId1, true); var sessionId2 = Guid.NewGuid().ToString(); - await sender.SendAsync(GetMessage(sessionId2)); + await sender.SendMessageAsync(GetMessage(sessionId2)); sessions.TryAdd(sessionId2, true); TaskCompletionSource tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); @@ -916,7 +916,7 @@ public async Task SessionLockLostWhenProcessSessionMessages(int numSessions, int var sessionId = Guid.NewGuid().ToString(); sessionIds.Add(sessionId); var messages = GetMessages(messagesPerSession, sessionId); - await sender.SendAsync(messages); + await sender.SendMessagesAsync(messages); sessions.TryAdd(sessionId, true); } @@ -1060,7 +1060,7 @@ public async Task UserErrorHandlerInvokeOnceIfSessionLockLost() ConcurrentDictionary sessions = new ConcurrentDictionary(); var sessionId = Guid.NewGuid().ToString(); - await sender.SendAsync(GetMessage(sessionId)); + await sender.SendMessageAsync(GetMessage(sessionId)); sessions.TryAdd(sessionId, true); TaskCompletionSource tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); @@ -1156,7 +1156,7 @@ public async Task ErrorSourceRespected(ServiceBusErrorSource errorSource) ConcurrentDictionary sessions = new ConcurrentDictionary(); var sessionId = Guid.NewGuid().ToString(); - await sender.SendAsync(GetMessage(sessionId)); + await sender.SendMessageAsync(GetMessage(sessionId)); if (errorSource == ServiceBusErrorSource.AcceptMessageSession) { @@ -1332,7 +1332,7 @@ public async Task SessionOpenEventDoesNotLoseLock() ConcurrentDictionary sessions = new ConcurrentDictionary(); var sessionId = Guid.NewGuid().ToString(); - await sender.SendAsync(GetMessage(sessionId)); + await sender.SendMessageAsync(GetMessage(sessionId)); sessions.TryAdd(sessionId, true); TaskCompletionSource tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/SessionProcessorTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/SessionProcessorTests.cs index 8bb1ccd3307d..343a8d630b2e 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/SessionProcessorTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Processor/SessionProcessorTests.cs @@ -201,34 +201,34 @@ public void UserSettledPropertySetCorrectlyOnException() var mockReceiver = new Mock(); mockReceiver - .Setup(receiver => receiver.AbandonAsync( + .Setup(receiver => receiver.AbandonMessageAsync( It.IsAny(), It.IsAny>(), It.IsAny())) .Throws(new Exception()); mockReceiver - .Setup(receiver => receiver.DeferAsync( + .Setup(receiver => receiver.DeferMessageAsync( It.IsAny(), It.IsAny>(), It.IsAny())) .Throws(new Exception()); mockReceiver - .Setup(receiver => receiver.CompleteAsync( + .Setup(receiver => receiver.CompleteMessageAsync( It.IsAny(), It.IsAny())) .Throws(new Exception()); mockReceiver - .Setup(receiver => receiver.DeadLetterAsync( + .Setup(receiver => receiver.DeadLetterMessageAsync( It.IsAny(), It.IsAny>(), It.IsAny())) .Throws(new Exception()); mockReceiver - .Setup(receiver => receiver.DeadLetterAsync( + .Setup(receiver => receiver.DeadLetterMessageAsync( It.IsAny(), It.IsAny(), It.IsAny(), diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Receiver/ReceiverLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Receiver/ReceiverLiveTests.cs index 0d464b9ffe4f..213b9b4fa7fc 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Receiver/ReceiverLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Receiver/ReceiverLiveTests.cs @@ -22,10 +22,10 @@ public async Task Peek() var messageCt = 10; ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable sentMessages = AddMessages(batch, messageCt).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); await using var receiver = client.CreateReceiver(scope.QueueName); var messageEnum = sentMessages.GetEnumerator(); @@ -33,7 +33,7 @@ public async Task Peek() var ct = 0; while (ct < messageCt) { - foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekBatchAsync( + foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekMessagesAsync( maxMessages: messageCt)) { messageEnum.MoveNext(); @@ -45,6 +45,23 @@ public async Task Peek() } } + [Test] + public async Task PeekSingleMessage() + { + await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) + { + await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); + ServiceBusSender sender = client.CreateSender(scope.QueueName); + var msgs = GetMessages(2); + await sender.SendMessagesAsync(msgs); + var receiver = client.CreateReceiver(scope.QueueName); + var message1 = await receiver.PeekMessageAsync(); + Assert.IsNotNull(message1.SequenceNumber); + var message2 = await receiver.PeekMessageAsync(message1.SequenceNumber + 1); + Assert.AreEqual(msgs[1].MessageId, message2.MessageId); + } + } + [Test] public async Task ReceiveMessagesInPeekLockMode() { @@ -54,17 +71,17 @@ public async Task ReceiveMessagesInPeekLockMode() var messageCount = 10; ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable messages = AddMessages(batch, messageCount).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); var receiver = client.CreateReceiver(scope.QueueName); var messageEnum = messages.GetEnumerator(); var remainingMessages = messageCount; while (remainingMessages > 0) { - foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages)) + foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); @@ -74,7 +91,7 @@ public async Task ReceiveMessagesInPeekLockMode() } Assert.AreEqual(0, remainingMessages); messageEnum.Reset(); - foreach (var item in await receiver.PeekBatchAsync(messageCount)) + foreach (var item in await receiver.PeekMessagesAsync(messageCount)) { messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); @@ -91,10 +108,10 @@ public async Task CompleteMessages() var messageCount = 10; ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable messages = AddMessages(batch, messageCount).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); var receiver = client.CreateReceiver(scope.QueueName); var messageEnum = messages.GetEnumerator(); @@ -102,17 +119,17 @@ public async Task CompleteMessages() while (remainingMessages > 0) { - foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages)) + foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); - await receiver.CompleteAsync(item.LockToken); + await receiver.CompleteMessageAsync(item.LockToken); } } Assert.AreEqual(0, remainingMessages); - var peekedMessage = receiver.PeekAsync(); + var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); } } @@ -126,10 +143,10 @@ public async Task AbandonMessages() var messageCount = 10; ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable messages = AddMessages(batch, messageCount).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); var receiver = client.CreateReceiver(scope.QueueName); @@ -138,7 +155,7 @@ public async Task AbandonMessages() IList receivedMessages = new List(); while (remainingMessages > 0) { - foreach (var msg in await receiver.ReceiveBatchAsync(remainingMessages)) + foreach (var msg in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); @@ -154,11 +171,11 @@ public async Task AbandonMessages() // as this would make the message available to be immediately received again foreach (var msg in receivedMessages) { - await receiver.AbandonAsync(msg); + await receiver.AbandonMessageAsync(msg); } messageEnum.Reset(); var receivedMessageCount = 0; - foreach (var item in await receiver.PeekBatchAsync(messageCount)) + foreach (var item in await receiver.PeekMessagesAsync(messageCount)) { receivedMessageCount++; messageEnum.MoveNext(); @@ -179,7 +196,7 @@ public async Task DeadLetterMessages() ServiceBusSender sender = client.CreateSender(scope.QueueName); IEnumerable messages = GetMessages(messageCount); - await sender.SendAsync(messages); + await sender.SendMessagesAsync(messages); var receiver = client.CreateReceiver(scope.QueueName); var remainingMessages = messageCount; @@ -187,17 +204,17 @@ public async Task DeadLetterMessages() while (remainingMessages > 0) { - foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages)) + foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); - await receiver.DeadLetterAsync(item.LockToken); + await receiver.DeadLetterMessageAsync(item.LockToken); } } Assert.AreEqual(0, remainingMessages); - var peekedMessage = receiver.PeekAsync(); + var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); messageEnum.Reset(); @@ -207,17 +224,17 @@ public async Task DeadLetterMessages() while (remainingMessages > 0) { - foreach (var item in await deadLetterReceiver.ReceiveBatchAsync(remainingMessages)) + foreach (var item in await deadLetterReceiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); - await deadLetterReceiver.CompleteAsync(item.LockToken); + await deadLetterReceiver.CompleteMessageAsync(item.LockToken); } } Assert.AreEqual(0, remainingMessages); - var deadLetterMessage = deadLetterReceiver.PeekAsync(); + var deadLetterMessage = deadLetterReceiver.PeekMessageAsync(); Assert.IsNull(deadLetterMessage.Result); } } @@ -231,10 +248,10 @@ public async Task DeferMessages() var messageCount = 10; ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable messages = AddMessages(batch, messageCount).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); var receiver = client.CreateReceiver(scope.QueueName); var messageEnum = messages.GetEnumerator(); @@ -243,18 +260,18 @@ public async Task DeferMessages() while (remainingMessages > 0) { - foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages)) + foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); sequenceNumbers.Add(item.SequenceNumber); - await receiver.DeferAsync(item.LockToken); + await receiver.DeferMessageAsync(item.LockToken); } } Assert.AreEqual(0, remainingMessages); - IList deferedMessages = await receiver.ReceiveDeferredMessageBatchAsync(sequenceNumbers); + IList deferedMessages = await receiver.ReceiveDeferredMessagesAsync(sequenceNumbers); var messageList = messages.ToList(); Assert.AreEqual(messageList.Count, deferedMessages.Count); @@ -262,6 +279,12 @@ public async Task DeferMessages() { Assert.AreEqual(messageList[i].MessageId, deferedMessages[i].MessageId); } + + // verify that looking up a non-existent sequence number will throw + sequenceNumbers.Add(45); + Assert.That( + async () => await receiver.ReceiveDeferredMessagesAsync(sequenceNumbers), + Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessageNotFound)); } } @@ -274,13 +297,13 @@ public async Task CanPeekADeferredMessage() ServiceBusSender sender = client.CreateSender(scope.QueueName); - await sender.SendAsync(GetMessage()); + await sender.SendMessageAsync(GetMessage()); var receiver = client.CreateReceiver(scope.QueueName); - var receivedMsg = await receiver.ReceiveAsync(); + var receivedMsg = await receiver.ReceiveMessageAsync(); - await receiver.DeferAsync(receivedMsg); - var peekedMsg = await receiver.PeekAsync(); + await receiver.DeferMessageAsync(receivedMsg); + var peekedMsg = await receiver.PeekMessageAsync(); Assert.AreEqual(receivedMsg.MessageId, peekedMsg.MessageId); Assert.AreEqual(receivedMsg.SequenceNumber, peekedMsg.SequenceNumber); @@ -299,10 +322,10 @@ public async Task ReceiveMessagesInReceiveAndDeleteMode() var messageCount = 10; ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable messages = AddMessages(batch, messageCount).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); var clientOptions = new ServiceBusReceiverOptions() { @@ -313,7 +336,7 @@ public async Task ReceiveMessagesInReceiveAndDeleteMode() var remainingMessages = messageCount; while (remainingMessages > 0) { - foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages).ConfigureAwait(false)) + foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages).ConfigureAwait(false)) { messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); @@ -322,7 +345,7 @@ public async Task ReceiveMessagesInReceiveAndDeleteMode() } Assert.AreEqual(0, remainingMessages); - var peekedMessage = receiver.PeekAsync(); + var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); } } @@ -335,17 +358,17 @@ public async Task ReceiveSingleMessageInReceiveAndDeleteMode() await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusMessage sentMessage = GetMessage(); - await sender.SendAsync(sentMessage); + await sender.SendMessageAsync(sentMessage); var clientOptions = new ServiceBusReceiverOptions() { ReceiveMode = ReceiveMode.ReceiveAndDelete, }; var receiver = client.CreateReceiver(scope.QueueName, clientOptions); - var receivedMessage = await receiver.ReceiveAsync(); + var receivedMessage = await receiver.ReceiveMessageAsync(); Assert.AreEqual(sentMessage.MessageId, receivedMessage.MessageId); - var message = receiver.PeekAsync(); + var message = receiver.PeekMessageAsync(); Assert.IsNull(message.Result); } } @@ -358,11 +381,11 @@ public async Task ReceiverThrowsWhenUsingSessionEntity() await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusMessage sentMessage = GetMessage("sessionId"); - await sender.SendAsync(sentMessage); + await sender.SendMessageAsync(sentMessage); var receiver = client.CreateReceiver(scope.QueueName); Assert.That( - async () => await receiver.ReceiveAsync(), + async () => await receiver.ReceiveMessageAsync(), Throws.InstanceOf()); } } @@ -376,10 +399,10 @@ public async Task RenewMessageLock() ServiceBusSender sender = client.CreateSender(scope.QueueName); var messageCount = 1; ServiceBusMessage message = GetMessage(); - await sender.SendAsync(message); + await sender.SendMessageAsync(message); var receiver = client.CreateReceiver(scope.QueueName); - ServiceBusReceivedMessage[] receivedMessages = (await receiver.ReceiveBatchAsync(messageCount)).ToArray(); + ServiceBusReceivedMessage[] receivedMessages = (await receiver.ReceiveMessagesAsync(messageCount)).ToArray(); var receivedMessage = receivedMessages.First(); var firstLockedUntilUtcTime = receivedMessage.LockedUntil; @@ -392,12 +415,12 @@ public async Task RenewMessageLock() Assert.True(receivedMessage.LockedUntil >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(10)); // Complete Messages - await receiver.CompleteAsync(receivedMessage.LockToken); + await receiver.CompleteMessageAsync(receivedMessage.LockToken); Assert.AreEqual(messageCount, receivedMessages.Length); Assert.AreEqual(message.MessageId, receivedMessage.MessageId); - var peekedMessage = receiver.PeekAsync(); + var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); } } @@ -419,7 +442,7 @@ public async Task MaxWaitTimeRespected() var receiver = client.CreateReceiver(scope.QueueName); var start = DateTimeOffset.UtcNow; - var receivedMessage = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5)); + var receivedMessage = await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(5)); var end = DateTimeOffset.UtcNow; Assert.IsNull(receivedMessage); var diff = end - start; @@ -427,7 +450,7 @@ public async Task MaxWaitTimeRespected() start = DateTimeOffset.UtcNow; // no wait time specified => should default to TryTimeout - receivedMessage = await receiver.ReceiveAsync(); + receivedMessage = await receiver.ReceiveMessageAsync(); end = DateTimeOffset.UtcNow; Assert.IsNull(receivedMessage); diff = end - start; @@ -443,14 +466,14 @@ public async Task ThrowIfCompletePeekedMessage() await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); - await sender.SendAsync(GetMessage()); + await sender.SendMessageAsync(GetMessage()); var receiver = client.CreateReceiver(scope.QueueName); - var peekedMessage = await receiver.PeekAsync(); + var peekedMessage = await receiver.PeekMessageAsync(); Assert.That( - async () => await receiver.CompleteAsync(peekedMessage), + async () => await receiver.CompleteMessageAsync(peekedMessage), Throws.InstanceOf()); } } @@ -463,14 +486,14 @@ public async Task ThrowIfAbandonPeekedMessage() await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); - await sender.SendAsync(GetMessage()); + await sender.SendMessageAsync(GetMessage()); var receiver = client.CreateReceiver(scope.QueueName); - var peekedMessage = await receiver.PeekAsync(); + var peekedMessage = await receiver.PeekMessageAsync(); Assert.That( - async () => await receiver.AbandonAsync(peekedMessage), + async () => await receiver.AbandonMessageAsync(peekedMessage), Throws.InstanceOf()); } } @@ -483,14 +506,14 @@ public async Task ThrowIfDeferPeekedMessage() await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); - await sender.SendAsync(GetMessage()); + await sender.SendMessageAsync(GetMessage()); var receiver = client.CreateReceiver(scope.QueueName); - var peekedMessage = await receiver.PeekAsync(); + var peekedMessage = await receiver.PeekMessageAsync(); Assert.That( - async () => await receiver.DeferAsync(peekedMessage), + async () => await receiver.DeferMessageAsync(peekedMessage), Throws.InstanceOf()); } } @@ -503,14 +526,14 @@ public async Task ThrowIfDeadletterPeekedMessage() await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); - await sender.SendAsync(GetMessage()); + await sender.SendMessageAsync(GetMessage()); var receiver = client.CreateReceiver(scope.QueueName); - var peekedMessage = await receiver.PeekAsync(); + var peekedMessage = await receiver.PeekMessageAsync(); Assert.That( - async () => await receiver.DeadLetterAsync(peekedMessage), + async () => await receiver.DeadLetterMessageAsync(peekedMessage), Throws.InstanceOf()); } } @@ -523,11 +546,11 @@ public async Task ThrowIfRenewlockOfPeekedMessage() await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); - await sender.SendAsync(GetMessage()); + await sender.SendMessageAsync(GetMessage()); var receiver = client.CreateReceiver(scope.QueueName); - var peekedMessage = await receiver.PeekAsync(); + var peekedMessage = await receiver.PeekMessageAsync(); Assert.That( async () => await receiver.RenewMessageLockAsync(peekedMessage), diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Receiver/ReceiverTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Receiver/ReceiverTests.cs index 797a6ecf18a3..fe8b83462d2e 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Receiver/ReceiverTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Receiver/ReceiverTests.cs @@ -50,10 +50,10 @@ public void ReceiveValidatesMaxWaitTime() var client = new ServiceBusClient(connString); var receiver = client.CreateReceiver("queue"); Assert.That( - async () => await receiver.ReceiveAsync(TimeSpan.FromSeconds(0)), + async () => await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(0)), Throws.InstanceOf()); Assert.That( - async () => await receiver.ReceiveAsync(TimeSpan.FromSeconds(-1)), + async () => await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(-1)), Throws.InstanceOf()); } } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Receiver/SessionReceiverLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Receiver/SessionReceiverLiveTests.cs index 86a8a9757303..90bd8ff9fc74 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Receiver/SessionReceiverLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Receiver/SessionReceiverLiveTests.cs @@ -30,10 +30,10 @@ public async Task PeekSession(long? sequenceNumber, string partitionKey) var sessionId = Guid.NewGuid().ToString(); // send the messages - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable sentMessages = AddMessages(batch, messageCt, sessionId, partitionKey).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); Dictionary sentMessageIdToMsg = new Dictionary(); foreach (ServiceBusMessage message in sentMessages) { @@ -51,9 +51,9 @@ public async Task PeekSession(long? sequenceNumber, string partitionKey) // verify peeked == send var ct = 0; - foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekBatchAtAsync( - sequenceNumber: (long)sequenceNumber, - maxMessages: messageCt)) + foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekMessagesAsync( + messageCt, + sequenceNumber)) { var peekedText = peekedMessage.Body.ToString(); var sentMsg = sentMessageIdToMsg[peekedMessage.MessageId]; @@ -82,10 +82,10 @@ public async Task LockSameSessionShouldThrow() int messageCt = 10; var sessionId = Guid.NewGuid().ToString(); // send the messages - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); ServiceBusMessageBatch messageBatch = AddMessages(batch, messageCt, sessionId); - await sender.SendAsync(messageBatch); + await sender.SendMessagesAsync(messageBatch); var options = new ServiceBusSessionReceiverOptions { SessionId = sessionId @@ -117,16 +117,16 @@ public async Task PeekRangeIncrementsSequenceNumber(int messageCt, int peekCt) var sessionId = Guid.NewGuid().ToString(); // send the messages - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); ServiceBusMessageBatch messagebatch = AddMessages(batch, messageCt, sessionId); - await sender.SendAsync(messagebatch); + await sender.SendMessagesAsync(messagebatch); ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(scope.QueueName); long seq = 0; for (int i = 0; i < messageCt / peekCt; i++) { - foreach (ServiceBusReceivedMessage msg in await receiver.PeekBatchAsync( + foreach (ServiceBusReceivedMessage msg in await receiver.PeekMessagesAsync( maxMessages: peekCt)) { Assert.IsTrue(msg.SequenceNumber > seq); @@ -151,17 +151,17 @@ public async Task PeekIncrementsSequenceNumber(int messageCt) ServiceBusSender sender = client.CreateSender(scope.QueueName); var sessionId = Guid.NewGuid().ToString(); // send the messages - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); ServiceBusMessageBatch messagebatch = AddMessages(batch, messageCt, sessionId); - await sender.SendAsync(messagebatch); + await sender.SendMessagesAsync(messagebatch); ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(scope.QueueName); long seq = 0; for (int i = 0; i < messageCt; i++) { - ServiceBusReceivedMessage msg = await receiver.PeekAsync(); + ServiceBusReceivedMessage msg = await receiver.PeekMessageAsync(); Assert.IsTrue(msg.SequenceNumber > seq); if (seq > 0) { @@ -185,17 +185,17 @@ public async Task RoundRobinSessions() // send the messages foreach (string session in sessions) { - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); ServiceBusMessageBatch messageBatch = AddMessages(batch, messageCt, session); - await sender.SendAsync(messageBatch); + await sender.SendMessagesAsync(messageBatch); } // create receiver not scoped to a specific session for (int i = 0; i < 10; i++) { ServiceBusSessionReceiver receiver = await client.CreateSessionReceiverAsync(scope.QueueName); - foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekBatchAtAsync( - sequenceNumber: 1, + foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekMessagesAsync( + fromSequenceNumber: 1, maxMessages: 10)) { var sessionId = receiver.SessionId; @@ -218,16 +218,16 @@ public async Task ReceiveMessagesInPeekLockMode() var messageCount = 10; var sessionId = "sessionId1"; - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable messages = AddMessages(batch, messageCount, sessionId).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(scope.QueueName); var messageEnum = messages.GetEnumerator(); - foreach (var item in await receiver.ReceiveBatchAsync(messageCount)) + foreach (var item in await receiver.ReceiveMessagesAsync(messageCount)) { messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); @@ -236,7 +236,7 @@ public async Task ReceiveMessagesInPeekLockMode() } messageEnum.Reset(); - foreach (var item in await receiver.PeekBatchAsync(messageCount)) + foreach (var item in await receiver.PeekMessagesAsync(messageCount)) { messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); @@ -255,10 +255,10 @@ public async Task ReceiveMessagesInReceiveAndDeleteMode() var messageCount = 10; var sessionId = "sessionId1"; - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable messages = AddMessages(batch, messageCount, sessionId).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); var clientOptions = new ServiceBusSessionReceiverOptions() { @@ -275,7 +275,7 @@ public async Task ReceiveMessagesInReceiveAndDeleteMode() while (remainingMessages > 0) { - foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages)) + foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages)) { messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); @@ -285,7 +285,7 @@ public async Task ReceiveMessagesInReceiveAndDeleteMode() } Assert.AreEqual(0, remainingMessages); - var peekedMessage = receiver.PeekAsync(); + var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); } } @@ -302,10 +302,10 @@ public async Task CompleteMessages(bool useSpecificSession) var messageCount = 10; var sessionId = "sessionId1"; - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable messages = AddMessages(batch, messageCount, sessionId).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync( scope.QueueName, @@ -318,18 +318,18 @@ public async Task CompleteMessages(bool useSpecificSession) while (remainingMessages > 0) { - foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages)) + foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId); - await receiver.CompleteAsync(item.LockToken); + await receiver.CompleteMessageAsync(item.LockToken); } } Assert.AreEqual(0, remainingMessages); - var peekedMessage = receiver.PeekAsync(); + var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); } } @@ -346,10 +346,10 @@ public async Task AbandonMessages(bool useSpecificSession) var messageCount = 10; var sessionId = "sessionId1"; - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable messages = AddMessages(batch, messageCount, sessionId).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync( scope.QueueName, @@ -363,7 +363,7 @@ public async Task AbandonMessages(bool useSpecificSession) while (remainingMessages > 0) { - foreach (var msg in await receiver.ReceiveBatchAsync(remainingMessages)) + foreach (var msg in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); @@ -379,12 +379,12 @@ public async Task AbandonMessages(bool useSpecificSession) // as this would make the message available to be immediately received again foreach (var msg in receivedMessages) { - await receiver.AbandonAsync(msg); + await receiver.AbandonMessageAsync(msg); } messageEnum.Reset(); var receivedMessageCount = 0; - foreach (var item in await receiver.PeekBatchAsync(messageCount)) + foreach (var item in await receiver.PeekMessagesAsync(messageCount)) { receivedMessageCount++; messageEnum.MoveNext(); @@ -406,10 +406,10 @@ public async Task DeadLetterMessages(bool useSpecificSession) ServiceBusSender sender = client.CreateSender(scope.QueueName); var messageCount = 10; var sessionId = "sessionId1"; - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable messages = AddMessages(batch, messageCount, sessionId).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); var receiver = await client.CreateSessionReceiverAsync( scope.QueueName, @@ -422,18 +422,18 @@ public async Task DeadLetterMessages(bool useSpecificSession) while (remainingMessages > 0) { - foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages)) + foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId); - await receiver.DeadLetterAsync(item.LockToken, "testReason", "testDescription"); + await receiver.DeadLetterMessageAsync(item.LockToken, "testReason", "testDescription"); } } Assert.AreEqual(0, remainingMessages); - var peekedMessage = receiver.PeekAsync(); + var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); messageEnum.Reset(); @@ -442,7 +442,7 @@ public async Task DeadLetterMessages(bool useSpecificSession) while (remainingMessages > 0) { - foreach (var msg in await deadLetterReceiver.ReceiveBatchAsync(remainingMessages)) + foreach (var msg in await deadLetterReceiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); @@ -450,12 +450,12 @@ public async Task DeadLetterMessages(bool useSpecificSession) Assert.AreEqual(messageEnum.Current.SessionId, msg.SessionId); Assert.AreEqual("testReason", msg.DeadLetterReason); Assert.AreEqual("testDescription", msg.DeadLetterErrorDescription); - await deadLetterReceiver.CompleteAsync(msg.LockToken); + await deadLetterReceiver.CompleteMessageAsync(msg.LockToken); } } Assert.AreEqual(0, remainingMessages); - var deadLetterMessage = await deadLetterReceiver.PeekAsync(); + var deadLetterMessage = await deadLetterReceiver.PeekMessageAsync(); Assert.IsNull(deadLetterMessage); } } @@ -471,10 +471,10 @@ public async Task DeadLetterMessagesSubscription(bool useSpecificSession) ServiceBusSender sender = client.CreateSender(scope.TopicName); var messageCount = 10; var sessionId = "sessionId1"; - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable messages = AddMessages(batch, messageCount, sessionId).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); var topicName = scope.TopicName; var subscriptionName = scope.SubscriptionNames.First(); @@ -490,7 +490,7 @@ public async Task DeadLetterMessagesSubscription(bool useSpecificSession) while (remainingMessages > 0) { - foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages)) + foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); @@ -501,12 +501,12 @@ public async Task DeadLetterMessagesSubscription(bool useSpecificSession) props[ServiceBusReceivedMessage.DeadLetterReasonHeader] = DateTime.UtcNow; props[ServiceBusReceivedMessage.DeadLetterErrorDescriptionHeader] = DateTime.UtcNow; - await receiver.DeadLetterAsync(item.LockToken, props); + await receiver.DeadLetterMessageAsync(item.LockToken, props); } } Assert.AreEqual(0, remainingMessages); - var peekedMessage = receiver.PeekAsync(); + var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); messageEnum.Reset(); @@ -515,7 +515,7 @@ public async Task DeadLetterMessagesSubscription(bool useSpecificSession) while (remainingMessages > 0) { - foreach (var msg in await deadLetterReceiver.ReceiveBatchAsync(remainingMessages)) + foreach (var msg in await deadLetterReceiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); @@ -525,12 +525,12 @@ public async Task DeadLetterMessagesSubscription(bool useSpecificSession) Assert.IsNull(msg.DeadLetterReason); Assert.IsNotNull(msg.Properties[ServiceBusReceivedMessage.DeadLetterReasonHeader]); Assert.IsNotNull(msg.Properties[ServiceBusReceivedMessage.DeadLetterErrorDescriptionHeader]); - await deadLetterReceiver.CompleteAsync(msg.LockToken); + await deadLetterReceiver.CompleteMessageAsync(msg.LockToken); } } Assert.AreEqual(0, remainingMessages); - var deadLetterMessage = await deadLetterReceiver.PeekAsync(); + var deadLetterMessage = await deadLetterReceiver.PeekMessageAsync(); Assert.IsNull(deadLetterMessage); } } @@ -547,10 +547,10 @@ public async Task DeferMessages(bool useSpecificSession) var messageCount = 10; var sessionId = "sessionId1"; - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable messages = AddMessages(batch, messageCount, sessionId).AsEnumerable(); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); var receiver = await client.CreateSessionReceiverAsync( scope.QueueName, @@ -563,18 +563,18 @@ public async Task DeferMessages(bool useSpecificSession) IList sequenceNumbers = new List(); while (remainingMessages > 0) { - foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages)) + foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId); sequenceNumbers.Add(item.SequenceNumber); - await receiver.DeferAsync(item.LockToken); + await receiver.DeferMessageAsync(item.LockToken); } } Assert.AreEqual(0, remainingMessages); - IList deferedMessages = await receiver.ReceiveDeferredMessageBatchAsync(sequenceNumbers); + IList deferedMessages = await receiver.ReceiveDeferredMessagesAsync(sequenceNumbers); var messageList = messages.ToList(); Assert.AreEqual(messageList.Count, deferedMessages.Count); @@ -599,8 +599,8 @@ public async Task RenewSessionLock(bool isSessionSpecified) ServiceBusMessage message = GetMessage(sessionId1); // send another session message before the one we are interested in to make sure that when isSessionSpecified=true, it is being respected - await sender.SendAsync(GetMessage("sessionId2")); - await sender.SendAsync(message); + await sender.SendMessageAsync(GetMessage("sessionId2")); + await sender.SendMessageAsync(message); ServiceBusSessionReceiver receiver = await client.CreateSessionReceiverAsync( scope.QueueName, @@ -612,7 +612,7 @@ public async Task RenewSessionLock(bool isSessionSpecified) { Assert.AreEqual(sessionId1, receiver.SessionId); } - ServiceBusReceivedMessage[] receivedMessages = (await receiver.ReceiveBatchAsync(messageCount)).ToArray(); + ServiceBusReceivedMessage[] receivedMessages = (await receiver.ReceiveMessagesAsync(messageCount)).ToArray(); var receivedMessage = receivedMessages.First(); var firstLockedUntilUtcTime = receiver.SessionLockedUntil; @@ -625,7 +625,7 @@ public async Task RenewSessionLock(bool isSessionSpecified) Assert.True(receiver.SessionLockedUntil >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(10)); // Complete Messages - await receiver.CompleteAsync(receivedMessage.LockToken); + await receiver.CompleteMessageAsync(receivedMessage.LockToken); Assert.AreEqual(messageCount, receivedMessages.Length); if (isSessionSpecified) @@ -633,7 +633,7 @@ public async Task RenewSessionLock(bool isSessionSpecified) Assert.AreEqual(message.MessageId, receivedMessage.MessageId); } - var peekedMessage = receiver.PeekAsync(); + var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); } } @@ -649,9 +649,9 @@ public async Task ReceiverThrowsAfterSessionLockLost(bool isSessionSpecified) ServiceBusSender sender = client.CreateSender(scope.QueueName); var sessionId1 = "sessionId1"; - await sender.SendAsync(GetMessage(sessionId1)); + await sender.SendMessageAsync(GetMessage(sessionId1)); // send another session message before the one we are interested in to make sure that when isSessionSpecified=true, it is being respected - await sender.SendAsync(GetMessage("sessionId2")); + await sender.SendMessageAsync(GetMessage("sessionId2")); ServiceBusSessionReceiver receiver = await client.CreateSessionReceiverAsync( scope.QueueName, @@ -664,11 +664,11 @@ public async Task ReceiverThrowsAfterSessionLockLost(bool isSessionSpecified) Assert.AreEqual(sessionId1, receiver.SessionId); } - var message = await receiver.ReceiveAsync(); + var message = await receiver.ReceiveMessageAsync(); await Task.Delay((receiver.SessionLockedUntil - DateTime.UtcNow) + TimeSpan.FromSeconds(5)); - Assert.That(async () => await receiver.ReceiveAsync(), + Assert.That(async () => await receiver.ReceiveMessageAsync(), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.SessionLockLost)); @@ -680,23 +680,23 @@ public async Task ReceiverThrowsAfterSessionLockLost(bool isSessionSpecified) Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.SessionLockLost)); - Assert.That(async () => await receiver.CompleteAsync(message), + Assert.That(async () => await receiver.CompleteMessageAsync(message), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.SessionLockLost)); - Assert.That(async () => await receiver.CompleteAsync(message), + Assert.That(async () => await receiver.CompleteMessageAsync(message), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.SessionLockLost)); - Assert.That(async () => await receiver.DeadLetterAsync(message), + Assert.That(async () => await receiver.DeadLetterMessageAsync(message), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.SessionLockLost)); - Assert.That(async () => await receiver.DeferAsync(message), + Assert.That(async () => await receiver.DeferMessageAsync(message), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.SessionLockLost)); - Assert.That(async () => await receiver.AbandonAsync(message), + Assert.That(async () => await receiver.AbandonMessageAsync(message), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.SessionLockLost)); } @@ -748,7 +748,7 @@ public async Task SessionReceiverThrowsWhenUsingNonSessionEntity() await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusMessage sentMessage = GetMessage(); - await sender.SendAsync(sentMessage); + await sender.SendMessageAsync(sentMessage); Assert.That( async () => await client.CreateSessionReceiverAsync(scope.QueueName), @@ -768,7 +768,7 @@ public async Task GetAndSetSessionStateTest(bool isSessionSpecified) ServiceBusSender sender = client.CreateSender(scope.QueueName); var sessionId = "test-sessionId"; ServiceBusMessage message = GetMessage(sessionId); - await sender.SendAsync(message); + await sender.SendMessageAsync(message); ServiceBusSessionReceiver receiver = await client.CreateSessionReceiverAsync( scope.QueueName, @@ -776,7 +776,7 @@ public async Task GetAndSetSessionStateTest(bool isSessionSpecified) { SessionId = isSessionSpecified ? sessionId : null }); - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); Assert.AreEqual(message.MessageId, receivedMessage.MessageId); Assert.AreEqual(message.SessionId, receivedMessage.SessionId); @@ -789,9 +789,9 @@ public async Task GetAndSetSessionStateTest(bool isSessionSpecified) Assert.AreEqual(sessionStateString, returnedSessionStateString); // Complete message using Session Receiver - await receiver.CompleteAsync(receivedMessage); + await receiver.CompleteMessageAsync(receivedMessage); - var peekedMessage = receiver.PeekAsync(); + var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); sessionStateString = "Completed Message On Session!"; diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/RuleManager/RuleManagerLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/RuleManager/RuleManagerLiveTests.cs index d85a11cfa812..fe9a1a89b00d 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/RuleManager/RuleManagerLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/RuleManager/RuleManagerLiveTests.cs @@ -210,7 +210,7 @@ await ruleManager.AddRuleAsync(new RuleDescription await SendMessages(client, scope.TopicName); var receiver = client.CreateReceiver(scope.TopicName, scope.SubscriptionNames.First()); - var messages = await receiver.ReceiveBatchAsync(Orders.Length, TimeSpan.FromSeconds(10)); + var messages = await receiver.ReceiveMessagesAsync(Orders.Length, TimeSpan.FromSeconds(10)); Assert.AreEqual(0, messages.Count()); } } @@ -548,7 +548,7 @@ private async Task SendMessages(ServiceBusClient client, string topicName) { "priority", Orders[i].Priority } } }; - await sender.SendAsync(message); + await sender.SendMessageAsync(message); } } @@ -564,7 +564,7 @@ private async Task> ReceiveAndAssertMessages( var remainingMessages = expectedOrders.Count(); while (remainingMessages > 0) { - foreach (var item in await receiver.ReceiveBatchAsync(Orders.Length).ConfigureAwait(false)) + foreach (var item in await receiver.ReceiveMessagesAsync(Orders.Length).ConfigureAwait(false)) { receivedMessages.Add(item); messageEnum.MoveNext(); diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample01_HelloWorld.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample01_HelloWorld.cs index 4c1ba0996227..50ad560f7c22 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample01_HelloWorld.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample01_HelloWorld.cs @@ -33,13 +33,13 @@ public async Task SendAndReceiveMessage() ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message - await sender.SendAsync(message); + await sender.SendMessageAsync(message); // create a receiver that we can use to receive the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // get the message body as a string string body = receivedMessage.Body.ToString(); @@ -65,13 +65,13 @@ public async Task SendAndPeekMessage() ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message - await sender.SendAsync(message); + await sender.SendMessageAsync(message); // create a receiver that we can use to receive the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); #region Snippet:ServiceBusPeek - ServiceBusReceivedMessage peekedMessage = await receiver.PeekAsync(); + ServiceBusReceivedMessage peekedMessage = await receiver.PeekMessageAsync(); #endregion // get the message body as a string @@ -101,7 +101,7 @@ public async Task SendAndReceiveMessageBatch() messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); messages.Add(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); // send the messages - await sender.SendAsync(messages); + await sender.SendMessagesAsync(messages); #endregion #endregion #region Snippet:ServiceBusReceiveBatch @@ -109,7 +109,7 @@ public async Task SendAndReceiveMessageBatch() ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties - IList receivedMessages = await receiver.ReceiveBatchAsync(maxMessages: 2); + IList receivedMessages = await receiver.ReceiveMessagesAsync(maxMessages: 2); foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages) { @@ -146,19 +146,19 @@ public async Task SendAndReceiveMessageSafeBatch() // create a message batch that we can send #region Snippet:ServiceBusSendAndReceiveSafeBatch - ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync(); - messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); - messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); + ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync(); + messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); + messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); // send the message batch - await sender.SendAsync(messageBatch); + await sender.SendMessagesAsync(messageBatch); #endregion // create a receiver that we can use to receive the messages ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties - IList receivedMessages = await receiver.ReceiveBatchAsync(maxMessages: 2); + IList receivedMessages = await receiver.ReceiveMessagesAsync(maxMessages: 2); foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages) { @@ -198,13 +198,13 @@ public async Task ScheduleMessage() // create a receiver that we can use to peek the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); - Assert.IsNotNull(await receiver.PeekAsync()); + Assert.IsNotNull(await receiver.PeekMessageAsync()); // cancel the scheduled messaged, thereby deleting from the service #region Snippet:ServiceBusCancelScheduled await sender.CancelScheduledMessageAsync(seq); #endregion - Assert.IsNull(await receiver.PeekAsync()); + Assert.IsNull(await receiver.PeekMessageAsync()); } } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample02_MessageSettlement.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample02_MessageSettlement.cs index ba36ae4bf1b4..ef004ee094e9 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample02_MessageSettlement.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample02_MessageSettlement.cs @@ -30,18 +30,18 @@ public async Task CompleteMessage() ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message - await sender.SendAsync(message); + await sender.SendMessageAsync(message); // create a receiver that we can use to receive and settle the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // complete the message, thereby deleting it from the service - await receiver.CompleteAsync(receivedMessage); + await receiver.CompleteMessageAsync(receivedMessage); #endregion - Assert.IsNull(await GetNoRetryClient().CreateReceiver(queueName).ReceiveAsync()); + Assert.IsNull(await GetNoRetryClient().CreateReceiver(queueName).ReceiveMessageAsync()); } } @@ -62,18 +62,18 @@ public async Task AbandonMessage() ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message - await sender.SendAsync(message); + await sender.SendMessageAsync(message); // create a receiver that we can use to receive and settle the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); #region Snippet:ServiceBusAbandonMessage - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // abandon the message, thereby releasing the lock and allowing it to be received again by this or other receivers - await receiver.AbandonAsync(receivedMessage); + await receiver.AbandonMessageAsync(receivedMessage); #endregion - Assert.IsNotNull(GetNoRetryClient().CreateReceiver(queueName).ReceiveAsync()); + Assert.IsNotNull(GetNoRetryClient().CreateReceiver(queueName).ReceiveMessageAsync()); } } @@ -94,17 +94,17 @@ public async Task DeferMessage() ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message - await sender.SendAsync(message); + await sender.SendMessageAsync(message); // create a receiver that we can use to receive and settle the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); #region Snippet:ServiceBusDeferMessage - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // defer the message, thereby preventing the message from being received again without using // the received deferred message API. - await receiver.DeferAsync(receivedMessage); + await receiver.DeferMessageAsync(receivedMessage); // receive the deferred message by specifying the service set sequence number of the original // received message @@ -131,20 +131,20 @@ public async Task DeadLetterMessage() ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message - await sender.SendAsync(message); + await sender.SendMessageAsync(message); // create a receiver that we can use to receive and settle the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); #region Snippet:ServiceBusDeadLetterMessage - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // deadletter the message, thereby preventing the message from being received again without receiving from the dead letter queue. - await receiver.DeadLetterAsync(receivedMessage); + await receiver.DeadLetterMessageAsync(receivedMessage); // receive the dead lettered message with receiver scoped to the dead letter queue. ServiceBusReceiver dlqReceiver = client.CreateDeadLetterReceiver(queueName); - ServiceBusReceivedMessage dlqMessage = await dlqReceiver.ReceiveAsync(); + ServiceBusReceivedMessage dlqMessage = await dlqReceiver.ReceiveMessageAsync(); #endregion Assert.IsNotNull(dlqMessage); } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample03_SendReceiveSessions.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample03_SendReceiveSessions.cs index 97758c781ca6..3e276e66c4a2 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample03_SendReceiveSessions.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample03_SendReceiveSessions.cs @@ -34,14 +34,14 @@ public async Task SendAndReceiveSessionMessage() }; // send the message - await sender.SendAsync(message); + await sender.SendMessageAsync(message); // create a session receiver that we can use to receive the message. Since we don't specify a // particular session, we will get the next available session from the service. ServiceBusSessionReceiver receiver = await client.CreateSessionReceiverAsync(queueName); // the received message is a different type as it contains some service set properties - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); Console.WriteLine(receivedMessage.SessionId); // we can also set arbitrary session state using this receiver @@ -72,20 +72,20 @@ public async Task ReceiveFromSpecificSession() ServiceBusSender sender = client.CreateSender(queueName); // create a message batch that we can send - ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync(); - messageBatch.TryAdd( + ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync(); + messageBatch.TryAddMessage( new ServiceBusMessage(Encoding.UTF8.GetBytes("First")) { SessionId = "Session1" }); - messageBatch.TryAdd( + messageBatch.TryAddMessage( new ServiceBusMessage(Encoding.UTF8.GetBytes("Second")) { SessionId = "Session2" }); // send the message batch - await sender.SendAsync(messageBatch); + await sender.SendMessagesAsync(messageBatch); #region Snippet:ServiceBusReceiveFromSpecificSession // create a receiver specifying a particular session @@ -97,7 +97,7 @@ public async Task ReceiveFromSpecificSession() }); // the received message is a different type as it contains some service set properties - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); Console.WriteLine(receivedMessage.SessionId); #endregion diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample04_Processor.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample04_Processor.cs index 7d1b8d692160..eeccd466f60b 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample04_Processor.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample04_Processor.cs @@ -31,12 +31,12 @@ public async Task ProcessMessages() ServiceBusSender sender = client.CreateSender(queueName); // create a message batch that we can send - ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync(); - messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); - messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); + ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync(); + messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); + messageBatch.TryAddMessage(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); // send the message batch - await sender.SendAsync(messageBatch); + await sender.SendMessagesAsync(messageBatch); // get the options to use for configuring the processor var options = new ServiceBusProcessorOptions diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample05_SessionProcessor.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample05_SessionProcessor.cs index 28eeea27e464..70aa0d581c1a 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample05_SessionProcessor.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample05_SessionProcessor.cs @@ -30,20 +30,20 @@ public async Task ProcessSessionMessages() ServiceBusSender sender = client.CreateSender(queueName); // create a message batch that we can send - ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync(); - messageBatch.TryAdd( + ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync(); + messageBatch.TryAddMessage( new ServiceBusMessage(Encoding.UTF8.GetBytes("First")) { SessionId = "Session1" }); - messageBatch.TryAdd( + messageBatch.TryAddMessage( new ServiceBusMessage(Encoding.UTF8.GetBytes("Second")) { SessionId = "Session2" }); // send the message batch - await sender.SendAsync(messageBatch); + await sender.SendMessagesAsync(messageBatch); // get the options to use for configuring the processor var options = new ServiceBusSessionProcessorOptions diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample06_Transactions.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample06_Transactions.cs index 28ac1e8f4632..f420285ae923 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample06_Transactions.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Samples/Sample06_Transactions.cs @@ -25,21 +25,21 @@ public async Task TransactionalSendAndComplete() //@@ await using var client = new ServiceBusClient(connectionString); ServiceBusSender sender = client.CreateSender(queueName); - await sender.SendAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); + await sender.SendMessageAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); ServiceBusReceiver receiver = client.CreateReceiver(queueName); - ServiceBusReceivedMessage firstMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage firstMessage = await receiver.ReceiveMessageAsync(); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await sender.SendAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); - await receiver.CompleteAsync(firstMessage); + await sender.SendMessageAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); + await receiver.CompleteMessageAsync(firstMessage); ts.Complete(); } #endregion - ServiceBusReceivedMessage secondMessage = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5)); + ServiceBusReceivedMessage secondMessage = await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(5)); Assert.NotNull(secondMessage); - await receiver.CompleteAsync(secondMessage); + await receiver.CompleteMessageAsync(secondMessage); }; } @@ -62,7 +62,7 @@ public async Task TransactionalSendVia() //@@ await using var client = new ServiceBusClient(connectionString); ServiceBusSender senderA = client.CreateSender(queueA); - await senderA.SendAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); + await senderA.SendMessageAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); ServiceBusSender senderBViaA = client.CreateSender(queueB, new ServiceBusSenderOptions { @@ -70,22 +70,22 @@ public async Task TransactionalSendVia() }); ServiceBusReceiver receiverA = client.CreateReceiver(queueA); - ServiceBusReceivedMessage firstMessage = await receiverA.ReceiveAsync(); + ServiceBusReceivedMessage firstMessage = await receiverA.ReceiveMessageAsync(); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await receiverA.CompleteAsync(firstMessage); - await senderBViaA.SendAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); + await receiverA.CompleteMessageAsync(firstMessage); + await senderBViaA.SendMessageAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); ts.Complete(); } #endregion - ServiceBusReceivedMessage secondMessage = await receiverA.ReceiveAsync(TimeSpan.FromSeconds(5)); + ServiceBusReceivedMessage secondMessage = await receiverA.ReceiveMessageAsync(TimeSpan.FromSeconds(5)); Assert.Null(secondMessage); ServiceBusReceiver receiverB = client.CreateReceiver(queueB); - secondMessage = await receiverB.ReceiveAsync(TimeSpan.FromSeconds(5)); + secondMessage = await receiverB.ReceiveMessageAsync(TimeSpan.FromSeconds(5)); Assert.NotNull(secondMessage); - await receiverB.CompleteAsync(secondMessage); + await receiverB.CompleteMessageAsync(secondMessage); }; } } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/SenderLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/SenderLiveTests.cs index c9431955e9f2..2d218dfa5cf4 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/SenderLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/SenderLiveTests.cs @@ -3,6 +3,7 @@ using System; using System.Collections.Generic; +using System.Linq; using System.Net; using System.Threading.Tasks; using Azure.Messaging.ServiceBus; @@ -19,7 +20,7 @@ public async Task SendConnString() await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { await using var sender = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString).CreateSender(scope.QueueName); - await sender.SendAsync(GetMessage()); + await sender.SendMessageAsync(GetMessage()); } } @@ -30,7 +31,7 @@ public async Task SendToken() { await using var client = new ServiceBusClient(TestEnvironment.FullyQualifiedNamespace, TestEnvironment.Credential); var sender = client.CreateSender(scope.QueueName); - await sender.SendAsync(GetMessage()); + await sender.SendMessageAsync(GetMessage()); } } @@ -51,7 +52,7 @@ public async Task SendConnectionTopic() await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options); ServiceBusSender sender = client.CreateSender(scope.TopicName); - await sender.SendAsync(GetMessage()); + await sender.SendMessageAsync(GetMessage()); } } @@ -72,7 +73,7 @@ public async Task SendTopicSession() await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options); ServiceBusSender sender = client.CreateSender(scope.TopicName); - await sender.SendAsync(GetMessage("sessionId")); + await sender.SendMessageAsync(GetMessage("sessionId")); } } @@ -83,10 +84,10 @@ public async Task CanSendAMessageBatch() { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); ServiceBusMessageBatch messageBatch = AddMessages(batch, 3); - await sender.SendAsync(messageBatch); + await sender.SendMessagesAsync(messageBatch); } } @@ -97,10 +98,10 @@ public async Task CanSendAnEmptyBodyMessageBatch() { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); - batch.TryAdd(new ServiceBusMessage(Array.Empty())); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); + batch.TryAddMessage(new ServiceBusMessage(Array.Empty())); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); } } @@ -111,14 +112,14 @@ public async Task CanSendLargeMessageBatch() { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); // Actual limit is 262144 bytes for a single message. - batch.TryAdd(new ServiceBusMessage(new byte[100000 / 3])); - batch.TryAdd(new ServiceBusMessage(new byte[100000 / 3])); - batch.TryAdd(new ServiceBusMessage(new byte[100000 / 3])); + batch.TryAddMessage(new ServiceBusMessage(new byte[100000 / 3])); + batch.TryAddMessage(new ServiceBusMessage(new byte[100000 / 3])); + batch.TryAddMessage(new ServiceBusMessage(new byte[100000 / 3])); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); } } @@ -129,12 +130,12 @@ public async Task CannotSendLargerThanMaximumSize() { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); // Actual limit is 262144 bytes for a single message. ServiceBusMessage message = new ServiceBusMessage(new byte[300000]); - Assert.That(async () => await sender.SendAsync(message), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessageSizeExceeded)); + Assert.That(async () => await sender.SendMessageAsync(message), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessageSizeExceeded)); } } @@ -145,13 +146,13 @@ public async Task TryAddReturnsFalseIfSizeExceed() { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); - using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); + using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); // Actual limit is 262144 bytes for a single message. - Assert.That(() => batch.TryAdd(new ServiceBusMessage(new byte[200000])), Is.True, "A message was rejected by the batch; all messages should be accepted."); - Assert.That(() => batch.TryAdd(new ServiceBusMessage(new byte[200000])), Is.False, "A message was rejected by the batch; message size exceed."); + Assert.That(() => batch.TryAddMessage(new ServiceBusMessage(new byte[200000])), Is.True, "A message was rejected by the batch; all messages should be accepted."); + Assert.That(() => batch.TryAddMessage(new ServiceBusMessage(new byte[200000])), Is.False, "A message was rejected by the batch; message size exceed."); - await sender.SendAsync(batch); + await sender.SendMessagesAsync(batch); } } @@ -174,18 +175,43 @@ public async Task Schedule() await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); await using var sender = client.CreateSender(scope.QueueName); var scheduleTime = DateTimeOffset.UtcNow.AddHours(10); - var sequenceNum = await sender.ScheduleMessageAsync(GetMessage(), scheduleTime); + var seq = await sender.ScheduleMessageAsync(GetMessage(), scheduleTime); await using var receiver = client.CreateReceiver(scope.QueueName); - ServiceBusReceivedMessage msg = await receiver.PeekAtAsync(sequenceNum); + ServiceBusReceivedMessage msg = await receiver.PeekMessageAsync(seq); Assert.AreEqual(0, Convert.ToInt32(new TimeSpan(scheduleTime.Ticks - msg.ScheduledEnqueueTime.Ticks).TotalSeconds)); - await sender.CancelScheduledMessageAsync(sequenceNum); - msg = await receiver.PeekAtAsync(sequenceNum); + await sender.CancelScheduledMessageAsync(seq); + msg = await receiver.PeekMessageAsync(seq); Assert.IsNull(msg); } } + [Test] + public async Task ScheduleMultiple() + { + await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) + { + await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); + await using var sender = client.CreateSender(scope.QueueName); + var scheduleTime = DateTimeOffset.UtcNow.AddHours(10); + var sequenceNums = await sender.ScheduleMessagesAsync(GetMessages(5), scheduleTime); + + await using var receiver = client.CreateReceiver(scope.QueueName); + foreach (long seq in sequenceNums) + { + ServiceBusReceivedMessage msg = await receiver.PeekMessageAsync(seq); + Assert.AreEqual(0, Convert.ToInt32(new TimeSpan(scheduleTime.Ticks - msg.ScheduledEnqueueTime.Ticks).TotalSeconds)); + } + await sender.CancelScheduledMessagesAsync(sequenceNumbers: sequenceNums); + foreach (long seq in sequenceNums) + { + ServiceBusReceivedMessage msg = await receiver.PeekMessageAsync(seq); + Assert.IsNull(msg); + } + } + } + [Test] public async Task CloseSenderShouldNotCloseConnection() { @@ -197,14 +223,14 @@ public async Task CloseSenderShouldNotCloseConnection() var sequenceNum = await sender.ScheduleMessageAsync(GetMessage(), scheduleTime); await sender.DisposeAsync(); // shouldn't close connection, but should close send link - Assert.That(async () => await sender.SendAsync(GetMessage()), + Assert.That(async () => await sender.SendMessageAsync(GetMessage()), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.ClientClosed)); Assert.That(async () => await sender.ScheduleMessageAsync(GetMessage(), default), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.ClientClosed)); Assert.That(async () => await sender.CancelScheduledMessageAsync(sequenceNum), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.ClientClosed)); // receive should still work await using var receiver = client.CreateReceiver(scope.QueueName); - ServiceBusReceivedMessage msg = await receiver.PeekAtAsync(sequenceNum); + ServiceBusReceivedMessage msg = await receiver.PeekMessageAsync(sequenceNum); Assert.AreEqual(0, Convert.ToInt32(new TimeSpan(scheduleTime.Ticks - msg.ScheduledEnqueueTime.Ticks).TotalSeconds)); } } @@ -218,7 +244,7 @@ public async Task CreateSenderWithoutParentReference() for (int i = 0; i < 10; i++) { await Task.Delay(1000); - await sender.SendAsync(GetMessage()); + await sender.SendMessageAsync(GetMessage()); } } } @@ -232,9 +258,9 @@ public async Task SendSessionMessageToNonSessionfulEntityShouldNotThrow() var sender = client.CreateSender(scope.QueueName); // this is apparently supported. The session is ignored by the service but can be used // as additional app data. Not recommended. - await sender.SendAsync(GetMessage("sessionId")); + await sender.SendMessageAsync(GetMessage("sessionId")); var receiver = client.CreateReceiver(scope.QueueName); - var msg = await receiver.ReceiveAsync(); + var msg = await receiver.ReceiveMessageAsync(); Assert.AreEqual("sessionId", msg.SessionId); } } @@ -246,7 +272,7 @@ public async Task SendNonSessionMessageToSessionfulEntityShouldThrow() { await using var sender = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString).CreateSender(scope.QueueName); Assert.That( - async () => await sender.SendAsync(GetMessage()), + async () => await sender.SendMessageAsync(GetMessage()), Throws.InstanceOf()); } } @@ -262,7 +288,7 @@ public async Task CanSendReceivedMessage() await using var sender = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString).CreateSender(scope.QueueName); var messageCt = 10; IEnumerable messages = GetMessages(messageCt); - await sender.SendAsync(messages); + await sender.SendMessagesAsync(messages); var receiver = client.CreateReceiver(scope.QueueName, new ServiceBusReceiverOptions() { @@ -273,7 +299,7 @@ public async Task CanSendReceivedMessage() IList receivedMessages = new List(); while (remainingMessages > 0) { - foreach (var msg in await receiver.ReceiveBatchAsync(messageCt)) + foreach (var msg in await receiver.ReceiveMessagesAsync(messageCt)) { remainingMessages--; receivedMessages.Add(msg); @@ -281,7 +307,7 @@ public async Task CanSendReceivedMessage() } foreach (ServiceBusReceivedMessage msg in receivedMessages) { - await sender.SendAsync(new ServiceBusMessage(msg)); + await sender.SendMessageAsync(new ServiceBusMessage(msg)); } var messageEnum = receivedMessages.GetEnumerator(); @@ -289,7 +315,7 @@ public async Task CanSendReceivedMessage() remainingMessages = messageCt; while (remainingMessages > 0) { - foreach (var msg in await receiver.ReceiveBatchAsync(remainingMessages)) + foreach (var msg in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); @@ -310,7 +336,7 @@ public async Task CreateBatchThrowsIftheEntityDoesNotExist() await using var client = new ServiceBusClient(connectionString); ServiceBusSender sender = client.CreateSender("FakeEntity"); - Assert.That(async () => await sender.CreateBatchAsync(), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); + Assert.That(async () => await sender.CreateMessageBatchAsync(), Throws.InstanceOf().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); } } } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/SenderTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/SenderTests.cs index c28a89e04c33..a508f5fb0820 100755 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/SenderTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/SenderTests.cs @@ -22,7 +22,7 @@ public void SendNullMessageShouldThrow() { CallBase = true }; - Assert.ThrowsAsync(async () => await mock.Object.SendAsync(message: null)); + Assert.ThrowsAsync(async () => await mock.Object.SendMessageAsync(null)); } [Test] @@ -32,7 +32,7 @@ public void SendNullMessageListShouldThrow() { CallBase = true }; - Assert.ThrowsAsync(async () => await mock.Object.SendAsync(messages: null)); + Assert.ThrowsAsync(async () => await mock.Object.SendMessagesAsync(messages: null)); } [Test] @@ -42,7 +42,7 @@ public async Task SendEmptyListShouldNotThrow() { CallBase = true }; - await mock.Object.SendAsync(new List()); + await mock.Object.SendMessagesAsync(new List()); } [Test] @@ -53,13 +53,13 @@ public async Task SendSingleDelegatesToSendList() CallBase = true }; mock - .Setup(m => m.SendAsync( + .Setup(m => m.SendMessagesAsync( It.Is>(value => value.Count() == 1), It.IsAny())) .Returns(Task.CompletedTask) .Verifiable("The single send should delegate to the list send."); - await mock.Object.SendAsync(new ServiceBusMessage()); + await mock.Object.SendMessageAsync(new ServiceBusMessage()); } [Test] @@ -69,7 +69,39 @@ public void SendNullBatchShouldThrow() { CallBase = true }; - Assert.ThrowsAsync(async () => await mock.Object.SendAsync((ServiceBusMessageBatch)null)); + Assert.ThrowsAsync(async () => await mock.Object.SendMessagesAsync((ServiceBusMessageBatch)null)); + } + + [Test] + public void ScheduleNullMessageShouldThrow() + { + var mock = new Mock() + { + CallBase = true + }; + Assert.ThrowsAsync(async () => await mock.Object.ScheduleMessageAsync(null, default)); + } + + [Test] + public void ScheduleNullMessageListShouldThrow() + { + var mock = new Mock() + { + CallBase = true + }; + Assert.ThrowsAsync(async () => await mock.Object.ScheduleMessagesAsync(null, default)); + } + + [Test] + public void ScheduleEmptyListShouldThrow() + { + var mock = new Mock() + { + CallBase = true + }; + Assert.ThrowsAsync(async () => await mock.Object.ScheduleMessagesAsync( + new List(), + default)); } [Test] @@ -164,7 +196,7 @@ public void CreateSenderUsingNullSendViaDoesNotThrow() } /// - /// Verifies functionality of the + /// Verifies functionality of the /// method. /// /// @@ -192,24 +224,24 @@ public async Task SendBatchManagesLockingTheBatch() .Setup(connection => connection.ThrowIfClosed()); mockTransportBatch - .Setup(transport => transport.TryAdd(It.IsAny())) + .Setup(transport => transport.TryAddMessage(It.IsAny())) .Returns(true); mockTransportSender .Setup(transport => transport.SendBatchAsync(It.IsAny(), It.IsAny())) .Returns(async () => await Task.WhenAny(completionSource.Task, Task.Delay(Timeout.Infinite, cancellationSource.Token))); - Assert.That(batch.TryAdd(new ServiceBusMessage(Array.Empty())), Is.True, "The batch should not be locked before sending."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(Array.Empty())), Is.True, "The batch should not be locked before sending."); var sender = new ServiceBusSender("dummy", null, mockConnection.Object); - var sendTask = sender.SendAsync(batch); + var sendTask = sender.SendMessagesAsync(batch); - Assert.That(() => batch.TryAdd(new ServiceBusMessage(Array.Empty())), Throws.InstanceOf(), "The batch should be locked while sending."); + Assert.That(() => batch.TryAddMessage(new ServiceBusMessage(Array.Empty())), Throws.InstanceOf(), "The batch should be locked while sending."); completionSource.TrySetResult(true); await sendTask; Assert.That(cancellationSource.IsCancellationRequested, Is.False, "The cancellation token should not have been signaled."); - Assert.That(batch.TryAdd(new ServiceBusMessage(Array.Empty())), Is.True, "The batch should not be locked after sending."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(Array.Empty())), Is.True, "The batch should not be locked after sending."); cancellationSource.Cancel(); } diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/ServiceBusMessageBatchTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/ServiceBusMessageBatchTests.cs index f77a69acee3b..209595966753 100755 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/ServiceBusMessageBatchTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Sender/ServiceBusMessageBatchTests.cs @@ -59,7 +59,7 @@ public void PropertyAccessIsDelegatedToTheTransportClient() } /// - /// Verifies property accessors for the + /// Verifies property accessors for the /// method. /// /// @@ -70,7 +70,7 @@ public void TryAddIsDelegatedToTheTransportClient() var batch = new ServiceBusMessageBatch(mockBatch); var message = new ServiceBusMessage(new byte[] { 0x21 }); - Assert.That(batch.TryAdd(message), Is.True, "The message should have been accepted."); + Assert.That(batch.TryAddMessage(message), Is.True, "The message should have been accepted."); Assert.That(mockBatch.TryAddCalledWith, Is.SameAs(message), "The message should have been passed with delegation."); } @@ -90,7 +90,7 @@ public void AsEnumerableIsDelegatedToTheTransportClient() } /// - /// Verifies property accessors for the + /// Verifies property accessors for the /// method. /// /// @@ -116,13 +116,13 @@ public void TryAddRespectsTheBatchLock() var batch = new ServiceBusMessageBatch(mockBatch); var message = new ServiceBusMessage(new byte[] { 0x21 }); - Assert.That(batch.TryAdd(new ServiceBusMessage(new byte[] { 0x21 })), Is.True, "The message should have been accepted before locking."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(new byte[] { 0x21 })), Is.True, "The message should have been accepted before locking."); batch.Lock(); - Assert.That(() => batch.TryAdd(new ServiceBusMessage(Array.Empty())), Throws.InstanceOf(), "The batch should not accept messages when locked."); + Assert.That(() => batch.TryAddMessage(new ServiceBusMessage(Array.Empty())), Throws.InstanceOf(), "The batch should not accept messages when locked."); batch.Unlock(); - Assert.That(batch.TryAdd(new ServiceBusMessage(Array.Empty())), Is.True, "The message should have been accepted after unlocking."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(Array.Empty())), Is.True, "The message should have been accepted after unlocking."); } /// @@ -137,7 +137,7 @@ public void ClearRespectsTheBatchLock() var batch = new ServiceBusMessageBatch(mockBatch); var messageData = new ServiceBusMessage(new byte[] { 0x21 }); - Assert.That(batch.TryAdd(new ServiceBusMessage(new byte[] { 0x21 })), Is.True, "The message should have been accepted before locking."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(new byte[] { 0x21 })), Is.True, "The message should have been accepted before locking."); batch.Lock(); Assert.That(() => batch.Clear(), Throws.InstanceOf(), "The batch should not accept messages when locked."); @@ -159,7 +159,7 @@ public void DisposeRespectsTheBatchLock() var mockBatch = new MockTransportBatch(); var batch = new ServiceBusMessageBatch(mockBatch); - Assert.That(batch.TryAdd(new ServiceBusMessage(new byte[] { 0x21 })), Is.True, "The message should have been accepted before locking."); + Assert.That(batch.TryAddMessage(new ServiceBusMessage(new byte[] { 0x21 })), Is.True, "The message should have been accepted before locking."); batch.Lock(); Assert.That(() => batch.Dispose(), Throws.InstanceOf(), "The batch should not accept messages when locked."); @@ -202,7 +202,7 @@ private class MockTransportBatch : TransportMessageBatch public override void Dispose() => DisposeInvoked = true; public override void Clear() => ClearInvoked = true; - public override bool TryAdd(ServiceBusMessage message) + public override bool TryAddMessage(ServiceBusMessage message) { TryAddCalledWith = message; return true; diff --git a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Transactions/TransactionLiveTests.cs b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Transactions/TransactionLiveTests.cs index ad322a5a5261..908b9efcc491 100644 --- a/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Transactions/TransactionLiveTests.cs +++ b/sdk/servicebus/Azure.Messaging.ServiceBus/tests/Transactions/TransactionLiveTests.cs @@ -30,17 +30,17 @@ public async Task TransactionalSendCommit(bool partitioned, bool sessionEnabled) partitioned ? "sessionId" : null); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await sender.SendAsync(message); + await sender.SendMessageAsync(message); ts.Complete(); } ServiceBusReceiver receiver = sessionEnabled ? await client.CreateSessionReceiverAsync(scope.QueueName) : client.CreateReceiver(scope.QueueName); - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message.Body.ToString(), receivedMessage.Body.ToString()); - await receiver.CompleteAsync(receivedMessage); + await receiver.CompleteMessageAsync(receivedMessage); }; } @@ -56,25 +56,25 @@ public async Task TransactionalSendMultipleSessions() ServiceBusMessage message2 = GetMessage("session2"); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await sender.SendAsync(message1); + await sender.SendMessageAsync(message1); await sender.ScheduleMessageAsync(message2, DateTimeOffset.UtcNow); ts.Complete(); } ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(scope.QueueName); - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message1.Body.ToString(), receivedMessage.Body.ToString()); - await receiver.CompleteAsync(receivedMessage); + await receiver.CompleteMessageAsync(receivedMessage); receiver = await client.CreateSessionReceiverAsync(scope.QueueName); - receivedMessage = await receiver.ReceiveAsync(); + receivedMessage = await receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message2.Body.ToString(), receivedMessage.Body.ToString()); - await receiver.CompleteAsync(receivedMessage); + await receiver.CompleteMessageAsync(receivedMessage); }; } @@ -94,7 +94,7 @@ public async Task TransactionalSendMultipleSessionsRollback() ServiceBusMessage message2 = GetMessage("session2"); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await sender.SendAsync(message1); + await sender.SendMessageAsync(message1); await sender.ScheduleMessageAsync(message2, DateTimeOffset.UtcNow.AddMinutes(1)); } Assert.That( @@ -124,7 +124,7 @@ public async Task TransactionalCancelScheduleRollback() await sender.CancelScheduledMessageAsync(seq); } ServiceBusReceiver receiver = client.CreateReceiver(scope.QueueName); - ServiceBusReceivedMessage msg = await receiver.PeekAsync(); + ServiceBusReceivedMessage msg = await receiver.PeekMessageAsync(); Assert.NotNull(msg); }; } @@ -138,20 +138,20 @@ public async Task TransactionalSendAndReceiveSubscription() ServiceBusSender sender = client.CreateSender(scope.TopicName); ServiceBusMessage message = GetMessage(); - await sender.SendAsync(message); + await sender.SendMessageAsync(message); ServiceBusReceiver receiver = client.CreateReceiver(scope.TopicName, scope.SubscriptionNames.First()); - ServiceBusReceivedMessage received = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage received = await receiver.ReceiveMessageAsync(); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await sender.SendAsync(GetMessage()); - await receiver.CompleteAsync(received); + await sender.SendMessageAsync(GetMessage()); + await receiver.CompleteMessageAsync(received); ts.Complete(); } - received = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5)); + received = await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(5)); Assert.NotNull(received); - await receiver.CompleteAsync(received); + await receiver.CompleteMessageAsync(received); }; } @@ -172,7 +172,7 @@ public async Task TransactionalSendRollback(bool partitioned, bool sessionEnable partitioned ? "sessionId" : null); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await sender.SendAsync(message); + await sender.SendMessageAsync(message); // not completing the transaction } @@ -185,7 +185,7 @@ await client.CreateSessionReceiverAsync( }) : client.CreateReceiver(scope.QueueName); - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5)); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(5)); Assert.IsNull(receivedMessage); }; @@ -207,23 +207,23 @@ public async Task TransactionalCompleteRollback(bool partitioned, bool sessionEn ServiceBusMessage message = GetMessage( sessionEnabled ? "sessionId" : null, partitioned ? "sessionId" : null); - await sender.SendAsync(message); + await sender.SendMessageAsync(message); ServiceBusReceiver receiver = sessionEnabled ? await client.CreateSessionReceiverAsync(scope.QueueName) : client.CreateReceiver(scope.QueueName); - var receivedMessage = await receiver.ReceiveAsync(); + var receivedMessage = await receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual( message.Body.ToString(), receivedMessage.Body.ToString()); var sequenceNumber = receivedMessage.SequenceNumber; - await receiver.DeferAsync(receivedMessage); + await receiver.DeferMessageAsync(receivedMessage); ServiceBusReceivedMessage deferredMessage = await receiver.ReceiveDeferredMessageAsync(sequenceNumber); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await receiver.CompleteAsync(deferredMessage); + await receiver.CompleteMessageAsync(deferredMessage); } // Adding delay since transaction Commit/Rollback is an asynchronous operation. @@ -234,7 +234,7 @@ public async Task TransactionalCompleteRollback(bool partitioned, bool sessionEn { using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await receiver.CompleteAsync(deferredMessage); + await receiver.CompleteMessageAsync(deferredMessage); ts.Complete(); } // Adding delay since transaction Commit/Rollback is an asynchronous operation. @@ -243,12 +243,12 @@ public async Task TransactionalCompleteRollback(bool partitioned, bool sessionEn } else { - await receiver.CompleteAsync(deferredMessage); + await receiver.CompleteMessageAsync(deferredMessage); } Assert.That( async () => - await receiver.CompleteAsync(deferredMessage), Throws.InstanceOf() + await receiver.CompleteMessageAsync(deferredMessage), Throws.InstanceOf() .And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.MessageLockLost)); } @@ -271,9 +271,9 @@ public async Task TransactionThrowsWhenOperationsOfDifferentPartitionsAreInSameT var transaction = new CommittableTransaction(); using (TransactionScope ts = new TransactionScope(transaction, TransactionScopeAsyncFlowOption.Enabled)) { - await sender.SendAsync(message1); + await sender.SendMessageAsync(message1); Assert.ThrowsAsync( - async () => await sender.SendAsync(message2)); + async () => await sender.SendMessageAsync(message2)); ts.Complete(); } @@ -284,21 +284,21 @@ public async Task TransactionThrowsWhenOperationsOfDifferentPartitionsAreInSameT await Task.Delay(TimeSpan.FromSeconds(2)); // Two complete operations to different partitions. - await sender.SendAsync(message1); - await sender.SendAsync(message2); + await sender.SendMessageAsync(message1); + await sender.SendMessageAsync(message2); - ServiceBusReceivedMessage receivedMessage1 = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage1 = await receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage1); - ServiceBusReceivedMessage receivedMessage2 = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage2 = await receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage2); transaction = new CommittableTransaction(); using (TransactionScope ts = new TransactionScope(transaction, TransactionScopeAsyncFlowOption.Enabled)) { - await receiver.CompleteAsync(receivedMessage1); + await receiver.CompleteMessageAsync(receivedMessage1); Assert.ThrowsAsync( - async () => await receiver.CompleteAsync(receivedMessage2)); + async () => await receiver.CompleteMessageAsync(receivedMessage2)); ts.Complete(); } @@ -308,14 +308,14 @@ public async Task TransactionThrowsWhenOperationsOfDifferentPartitionsAreInSameT // Operating on the same message should not be done. await Task.Delay(TimeSpan.FromSeconds(2)); - await receiver.CompleteAsync(receivedMessage1); + await receiver.CompleteMessageAsync(receivedMessage1); // the service seems to abandon the message that // triggered the InvalidOperationException // in the transaction Assert.That( async () => - await receiver.CompleteAsync(receivedMessage2), Throws.InstanceOf() + await receiver.CompleteMessageAsync(receivedMessage2), Throws.InstanceOf() .And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.MessageLockLost)); } @@ -332,16 +332,16 @@ public async Task TransactionCommitWorksUsingSendersAndReceiversFromSameClients( ServiceBusMessage message1 = GetMessage(); ServiceBusMessage message2 = GetMessage(); - await sender.SendAsync(message1); + await sender.SendMessageAsync(message1); - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message1.Body.ToString(), receivedMessage.Body.ToString()); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await receiver.CompleteAsync(receivedMessage); - await sender.SendAsync(message2); + await receiver.CompleteMessageAsync(receivedMessage); + await sender.SendMessageAsync(message2); ts.Complete(); } @@ -352,15 +352,15 @@ public async Task TransactionCommitWorksUsingSendersAndReceiversFromSameClients( // Assert that complete did succeed Assert.That( async () => - await receiver.CompleteAsync(receivedMessage), Throws.InstanceOf() + await receiver.CompleteMessageAsync(receivedMessage), Throws.InstanceOf() .And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.MessageLockLost)); // Assert that send did succeed - receivedMessage = await receiver.ReceiveAsync(); + receivedMessage = await receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message2.Body.ToString(), receivedMessage.Body.ToString()); - await receiver.CompleteAsync(receivedMessage); + await receiver.CompleteMessageAsync(receivedMessage); } } @@ -376,19 +376,19 @@ public async Task TransactionCommitThrowsUsingDifferentClientsToSameEntity() ServiceBusMessage message1 = GetMessage(); ServiceBusMessage message2 = GetMessage(); - await sender.SendAsync(message1); + await sender.SendMessageAsync(message1); - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message1.Body.ToString(), receivedMessage.Body.ToString()); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await receiver.CompleteAsync(receivedMessage); + await receiver.CompleteMessageAsync(receivedMessage); Assert.That( async () => - await sender.SendAsync(message2), Throws.InstanceOf()); + await sender.SendMessageAsync(message2), Throws.InstanceOf()); ts.Complete(); } } @@ -405,16 +405,16 @@ public async Task TransactionRollbackWorksAcrossClientsUsingSameConnectionToSame ServiceBusMessage message1 = GetMessage(); ServiceBusMessage message2 = GetMessage(); - await sender.SendAsync(message1); + await sender.SendMessageAsync(message1); - ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); + ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message1.Body.ToString(), receivedMessage.Body.ToString()); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await receiver.CompleteAsync(receivedMessage.LockToken); - await sender.SendAsync(message2); + await receiver.CompleteMessageAsync(receivedMessage.LockToken); + await sender.SendMessageAsync(message2); } // Adding delay since transaction Commit/Rollback is an asynchronous operation. @@ -422,10 +422,10 @@ public async Task TransactionRollbackWorksAcrossClientsUsingSameConnectionToSame await Task.Delay(TimeSpan.FromSeconds(2)); // Following should succeed without exceptions - await receiver.CompleteAsync(receivedMessage.LockToken); + await receiver.CompleteMessageAsync(receivedMessage.LockToken); // Assert that send failed - receivedMessage = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5)); + receivedMessage = await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(5)); Assert.Null(receivedMessage); } } @@ -456,26 +456,26 @@ public async Task TransactionalSendViaCommitTest() var message2 = new ServiceBusMessage(body) { MessageId = "2", PartitionKey = "pk2", ViaPartitionKey = "pk1" }; var message3 = new ServiceBusMessage(body) { MessageId = "3", PartitionKey = "pk3", ViaPartitionKey = "pk1" }; - await intermediateSender.SendAsync(message1).ConfigureAwait(false); - var receivedMessage = await intermediateReceiver.ReceiveAsync(); + await intermediateSender.SendMessageAsync(message1).ConfigureAwait(false); + var receivedMessage = await intermediateReceiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual("pk1", receivedMessage.PartitionKey); // If the transaction succeeds, then all the operations occurred on the same partition. using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await intermediateReceiver.CompleteAsync(receivedMessage); - await destination1ViaSender.SendAsync(message2); - await destination2ViaSender.SendAsync(message3); + await intermediateReceiver.CompleteMessageAsync(receivedMessage); + await destination1ViaSender.SendMessageAsync(message2); + await destination2ViaSender.SendMessageAsync(message3); ts.Complete(); } // Assert that first message indeed completed. - receivedMessage = await intermediateReceiver.ReceiveAsync(TimeSpan.FromSeconds(5)); + receivedMessage = await intermediateReceiver.ReceiveMessageAsync(TimeSpan.FromSeconds(5)); Assert.Null(receivedMessage); // Assert that second message reached its destination. - var receivedMessage1 = await destination1Receiver.ReceiveAsync(); + var receivedMessage1 = await destination1Receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage1); Assert.AreEqual("pk2", receivedMessage1.PartitionKey); @@ -486,20 +486,20 @@ public async Task TransactionalSendViaCommitTest() }; using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { - await destination1Receiver.CompleteAsync(receivedMessage1); - await destination1Sender.SendAsync(destination1Message); + await destination1Receiver.CompleteMessageAsync(receivedMessage1); + await destination1Sender.SendMessageAsync(destination1Message); ts.Complete(); } // Assert that third message reached its destination. - var receivedMessage2 = await destination2Receiver.ReceiveAsync(); + var receivedMessage2 = await destination2Receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage2); Assert.AreEqual("pk3", receivedMessage2.PartitionKey); - await destination2Receiver.CompleteAsync(receivedMessage2); + await destination2Receiver.CompleteMessageAsync(receivedMessage2); // Cleanup - receivedMessage1 = await destination1Receiver.ReceiveAsync(); - await destination1Receiver.CompleteAsync(receivedMessage1); + receivedMessage1 = await destination1Receiver.ReceiveMessageAsync(); + await destination1Receiver.CompleteMessageAsync(receivedMessage1); } }