public MessageReceiver GetMessageReceiver(string topic, string subscription)
{
var connectionStr = Environment.GetEnvironmentVariable(ServiceBusConnectionString);
string path = EntityNameHelper.FormatSubscriptionPath(topic, subscription);
return(new MessageReceiver(connectionStr, path));
}
IBrokeredMessageReceiver CreateBrokeredMessageReceiver(string topicPath, string subscriptionName, Action <IReceiveEndpointConfigurator> configure)
{
if (string.IsNullOrWhiteSpace(topicPath))
{
throw new ArgumentNullException(nameof(topicPath));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
var subscriptionPath = EntityNameHelper.FormatSubscriptionPath(topicPath, subscriptionName);
return(_receivers.GetOrAdd(subscriptionPath, name =>
{
var topicConfigurator = new TopicConfigurator(topicPath, false);
var settings = new SubscriptionEndpointSettings(topicConfigurator.GetTopicDescription(), subscriptionName);
var endpointConfiguration = _hostConfiguration.CreateSubscriptionEndpointConfiguration(settings);
var configurator = new SubscriptionBrokeredMessageReceiverConfiguration(_hostConfiguration, endpointConfiguration);
configure(configurator);
return configurator.Build();
}));
}
protected override IAsyncResult OnBeginCreateReceiver(TimeSpan timeout, AsyncCallback callback, object state)
{
string str = EntityNameHelper.FormatSubscriptionPath(base.Path, base.ClientId);
AmqpMessageReceiver amqpMessageReceiver = new AmqpMessageReceiver(this.messagingFactory, str, new MessagingEntityType?(MessagingEntityType.VolatileTopicSubscription), base.RetryPolicy, ReceiveMode.ReceiveAndDelete, base.Filter);
return(new CompletedAsyncResult <AmqpMessageReceiver>(amqpMessageReceiver, callback, state));
}
public async Task <long> PurgeMessages(string connectionString, string topicPath, string subscriptionPath,
bool isDlq)
{
var path = EntityNameHelper.FormatSubscriptionPath(topicPath, subscriptionPath);
path = isDlq ? EntityNameHelper.FormatDeadLetterPath(path) : path;
long purgedCount = 0;
var receiver = new MessageReceiver(connectionString, path, ReceiveMode.ReceiveAndDelete);
var operationTimeout = TimeSpan.FromSeconds(5);
while (true)
{
var messages = await receiver.ReceiveAsync(_maxMessageCount, operationTimeout);
if (messages == null || messages.Count == 0)
{
break;
}
purgedCount += messages.Count;
}
await receiver.CloseAsync();
return(purgedCount);
}
public async Task DeadletterMessage(string connectionString, string topicPath, string subscriptionPath,
Message message)
{
var path = EntityNameHelper.FormatSubscriptionPath(topicPath, subscriptionPath);
var receiver = new MessageReceiver(connectionString, path, ReceiveMode.PeekLock);
while (true)
{
var messages = await receiver.ReceiveAsync(_maxMessageCount);
if (messages == null || messages.Count == 0)
{
break;
}
var foundMessage = messages.FirstOrDefault(m => m.MessageId.Equals(message.MessageId));
if (foundMessage != null)
{
await receiver.DeadLetterAsync(foundMessage.SystemProperties.LockToken);
break;
}
}
await receiver.CloseAsync();
}
public async Task Capture_Transaction_When_Receive_From_Topic_Subscription()
{
await using var scope = await TopicScope.CreateWithTopicAndSubscription(_adminClient);
var sender = new MessageSender(_environment.ServiceBusConnectionString, scope.TopicName);
var receiver = new MessageReceiver(_environment.ServiceBusConnectionString,
EntityNameHelper.FormatSubscriptionPath(scope.TopicName, scope.SubscriptionName));
await sender.SendAsync(
new Message(Encoding.UTF8.GetBytes("test message"))).ConfigureAwait(false);
await receiver.ReceiveAsync(TimeSpan.FromSeconds(30)).ConfigureAwait(false);
if (!_sender.WaitForTransactions(TimeSpan.FromMinutes(2)))
{
throw new Exception("No transaction received in timeout");
}
_sender.Transactions.Should().HaveCount(1);
var transaction = _sender.FirstTransaction;
var subscription = $"{scope.TopicName}/Subscriptions/{scope.SubscriptionName}";
transaction.Name.Should().Be($"{ServiceBus.SegmentName} RECEIVE from {subscription}");
transaction.Type.Should().Be(ApiConstants.TypeMessaging);
transaction.Links.Should().NotBeNullOrEmpty();
transaction.Context.Message.Should().NotBeNull();
transaction.Context.Message.Queue.Should().NotBeNull();
transaction.Context.Message.Queue.Name.Should().Be(subscription);
}
static void ReceiveFromSub(string topic, string sub)
{
var entityPath = EntityNameHelper.FormatSubscriptionPath(topic, sub);
var receiver = new MessageReceiver(SBConnectionString, entityPath, ReceiveMode.ReceiveAndDelete);
RegisterMessageHandler(receiver);
}
protected override IAsyncResult OnBeginCreateReceiver(TimeSpan timeout, AsyncCallback callback, object state)
{
string str = EntityNameHelper.FormatSubscriptionPath(base.Path, base.ClientId);
CreateReceiverLinkSettings createReceiverLinkSetting = new CreateReceiverLinkSettings((SbmpMessagingFactory)base.MessagingFactory, str, base.Path, new MessagingEntityType?(MessagingEntityType.VolatileTopicSubscription), ReceiveMode.ReceiveAndDelete, this.ControlMessageCreator, base.RetryPolicy, false);
return(new CompletedAsyncResult <SbmpMessageReceiver>(createReceiverLinkSetting.MessageReceiver, callback, state));
}
public async Task Capture_Transaction_When_ReceiveDeferred_From_Topic_Subscription()
{
await using var scope = await TopicScope.CreateWithTopicAndSubscription(_adminClient);
var sender = new MessageSender(_environment.ServiceBusConnectionString, scope.TopicName);
var receiver = new MessageReceiver(_environment.ServiceBusConnectionString,
EntityNameHelper.FormatSubscriptionPath(scope.TopicName, scope.SubscriptionName));
await sender.SendAsync(
new Message(Encoding.UTF8.GetBytes("test message"))).ConfigureAwait(false);
var message = await receiver.ReceiveAsync(TimeSpan.FromSeconds(30)).ConfigureAwait(false);
await receiver.DeferAsync(message.SystemProperties.LockToken).ConfigureAwait(false);
await receiver.ReceiveDeferredMessageAsync(message.SystemProperties.SequenceNumber).ConfigureAwait(false);
if (!_sender.WaitForTransactions(TimeSpan.FromMinutes(2), count: 2))
{
throw new Exception("No transaction received in timeout");
}
_sender.Transactions.Should().HaveCount(2);
var transaction = _sender.FirstTransaction;
transaction.Name.Should().Be($"{ServiceBus.SegmentName} RECEIVE from {scope.TopicName}/Subscriptions/{scope.SubscriptionName}");
transaction.Type.Should().Be(ApiConstants.TypeMessaging);
var secondTransaction = _sender.Transactions[1];
secondTransaction.Name.Should().Be($"{ServiceBus.SegmentName} RECEIVEDEFERRED from {scope.TopicName}/Subscriptions/{scope.SubscriptionName}");
secondTransaction.Type.Should().Be(ApiConstants.TypeMessaging);
}
//https://github.com/Azure/azure-service-bus/blob/master/samples/DotNet/Microsoft.Azure.ServiceBus/ReceiveSample/readme.md
public AzureServiceBusTopicReceiver(string connectionString, string topicName, string subscriptionName, bool peekLock = true, MessageHandlerOptions handlerOptions = null)
: base(
CreateClient(connectionString, topicName, subscriptionName, peekLock),
CreateMessageReceiver(connectionString, EntityNameHelper.FormatSubscriptionPath(topicName, subscriptionName), peekLock),
handlerOptions)
{
}
protected override IMessageReceiver CreateMessageReceiver(string connectionString, string topicName, string subscriberName, ITokenProvider tokenProvider)
{
ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(connectionString);
return(new MessageReceiver(builder.Endpoint,
EntityNameHelper.FormatSubscriptionPath(topicName, subscriberName), tokenProvider));
}
private static async Task PurgeSubscriptionAsync(string subscriptionName)
{
try
{
Logger.Info($"Purging subscription '{subscriptionName}'");
var messageReceiver = new MessageReceiver(
ServiceBusConnectionString,
EntityNameHelper.FormatSubscriptionPath(TopicName, subscriptionName),
ReceiveMode.ReceiveAndDelete);
int batchSize = 100;
var operationTimeout = TimeSpan.FromSeconds(3);
do
{
var messages = await messageReceiver.ReceiveAsync(batchSize, operationTimeout).ConfigureAwait(false);
if (messages == null || messages.Count == 0) // Returns null if no message is found
{
break;
}
}while (true);
await messageReceiver.CloseAsync();
}
catch (Exception ex)
{
Logger.Error($"Error purging subscription {subscriptionName}", ex);
}
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
/// <param name="IsSender">Since Sender and Receiver aren't interchangable even when the the underlying client is (queue),
/// wee need to cache them seperately (the underlying framework will cache them anyhow; so as long as they aren't closed/disposed</param>
/// <param name="subscriptionName"></param>
/// <returns></returns>
private static Tuple <string, string> _getEntityNameAndUniqueKey(ServiceBusConnectionStringBuilder builder, bool isSender = false, string subscriptionName = null)
{
if (!String.IsNullOrEmpty(subscriptionName))
{
builder.EntityPath = EntityNameHelper.FormatSubscriptionPath(builder.EntityPath, subscriptionName);
}
return(new Tuple <string, string>(builder.EntityPath, $"{builder.Endpoint}/{builder.EntityPath}{isSender}".ToLowerInvariant()));
}
public ServiceBusTriggerBinding(string parameterName, Type parameterType, ITriggerDataArgumentBinding <Message> argumentBinding, ServiceBusAccount account,
ServiceBusOptions options, MessagingProvider messagingProvider, string topicName, string subscriptionName)
: this(parameterName, parameterType, argumentBinding, account, options, messagingProvider)
{
_topicName = topicName;
_subscriptionName = subscriptionName;
_entityPath = EntityNameHelper.FormatSubscriptionPath(topicName, subscriptionName);
}
public ServiceBusTriggerBinding(string parameterName, Type parameterType, ITriggerDataArgumentBinding <Message> argumentBinding, ServiceBusAccount account,
ServiceBusConfiguration config, string topicName, string subscriptionName)
: this(parameterName, parameterType, argumentBinding, account, config)
{
_topicName = topicName;
_subscriptionName = subscriptionName;
_entityPath = EntityNameHelper.FormatSubscriptionPath(topicName, subscriptionName);
}
public Task <IListener> CreateAsync(CancellationToken cancellationToken)
{
string entityPath = EntityNameHelper.FormatSubscriptionPath(_topicName, _subscriptionName);
ServiceBusTriggerExecutor triggerExecutor = new ServiceBusTriggerExecutor(_executor);
var listener = new ServiceBusListener(entityPath, triggerExecutor, _config, _account);
return(Task.FromResult <IListener>(listener));
}
public AzureMessageReceiver(IActorRuntime runtime, string connectionString, string topicName, ActorId actorId, string subscriptionName)
{
this.ActorRuntime = runtime;
this.LocalActorId = actorId;
this.LocalActorName = (actorId == null) ? "Client" : actorId.Name;
this.SubscriptionReceiver = new MessageReceiver(connectionString,
EntityNameHelper.FormatSubscriptionPath(topicName, subscriptionName),
ReceiveMode.ReceiveAndDelete);
}
protected override ClientContext CreateClientContext(MessagingFactoryContext connectionContext, Uri inputAddress)
{
var entityPath = EntityNameHelper.FormatSubscriptionPath(_settings.TopicDescription.Path, _settings.SubscriptionDescription.SubscriptionName);
var messageReceiver = connectionContext.MessagingFactory.CreateMessageReceiver(entityPath);
messageReceiver.PrefetchCount = _settings.PrefetchCount;
return(new SubscriptionClientContext(messageReceiver, inputAddress, _settings));
}
private async Task Cleanup()
{
await CleanUpEntity(FirstQueueName);
await CleanUpEntity(SecondQueueName);
await CleanUpEntity(BinderQueueName);
await CleanUpEntity(FirstQueueName, _secondaryConnectionString);
await CleanUpEntity(EntityNameHelper.FormatSubscriptionPath(TopicName, TopicSubscriptionName1));
await CleanUpEntity(EntityNameHelper.FormatSubscriptionPath(TopicName, TopicSubscriptionName2));
}
public IMessageReceiver Create(string queueName, ReceiveMode receiveMode, bool isDeadLetterQueue = false)
{
string path = EntityNameHelper.FormatSubscriptionPath(_connectionDetails.TopicName, queueName);
if (isDeadLetterQueue)
{
path = EntityNameHelper.FormatDeadLetterPath(path);
}
return(new MessageReceiver(_connectionDetails.ServiceBusConnectionString, path, receiveMode, RetryPolicy.NoRetry, 0));
}
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
var attribute = TypeUtility.GetResolvedAttribute <ServiceBusTriggerAttribute>(parameter);
if (attribute == null)
{
return(Task.FromResult <ITriggerBinding>(null));
}
string queueName = null;
string topicName = null;
string subscriptionName = null;
string entityPath = null;
if (attribute.QueueName != null)
{
queueName = Resolve(attribute.QueueName);
entityPath = queueName;
}
else
{
topicName = Resolve(attribute.TopicName);
subscriptionName = Resolve(attribute.SubscriptionName);
entityPath = EntityNameHelper.FormatSubscriptionPath(topicName, subscriptionName);
}
ITriggerDataArgumentBinding <Message> argumentBinding = InnerProvider.TryCreate(parameter);
if (argumentBinding == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind ServiceBusTrigger to type '{0}'.", parameter.ParameterType));
}
attribute.Connection = Resolve(attribute.Connection);
ServiceBusAccount account = new ServiceBusAccount(_options, _configuration, attribute);
ITriggerBinding binding;
if (queueName != null)
{
binding = new ServiceBusTriggerBinding(parameter.Name, parameter.ParameterType, argumentBinding, account, _options, _messagingProvider, queueName);
}
else
{
binding = new ServiceBusTriggerBinding(parameter.Name, parameter.ParameterType, argumentBinding, account, _options, _messagingProvider, topicName, subscriptionName);
}
return(Task.FromResult <ITriggerBinding>(binding));
}
public static void SBSub1Trigger(
[ServiceBusTrigger(_topicName, _subscriptionName, IsSessionsEnabled = true)] Message message, int deliveryCount,
IMessageSession messageSession,
ILogger log,
string lockToken)
{
Assert.Equal(EntityNameHelper.FormatSubscriptionPath(_topicName, _subscriptionName), messageSession.Path);
Assert.Equal(1, deliveryCount);
ServiceBusSessionsTestHelper.ProcessMessage(message, log, _waitHandle1, _waitHandle2);
}
public async Task ClearDeadLetters(string topicName, string subscriptionName)
{
var messageReceiver = new MessageReceiver(ServiceBusConnectionString, EntityNameHelper.FormatSubscriptionPath(topicName, subscriptionName), ReceiveMode.PeekLock);
var message = await messageReceiver.ReceiveAsync();
while ((message = await messageReceiver.ReceiveAsync()) != null)
{
await messageReceiver.CompleteAsync(message.SystemProperties.LockToken);
}
await messageReceiver.CloseAsync();
}
/// <inheritdoc />
protected override async Task RebuildReceiver()
{
using (await ReceiverLock.WriterLockAsync())
{
if (Receiver != null && !Receiver.IsClosedOrClosing)
{
await Receiver.CloseAsync().ConfigureAwait(false);
}
Receiver = new MessageReceiver(ConnectionString, EntityNameHelper.FormatSubscriptionPath(AzureTopic.Name, SubscriptionName), ReceiveMode.PeekLock, new RetryExponential(TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(500), 3), BatchSize);
}
}
public SubscriptionWrapper(
SubscriptionOptions options,
ServiceBusOptions parentOptions,
IServiceProvider provider)
: base(
options,
parentOptions,
provider,
EntityNameHelper.FormatSubscriptionPath(options.TopicName, options.SubscriptionName))
{
_options = options;
}
public GatewayMessageReceiver(GatewaySettings settings, ITextMessageProcessors processors, ILogger logger)
{
_logger = logger;
_processors = processors;
var subscription = EntityNameHelper.FormatSubscriptionPath(settings.ListenToTopic, settings.ServiceName);
_receiver = new MessageReceiver(settings.ServieBusConnectionString, subscription);
_receiver.RegisterMessageHandler(NewMessagReceivedHandler, ExceptionReceivedHandler);
_logger.Information($"Conneted SmsReciever to {settings.ServiceName}");
}
public AzureServiceBusMessageSubscriber(
string connectionString,
string topicName,
string subscriptionName)
{
var entityPath = EntityNameHelper.FormatSubscriptionPath(topicName, subscriptionName);
_messageReceiver = new MessageReceiver(
connectionString,
entityPath,
ReceiveMode.PeekLock);
}
private async Task ReceiveMessages(string subscription)
{
var entityPath = EntityNameHelper.FormatSubscriptionPath(TopicName, subscription);
var receiver = new MessageReceiver(ServiceBusConnectionString, entityPath, ReceiveMode.PeekLock, RetryPolicy.Default, 100);
// In reality you would not break out of the loop like in this example but would keep looping. The receiver keeps the connection open
// to the broker for the specified amount of seconds and the broker returns messages as soon as they arrive. The client then initiates
// a new connection. So in reality you would not want to break out of the loop.
// Also note that the code shows how to batch receive, which you would do for performance reasons. For convenience you can also always
// use the regular receive pump which we show in our Quick Start and in other github samples.
while (true)
{
try
{
IList <Message> messages = await receiver.ReceiveAsync(10, TimeSpan.FromSeconds(2));
// Note the extension class which is serializing an deserializing messages and testing messages is null or 0.
// If you think you did not receive all messages, just press M and receive again via the menu.
if (messages.Any())
{
foreach (var message in messages)
{
lock (Console.Out)
{
Item item = message.As <Item>();
IDictionary <string, object> myUserProperties = message.UserProperties;
Console.WriteLine($"StoreId={myUserProperties["StoreId"]}");
if (message.Label != null)
{
Console.WriteLine($"Label={message.Label}");
}
Console.WriteLine(
$"Item data: Price={item.getPrice()}, Color={item.getColor()}, Category={item.getItemCategory()}");
}
await receiver.CompleteAsync(message.SystemProperties.LockToken);
}
}
else
{
break;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
await receiver.CloseAsync();
}
private async Task <AzureMessage> PeekDlqMessageBySequenceNumber(string connectionString, string topicPath,
string subscriptionPath, long sequenceNumber)
{
var path = EntityNameHelper.FormatSubscriptionPath(topicPath, subscriptionPath);
var deadletterPath = EntityNameHelper.FormatDeadLetterPath(path);
var receiver = new MessageReceiver(connectionString, deadletterPath, ReceiveMode.PeekLock);
var azureMessage = await receiver.PeekBySequenceNumberAsync(sequenceNumber);
await receiver.CloseAsync();
return(azureMessage);
}
private void StartReceiving()
{
var entityPath = EntityNameHelper.FormatSubscriptionPath(Name, MyUsername);
var receiver = new MessageReceiver(WorkshopConfig.SBConnectionString, entityPath, ReceiveMode.ReceiveAndDelete);
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = true
};
receiver.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}