/// <summary>
/// Attempts to get the aggregate root entity associated with the aggregate identifier.
/// </summary>
/// <param name="identifier">The aggregate identifier.</param>
/// <returns>The found <typeparamref name="TAggregateRoot"/>, or empty if not found.</returns>
public Optional <TAggregateRoot> GetOptional(string identifier)
{
Aggregate aggregate;
if (_unitOfWork.TryGet(identifier, out aggregate))
{
return(new Optional <TAggregateRoot>((TAggregateRoot)aggregate.Root));
}
var streamUserCredentials = _configuration.StreamUserCredentialsResolver.Resolve(identifier);
var streamName = _configuration.StreamNameResolver.Resolve(identifier);
var slice = _connection.ReadStreamEventsForward(streamName, StreamPosition.Start, _configuration.SliceSize,
false, streamUserCredentials);
if (slice.Status == SliceReadStatus.StreamDeleted || slice.Status == SliceReadStatus.StreamNotFound)
{
return(Optional <TAggregateRoot> .Empty);
}
var root = _rootFactory();
root.Initialize(slice.Events.SelectMany(resolved => _configuration.Deserializer.Deserialize(resolved)));
while (!slice.IsEndOfStream)
{
slice = _connection.ReadStreamEventsForward(streamName, slice.NextEventNumber, _configuration.SliceSize,
false, streamUserCredentials);
root.Initialize(slice.Events.SelectMany(resolved => _configuration.Deserializer.Deserialize(resolved)));
}
aggregate = new Aggregate(identifier, slice.LastEventNumber, root);
_unitOfWork.Attach(aggregate);
return(new Optional <TAggregateRoot>(root));
}
public void read_stream_forward_respects_max_count()
{
var res = _connection.ReadStreamEventsForward(Stream, 0, 100, false);
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(3, res.Events.Length);
Assert.AreEqual(_testEvents.Skip(2).Select(x => x.EventId).ToArray(),
res.Events.Select(x => x.Event.EventId).ToArray());
}
public void following_append_with_correct_expected_version_are_commited_correctly()
{
Assert.AreEqual(4, _connection.AppendToStream("test-stream", 2, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).NextExpectedVersion);
var res = _connection.ReadStreamEventsForward("test-stream", 0, 100, false);
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(5, res.Events.Length);
for (int i = 0; i < 5; ++i)
{
Assert.AreEqual(i, res.Events[i].OriginalEventNumber);
}
}
public override TResult GetById <TResult>(Guid id)
{
var streamName = AggregateToStreamName(typeof(TResult), id);
try
{
var eventsSlice = _connection.ReadStreamEventsForward(streamName, 0, int.MaxValue, false);
if (eventsSlice.Status == SliceReadStatus.StreamNotFound)
{
throw new AggregateNotFoundException("Could not found aggregate of type " + typeof(TResult) +
" and id " + id);
}
var deserializedEvents = eventsSlice.Events.Select(e =>
{
var metadata = DeserializeObject <Dictionary <string, string> >(e.OriginalEvent.Metadata);
var eventData = DeserializeObject(e.OriginalEvent.Data, metadata[EventClrTypeHeader]);
return(eventData as IEvent);
});
return(BuildAggregate <TResult>(deserializedEvents));
}
catch (Exception ex)
{
throw;
}
}
public void read_stream_forward_respects_truncatebefore()
{
const string stream = "read_stream_forward_respects_truncatebefore";
_connection.AppendToStream(stream, ExpectedVersion.EmptyStream, _testEvents);
_connection.SetStreamMetadata(stream, ExpectedVersion.EmptyStream, StreamMetadata.Build().SetTruncateBefore(2));
var res = _connection.ReadStreamEventsForward(stream, 0, 100, false);
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(3, res.Events.Length);
Assert.AreEqual(_testEvents.Skip(2).Select(x => x.EventId).ToArray(),
res.Events.Select(x => x.Event.EventId).ToArray());
}
public IEnumerable <DomainEvent> GetStream(string streamName, int fromVersion, int toVersion)
{
// ES wants the number of events to retrieve not highest version
var amount = (toVersion - fromVersion) + 1;
Console.WriteLine("Amount: " + amount);
var events = esConn.ReadStreamEventsForward(StreamName(streamName), fromVersion, amount, false); // last param not important here
// map events back from JSON string to DomainEvent. Header indicates the type
return(events.Events.Select(e => (DomainEvent)RebuildEvent(e)));
}
public static int Count(IEventStoreConnection store, string stream)
{
var result = 0;
while (true)
{
var slice = store.ReadStreamEventsForward(stream, result, SliceSize, false);
result += slice.Events.Length;
if (slice.IsEndOfStream)
break;
}
return result;
}
public TAggregate GetById <TAggregate>(string streamName) where TAggregate : class, IAggregate
{
EnsureConnected();
var aggregate = ConstructAggregate <TAggregate>();
StreamEventsSlice currentSlice;
var nextSliceStart = 0;
do
{
currentSlice = _eventStoreConnection.ReadStreamEventsForward(streamName, nextSliceStart, ReadPageSize, true);
nextSliceStart = currentSlice.NextEventNumber;
foreach (var evnt in currentSlice.Events)
{
aggregate.ApplyEvent(_adapter.DeserializeEvent(evnt.Event));
}
} while (!currentSlice.IsEndOfStream);
return(aggregate);
}
public IList <Event> GetEventsForAggregate(Guid aggregate_id,
IEventSerializer serializer, int version)
{
var events = new List <Event>();
var stream_name = StreamNameForID(aggregate_id);
int position = 0;
StreamEventsSlice slice;
do
{
var count = position + kReadPageSize <= version
? kReadPageSize
: version - position + 1;
slice = connection_.ReadStreamEventsForward(stream_name, position,
count, false);
position = slice.NextEventNumber;
var serialized_events =
slice.Events.Select(@event => Deserialize(@event, serializer));
events.AddRange(serialized_events);
} while (version > slice.NextEventNumber && !slice.IsEndOfStream);
return(events);
}
protected override void ReadEventsTill(IEventStoreConnection connection, bool resolveLinkTos,
UserCredentials userCredentials, long?lastCommitPosition, int?lastEventNumber)
{
bool done;
do
{
var slice = connection.ReadStreamEventsForward(StreamId, _nextReadEventNumber, ReadBatchSize, resolveLinkTos, userCredentials);
switch (slice.Status)
{
case SliceReadStatus.Success:
{
foreach (var e in slice.Events)
{
TryProcess(e);
}
_nextReadEventNumber = slice.NextEventNumber;
done = lastEventNumber == null ? slice.IsEndOfStream : slice.NextEventNumber > lastEventNumber;
break;
}
case SliceReadStatus.StreamNotFound:
{
if (lastEventNumber.HasValue && lastEventNumber != -1)
{
throw new Exception(string.Format("Impossible: stream {0} disappeared in the middle of catching up subscription.", StreamId));
}
done = true;
break;
}
case SliceReadStatus.StreamDeleted:
throw new StreamDeletedException(StreamId);
default:
throw new ArgumentOutOfRangeException(string.Format("Unexpected StreamEventsSlice.Status: {0}.", slice.Status));
}
if (!done && slice.IsEndOfStream)
{
Thread.Sleep(1); // we are waiting for server to flush its data
}
} while (!done);
if (Verbose)
{
Log.Debug("Catch-up Subscription to {0}: finished reading events, nextReadEventNumber = {1}.",
IsSubscribedToAll ? "<all>" : StreamId, _nextReadEventNumber);
}
}
/// <summary>
/// Reads all events in stream
/// </summary>
protected IEnumerable <ResolvedEvent> ReadAllEventsInStream(string streamName, IEventStoreConnection connection, int pageSize = 500)
{
var result = new List <ResolvedEvent>();
var coursor = StreamPosition.Start;
StreamEventsSlice events = null;
do
{
events = connection.ReadStreamEventsForward(streamName, coursor, pageSize, false);
result.AddRange(events.Events);
coursor = events.NextEventNumber;
} while (events != null && !events.IsEndOfStream);
return(result);
}
public static int Count(IEventStoreConnection store, string stream)
{
var result = 0;
while (true)
{
var slice = store.ReadStreamEventsForward(stream, result, SliceSize, false);
result += slice.Events.Length;
if (slice.IsEndOfStream)
{
break;
}
}
return(result);
}
public IEnumerable LoadEventsFor <TAggregate>(Guid id)
{
StreamEventsSlice currentSlice;
var nextSliceStart = StreamPosition.Start;
do
{
currentSlice = conn.ReadStreamEventsForward(id.ToString(), nextSliceStart, 200, false);
foreach (var e in currentSlice.Events)
{
yield return(Deserialize(e.Event.EventType, e.Event.Data));
}
nextSliceStart = currentSlice.NextEventNumber;
} while (!currentSlice.IsEndOfStream);
}
public TAggregate GetById(Guid id, int version)
{
if (version < 0)
{
throw new InvalidOperationException("Cannot get version < 0");
}
var streamName = _aggregateIdToStreamName(typeof(TAggregate), id);
var aggregate = LoadFromSnapshot(id, version) ?? ConstructAggregate();
var sliceStart = aggregate.Version + 1;
StreamEventsSlice currentSlice;
do
{
var sliceCount = sliceStart + ReadPageSize <= version
? ReadPageSize
: version - sliceStart + 1;
if (sliceCount <= 0)
{
break;
}
currentSlice = _eventStoreConnection.ReadStreamEventsForward(streamName, sliceStart, sliceCount, false);
if (currentSlice.Status == SliceReadStatus.StreamNotFound)
{
throw new AggregateNotFoundException(id, typeof(TAggregate));
}
if (currentSlice.Status == SliceReadStatus.StreamDeleted)
{
throw new AggregateDeletedException(id, typeof(TAggregate));
}
sliceStart = currentSlice.NextEventNumber;
aggregate.LoadsFromHistory(currentSlice.Events.Select(evnt => DeserializeObject <EventBase>(evnt.OriginalEvent.Metadata, evnt.OriginalEvent.Data)));
} while (version >= currentSlice.NextEventNumber && !currentSlice.IsEndOfStream);
if (aggregate.Version != version && version < Int32.MaxValue)
{
throw new AggregateVersionException(id, typeof(TAggregate), aggregate.Version, version);
}
return(aggregate);
}
public TAggregate GetById <TAggregate>(Guid id, int version) where TAggregate : class, IAggregate
{
if (version <= 0)
{
throw new InvalidOperationException("Cannot get version <= 0");
}
var streamName = _aggregateIdToStreamName(typeof(TAggregate), id);
var aggregate = ConstructAggregate <TAggregate>(id);
//aggregate.Id = id;
var sliceStart = 0;
StreamEventsSlice currentSlice;
do
{
var sliceCount = sliceStart + ReadPageSize <= version
? ReadPageSize
: version - sliceStart + 1;
currentSlice = _eventStoreConnection.ReadStreamEventsForward(streamName, sliceStart, sliceCount, false);
if (currentSlice.Status == SliceReadStatus.StreamNotFound)
{
throw new AggregateNotFoundException(id, typeof(TAggregate));
}
if (currentSlice.Status == SliceReadStatus.StreamDeleted)
{
throw new AggregateDeletedException(id, typeof(TAggregate));
}
sliceStart = currentSlice.NextEventNumber;
foreach (var evnt in currentSlice.Events)
{
var realEvent = DeserializeEvent(evnt.OriginalEvent.Metadata, evnt.OriginalEvent.Data);
aggregate.ApplyEvent(realEvent);
}
} while (version >= currentSlice.NextEventNumber && !currentSlice.IsEndOfStream);
if (aggregate.Version != version && version < Int32.MaxValue)
{
throw new AggregateVersionException(id, typeof(TAggregate), aggregate.Version, version);
}
return(aggregate);
}
private void LoadProjectionCatalog()
{
Log("Loading projection catalog...");
StreamEventsSlice projections;
_lastCatalogEventNumber = 0;
do
{
Log("Reading catalog chunk...");
projections = _connection.ReadStreamEventsForward("$projections-$all", _lastCatalogEventNumber, 100, false, _credentials);
Log("{0} events loaded", projections.Events.Length);
foreach (var e in projections.Events)
{
if (e.Event.EventType == "$stream-created-implicit")
{
continue;
}
var projectionName = Encoding.UTF8.GetString(e.Event.Data);
if (e.Event.EventType == ProjectionCreatedOld)
{
Log("Old style projection registration found for: {0}", projectionName);
_oldStyleProjections.Add(projectionName);
}
else if (e.Event.EventType == ProjectionCreatedNew)
{
Log("New style projection registration found for: {0}", projectionName);
if (_oldStyleProjections.Contains(projectionName))
{
Log("Old style registration for the {0} is already upgraded", projectionName);
_oldStyleProjections.Remove(projectionName);
}
}
else
{
Log("Skipping event: {0}", e.Event.EventType);
}
_existingProjections.Add(projectionName);
_lastCatalogEventNumber = e.Event.EventNumber;
}
} while (!projections.IsEndOfStream);
Log("Projection catalog loaded.");
}
public static void DeleteAllStreams(this IEventStoreConnection connection)
{
var slice = connection.ReadAllEventsForward(Position.Start, Int32.MaxValue, false,
EmbeddedEventStore.Instance.DefaultCredentials);
var streams = slice.
Events.
Select(_ => _.OriginalStreamId).
Where(StreamNameIsNotReserved).
Distinct();
foreach (var stream in
from _ in streams
let streamStatusSlice = connection.ReadStreamEventsForward(_, 0, 1, false)
where streamStatusSlice.Status != SliceReadStatus.StreamDeleted &&
streamStatusSlice.Status != SliceReadStatus.StreamNotFound
select _)
{
connection.DeleteStream(stream, ExpectedVersion.Any, EmbeddedEventStore.Instance.DefaultCredentials);
}
}
public void SavesCommitHeadersOnEachEvent()
{
var commitId = Guid.NewGuid();
var aggregateToSave = new TestAggregate(Guid.NewGuid());
aggregateToSave.ProduceEvents(20);
_repo.Save(aggregateToSave, commitId, d => {
d.Add("CustomHeader1", "CustomValue1");
d.Add("CustomHeader2", "CustomValue2");
});
var read = _connection.ReadStreamEventsForward(string.Format("aggregate-{0}", aggregateToSave.Id), 1, 20, false);
foreach (var serializedEvent in read.Events)
{
var parsedMetadata = JObject.Parse(Encoding.UTF8.GetString(serializedEvent.OriginalEvent.Metadata));
var deserializedCommitId = parsedMetadata.Property("CommitId").Value.ToObject<Guid>();
Assert.AreEqual(commitId, deserializedCommitId);
var deserializedCustomHeader1 = parsedMetadata.Property("CustomHeader1").Value.ToObject<string>();
Assert.AreEqual("CustomValue1", deserializedCustomHeader1);
var deserializedCustomHeader2 = parsedMetadata.Property("CustomHeader2").Value.ToObject<string>();
Assert.AreEqual("CustomValue2", deserializedCustomHeader2);
}
}
static void FromStream(IEventStoreConnection con, UserCredentials userCredentials)
{
var ad = new MyBudget.Infrastructure.EventStoreAdapter(address, userCredentials);
// var sub = con.SubscribeToStreamFrom("$category-Users", null, true, Appeared, Live, Dropped, userCredentials);
// sub.Start();
var read = con.ReadStreamEventsForward("lines_of_", 0, 1000, true, userCredentials);
foreach (var e in read.Events)
{
var t = ad.TryGetDomainEvent(e);
}
var mre = new ManualResetEvent(false);
mre.WaitOne(3000);
var rgpsa = events.GroupBy(g => g.Event.EventId).ToList();
int i = 0;
var rgps = events.Select(s => new { s, position = i++ }).GroupBy(g => g.s.Event.EventId).ToList();
//var rgps2 = read.Events.Select(s => new { s, position = i++ }).GroupBy(g => g.s.Event.EventId).ToList();
foreach (var r in rgps)
{
var values = r.ToArray();
foreach (var v in values)
{
var t = ad.TryGetDomainEvent(v.s);
}
}
Console.ReadLine();
}
static void FromStream(IEventStoreConnection con, UserCredentials userCredentials)
{
var ad = new MyBudget.Infrastructure.EventStoreAdapter(address, userCredentials);
// var sub = con.SubscribeToStreamFrom("$category-Users", null, true, Appeared, Live, Dropped, userCredentials);
// sub.Start();
var read = con.ReadStreamEventsForward("lines_of_", 0, 1000, true, userCredentials);
foreach (var e in read.Events)
{
var t = ad.TryGetDomainEvent(e);
}
var mre = new ManualResetEvent(false);
mre.WaitOne(3000);
var rgpsa = events.GroupBy(g => g.Event.EventId).ToList();
int i = 0;
var rgps = events.Select(s => new { s, position = i++ }).GroupBy(g => g.s.Event.EventId).ToList();
//var rgps2 = read.Events.Select(s => new { s, position = i++ }).GroupBy(g => g.s.Event.EventId).ToList();
foreach (var r in rgps)
{
var values = r.ToArray();
foreach (var v in values)
{
var t = ad.TryGetDomainEvent(v.s);
}
}
Console.ReadLine();
}
protected override void ReadEventsTill(IEventStoreConnection connection, bool resolveLinkTos,
UserCredentials userCredentials, long? lastCommitPosition, int? lastEventNumber)
{
bool done;
do
{
var slice = connection.ReadStreamEventsForward(StreamId, _nextReadEventNumber, ReadBatchSize, resolveLinkTos, userCredentials);
switch (slice.Status)
{
case SliceReadStatus.Success:
{
foreach (var e in slice.Events)
{
TryProcess(e);
}
_nextReadEventNumber = slice.NextEventNumber;
done = lastEventNumber == null ? slice.IsEndOfStream : slice.NextEventNumber > lastEventNumber;
break;
}
case SliceReadStatus.StreamNotFound:
{
if (lastEventNumber.HasValue && lastEventNumber != -1)
throw new Exception(string.Format("Impossible: stream {0} disappeared in the middle of catching up subscription.", StreamId));
done = true;
break;
}
case SliceReadStatus.StreamDeleted:
throw new StreamDeletedException(StreamId);
default:
throw new ArgumentOutOfRangeException(string.Format("Unexpected StreamEventsSlice.Status: {0}.", slice.Status));
}
if (!done && slice.IsEndOfStream)
Thread.Sleep(1); // we are waiting for server to flush its data
} while (!done);
if (Verbose)
Log.Debug("Catch-up Subscription to {0}: finished reading events, nextReadEventNumber = {1}.",
IsSubscribedToAll ? "<all>" : StreamId, _nextReadEventNumber);
}
protected void ReadStreamForward(string streamId, string login, string password)
{
Connection.ReadStreamEventsForward(streamId, 0, 1, false,
login == null && password == null ? null : new UserCredentials(login, password));
}
ResolvedEvent GetInputMessage(string actorId, int minVersion)
{
var slice = _connection.ReadStreamEventsForward(actorId + "-input", minVersion, 1, true);
return(slice.Events.Single());
}
public static IEnumerable <ResolvedEvent> RecentEvents(string stream)
{
var results = esConn.ReadStreamEventsForward(stream, 0, 20, false);
return(results.Events);
}
public void soft_deleted_stream_returns_no_stream_and_no_events_on_read()
{
const string stream = "soft_deleted_stream_returns_no_stream_and_no_events_on_read";
Assert.AreEqual(1, _conn.AppendToStream(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).NextExpectedVersion);
_conn.DeleteStream(stream, 1);
var res = _conn.ReadStreamEventsForward(stream, 0, 100, false);
Assert.AreEqual(SliceReadStatus.StreamNotFound, res.Status);
Assert.AreEqual(0, res.Events.Length);
Assert.AreEqual(1, res.LastEventNumber);
}