protected virtual IEnumerable<dynamic> GetHandlersForEvent(IPublishableEvent eventMessage)
{
var type = eventMessage.Payload.GetType();
var handlerType = typeof (IEventHandler<>).MakeGenericType(type);
var handlers = _container.ResolveAll(handlerType);
return handlers.Cast<dynamic>();
}
public void Publish(IPublishableEvent eventMessage)
{
foreach (var bus in _wrappedBuses)
{
bus.Publish(eventMessage);
}
}
public void Publish(IPublishableEvent eventMessage)
{
foreach (var bus in _wrappedBuses)
{
bus.Publish(eventMessage);
}
}
private static IMessage CreateEventMessage(IPublishableEvent evnt)
{
Type factoryType = typeof(EventMessageFactory <>).MakeGenericType(evnt.Payload.GetType());
var factory = (IEventMessageFactory)Activator.CreateInstance(factoryType);
return(factory.CreateEventMessage(evnt));
}
protected virtual IEnumerable <dynamic> GetHandlersForEvent(IPublishableEvent eventMessage)
{
var type = eventMessage.Payload.GetType();
var handlerType = typeof(IEventHandler <>).MakeGenericType(type);
var handlers = _container.ResolveAll(handlerType);
return(handlers.Cast <dynamic>());
}
/// <inheritdoc />
public Task PublishAsync(IPublishableEvent @event)
{
var eventBody = JsonConvert.SerializeObject(@event, Formatting.Indented);
Console.WriteLine($"POST {@event.Metadata.EntityName}/{@event.Metadata.EventName}/{@event.Metadata.MajorVersion}/{@event.Metadata.MinorVersion}");
Console.WriteLine(eventBody);
return(Task.CompletedTask);
}
private static void TransactionallyPublishToHandlers(IPublishableEvent eventMessage, Type eventMessageType, IEnumerable <Action <PublishedEvent> > handlers)
{
Contract.Requires <ArgumentNullException>(handlers != null);
using (var transaction = new TransactionScope())
{
PublishToHandlers(eventMessage, eventMessageType, handlers);
transaction.Complete();
}
}
public void Registering_handler_via_generic_overload_should_also_add_the_handler()
{
var aDomainEventHandler = MockRepository.GenerateMock <IEventHandler <ADomainEvent> >();
var bus = new InProcessEventBus();
bus.RegisterHandler(aDomainEventHandler);
var events = new IPublishableEvent[]
{
CreateAEvent(), CreateADomainEvent(), CreateADomainEvent(), CreateAEvent(), CreateADomainEvent(), CreateAEvent(),
CreateAEvent(), CreateADomainEvent(), CreateADomainEvent(), CreateAEvent(), CreateADomainEvent(), CreateAEvent()
};
bus.Publish(events);
aDomainEventHandler.AssertWasCalled(h => h.Handle(null), options => options.IgnoreArguments().Repeat.Times(6));
}
public void When_multiple_messages_are_published_and_a_specific_handler_is_register_oply_the_matching_events_should_be_received_at_the_handler()
{
var aDomainEventHandler = MockRepository.GenerateMock <IEventHandler <ADomainEvent> >();
var bus = new InProcessEventBus();
bus.RegisterHandler(aDomainEventHandler);
var events = new IPublishableEvent[]
{
CreateAEvent(), CreateADomainEvent(), CreateADomainEvent(), CreateAEvent(), CreateADomainEvent(), CreateAEvent(),
CreateAEvent(), CreateADomainEvent(), CreateADomainEvent(), CreateAEvent(), CreateADomainEvent(), CreateAEvent()
};
bus.Publish(events);
aDomainEventHandler.AssertWasCalled(h => h.Handle(null), options => options.IgnoreArguments().Repeat.Times(6));
}
public void Registering_handler_via_generic_overload_should_also_add_the_handler()
{
var aDomainEventHandler = MockRepository.GenerateMock<IEventHandler<ADomainEvent>>();
var bus = new InProcessEventBus();
bus.RegisterHandler(aDomainEventHandler);
var events = new IPublishableEvent[]
{
CreateAEvent(), CreateADomainEvent(), CreateADomainEvent(), CreateAEvent(), CreateADomainEvent(), CreateAEvent(),
CreateAEvent(), CreateADomainEvent(), CreateADomainEvent(), CreateAEvent(), CreateADomainEvent(), CreateAEvent()
};
bus.Publish(events);
aDomainEventHandler.AssertWasCalled(h => h.Handle(null), options => options.IgnoreArguments().Repeat.Times(6));
}
private static void PublishToHandlers(IPublishableEvent eventMessage, Type eventMessageType, IEnumerable <Action <PublishedEvent> > handlers)
{
Contract.Requires <ArgumentNullException>(handlers != null);
Log.DebugFormat("Found {0} handlers for event {1}.", handlers.Count(), eventMessageType.FullName);
var publishedEventClosedType = typeof(PublishedEvent <>).MakeGenericType(eventMessage.Payload.GetType());
var publishedEvent = (PublishedEvent)Activator.CreateInstance(publishedEventClosedType, eventMessage);
foreach (var handler in handlers)
{
Log.DebugFormat("Calling handler {0} for event {1}.", handler.GetType().FullName,
eventMessageType.FullName);
handler(publishedEvent);
Log.DebugFormat("Call finished.");
}
}
public void Publish(IPublishableEvent eventMessage)
{
var eventMessageType = eventMessage.GetType();
Log.InfoFormat("Started publishing event {0}.", eventMessageType.FullName);
var handlers = GetHandlersForEvent(eventMessage).ToList();
var publishedEventClosedType = typeof(PublishedEvent <>).MakeGenericType(eventMessage.Payload.GetType());
var publishedEvent = (PublishedEvent)Activator.CreateInstance(publishedEventClosedType, eventMessage);
if (handlers.Count() == 0)
{
Log.WarnFormat("Did not found any handlers for event {0}.", eventMessageType.FullName);
}
else
{
PublishToHandlers(publishedEvent, eventMessageType, handlers);
}
}
public void Publish(IPublishableEvent eventMessage)
{
var eventMessageType = eventMessage.GetType();
Log.InfoFormat("Started publishing event {0}.", eventMessageType.FullName);
var handlers = GetHandlersForEvent(eventMessage).ToList();
var publishedEventClosedType = typeof(PublishedEvent<>).MakeGenericType(eventMessage.Payload.GetType());
var publishedEvent = (PublishedEvent)Activator.CreateInstance(publishedEventClosedType, eventMessage);
if (handlers.Count() == 0)
{
Log.WarnFormat("Did not found any handlers for event {0}.", eventMessageType.FullName);
}
else
{
PublishToHandlers(publishedEvent, eventMessageType, handlers);
}
}
public IResult ThrowEvent(IPublishableEvent publishableEvent, string topic = "/", Action <IMessagePublishedEventArgs> MessagePublished = null, byte qosLevel = 2, bool retain = false)
{
if (messageClient == null || !messageClient.IsConnected)
{
return(new Result(false, new Message(MessageType.Warning, "MessageClient is not initialized or not connected")));
}
if (publishableEvent == null)
{
return(new Result(new ArgumentNullException("publishableEvent")));
}
if (eventDelegates.TryGetValue(publishableEvent.Name, out EventDelegate eventDelegate))
{
eventDelegate.Invoke(this, publishableEvent);
}
string message = JsonConvert.SerializeObject(publishableEvent, Formatting.Indented);
return(messageClient.Publish(topic, message, MessagePublished, qosLevel, retain));
}
protected IEnumerable <Action <PublishedEvent> > GetHandlersForEvent(IPublishableEvent eventMessage)
{
if (eventMessage == null)
{
return(null);
}
var dataType = eventMessage.Payload.GetType();
var result = new List <Action <PublishedEvent> >();
foreach (var key in _handlerRegister.Keys)
{
if (key.IsAssignableFrom(dataType))
{
var handlers = _handlerRegister[key];
result.AddRange(handlers);
}
}
return(result);
}
public void Publish(IPublishableEvent eventMessage)
{
var eventMessageType = eventMessage.GetType();
Log.InfoFormat("Started publishing event {0}.", eventMessageType.FullName);
IEnumerable <Action <PublishedEvent> > handlers = GetHandlersForEvent(eventMessage);
if (handlers.Count() == 0)
{
Log.WarnFormat("Did not found any handlers for event {0}.", eventMessageType.FullName);
}
else
{
if (_useTransactionScope)
{
TransactionallyPublishToHandlers(eventMessage, eventMessageType, handlers);
}
else
{
PublishToHandlers(eventMessage, eventMessageType, handlers);
}
}
}
public SourcedEventProcessingElement(int sequenceNumber, IPublishableEvent @event)
{
SequenceNumber = sequenceNumber;
_event = @event;
}
public SourcedEventProcessingElement(IPublishableEvent evnt)
{
_event = evnt;
}
public IResult ThrowEvent(IPublishableEvent publishableEvent, string topic, Action <IMessagePublishedEventArgs> MessagePublished, byte qosLevel, bool retain)
{
return(submodelServiceProvider.ThrowEvent(publishableEvent, topic, MessagePublished, qosLevel, retain));
}
public SourcedEventProcessingElement(IPublishableEvent evnt)
{
_event = evnt;
}
public SourcedEventProcessingElement(int sequenceNumber, IPublishableEvent @event)
{
SequenceNumber = sequenceNumber;
_event = @event;
}
public void Publish(IPublishableEvent eventMessage)
{
Bus.Publish(eventMessage);
}
public void Publish(IPublishableEvent eventMessage)
{
_recording.Add(eventMessage);
_realBus.Publish(eventMessage);
}
public void Publish(IPublishableEvent eventMessage)
{
_recording.Add(eventMessage);
_realBus.Publish(eventMessage);
}
public IResult ThrowEvent(IPublishableEvent publishableEvent, string topic, Action <IMessagePublishedEventArgs> MessagePublished, byte qosLevel)
{
throw new NotImplementedException();
}
public void Publish(IPublishableEvent eventMessage)
{
}
public void Publish(IPublishableEvent eventMessage)
{
Bus.Publish(eventMessage);
}
public void Publish(IPublishableEvent eventMessage)
{
EventDispatcher.Dispatch(eventMessage);
}
public void Publish(IPublishableEvent eventMessage)
{
Bus.Publish(CreateEventMessage(eventMessage));
}
public PublishedEvent(IPublishableEvent evnt) : base(evnt)
{
}
IMessage IEventMessageFactory.CreateEventMessage(IPublishableEvent evnt)
{
return(new EventMessage <T>(evnt));
}
public void When_multiple_messages_are_published_and_a_specific_handler_is_register_oply_the_matching_events_should_be_received_at_the_handler()
{
var aDomainEventHandler = MockRepository.GenerateMock<IEventHandler<ADomainEvent>>();
var bus = new InProcessEventBus();
bus.RegisterHandler(aDomainEventHandler);
var events = new IPublishableEvent[]
{
CreateAEvent(), CreateADomainEvent(), CreateADomainEvent(), CreateAEvent(), CreateADomainEvent(), CreateAEvent(),
CreateAEvent(), CreateADomainEvent(), CreateADomainEvent(), CreateAEvent(), CreateADomainEvent(), CreateAEvent()
};
bus.Publish(events);
aDomainEventHandler.AssertWasCalled(h => h.Handle(null), options => options.IgnoreArguments().Repeat.Times(6));
}
public EventMessage(IPublishableEvent evnt) : base(evnt)
{
}
public void Publish(IPublishableEvent eventMessage)
{
//let event store dispatch messages
}
