private static void PrintReceivedMessage(ServiceBusReceivedMessage message) { Console.ForegroundColor = (ConsoleColor)Enum.Parse(typeof(ConsoleColor), message.Subject); Console.WriteLine($"Received message with color: {message.ApplicationProperties["Color"]}, CorrelationId: {message.CorrelationId}"); Console.ResetColor(); }
/// <summary> /// Sets the <see cref="ServiceBusReceivedMessage.ReplyTo"/>. /// </summary> /// <param name="message">The message to modify.</param> /// <param name="replyTo">The reply to value to set on the message.</param> protected void SetReplyTo(ServiceBusReceivedMessage message, string replyTo) { message.AmqpMessage.Properties.ReplyTo = new AmqpAddress(replyTo); }
public async Task CrossEntityTransactionReceivesFirstRollback() { await using var client = CreateCrossEntityTxnClient(); 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); await using var noTxClient = CreateClient(); var senderA = noTxClient.CreateSender(queueA.QueueName); var receiverA = client.CreateReceiver(queueA.QueueName); var senderB = client.CreateSender(queueB.QueueName); var senderC = client.CreateSender(topicC.TopicName); var message = new ServiceBusMessage(); await senderA.SendMessageAsync(message); ServiceBusReceivedMessage receivedMessage = await receiverA.ReceiveMessageAsync(); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await receiverA.CompleteMessageAsync(receivedMessage); await senderB.SendMessageAsync(message); await senderC.SendMessageAsync(message); } await receiverA.AbandonMessageAsync(receivedMessage); // transaction wasn't committed - verify that it was rolled back receivedMessage = await receiverA.ReceiveMessageAsync(); Assert.IsNotNull(receivedMessage); await receiverA.AbandonMessageAsync(receivedMessage); var receiverB = noTxClient.CreateReceiver(queueB.QueueName); receivedMessage = await receiverB.ReceiveMessageAsync(TimeSpan.FromSeconds(10)); Assert.IsNull(receivedMessage); var receiverC = noTxClient.CreateReceiver(topicC.TopicName, topicC.SubscriptionNames.First()); receivedMessage = await receiverC.ReceiveMessageAsync(TimeSpan.FromSeconds(10)); Assert.IsNull(receivedMessage); receivedMessage = await receiverA.ReceiveMessageAsync(); // now commit the transaction using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await receiverA.CompleteMessageAsync(receivedMessage); await senderB.SendMessageAsync(message); await senderC.SendMessageAsync(message); ts.Complete(); } receivedMessage = await receiverA.ReceiveMessageAsync(TimeSpan.FromSeconds(10)); Assert.IsNull(receivedMessage); receivedMessage = await receiverB.ReceiveMessageAsync(); Assert.IsNotNull(receivedMessage); receivedMessage = await receiverC.ReceiveMessageAsync(); Assert.IsNotNull(receivedMessage); }
public override async Task CompleteProcessingMessageAsync(ServiceBusReceiver receiver, ServiceBusReceivedMessage message, Executors.FunctionResult result, CancellationToken cancellationToken) { _logger?.LogInformation("Custom processor End called!"); await base.CompleteProcessingMessageAsync(receiver, message, result, cancellationToken); }
/// <summary> /// Sets the <see cref="ServiceBusReceivedMessage.To"/>. /// </summary> /// <param name="message">The message to modify.</param> /// <param name="to">The to value to set on the message.</param> protected void SetTo(ServiceBusReceivedMessage message, string to) { message.AmqpMessage.Properties.To = new AmqpAddress(to); }
/// <summary> /// This operation is called after a message is received, but before it is returned to the <see cref="ServiceBusReceiver"/>. /// It can be overridden to alter the body and the properties of an /// incoming message. /// </summary> /// <param name="message">The <see cref="ServiceBusReceivedMessage"/> to be modified by the plugin.</param> public virtual ValueTask AfterMessageReceiveAsync(ServiceBusReceivedMessage message) => default;
public void UserSettledPropertySetCorrectlyOnException() { var msg = new ServiceBusReceivedMessage(); var mockReceiver = new Mock <ServiceBusReceiver>(); mockReceiver .Setup(receiver => receiver.AbandonMessageAsync( It.IsAny <ServiceBusReceivedMessage>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <CancellationToken>())) .Throws(new Exception()); mockReceiver .Setup(receiver => receiver.DeferMessageAsync( It.IsAny <ServiceBusReceivedMessage>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <CancellationToken>())) .Throws(new Exception()); mockReceiver .Setup(receiver => receiver.CompleteMessageAsync( It.IsAny <ServiceBusReceivedMessage>(), It.IsAny <CancellationToken>())) .Throws(new Exception()); mockReceiver .Setup(receiver => receiver.DeadLetterMessageAsync( It.IsAny <ServiceBusReceivedMessage>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <CancellationToken>())) .Throws(new Exception()); mockReceiver .Setup(receiver => receiver.DeadLetterMessageAsync( It.IsAny <ServiceBusReceivedMessage>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>())) .Throws(new Exception()); var args = new ProcessMessageEventArgs( msg, mockReceiver.Object, CancellationToken.None); Assert.IsFalse(msg.IsSettled); msg.IsSettled = false; Assert.That(async() => await args.AbandonMessageAsync(msg), Throws.InstanceOf <Exception>()); Assert.IsFalse(msg.IsSettled); Assert.That(async() => await args.CompleteMessageAsync(msg), Throws.InstanceOf <Exception>()); Assert.IsFalse(msg.IsSettled); msg.IsSettled = false; Assert.That(async() => await args.DeadLetterMessageAsync(msg), Throws.InstanceOf <Exception>()); Assert.IsFalse(msg.IsSettled); msg.IsSettled = false; Assert.That(async() => await args.DeadLetterMessageAsync(msg, "reason"), Throws.InstanceOf <Exception>()); Assert.IsFalse(msg.IsSettled); msg.IsSettled = false; Assert.That(async() => await args.DeferMessageAsync(msg), Throws.InstanceOf <Exception>()); Assert.IsFalse(msg.IsSettled); }
/// <summary> /// Sets the <see cref="ServiceBusReceivedMessage.ScheduledEnqueueTime"/>. /// </summary> /// <param name="message">The message to modify.</param> /// <param name="scheduledEnqueueTime">The scheduled enqueue time to set on the message.</param> protected void SetScheduledEnqueueTime(ServiceBusReceivedMessage message, DateTimeOffset scheduledEnqueueTime) { message.AmqpMessage.MessageAnnotations[AmqpMessageConstants.ScheduledEnqueueTimeUtcName] = scheduledEnqueueTime.UtcDateTime; }
public async Task GetQueueRuntimeInfo() { var queueName = nameof(GetQueueRuntimeInfo).ToLower() + Recording.Random.NewGuid().ToString("D").Substring(0, 8); var mgmtClient = GetClient(); await using var sbClient = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); QueueProperties queue = await mgmtClient.CreateQueueAsync(queueName); queue = await mgmtClient.GetQueueAsync(queueName); // Changing Last Updated Time queue.AutoDeleteOnIdle = TimeSpan.FromMinutes(100); QueueProperties updatedQueue = await mgmtClient.UpdateQueueAsync(queue); // Populating 1 active message, 1 dead letter message and 1 scheduled message // Changing Last Accessed Time ServiceBusSender sender = sbClient.CreateSender(queueName); 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.ReceiveMessageAsync(); await receiver.DeadLetterMessageAsync(msg.LockToken); List <QueueRuntimeProperties> runtimeInfoList = new List <QueueRuntimeProperties>(); await foreach (QueueRuntimeProperties queueRuntimeInfo in mgmtClient.GetQueuesRuntimePropertiesAsync()) { runtimeInfoList.Add(queueRuntimeInfo); } runtimeInfoList = runtimeInfoList.Where(e => e.Name.StartsWith(nameof(GetQueueRuntimeInfo).ToLower())).ToList(); Assert.True(runtimeInfoList.Count == 1, $"Expected 1 queue but {runtimeInfoList.Count} queues returned"); QueueRuntimeProperties runtimeInfo = runtimeInfoList.First(); Assert.NotNull(runtimeInfo); Assert.AreEqual(queueName, runtimeInfo.Name); Assert.True(runtimeInfo.CreatedAt < runtimeInfo.UpdatedAt); Assert.True(runtimeInfo.UpdatedAt < runtimeInfo.AccessedAt); Assert.AreEqual(1, runtimeInfo.ActiveMessageCount); Assert.AreEqual(1, runtimeInfo.DeadLetterMessageCount); Assert.AreEqual(1, runtimeInfo.ScheduledMessageCount); Assert.AreEqual(3, runtimeInfo.TotalMessageCount); Assert.True(runtimeInfo.SizeInBytes > 0); QueueRuntimeProperties singleRuntimeInfo = await mgmtClient.GetQueueRuntimePropertiesAsync(runtimeInfo.Name); Assert.AreEqual(runtimeInfo.AccessedAt, singleRuntimeInfo.AccessedAt); Assert.AreEqual(runtimeInfo.CreatedAt, singleRuntimeInfo.CreatedAt); Assert.AreEqual(runtimeInfo.UpdatedAt, singleRuntimeInfo.UpdatedAt); Assert.AreEqual(runtimeInfo.TotalMessageCount, singleRuntimeInfo.TotalMessageCount); Assert.AreEqual(runtimeInfo.ActiveMessageCount, singleRuntimeInfo.ActiveMessageCount); Assert.AreEqual(runtimeInfo.DeadLetterMessageCount, singleRuntimeInfo.DeadLetterMessageCount); Assert.AreEqual(runtimeInfo.ScheduledMessageCount, singleRuntimeInfo.ScheduledMessageCount); Assert.AreEqual(runtimeInfo.SizeInBytes, singleRuntimeInfo.SizeInBytes); await mgmtClient.DeleteQueueAsync(queueName); }
public async Task GetSubscriptionRuntimeInfoTest() { var topicName = nameof(GetSubscriptionRuntimeInfoTest).ToLower() + Recording.Random.NewGuid().ToString("D").Substring(0, 8); var subscriptionName = Recording.Random.NewGuid().ToString("D").Substring(0, 8); var client = GetClient(); await using var sbClient = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); await client.CreateTopicAsync(topicName); TopicProperties getTopic = await client.GetTopicAsync(topicName); // Changing Last Updated Time getTopic.AutoDeleteOnIdle = TimeSpan.FromMinutes(100); await client.UpdateTopicAsync(getTopic); SubscriptionProperties subscriptionDescription = await client.CreateSubscriptionAsync(topicName, subscriptionName); // Changing Last Updated Time for subscription subscriptionDescription.AutoDeleteOnIdle = TimeSpan.FromMinutes(100); await client.UpdateSubscriptionAsync(subscriptionDescription); // Populating 1 active message, 1 dead letter message and 1 scheduled message // Changing Last Accessed Time ServiceBusSender sender = sbClient.CreateSender(topicName); 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.ReceiveMessageAsync(); await receiver.DeadLetterMessageAsync(msg.LockToken); List <SubscriptionRuntimeProperties> runtimeInfoList = new List <SubscriptionRuntimeProperties>(); await foreach (SubscriptionRuntimeProperties subscriptionRuntimeInfo in client.GetSubscriptionsRuntimePropertiesAsync(topicName)) { runtimeInfoList.Add(subscriptionRuntimeInfo); } runtimeInfoList = runtimeInfoList.Where(e => e.TopicName.StartsWith(nameof(GetSubscriptionRuntimeInfoTest).ToLower())).ToList(); Assert.True(runtimeInfoList.Count == 1, $"Expected 1 subscription but {runtimeInfoList.Count} subscriptions returned"); SubscriptionRuntimeProperties runtimeInfo = runtimeInfoList.First(); Assert.NotNull(runtimeInfo); Assert.AreEqual(topicName, runtimeInfo.TopicName); Assert.AreEqual(subscriptionName, runtimeInfo.SubscriptionName); Assert.True(runtimeInfo.CreatedAt < runtimeInfo.UpdatedAt); Assert.True(runtimeInfo.UpdatedAt < runtimeInfo.AccessedAt); Assert.AreEqual(1, runtimeInfo.ActiveMessageCount); Assert.AreEqual(1, runtimeInfo.DeadLetterMessageCount); Assert.AreEqual(2, runtimeInfo.TotalMessageCount); SubscriptionRuntimeProperties singleRuntimeInfo = await client.GetSubscriptionRuntimePropertiesAsync(topicName, subscriptionName); Assert.AreEqual(runtimeInfo.CreatedAt, singleRuntimeInfo.CreatedAt); Assert.AreEqual(runtimeInfo.AccessedAt, singleRuntimeInfo.AccessedAt); Assert.AreEqual(runtimeInfo.UpdatedAt, singleRuntimeInfo.UpdatedAt); Assert.AreEqual(runtimeInfo.SubscriptionName, singleRuntimeInfo.SubscriptionName); Assert.AreEqual(runtimeInfo.TotalMessageCount, singleRuntimeInfo.TotalMessageCount); Assert.AreEqual(runtimeInfo.ActiveMessageCount, singleRuntimeInfo.ActiveMessageCount); Assert.AreEqual(runtimeInfo.DeadLetterMessageCount, singleRuntimeInfo.DeadLetterMessageCount); Assert.AreEqual(runtimeInfo.TopicName, singleRuntimeInfo.TopicName); List <TopicRuntimeProperties> topicRuntimePropertiesList = new List <TopicRuntimeProperties>(); await foreach (TopicRuntimeProperties topicRuntime in client.GetTopicsRuntimePropertiesAsync()) { topicRuntimePropertiesList.Add(topicRuntime); } topicRuntimePropertiesList = topicRuntimePropertiesList.Where(e => e.Name.StartsWith(nameof(GetSubscriptionRuntimeInfoTest).ToLower())).ToList(); Assert.True(topicRuntimePropertiesList.Count == 1, $"Expected 1 subscription but {topicRuntimePropertiesList.Count} subscriptions returned"); TopicRuntimeProperties topicRuntimeProperties = topicRuntimePropertiesList.First(); Assert.NotNull(topicRuntimeProperties); Assert.AreEqual(topicName, topicRuntimeProperties.Name); Assert.True(topicRuntimeProperties.CreatedAt < topicRuntimeProperties.UpdatedAt); Assert.True(topicRuntimeProperties.UpdatedAt < topicRuntimeProperties.AccessedAt); Assert.AreEqual(1, topicRuntimeProperties.ScheduledMessageCount); TopicRuntimeProperties singleTopicRuntimeProperties = await client.GetTopicRuntimePropertiesAsync(topicName); Assert.AreEqual(topicRuntimeProperties.CreatedAt, singleTopicRuntimeProperties.CreatedAt); Assert.AreEqual(topicRuntimeProperties.AccessedAt, singleTopicRuntimeProperties.AccessedAt); Assert.AreEqual(topicRuntimeProperties.UpdatedAt, singleTopicRuntimeProperties.UpdatedAt); Assert.AreEqual(topicRuntimeProperties.ScheduledMessageCount, singleTopicRuntimeProperties.ScheduledMessageCount); Assert.AreEqual(topicRuntimeProperties.Name, singleTopicRuntimeProperties.Name); await client.DeleteTopicAsync(topicName); }
protected override async Task SettleAsync(ServiceBusReceivedMessage message, CancellationToken cancellationToken) { await Receiver.DeadLetterMessageAsync(message, "reason", cancellationToken : cancellationToken); }
public async Task CrossEntityTransactionSendsFirstRollback() { await using var client = CreateCrossEntityTxnClient(); 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 queueC = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false); await using var noTxClient = CreateClient(); var senderA = noTxClient.CreateSender(queueA.QueueName); var receiverA = client.CreateReceiver(queueA.QueueName); var receiverB = client.CreateReceiver(queueB.QueueName); var senderB = client.CreateSender(queueB.QueueName); var senderC = client.CreateSender(queueC.QueueName); var receiverC = noTxClient.CreateReceiver(queueC.QueueName); var message = new ServiceBusMessage(); // B is the send via entity since it is first await senderB.SendMessageAsync(message); await senderA.SendMessageAsync(message); // you can't use a receiver after a sender (for a different entity) when using a Transaction Group because it would be // saying that you want to receive via the sender entity which isn't possible Assert.ThrowsAsync <InvalidOperationException>(async() => await receiverA.ReceiveMessageAsync()); // After the above throws, the session gets closed by the AMQP lib, so we are testing whether the fault tolerant session/controller // objects get re-created correctly. ServiceBusReceivedMessage receivedMessageB = await receiverB.ReceiveMessageAsync(); // If the transaction succeeds, then all the operations occurred on the same partition. var transaction = new CommittableTransaction(); using (var ts = new TransactionScope(transaction, TransactionScopeAsyncFlowOption.Enabled)) { // this is allowed because it is on B await receiverB.CompleteMessageAsync(receivedMessageB); // send to C via B - this is allowed because we are sending await senderC.SendMessageAsync(message); ts.Complete(); } transaction.Rollback(); // Adding delay since transaction Commit/Rollback is an asynchronous operation. await Task.Delay(TimeSpan.FromSeconds(2)); await receiverB.AbandonMessageAsync(receivedMessageB); receivedMessageB = await receiverB.ReceiveMessageAsync(); Assert.IsNotNull(receivedMessageB); await receiverB.AbandonMessageAsync(receivedMessageB); var receivedMessageC = await receiverC.ReceiveMessageAsync(); Assert.IsNull(receivedMessageC); // If the transaction succeeds, then all the operations occurred on the same partition. using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { receivedMessageB = await receiverB.ReceiveMessageAsync(); // this is allowed because it is on B await receiverB.CompleteMessageAsync(receivedMessageB); // this will fail because it is not part of txn group Assert.ThrowsAsync <ServiceBusException>(async() => await senderA.SendMessageAsync(message)); ts.Complete(); } receivedMessageB = await receiverB.ReceiveMessageAsync(); Assert.IsNull(receivedMessageB); }
public async Task CrossEntityTransactionSendsFirst(bool partitioned, bool enableSessions) { await using var client = CreateCrossEntityTxnClient(); await using var queueA = await ServiceBusScope.CreateWithQueue(enablePartitioning : partitioned, enableSession : enableSessions); await using var queueB = await ServiceBusScope.CreateWithQueue(enablePartitioning : partitioned, enableSession : enableSessions); await using var queueC = await ServiceBusScope.CreateWithQueue(enablePartitioning : partitioned, enableSession : enableSessions); await using var noTxClient = CreateClient(); var senderA = noTxClient.CreateSender(queueA.QueueName); ServiceBusReceiver receiverA = null; ServiceBusReceiver receiverB = null; ServiceBusReceiver receiverC = null; if (!enableSessions) { receiverA = client.CreateReceiver(queueA.QueueName); receiverB = client.CreateReceiver(queueB.QueueName); receiverC = noTxClient.CreateReceiver(queueC.QueueName); } var senderB = client.CreateSender(queueB.QueueName); var senderC = client.CreateSender(queueC.QueueName); var message = new ServiceBusMessage { SessionId = enableSessions ? "sessionId" : null, TransactionPartitionKey = partitioned ? "sessionId" : null }; // B is the send via entity since it is first await senderB.SendMessageAsync(message); await senderA.SendMessageAsync(message); if (enableSessions) { // you can't use a receiver after a sender (for a different entity) when using a Transaction Group because it would be // saying that you want to receive via the sender entity which isn't possible Assert.ThrowsAsync <InvalidOperationException>( async() => await client.AcceptNextSessionAsync(queueA.QueueName)); receiverB = await client.AcceptNextSessionAsync(queueB.QueueName); } else { Assert.ThrowsAsync <InvalidOperationException>(async() => await receiverA.ReceiveMessageAsync()); } // After the above throws, the session gets closed by the AMQP lib, so we are testing whether the fault tolerant session/controller // objects get re-created correctly. ServiceBusReceivedMessage receivedMessageB = await receiverB.ReceiveMessageAsync(); // If the transaction succeeds, then all the operations occurred on the same partition. using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { // this is allowed because it is on B await receiverB.CompleteMessageAsync(receivedMessageB); // send to C via B - this is allowed because we are sending await senderC.SendMessageAsync(message); ts.Complete(); } if (enableSessions) { receiverC = await noTxClient.AcceptNextSessionAsync(queueC.QueueName); } var receivedMessageC = await receiverC.ReceiveMessageAsync(); Assert.IsNotNull(receivedMessageC); receivedMessageB = await receiverB.ReceiveMessageAsync(); Assert.IsNull(receivedMessageB); await senderB.SendMessageAsync(message); // If the transaction succeeds, then all the operations occurred on the same partition. using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { receivedMessageB = await receiverB.ReceiveMessageAsync(); // this is allowed because it is on B await receiverB.CompleteMessageAsync(receivedMessageB); // this will fail because it is not part of txn group Assert.ThrowsAsync <ServiceBusException>(async() => await senderA.SendMessageAsync(message)); ts.Complete(); } }
/// <summary> /// Sets the <see cref="ServiceBusReceivedMessage.ReplyToSessionId"/>. /// </summary> /// <param name="message">The message to modify.</param> /// <param name="replyToSessionId">The reply to session ID value to set on the message.</param> protected void SetReplyToSessionId(ServiceBusReceivedMessage message, string replyToSessionId) { message.AmqpMessage.Properties.ReplyToGroupId = replyToSessionId; }
protected internal override async Task <bool> BeginProcessingMessageAsync(ServiceBusMessageActions messageActions, ServiceBusReceivedMessage message, CancellationToken cancellationToken) { _logger?.LogInformation("Custom processor Begin called!"); return(await base.BeginProcessingMessageAsync(messageActions, message, cancellationToken)); }
/// <summary> /// Sets the <see cref="ServiceBusReceivedMessage.SessionId"/>. /// </summary> /// <param name="message">The message to modify.</param> /// <param name="sessionId">The session ID to set on the message.</param> protected void SetSessionId(ServiceBusReceivedMessage message, string sessionId) { message.AmqpMessage.Properties.GroupId = sessionId; }
protected static void SBTopicListener2Impl(ServiceBusReceivedMessage message) { _resultMessage2 = message.Body.ToString() + "-topic-2"; _topicSubscriptionCalled2.Set(); }
/// <summary> /// Sets the <see cref="ServiceBusReceivedMessage.TimeToLive"/>. /// </summary> /// <param name="message">The message to modify.</param> /// <param name="timeToLive">The time to live to set on the message.</param> protected void SetTimeToLive(ServiceBusReceivedMessage message, TimeSpan timeToLive) { message.AmqpMessage.Header.TimeToLive = timeToLive; }
public static void SBTopicListener2( [ServiceBusTrigger(TopicNameKey, SecondSubscriptionNameKey)] ServiceBusReceivedMessage message) { SBTopicListener2Impl(message); }
/// <summary> /// Sets the <see cref="ServiceBusReceivedMessage.ViaPartitionKey"/>. /// </summary> /// <param name="message">The message to modify.</param> /// <param name="viaPartitionKey">The via partition key to set on the message.</param> protected void SetViaPartitionKey(ServiceBusReceivedMessage message, string viaPartitionKey) { message.AmqpMessage.MessageAnnotations[AmqpMessageConstants.ViaPartitionKeyName] = viaPartitionKey; }
public override async Task <bool> BeginProcessingMessageAsync(ServiceBusReceiver receiver, ServiceBusReceivedMessage message, CancellationToken cancellationToken) { _logger?.LogInformation("Custom processor Begin called!"); return(await base.BeginProcessingMessageAsync(receiver, message, cancellationToken)); }
/// <summary> /// Set the <see cref="ServiceBusReceivedMessage.Body"/>. /// </summary> /// <param name="message">The message to modify.</param> /// <param name="body">The body to set on the message. This will overwrite any existing body.</param> #pragma warning disable CA1822 // Mark members as static protected void SetBody(ServiceBusReceivedMessage message, BinaryData body) { message.AmqpMessage.Body = new AmqpMessageBody(new ReadOnlyMemory <byte>[] { body }); }
public async Task TransactionThrowsWhenOperationsOfDifferentPartitionsAreInSameTransaction() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: true, enableSession: false)) { await using var client = CreateClient(); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusReceiver receiver = client.CreateReceiver(scope.QueueName); string body = Guid.NewGuid().ToString("N"); ServiceBusMessage message1 = GetMessage(partitionKey: "1"); ServiceBusMessage message2 = GetMessage(partitionKey: "2"); // Two send operations to different partitions. var transaction = new CommittableTransaction(); using (TransactionScope ts = new TransactionScope(transaction, TransactionScopeAsyncFlowOption.Enabled)) { await sender.SendMessageAsync(message1); Assert.ThrowsAsync <InvalidOperationException>( async() => await sender.SendMessageAsync(message2)); ts.Complete(); } transaction.Rollback(); // 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)); // Two complete operations to different partitions. await sender.SendMessageAsync(message1); await sender.SendMessageAsync(message2); ServiceBusReceivedMessage receivedMessage1 = await receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage1); ServiceBusReceivedMessage receivedMessage2 = await receiver.ReceiveMessageAsync(); Assert.NotNull(receivedMessage2); transaction = new CommittableTransaction(); using (TransactionScope ts = new TransactionScope(transaction, TransactionScopeAsyncFlowOption.Enabled)) { await receiver.CompleteMessageAsync(receivedMessage1); Assert.ThrowsAsync <InvalidOperationException>( async() => await receiver.CompleteMessageAsync(receivedMessage2)); ts.Complete(); } transaction.Rollback(); // 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)); await receiver.CompleteMessageAsync(receivedMessage1); // the service seems to abandon the message that // triggered the InvalidOperationException // in the transaction Assert.That( async() => await receiver.CompleteMessageAsync(receivedMessage2), Throws.InstanceOf <ServiceBusException>() .And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusFailureReason.MessageLockLost)); } }