public CheckEventTask(IEventRepository eventRepository, IEventRouter eventRouter, ILogger logger, IEventSourceService eventSourceService) { this.eventRepository = eventRepository; this.eventRouter = eventRouter; this.eventSourceService = eventSourceService; this.logger = logger.WithClassName().WithCategory(Names.LogCategory.Event); }
protected Aggregate(IEventRouter router = null) { _id = Guid.NewGuid(); _version = 0; _uncommittedEvents = new List<object>(); _router = router ?? new ConventionEventRouter(); }
public async Task RunShouldRouteTheMessageIfEndOfMessageIsReached( byte[] bytes, uint interval, int sequenceNumber, [Frozen, Substitute] Stream stream, [Frozen, Substitute] IChannel <GatewayMessageChunk> channel, [Frozen, Substitute] IGatewayUtilsFactory factory, [Frozen, Substitute] IGatewayService gateway, [Frozen, Substitute] ISerializer serializer, [Frozen, Substitute] IEventRouter router, [Target] DefaultGatewayRxWorker worker ) { var @event = new HelloEvent { HeartbeatInterval = interval }; var message = new GatewayMessage { SequenceNumber = sequenceNumber, Data = @event }; var cancellationToken = new CancellationToken(false); serializer.Deserialize <GatewayMessage>(Any <Stream>(), Any <CancellationToken>()).Returns(message); channel.Read(Any <CancellationToken>()).Returns(new GatewayMessageChunk(bytes, bytes.Length, true)); await worker.Start(gateway); await worker.Run(cancellationToken); await router.Received().Route(Is(@event), Is(cancellationToken)); }
protected Aggregate(IEventRouter router = null) { _id = Guid.NewGuid(); _version = 0; _uncommittedEvents = new List <object>(); _router = router ?? new ConventionEventRouter(); }
//*************************** CONSTRUCTOR **************************************** public BookingHandler(IEventRouter eventRouter, IBookingRepository bookingRepository, IOrderRepository orderRepository, ITransporterRepository transporterRepository, IUtilBookingRepository utilBookingRepository) { _eventRouter = eventRouter; _bookingRepository = bookingRepository; _orderRepository = orderRepository; _transporterRepository = transporterRepository; _utilBookingRepository = utilBookingRepository; }
protected AggregateBase(string id, IEventRouter eventRouter) { Guard.EnsureNullOrWhiteSpace(id, "id"); Guard.EnsureNotNull(eventRouter, "eventRouter"); _id = id; _registeredRoutes = eventRouter; _registeredRoutes.Register(this); }
public EventPublisher(IEventRouter router) { if (router == null) { throw new ArgumentNullException(nameof(router)); } _router = router; }
protected AggregateBase(string id, IEventRouter eventRouter) { Ensure.That(id, "id").IsNotNullOrWhiteSpace(); Ensure.That(eventRouter, "eventRouter").IsNotNull(); _id = id; _registeredRoutes = eventRouter; //_registeredRoutes.Register(this); }
public static ISession Create( ITransaction transaction, IEventStore eventStore, ISnapshotStore snapshotStore, ILoggerFactory loggerFactory = null, IEventPublisher eventPublisher = null, IEventRouter eventRouter = null, IEventUpdateManager eventUpdateManager = null, IEnumerable <IMetadataProvider> metadataProviders = null, ISnapshotStrategy snapshotStrategy = null, IEventsMetadataService eventsMetadataService = null) { // TODO: refactor ctor's Session sucks :( if (eventStore == null) { throw new ArgumentNullException(nameof(eventStore)); } if (snapshotStore == null) { throw new ArgumentNullException(nameof(snapshotStore)); } if (loggerFactory == null) { loggerFactory = new NoopLoggerFactory(); } if (eventRouter == null) { eventRouter = StubEventRouter.Ok(); } if (eventPublisher == null) { eventPublisher = new EventPublisher(eventRouter); } var session = new Session( loggerFactory: loggerFactory, transaction: transaction, eventStore: eventStore, snapshotStore: snapshotStore, eventPublisher: eventPublisher, eventUpdateManager: eventUpdateManager, metadataProviders: metadataProviders, snapshotStrategy: snapshotStrategy, eventsMetadataService: eventsMetadataService); return(session); }
public static void AttachRouter(this IContext context, IEventRouter router) { var currentContext = context; while (currentContext != null) { if (currentContext is IEventScope) { currentContext.RegisterInstance(router); break; } currentContext = currentContext.Parent; } }
/// <summary> /// Initializes a new instance of the <see cref="DefaultGatewayRxWorker" /> class. /// </summary> /// <param name="serializer">Serializer to use for serializing messages.</param> /// <param name="timerFactory">Factory used to create timers.</param> /// <param name="gatewayUtilsFactory">Factory to create various utils with.</param> /// <param name="eventRouter">Router to route events to controllers.</param> /// <param name="logger">Logger used to log information to some destination(s).</param> public DefaultGatewayRxWorker( ISerializer serializer, ITimerFactory timerFactory, IGatewayUtilsFactory gatewayUtilsFactory, IEventRouter eventRouter, ILogger <DefaultGatewayRxWorker> logger ) { this.serializer = serializer; this.timerFactory = timerFactory; this.gatewayUtilsFactory = gatewayUtilsFactory; this.eventRouter = eventRouter; this.logger = logger; channel = gatewayUtilsFactory.CreateChannel <GatewayMessageChunk>(); }
public async Task RunShouldNotRouteTheMessageIfEndOfMessageIsReachedButEventDataIsNull( byte[] bytes, uint interval, int sequenceNumber, [Frozen, Substitute] Stream stream, [Frozen, Substitute] IChannel <GatewayMessageChunk> channel, [Frozen, Substitute] IGatewayUtilsFactory factory, [Frozen, Substitute] IGatewayService gateway, [Frozen, Substitute] ISerializer serializer, [Frozen, Substitute] IEventRouter router, [Target] DefaultGatewayRxWorker worker ) { channel.Read(Any <CancellationToken>()).Returns(new GatewayMessageChunk(bytes, bytes.Length, true)); await worker.Start(gateway); await worker.Run(); await router.DidNotReceive().Route(Any <IGatewayEvent>(), Any <CancellationToken>()); }
public static ISession Create( ITransaction transaction, ICompositeStores stores, ILoggerFactory loggerFactory = null, IEventPublisher eventPublisher = null, IEventRouter eventRouter = null, IEventUpdateManager eventUpdateManager = null, IEnumerable <IMetadataProvider> metadataProviders = null, ISnapshotStrategy snapshotStrategy = null, IEventsMetadataService eventsMetadataService = null) { return(Create(transaction, stores.EventStore, stores.SnapshotStore, loggerFactory, eventPublisher, eventRouter, eventUpdateManager, metadataProviders, snapshotStrategy, eventsMetadataService)); }
public FullyAuditIdentityRoleEntity() { _eventRouter = new InstanceEventRouter(); }
public ActionHintAccumulator(HintKey hintKey, IEventRouter eventRouter) { hintKey_ = hintKey; eventRouter_ = eventRouter; }
/// <summary> /// Initializes node with service locator and event distributor instances /// </summary> /// <param name="serviceLocator"></param> /// <param name="eventRouter"></param> public abstract void Initialize(IServiceLocator serviceLocator, IEventRouter eventRouter);
public Entity() { _eventRouter = new InstanceEventRouter(); }
public SupplierHandler(ISupplierRepository supplierRepository, IEventRouter eventRouter) { _supplierRepository = supplierRepository; _eventRouter = eventRouter; }
public OrderHandler(IOrderRepository orderRepository, IEventRouter eventRouter) { _orderRepository = orderRepository; _eventRouter = eventRouter; }
public AuditIdentityUserEntity() { _eventRouter = new InstanceEventRouter(); }
public void UnregisterRouter(IEventRouter eventRouter) { eventRouters.Remove(eventRouter); }
public void RegisterRouter(IEventRouter eventRouter) { eventRouters.Add(eventRouter); }
public IdentityRoleEntity() { _eventRouter = new InstanceEventRouter(); }
public User(Action <string> logger, string id, IEventRouter router) : base(id, router) { _logger = logger; }
// PRAGMA MARK - Public Interface public HumanPlayerFilterEventRouter(IEventRouter <BattlePlayer> eventRouter) { eventRouter_ = eventRouter; }
public TransporterHandler(ITransporterRepository transporterRepository, IEventRouter eventRouter, testContext context) { _transporterRepository = transporterRepository; _eventRouter = eventRouter; _context = context; }
public EventPublisher(IEventRouter router) { _router = router ?? throw new ArgumentNullException(nameof(router)); }