protected override Task <IImmutableList <Exception> > WriteMessagesAsync(IEnumerable <AtomicWrite> messages)
{
TaskCompletionSource <IImmutableList <Exception> > promise =
new TaskCompletionSource <IImmutableList <Exception> >();
if (ChaosSupportExtensions.ShouldFail(_writeFailureRate))
{
promise.SetException(new WriteFailedException(messages));
}
else
{
try
{
foreach (var message in messages)
{
foreach (var persistent in (IEnumerable <IPersistentRepresentation>)message.Payload)
{
Add(persistent);
}
}
promise.SetResult(null);
}
catch (Exception e)
{
promise.SetException(e);
}
}
return(promise.Task);
}
public override Task <long> ReadHighestSequenceNrAsync(string persistenceId, long fromSequenceNr)
{
if (ChaosSupportExtensions.ShouldFail(_readHighestFailureRate))
{
return(Task.FromResult(0L).ContinueWith(task => { throw new ReadHighestFailedException(); return 0L; }));
}
else
{
return(Task.FromResult(HighestSequenceNr(persistenceId)));
}
}
protected override void WriteMessages(IEnumerable <IPersistentRepresentation> messages)
{
if (ChaosSupportExtensions.ShouldFail(_writeFailureRate))
{
throw new WriteFailedException(messages);
}
else
{
foreach (var message in messages)
{
Add(message);
}
}
}
public override Task <long> ReadHighestSequenceNrAsync(string persistenceId, long fromSequenceNr)
{
var promise = new TaskCompletionSource <long>();
if (ChaosSupportExtensions.ShouldFail(_readHighestFailureRate))
{
promise.SetException(new ReadHighestFailedException());
}
else
{
promise.SetResult(HighestSequenceNr(persistenceId));
}
return(promise.Task);
}
public override Task ReplayMessagesAsync(string persistenceId, long fromSequenceNr, long toSequenceNr, long max, Action <IPersistentRepresentation> replayCallback)
{
if (ChaosSupportExtensions.ShouldFail(_replayFailureRate))
{
var replays = Read(persistenceId, fromSequenceNr, toSequenceNr, max).ToArray();
var top = replays.Take(_random.Next(replays.Length + 1));
foreach (var persistentRepresentation in top)
{
replayCallback(persistentRepresentation);
}
return(Task.FromResult(0L).ContinueWith(task => { throw new ReplayFailedException(top); }));
}
else
{
foreach (var p in Read(persistenceId, fromSequenceNr, toSequenceNr, max))
{
replayCallback(p);
}
return(Task.FromResult(new object()));
}
}
public override Task ReplayMessagesAsync(IActorContext context, string persistenceId, long fromSequenceNr, long toSequenceNr, long max, Action <IPersistentRepresentation> recoveryCallback)
{
var promise = new TaskCompletionSource <object>();
if (ChaosSupportExtensions.ShouldFail(_replayFailureRate))
{
var replays = Read(persistenceId, fromSequenceNr, toSequenceNr, max).ToArray();
var top = replays.Take(_random.Next(replays.Length + 1)).ToArray();
foreach (var persistentRepresentation in top)
{
recoveryCallback(persistentRepresentation);
}
promise.SetException(new ReplayFailedException(top));
}
else
{
foreach (var p in Read(persistenceId, fromSequenceNr, toSequenceNr, max))
{
recoveryCallback(p);
}
promise.SetResult(new object());
}
return(promise.Task);
}
