public Task PublishAsync(Type eventType, object eventData, IBasicProperties properties, Dictionary <string, object> headersArguments = null)
{
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
var body = Serializer.Serialize(eventData);
return(PublishAsync(eventName, body, properties, headersArguments));
}
public void Constructor_TestMethod()
{
EventNameAttribute testObj = new EventNameAttribute("Test Event Occured");
Assert.IsNotNull(testObj);
}
protected override void UnSubscribe(Type eventType, Type handlerType)
{
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
_logger.LogInformation("Unsubscribing from event {EventName}", eventName);
_subsManager.RemoveSubscription(eventType, handlerType);
}
protected virtual IEnumerable <ConsumerExecutorDescriptor> GetHandlerDescription(Type eventType, Type typeInfo)
{
var serviceTypeInfo = typeof(IDistributedEventHandler <>)
.MakeGenericType(eventType);
var method = typeInfo
.GetMethod(
nameof(IDistributedEventHandler <object> .HandleEventAsync),
new[] { eventType }
);
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
var topicAttr = method.GetCustomAttributes <TopicAttribute>(true);
var topicAttributes = topicAttr.ToList();
if (topicAttributes.Count == 0)
{
topicAttributes.Add(new CapSubscribeAttribute(eventName));
}
foreach (var attr in topicAttributes)
{
SetSubscribeAttribute(attr);
var parameters = method.GetParameters()
.Select(parameter => new ParameterDescriptor
{
Name = parameter.Name,
ParameterType = parameter.ParameterType,
IsFromCap = parameter.GetCustomAttributes(typeof(FromCapAttribute)).Any()
}).ToList();
yield return(InitDescriptor(attr, method, typeInfo.GetTypeInfo(), serviceTypeInfo.GetTypeInfo(), parameters));
}
}
public Task PublishAsync(Type eventType, object eventData, IBasicProperties properties, Dictionary <string, object> headersArguments = null)
{
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
var body = Serializer.Serialize(eventData);
using (var channel = ConnectionPool.Get(AbpRabbitMqEventBusOptions.ConnectionName).CreateModel())
{
channel.ExchangeDeclare(
AbpRabbitMqEventBusOptions.ExchangeName,
"direct",
durable: true
);
if (properties == null)
{
properties = channel.CreateBasicProperties();
properties.DeliveryMode = RabbitMqConsts.DeliveryModes.Persistent;
properties.MessageId = Guid.NewGuid().ToString("N");
}
SetEventMessageHeaders(properties, headersArguments);
channel.BasicPublish(
exchange: AbpRabbitMqEventBusOptions.ExchangeName,
routingKey: eventName,
mandatory: true,
basicProperties: properties,
body: body
);
}
return(Task.CompletedTask);
}
public override Task PublishAsync(Type eventType, object eventData)
{
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
var body = Serializer.Serialize(eventData);
using (var channel = ConnectionPool.Get(AbpRabbitMqEventBusOptions.ConnectionName).CreateModel())
{
channel.ExchangeDeclare(
AbpRabbitMqEventBusOptions.ExchangeName,
"direct",
durable: true
);
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = RabbitMqConsts.DeliveryModes.Persistent;
channel.BasicPublish(
exchange: AbpRabbitMqEventBusOptions.ExchangeName,
routingKey: eventName,
mandatory: true,
basicProperties: properties,
body: body
);
}
return(Task.CompletedTask);
}
private Task PublishAsync(string topicName, Type eventType, object eventData, Headers headers, Dictionary <string, object> headersArguments)
{
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
var body = Serializer.Serialize(eventData);
return(PublishAsync(topicName, eventName, body, headers, headersArguments));
}
private async Task <bool> AddToOutboxAsync(Type eventType, object eventData)
{
var unitOfWork = UnitOfWorkManager.Current;
if (unitOfWork == null)
{
return(false);
}
foreach (var outboxConfig in AbpDistributedEventBusOptions.Outboxes.Values)
{
if (outboxConfig.Selector == null || outboxConfig.Selector(eventType))
{
var eventOutbox = (IEventOutbox)unitOfWork.ServiceProvider.GetRequiredService(outboxConfig.ImplementationType);
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
await eventOutbox.EnqueueAsync(
new OutgoingEventInfo(
GuidGenerator.Create(),
eventName,
Serialize(eventData),
Clock.Now
)
);
return(true);
}
}
return(false);
}
public virtual string GetName(Type eventType)
{
if (!eventType.IsGenericType)
{
throw new AbpException($"Given type is not generic: {eventType.AssemblyQualifiedName}");
}
var genericArguments = eventType.GetGenericArguments();
if (genericArguments.Length > 1)
{
throw new AbpException($"Given type has more than one generic argument: {eventType.AssemblyQualifiedName}");
}
var eventName = EventNameAttribute.GetNameOrDefault(genericArguments[0]);
if (!Prefix.IsNullOrEmpty())
{
eventName = Prefix + eventName;
}
if (!Postfix.IsNullOrEmpty())
{
eventName = eventName + Postfix;
}
return(eventName);
}
public void WhenCreateAEventNameAttributeItIsCreated()
{
var expectedName = Guid.NewGuid().ToString();
var target = new EventNameAttribute(expectedName);
Assert.Equal(expectedName, target.Name);
}
public void AttributedClass_TestMethod()
{
string expected = "Mock Test Event";
string actual = "Not set";
actual = EventNameAttribute.GetEventName(typeof(EventNameAttribute_Mock ));
Assert.AreEqual(expected, actual);
}
private List <IEventHandlerFactory> GetOrCreateHandlerFactories(Type eventType)
{
return(HandlerFactories.GetOrAdd(
eventType,
type => {
var eventName = EventNameAttribute.GetNameOrDefault(type);
EventTypes[eventName] = type;
return new List <IEventHandlerFactory> ();
}
));
}
private List <IEventHandlerFactory> GetOrCreateHandlerFactories(Type eventType)
{
return(HandlerFactories.GetOrAdd(
eventType,
type =>
{
var eventName = EventNameAttribute.GetNameOrDefault(type);
EventStopingTokens[eventName] = new CancellationTokenSource();
return new List <IEventHandlerFactory>();
}
));
}
protected override void Subscribe(Type eventType, Type handlerType)
{
var rabbitMqMessageConsumer = TeyGetOrSetMessageConsumer(eventType);
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
_logger.LogInformation("Subscribing from event {EventName}", eventName);
if (!_subsManager.IncludeSubscriptionsHandlesForEventName(eventName))
{
rabbitMqMessageConsumer?.BindAsync(eventName);
}
_subsManager.AddSubscription(eventType, handlerType);
}
public async Task ProcessEventAsync(Type eventType, object eventData)
{
var messageId = MessageContext.Current.TransportMessage.GetMessageId();
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
if (await AddToInboxAsync(messageId, eventName, eventType, MessageContext.Current.TransportMessage.Body))
{
return;
}
await TriggerHandlersAsync(eventType, eventData);
}
public void RoundTrip_TestMethod()
{
string expected = "Test Method Occurred";
string actual = "Not set";
EventNameAttribute testObj = new EventNameAttribute(expected );
actual = testObj.Name;
Assert.AreEqual(expected, actual);
}
public override async Task PublishAsync(Type eventType, object eventData)
{
if (eventData is null)
{
throw new ArgumentNullException(nameof(eventData));
}
var topic = EventNameAttribute.GetNameOrDefault(eventType);
// We need to make sure that we pass the concrete type to PublishEventAsync,
// which can be accomplished by casting the event to dynamic. This ensures
// that all event fields are properly serialized.
await _dapr.PublishEventAsync(_options.Value.PubSubName, topic, (dynamic)eventData);
}
public override IDisposable Subscribe(Type eventType, IEventHandlerFactory factory)
{
var handlerFactories = GetOrCreateHandlerFactories(eventType);
handlerFactories.Add(factory);
if (handlerFactories.Count == 1) //TODO: Multi-threading!
{
Consumer.BindAsync(EventNameAttribute.GetNameOrDefault(eventType));
}
return(new EventHandlerFactoryUnregistrar(this, eventType, factory));
}
protected override IEnumerable <EventTypeWithEventHandlerFactories> GetHandlerFactories(Type eventType)
{
var handlerFactoryList = new List <EventTypeWithEventHandlerFactories>();
foreach (var handlerFactory in HandlerFactories.Where(hf => ShouldTriggerEventForHandler(eventType, hf.Key)))
{
handlerFactoryList.Add(new EventTypeWithEventHandlerFactories(handlerFactory.Key, handlerFactory.Value));
var topic = EventNameAttribute.GetNameOrDefault(handlerFactory.Key);
AddHandler(topic, handlerFactory.Value);
}
return(handlerFactoryList.ToArray());
}
public override async Task PublishAsync(Type eventType, object eventData)
{
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
var body = Serializer.Serialize(eventData);
var producer = ProducerPool.Get(AbpKafkaEventBusOptions.ConnectionName);
await producer.ProduceAsync(
AbpKafkaEventBusOptions.TopicName,
new Message <string, byte[]>
{
Key = eventName, Value = body
});
}
/// <summary>
/// 发布事件
/// </summary>
/// <param name="eventType">事件类型</param>
/// <param name="eventData">事件数据对象</param>
/// <returns></returns>
public override async Task PublishAsync(Type eventType, object eventData)
{
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
await CapPublisher
.PublishAsync(
eventName, eventData,
new Dictionary <string, string>
{
{ AbpCAPHeaders.UserId, CurrentUser.Id?.ToString() ?? "" },
{ AbpCAPHeaders.ClientId, CurrentClient.Id ?? "" },
{ AbpCAPHeaders.TenantId, CurrentTenant.Id?.ToString() ?? "" },
},
CancellationTokenProvider.FallbackToProvider());
}
public static IEvent Wrap(object eventPayload)
{
// If it already implements IEvent just return that
IEvent ret = eventPayload as IEvent;
if (null != ret)
{
return(ret);
}
else
{
// Otherwise wrap and return it
return(new EventInstance(EventNameAttribute.GetEventName(eventPayload.GetType()), eventPayload));
}
}
private async Task PublishAsync(string topicName, Type eventType, object eventData, Headers headers, Dictionary <string, object> headersArguments)
{
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
var body = Serializer.Serialize(eventData);
var producer = ProducerPool.Get(AbpKafkaEventBusOptions.ConnectionName);
SetEventMessageHeaders(headers, headersArguments);
await producer.ProduceAsync(
topicName,
new Message <string, byte[]>
{
Key = eventName, Value = body, Headers = headers
});
}
public override IDisposable Subscribe(Type eventType, IEventHandlerFactory factory)
{
var handlerFactories = GetOrCreateHandlerFactories(eventType);
if (factory.IsInFactories(handlerFactories))
{
return(NullDisposable.Instance);
}
handlerFactories.Add(factory);
if (handlerFactories.Count == 1) //TODO: Multi-threading!
{
var topic = EventNameAttribute.GetNameOrDefault(eventType);
AddHandler(topic, handlerFactories);
}
return(new EventHandlerFactoryUnregistrar(this, eventType, factory));
}
protected override Task PublishAsync(Type eventType, IntegrationEvent eventDate)
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
var policy = Policy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
_logger.LogWarning(ex, "Could not publish event: {EventId} after {Timeout}s ({ExceptionMessage})", eventDate.Id, $"{time.TotalSeconds:n1}", ex.Message);
});
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
_logger.LogTrace("Creating RabbitMQ channel to publish event: {EventId} ({EventName})", eventDate.Id, eventName);
using (var channel = _persistentConnection.CreateModel())
{
_logger.LogTrace("Declaring RabbitMQ exchange to publish event: {EventId}", eventDate.Id);
var message = JsonConvert.SerializeObject(eventDate);
var body = Encoding.UTF8.GetBytes(message);
var model = channel;
var exchangeName = GetPublishConfigure();
model.ExchangeDeclare(exchange: exchangeName, type: "direct", durable: true);
policy.Execute(() =>
{
var properties = model.CreateBasicProperties();
properties.DeliveryMode = 2; // persistent
_logger.LogTrace("Publishing event to RabbitMQ: {EventId}", eventDate.Id);
model.BasicPublish(
exchange: exchangeName,
routingKey: eventName,
mandatory: true,
basicProperties: properties,
body: body);
});
}
return(Task.CompletedTask);
}
private void SubsManager_OnEventRemoved(object sender, Type eventType)
{
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
var(exchangeName, queueName) = GetExchangeNameAndQueueName(eventType);
var key = $"{exchangeName}_{queueName}";
if (!RabbitMqMessageConsumerDic.ContainsKey(key))
{
return;
}
var rabbitMqMessageConsumer = RabbitMqMessageConsumerDic[key];
rabbitMqMessageConsumer.UnbindAsync(eventName);
if (rabbitMqMessageConsumer.HasRoutingKeyBindingQueue())
{
return;
}
rabbitMqMessageConsumer.Dispose();
RabbitMqMessageConsumerDic.TryRemove(key, out _);
}
protected override void Publish(Type eventType, IntegrationEvent eventDate)
{
var exceptions = new List <Exception>();
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
if (_subsManager.IncludeEventTypeForEventName(eventName))
{
var eventHandleTypes = _subsManager.TryGetEventHandlerTypes(eventName);
foreach (var eventHandleType in eventHandleTypes)
{
try
{
var handlerInstance = _eventHandlerFactory.GetHandler(eventHandleType);
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
var method = concreteType.GetMethod("Handle");
if (method != null)
{
((Task)method.Invoke(handlerInstance, new object[] { eventDate })).GetAwaiter().GetResult();
}
}
catch (TargetInvocationException ex)
{
exceptions.Add(ex.InnerException);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
}
else
{
_logger.LogWarning("No subscription for local memory event: {eventName}", eventName);
}
if (exceptions.Any())
{
throw new AggregateException(
"More than one error has occurred while triggering the event: " + eventType, exceptions);
}
}
private IEnumerable <MethodInfo> GenerateExecutableMethods(IEventListener listener, IEventDescriptor eventInfo)
{
string eventType = EventTypeAttribute.GetEventType(listener);
if (eventType != eventInfo.EventType)
{
return(Enumerable.Empty <MethodInfo>());
}
return(listener.GetType()
.GetMethods()
.Where(method =>
{
var ps = method.GetParameters();
return ps.Length == 0 || ps.Length == 1;
})
.Where(method =>
{
string eventName = EventNameAttribute.GetEventName(method);
return eventName == eventInfo.EventName;
}).ToList());
}
public override IDisposable Subscribe(Type eventType, IEventHandlerFactory factory)
{
var handlerFactories = GetOrCreateHandlerFactories(eventType);
handlerFactories.Add(factory);
if (handlerFactories.Count == 1) //TODO: Multi-threading!
{
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
using (var channel = ConnectionPool.Get().CreateModel()) //TODO: Connection name per event!
{
channel.QueueBind(
queue: RabbitMqDistributedEventBusOptions.ClientName,
exchange: RabbitMqDistributedEventBusOptions.ExchangeName,
routingKey: eventName
);
}
}
return(new EventHandlerFactoryUnregistrar(this, eventType, factory));
}
public override Task PublishAsync(Type eventType, object eventData)
{
var eventName = EventNameAttribute.GetNameOrDefault(eventType);
var body = Serializer.Serialize(eventData);
using (var channel = ConnectionPool.Get().CreateModel()) //TODO: Connection name per event!
{
//TODO: Other properties like durable?
channel.ExchangeDeclare(RabbitMqDistributedEventBusOptions.ExchangeName, "");
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 2; //persistent
channel.BasicPublish(
exchange: RabbitMqDistributedEventBusOptions.ExchangeName,
routingKey: eventName,
mandatory: true,
basicProperties: properties,
body: body
);
}
return(Task.CompletedTask);
}
