public async Task ReceiveSingleMessageLogsEvents()
{
var mockLogger = new Mock <ServiceBusEventSource>();
var mockTransportReceiver = new Mock <TransportReceiver>();
var mockConnection = GetMockConnection(mockTransportReceiver);
mockTransportReceiver.Setup(
transportReceiver => transportReceiver.ReceiveMessagesAsync(
1,
It.IsAny <TimeSpan?>(),
It.IsAny <CancellationToken>()))
.Returns(
Task.FromResult((IReadOnlyList <ServiceBusReceivedMessage>)
new List <ServiceBusReceivedMessage> {
new ServiceBusReceivedMessage()
}));
var receiver = new ServiceBusReceiver(
mockConnection.Object,
"queueName",
false,
new ServiceBusPlugin[] { },
new ServiceBusReceiverOptions())
{
Logger = mockLogger.Object
};
await receiver.ReceiveMessageAsync();
mockLogger
.Verify(
log => log.ReceiveMessageStart(
receiver.Identifier,
1),
Times.Once);
mockLogger
.Verify(
log => log.ReceiveMessageComplete(
receiver.Identifier,
1),
Times.Once);
mockLogger
.Verify(
log => log.MaxMessagesExceedsPrefetch(
receiver.Identifier,
receiver.PrefetchCount,
1),
Times.Never);
}
public async Task TransactionalSendVia()
{
await using (var scopeA = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var scopeB = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false);
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueA = scopeA.QueueName;
string queueB = scopeB.QueueName;
await using var client = GetClient();
#region Snippet:ServiceBusTransactionalSendVia
//@@ string connectionString = "<connection_string>";
//@@ string queueA = "<queue_name>";
//@@ string queueB = "<other_queue_name>";
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
//@@ await using var client = new ServiceBusClient(connectionString);
ServiceBusSender senderA = client.CreateSender(queueA);
await senderA.SendAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("First")));
ServiceBusSender senderBViaA = client.CreateSender(queueB, new ServiceBusSenderOptions
{
ViaQueueOrTopicName = queueA
});
ServiceBusReceiver receiverA = client.CreateReceiver(queueA);
ServiceBusReceivedMessage firstMessage = await receiverA.ReceiveAsync();
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await receiverA.CompleteAsync(firstMessage);
await senderBViaA.SendAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second")));
ts.Complete();
}
#endregion
ServiceBusReceivedMessage secondMessage = await receiverA.ReceiveAsync(TimeSpan.FromSeconds(5));
Assert.Null(secondMessage);
ServiceBusReceiver receiverB = client.CreateReceiver(queueB);
secondMessage = await receiverB.ReceiveAsync(TimeSpan.FromSeconds(5));
Assert.NotNull(secondMessage);
await receiverB.CompleteAsync(secondMessage);
};
}
public async Task SendAndReceiveMessageBatch()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
#region Snippet:ServiceBusInitializeSend
#if SNIPPET
string connectionString = "<connection_string>";
string queueName = "<queue_name>";
#else
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
#endif
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);
// create the sender
ServiceBusSender sender = client.CreateSender(queueName);
#region Snippet:ServiceBusSendAndReceiveBatch
IList <ServiceBusMessage> messages = new List <ServiceBusMessage>();
messages.Add(new ServiceBusMessage("First"));
messages.Add(new ServiceBusMessage("Second"));
// send the messages
await sender.SendMessagesAsync(messages);
#endregion
#endregion
#region Snippet:ServiceBusReceiveBatch
// 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
IReadOnlyList <ServiceBusReceivedMessage> receivedMessages = await receiver.ReceiveMessagesAsync(maxMessages : 2);
foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages)
{
// get the message body as a string
string body = receivedMessage.Body.ToString();
Console.WriteLine(body);
}
#endregion
var sentMessagesEnum = messages.GetEnumerator();
foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages)
{
sentMessagesEnum.MoveNext();
Assert.AreEqual(sentMessagesEnum.Current.Body.ToString(), receivedMessage.Body.ToString());
}
}
}
public async Task ForwardingEntity()
{
// queueName--Fwd to--> destinationName--fwd dlq to-- > dqlDestinationName
var queueName = Recording.Random.NewGuid().ToString("D").Substring(0, 8);
var destinationName = Recording.Random.NewGuid().ToString("D").Substring(0, 8);
var dlqDestinationName = Recording.Random.NewGuid().ToString("D").Substring(0, 8);
var mgmtClient = CreateClient();
await mgmtClient.CreateQueueAsync(dlqDestinationName);
await mgmtClient.CreateQueueAsync(
new CreateQueueOptions(destinationName)
{
ForwardDeadLetteredMessagesTo = dlqDestinationName
});
await mgmtClient.CreateQueueAsync(
new CreateQueueOptions(queueName)
{
ForwardTo = destinationName
});
await using var sbClient = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = sbClient.CreateSender(queueName);
await sender.SendMessageAsync(new ServiceBusMessage()
{
MessageId = "mid"
});
ServiceBusReceiver receiver = sbClient.CreateReceiver(destinationName);
ServiceBusReceivedMessage msg = await receiver.ReceiveMessageAsync();
Assert.NotNull(msg);
Assert.AreEqual("mid", msg.MessageId);
await receiver.DeadLetterMessageAsync(msg.LockToken);
receiver = sbClient.CreateReceiver(dlqDestinationName);
msg = await receiver.ReceiveMessageAsync();
Assert.NotNull(msg);
Assert.AreEqual("mid", msg.MessageId);
await receiver.CompleteMessageAsync(msg.LockToken);
await mgmtClient.DeleteQueueAsync(queueName);
await mgmtClient.DeleteQueueAsync(destinationName);
await mgmtClient.DeleteQueueAsync(dlqDestinationName);
}
public async Task TransactionGroup()
{
await using var client = new ServiceBusClient(
TestEnvironment.ServiceBusConnectionString,
new ServiceBusClientOptions
{
EnableCrossEntityTransactions = true
});
await using var queueA = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false);
await using var queueB = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false);
await using var topicC = await ServiceBusScope.CreateWithTopic(enablePartitioning : false, enableSession : false);
// The first sender won't be part of our transaction and is
// used only to populate the queue.
ServiceBusSender senderA = client.CreateSender(queueA.QueueName);
await senderA.SendMessageAsync(new ServiceBusMessage());
ServiceBusReceiver receiverA = client.CreateReceiver(queueA.QueueName);
ServiceBusSender senderB = client.CreateSender(queueB.QueueName);
ServiceBusSender senderC = client.CreateSender(topicC.TopicName);
#region Snippet:ServiceBusTransactionGroup
//@@ var options = new ServiceBusClientOptions { EnableCrossEntityTransactions = true };
//@@ await using var client = new ServiceBusClient(connectionString, options);
//@@ ServiceBusReceiver receiverA = client.CreateReceiver("queueA");
//@@ ServiceBusSender senderB = client.CreateSender("queueB");
//@@ ServiceBusSender senderC = client.CreateSender("topicC");
ServiceBusReceivedMessage receivedMessage = await receiverA.ReceiveMessageAsync();
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await receiverA.CompleteMessageAsync(receivedMessage);
await senderB.SendMessageAsync(new ServiceBusMessage());
await senderC.SendMessageAsync(new ServiceBusMessage());
ts.Complete();
}
#endregion
receivedMessage = await receiverA.ReceiveMessageAsync();
Assert.IsNull(receivedMessage);
}
public async Task PeekBatchOfMessagesLogsEvents(bool specifySeqNumber)
{
var mockLogger = new Mock <ServiceBusEventSource>();
var maxMessages = 4;
var mockTransportReceiver = new Mock <TransportReceiver>();
var mockConnection = GetMockConnection(mockTransportReceiver);
mockTransportReceiver.Setup(
transportReceiver => transportReceiver.PeekMessagesAsync(
It.IsAny <long?>(),
maxMessages,
It.IsAny <CancellationToken>()))
.Returns(
Task.FromResult((IReadOnlyList <ServiceBusReceivedMessage>)
new List <ServiceBusReceivedMessage> {
new ServiceBusReceivedMessage(),
new ServiceBusReceivedMessage()
}));
var receiver = new ServiceBusReceiver(
mockConnection.Object,
"queueName",
false,
new ServiceBusPlugin[] { },
new ServiceBusReceiverOptions())
{
Logger = mockLogger.Object
};
var seqNumber = 5;
IReadOnlyList <ServiceBusReceivedMessage> msgs;
msgs = await receiver.PeekMessagesAsync(maxMessages, specifySeqNumber?seqNumber : (long?)null);
mockLogger
.Verify(
log => log.PeekMessageStart(
receiver.Identifier,
specifySeqNumber ? (long?)seqNumber : null,
// the amount requested
maxMessages),
Times.Once);
mockLogger
.Verify(
log => log.PeekMessageComplete(
receiver.Identifier,
// the amount we actually received
msgs.Count),
Times.Once);
}
public void CreateEventArgs_WithServiceBusReceiver_GetsServiceBusReceiverSucceeds()
{
// Arrange
Order order = OrderGenerator.Generate();
ServiceBusReceivedMessage message = order.AsServiceBusReceivedMessage();
var expectedReceiver = Mock.Of <ServiceBusReceiver>();
// Act
var eventArgs = new ProcessMessageEventArgs(message, expectedReceiver, CancellationToken.None);
// Assert
ServiceBusReceiver actualReceiver = eventArgs.GetServiceBusReceiver();
Assert.Equal(expectedReceiver, actualReceiver);
}
public static async Task <long> DeferMessageAsync(string connectionString, string queueName)
{
await using var client = new ServiceBusClient(connectionString);
// create a receiver that we can use to receive the message
ServiceBusReceiver receiver = client.CreateReceiver(queueName);
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.DeferMessageAsync(receivedMessage);
return(receivedMessage.SequenceNumber);
}
public static async Task TopicNoSessions(
[ServiceBusTrigger(TopicNameKey, FirstSubscriptionNameKey)] ServiceBusReceivedMessage msg,
ServiceBusReceiver messageReceiver,
CancellationToken cancellationToken,
ILogger logger)
{
logger.LogInformation($"DrainModeValidationFunctions.NoSessions: message data {msg.Body}");
_drainValidationPreDelay.Set();
await DrainModeHelper.WaitForCancellation(cancellationToken);
Assert.True(cancellationToken.IsCancellationRequested);
await messageReceiver.CompleteMessageAsync(msg);
_drainValidationPostDelay.Set();
}
public void Setup()
{
_mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);
_client = new ServiceBusClient(_testConnection);
ServiceBusProcessorOptions processorOptions = new ServiceBusProcessorOptions();
ServiceBusProcessor messageProcessor = _client.CreateProcessor(_entityPath);
ServiceBusReceiver receiver = _client.CreateReceiver(_entityPath);
_mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, messageProcessor);
var configuration = ConfigurationUtilities.CreateConfiguration(new KeyValuePair <string, string>(_connection, _testConnection));
_serviceBusOptions = new ServiceBusOptions();
_mockProvider = new Mock <MessagingProvider>(new OptionsWrapper <ServiceBusOptions>(_serviceBusOptions));
_mockClientFactory = new Mock <ServiceBusClientFactory>(
configuration,
Mock.Of <AzureComponentFactory>(),
_mockProvider.Object,
new AzureEventSourceLogForwarder(new NullLoggerFactory()),
new OptionsWrapper <ServiceBusOptions>(_serviceBusOptions));
_mockProvider
.Setup(p => p.CreateMessageProcessor(_client, _entityPath, It.IsAny <ServiceBusProcessorOptions>()))
.Returns(_mockMessageProcessor.Object);
_mockProvider
.Setup(p => p.CreateClient(_testConnection, It.IsAny <ServiceBusClientOptions>()))
.Returns(_client);
_loggerFactory = new LoggerFactory();
_loggerProvider = new TestLoggerProvider();
_loggerFactory.AddProvider(_loggerProvider);
_listener = new ServiceBusListener(
_functionId,
ServiceBusEntityType.Queue,
_entityPath,
false,
_serviceBusOptions.AutoCompleteMessages,
_mockExecutor.Object,
_serviceBusOptions,
_connection,
_mockProvider.Object,
_loggerFactory,
false,
_mockClientFactory.Object);
_scaleMonitor = (ServiceBusScaleMonitor)_listener.GetMonitor();
}
public async Task AbandonMessages(bool useSpecificSession)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
ServiceBusReceiver receiver = await client.GetSessionReceiverAsync(
scope.QueueName,
sessionId : useSpecificSession?sessionId : null);
var messageEnum = messages.GetEnumerator();
var remainingMessages = messageCount;
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
await receiver.AbandonAsync(item.LockToken);
Assert.AreEqual(item.DeliveryCount, 1);
}
}
Assert.AreEqual(0, remainingMessages);
messageEnum.Reset();
var receivedMessageCount = 0;
foreach (var item in await receiver.PeekBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
}
Assert.AreEqual(messageCount, receivedMessageCount);
}
}
public async Task ReceiveMessagesWhenQueueEmpty()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, new ServiceBusClientOptions
{
RetryOptions =
{
// very high TryTimeout
TryTimeout = TimeSpan.FromSeconds(120)
}
});
var messageCount = 2;
var sessionId = "sessionId1";
ServiceBusSender sender = client.CreateSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendMessagesAsync(batch);
ServiceBusReceiver receiver = await client.AcceptNextSessionAsync(
scope.QueueName,
new ServiceBusSessionReceiverOptions
{
PrefetchCount = 100
});
var remainingMessages = messageCount;
while (remainingMessages > 0)
{
foreach (var message in await receiver.ReceiveMessagesAsync(remainingMessages))
{
await receiver.CompleteMessageAsync(message);
remainingMessages--;
}
}
using var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(3));
var start = DateTime.UtcNow;
Assert.ThrowsAsync <TaskCanceledException>(async() => await receiver.ReceiveMessagesAsync(1, cancellationToken: cancellationTokenSource.Token));
var stop = DateTime.UtcNow;
Assert.That(stop - start, Is.EqualTo(TimeSpan.FromSeconds(3)).Within(TimeSpan.FromSeconds(3)));
}
}
private static async Task ReceiveMessageAsync(string connectionString, string queueName)
{
// create a Service Bus client
await using (ServiceBusClient client = new ServiceBusClient(connectionString))
{
// create a sender for the queue
ServiceBusReceiver receiver = client.CreateReceiver(queueName, new ServiceBusReceiverOptions()
{
ReceiveMode = ServiceBusReceiveMode.PeekLock
});
// receive the message
Console.WriteLine($"Sent a single message to the queue: {queueName}");
}
}
/// <summary>
/// Initialize a received item with all Sql Transactional Outbox data. The resulting item will
/// allow for specific handling of the Message Acknowledgement/Rejection/Dead-lettering if the correct Reciever is provided.
/// NOTE: With Azure Functions there is no client when used with Function Bindings because this is handled
/// by the Azure Functions framework when the Message is returned, so this should be a No-op if null/not-specified!
/// </summary>
/// <param name="azureServiceBusMessage"></param>
/// <param name="outboxItemFactory"></param>
/// <param name="azureServiceBusReceiverClient"></param>
public AzureServiceBusReceivedItem(
ServiceBusReceivedMessage azureServiceBusMessage,
ISqlTransactionalOutboxItemFactory <TUniqueIdentifier, TPayloadBody> outboxItemFactory,
//Client is OPTIONAL; necessary when processing will be handled by AzureFunctions framework bindings, etc.
ServiceBusReceiver azureServiceBusReceiverClient = null
)
{
//Provide access to the original Azure Service Bus Message for customized Advanced functionality.
this.AzureServiceBusMessage = azureServiceBusMessage.AssertNotNull(nameof(azureServiceBusMessage));
this.ServiceBusReceiver = azureServiceBusReceiverClient;
this.OutboxItemFactory = outboxItemFactory.AssertNotNull(nameof(outboxItemFactory));
bool isFifoProcessingEnabled = azureServiceBusReceiverClient is ServiceBusSessionReceiver;
this.InitAzureServiceBusOutboxReceivedItem(isFifoProcessingEnabled);
}
public MessageServiceAzureServiceBus(ApplicationSettings applicationSettings)
{
_applicationSettings = applicationSettings;
// Create a ServiceBusClient that will authenticate using a connection string
string connectionString = _applicationSettings.QueueConnectionString;
string queueName = _applicationSettings.QueueName;
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
var options = new ServiceBusClientOptions {
EnableCrossEntityTransactions = true
};
var client = new ServiceBusClient(connectionString, options);
// Create the sender and receiver
_sender = client.CreateSender(queueName);
_receiver = client.CreateReceiver(queueName);
}
// Passes service bus message from a queue to another queue
public async Task SBQueue2SBQueue(
[ServiceBusTrigger(FirstQueueNameKey)] string start, int deliveryCount,
ServiceBusReceiver messageReceiver,
string lockToken,
[ServiceBus(SecondQueueNameKey)] ServiceBusSender messageSender)
{
Assert.AreEqual(_firstQueueScope.QueueName, messageReceiver.EntityPath);
Assert.AreEqual(1, deliveryCount);
// verify the message receiver and token are valid
// TODO lockToken overload not supported in new SDK
//await messageReceiver.RenewLockAsync(lockToken);
var message = SBQueue2SBQueue_GetOutputMessage(start);
await messageSender.SendMessageAsync(message);
}
public async Task SendAndReceiveMessageSafeBatch()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
//@@ string connectionString = "<connection_string>";
//@@ string queueName = "<queue_name>";
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);
// create the sender
ServiceBusSender sender = client.CreateSender(queueName);
// 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")));
// send the message batch
await sender.SendAsync(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 <ServiceBusReceivedMessage> receivedMessages = await receiver.ReceiveBatchAsync(maxMessages : 2);
foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages)
{
// get the message body as a string
string body = Encoding.UTF8.GetString(receivedMessage.Body.ToArray());
Console.WriteLine(body);
}
var sentMessagesEnum = messageBatch.AsEnumerable <ServiceBusMessage>().GetEnumerator();
foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages)
{
sentMessagesEnum.MoveNext();
Assert.AreEqual(sentMessagesEnum.Current.Body.ToArray(), receivedMessage.Body.ToArray());
}
}
}
public void DeadLetterMessageExceptionLogsEvents()
{
var mockLogger = new Mock <ServiceBusEventSource>();
var mockTransportReceiver = new Mock <TransportReceiver>();
var mockConnection = GetMockConnection(mockTransportReceiver);
mockTransportReceiver.Setup(
transportReceiver => transportReceiver.DeadLetterAsync(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <IDictionary <string, object> >(),
It.IsAny <CancellationToken>()))
.Throws(new Exception());
var receiver = new ServiceBusReceiver(
mockConnection.Object,
"queueName",
false,
new ServiceBusPlugin[] { },
new ServiceBusReceiverOptions())
{
Logger = mockLogger.Object
};
var msg = new ServiceBusReceivedMessage()
{
LockTokenGuid = Guid.NewGuid()
};
Assert.That(
async() => await receiver.DeadLetterMessageAsync(msg),
Throws.InstanceOf <Exception>());
mockLogger
.Verify(
log => log.DeadLetterMessageStart(
receiver.Identifier,
1,
msg.LockToken),
Times.Once);
mockLogger
.Verify(
log => log.DeadLetterMessageException(
receiver.Identifier,
It.IsAny <string>()),
Times.Once);
}
public async Task RenewSessionLock(bool isSessionSpecified)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
var messageCount = 1;
var sessionId1 = "sessionId1";
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);
ServiceBusReceiver receiver = await client.GetSessionReceiverAsync(scope.QueueName, sessionId : isSessionSpecified?sessionId1 : null);
var session = receiver.GetSessionManager();
if (isSessionSpecified)
{
Assert.AreEqual(sessionId1, session.SessionId);
}
ServiceBusReceivedMessage[] receivedMessages = (await receiver.ReceiveBatchAsync(messageCount)).ToArray();
var receivedMessage = receivedMessages.First();
var firstLockedUntilUtcTime = session.LockedUntil;
// Sleeping for 10 seconds...
await Task.Delay(10000);
await session.RenewSessionLockAsync();
Assert.True(session.LockedUntil >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(10));
// Complete Messages
await receiver.CompleteAsync(receivedMessage.LockToken);
Assert.AreEqual(messageCount, receivedMessages.Length);
if (isSessionSpecified)
{
Assert.AreEqual(message.MessageId, receivedMessage.MessageId);
}
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
}
}
public async Task ReceiveBatchOfMessagesLogsEvents()
{
var mockLogger = new Mock <ServiceBusEventSource>();
var maxMessages = 4;
var mockTransportReceiver = new Mock <TransportReceiver>();
var mockConnection = GetMockConnection(mockTransportReceiver);
mockTransportReceiver.Setup(
transportReceiver => transportReceiver.ReceiveMessagesAsync(
maxMessages,
It.IsAny <TimeSpan?>(),
It.IsAny <CancellationToken>()))
.Returns(
Task.FromResult((IList <ServiceBusReceivedMessage>)
new List <ServiceBusReceivedMessage> {
new ServiceBusReceivedMessage(),
new ServiceBusReceivedMessage()
}));
var receiver = new ServiceBusReceiver(
mockConnection.Object,
"queueName",
false,
new ServiceBusPlugin[] { },
new ServiceBusReceiverOptions())
{
Logger = mockLogger.Object
};
var msgs = await receiver.ReceiveMessagesAsync(maxMessages : maxMessages);
mockLogger
.Verify(
log => log.ReceiveMessageStart(
receiver.Identifier,
// the amount requested
maxMessages),
Times.Once);
mockLogger
.Verify(
log => log.ReceiveMessageComplete(
receiver.Identifier,
// the amount we actually received
msgs.Count),
Times.Once);
}
public async Task TransactionCommitWorksUsingSendersAndReceiversFromSameClients()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
ServiceBusReceiver receiver = client.CreateReceiver(scope.QueueName);
ServiceBusMessage message1 = GetMessage();
ServiceBusMessage message2 = GetMessage();
await sender.SendAsync(message1);
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync();
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);
ts.Complete();
}
// Adding delay since transaction Commit/Rollback is an asynchronous operation.
// Operating on the same message should not be done.
await Task.Delay(TimeSpan.FromSeconds(2));
// Assert that complete did succeed
Assert.That(
async() =>
await receiver.CompleteAsync(receivedMessage), Throws.InstanceOf <ServiceBusException>()
.And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.MessageLockLost));
// Assert that send did succeed
receivedMessage = await receiver.ReceiveAsync();
Assert.NotNull(receivedMessage);
Assert.AreEqual(message2.Body.ToString(), receivedMessage.Body.ToString());
await receiver.CompleteAsync(receivedMessage);
}
}
private async Task ProcessMessageAsync(ProcessMessageEventArgs args)
{
ServiceBusReceivedMessage message = args?.Message;
if (message is null)
{
Logger.LogWarning("Received message on Azure Service Bus message pump '{JobId}' was null, skipping", JobId);
return;
}
if (_isHostShuttingDown)
{
Logger.LogWarning("Abandoning message with ID '{MessageId}' as the Azure Service Bus message pump is shutting down", message.MessageId);
await args.AbandonMessageAsync(message);
return;
}
if (String.IsNullOrEmpty(message.CorrelationId))
{
Logger.LogTrace("No operation ID was found on the message '{MessageId}' during processing in the Azure Service Bus message pump '{JobId}'", message.MessageId, JobId);
}
AzureServiceBusMessageContext messageContext = message.GetMessageContext(JobId);
MessageCorrelationInfo correlationInfo = message.GetCorrelationInfo(Settings.Options.Correlation?.TransactionIdPropertyName ?? PropertyNames.TransactionId);
ServiceBusReceiver receiver = args.GetServiceBusReceiver();
using (IServiceScope serviceScope = ServiceProvider.CreateScope())
{
var correlationInfoAccessor = serviceScope.ServiceProvider.GetService <ICorrelationInfoAccessor <MessageCorrelationInfo> >();
if (correlationInfoAccessor is null)
{
Logger.LogTrace("No message correlation configured in Azure Service Bus message pump '{JobId}' while processing message '{MessageId}'", JobId, message.MessageId);
await _messageRouter.RouteMessageAsync(receiver, args.Message, messageContext, correlationInfo, args.CancellationToken);
}
else
{
correlationInfoAccessor.SetCorrelationInfo(correlationInfo);
using (LogContext.Push(new MessageCorrelationInfoEnricher(correlationInfoAccessor)))
{
await _messageRouter.RouteMessageAsync(receiver, args.Message, messageContext, correlationInfo, args.CancellationToken);
}
}
}
}
public async Task PeekSingleMessageLogsEvents(bool specifySeqNumber)
{
var mockLogger = new Mock <ServiceBusEventSource>();
var mockTransportReceiver = new Mock <TransportReceiver>();
var mockConnection = GetMockConnection(mockTransportReceiver);
mockTransportReceiver.Setup(
transportReceiver => transportReceiver.PeekBatchAtAsync(
It.IsAny <long?>(),
It.IsAny <int>(),
It.IsAny <CancellationToken>()))
.Returns(
Task.FromResult((IList <ServiceBusReceivedMessage>)
new List <ServiceBusReceivedMessage> {
new ServiceBusReceivedMessage()
}));
var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions())
{
Logger = mockLogger.Object
};
var seqNumber = 5;
if (specifySeqNumber)
{
await receiver.PeekAtAsync(seqNumber);
}
else
{
await receiver.PeekAsync();
}
mockLogger
.Verify(
log => log.PeekMessageStart(
receiver.Identifier,
specifySeqNumber ? (long?)seqNumber : null,
1),
Times.Once);
mockLogger
.Verify(
log => log.PeekMessageComplete(
receiver.Identifier,
1),
Times.Once);
}
public async Task <ServiceBusReceivedMessage> ReceiveMessageAsync(string queueName)
{
string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];
// create a Service Bus client
await using (ServiceBusClient client = new ServiceBusClient(connectionString))
{
// create a sender for the queue
ServiceBusReceiver receiver = client.CreateReceiver(queueName,
new ServiceBusReceiverOptions {
ReceiveMode = ServiceBusReceiveMode.ReceiveAndDelete
});
ServiceBusReceivedMessage message = await receiver.ReceiveMessageAsync();
return(message);
}
}
public static async Task TopicNoSessionsBatch(
[ServiceBusTrigger(TopicNameKey, FirstSubscriptionNameKey)] ServiceBusReceivedMessage[] array,
ServiceBusReceiver messageReceiver,
CancellationToken cancellationToken,
ILogger logger)
{
Assert.True(array.Length > 0);
logger.LogInformation($"DrainModeTestJobBatch.TopicNoSessionsBatch: received {array.Length} messages");
_drainValidationPreDelay.Set();
await DrainModeHelper.WaitForCancellation(cancellationToken);
Assert.True(cancellationToken.IsCancellationRequested);
foreach (ServiceBusReceivedMessage msg in array)
{
await messageReceiver.CompleteMessageAsync(msg);
}
_drainValidationPostDelay.Set();
}
/// <summary>
/// Delete Messages
/// </summary>
/// <returns></returns>
public async Task DeleteMessagesAsync()
{
var a = new Appsettings();
await using var queueClient = new ServiceBusClient(Appsettings.app("ServiceBus", "PrimaryConnectionString"));
try
{
// create a receiver that we can use to receive the message
ServiceBusReceiver receiver = queueClient.CreateReceiver(Appsettings.app("ServiceBus", "QueueName"));
ServiceBusReceivedMessage peekedMessage = await receiver.ReceiveMessageAsync();
await receiver.CompleteMessageAsync(peekedMessage);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task ReceiveMessagesInReceiveAndDeleteMode()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendMessagesAsync(batch);
var clientOptions = new ServiceBusSessionReceiverOptions
{
ReceiveMode = ServiceBusReceiveMode.ReceiveAndDelete
};
ServiceBusReceiver receiver = await client.AcceptSessionAsync(
scope.QueueName,
sessionId,
clientOptions);
var remainingMessages = messageCount;
var messageEnum = messages.GetEnumerator();
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages))
{
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
remainingMessages--;
}
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekMessageAsync();
Assert.IsNull(peekedMessage.Result);
}
}
public ServiceBusListenerTests()
{
_mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);
var client = new ServiceBusClient(_testConnection);
ServiceBusProcessor processor = client.CreateProcessor(_entityPath);
ServiceBusReceiver receiver = client.CreateReceiver(_entityPath);
var configuration = ConfigurationUtilities.CreateConfiguration(new KeyValuePair <string, string>("connection", _testConnection));
ServiceBusOptions config = new ServiceBusOptions
{
ExceptionHandler = ExceptionReceivedHandler
};
_mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, processor);
_mockMessagingProvider = new Mock <MessagingProvider>(new OptionsWrapper <ServiceBusOptions>(config));
_mockClientFactory = new Mock <ServiceBusClientFactory>(configuration, Mock.Of <AzureComponentFactory>(), _mockMessagingProvider.Object, new AzureEventSourceLogForwarder(new NullLoggerFactory()), new OptionsWrapper <ServiceBusOptions>(new ServiceBusOptions()));
_mockMessagingProvider
.Setup(p => p.CreateMessageProcessor(It.IsAny <ServiceBusClient>(), _entityPath, It.IsAny <ServiceBusProcessorOptions>()))
.Returns(_mockMessageProcessor.Object);
_mockMessagingProvider
.Setup(p => p.CreateBatchMessageReceiver(It.IsAny <ServiceBusClient>(), _entityPath, default))
.Returns(receiver);
_loggerFactory = new LoggerFactory();
_loggerProvider = new TestLoggerProvider();
_loggerFactory.AddProvider(_loggerProvider);
_listener = new ServiceBusListener(
_functionId,
ServiceBusEntityType.Queue,
_entityPath,
false,
config.AutoCompleteMessages,
_mockExecutor.Object,
config,
"connection",
_mockMessagingProvider.Object,
_loggerFactory,
false,
_mockClientFactory.Object);
}
static async Task Main(string[] args)
{
string connectionString = "Endpoint = sb://trialbus.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=xN4pYhOcgxH5UL+0cUeguN5hjsi/1gFtGZkS6nZy/2Q=";
string queueName = "demoqueue";
await using ServiceBusClient client = new ServiceBusClient(connectionString);
// 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.ReceiveMessageAsync();
// get the message body as a string
string body = receivedMessage.Body.ToString();
Console.WriteLine(body);
}
public static async Task ReceivedMessagesAsync(ServiceBusReceiver serviceBusReceiver, string subscriber)
{
while (true)
{
var receivedMessage = await serviceBusReceiver.ReceiveMessagesAsync(1, TimeSpan.FromSeconds(1));
if (receivedMessage == null || receivedMessage.Count == 0)
{
break;
}
foreach (var message in receivedMessage)
{
var body = message.Body.ToString();
var msgPropNumber = message.ApplicationProperties["MsgProp"];
Console.WriteLine($"{subscriber}\t{msgPropNumber}\t{body}");
}
}
}
