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);
}
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 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);
}
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();
}
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);
}