public void ReceiveResponses(ProcessRequestsAsyncCompletedArgs args, Response[] tempResponseArray, Request[] requestsToSendAsArray)
{
if (args == null)
{
responseReceivedCallback(new ReceivedResponses(tempResponseArray, keyToResultPositions));
}
else
{
if (HasException(args))
{
HandleException(args);
}
else
{
var disposable = responseReceivedCallback.Target as Disposable;
if (disposable == null || !disposable.IsDisposed)
{
var receivedResponses = args.Result;
AddCacheableResponsesToCache(receivedResponses, requestsToSendAsArray);
PutReceivedResponsesInTempResponseArray(tempResponseArray, receivedResponses);
responseReceivedCallback(new ReceivedResponses(tempResponseArray, keyToResultPositions));
}
}
}
}
private static bool HasException(ProcessRequestsAsyncCompletedArgs args)
{
if (args.Error == null)
{
return(args.Result.Any(r => r.Exception != null));
}
return(true);
}
private static ExceptionType GetExceptionType(ProcessRequestsAsyncCompletedArgs args)
{
if (args.Error == null)
{
var responseWithException = GetFirstException(args.Result);
if (responseWithException != null)
{
return(responseWithException.ExceptionType);
}
return(ExceptionType.Unknown);
}
return(ExceptionType.Unknown);
}
private static ExceptionInfo GetException(ProcessRequestsAsyncCompletedArgs args)
{
if (args.Error == null)
{
var responseWithException = GetFirstException(args.Result);
if (responseWithException != null)
{
return(responseWithException.Exception);
}
return(null);
}
return(new ExceptionInfo(args.Error));
}
/// <summary>
/// Called when [process requests completed].
/// </summary>
/// <param name="processRequestsAsyncCompletedArgs">The process requests async completed args.</param>
/// <param name="responseReciever">The response reciever.</param>
/// <param name="tempResponseArray">The temp response array.</param>
/// <param name="requestsToSendAsArray">The requests to send as array.</param>
public override void OnProcessRequestsCompleted(
ProcessRequestsAsyncCompletedArgs processRequestsAsyncCompletedArgs,
ResponseReceiver responseReciever,
Response[] tempResponseArray,
Request[] requestsToSendAsArray )
{
base.OnProcessRequestsCompleted ( processRequestsAsyncCompletedArgs, responseReciever, tempResponseArray, requestsToSendAsArray );
var requestEndTime = DateTime.Now;
var timespan = requestEndTime - _requestStartTime;
var requestString = GetRequestString ( requestsToSendAsArray );
Logger.Debug (
"Response received for the following agatha batch: [{0}]. Elapsed milliseconds ({1})", requestString, timespan.TotalMilliseconds );
}
private void HandleException(ProcessRequestsAsyncCompletedArgs args)
{
var disposable = responseReceivedCallback.Target as Disposable;
if (disposable == null || !disposable.IsDisposed)
{
var exception = GetException(args);
if (exceptionOccurredCallback != null)
{
exceptionOccurredCallback(exception);
}
else if (exceptionAndTypeOccuredCallback != null)
{
var exceptionType = GetExceptionType(args);
exceptionAndTypeOccuredCallback(exception, exceptionType);
}
else
{
responseReceivedCallback(new ReceivedResponses(args.Result, keyToResultPositions));
}
}
}
public virtual void OnProcessRequestsCompleted(ProcessRequestsAsyncCompletedArgs args, ResponseReceiver responseReciever,
Response[] tempResponseArray, Request[] requestsToSendAsArray)
{
Dispose();
responseReciever.ReceiveResponses(args, tempResponseArray, requestsToSendAsArray);
}
protected override void Act()
{
lastProcessRequestInput = input;
lastProcessRequestsThrewException = false;
output = null;
input.Stub(input.requestResponsePair);
asyncRequestProcessor.ProcessRequestsAsync(input.requestResponsePair.Item1, args => output = args);
// this uglyness is only here because of the async stuff
int counter = 0;
while (output == null)
{
if (++counter == 20)
{
throw new InvalidOperationException("time out... the callback should've been called already");
}
Thread.Sleep(10);
}
}
