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); }