public StoreSnapshots(IMetrics metrics, IStoreEvents store, ISnapshotReader snapshots)
{
_metrics = metrics;
_store = store;
_snapshots = snapshots;
_streamGen = Configuration.Settings.Generator;
}
public OobWriter(IMessageDispatcher dispatcher, IStoreEvents store, IVersionRegistrar registrar)
{
_dispatcher = dispatcher;
_store = store;
_generator = Configuration.Settings.Generator;
_registrar = registrar;
}
public ResolveWeaklyConflictResolver(IStoreSnapshots snapstore, IStoreEvents eventstore, IDelayedChannel delay, StreamIdGenerator streamGen)
{
_snapstore = snapstore;
_eventstore = eventstore;
_delay = delay;
_streamGen = streamGen;
}
public StoreSnapshots(IMetrics metrics, IStoreEvents store, ISnapshotReader snapshots, StreamIdGenerator streamGen)
{
_metrics = metrics;
_store = store;
_snapshots = snapshots;
_streamGen = streamGen;
}
public Task takes_snapshot()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Delayes conflicting events to be resolved later
var resolver = new Aggregates.Internal.ResolveWeaklyConflictResolver(_snapstore.Object, _eventstore.Object, _channel.Object, streamGen);
var entity = new FakeEntity();
(entity as IEntity <FakeState>).Instantiate(new FakeState());
entity.State.TakeASnapshot = true;
return(Task.CompletedTask);
//await resolver.Resolve(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary<string, string>())
// .ConfigureAwait(false);
//Assert.AreEqual(1, entity.Conflicts);
//_stream.Verify(x => x.Add(Moq.It.IsAny<IEvent>(), Moq.It.IsAny<IDictionary<string, string>>()),
// Moq.Times.Once);
//_stream.Verify(x => x.AddSnapshot(Moq.It.IsAny<IMemento>()), Moq.Times.Once);
//_store.Verify(x => x.WriteStream<Entity>(Moq.It.IsAny<Guid>(), Moq.It.IsAny<IEventStream>(),
// Moq.It.IsAny<IDictionary<string, string>>()), Moq.Times.Once);
}
public async Task takes_snapshot()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Delayes conflicting events to be resolved later
var resolver = new Aggregates.Internal.ResolveWeaklyConflictResolver(_store.Object, _eventstore.Object, _channel.Object, streamGen);
_stream.Setup(x => x.AddSnapshot(Moq.It.IsAny <IMemento>()));
_stream.Setup(x => x.StreamVersion).Returns(0);
_stream.Setup(x => x.CommitVersion).Returns(1);
var entity = new Entity(_stream.Object, _resolver.Object);
entity.TakeASnapshot = true;
await resolver.Resolve(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>())
.ConfigureAwait(false);
Assert.AreEqual(1, entity.Conflicts);
_stream.Verify(x => x.Add(Moq.It.IsAny <IEvent>(), Moq.It.IsAny <IDictionary <string, string> >()),
Moq.Times.Once);
_stream.Verify(x => x.AddSnapshot(Moq.It.IsAny <IMemento>()), Moq.Times.Once);
_store.Verify(x => x.WriteStream <Entity>(Moq.It.IsAny <Guid>(), Moq.It.IsAny <IEventStream>(),
Moq.It.IsAny <IDictionary <string, string> >()), Moq.Times.Once);
}
public StoreStreams(IStoreEvents store, IStreamCache cache, bool cacheStreams, StreamIdGenerator streamGen)
{
_store = store;
_cache = cache;
_shouldCache = cacheStreams;
_streamGen = streamGen;
}
public StorePocos(IStoreEvents store, ICache cache, bool shouldCache, StreamIdGenerator streamGen)
{
_store = store;
_cache = cache;
_shouldCache = shouldCache;
_streamGen = streamGen;
}
public ResolveWeaklyConflictResolver(IStoreStreams eventstore, IDelayedChannel delay, StreamIdGenerator streamGen, int maxPulledDelayed)
{
_store = eventstore;
_delay = delay;
_streamGen = streamGen;
_maxPulledDelayed = maxPulledDelayed;
}
public DelayedCache(IMetrics metrics, IStoreEvents store, IVersionRegistrar registrar, IRandomProvider random, ITimeProvider time)
{
_metrics = metrics;
_store = store;
_registrar = registrar;
_random = random;
_time = time;
_flushInterval = Configuration.Settings.FlushInterval;
_endpoint = Configuration.Settings.Endpoint;
_maxSize = Configuration.Settings.MaxDelayed;
_flushSize = Configuration.Settings.FlushSize;
_expiration = Configuration.Settings.DelayedExpiration;
_streamGen = Configuration.Settings.Generator;
_cts = new CancellationTokenSource();
_cacheLock = new object();
_memCache = new Dictionary <CacheKey, CachedList>(new CacheKey.EqualityComparer());
_thread = new Thread(Threaded)
{
IsBackground = true, Name = $"Delayed Cache Thread"
};
// Add a process exit event handler to flush cached delayed events before exiting the app
// Not perfect in the case of a fatal app error - but something
AppDomain.CurrentDomain.ProcessExit += (sender, e) => Threaded(this);
_thread.Start(this);
}
public DelayedCache(IMetrics metrics, IStoreEvents store, TimeSpan flushInterval, string endpoint, int maxSize, int flushSize, TimeSpan delayedExpiration, StreamIdGenerator streamGen)
{
_metrics = metrics;
_store = store;
_flushInterval = flushInterval;
_endpoint = endpoint;
_maxSize = maxSize;
_flushSize = flushSize;
_expiration = delayedExpiration;
_streamGen = streamGen;
_cts = new CancellationTokenSource();
_cacheLock = new object();
_memCache = new Dictionary <CacheKey, CachedList>(new CacheKey.EqualityComparer());
_rand = new Random();
_thread = new Thread(Threaded)
{
IsBackground = true, Name = $"Delayed Cache Thread"
};
// Add a process exit event handler to flush cached delayed events before exiting the app
// Not perfect in the case of a fatal app error - but something
AppDomain.CurrentDomain.ProcessExit += (sender, e) => Threaded(this);
_thread.Start(this);
}
public async Task ignore_resolver()
{
var store = new Moq.Mock <IStoreEvents>();
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
var fullevent = new Moq.Mock <IFullEvent>();
fullevent.Setup(x => x.Event).Returns(new Event());
_stream.Setup(x => x.Add(Moq.It.IsAny <IEvent>(), Moq.It.IsAny <IDictionary <string, string> >()));
store.Setup(
x => x.WriteEvents("test", new[] { fullevent.Object }, Moq.It.IsAny <IDictionary <string, string> >(), null))
.Returns(Task.FromResult(0L));
// Ignores conflict, just commits
var resolver = new IgnoreConflictResolver(store.Object, streamGen);
var entity = new Entity(_stream.Object, _resolver.Object);
await resolver.Resolve(entity, new[] { fullevent.Object }, Guid.NewGuid(), new Dictionary <string, string>())
.ConfigureAwait(false);
_stream.Verify(x => x.Add(Moq.It.IsAny <IEvent>(), Moq.It.IsAny <IDictionary <string, string> >()),
Moq.Times.Once);
store.Verify(
x => x.WriteEvents("test", new[] { fullevent.Object }, Moq.It.IsAny <IDictionary <string, string> >(), null),
Moq.Times.Once);
}
public StorePocos(IStoreEvents store, ICache cache, IMessageSerializer serializer, bool shouldCache, StreamIdGenerator streamGen)
{
_store = store;
_cache = cache;
_serializer = serializer;
_shouldCache = shouldCache;
_streamGen = streamGen;
}
public StoreEvents(IMetrics metrics, IMessageSerializer serializer, IEventMapper mapper, StreamIdGenerator generator, int readsize, Compression compress, IEventStoreConnection[] connections)
{
_metrics = metrics;
_serializer = serializer;
_mapper = mapper;
_generator = generator;
_clients = connections;
_readsize = readsize;
_compress = compress;
}
public StoreStreams(ICache cache, IStoreEvents store, IMessagePublisher publisher, IStoreSnapshots snapstore, StreamIdGenerator streamGen, IEnumerable <IEventMutator> mutators)
{
_cache = cache;
_store = store;
_publisher = publisher;
_snapstore = snapstore;
_streamGen = streamGen;
_mutators = mutators;
_random = new Random();
}
public StoreEvents(IMetrics metrics, IMessageSerializer serializer, IEventMapper mapper, IEventStoreConnection[] connections)
{
_metrics = metrics;
_serializer = serializer;
_mapper = mapper;
_clients = connections;
_generator = Configuration.Settings.Generator;
_readsize = Configuration.Settings.ReadSize;
_compress = Configuration.Settings.Compression;
}
public void dont_catch_frozen_exception()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_store.Object, _eventstore.Object, streamGen);
var entity = new Entity(_stream.Object, _resolver.Object);
_store.Setup(x => x.Freeze <Entity>(Moq.It.IsAny <IEventStream>())).Throws(new VersionException("test"));
Assert.ThrowsAsync <VersionException>(
() => resolver.Resolve(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>()));
}
public void no_route_exception()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_store.Object, _eventstore.Object, streamGen);
var entity = new Entity(_stream.Object, _resolver.Object);
_resolver.Setup(x => x.Conflict(Moq.It.IsAny <Entity>(), typeof(Event))).Throws <NoRouteException>();
Assert.ThrowsAsync <ConflictResolutionFailedException>(
() => resolver.Resolve(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>()));
}
public void dont_catch_abandon_resolution()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Delayes conflicting events to be resolved later
var resolver = new Aggregates.Internal.ResolveWeaklyConflictResolver(_store.Object, _eventstore.Object, _channel.Object, streamGen);
var entity = new Entity(_stream.Object, _resolver.Object);
_resolver.Setup(x => x.Conflict(Moq.It.IsAny <Entity>(), typeof(Event))).Throws <AbandonConflictException>();
Assert.ThrowsAsync <AbandonConflictException>(
() => resolver.Resolve(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>()));
}
public void no_route_exception()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Delayes conflicting events to be resolved later
var resolver = new Aggregates.Internal.ResolveWeaklyConflictResolver(_snapstore.Object, _eventstore.Object, _channel.Object, streamGen);
var entity = new FakeEntity();
//_resolver.Setup(x => x.Conflict(Moq.It.IsAny<Entity>(), typeof(Event))).Throws<NoRouteException>();
//Assert.ThrowsAsync<ConflictResolutionFailedException>(
// () => resolver.Resolve(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary<string, string>()));
}
public void dont_catch_abandon_resolution()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_snapstore.Object, _eventstore.Object, streamGen);
var entity = new FakeEntity();
(entity as IEntity <FakeState>).Instantiate(new FakeState());
entity.State.ThrowAbandon = true;
Assert.ThrowsAsync <AbandonConflictException>(
() => resolver.Resolve <FakeEntity, FakeState>(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>()));
}
public void no_route_exception()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_snapstore.Object, _eventstore.Object, streamGen);
_event.Setup(x => x.Event).Returns(new FakeUnknownEvent());
var entity = new FakeEntity();
(entity as IEntity <FakeState>).Instantiate(new FakeState());
Assert.ThrowsAsync <ConflictResolutionFailedException>(
() => resolver.Resolve <FakeEntity, FakeState>(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>()));
}
public EventStoreDelayed(IStoreEvents store, string endpoint, int maxSize, int readSize, TimeSpan flushInterval, StreamIdGenerator streamGen)
{
_store = store;
_streamGen = streamGen;
_endpoint = endpoint;
if (_flusher == null)
{
// Add a process exit event handler to flush cached delayed events before exiting the app
// Not perfect in the case of a fatal app error - but something
AppDomain.CurrentDomain.ProcessExit += (sender, e) => Flush(new FlushState {
Store = store, StreamGen = streamGen, Endpoint = endpoint, MaxSize = maxSize, ReadSize = readSize, Expiration = flushInterval
}, all: true).Wait();
_flusher = Timer.Repeat((s) => Flush(s), new FlushState {
Store = store, StreamGen = streamGen, Endpoint = endpoint, MaxSize = maxSize, ReadSize = readSize, Expiration = flushInterval
}, flushInterval, "delayed flusher");
}
}
public async Task strong_resolve_conflict()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_snapstore.Object, _eventstore.Object, streamGen);
var entity = new FakeEntity();
(entity as IEntity <FakeState>).Instantiate(new FakeState());
await resolver.Resolve <FakeEntity, FakeState>(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>())
.ConfigureAwait(false);
Assert.AreEqual(1, entity.State.Conflicts);
_eventstore.Verify(x => x.WriteEvents <FakeEntity>(Moq.It.IsAny <string>(), Moq.It.IsAny <Id>(), Moq.It.IsAny <Id[]>(), Moq.It.IsAny <IFullEvent[]>(), Moq.It.IsAny <IDictionary <string, string> >(), Moq.It.IsAny <long?>()), Moq.Times.Once);
}
public async Task oob_events_not_conflict_resolved()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
_event.Setup(x => x.Descriptor.Headers[Defaults.OobHeaderKey]).Returns("test");
_event.Setup(x => x.Descriptor.StreamType).Returns(StreamTypes.OOB);
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_snapstore.Object, _eventstore.Object, streamGen);
var entity = new FakeEntity();
(entity as IEntity <FakeState>).Instantiate(new FakeState());
await resolver.Resolve <FakeEntity, FakeState>(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>())
.ConfigureAwait(false);
Assert.AreEqual(0, entity.State.Conflicts);
}
public Task oob_events_not_conflict_resolved()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
_event.Setup(x => x.Descriptor.Headers[Defaults.OobHeaderKey]).Returns("test");
_event.Setup(x => x.Descriptor.StreamType).Returns(StreamTypes.OOB);
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveWeaklyConflictResolver(_snapstore.Object, _eventstore.Object, _channel.Object, streamGen);
var entity = new FakeEntity();
return(Task.CompletedTask);
//await resolver.Resolve(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary<string, string>())
// .ConfigureAwait(false);
//Assert.AreEqual(0, entity.Conflicts);
//_stream.Verify(x => x.AddOob(Moq.It.IsAny<IEvent>(), "test", Moq.It.IsAny<IDictionary<string, string>>()),
// Moq.Times.Once);
}
public async Task strong_resolve_conflict()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_store.Object, _eventstore.Object, streamGen);
var entity = new Entity(_stream.Object, _resolver.Object);
await resolver.Resolve(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>())
.ConfigureAwait(false);
Assert.AreEqual(1, entity.Conflicts);
_stream.Verify(x => x.Add(Moq.It.IsAny <IEvent>(), Moq.It.IsAny <IDictionary <string, string> >()),
Moq.Times.Once);
_store.Verify(
x => x.WriteStream <Entity>(Moq.It.IsAny <Guid>(), Moq.It.IsAny <IEventStream>(),
Moq.It.IsAny <IDictionary <string, string> >()),
Moq.Times.Once);
}
public async Task conflict_no_resolve()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
_channel.Setup(x => x.Age(Moq.It.IsAny <string>(), Moq.It.IsAny <string>()))
.Returns(Task.FromResult((TimeSpan?)TimeSpan.FromSeconds(1)));
// Delays conflicting events to be resolved later
var resolver = new Aggregates.Internal.ResolveWeaklyConflictResolver(_store.Object, _eventstore.Object, _channel.Object, streamGen);
var entity = new Entity(_stream.Object, _resolver.Object);
await resolver.Resolve(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>())
.ConfigureAwait(false);
Assert.AreEqual(0, entity.Conflicts);
_stream.Verify(x => x.Add(Moq.It.IsAny <IEvent>(), Moq.It.IsAny <IDictionary <string, string> >()),
Moq.Times.Never);
_store.Verify(x => x.WriteStream <Entity>(Moq.It.IsAny <Guid>(), Moq.It.IsAny <IEventStream>(),
Moq.It.IsAny <IDictionary <string, string> >()), Moq.Times.Never);
}
public async Task ignore_resolver()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
var fullevent = new Moq.Mock <IFullEvent>();
fullevent.Setup(x => x.Event).Returns(new Event());
_store.Setup(x => x.WriteEvents <FakeEntity>(Moq.It.IsAny <string>(), Moq.It.IsAny <Id>(), Moq.It.IsAny <Id[]>(), Moq.It.IsAny <IFullEvent[]>(), Moq.It.IsAny <IDictionary <string, string> >(), Moq.It.IsAny <long?>()))
.Returns(Task.FromResult(0L));
// Ignores conflict, just commits
var resolver = new IgnoreConflictResolver(_store.Object, streamGen);
var entity = new FakeEntity();
(entity as IEntity <FakeState>).Instantiate(new FakeState());
await resolver.Resolve <FakeEntity, FakeState>(entity, new[] { fullevent.Object }, Guid.NewGuid(), new Dictionary <string, string>())
.ConfigureAwait(false);
_store.Verify(x => x.WriteEvents <FakeEntity>(Moq.It.IsAny <string>(), Moq.It.IsAny <Id>(), Moq.It.IsAny <Id[]>(), Moq.It.IsAny <IFullEvent[]>(), Moq.It.IsAny <IDictionary <string, string> >(), Moq.It.IsAny <long?>()), Moq.Times.Once);
}
public async Task doesnt_take_snapshot()
{
var streamGen = new StreamIdGenerator((type, stream, bucket, id, parents) => "test");
// Runs all conflicting events back through a re-hydrated entity
var resolver = new Aggregates.Internal.ResolveStronglyConflictResolver(_snapstore.Object, _eventstore.Object, streamGen);
var uow = new Moq.Mock <IDomainUnitOfWork>();
var entity = new FakeEntity();
(entity as IEntity <FakeState>).Instantiate(new FakeState());
(entity as INeedDomainUow).Uow = uow.Object;
entity.State.TakeASnapshot = true;
_snapstore.Setup(x => x.WriteSnapshots <FakeEntity>(Moq.It.IsAny <IState>(), Moq.It.IsAny <IDictionary <string, string> >()))
.Returns(Task.CompletedTask);
await resolver.Resolve <FakeEntity, FakeState>(entity, new[] { _event.Object }, Guid.NewGuid(), new Dictionary <string, string>())
.ConfigureAwait(false);
Assert.AreEqual(1, entity.State.Conflicts);
_snapstore.Verify(x => x.WriteSnapshots <FakeEntity>(Moq.It.IsAny <IState>(), Moq.It.IsAny <IDictionary <string, string> >()), Moq.Times.Never);
}
