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 }