public ProcessorEventSubscriptionProvider(IEventStoreFacade eventStore, IEventConverter eventConverter, IServiceProvider serviceProvider) { _eventStore = eventStore; _eventConverter = eventConverter; _serviceProvider = serviceProvider; }
public ProjectionEventStreamSubscriptionProvider(IEventStoreFacade eventStore, IEventConverter eventConverter, IProjectionEventStreamRepository repo) { _eventStore = eventStore; _eventConverter = eventConverter; _repo = repo; }
private static AggregateEventStream <HotelAggregate> GetStream(IEventStoreFacade connection, IAggregateSchema <HotelAggregate> schema) { AggregateEventStream <HotelAggregate> stream = new AggregateEventStream <HotelAggregate>(connection, new EventConverter(), new EventDataFactory(), new EventMetadataFactory <HotelAggregate>(), schema, Logger.None); return(stream); }
public SubscriptionFactory(IEventStoreFacade connection, IServiceProvider serviceProvider) { _connection = connection; _serviceProvider = serviceProvider; _onSpecMeth = this.GetType().GetMethod(nameof(OnSpecEventAppearead), BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.InvokeMethod); }
public StreamJoinCoordinator(IEventStoreFacade connection, Serilog.ILogger logger, IServiceProvider serviceProvider) { this._connection = connection; _logger = logger; _serviceProvider = serviceProvider; _readyPastCatchupReceivers = 0; }
public EventStoreHubInitializer(IEventStoreFacade connection, IHubContext <EventStoreHub> hubConnection, ILogger logger, IEventConverter eventConveter, IProjectionSchemaRegister projectionSchema) { this._connection = connection; this._hubConnection = hubConnection; this._logger = logger; this._eventConverter = eventConveter; this._projectionSchema = projectionSchema; }
public async Task Subscribe(IEventStoreFacade connection) { _connection = connection; _lastCheckpoint = await _checkpointRepo.GetLastCheckpoint(); this.Subscription = await _connection.SubscribeToStreamAsync(_streamName, new StreamRevision(_lastCheckpoint ?? 0L), OnEventAppeared, OnLiveProcessingStarted, true, OnSubscriptionDropped); }
public ProjectionEventStream(IEventStoreFacade connection, IEventConverter eventConveter, IEventDataFactory eventDataFactory, IProjectionSchema <TProjection> projectionSchema) { _connection = connection; _eventConveter = eventConveter; _eventDataFactory = eventDataFactory; _projectionSchema = projectionSchema; _projectionStreamName = $"{ServiceConventions.GetCategoryFromNamespace(typeof(TProjection).Namespace)}Projection"; }
public async Task Configure(IEventStoreFacade connection, IEventHandlerDispatcher dispatcher, Serilog.ILogger logger) { _logger = logger; _logger.Information("Subscribed for {eventName} for local projections. (with EventDispatcher)", typeof(TEvent).Name); var stream = $"$et-{typeof(TEvent).Name}"; this._dispatcher = dispatcher; // Should we wait for the subscription? - or should we re-subscribe await connection.SubscribeToStreamAsync(stream, OnReadEvent, true); }
public ProjectionMultiEventStreamSubscriptionProvider(IEventStoreFacade eventStore, IEventConverter eventConverter, IProjectionEventStreamRepository repo, IProjectionEventStream stream, IProjectionSchema schema) { _eventStore = eventStore; _eventConverter = eventConverter; _repo = repo; _stream = stream; _schema = schema; _events = new HashSet <Type>(); }
public AggregateEventStream(IEventStoreFacade connection, IEventConverter eventConverter, IEventDataFactory eventDataFactory, IEventMetadataFactory <TAggregate> metadataFactory, IAggregateSchema <TAggregate> aggregateSchema, Serilog.ILogger logger) { _connection = connection; _eventConverter = eventConverter; _eventDataFactory = eventDataFactory; _metadataFactory = metadataFactory; _aggregateSchema = aggregateSchema; _logger = logger; }
public async Task Configure(IEventStoreFacade connection, IEventConverter eventConverter, IHubContext <EventStoreHub> hubConnection, Serilog.ILogger logger) { Log = logger; _converter = eventConverter; var stream = $"$et-{typeof(TEvent).Name}"; this._connection = hubConnection; var t = await connection.SubscribeToStreamAsync(stream, StreamRevision.Start, OnReadEvent, null, true); Log.Information("Subscribed for {eventName} for pushing to signalR clients.", typeof(TEvent).Name); }
public static async Task BindToSignalHub(this IEventStoreFacade connection, IEventConverter eventConverter, IProjectionSchemaRegister projectionSchema, IHubContext <EventStoreHub> hubConnection, Serilog.ILogger logger) { foreach (var e in projectionSchema.Events) { var configuratorType = typeof(SignalRConfigurator <>).MakeGenericType(e); var configurator = Ctor <ISignalRConfigurator> .Create(configuratorType); await configurator.Configure(connection, eventConverter, hubConnection, logger); } }
public ProjectionEventSubscriptionProvider(IEventStoreFacade eventStore, IEventConverter eventConverter) : base(eventStore, eventConverter) { }
protected SingleEventSubscriptionProvider(IEventStoreFacade eventStore, IEventConverter eventConverter) { _eventStore = eventStore; _eventConverter = eventConverter; }
public EventStoreSubscriber(IEventStoreFacade connection, IEventHandlerDispatcher dispatcher, ILogger logger) { this._connection = connection; this._dispatcher = dispatcher; this._logger = logger; }