protected override void Context() { for (int c = 1; c <= ParallelWriters; c++) { var client = new AcceptanceTestMongoPersistenceFactory().Build(); if (c == 1) { client.Drop(); client.Initialize(); } _writers.Add(client); } _observer = new Observer(); var reader = new AcceptanceTestMongoPersistenceFactory().Build(); _client = new PollingClient(reader, PollingInterval); _observeCommits = _client.ObserveFrom(null); _subscription = _observeCommits.Subscribe(_observer); _observeCommits.Start(); }
public async Task CreateAccountEventIsPublishedToBus() { MassTransitDispatcher massTransitDispatcher = new MassTransitDispatcher(bus); PollingClient pollingClient = new PollingClient(store.Advanced, 100); IObserveCommits commitObserver = pollingClient.ObserveFrom(null); AccountDenormalizer denormalizer = new AccountDenormalizer(); bus.Subscribe(denormalizer); using (PollingHook pollingHook = new PollingHook(commitObserver)) { using (var subscription = commitObserver.Subscribe(massTransitDispatcher)) { commitObserver.PollNow(); commitObserver.Start(); Guid accountID = Guid.NewGuid(); string name = Guid.NewGuid().ToString(); string twitter = Guid.NewGuid().ToString(); System.Diagnostics.Debug.Print(string.Format("Creating account {0}", accountID)); client.CreateNewAccount(accountID, name, twitter); DateTime timeoutEnd = DateTime.Now.AddSeconds(10); while (denormalizer.AccountName != name && DateTime.Now < timeoutEnd) { await Task.Delay(100); } denormalizer.AccountName.Should().Be(name); } } }
protected override async Task Because() { // NOTE: We do not await intentionally here! _commitObserved = _observeCommits.FirstAsync().ToTask(); await _observeCommits.Start(); }
public void CreateAccountEventIsPublishedToBus() { using (MassTransitDispatcher massTransitDispatcher = new MassTransitDispatcher(bus)) { PollingClient pollingClient = new PollingClient(store.Advanced, 100); IObserveCommits commitObserver = pollingClient.ObserveFrom(null); IEventHandler <SimpleAggregateCreated> denormalizer = A.Fake <IEventHandler <SimpleAggregateCreated> >(); AutoResetEvent are = new AutoResetEvent(false); A.CallTo(() => denormalizer.Handle(A <SimpleAggregateCreated> .Ignored)).Invokes(() => are.Set()); bus.Subscribe(denormalizer); using (PollingHook pollingHook = new PollingHook(commitObserver)) { using (var subscription = commitObserver.Subscribe(massTransitDispatcher)) { commitObserver.PollNow(); commitObserver.Start(); Guid aggregateID = Guid.NewGuid(); SimpleAggregate aggregate = new SimpleAggregate(aggregateID, DateTime.Now); repository.Save(aggregate, Guid.NewGuid(), (o) => { }); are.WaitOne(10000).Should().BeTrue("event should be dispatched and recieved within timeout"); } } } }
protected override async Task Because() { await _observeCommits1.Start(); for (int i = 0; i < 15; i++) { await StoreEvents.Advanced.CommitSingle(); } }
protected override void Because() { _observeCommits1.Start(); Task.Factory.StartNew(() => { for (int i = 0; i < 15; i++) { StoreEvents.Advanced.CommitSingle(); } }); }
public void Start() { var start = _tracker.LoadCheckpoint(); var client = new PollingClient(_eventStore.Advanced, 1000); var dispatcher = new CommitsDispatcher(_tracker, Logger); _observer = client.ObserveFrom(start); _subscription = _observer.Subscribe(dispatcher); _observer.Start(); Logger.InfoFormat("Projection engine started from {0}", start); }
protected override void Context() { base.Context(); StoreEvents.Advanced.CommitSingle(); _observeCommits = PollingClient.ObserveFrom(); _commitObserved = _observeCommits.FirstAsync().ToTask(); _observeCommits.Start(); _commitObserved.Wait(PollingInterval * 2); _observeCommits.Dispose(); StoreEvents.Advanced.CommitSingle(); string checkpointToken = _commitObserved.Result.CheckpointToken; _observeCommits = PollingClient.ObserveFrom(checkpointToken); }
public void Init() { //checkpoint token, can be persisted so we don't need to read the EventStore from scratch string checkpointToken = null; var pollingClient = new PollingClient(Program.StoreEvents.Advanced); _observer = pollingClient.ObserveFromBucket(InvoicesBucketId, checkpointToken); _observer.Subscribe(new InvoicesObserver()); //init the projection on startup _observer.PollNow(); //start a long running task that will poll the event store periodicaly _observerTask = _observer.Start(); }
protected override async Task Context() { await base.Context(); await StoreEvents.Advanced.CommitSingle(); _observeCommits = PollingClient.ObserveFrom(); _commitObserved = _observeCommits.FirstAsync().ToTask(); await _observeCommits.Start(); var task = await Task.WhenAny(_commitObserved, Task.Delay(PollingInterval * 2)); task.Should().Be(_commitObserved); _observeCommits.Dispose(); await StoreEvents.Advanced.CommitSingle(); string checkpointToken = _commitObserved.Result.CheckpointToken; _observeCommits = PollingClient.ObserveFrom(checkpointToken); }
private static void Main() { using (var store = WireupEventStore()) { var client = new PollingClient(store.Advanced); string checkpointToken = LoadCheckpoint(); using (IObserveCommits observeCommits = client.ObserveFrom(checkpointToken)) using (observeCommits.Subscribe(commit => { // Project the commit etc Console.WriteLine(Resources.CommitInfo, commit.BucketId, commit.StreamId, commit.CommitSequence); // Track the most recent checkpoint checkpointToken = commit.CheckpointToken; })) { observeCommits.Start(); Console.WriteLine(Resources.PressAnyKey); Console.ReadKey(); SaveCheckpoint(checkpointToken); } } }
protected override async Task Because() { await _observeCommits.Start(); await StoreEvents.Advanced.CommitSingle(); }
protected override void Because() { _observeCommits.Start(); }
protected override void Because() { _observeCommits.Start(); _commitObserved = _observeCommits.FirstAsync().ToTask(); }
protected override void Because() { _observeCommits.Start(); StoreEvents.Advanced.CommitSingle(); }
protected override void Because() { _observingCommits = _observeCommits.Start(); StoreEvents.Advanced.CommitSingle(); _exception = Catch.Exception(() => _observingCommits.Wait(1000)); }
protected override async Task Because() { // We intentionally do not await here! await _observeCommits.Start(); }
/// <summary> /// Starts observing commits and dispatching them.. /// </summary> /// <returns></returns> public async Task Start() { if (_isStarted.CompareExchange(true, false)) { return; } string checkpointToken = await _checkpointRepository.Get(); _commitStream = _eventStoreClient.ObserveFrom(checkpointToken); //TODO replace with EventStoreClient in NES v6 var subscription = _commitStream .Subscribe(commit => Task.Run(async () => { try { await _retryPolicy.Retry(() => _dispatchCommit(commit, CancellationToken.None), _disposed.Token); await _retryPolicy.Retry(() => _checkpointRepository.Put(commit.CheckpointToken), _disposed.Token); } catch (Exception ex) { Logger.ErrorException( Messages.ExceptionHasOccuredWhenDispatchingACommit.FormatWith(commit.ToString()), ex); _commitsProjectedStream.OnError(ex); throw; } _commitsProjectedStream.OnNext(commit); }).Wait()); _commitStream.Start(); _compositeDisposable.Add(_commitStream); _compositeDisposable.Add(subscription); }
void StartPolling() { Init(); _observeCommits.Start(); }