internal FilterLogEventsResponse FilterLogEvents(FilterLogEventsRequest request)
{
var marshaller = new FilterLogEventsRequestMarshaller();
var unmarshaller = FilterLogEventsResponseUnmarshaller.Instance;
return(Invoke <FilterLogEventsRequest, FilterLogEventsResponse>(request, marshaller, unmarshaller));
}
public async Task FilterLogEventsTest_TwoResponses()
{
var request = new FilterLogEventsRequest();
var firstResponse = new FilterLogEventsResponse()
{
NextToken = "foo"
};
var secondResponse = new FilterLogEventsResponse()
{
NextToken = null
};
var token = new CancellationToken();
_mockClient.SetupSequence(x => x.FilterLogEventsAsync(It.IsAny <FilterLogEventsRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(firstResponse)
.ReturnsAsync(secondResponse);
var numResponses = 0;
await foreach (var desination in _mockClient.Object.Paginators.FilterLogEvents(request).Responses.WithCancellation(token))
{
numResponses += 1;
}
Assert.Equal(2, numResponses);
}
private async Task ReadRecords()
{
var request = new FilterLogEventsRequest()
{
LogGroupName = _context.LogGroupName,
StartTime = Progress.NextIterationStart.ToUnixTimeMilliseconds(),
EndTime = Progress.NextIterationEnd.ToUnixTimeMilliseconds(),
NextToken = Progress.NextToken,
FilterPattern = _context.EventFilterPattern,
LogStreamNamePrefix = _context.LogStreamNamePrefix,
LogStreamNames = _context.LogStreamNames,
Limit = _context.ReadMaxBatchSize
};
_context.Logger.Debug("Calling AWS API with input {@Request}", request);
_readResponse = await ReadRecordsWithExponentialBackoff(request);
_context.Logger.Debug("AWS API returned {HttpStatusCode} with {RecordCount} records, {ResponseSize} bytes",
_readResponse.HttpStatusCode, _readResponse.Events.Count, _readResponse.ContentLength);
if (_readResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new ApplicationException("AWS Service call did not return OK status code");
}
RecordCount = _readResponse.Events.Count;
SizeBytes = (int)_readResponse.ContentLength;
}
/// <summary>
/// Initiates the asynchronous execution of the FilterLogEvents operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the FilterLogEvents operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task <FilterLogEventsResponse> FilterLogEventsAsync(FilterLogEventsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new FilterLogEventsRequestMarshaller();
var unmarshaller = FilterLogEventsResponseUnmarshaller.Instance;
return(InvokeAsync <FilterLogEventsRequest, FilterLogEventsResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
public async Task FilterLogEventsTest__OnlyUsedOnce()
{
var request = new FilterLogEventsRequest();
var response = new FilterLogEventsResponse();
var token = new CancellationToken();
var paginator = _mockClient.Object.Paginators.FilterLogEvents(request);
_mockClient.Setup(x => x.FilterLogEventsAsync(It.IsAny <FilterLogEventsRequest>(), It.IsAny <CancellationToken>())).ReturnsAsync(response);
// Should work the first time
await LoopOverFilterLogEvents(paginator, token);
// Second time should throw an exception
await Assert.ThrowsAsync <System.InvalidOperationException>(async() => await LoopOverFilterLogEvents(paginator, token));
}
public async Task FilterLogEventsTest__CancellationToken()
{
var request = new FilterLogEventsRequest();
var firstResponse = new FilterLogEventsResponse()
{
NextToken = "foo"
};
var secondResponse = new FilterLogEventsResponse()
{
NextToken = null
};
var paginator = _mockClient.Object.Paginators.FilterLogEvents(request);
var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
tokenSource.Cancel();
_mockClient.SetupSequence(x => x.FilterLogEventsAsync(It.IsAny <FilterLogEventsRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(firstResponse)
.ReturnsAsync(secondResponse);
await Assert.ThrowsAsync <OperationCanceledException>(async() => await LoopOverFilterLogEvents(paginator, token));
}
private async Task <FilterLogEventsResponse> ReadRecordsWithExponentialBackoff(FilterLogEventsRequest request)
{
var waitRange = Timing.IterationReadCall.InitialWaitRangeMillis;
var tries = 0;
while (true)
{
var beforeRead = InstantUtils.Now;
try
{
return(await _context.AwsClient.FilterLogEventsAsync(request));
}
catch (AmazonCloudWatchLogsException e)
{
if (e.ErrorCode != "ThrottlingException")
{
throw;
}
}
finally
{
var afterRead = InstantUtils.Now;
ReadTimeMillis += (int)afterRead.Minus(beforeRead).TotalMilliseconds;
}
if (++tries > Timing.IterationReadCall.MaxNumberOfRetries)
{
throw new ApplicationException("Read from AWC CloudWatchLogs failed after too many retries");
}
_context.Logger.Debug("Read blocked by ThrottlingException for {NumRetries} times, retrying", tries);
await WaitRandom(waitRange);
waitRange *= Timing.IterationReadCall.WaitRangeMultiplier;
}
}
