// First listener for the topic
public static void SBTopicListener1(
[ServiceBusTrigger(TopicNameKey, FirstSubscriptionNameKey)] string message,
ServiceBusMessageActions messageActions,
string lockToken)
{
SBTopicListener1Impl(message);
}
public static void SBQueue2SBQueue(
[ServiceBusTrigger(FirstQueueNameKey)] TestPoco[] array,
ServiceBusMessageActions messageActions)
{
string[] messages = array.Select(x => "{'Name': '" + x.Name + "', 'Value': 'Value'}").ToArray();
ServiceBusMultipleTestJobsBase.ProcessMessages(messages);
}
internal async Task ProcessMessageAsync(ProcessMessageEventArgs args)
{
EnsureIsRunning();
_concurrencyUpdateManager?.MessageProcessed();
using (CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(args.CancellationToken, _cancellationTokenSource.Token))
{
var actions = new ServiceBusMessageActions(args);
if (!await _messageProcessor.Value.BeginProcessingMessageAsync(actions, args.Message, linkedCts.Token).ConfigureAwait(false))
{
return;
}
var receiveActions = new ServiceBusReceiveActions(args);
ServiceBusTriggerInput input = ServiceBusTriggerInput.CreateSingle(args.Message, actions, receiveActions, _client.Value);
TriggeredFunctionData data = input.GetTriggerFunctionData();
FunctionResult result = await _triggerExecutor.TryExecuteAsync(data, linkedCts.Token).ConfigureAwait(false);
try
{
await _messageProcessor.Value.CompleteProcessingMessageAsync(actions, args.Message, result, linkedCts.Token)
.ConfigureAwait(false);
}
finally
{
receiveActions.EndExecutionScope();
}
}
}
public async Task CompleteProcessingMessageAsync_DefaultOnMessageOptions()
{
ServiceBusReceivedMessage message = ServiceBusModelFactory.ServiceBusReceivedMessage();
FunctionResult result = new FunctionResult(true);
var client = new ServiceBusClient("Endpoint = sb://test.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=abc123=");
var actions = new ServiceBusMessageActions(client.CreateReceiver("test-entity"));
await _processor.CompleteProcessingMessageAsync(actions, message, result, CancellationToken.None);
}
public static void SBQueue2SBQueue(
[ServiceBusTrigger(FirstQueueNameKey)]
ServiceBusReceivedMessage[] array,
ServiceBusMessageActions messageActions)
{
string[] messages = array.Select(x => x.Body.ToString()).ToArray();
ServiceBusMultipleTestJobsBase.ProcessMessages(messages);
}
static async Task SafeCompleteMessageAsync(ServiceBusMessageActions messageActions, ServiceBusReceivedMessage message, Transaction committableTransaction, CancellationToken cancellationToken = default)
{
using (var scope = new TransactionScope(committableTransaction, TransactionScopeAsyncFlowOption.Enabled))
{
await messageActions.CompleteMessageAsync(message, cancellationToken).ConfigureAwait(false);
scope.Complete();
}
}
public static async Task RunAsync(
[ServiceBusTrigger(FirstQueueNameKey, AutoCompleteMessages = true)]
ServiceBusReceivedMessage message,
ServiceBusMessageActions messageActions)
{
// we want to validate that this doesn't trigger an exception in the SDK since AutoComplete = true
await messageActions.CompleteMessageAsync(message);
_waitHandle1.Set();
}
public static async Task RunAsync(
[ServiceBusTrigger(FirstQueueNameKey, AutoCompleteMessages = true)]
ServiceBusReceivedMessage[] array,
ServiceBusMessageActions messageActions)
{
string[] messages = array.Select(x => x.Body.ToString()).ToArray();
foreach (var msg in array)
{
await messageActions.CompleteMessageAsync(msg);
}
ServiceBusMultipleTestJobsBase.ProcessMessages(messages);
}
public static async Task SBQueue2SBQueue(
[ServiceBusTrigger(FirstQueueNameKey)] string[] messages,
ServiceBusMessageActions messageActions, CancellationToken cancellationToken)
{
try
{
ServiceBusMultipleTestJobsBase.ProcessMessages(messages);
await Task.Delay(0, cancellationToken);
}
catch (OperationCanceledException)
{
}
}
public void CompleteProcessingMessageAsync_Failure_PropagatesException()
{
ServiceBusReceivedMessage message = ServiceBusModelFactory.ServiceBusReceivedMessage();
var functionException = new InvalidOperationException("Kaboom!");
FunctionResult result = new FunctionResult(functionException);
var client = new ServiceBusClient("Endpoint = sb://test.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=abc123=");
var actions = new ServiceBusMessageActions(client.CreateReceiver("test-entity"));
var ex = Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await _processor.CompleteProcessingMessageAsync(actions, message, result, CancellationToken.None);
});
Assert.AreSame(functionException, ex);
}
// Passes service bus message from a queue to another queue
public async Task SBQueue2SBQueue(
[ServiceBusTrigger(FirstQueueNameKey)] string start, int deliveryCount,
ServiceBusMessageActions messageActions,
string lockToken,
[ServiceBus(SecondQueueNameKey)] ServiceBusSender messageSender)
{
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 static async Task QueueNoSessions(
[ServiceBusTrigger(FirstQueueNameKey)] ServiceBusReceivedMessage msg,
ServiceBusMessageActions messageActions,
CancellationToken cancellationToken,
ILogger logger)
{
logger.LogInformation($"DrainModeValidationFunctions.QueueNoSessions: message data {msg.Body}");
_drainValidationPreDelay.Set();
await DrainModeHelper.WaitForCancellation(cancellationToken);
Assert.True(cancellationToken.IsCancellationRequested);
await messageActions.CompleteMessageAsync(msg);
_drainValidationPostDelay.Set();
}
public async Task CanCompleteMessagesConcurrently()
{
var mockReceiver = new Mock <ServiceBusReceiver>();
mockReceiver.Setup(r => r.CompleteMessageAsync(It.IsAny <ServiceBusReceivedMessage>(), It.IsAny <CancellationToken>()))
// simulate completing the message
.Returns(async() => await Task.Delay(20));
var actions = new ServiceBusMessageActions(mockReceiver.Object);
var tasks = new List <Task>();
for (int i = 0; i < 1000; i++)
{
tasks.Add(actions.CompleteMessageAsync(ServiceBusModelFactory.ServiceBusReceivedMessage()));
}
await Task.WhenAll(tasks);
}
public static async Task Run(
[ServiceBusTrigger("<queue_name>", Connection = "<connection_name>")]
ServiceBusReceivedMessage[] messages,
ServiceBusMessageActions messageActions)
{
foreach (ServiceBusReceivedMessage message in messages)
{
if (message.MessageId == "1")
{
await messageActions.DeadLetterMessageAsync(message);
}
else
{
await messageActions.CompleteMessageAsync(message);
}
}
}
public static async Task TopicNoSessionsBatch(
[ServiceBusTrigger(TopicNameKey, FirstSubscriptionNameKey)] ServiceBusReceivedMessage[] array,
ServiceBusMessageActions messageActions,
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 messageActions.CompleteMessageAsync(msg);
}
_drainValidationPostDelay.Set();
}
public static async Task Run(
[ServiceBusTrigger("<queue_name>", Connection = "<connection_name>", IsSessionsEnabled = true)]
ServiceBusReceivedMessage message,
ServiceBusMessageActions messageActions,
ServiceBusReceiveActions receiveActions)
{
if (message.MessageId == "1")
{
await messageActions.DeadLetterMessageAsync(message);
}
else
{
await messageActions.CompleteMessageAsync(message);
// attempt to receive additional messages in this session
await receiveActions.ReceiveMessagesAsync(maxMessages : 10);
}
}
internal async Task ProcessMessageAsync(ProcessMessageEventArgs args)
{
using (CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(args.CancellationToken, _cancellationTokenSource.Token))
{
var actions = new ServiceBusMessageActions(args);
if (!await _messageProcessor.BeginProcessingMessageAsync(actions, args.Message, linkedCts.Token).ConfigureAwait(false))
{
return;
}
ServiceBusTriggerInput input = ServiceBusTriggerInput.CreateSingle(args.Message);
input.MessageActions = actions;
TriggeredFunctionData data = input.GetTriggerFunctionData();
FunctionResult result = await _triggerExecutor.TryExecuteAsync(data, linkedCts.Token).ConfigureAwait(false);
await _messageProcessor.CompleteProcessingMessageAsync(actions, args.Message, result, linkedCts.Token).ConfigureAwait(false);
}
}
public static async Task QueueWithSessions(
[ServiceBusTrigger(FirstQueueNameKey, IsSessionsEnabled = true)]
ServiceBusReceivedMessage msg,
string sessionId,
ServiceBusMessageActions messageActions,
CancellationToken cancellationToken,
ILogger logger)
{
logger.LogInformation(
$"DrainModeValidationFunctions.QueueWithSessions: message data {msg.Body} with session id {msg.SessionId}");
Assert.AreEqual(_drainModeSessionId, msg.SessionId);
Assert.AreEqual(msg.SessionId, sessionId);
_drainValidationPreDelay.Set();
await DrainModeHelper.WaitForCancellation(cancellationToken);
Assert.True(cancellationToken.IsCancellationRequested);
await messageActions.CompleteMessageAsync(msg);
_drainValidationPostDelay.Set();
}
public static async Task QueueWithSessionsBatch(
[ServiceBusTrigger(FirstQueueNameKey, IsSessionsEnabled = true)]
ServiceBusReceivedMessage[] array,
ServiceBusMessageActions messageActions,
CancellationToken cancellationToken,
ILogger logger)
{
Assert.True(array.Length > 0);
logger.LogInformation(
$"DrainModeTestJobBatch.QueueWithSessionsBatch: received {array.Length} messages with session id {array[0].SessionId}");
Assert.AreEqual(_drainModeSessionId, array[0].SessionId);
_drainValidationPreDelay.Set();
await DrainModeHelper.WaitForCancellation(cancellationToken);
Assert.True(cancellationToken.IsCancellationRequested);
foreach (ServiceBusReceivedMessage msg in array)
{
await messageActions.CompleteMessageAsync(msg);
}
_drainValidationPostDelay.Set();
}
// Passes service bus message from a queue to another queue
public async Task SBQueue2SBQueue(
[ServiceBusTrigger(FirstQueueNameKey)]
string body,
int deliveryCount,
string lockToken,
string deadLetterSource,
DateTime expiresAtUtc,
DateTime enqueuedTimeUtc,
string contentType,
string replyTo,
string to,
string subject,
string label,
string correlationId,
IDictionary <string, object> applicationProperties,
IDictionary <string, object> userProperties,
ServiceBusMessageActions messageActions,
[ServiceBus(SecondQueueNameKey)] ServiceBusSender messageSender)
{
Assert.AreEqual("E2E", body);
Assert.AreEqual(1, deliveryCount);
Assert.IsNotNull(lockToken);
Assert.IsNull(deadLetterSource);
Assert.AreEqual("replyTo", replyTo);
Assert.AreEqual("to", to);
Assert.AreEqual("subject", subject);
Assert.AreEqual("subject", label);
Assert.AreEqual("correlationId", correlationId);
Assert.AreEqual("application/json", contentType);
Assert.AreEqual("value", applicationProperties["key"]);
Assert.AreEqual("value", userProperties["key"]);
Assert.IsTrue(expiresAtUtc > DateTime.UtcNow);
Assert.IsTrue(enqueuedTimeUtc < DateTime.UtcNow);
var message = SBQueue2SBQueue_GetOutputMessage(body);
await messageSender.SendMessageAsync(message);
}
public static void Run(
[ServiceBusTrigger(FirstQueueNameKey)]
ServiceBusReceivedMessage[] array,
int[] deliveryCountArray,
string[] lockTokenArray,
string[] deadLetterSourceArray,
DateTime[] expiresAtUtcArray,
DateTime[] enqueuedTimeUtcArray,
string[] contentTypeArray,
string[] replyToArray,
string[] toArray,
string[] subjectArray,
string[] labelArray,
string[] correlationIdArray,
IDictionary <string, object>[] applicationPropertiesArray,
IDictionary <string, object>[] userPropertiesArray,
ServiceBusMessageActions messageActions)
{
for (int i = 0; i < array.Length; i++)
{
Assert.AreEqual(1, deliveryCountArray[i]);
Assert.IsNotNull(lockTokenArray[i]);
Assert.IsNull(deadLetterSourceArray[i]);
Assert.AreEqual("replyTo", replyToArray[i]);
Assert.AreEqual("to", toArray[i]);
Assert.AreEqual("subject", subjectArray[i]);
Assert.AreEqual("subject", labelArray[i]);
Assert.AreEqual("correlationId", correlationIdArray[i]);
Assert.AreEqual("application/json", contentTypeArray[i]);
Assert.AreEqual("value", applicationPropertiesArray[i]["key"]);
Assert.AreEqual("value", userPropertiesArray[i]["key"]);
Assert.IsTrue(expiresAtUtcArray[i] > DateTime.UtcNow);
Assert.IsTrue(enqueuedTimeUtcArray[i] < DateTime.UtcNow);
}
string[] messages = array.Select(x => x.Body.ToString()).ToArray();
ServiceBusMultipleTestJobsBase.ProcessMessages(messages);
}
public async Task ProcessAtomic(
ServiceBusReceivedMessage message,
ExecutionContext executionContext,
ServiceBusClient serviceBusClient,
ServiceBusMessageActions messageActions,
ILogger functionsLogger = null,
CancellationToken cancellationToken = default)
{
FunctionsLoggerFactory.Instance.SetCurrentLogger(functionsLogger);
try
{
await InitializeEndpointIfNecessary(executionContext, functionsLogger, cancellationToken).ConfigureAwait(false);
}
catch (Exception)
{
await messageActions.AbandonMessageAsync(message, cancellationToken : cancellationToken).ConfigureAwait(false);
throw;
}
try
{
using (var transaction = CreateTransaction())
{
var transportTransaction = CreateTransportTransaction(message.PartitionKey, transaction, serviceBusClient);
var messageContext = CreateMessageContext(message, transportTransaction);
await pipeline.PushMessage(messageContext, cancellationToken).ConfigureAwait(false);
await SafeCompleteMessageAsync(messageActions, message, transaction, cancellationToken).ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception exception)
{
ErrorHandleResult result;
using (var transaction = CreateTransaction())
{
var transportTransaction = CreateTransportTransaction(message.PartitionKey, transaction, serviceBusClient);
var errorContext = CreateErrorContext(message, transportTransaction, exception);
result = await pipeline.PushFailedMessage(errorContext, cancellationToken).ConfigureAwait(false);
if (result == ErrorHandleResult.Handled)
{
await SafeCompleteMessageAsync(messageActions, message, transaction, cancellationToken).ConfigureAwait(false);
}
transaction.Commit();
}
if (result != ErrorHandleResult.Handled)
{
await messageActions.AbandonMessageAsync(message, cancellationToken : cancellationToken).ConfigureAwait(false);
}
}
}
public override async Task CompleteProcessingMessageAsync(ServiceBusMessageActions messageActions, ServiceBusReceivedMessage message, Executors.FunctionResult result, CancellationToken cancellationToken)
{
_logger?.LogInformation("Custom processor End called!");
await base.CompleteProcessingMessageAsync(messageActions, message, result, cancellationToken);
}
public override async Task <bool> BeginProcessingMessageAsync(ServiceBusMessageActions messageActions, ServiceBusReceivedMessage message, CancellationToken cancellationToken)
{
_logger?.LogInformation("Custom processor Begin called!");
return(await base.BeginProcessingMessageAsync(messageActions, message, cancellationToken));
}
