private void EnsureTopicClientsCreated()
{
if (_topicClients != null)
{
return;
}
lock (_locker)
{
if (_topicClients != null)
{
return;
}
var topicClients = new Dictionary <string, TopicClient>();
var configuration = _configurationService.Get <AzureServiceBusConfiguration>();
foreach (var topic in configuration.Topics)
{
var topicName = _topicNameFormatter.GetTopicName(topic.TopicName);
var topicClient = TopicClient.CreateFromConnectionString(configuration.ConnectionString, topicName);
topicClients.Add(topic.MessageType, topicClient);
}
_topicClients = topicClients;
}
}
private void CheckAzureServiceBusMessageCounts()
{
_logger.Info("Checking Azure Service Bus Message counts");
var serviceBusConfiguration = _configurationService.Get <AzureServiceBusConfiguration>();
var namespaceManager = NamespaceManager.CreateFromConnectionString(serviceBusConfiguration.ConnectionString);
foreach (var topicConfiguration in serviceBusConfiguration.Topics)
{
var topicName = _topicNameFormatter.GetTopicName(topicConfiguration.TopicName);
var topicMessageCountDetails = GetTopicMessageCountDetails(
namespaceManager, topicName);
foreach (var subscriptionConfiguration in topicConfiguration.Subscriptions)
{
var subscriptionPath = string.Format("{0}/{1}",
topicName, subscriptionConfiguration.SubscriptionName);
var messageCountWarningLimit =
subscriptionConfiguration.MessageCountWarningLimit ??
serviceBusConfiguration.DefaultMessageCountWarningLimit;
var deadLetterMessageCountWarningLimit =
subscriptionConfiguration.DeadLetterMessageCountWarningLimit ??
serviceBusConfiguration.DefaultDeadLetterMessageCountWarningLimit;
_logger.Debug("Limits for topic/subscription {0} are {1} active and {2} dead-lettered messages",
subscriptionPath, messageCountWarningLimit, deadLetterMessageCountWarningLimit);
var subscriptionMessageCountDetails = GetSubscriptionMessageCountDetails(
namespaceManager, topicName, subscriptionConfiguration.SubscriptionName);
var messageCountNarrative = string.Format("Found {0} active, {1} scheduled and {2} dead-lettered message(s) for topic/subscription: {3}",
subscriptionMessageCountDetails.ActiveMessageCount,
topicMessageCountDetails.ScheduledMessageCount,
subscriptionMessageCountDetails.DeadLetterMessageCount,
subscriptionPath);
if (subscriptionMessageCountDetails.ActiveMessageCount >= messageCountWarningLimit ||
subscriptionMessageCountDetails.DeadLetterMessageCount >= deadLetterMessageCountWarningLimit)
{
_logger.Warn(messageCountNarrative);
}
else
{
_logger.Info(messageCountNarrative);
}
}
}
_logger.Info("Checked Azure Service Bus Message counts");
}
public void Initialise()
{
_logService.Debug("Initialising...");
var configuration = _configurationService.Get <AzureServiceBusConfiguration>();
var namespaceManager = NamespaceManager.CreateFromConnectionString(configuration.ConnectionString);
foreach (var topic in configuration.Topics)
{
var topicName = _topicNameFormatter.GetTopicName(topic.TopicName);
if (!namespaceManager.TopicExists(topicName))
{
var topicDescription = new TopicDescription(topicName);
try
{
_logService.Info("Creating topic '{0}'", topicName);
namespaceManager.CreateTopic(topicDescription);
_logService.Info("Created topic '{0}'", topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
_logService.Info("Topic already exists '{0}'", topicName);
}
}
foreach (var subscription in topic.Subscriptions)
{
if (!namespaceManager.SubscriptionExists(topicName, subscription.SubscriptionName))
{
try
{
_logService.Info("Creating subscription '{0}/{1}'", topicName, subscription.SubscriptionName);
namespaceManager.CreateSubscription(topicName, subscription.SubscriptionName);
_logService.Info("Created subscription '{0}/{1}'", topicName, subscription.SubscriptionName);
}
catch (MessagingEntityAlreadyExistsException)
{
_logService.Info("Subscription already exists '{0}/{1}'", topicName, subscription.SubscriptionName);
}
}
}
}
_logService.Debug("Initialised");
}
private SubscriberInfo SubscribeOne(IServiceBusSubscriber <TMessage> subscriber)
{
string topicName;
string subscriptionName;
if (!TryGetSubscriberTopicSubscriptionNames(subscriber, out topicName, out subscriptionName))
{
throw new InvalidOperationException(string.Format(
"No subscriber topic/subscription attribute specified for type '{0}'", typeof(TMessage).FullName));
}
var serviceBusConfiguration = _configurationService.Get <AzureServiceBusConfiguration>();
var subscriptionConfiguration = serviceBusConfiguration.Topics
.Where(each => each.TopicName == topicName)
.SelectMany(each => each.Subscriptions)
.FirstOrDefault(each => each.SubscriptionName == subscriptionName);
if (subscriptionConfiguration == null)
{
_logService.Info(
"No subscriber configuration found for topic/subscription \"{0}/{1}\", will use default configuration",
topicName, subscriptionName);
subscriptionConfiguration = new AzureServiceBusSubscriptionConfiguration();
}
//Ensure topic name is correctly formatted after its configuration has been retrieved
topicName = _topicNameFormatter.GetTopicName(topicName);
var subscriptionPath = string.Format("{0}/{1}", topicName, subscriptionConfiguration.SubscriptionName);
_logService.Info("Subscribing to topic/subscription '{0}'", subscriptionPath);
var topicClient = _clientFactory.CreateFromConnectionString(
serviceBusConfiguration.ConnectionString, topicName);
var options = new OnMessageOptions
{
MaxConcurrentCalls =
subscriptionConfiguration.MaxConcurrentMessagesPerNode ??
serviceBusConfiguration.DefaultMaxConcurrentMessagesPerNode,
AutoComplete = false
};
options.ExceptionReceived += LogSubscriptionClientException;
var subscriptionClient = _clientFactory.CreateFromConnectionString(
serviceBusConfiguration.ConnectionString,
topicName,
subscriptionConfiguration.SubscriptionName,
ReceiveMode.PeekLock);
var subscriberInfo = new SubscriberInfo
{
SubscriptionPath = subscriptionPath,
TopicClient = topicClient,
SubscriptionClient = subscriptionClient,
Subscriber = subscriber
};
subscriptionClient.OnMessage(brokeredMessage => ConsumeMessage(subscriberInfo, brokeredMessage), options);
_logService.Info("Subscribed to topic/subscription '{0}' with max of {1} concurrent call(s) per node",
subscriptionPath, options.MaxConcurrentCalls);
return(subscriberInfo);
}
