public void Subscribe <T>(IIntegrationEventHandler <T> handler) where T : IntegrationEvent
{
var subAlreadyExists = _handlers.FirstOrDefault(x => x.Handler == handler);
if (subAlreadyExists == null)
{
if (!_persistentConnection.IsConnected)
{
_policy.Execute(context => _persistentConnection.TryConnect(), new Dictionary <string, object>
{
{
"logmessage",
"RabbitMQ Client could not connect "
}
});
}
using (var channel = _persistentConnection.CreateModel())
{
var eventName = typeof(T).FullName;
_handlers.Add(new HandlerSubscription(handler, typeof(T), eventName));
channel.QueueBind(_queueName,
_exchangeName,
eventName);
StartBasicConsume();
}
}
}
public void Subscribe <T>(IIntegrationEventHandler <T> handler) where T : IntegrationEvent
{
var eventName = typeof(T).Name;
if (_handlers.ContainsKey(eventName))
{
_handlers[eventName].Add(handler);
}
else
{
if (!_persisterConnection.IsConnected)
{
_persisterConnection.TryConnect();
}
using (var channel = _persisterConnection.CreateModel())
{
channel.QueueBind(queue: _queueName,
exchange: BROKER_NAME,
routingKey: eventName);
_handlers.Add(eventName, new List <IIntegrationEventHandler>());
_handlers[eventName].Add(handler);
_eventTypes.Add(typeof(T));
}
}
}
/// <summary>
/// 摘要：
/// 表示一个取消订阅事件的方法
/// </summary>
/// <typeparam name="T">事件类型</typeparam>
/// <param name="handler">事件处理</param>
public void Unsubscribe <T>(IIntegrationEventHandler <T> handler) where T : IntegrationEvent
{
var eventName = typeof(T).Name;
if (_handlers.ContainsKey(eventName) && _handlers[eventName].Contains(handler))
{ //如果该事件类型存在事件处理
_handlers[eventName].Remove(handler); //移除事件处理
if (_handlers[eventName].Count == 0) //如果该事件类型不存在其他的事件处理
{
_handlers.Remove(eventName); //从事件处理字典中移除事件类型
var eventType = _eventTypes.Single(e => e.Name == eventName);
_eventTypes.Remove(eventType); //从时间类型列表中移除事件类型。
_model.QueueUnbind(queue: _queueName,
exchange: _brokerName,
routingKey: eventName);//与交换机解除绑定。
if (_handlers.Keys.Count == 0)
{
_queueName = string.Empty;
_model.Dispose();
_connection.Dispose();
}
}
}
}
public async Task CallHandlerAsync <TRequest, TResponse, TIntegrationEventHandler>(ILifetimeScope scope,
QueueOptions options) where TRequest : IntegrationEvent
where TResponse : IntegrationEvent
{
EventingBasicConsumer consumer = BuildChannel(options);
consumer.Received += async(model, args) =>
{
TRequest request = null;
using (ILifetimeScope innerScope = scope.BeginLifetimeScope())
using (MessageSerializer serializaer = new MessageSerializer())
using (IIntegrationEventHandler <TRequest, TResponse> handler = innerScope.Resolve <IIntegrationEventHandler <TRequest, TResponse> >())
{
IBasicProperties props = args.BasicProperties;
IBasicProperties replyProps = Channel.CreateBasicProperties();
replyProps.CorrelationId = props.CorrelationId;
request = Activator.CreateInstance <TRequest>();
if (args.Body.Length > 0)
{
request = serializaer.Deserialize <TRequest>(args.Body.ToArray())[0];
}
TResponse response = await handler.Handle(request);
Channel.BasicPublish("", props.ReplyTo, replyProps, serializaer.Serialize(response)[0]);
Channel.BasicAck(args.DeliveryTag, false);
}
};
}
public void Unsubscribe <T>(IIntegrationEventHandler <T> handler) where T : IntegrationEvent
{
var eventName = typeof(T).Name;
if (!_handlers.ContainsKey(eventName) || !_handlers[eventName].Contains(handler))
{
return;
}
_handlers[eventName].Remove(handler);
if (_handlers[eventName].Count != 0)
{
return;
}
_handlers.Remove(eventName);
var eventType = _eventTypes.SingleOrDefault(e => e.Name == eventName);
if (eventType != null)
{
_eventTypes.Remove(eventType);
}
}
public void Unsubscribe <T>(IIntegrationEventHandler <T> handler) where T : IntegrationEventBase
{
var eventName = typeof(T).Name;
if (_handlers.ContainsKey(eventName) && _handlers[eventName].Contains(handler))
{
_handlers[eventName].Remove(handler);
if (_handlers[eventName].Count == 0)
{
_handlers.Remove(eventName);
var eventType = _eventTypes.Single(e => e.Name == eventName);
_eventTypes.Remove(eventType);
_connection.Item1.QueueUnbind(queue: _queueName,
exchange: _brokerName,
routingKey: eventName);
if (_handlers.Keys.Count == 0)
{
_queueName = string.Empty;
_connection.Item1.Close();
_connection.Item2.Close();
}
}
}
}
public DataSensorsHandlerWrapper(IIntegrationEventHandler <DataSensorsAddedIntegrationEvent <DataSensorsAddedContent> > dataHandler,
INotice notice,
ILogger <DataSensorsHandlerWrapper> logger)
{
_dataHandler = dataHandler;
_notice = notice;
_logger = logger;
}
public void RemoveSubscription <T>(IIntegrationEventHandler <T> integrationEventHandler)
where T : IntegrationEvent
{
var eventName = GetEventKey <T>();
var handlerToRemove = DoFindSubscriptionToRemove(eventName, integrationEventHandler.GetType());
DoRemoveHandler(eventName, handlerToRemove);
}
public UserCreationCompletedIntegrationEventHandlerTest()
{
_accountGetterServiceMock = new Mock <IAccountGetterService>();
_accountConfirmationRequestServiceMock = new Mock <IAccountConfirmationRequestService>();
_integrationEventBusMock = new Mock <IIntegrationEventBus>();
_loggerMock = new Mock <ILogger>();
_userCreatedIntegrationEventHandler = new UserCreationCompletedIntegrationEventHandler(_accountGetterServiceMock.Object,
_accountConfirmationRequestServiceMock.Object, _integrationEventBusMock.Object, _loggerMock.Object);
}
public UserCreationCompletedIntegrationEventFailureHandlerTest()
{
_accountGetterServiceMock = new Mock <IAccountGetterService>();
_accountDataConsistencyServiceMock = new Mock <IAccountDataConsistencyService>();
_integrationEventBusMock = new Mock <IIntegrationEventBus>();
_loggerMock = new Mock <ILogger>();
_userCreatedIntegrationEventHandlerFailure = new UserCreationCompletedIntegrationEventFailureHandler(_accountGetterServiceMock.Object,
_accountDataConsistencyServiceMock.Object, _integrationEventBusMock.Object, _loggerMock.Object);
}
public BackgroundTasks(ILogger <BackgroundTasks> logger, IEventBus eventBus, TelemetryClient telemetryClient, IOptions <TopicsConfiguration> topicsConfiguration,
IIntegrationEventHandler <OriginalImageUploadedIntegrationEvent> imageUploadedEventHandler, IIntegrationEventHandler <ImageDeletedIntegrationEvent> imageDeletedEventHandler)
{
_logger = logger;
_eventBus = eventBus;
_telemetryClient = telemetryClient;
_topicsConfiguration = topicsConfiguration;
_imageUploadedEventHandler = imageUploadedEventHandler;
_imageDeletedEventHandler = imageDeletedEventHandler;
}
public UserDeletionCompletedIntegrationEventFailureHandlerTest()
{
_loggerMock = new Mock <ILogger>();
_integrationEventBusMock = new Mock <IIntegrationEventBus>();
_domainEventStoreMock = new Mock <IDomainEventStore>();
_accountRepositoryMock = new Mock <IAccountRepository>();
_userDeletionCompletedIntegrationEventFailure = new UserDeletionCompletedIntegrationEventFailureHandler(
_loggerMock.Object, _integrationEventBusMock.Object, _domainEventStoreMock.Object,
_accountRepositoryMock.Object);
}
public void Subscribe <T>(IIntegrationEventHandler <T> eventHandler) where T : IntegrationEvent
{
string exchangeName = "";
string queueName = "";
if (typeof(T) == typeof(UserCreatedIntegrationEvent))
{
exchangeName = EventBusInfo.topicExchangeNameAdd;
queueName = EventBusInfo.queueNameAdd;
}
else
if (typeof(T) == typeof(UserEditedIntegrationEvent))
{
exchangeName = EventBusInfo.topicExchangeNameEdit;
queueName = EventBusInfo.queueNameEdit;
}
else
if (typeof(T) == typeof(UserRemovedIntegrationEvent))
{
exchangeName = EventBusInfo.topicExchangeNameDelete;
queueName = EventBusInfo.queueNameDelete;
}
_channel.ExchangeDeclare(
exchange: exchangeName,
type: "fanout",
durable: true
);
_channel.QueueDeclare(queue: queueName,
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
_channel.QueueBind(
queue: queueName,
exchange: exchangeName,
routingKey: ""
);
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += async(model, args) =>
{
try
{
string message = Encoding.UTF8.GetString(args.Body);
var @event = JsonConvert.DeserializeObject <T>(message);
await eventHandler.Handle(@event);
}
catch (Exception) { }
};
_channel.BasicConsume(queue: queueName,
autoAck: true,
consumer: consumer);
}
public ChallengeStartingEventHandlerTests()
{
_mathChallengeServiceMock = new Mock <IMathChallengeService>();
_quizServiceMock = new Mock <IQuizService>();
_eventBusMock = new Mock <IEventBus>();
var loggerMock = new Mock <ILogger <ChallengeStartingEventHandler> >();
_handler = new ChallengeStartingEventHandler(
_mathChallengeServiceMock.Object,
_quizServiceMock.Object,
_eventBusMock.Object,
loggerMock.Object
);
}
///<inheritdoc/>
public virtual void Subscribe(IIntegrationEventHandler handler, string topic = null)
{
var topicName = topic ?? handler.Topic;
if (!Topics.ContainsKey(topicName))
{
Topics.Add(topicName, new List <IIntegrationEventHandler> {
handler
});
}
else if (Topics[topicName] != handler)
{
Topics[topicName].Add(handler);
}
}
public void Subscribe <T>(IIntegrationEventHandler <T> handler) where T : IntegrationEvent
{
var eventName = typeof(T).Name;
if (_handlers.ContainsKey(eventName))
{
_handlers[eventName].Add(handler);
}
else
{
var channel = GetChannel();
channel.QueueBind(_queueName, _brokerName, eventName);
_handlers.Add(eventName, new List <IIntegrationEventHandler>());
_handlers[eventName].Add(handler);
_eventTypes.Add(typeof(T));
}
}
public void Subscribe <T>(IIntegrationEventHandler <T> handler) where T : IntegrationEvent
{
var eventName = typeof(T).Name;
if (_handlers.ContainsKey(eventName))
{
_handlers[eventName].Add(handler);
}
else
{
_handlers.Add(eventName, new List <IIntegrationEventHandler>());
_handlers[eventName].Add(handler);
_eventTypes.Add(typeof(T));
}
}
public void SubscribeDynamic(string eventName, IIntegrationEventHandler <dynamic> handler)
{
try
{
this.OnMessageReceived += (async(msg, topic) =>
{
if (topic.Equals(eventName))
{
await handler.Handle(msg);
}
});
this.DoInternalSubscription(eventName);
this.memory.AddDynamicSubscription(eventName, handler);
}
catch (NMSException ex)
{
throw new NMSException("Could not subscribe dynamically ", ex);
}
}
public async Task SubscribeAsync <TRequestEvent, TIntegrationEventHandler>(ILifetimeScope scope,
QueueOptions options = null) where TRequestEvent : IntegrationEvent
where TIntegrationEventHandler : IIntegrationEventHandler <TRequestEvent>
{
Tuple <string, EventingBasicConsumer> channelData = BuildChannel(options);
channelData.Item2.Received += async(model, args) =>
{
using (ILifetimeScope innerScope = scope.BeginLifetimeScope())
using (MessageSerializer serializaer = new MessageSerializer())
using (IIntegrationEventHandler <TRequestEvent> handler = innerScope.Resolve <IIntegrationEventHandler <TRequestEvent> >())
{
TRequestEvent request = serializaer.Deserialize <TRequestEvent>(args.Body.ToArray())[0];
await handler.Handle(request);
}
};
Channel.BasicConsume(channelData.Item1, true, channelData.Item2);
}
/// <summary>
/// 摘要：
/// 表示一个订阅事件的方法
/// </summary>
/// <typeparam name="T">事件类型</typeparam>
/// <param name="handler">事件处理</param>
public void Subscribe <T>(IIntegrationEventHandler <T> handler) where T : IntegrationEvent
{
var eventName = typeof(T).Name;
if (_handlers.ContainsKey(eventName))
{
_handlers[eventName].Add(handler);
}
else
{
var channel = GetChannel();
channel.QueueBind(queue: _queueName,
exchange: _brokerName,
routingKey: eventName);//从交换机根据事件类型获取消息。
//记录事件处理
_handlers.Add(eventName, new List <IIntegrationEventHandler>());
_handlers[eventName].Add(handler);
_eventTypes.Add(typeof(T));//记录事件类型
}
}
public void Subscribe <T>(string eventName, IIntegrationEventHandler <T> integrationEventHandler)
where T : IntegrationEvent
{
try
{
this.OnMessageReceived += (async(msg, topic) =>
{
if (topic.Equals(eventName) || topic.Equals("topic://" + eventName))
{
await integrationEventHandler.Handle((T)msg);
}
});
this.DoInternalSubscription(eventName);
this.memory.AddSubscription <T>(eventName, integrationEventHandler);
}
catch (EventBusException ex)
{
throw new EventBusException("Could not subscribe ", ex);
}
}
public void Subscribe <T>(IIntegrationEventHandler <T> handler)
where T : IntegrationEvent
{
var eventType = typeof(T).FullName;
if (eventType != null)
{
if (_handlersDictionary.ContainsKey(eventType))
{
var handlers = _handlersDictionary[eventType];
handlers.Add(handler);
}
else
{
_handlersDictionary.Add(eventType, new List <IIntegrationEventHandler> {
handler
});
}
}
}
public void Unsubscribe(IIntegrationEventHandler handler)
{
var eventType = handler.GetType().BaseType.GetGenericArguments().First();
if (_handlers.ContainsKey(eventType))
{
_handlers.Remove(eventType);
if (!_persistentConnection.IsConnected)
{
_policy.Execute((context) => _persistentConnection.TryConnect(), new Dictionary <string, object>()
{
{
"logmessage",
"RabbitMQ Client could not connect "
}
});
}
_persistentConnection.CreateChannel();
_persistentConnection.RemoveRoutingKey(eventType.Name);
}
}
public void Unsubscribe <T>(IIntegrationEventHandler <T> handler) where T : IntegrationEvent
{
var eventName = typeof(T).Name;
if (_handlers.ContainsKey(eventName) && _handlers[eventName].Contains(handler))
{
_handlers[eventName].Remove(handler);
if (_handlers[eventName].Count == 0)
{
_handlers.Remove(eventName);
var eventType = _eventTypes.SingleOrDefault(e => e.Name == eventName);
if (eventType != null)
{
_eventTypes.Remove(eventType);
if (!_persisterConnection.IsConnected)
{
_persisterConnection.TryConnect();
}
using (var channel = _persisterConnection.CreateModel())
{
channel.QueueUnbind(queue: _queueName,
exchange: BROKER_NAME,
routingKey: eventName);
if (_handlers.Keys.Count == 0)
{
_queueName = string.Empty;
_consumerChannel.Close();
}
}
}
}
}
}
public async Task Subscribe <T>(string topicName, string subscriptionName, IIntegrationEventHandler <T> handler, int maxConcurrentCalls = 1)
where T : IntegrationEvent
{
if (subscriptionName == null)
{
throw new ArgumentNullException(nameof(subscriptionName));
}
string key = GetSubscriptionKey(topicName, subscriptionName);
if (_subscriptions.ContainsKey(key))
{
throw new ArgumentException($"Subscription {subscriptionName} for topic {topicName} already exist");
}
await _serviceBusPersistentConnection.CreateSubscriptionIfNotExists(topicName, subscriptionName);
var client = new SubscriptionClient(_serviceBusPersistentConnection.ConnectionString, topicName, subscriptionName);
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
// Maximum number of Concurrent calls to the callback `ProcessMessagesAsync`, set to 1 for simplicity.
// Set it according to how many messages the application wants to process in parallel.
MaxConcurrentCalls = maxConcurrentCalls,
// Indicates whether MessagePump should automatically complete the messages after returning from User Callback.
// False below indicates the Complete will be handled by the User Callback as in `ProcessMessagesAsync` below.
AutoComplete = false
};
client.RegisterMessageHandler(async(message, token) =>
{
var model = JsonConvert.DeserializeObject <T>(Encoding.UTF8.GetString(message.Body));
await handler.Handle(model);
await client.CompleteAsync(message.SystemProperties.LockToken);
}, messageHandlerOptions);
_subscriptions.TryAdd(key, 0);
}
public void Subscribe <TEvent>(IIntegrationEventHandler <TEvent> handler) where TEvent : IntegrationEvent
{
string handlerName = handler.GetType().Name;
string eventName = typeof(TEvent).FullName;
_logger.Information("Handler {HandlerName} is subscribing to event {EventName}",
handlerName, eventName);
RenewConnectionIfNeeded();
using (var channel = _rabbitMqPersistentConnection.CreateModel())
{
channel.QueueBind(queue: _queueName ?? string.Empty,
exchange: ExchangeName,
routingKey: eventName,
arguments: null);
}
InMemoryEventBus.Instance.Subscribe(handler);
StartBasicConsume();
}
public void Unsubscribe <T>(IIntegrationEventHandler <T> handler) where T : IntegrationEvent
{
var eventName = typeof(T).Name;
if (_handlers.ContainsKey(eventName) && _handlers[eventName].Contains(handler))
{
_handlers[eventName].Remove(handler);
if (_handlers[eventName].Count == 0)
{
_handlers.Remove(eventName);
var eventType = _eventTypes.Single(e => e.Name == eventName);
_eventTypes.Remove(eventType);
_model.QueueUnbind(_queueName, _brokerName, eventName);
if (_handlers.Keys.Count == 0)
{
_queueName = String.Empty;
_model.Dispose();
_connection.Dispose();
}
}
}
}
public HandlerSubscription(IIntegrationEventHandler handler, string eventName)
{
Handler = handler;
EventName = eventName;
}
public void Subscribe <T>(IIntegrationEventHandler <T> handler)
where T : IntegrationEvent
{
_handlers.Add(new HandlerSubscription(handler, typeof(T).FullName));
}
public void Subscribe <T>(IIntegrationEventHandler <T> handler) where T : IntegrationEvent
{
InMemoryEventBus.Instance.Subscribe(handler);
}
