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 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 object[] { integrationEvent });
}
}
}
}
else
{
_logger.LogWarning("No subscription for RabbitMQ event: {EventName}", eventName);
}
}
/// <summary>
/// 执行器
/// </summary>
/// <param name="eventName"></param>
/// <param name="message"></param>
/// <returns></returns>
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _autofac.CreateScope())
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var eventType = _subsManager.GetEventTypeByName(eventName);
if (eventType != null)
{
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handler = scope.ServiceProvider.GetRequiredService(subscription);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
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(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;
}
using dynamic eventData = JsonDocument.Parse(message);
await handler.Handle(eventData);
}
else
{
var handler = scope.ResolveOptional(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonSerializer.Deserialize(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
processed = true;
}
return(processed);
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handlers = _subsManager.GetHandlersForEvent(eventName);
foreach (var handlerfactory in handlers)
{
try
{
var handler = handlerfactory.DynamicInvoke();
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
catch
{
}
}
}
}
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)
{
var handler = scope.ResolveOptional(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
}
protected virtual async Task TriggerHandlersAsync(string eventName, string eventData, List <Exception> exceptions)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
try
{
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonUtils.DeserializeObject(eventData, eventType);
var handler = _serviceProvider.GetService(subscription.HandlerType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
}
}
public async Task ProcessEvent(string eventName, byte[] data)
{
if (!_subscriptionsManager.HasSubscriptionsForEvent(eventName))
{
return;
}
var message = Encoding.UTF8.GetString(data);
using (var scope = _serviceProvider.CreateScope())
{
var subscriptions = _subscriptionsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
var handler =
scope.ServiceProvider.GetService(subscription.HandlerType) as IDynamicEventHandler;
dynamic eventData = JObject.Parse(message);
if (handler != null)
{
await handler.Handle(eventData);
}
else
{
_logger.LogWarning($"Handler not found for {subscription.HandlerType} on {eventName}.");
}
}
else
{
var eventType = _subscriptionsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handler = scope.ServiceProvider.GetService(subscription.HandlerType);
var concreteHandlerType = typeof(IEventHandler <>).MakeGenericType(eventType);
await(Task) concreteHandlerType.GetMethod("Handle").Invoke(handler, new[] { integrationEvent });
}
}
}
}
private async Task ProcessEvent(IntegrationEvent @event)
{
var eventName = @event.GetType().Name;
if (_subManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _serviceProvider.CreateScope())
{
var subscriptions = _subManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var eventType = _subManager.GetEventTypeByName(eventName);
if (eventType != null)
{
var instance = scope.ServiceProvider.GetRequiredService(subscription);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(instance, new object[] { @event });
}
}
}
}
}
private async Task <bool> ProcessEvent(string eventName, string message)
{
var processed = false;
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _serviceCollection.BuildServiceProvider())
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
var handler = scope.GetService(subscription.HandlerType) as IDynamicIntegrationEventHandler;
if (handler == null)
{
continue;
}
dynamic eventData = JObject.Parse(message);
await handler.Handle(eventData);
}
else
{
var handler = scope.GetService(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 object[] { integrationEvent });
}
}
}
processed = true;
}
return(processed);
}
private async Task ProcessEventAsync(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
if (!(_serviceProvider.GetService(subscription.HandlerType) is
IDynamicIntegrationEventHandler handler))
{
continue;
}
dynamic eventData = JObject.Parse(message);
await handler.Handle(eventData);
}
else
{
var handler = _serviceProvider
.CreateScope()
.ServiceProvider
.GetService(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 });
}
}
}
}
private async Task ProcessEvent(IntegrationEvent iEvent)
{
var eventName = iEvent.GetNormalizeTypeName();
_logger.LogDebug("Processing event: {EventName}", eventName);
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = subscription.HandlerType;
if (handler == null)
{
continue;
}
var handlerConstructor = handler.GetConstructors(BindingFlags.Public | BindingFlags.Instance)
.OrderByDescending(c => c.GetParameters().Length).First();
var parameters = handlerConstructor.GetParameters();
var arguments = parameters.Select(p => _serviceProvider.GetService(p.ParameterType)).ToArray();
dynamic objectHandler = handlerConstructor.Invoke(arguments);
var eventType = _subsManager.GetEventTypeByName(eventName);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await Task.Yield();
await(Task) concreteType.GetMethod("Handle").Invoke(objectHandler, new object[] { iEvent });
}
}
else
{
_logger.LogWarning("No subscription for event: {EventName}.", eventName);
}
}
private async Task ProcessEvent(string eventName, string message)
{
_logger.LogTrace("Processing RabbitMQ event: {EventName}", eventName);
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
using var scope = _serviceProvider.CreateScope();
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
if (!(scope.ServiceProvider.GetService(subscription.HandlerType) is IDynamicIntegrationEventHandler handler))
{
continue;
}
dynamic eventData = JsonDocument.Parse(message);
await handler.Handle(eventData);
}
else
{
var handler = scope.ServiceProvider.GetService(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonSerializer.Deserialize(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
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 (!_subscriptionsManager.HasSubscriptionsForEvent(eventName))
{
return;
}
using (var scope = _autofac.BeginLifetimeScope(_autofacScopeName))
{
var subscriptions = _subscriptionsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
var handler =
scope.ResolveOptional(subscription.HandlerType) as IDynamicIntegrationEventHandler;
dynamic eventData = JObject.Parse(message);
if (handler != null)
{
await handler.Handle(eventData);
}
else
{
_logger.LogWarning($"Handler not found for {subscription.HandlerType} on {eventName}.");
}
}
else
{
var eventType = _subscriptionsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handler = scope.ResolveOptional(subscription.HandlerType);
var concreteHandlerType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteHandlerType.GetMethod("Handle").Invoke(handler, new[] { integrationEvent });
}
}
}
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var eventType = _subsManager.GetEventTypeByName(eventName);
if (eventType == null)
{
_logger.LogWarning("Unregistered event {0}", eventName);
return;
}
var(context, payload) = await Unwrap(message, eventType);
if (payload == null)
{
_logger.LogError("Integrated event malformed. Payload: {0}", message);
return;
}
using (var scope = _serviceProvider.CreateScope())
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (context != null)
{
var contextAccessor = scope.ServiceProvider.GetService <TenantContextAccessor>();
contextAccessor.TenantContext = context;
}
var handler = scope.ServiceProvider.GetService(subscription.HandlerType);
var concreteType = typeof(IIntegratedEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new[] { payload });
}
}
}
}
private async Task ProcessEvent(string eventName, string message, ulong deliveryTag)
{
try
{
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;
dynamic eventData = JObject.Parse(message);
await handler.Handle(eventData);
_consumerChannel.BasicAck(deliveryTag, false);
}
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 });
_consumerChannel.BasicAck(deliveryTag, false);
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
private async Task <bool> ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = _integrationEventHandlerFactory.GetIntegrationEventHandler(subscription.HandlerType.FullName);
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = message.DeserializeJson(eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
var method = concreteType.GetMethod("Handle");
if (method != null)
{
await((Task)method.Invoke(handler, new[] { integrationEvent })).ConfigureAwait(false);
}
}
return(true);
}
return(false);
}
private async Task ProcessEvent(string eventName, string message)
{
_logger.LogTrace("Processing NATS event: {EventName}", eventName);
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (!subscription.IsDynamic)
{
var handler = _serviceProvider.GetService(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonSerializer.Deserialize(message, eventType) as IntegrationEvent;
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await Task.Yield();
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
private async Task ProcessEvent(string eventName, string message)
{
// _logger.LogTrace("Processing RabbitMQ event: {EventName}", eventName);
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
var handler = 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 });
}
}
}
private async Task ProcessEvent(string eventName, string message)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
if (subscription.IsDynamic)
{
// var handler = scope.ResolveOptional(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 = Activator.CreateInstance(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)
{
_logger.LogTrace("Processing event: {EventName}", eventName);
if (_subscriptionsManager.HasSubscriptionsForEvent(eventName))
{
using (var scope = _serviceProvider.CreateScope())
{
var handlerTypes = _subscriptionsManager.GetHandlersForEvent(eventName);
foreach (var type in handlerTypes)
{
var handler = scope.ServiceProvider.GetService(type) as IIntegrationEventHandler;
var eventType = _subscriptionsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
}
}
}
else
{
_logger.LogWarning("No subscription for event: {EventName}", eventName);
}
}
private async Task ProcessEvent(string eventName, string message, bool redelivered)
{
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (var subscription in subscriptions)
{
using (var scope = _serviceProvider.CreateScope())
{
var serviceProvider = scope.ServiceProvider;
if (subscription.IsDynamic)
{
if (!(serviceProvider.GetService(subscription.HandlerType) is IDynamicIntegrationEventHandler handler))
{
continue;
}
dynamic integrationEvent = JObject.Parse(message);
await handler.Handle(integrationEvent, redelivered);
}
else
{
dynamic handler = serviceProvider.GetService(subscription.HandlerType);
if (handler == null)
{
continue;
}
var eventType = _subsManager.GetEventTypeByName(eventName);
dynamic integrationEvent = JsonConvert.DeserializeObject(message, eventType);
await handler.Handle(integrationEvent, redelivered);
}
}
_logger.LogInformation($"Consumed {eventName}");
}
}
}
protected virtual async ValueTask ProcessEvent(string routingKey, string eventName, ReadOnlyMemory <byte> message, CancellationToken cancel = default)
{
if (SubsManager.HasSubscriptionsForEvent(routingKey))
{
var subscriptions = SubsManager.GetHandlersForEvent(routingKey);
foreach (var subscription in subscriptions)
{
switch (subscription.SubscriptionManagerType)
{
case SubscriptionManagerType.Dynamic:
break;
case SubscriptionManagerType.Typed:
try
{
if (EventHandler is null)
{
}
else
{
var eventType = SubsManager.GetEventTypeByName(routingKey);
if (eventType is null)
{
Logger.LogError("ProcessEvent Typed: eventType is null! " + routingKey);
return;
}
await using var ms = new MemoryStream(message.ToArray());
var integrationEvent = Serializer.Deserialize(eventType, ms);
var concreteType =
typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await((ValueTask)concreteType.GetMethod("Handle")
.Invoke(EventHandler, new[] { integrationEvent, cancel })).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Logger.LogError("ProcessEvent Typed: " + ex.Message + " - " + ex.StackTrace);
}
break;
case SubscriptionManagerType.Queue:
try
{
if (EventHandler is null)
{
}
else
{
var eventType = SubsManager.GetEventTypeByName(routingKey);
if (eventType is null)
{
Logger.LogError("ProcessQueue: eventType is null! " + routingKey);
return;
}
await using var ms = new MemoryStream(message.ToArray());
var integrationEvent = Serializer.Deserialize(eventType, ms);
var concreteType =
typeof(IIntegrationQueueHandler <>).MakeGenericType(eventType);
await((ValueTask <bool>)concreteType.GetMethod("Enqueue")
.Invoke(EventHandler, new[] { integrationEvent, cancel })).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Logger.LogError("ProcessQueue: " + ex.Message + " - " + ex.StackTrace);
}
break;
case SubscriptionManagerType.Rpc:
try
{
if (EventHandler is null)
{
}
else
{
var eventType = SubsManager.GetEventTypeByName(routingKey);
if (eventType is null)
{
Logger.LogError("ProcessEvent: eventType is null! " + routingKey);
return;
}
var eventResultType = SubsManager.GetEventReplyTypeByName(routingKey);
if (eventResultType is null)
{
Logger.LogError("ProcessEvent: eventResultType is null! " + routingKey);
return;
}
await using var ms = new MemoryStream(message.ToArray());
var integrationEvent = Serializer.Deserialize(eventResultType, ms);
var concreteType =
typeof(IIntegrationRpcHandler <,>).MakeGenericType(eventType,
eventResultType);
await((ValueTask)concreteType.GetMethod("HandleReply")
.Invoke(EventHandler, new[] { integrationEvent, cancel })).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Logger.LogError("ProcessEvent Rpc: " + ex.Message + " - " + ex.StackTrace);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
}//ProcessEvent.
private async Task ProcessEvent(string eventName, ReadOnlyMemory <byte> body, QueueConsumerMode type, IBasicProperties properties, bool bindConsumer)
{
var message = Encoding.UTF8.GetString(body.ToArray());
var eventType = _subscriptionsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handlers = _subscriptionsManager.GetHandlersForEvent(eventName);
var concreteType = typeof(IEventHandler <>).MakeGenericType(eventType);
foreach (var item in handlers)
{
var handler = item.DynamicInvoke();
long count = 1;
try
{
if (type == QueueConsumerMode.Normal || type == QueueConsumerMode.Retry)
{
var fastInvoker = GetHandler($"{concreteType.FullName}.Handle", concreteType.GetMethod("Handle"));
await(Task) fastInvoker(handler, new object[] { integrationEvent });
}
}
catch
{
if (!_rabbitMqClient.IsConnected)
{
_rabbitMqClient.TryConnect();
}
count = GetRetryCount(properties);
using (var channel = _rabbitMqClient.CreateModel())
{
if (count > _retryCount)
{
// 重试次数大于设置次数，则自动加入到死信队列
var rollbackCount = count - _retryCount;
if (rollbackCount <= _rollbackCount)
{
IDictionary <String, Object> headers = new Dictionary <String, Object>();
if (!bindConsumer)
{
return;
}
if (!headers.ContainsKey("x-orig-routing-key"))
{
headers.Add("x-orig-routing-key", GetOrigRoutingKey(properties, eventName));
}
channel.BasicPublish($"{BROKER_NAME}@{QueueConsumerMode.Fail.ToString()}", eventName,
CreateOverrideProperties(properties, headers), body);
}
}
else
{
if (!bindConsumer)
{
return;
}
IDictionary <String, Object> headers = properties.Headers ?? new Dictionary <String, Object>();
if (!headers.ContainsKey("x-orig-routing-key"))
{
headers.Add("x-orig-routing-key", GetOrigRoutingKey(properties, eventName));
}
channel.BasicPublish($"{BROKER_NAME}@{QueueConsumerMode.Retry.ToString()}", eventName,
CreateOverrideProperties(properties, headers), body);
}
}
}
finally
{
var baseConcreteType = typeof(BaseEventHandler <>).MakeGenericType(eventType);
if (handler.GetType().BaseType == baseConcreteType)
{
var context = new EventContext()
{
Content = integrationEvent,
Count = count,
Type = type.ToString()
};
switch (type)
{
case QueueConsumerMode.Normal:
case QueueConsumerMode.Retry:
{
var fastInvoker = GetHandler($"{baseConcreteType.FullName}.Handled", baseConcreteType.GetMethod("Handled"));
await(Task) fastInvoker(handler, new object[] { context });
break;
}
case QueueConsumerMode.Fail:
{
var fastInvoker = GetHandler($"{baseConcreteType.FullName}.FailHandler", baseConcreteType.GetMethod("FailHandler"));
await(Task) fastInvoker(handler, new object[] { context });
break;
}
}
}
}
}
}
/// <summary>
/// 处理事件
/// </summary>
/// <param name="eventName"></param>
/// <param name="message"></param>
/// <returns></returns>
private async Task <bool> TryProcessEvent(string eventName, string message)
{
_logger?.LogTrace($"处理事件: {eventName}");
var result = false;
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
IEnumerable <SubscriptionInfo> subscriptions = _subsManager.GetHandlersForEvent(eventName);
foreach (SubscriptionInfo subscription in subscriptions)
{
if (subscription.IsDynamic)
{
if (!(_service.GetService(subscription.HandlerType) is IDynamicIntegrationEventHandler handler))
{
continue;
}
dynamic eventData = JObject.Parse(message);
try
{
await handler.HandleAsync(eventData);
}
catch (Exception exception)
{
await HandlerErrorMessageAsync(exception, async() => await handler.HandleAsync(eventData));
}
}
else
{
object handler = _service.GetService(subscription.HandlerType);
if (handler == null)
{
continue;
}
Type eventType = _subsManager.GetEventTypeByName(eventName);
object integrationEvent = JsonConvert.DeserializeObject(message, eventType);
Type concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
MethodInfo handlerMethodInfo = concreteType.GetMethod("HandleAsync");
if (handlerMethodInfo == null || handlerMethodInfo.ReturnType != typeof(Task))
{
continue;
}
try
{
await Task.Run(async() =>
{
await(Task) handlerMethodInfo.Invoke(handler, new[] { integrationEvent });
});
}
catch (Exception exception)
{
await HandlerErrorMessageAsync(exception, async() => await (Task) handlerMethodInfo.Invoke(handler, new[] { integrationEvent }));
}
}
_logger?.LogTrace($"处理器{subscription.HandlerType.Name}执行完毕");
}
result = true;
}
else
{
_logger?.LogError($"未找到订阅事件: {eventName}");
}
return(result);
}
private async Task ProcessEvent(string eventName, byte[] body, QueueConsumerMode mode, IBasicProperties properties)
{
var message = Encoding.UTF8.GetString(body);
if (_subsManager.HasSubscriptionsForEvent(eventName))
{
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
var handlers = _subsManager.GetHandlersForEvent(eventName);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
foreach (var handlerfactory in handlers)
{
var handler = handlerfactory.DynamicInvoke();
long retryCount = 1;
try
{
var fastInvoker = GetHandler($"{concreteType.FullName}.Handle", concreteType.GetMethod("Handle"));
await(Task) fastInvoker(handler, new object[] { integrationEvent });
}
catch
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
retryCount = GetRetryCount(properties);
using (var channel = _persistentConnection.CreateModel())
{
if (retryCount > _retryCount)
{
// 重试次数大于3次，则自动加入到死信队列
var rollbackCount = retryCount - _retryCount;
if (rollbackCount < _rollbackCount)
{
IDictionary <String, Object> headers = new Dictionary <String, Object>();
if (!headers.ContainsKey("x-orig-routing-key"))
{
headers.Add("x-orig-routing-key", GetOrigRoutingKey(properties, eventName));
}
retryCount = rollbackCount;
channel.BasicPublish(_exchanges[QueueConsumerMode.Fail], eventName, CreateOverrideProperties(properties, headers), body);
}
}
else
{
IDictionary <String, Object> headers = properties.Headers;
if (headers == null)
{
headers = new Dictionary <String, Object>();
}
if (!headers.ContainsKey("x-orig-routing-key"))
{
headers.Add("x-orig-routing-key", GetOrigRoutingKey(properties, eventName));
}
channel.BasicPublish(_exchanges[QueueConsumerMode.Retry], eventName, CreateOverrideProperties(properties, headers), body);
}
}
}
finally
{
var baseConcreteType = typeof(BaseIntegrationEventHandler <>).MakeGenericType(eventType);
if (handler.GetType().BaseType == baseConcreteType)
{
var context = new EventContext()
{
Content = integrationEvent,
Count = retryCount,
Type = mode.ToString()
};
var fastInvoker = GetHandler($"{baseConcreteType.FullName}.Handled", baseConcreteType.GetMethod("Handled"));
await(Task) fastInvoker(handler, new object[] { context });
}
}
}
}
}
private void MessageSender(ConsumeResult <Ignore, JObject> messageresult, string eventname)
{
foreach (var item in _subsManager.GetAllEventRegistered().Where(x => x.Name == eventname))
{
using (var scope = _autofac.BeginLifetimeScope(_autofacScopeName))
{
var handler = _subsManager.GetHandlersForEvent(item.Name).First();
var handlerType = scope.ResolveOptional(handler.HandlerType);
var eventType = _subsManager.GetEventTypeByName(item.Name);
var integrationEvent =
(Event)JsonConvert.DeserializeObject(messageresult.Value.ToString(), eventType);
//TenantContext :Change to set tenant context recevied.
//For Passing Tenant Context....
if (_contextHeaders.TryGetContext(ContextHeader,
messageresult.Headers, out var context))
{
//Here we are getting exsting http request
//context
_executionContextFactory.SetContext(context);
//Have to do this hack as existing code
// is assuming all the values are string.
//When refactored this will not be required.
//if we don't do this next line code
//.ToDictionary() will fail.
messageresult.Headers.Remove(ContextHeader);
}
integrationEvent.Headers = messageresult.Headers.ToDictionary(items => items.Key,
items => Encoding.ASCII.GetString(items.Value));
var concreteType = typeof(IEventHandler <>).MakeGenericType(eventType);
//Logging
RetriveHeaders(integrationEvent.Headers);
//Get Context from header
var scopedDictionary = new Dictionary <string, string>(integrationEvent.Headers);
scopedDictionary.Remove(Authorization);
// Passing logging headers in request of http context as this is consumer side code,
// logging headers are need if consumer further makes any http call.
if (_httpContextAccessor != null)
{
_httpContextAccessor.HttpContext = new DefaultHttpContext();
_httpContextAccessor.HttpContext.Request.Headers[CorrelationCurrentId] =
integrationEvent.Headers[CorrelationCurrentId];
_httpContextAccessor.HttpContext.Request.Headers[CorrelationOriginId] =
integrationEvent.Headers[CorrelationOriginId];
_httpContextAccessor.HttpContext.Request.Headers[CorrelationParentId] =
integrationEvent.Headers[CorrelationParentId];
}
using (_logger.BeginScope <IDictionary <string, string> >(scopedDictionary))
{
Stopwatch watch = null;
//if trace is on then trace properties will be logged
if (_trace)
{
// Start the Timer using Stopwatch
watch = new Stopwatch();
watch.Start();
}
var spanScope = StartServerSpan(_tracer, scopedDictionary, SpanKindConsumer);
spanScope?.Span.SetTag(Tags.SpanKind, Tags.SpanKindConsumer);
//Invoking Handle Method
var result = (Task)concreteType.GetMethod("Handle")
.Invoke(handlerType, new object[] { integrationEvent });
//tracing
result.ContinueWith(task =>
{
if (watch != null)
{
watch.Stop();
var responseTimeNs = watch.ElapsedMilliseconds * 1000000;
var traceProperties = new Dictionary <string, dynamic>
{
{ DurationNs, responseTimeNs }
};
using (_logger.BeginScope <IDictionary <string, dynamic> >(traceProperties))
{
_logger.LogInformation("TRACING");
}
spanScope?.Span.Finish();
}
});
}
}
}
}
