private IEnumerable <Task> ProcessEvent(ConsumeResult <string, byte[]> consumeResult)
{
var eventName = consumeResult.Topic;
var message = Encoding.UTF8.GetString(consumeResult.Message.Value);
if (_subscriptionManager.IsEventSubscribed(eventName))
{
var policy = BuildProcessEventPolicy();
using (var serviceScope = _serviceProvider.CreateScope())
{
foreach (var handlerType in _subscriptionManager.GetHandlersForEvent(eventName))
{
var handler = serviceScope.ServiceProvider.GetRequiredService(handlerType);
if (handler == null)
{
continue;
}
var eventType = _subscriptionManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IEventHandler <>).MakeGenericType(eventType);
_logger.LogInformation($"Process event \"{eventName}\" with \"{handler.GetType().Name}\"...");
yield return((Task)policy.Execute(() => concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent })));
}
}
}
}
private async Task ProcessEvent(string eventName, string message)
{
if (!_subscriptionManager.HasSubscriptionForEvent(eventName))
{
using (var scope = _autofacScope.BeginLifetimeScope(AUTOFAC_SCOPE_NAME))
{
var subscriptions = _subscriptionManager.GetHandlersForEvent(eventName);
foreach (var sub in subscriptions)
{
var handler = scope.ResolveOptional(sub.HandlerType);
if (sub.IsDynamic)
{
var dynamicHandler = handler as IDynamicIntegrationEventHandler;
dynamic eventData = JObject.Parse(message);
await dynamicHandler.Handle(eventData);
}
else
{
var eventType = _subscriptionManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
}
private async Task ProcessEvent(string eventName, string message)
{
logger.LogTrace($"Processing RabbitMQ event: {eventName}");
if (subscriptionManager.HasSubscritptionsForEvent(eventName))
{
using (var scope = autofac.BeginLifetimeScope())
{
var subscriptions = subscriptionManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = scope.ResolveOptional(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = subscriptionManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteHandlerType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
// TODO: ????
await Task.Yield();
await(Task) concreteHandlerType.GetMethod("Handle")
.Invoke(handler, new object[] { integrationEvent });
}
}
}
else
{
logger.LogWarning($"No subscription for event : {eventName}");
}
}
//Process Event to consumer channel (aka whoever is subscribed)
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _autofac.BeginLifetimeScope(AUTOFAC_SCOPE_NAME))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
//parse message into Json Object then handle the eventdata
}
else
{
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handler = scope.ResolveOptional(subscription.HandlerType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _scopeFactory.CreateScope())
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
var handler = scope.ServiceProvider.GetService(subscription.HandlerType) as IDynamicIntegrationEventHandler;
dynamic eventData = JObject.Parse(message);
await handler.Handle(eventData);
}
else
{
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handler = scope.ServiceProvider.GetService(subscription.HandlerType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
}
private async Task ProcessEvent(Envelope envelope)
{
if (envelope is null)
{
return;
}
if (!_busSubscriptionManager.HasSubscriptionsForEvent(envelope.Key))
{
return;
}
using (var scope = _autofac.BeginLifetimeScope())
{
var subscriptions = _busSubscriptionManager.GetHandlersForEvent(envelope.Key);
foreach (var subscription in subscriptions)
{
var handler = scope.ResolveOptional(subscription.HandlerType);
if (handler is null)
{
continue;
}
var eventType = _busSubscriptionManager.GetEventTypeByName(envelope.Key);
var integrationEvent = JsonConvert.DeserializeObject(envelope.Data?.ToString(), eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
// ReSharper disable once PossibleNullReferenceException
await(Task) concreteType
.GetMethod(nameof(IIntegrationEventHandler <IIntegrationEvent> .Handle))
?.Invoke(handler, new[] { integrationEvent });
}
}
}
public async ValueTask ProcessEvent <T>(T @event) where T : IntegrationEvent
{
if (_subsManager.HasSubscriptionsForEvent <T>())
{
using (var scope = _scopeFactory.CreateScope())
{
foreach (var handlerType in _subsManager.GetHandlersForEvent <T>())
{
var handler = (IIntegrationEventHandler <T>)scope.ServiceProvider.GetRequiredService(handlerType);
await handler.HandleAsync(@event, _cts.Token);
}
}
}
}
private async Task ProcessEvent(string eventName, string message)
{
_logger.LogTrace("Processing RabbitMQ event: {EventName}", eventName);
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _autofac.BeginLifetimeScope(AUTOFAC_SCOPE_NAME))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
var handler = scope.ResolveOptional(subscription.HandlerType) as IDynamicIntegrationEventHandler;
if (handler == null)
{
continue;
}
dynamic eventData = JObject.Parse(message);
await Task.Yield();
await handler.Handle(eventData);
}
else
{
var handler = scope.ResolveOptional(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await Task.Yield();
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
else
{
_logger.LogWarning("No subscription for RabbitMQ event: {EventName}", eventName);
}
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var handlertypes = _subsManager.GetHandlersForEvent(eventName);
foreach (var handlerType in handlertypes)
{
var handler = _services.GetService(handlerType);
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await Task.Yield();
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
private async Task <bool> ProcessEvent(string eventName, string message)
{
var processed = false;
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _autofac.BeginLifetimeScope(_autofacScopeName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
var handler = scope.ResolveOptional(subscription.HandlerType) as IDynamicIntegrationEventHandler;
if (handler == null)
{
continue;
}
dynamic eventData = JObject.Parse(message);
await handler.Handle(eventData);
}
else
{
var handler = scope.ResolveOptional(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new[] { integrationEvent });
}
}
}
processed = true;
}
return(processed);
}
private async Task ProcessEvent(string eventName, string message)
{
_logger.LogTrace("Processing RabbitMQ event: {EventName}", eventName);
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _autofac.BeginLifetimeScope(AUTOFAC_SCOPE_NAME))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
//TODO: For Dynamic. Do I even need it???
}
else
{
var handler = scope.ResolveOptional(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
//var jsonSerializerOptions = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
//var integrationEvent = System.Text.Json.JsonSerializer.Deserialize(message, eventType, jsonSerializerOptions);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await Task.Yield();
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
else
{
_logger.LogWarning("No subscription for RabbitMQ event: {EventName}", eventName);
}
}
private async Task ConsumerReceived(object sender, BasicDeliverEventArgs eventArgs)
{
var eventName = eventArgs.RoutingKey;
var message = Encoding.UTF8.GetString(eventArgs.Body);
if (_subscriptionManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subscriptionManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var policyContext = new Context(eventName);
var policyBuilder = Policy
.HandleResult <bool>(successfullyExecution => !successfullyExecution)
.Or <Exception>();
var policy = policyBuilder
.WaitAndRetryAsync(
_retryCount,
retryAttempt => TimeSpan.FromSeconds(1), (executionResult, retryDelay, ctx) =>
_logger.LogWarning($@"Falha no processamento da mensagem: {message}, retentativa em {retryDelay} segundos."))
.WithPolicyKey(eventName);
var policyExecution = await policy.ExecuteAsync(
async ctx => await ProcessEvent(eventName, message, subscription).ConfigureAwait(false), policyContext).ConfigureAwait(false);
if (!policyExecution)
{
// todo: adjust error messages to error queue listener
var errorIntegrationEvent = new ErrorIntegrationEvent(eventName, _queueName, "Deu ruim oh!");
Publish(errorIntegrationEvent);
}
_consumerChannel.BasicAck(eventArgs.DeliveryTag, false);
}
}
}
private async Task <bool> ProcessEvent <T>(T value) where T : IntegrationEvent
{
var processed = false;
if (_subscriptionManager.HasEvent <T>())
{
using (var scope = _serviceScopeFactory.CreateScope())
{
var subscriptions = _subscriptionManager.GetHandlersForEvent <T>();
foreach (var subscription in subscriptions)
{
var handler = scope.ServiceProvider.GetRequiredService(subscription);
if (handler == null)
{
continue;
}
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(typeof(T));
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { value });
}
}
processed = true;
}
return(processed);
}