public ASBConsumerTests()
{
var command = new ASBTestCommand()
{
CommandValue = "Do the things.",
CommandNumber = 26
};
_correlationId = Guid.NewGuid();
_channelName = $"Consumer-Tests-{Guid.NewGuid()}".Truncate(50);
_topicName = $"Consumer-Tests-{Guid.NewGuid()}";
var routingKey = new RoutingKey(_topicName);
AzureServiceBusSubscription <ASBTestCommand> subscription = new(
name : new SubscriptionName(_channelName),
channelName : new ChannelName(_channelName),
routingKey : routingKey
);
_contentType = "application/json";
_message = new Message(
new MessageHeader(command.Id, _topicName, MessageType.MT_COMMAND, _correlationId, contentType: _contentType),
new MessageBody(JsonSerializer.Serialize(command, JsonSerialisationOptions.Options))
);
_subscriptionConfiguration = new AzureServiceBusSubscriptionConfiguration()
{
DeadLetteringOnMessageExpiration = true,
DefaultMessageTimeToLive = TimeSpan.FromDays(4),
LockDuration = TimeSpan.FromMinutes(3),
MaxDeliveryCount = 7,
SqlFilter = "1=1"
};
var clientProvider = ASBCreds.ASBClientProvider;
_administrationClient = new AdministrationClientWrapper(clientProvider);
_administrationClient.CreateSubscription(_topicName, _channelName, _subscriptionConfiguration);
_serviceBusClient = clientProvider.GetServiceBusClient();
var channelFactory =
new AzureServiceBusChannelFactory(new AzureServiceBusConsumerFactory(clientProvider, false));
_channel = channelFactory.CreateChannel(subscription);
_producerRegistry = new AzureServiceBusProducerRegistryFactory(
clientProvider,
new AzureServiceBusPublication[]
{
new AzureServiceBusPublication {
Topic = new RoutingKey(_topicName)
}
}
)
.Create();
}
public AzureServiceBusSubscriptionClient(
IAzureServiceBusPersistentConnection persistentConnection,
ILogger <AzureServiceBusClient> logger,
IOptions <AzureServiceBusSubscriptionConfiguration> configuration,
IServiceProvider serviceProvider,
IConfiguration globalConfiguration)
{
Guard.Argument(persistentConnection, nameof(persistentConnection)).NotNull();
_serviceProvider = serviceProvider;
_configuration = Guard.Argument(configuration, nameof(configuration)).NotNull().Value.Value;
_logger = Guard.Argument(logger, nameof(logger)).NotNull().Value;
_serviceProvider = Guard.Argument(serviceProvider, nameof(serviceProvider)).NotNull().Value;
var subscriptionInfo = new AzureSubscriptionClientModel();
globalConfiguration.Bind(typeof(TEvent).Name, subscriptionInfo);
_subscriptionClient = persistentConnection.CreateSubscriptionClient(subscriptionInfo.TopicName, subscriptionInfo.SubscriptionName);
}
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);
}
public AzureServiceBusTopicConfiguration()
{
Subscriptions = new AzureServiceBusSubscriptionConfiguration[0];
}
private async Task CreateSubscriptionAsync(string topicName, string subscriptionName, AzureServiceBusSubscriptionConfiguration subscriptionConfiguration)
{
s_logger.LogInformation("Creating subscription {ChannelName} for topic {Topic}...", subscriptionName, topicName);
if (!TopicExists(topicName))
{
CreateTopic(topicName);
}
var subscriptionOptions = new CreateSubscriptionOptions(topicName, subscriptionName)
{
MaxDeliveryCount = subscriptionConfiguration.MaxDeliveryCount,
DeadLetteringOnMessageExpiration = subscriptionConfiguration.DeadLetteringOnMessageExpiration,
LockDuration = subscriptionConfiguration.LockDuration,
DefaultMessageTimeToLive = subscriptionConfiguration.DefaultMessageTimeToLive
};
var ruleOptions = string.IsNullOrEmpty(subscriptionConfiguration.SqlFilter)
? new CreateRuleOptions() : new CreateRuleOptions("sqlFilter", new SqlRuleFilter(subscriptionConfiguration.SqlFilter));
try
{
await _administrationClient.CreateSubscriptionAsync(subscriptionOptions, ruleOptions);
}
catch (Exception e)
{
s_logger.LogError(e, "Failed to create subscription {ChannelName} for topic {Topic}.", subscriptionName, topicName);
throw;
}
s_logger.LogInformation("Subscription {ChannelName} for topic {Topic} created.", subscriptionName, topicName);
}
/// <summary>
/// Create a Subscription.
/// </summary>
/// <param name="topicName">The name of the Topic.</param>
/// <param name="subscriptionName">The name of the Subscription.</param>
/// <param name="subscriptionConfiguration">The configuration options for the subscriptions.</param>
public void CreateSubscription(string topicName, string subscriptionName, AzureServiceBusSubscriptionConfiguration subscriptionConfiguration)
{
CreateSubscriptionAsync(topicName, subscriptionName, subscriptionConfiguration).Wait();
}
