public Task <ISinkResult <T> > ProcessAsync(T t, CancellationToken ct)
{
this.Processed.Add(t);
ISinkResult <T> result = new SinkResult <T>(new[] { t });
return(Task.FromResult(result));
}
public Task <ISinkResult <T> > ProcessAsync(ICollection <T> ts, CancellationToken ct)
{
foreach (T t in ts)
{
this.Processed.Add(t);
}
ISinkResult <T> result = new SinkResult <T>(ts);
return(Task.FromResult(result));
}
public Task <ISinkResult <IMessage> > ProcessAsync(ICollection <IMessage> messages, CancellationToken token)
{
foreach (IMessage message in messages)
{
this.endpoint.Processed.Add(message);
}
ISinkResult <IMessage> result = new SinkResult <IMessage>(messages);
return(Task.FromResult(result));
}
public void TestConstructor()
{
var result1 = new SinkResult <int>(new[] { 1 }, new[] { 2 }, null);
Assert.Equal(new[] { 1 }, result1.Succeeded);
Assert.Equal(new[] { 2 }, result1.Failed);
Assert.Equal(Option.None <SendFailureDetails>(), result1.SendFailureDetails);
var result2 = new SinkResult <int>(new[] { 3 }, new[] { 4 }, new SendFailureDetails(FailureKind.InternalError, new ArgumentNullException()));
Assert.Equal(new[] { 3 }, result2.Succeeded);
Assert.Equal(new[] { 4 }, result2.Failed);
Assert.True(result2.SendFailureDetails.HasValue);
result2.SendFailureDetails.ForEach(ex => Assert.IsType <ArgumentNullException>(ex.RawException));
}
public Task <ISinkResult <IMessage> > ProcessAsync(ICollection <IMessage> messages, CancellationToken token)
{
Console.ForegroundColor = this.endpoint.color;
foreach (IMessage message in messages)
{
if (this.count % 10000 == 0)
{
Console.WriteLine(string.Format(CultureInfo.InvariantCulture, "({0}) {1}: {2}", this.count, this.endpoint, message));
}
this.count++;
}
Console.ResetColor();
ISinkResult <IMessage> result = new SinkResult <IMessage>(messages);
return(Task.FromResult(result));
}
public Task <ISinkResult <IMessage> > ProcessAsync(ICollection <IMessage> messages, CancellationToken token)
{
ISinkResult <IMessage> result;
if (messages.Count <= 1)
{
// Only fail if we have more than one message
result = new SinkResult <IMessage>(messages);
}
else
{
IMessage[] successful = messages.Take(messages.Count / 2).ToArray();
IMessage[] failed = messages.Skip(messages.Count / 2).ToArray();
result = new SinkResult <IMessage>(successful, failed, new SendFailureDetails(FailureKind.InternalError, this.endpoint.Exception));
}
return(Task.FromResult(result));
}
public Task <ISinkResult <IMessage> > ProcessAsync(ICollection <IMessage> messages, CancellationToken token)
{
ISinkResult <IMessage> result;
if (this.endpoint.Failing)
{
result = new SinkResult <IMessage>(new IMessage[0], messages, new SendFailureDetails(FailureKind.InternalError, this.endpoint.Exception));
}
else
{
foreach (IMessage message in messages)
{
this.endpoint.Processed.Add(message);
}
result = new SinkResult <IMessage>(messages);
}
return(Task.FromResult(result));
}
public Task <ISinkResult <IMessage> > ProcessAsync(ICollection <IMessage> messages, CancellationToken token)
{
ISinkResult <IMessage> result;
if (this.endpoint.CanProcess)
{
foreach (IMessage message in messages)
{
this.endpoint.Processed.Add(message);
}
result = new SinkResult <IMessage>(messages);
}
else
{
// Simulate connectivity failure and don't process any messages
result = new SinkResult <IMessage>(new IMessage[0], messages, new SendFailureDetails(FailureKind.InternalError, new Exception("endpoint failed")));
}
return(Task.FromResult(result));
}
public async Task <ISinkResult <T> > ProcessAsync(ICollection <T> ts, CancellationToken token)
{
var succeeded = new List <T>();
var failed = new List <T>();
var invalid = new List <InvalidDetails <T> >();
ICollection <T> messages = ts;
ISinkResult <T> rv;
ShouldRetry shouldRetry = this.retryPolicy.RetryStrategy.GetShouldRetry();
try
{
int i = 0;
SendFailureDetails failureDetails = null;
bool finished = false;
while (!finished)
{
token.ThrowIfCancellationRequested();
ISinkResult <T> result = await this.underlying.ProcessAsync(messages, token);
succeeded.AddRange(result.Succeeded);
invalid.AddRange(result.InvalidDetailsList);
if (result.IsSuccessful)
{
failureDetails = null;
finished = true;
}
else
{
TimeSpan retryAfter;
failureDetails = result.SendFailureDetails.OrDefault();
if (failureDetails != null && this.retryPolicy.ErrorDetectionStrategy.IsTransient(failureDetails.RawException) && shouldRetry(i, failureDetails.RawException, out retryAfter))
{
// if we should retry, set the next group of messages to send
// to the failed messages from the previous attempt
messages = result.Failed;
Preconditions.CheckRange(retryAfter.TotalMilliseconds, 0.0);
await Task.Delay(retryAfter, token);
i++;
}
else
{
// do not retry, return failed messages as failed
failed.AddRange(result.Failed);
finished = true;
}
}
}
rv = new SinkResult <T>(succeeded, failed, invalid, failureDetails);
}
catch (OperationCanceledException ex)
{
failed.AddRange(messages);
rv = new SinkResult <T>(succeeded, failed, invalid, new SendFailureDetails(FailureKind.InternalError, ex));
}
catch (Exception ex)
{
failed.AddRange(messages);
rv = new SinkResult <T>(succeeded, failed, invalid, new SendFailureDetails(FailureKind.InternalError, ex));
}
return(rv);
}
public Task <ISinkResult <T> > ProcessAsync(ICollection <T> ts, CancellationToken token)
{
ISinkResult <T> result = new SinkResult <T>(Empty, ts, new SendFailureDetails(FailureKind.InternalError, this.Exception));
return(Task.FromResult(result));
}
public Task <ISinkResult <T> > ProcessAsync(ICollection <T> ts, CancellationToken token)
{
ISinkResult <T> result = new SinkResult <T>(ts);
return(Task.FromResult(result));
}
public Task <ISinkResult <IMessage> > ProcessAsync(ICollection <IMessage> messages, CancellationToken token)
{
ISinkResult <IMessage> result = new SinkResult <IMessage>(messages);
return(Task.FromResult(result));
}
public Task <ISinkResult <IMessage> > ProcessAsync(ICollection <IMessage> messages, CancellationToken token)
{
ISinkResult <IMessage> result = new SinkResult <IMessage>(new IMessage[0], messages, new SendFailureDetails(FailureKind.InternalError, this.endpoint.Exception));
return(Task.FromResult(result));
}
