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 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 void Context() { base.Context(); StoreEvents.Advanced.CommitSingle(); _observeCommits = PollingClient.ObserveFrom(); _subscriberException = new Exception(); _subscription = _observeCommits.Subscribe(c => { throw _subscriberException; }, ex => _onErrorException = ex); }
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); }
public IObserveCommits Construct() { var pollingClient = new PollingClient(eventStore.Advanced); var checkpoint = checkpointRepo.LoadCheckpoint(); IObserveCommits subscription = pollingClient.ObserveFrom(checkpoint); foreach (var commitObserver in commitObservers) { subscription.Subscribe(commitObserver); } return(subscription); }
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(); }
private void Init() { _maxDispatchedCheckpoint = 0; DumpProjections(); _stopping = new ManualResetEventSlim(false); TenantContext.Enter(_config.TenantId); _housekeeper.Init(); _eventstore = Wireup .Init() .LogTo(t => new NEventStoreLog4NetLogger(LoggerFactory.Create(t))) .UsingMongoPersistence(() => _config.EventStoreConnectionString, new DocumentObjectSerializer()) .InitializeStorageEngine() .Build(); ConfigureProjections(); // cleanup _housekeeper.RemoveAll(_eventstore.Advanced); var allSlots = _projectionsBySlot.Keys.ToArray(); _client.Create(_eventstore.Advanced, _config.PollingMsInterval); var subscriptions = new List <IDisposable>(); _observeCommits = _client.ObserveFrom(GetStartGlobalCheckpoint()); foreach (var slotName in allSlots) { MetricsHelper.CreateMeterForDispatcherCountSlot(slotName); var startCheckpoint = GetStartCheckpointForSlot(slotName); Logger.InfoFormat("Slot {0} starts from {1}", slotName, startCheckpoint); var name = slotName; subscriptions.Add( _observeCommits.Subscribe(commit => DispatchCommit(commit, name, LongCheckpoint.Parse(startCheckpoint)), HandleError)); } _subscriptions = subscriptions.ToArray(); }
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); } } }
/// <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); }