/// <summary>
///
/// </summary>
/// <param name="eventSerialized"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public Task ExecuteDomainSubscribers(string eventSerialized, CancellationToken cancellationToken)
{
var eventDeserialized = _deserializer.Deserialize(eventSerialized);
return(Task.WhenAll(
DomainEventSubscriberInformationService
.GetAllEventsSubscribers(eventDeserialized)
.Select(subscriber =>
ExecuteDomainSubscriber(eventSerialized, eventDeserialized, subscriber, cancellationToken))));
}
public void Consume(DomainEvent @event)
{
var subscribers = DomainEventSubscriberInformationService.GetAllEventsSubscribers(@event);
foreach (var subscriber in subscribers)
{
_domainEventsToExecute.Subscribers.Add(cancellationToken =>
_domainEventMediator.ExecuteOn(@event, subscriber, cancellationToken));
}
//return Task.WhenAll(subscribers.Select(subscriber =>
// _domainEventMediator.ExecuteOn(@event, subscriber, cancellationToken)));
}
/// <summary>
///
/// </summary>
/// <param name="stoppingToken"></param>
/// <returns></returns>
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
using var initialScope = _serviceScopeFactory.CreateScope();
var domainEventJsonDeserializer = initialScope.ServiceProvider.GetRequiredService <DomainEventJsonDeserializer>();
var domainEventMediator = initialScope.ServiceProvider.GetRequiredService <DomainEventMediator>();
var redisSubscriber = initialScope.ServiceProvider.GetRequiredService <IConnectionMultiplexer>().GetSubscriber();
await redisSubscriber.SubscribeAsync("*", async (_, value) =>
{
var @event = domainEventJsonDeserializer.Deserialize(value);
var subscribers = DomainEventSubscriberInformationService.GetAllEventsSubscribers(@event);
await Task.WhenAll(subscribers.Select(subscriber =>
domainEventMediator.ExecuteOn(@event, subscriber, stoppingToken)));
});
}
/// <summary>
///
/// </summary>
/// <param name="stoppingToken"></param>
/// <returns></returns>
protected override Task ExecuteAsync(CancellationToken stoppingToken)
{
using var scope = _serviceScopeFactory.CreateScope();
var channel = scope.ServiceProvider.GetRequiredService <RabbitMqConnectionFactory>().Channel();
var exchangeName = scope.ServiceProvider.GetRequiredService <IOptions <RabbitMqConfigParams> >().Value.ExchangeName;
var retryDomainEventExchange = RabbitMqExchangeNameFormatter.Retry(exchangeName);
var deadLetterDomainEventExchange = RabbitMqExchangeNameFormatter.DeadLetter(exchangeName);
channel.ExchangeDeclare(exchangeName, ExchangeType.Topic);
channel.ExchangeDeclare(retryDomainEventExchange, ExchangeType.Topic);
channel.ExchangeDeclare(deadLetterDomainEventExchange, ExchangeType.Topic);
foreach (var subscriberInformation in DomainEventSubscriberInformationService.All())
{
var domainEventsQueueName = RabbitMqQueueNameFormatter.Format(subscriberInformation);
var retryQueueName = RabbitMqQueueNameFormatter.FormatRetry(subscriberInformation);
var deadLetterQueueName = RabbitMqQueueNameFormatter.FormatDeadLetter(subscriberInformation);
var subscribedEvent = EventNameSubscribed(subscriberInformation);
var queue = channel.QueueDeclare(domainEventsQueueName, true, false, false);
var retryQueue = channel.QueueDeclare(retryQueueName, true, false, false,
RetryQueueArguments(exchangeName, domainEventsQueueName));
var deadLetterQueue = channel.QueueDeclare(deadLetterQueueName, true, false, false);
channel.QueueBind(queue, exchangeName, domainEventsQueueName);
channel.QueueBind(retryQueue, retryDomainEventExchange, domainEventsQueueName);
channel.QueueBind(deadLetterQueue, deadLetterDomainEventExchange, domainEventsQueueName);
channel.QueueBind(queue, exchangeName, subscribedEvent);
}
return(scope.ServiceProvider.GetRequiredService <RabbitMqDomainEventsConsumer>().Consume());
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public Task Consume()
{
DomainEventSubscriberInformationService.GetAllEventsSubscribers().ForEach(eventSubscriber => ConsumeMessages(eventSubscriber));
return(Task.CompletedTask);
}
