public void read_stream_backward_respects_max_count()
{
var res = _connection.ReadStreamEventsBackward(Stream, -1, 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.Reverse().Select(x => x.Event.EventId).ToArray());
}
private static StreamEventsSlice ReadStreamEventsBackwards(this IEventStoreConnection connection, string streamName, int lastEventNumber)
{
return(connection.ReadStreamEventsBackward(
streamName,
lastEventNumber,
PageSize, false,
EventStoreCredentials.Default));
}
public IEnumerable <MeasurementReadAveragePerDay> GetValues(string deviceStreamName)
{
var projectionResultStream = "MeasurementAverageDay-" + deviceStreamName;
return(_connection.ReadStreamEventsBackward <MeasurementAverageDay>(projectionResultStream)
.Select(e => new MeasurementReadAveragePerDay(e.Timeslot, e.Average))
.ToList());
}
public void read_stream_backward_respects_truncatebefore()
{
const string stream = "read_stream_backward_respects_truncatebefore";
_connection.AppendToStream(stream, ExpectedVersion.EmptyStream, _testEvents);
_connection.SetStreamMetadata(stream, ExpectedVersion.EmptyStream, StreamMetadata.Build().SetTruncateBefore(2));
var res = _connection.ReadStreamEventsBackward(stream, -1, 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.Reverse().Select(x => x.Event.EventId).ToArray());
}
protected void AssertStreamTail(string streamId, params string[] events)
{
#if DEBUG
var result = _conn.ReadStreamEventsBackward(streamId, -1, events.Length, true, _admin);
switch (result.Status)
{
case SliceReadStatus.StreamDeleted:
Assert.Fail("Stream '{0}' is deleted", streamId);
break;
case SliceReadStatus.StreamNotFound:
Assert.Fail("Stream '{0}' does not exist", streamId);
break;
case SliceReadStatus.Success:
var resultEventsReversed = result.Events.Reverse().ToArray();
if (resultEventsReversed.Length < events.Length)
{
DumpFailed("Stream does not contain enough events", streamId, events, result.Events);
}
else
{
for (var index = 0; index < events.Length; index++)
{
var parts = events[index].Split(new char[] { ':' }, 2);
var eventType = parts[0];
var eventData = parts[1];
if (resultEventsReversed[index].Event.EventType != eventType)
{
DumpFailed("Invalid event type", streamId, events, resultEventsReversed);
}
else
if (resultEventsReversed[index].Event.DebugDataView != eventData)
{
DumpFailed("Invalid event body", streamId, events, resultEventsReversed);
}
}
}
break;
}
#endif
}
public T GetLatestSnapshot <T>(string streamName) where T : class
{
var stream = SnapshotStreamNameFor(streamName);
var amountToFetch = 1; // just the latest one
var ev = esConn.ReadStreamEventsBackward(stream, StreamPosition.End, amountToFetch, false);
if (ev.Events.Any())
{
return((T)RebuildEvent(ev.Events.Single()));
}
else
{
return(null);
}
}
private void UpgradeProjectionStream(string projectionStream)
{
Log("Reading the last event from the {0}", projectionStream);
var lastProjectionVersion = _connection.ReadStreamEventsBackward(
projectionStream, -1, 1, false, _credentials);
if (lastProjectionVersion.Events.Length > 0)
{
Log("Loaded the last event from the {0} stream", projectionStream);
var projectionDefinition = lastProjectionVersion.Events[0].Event;
Log("The last event type is: {0}", projectionDefinition.EventType);
if (projectionDefinition.EventType == ProjectionUpdatedOld)
{
Log("The old style projection definition event found");
if (!_runUpgrade)
{
Log(
"*** Skipping projection definition stream {0} upgrade. Run with --upgrade option to upgrade",
projectionStream);
_upgradeRequired = true;
return;
}
Log("Writing new projection definition event to {0}", projectionStream);
_connection.AppendToStream(
projectionStream, projectionDefinition.EventNumber, _credentials,
new EventData(
Guid.NewGuid(), ProjectionUpdatedNew, true, projectionDefinition.Data,
projectionDefinition.Metadata));
Log("New projection definition has been written to {0}", projectionStream);
}
}
else
{
Log("The {0} projection definition stream is empty", projectionStream);
}
}
private TAggregate LoadFromSnapshot(Guid id, int version)
{
var streamName = _aggregateIdToSnapshotStreamName(typeof(TAggregate), id);
var sliceStart = StreamPosition.End;
var sliceCount = ReadPageSize;
StreamEventsSlice currentSlice;
do
{
currentSlice = _eventStoreConnection.ReadStreamEventsBackward(streamName, sliceStart, sliceCount, false);
if (currentSlice.Status == SliceReadStatus.StreamNotFound)
{
return(null);
}
if (currentSlice.Status == SliceReadStatus.StreamDeleted)
{
throw new AggregateDeletedException(id, typeof(TAggregate));
}
sliceStart = currentSlice.NextEventNumber;
foreach (var resolvedEvent in currentSlice.Events)
{
var aggregate = DeserializeObject <TAggregate>(resolvedEvent.OriginalEvent.Metadata, resolvedEvent.OriginalEvent.Data);
if (aggregate.Version <= version)
{
return(aggregate);
}
}
} while (!currentSlice.IsEndOfStream);
return(null);
}
protected void ReadStreamBackward(string streamId, string login, string password)
{
Connection.ReadStreamEventsBackward(streamId, 0, 1, false,
login == null && password == null ? null : new UserCredentials(login, password));
}
