/// <summary> /// Initializes a new instance of the <see cref="DurableCommitDispatcher"/> class. /// </summary> /// <param name="eventStoreClient">An event store client.</param> /// <param name="checkpointRepository">A checkpoint repository. Each instane of a <see cref="DurableCommitDispatcher"/> /// should have their own instance of a <see cref="ICheckpointRepository"/>.</param> /// <param name="handlerResolver">A collection of handler modules to dispatch the commit to.</param> /// <exception cref="System.ArgumentNullException"> /// eventStoreClient /// or /// checkpointRepository /// or /// dispatchCommit /// </exception> public DurableCommitDispatcher( [NotNull] IEventStoreClient eventStoreClient, [NotNull] ICheckpointRepository checkpointRepository, [NotNull] IHandlerResolver handlerResolver) : this(eventStoreClient, checkpointRepository, handlerResolver.DispatchCommit) { }
public CheckpointService() { if (Repository == null) { Repository = new CheckpointRepository(); } }
protected ProjectionDispatcher( IProjectionHandlerResolver handlerResolver, ICheckpointRepository checkpointRepository) { _handlerResolver = handlerResolver; _checkpointRepository = checkpointRepository; }
public NEventStoreProjectionDispatcher( EventStoreClient eventStoreClient, IProjectionHandlerResolver handlerResolver, ICheckpointRepository checkpointRepository) : base(handlerResolver, checkpointRepository) { _eventStoreClient = eventStoreClient; }
public KinesisShardReaderBase(IAmazonKinesis client, ICheckpointRepository checkpointRepository, IHeartbeatService heartbeatService) { _client = client; CheckpointRepository = checkpointRepository; HeartbeatService = heartbeatService; }
public StreamProcessor(IBusFactory busFactory, IAwsClientFactory awsClientFactory, IAwsKinesisFactory awsKinesisFactory, IOptions <AwsSettings> awsOptions, IOptions <ServerSettings> serverOptions, IMapper mapper, ILogger <StreamProcessor> logger, IMembershipService membershipService, ICheckpointRepository checkpointRepository) { if (busFactory == null) { throw new ArgumentNullException(nameof(busFactory)); } if (awsClientFactory == null) { throw new ArgumentNullException("awsClientFactory"); } if (awsOptions == null) { throw new ArgumentNullException(nameof(awsOptions)); } if (serverOptions == null) { throw new ArgumentNullException(nameof(serverOptions)); } if (mapper == null) { throw new ArgumentNullException(nameof(mapper)); } _eventBus = busFactory.CreateEventsBus(); _kinesisFactory = awsKinesisFactory; _mapper = mapper; _logger = logger; _membershipService = membershipService; _serverSettings = serverOptions.Value; _checkpointRepository = checkpointRepository; var processedMeasurementStreamWriter = _kinesisFactory.CreateWriter(); var recordProcessingFactory = new RecordProcessorFactory(membershipService, logger); _rawMeasurementsStreamReader = _kinesisFactory.CreateReader( recordProcessingFactory, _checkpointRepository, processedMeasurementStreamWriter); // Handle processed measurements. // Read from the processed measurements stream and publish out to // EasyNetQ/RabbitQ. This should be removed once // all other services (Web/MQTT/Notifier/Membership) are getting measurements // from the processed stream rather than the queue _processedMeasurementsStreamReader = _kinesisFactory.CreateProcesssedMeasurementsReader( _checkpointRepository, _eventBus); }
/// <summary> /// Initializes a new instance of the <see cref="DurableCommitDispatcher"/> class. /// </summary> /// <param name="eventStoreClient">An event store client.</param> /// <param name="checkpointRepository">A checkpoint repository. Each instane of a <see cref="DurableCommitDispatcher"/> /// should have their own instance of a <see cref="ICheckpointRepository"/>.</param> /// <param name="handlerModules">A collection of handler modules to dispatch the commit to.</param> /// <param name="retryPolicy">A retry policy when a <see cref="TransientException"/> occurs. /// If none specified TransientException.None is used.</param> /// <exception cref="System.ArgumentNullException"> /// eventStoreClient /// or /// checkpointRepository /// or /// dispatchCommit /// </exception> public DurableCommitDispatcher( [NotNull] IEventStoreClient eventStoreClient, [NotNull] ICheckpointRepository checkpointRepository, [NotNull] IEnumerable <IHandlerResolver> handlerModules, TransientExceptionRetryPolicy retryPolicy = null) : this(eventStoreClient, checkpointRepository, handlerModules.DispatchCommit, retryPolicy) { Guard.EnsureNotNull(handlerModules, "handlerModule"); }
public EventObserverSubscriptionFactory(IStoreEvents eventStore, ICheckpointRepository checkpointRepo, IEnumerable <IObserver <ICommit> > commitObservers) { Contract.Requires <ArgumentNullException>(eventStore != null, "eventStore"); Contract.Requires <ArgumentNullException>(checkpointRepo != null, "checkpointRepo"); Contract.Requires <ArgumentNullException>(commitObservers != null, "commitObservers"); this.checkpointRepo = checkpointRepo; this.eventStore = eventStore; this.commitObservers = commitObservers; }
public ResolvedEventDispatcher( IEventStoreConnection eventStore, ISerializer serializer, ICheckpointRepository checkpoints, [NotNull] IHandlerResolver handlerResolver, Action onCaughtUp = null, string streamId = null, UserCredentials userCredentials = null) : this(eventStore, serializer, checkpoints, handlerResolver.DispatchResolvedEvent, onCaughtUp, streamId, userCredentials) {}
public ProcessedMeasurementsShardReaderFactory(ICheckpointRepository checkpointRepository, IHeartbeatService heartbeatService, IBus bus, ILogger logger) { _checkpointRepository = checkpointRepository; _heartbeatService = heartbeatService; _bus = bus; _logger = logger; }
public ProcessedMeasurementsKinesisShardReader(IAmazonKinesis client, ICheckpointRepository checkpointRepository, IHeartbeatService heartbeatService, IBus bus, ILogger logger) : base(client, checkpointRepository, heartbeatService) { _bus = bus; _logger = logger; }
public ResolvedEventDispatcher( IEventStoreConnection eventStore, ISerializer serializer, ICheckpointRepository checkpoints, [NotNull] IHandlerResolver handlerResolver, Action onCaughtUp = null, string streamId = null, UserCredentials userCredentials = null) : this(eventStore, serializer, checkpoints, handlerResolver.DispatchResolvedEvent, onCaughtUp, streamId, userCredentials) { }
public WayBillController(IWayBillRepository wayBillRepository, IDriverRepository driverRepository, IVehicleRepository vehicleRepository, IRouteRepository routeRepository, ICheckpointRepository checkpointRepository, IMedicNoteRepository medicNoteRepository, IMechanicNoteRepository mechanicNoteRepository) { this.wayBillRepository = wayBillRepository ?? throw new ArgumentNullException(nameof(wayBillRepository)); this.driverRepository = driverRepository ?? throw new ArgumentNullException(nameof(driverRepository)); this.vehicleRepository = vehicleRepository ?? throw new ArgumentNullException(nameof(vehicleRepository)); this.routeRepository = routeRepository ?? throw new ArgumentNullException(nameof(routeRepository)); this.checkpointRepository = checkpointRepository ?? throw new ArgumentNullException(nameof(checkpointRepository)); this.medicNoteRepository = medicNoteRepository ?? throw new ArgumentNullException(nameof(medicNoteRepository)); this.mechanicNoteRepository = mechanicNoteRepository ?? throw new ArgumentNullException(nameof(mechanicNoteRepository)); }
public RawMeasurementsKinesisShardReader(IAmazonKinesis client, ICheckpointRepository checkpointRepository, IHeartbeatService heartbeatService, IProcessedMeasurementStreamWriter processedMeasurementStreamWriter, IRecordProcessor recordProcessor, ILogger logger) : base(client, checkpointRepository, heartbeatService) { _processedMeasurementStreamWriter = processedMeasurementStreamWriter; _recordProcessor = recordProcessor; _logger = logger; }
public bool Start(IDomainRepository domainRepository, IEventStoreConnection connection, IEnumerable <Action <ICommand> > preExecutionPipe = null, IEnumerable <Action <object> > postExecutionPipe = null) { _connection = connection; _domainEntry = new DomainEntry(domainRepository, preExecutionPipe, postExecutionPipe); _checkpointRepository = new EventStoreCheckpointRepository(connection, CheckpointId); _latestPosition = _checkpointRepository.Get(); var settings = new CatchUpSubscriptionSettings(10, 100, false, true); _connection.SubscribeToAllFrom(_latestPosition, settings, HandleEvent); Console.WriteLine("AppServiceStrategy started"); return(true); }
public RawMeasurementsShardReaderFactory(IRecordProcessorFactory recordProcessorFactory, IProcessedMeasurementStreamWriter processedMeasurementStreamWriter, ICheckpointRepository checkpointRepository, IHeartbeatService heartbeatService, ILogger logger) { _recordProcessorFactory = recordProcessorFactory; _processedMeasurementStreamWriter = processedMeasurementStreamWriter; _checkpointRepository = checkpointRepository; _heartbeatService = heartbeatService; _logger = logger; }
/// <summary> /// Initializes a new instance of the <see cref="DurableCommitDispatcher"/> class. /// </summary> /// <param name="eventStoreClient">An event store client.</param> /// <param name="checkpointRepository">A checkpoint repository. Each instane of a <see cref="DurableCommitDispatcher"/> /// should have their own instance of a <see cref="ICheckpointRepository"/>.</param> /// <param name="dispatchCommit">A handler to dispatch the commit to.</param> /// <param name="retryPolicy">A retry policy when a <see cref="TransientException"/> occurs. /// If none specified TransientException.None is used.</param> /// <exception cref="System.ArgumentNullException"> /// eventStoreClient /// or /// checkpointRepository /// or /// dispatchCommit /// </exception> public DurableCommitDispatcher( [NotNull] IEventStoreClient eventStoreClient, [NotNull] ICheckpointRepository checkpointRepository, [NotNull] Func<ICommit, CancellationToken, Task> dispatchCommit) { Ensure.That(eventStoreClient, "eventStoreClient").IsNotNull(); Ensure.That(checkpointRepository, "checkpointRepository").IsNotNull(); Ensure.That(dispatchCommit, "dispatchCommit").IsNotNull(); _eventStoreClient = eventStoreClient; _checkpointRepository = checkpointRepository; _dispatchCommit = dispatchCommit; }
/// <summary> /// Initializes a new instance of the <see cref="DurableCommitDispatcher"/> class. /// </summary> /// <param name="eventStoreClient">An event store client.</param> /// <param name="checkpointRepository">A checkpoint repository. Each instane of a <see cref="DurableCommitDispatcher"/> /// should have their own instance of a <see cref="ICheckpointRepository"/>.</param> /// <param name="dispatchCommit">A handler to dispatch the commit to.</param> /// <param name="retryPolicy">A retry policy when a <see cref="TransientException"/> occurs. /// If none specified TransientException.None is used.</param> /// <exception cref="System.ArgumentNullException"> /// eventStoreClient /// or /// checkpointRepository /// or /// dispatchCommit /// </exception> public DurableCommitDispatcher( [NotNull] IEventStoreClient eventStoreClient, [NotNull] ICheckpointRepository checkpointRepository, [NotNull] Func <ICommit, CancellationToken, Task> dispatchCommit) { Ensure.That(eventStoreClient, "eventStoreClient").IsNotNull(); Ensure.That(checkpointRepository, "checkpointRepository").IsNotNull(); Ensure.That(dispatchCommit, "dispatchCommit").IsNotNull(); _eventStoreClient = eventStoreClient; _checkpointRepository = checkpointRepository; _dispatchCommit = dispatchCommit; }
public TaskService(IRTaskRepository taskRepository, IMapper mapper, ITeamRepository teamRepository, IProjectRepository projectRepository, SessionService sessionService, AttachmentService attachmentService, CommentService commentService, CheckPointService checkPointService, ICheckpointRepository checkpointRepository, IUserRepository userRepository) { this.taskRepository = taskRepository; this.mapper = mapper; this.teamRepository = teamRepository; this.projectRepository = projectRepository; this.checkpointRepository = checkpointRepository; this.sessionService = sessionService; this.attachmentService = attachmentService; this.checkPointService = checkPointService; this.commentService = commentService; this.userRepository = userRepository; }
public KinesisStreamReader(IAmazonKinesis client, string streamName, string readerName, IShardReaderFactory shardReaderFactory, ICheckpointRepository checkpointRepository, ILogger logger) { _client = client; _streamName = streamName; _readerName = readerName; _shardReaderFactory = shardReaderFactory; _checkpointRepository = checkpointRepository; _logger = logger; }
/// <summary> /// Initializes a new instance of the <see cref="DurableCommitDispatcher"/> class. /// </summary> /// <param name="eventStoreClient">An event store client.</param> /// <param name="checkpointRepository">A checkpoint repository. Each instane of a <see cref="DurableCommitDispatcher"/> /// should have their own instance of a <see cref="ICheckpointRepository"/>.</param> /// <param name="dispatchCommit">A handler to dispatch the commit to.</param> /// <param name="retryPolicy">A retry policy when a <see cref="TransientException"/> occurs. /// If none specified TransientException.None is used.</param> /// <exception cref="System.ArgumentNullException"> /// eventStoreClient /// or /// checkpointRepository /// or /// dispatchCommit /// </exception> public DurableCommitDispatcher( [NotNull] IEventStoreClient eventStoreClient, [NotNull] ICheckpointRepository checkpointRepository, [NotNull] Func <ICommit, CancellationToken, Task> dispatchCommit, TransientExceptionRetryPolicy retryPolicy = null) { Guard.EnsureNotNull(eventStoreClient, "eventStoreClient"); Guard.EnsureNotNull(checkpointRepository, "checkpointRepository"); Guard.EnsureNotNull(dispatchCommit, "dispatchCommit"); _eventStoreClient = eventStoreClient; _checkpointRepository = checkpointRepository; _dispatchCommit = dispatchCommit; _retryPolicy = retryPolicy ?? TransientExceptionRetryPolicy.None(); }
public Subscriber( IEventStoreConnection eventStoreConnection, ICheckpointRepository <Position> checkpointRepository, ILogger <Subscriber> logger, IConfiguration configuration, IMediator mediator, IDomainEventMapper domainEventMapper) { _eventStoreConnection = eventStoreConnection; _checkpointRepository = checkpointRepository; _logger = logger; _configuration = configuration; _mediator = mediator; _domainEventMapper = domainEventMapper; }
public IKinesisStreamReader CreateProcesssedMeasurementsReader( ICheckpointRepository checkpointRepository, IBus eventBus) { var streamName = _awsSettings.ProcessedMeasurementsStreamName; var client = _clientFactory.CreateKinesisClient(); ProcessedMeasurementsShardReaderFactory factory = new ProcessedMeasurementsShardReaderFactory(checkpointRepository, _heartbeatService, eventBus, _logger); return(new KinesisStreamReader(client, streamName, "Measurements", factory, checkpointRepository, _logger)); }
public ResolvedEventDispatcher( IEventStoreConnection eventStore, ISerializer serializer, ICheckpointRepository checkpoints, Func<ISerializer, ResolvedEvent, bool, CancellationToken, Task> dispatchResolvedEvent, Action onCaughtUp = null, string streamId = null, UserCredentials userCredentials = null) { _isStarted = new InterlockedBoolean(); _isDisposed = new InterlockedBoolean(); _eventStore = eventStore; _serializer = serializer; _checkpoints = checkpoints; _dispatchResolvedEvent = dispatchResolvedEvent; _onCaughtUp = onCaughtUp ?? (() => { }); _streamId = streamId; _userCredentials = userCredentials; _projectedEvents = new Subject<ResolvedEvent>(); _queue = new SimpleQueue(async (resolvedEvent, token) => { try { await _dispatchResolvedEvent(_serializer, resolvedEvent, _subscription.IsSubscribedToAll, _disposed.Token); } catch(Exception ex) { _projectedEvents.OnError(ex); throw; } if(_isDisposed.Value) { return; } _projectedEvents.OnNext(resolvedEvent); }, _disposed.Token); }
public IKinesisStreamReader CreateReader(IRecordProcessorFactory recordProcessorFactory, ICheckpointRepository checkpointRepository, IProcessedMeasurementStreamWriter processedMeasurementStreamWriter) { var streamName = _awsSettings.RawMeasurementsStreamName; var client = _clientFactory.CreateKinesisClient(); RawMeasurementsShardReaderFactory factory = new RawMeasurementsShardReaderFactory(recordProcessorFactory, processedMeasurementStreamWriter, checkpointRepository, _heartbeatService, _logger); return(new KinesisStreamReader(client, streamName, "", factory, checkpointRepository, _logger)); }
public ResolvedEventDispatcher( IEventStoreConnection eventStore, ISerializer serializer, ICheckpointRepository checkpoints, Func <ISerializer, ResolvedEvent, bool, CancellationToken, Task> dispatchResolvedEvent, Action onCaughtUp = null, string streamId = null, UserCredentials userCredentials = null) { _isStarted = new InterlockedBoolean(); _isDisposed = new InterlockedBoolean(); _eventStore = eventStore; _serializer = serializer; _checkpoints = checkpoints; _dispatchResolvedEvent = dispatchResolvedEvent; _onCaughtUp = onCaughtUp ?? (() => { }); _streamId = streamId; _userCredentials = userCredentials; _projectedEvents = new Subject <ResolvedEvent>(); _queue = new SimpleQueue(async(resolvedEvent, token) => { try { await _dispatchResolvedEvent(_serializer, resolvedEvent, _subscription.IsSubscribedToAll, _disposed.Token); } catch (Exception ex) { _projectedEvents.OnError(ex); throw; } if (_isDisposed.Value) { return; } _projectedEvents.OnNext(resolvedEvent); }, _disposed.Token); }
public CheckPointService(ICheckpointRepository checkpointRepository, IMapper mapper, IRTaskRepository taskRepository) { this.checkpointRepository = checkpointRepository; this.mapper = mapper; this.taskRepository = taskRepository; }
public BackgroundEventProcessor(IIntegrationEventBus bus, IEventStoreConnection eventStore, ICheckpointRepository checkpointStore) { this._bus = bus ?? throw new ArgumentNullException(nameof(bus)); this._eventStore = eventStore ?? throw new ArgumentNullException(nameof(eventStore)); this._checkpointStore = checkpointStore ?? throw new ArgumentNullException(nameof(checkpointStore)); }
public ReadModelCommitObserver(ICheckpointRepository checkpointRepo, IDispatchCommits dispatcher) { Contract.Requires <ArgumentNullException>(checkpointRepo != null, "checkpointRepo"); this.checkpointRepo = checkpointRepo; this.dispatcher = dispatcher; }
public TestProjectionDispatcher(IProjectionHandlerResolver handlerResolver, ICheckpointRepository checkpointRepository) : base(handlerResolver, checkpointRepository) {}
public RoutesController(IRouteRepository routeRepository, ICheckpointRepository checkpointRepository) { this.routeRepository = routeRepository ?? throw new ArgumentNullException(nameof(routeRepository)); this.checkpointRepository = checkpointRepository ?? throw new ArgumentNullException(nameof(checkpointRepository)); }
public CheckpointsController(ICheckpointRepository repository) { this.repository = repository ?? throw new ArgumentNullException(nameof(repository)); }
/// <summary> /// Initializes a new instance of the <see cref="DurableCommitDispatcher"/> class. /// </summary> /// <param name="eventStoreClient">An event store client.</param> /// <param name="checkpointRepository">A checkpoint repository. Each instane of a <see cref="DurableCommitDispatcher"/> /// should have their own instance of a <see cref="ICheckpointRepository"/>.</param> /// <param name="dispatchCommit">A handler to dispatch the commit to.</param> /// <param name="retryPolicy">A retry policy when a <see cref="TransientException"/> occurs. /// If none specified TransientException.None is used.</param> /// <exception cref="System.ArgumentNullException"> /// eventStoreClient /// or /// checkpointRepository /// or /// dispatchCommit /// </exception> public DurableCommitDispatcher( [NotNull] IEventStoreClient eventStoreClient, [NotNull] ICheckpointRepository checkpointRepository, [NotNull] Func<ICommit, CancellationToken, Task> dispatchCommit, TransientExceptionRetryPolicy retryPolicy = null) { Guard.EnsureNotNull(eventStoreClient, "eventStoreClient"); Guard.EnsureNotNull(checkpointRepository, "checkpointRepository"); Guard.EnsureNotNull(dispatchCommit, "dispatchCommit"); _eventStoreClient = eventStoreClient; _checkpointRepository = checkpointRepository; _dispatchCommit = dispatchCommit; _retryPolicy = retryPolicy ?? TransientExceptionRetryPolicy.None(); _compositeDisposable.Add(_commitsProjectedStream); }
public MyoController(IUserRepository userRepository, IMyoRepository myoRepository, ICheckpointRepository checkpointRepository) { this.userRepository = userRepository; this.myoRepository = myoRepository; this.checkpointRepository = checkpointRepository; }
public TestProjectionDispatcher(IProjectionHandlerResolver handlerResolver, ICheckpointRepository checkpointRepository) : base(handlerResolver, checkpointRepository) { }