void getResponseCallback(IAsyncResult result)
{
AsyncResult asyncResult = result as AsyncResult;
if (asyncResult == null)
{
asyncResult = result.AsyncState as AsyncResult;
}
UnmarshallerContext context = null;
asyncResult.RequestState.GetResponseCallbackCalled = true;
bool shouldRetry = false;
AmazonWebServiceResponse response = null;
try
{
AsyncResult.AsyncRequestState state = asyncResult.RequestState;
HttpWebResponse httpResponse = null;
try
{
if (asyncResult.CompletedSynchronously)
{
httpResponse = state.WebRequest.GetResponse() as HttpWebResponse;
}
else
{
httpResponse = state.WebRequest.EndGetResponse(result) as HttpWebResponse;
}
using (asyncResult.Metrics.StartEvent(Metric.ResponseProcessingTime))
{
var unmarshaller = asyncResult.Unmarshaller;
LogResponse(asyncResult.Metrics, asyncResult.Request, httpResponse.StatusCode);
try
{
var httpResponseData = new HttpWebRequestResponseData(httpResponse);
context = unmarshaller.CreateContext(httpResponseData,
this.SupportResponseLogging &&
(Config.LogResponse || Config.ReadEntireResponse || AWSConfigs.LoggingConfig.LogResponses != ResponseLoggingOption.Never),
httpResponseData.ResponseBody.OpenResponse(),
asyncResult.Metrics);
using (asyncResult.Metrics.StartEvent(Metric.ResponseUnmarshallTime))
{
response = unmarshaller.Unmarshall(context);
}
context.ValidateCRC32IfAvailable();
response.ContentLength = httpResponse.ContentLength;
response.HttpStatusCode = httpResponse.StatusCode;
asyncResult.FinalResponse = response;
if (response.ResponseMetadata != null)
{
asyncResult.Metrics.AddProperty(Metric.AWSRequestID, response.ResponseMetadata.RequestId);
}
LogFinishedResponse(asyncResult.Metrics, context, httpResponse.ContentLength);
}
finally
{
if (!unmarshaller.HasStreamingProperty)
{
httpResponse.Close();
}
}
}
}
catch (WebException we)
{
HttpWebResponse exceptionHttpResponse = we.Response as HttpWebResponse;
// If the error is a 404 and the request is configured to supress it. Then unmarshall as much as we can.
if (exceptionHttpResponse != null &&
exceptionHttpResponse.StatusCode == HttpStatusCode.NotFound &&
asyncResult.Request.Suppress404Exceptions)
{
var unmarshaller = asyncResult.Unmarshaller;
var httpResponseData = new HttpWebRequestResponseData(exceptionHttpResponse);
UnmarshallerContext errorContext = unmarshaller.CreateContext(
httpResponseData,
Config.LogResponse || Config.ReadEntireResponse || AWSConfigs.LoggingConfig.LogResponses != ResponseLoggingOption.Never,
httpResponseData.ResponseBody.OpenResponse(),
asyncResult.Metrics);
try
{
response = unmarshaller.Unmarshall(errorContext);
response.ContentLength = exceptionHttpResponse.ContentLength;
response.HttpStatusCode = exceptionHttpResponse.StatusCode;
}
catch (Exception e)
{
logger.Debug(e, "Failed to unmarshall 404 response when it was being supressed");
}
asyncResult.FinalResponse = response;
}
else
{
if (exceptionHttpResponse != null)
{
LogResponse(asyncResult.Metrics, asyncResult.Request, exceptionHttpResponse.StatusCode);
}
else
{
asyncResult.Metrics.StopEvent(Metric.HttpRequestTime);
}
shouldRetry = HandleHttpWebErrorResponse(asyncResult, we);
}
}
catch (IOException ioe)
{
LogResponse(asyncResult.Metrics, asyncResult.Request, HttpStatusCode.Unused);
shouldRetry = HandleIOException(asyncResult, httpResponse, ioe);
if (!shouldRetry)
{
asyncResult.Exception = ioe;
}
}
if (shouldRetry)
{
asyncResult.RequestState.WebRequest.Abort();
asyncResult.RetriesAttempt++;
InvokeHelper(asyncResult);
}
else
{
LogFinalMetrics(asyncResult.Metrics);
}
}
catch (Exception e)
{
if (context != null && AWSConfigs.LoggingConfig.LogResponses == ResponseLoggingOption.OnError)
{
this.logger.Error(e, "Received response: [{0}]", context.ResponseBody);
}
asyncResult.RequestState.WebRequest.Abort();
asyncResult.Exception = e;
asyncResult.Metrics.AddProperty(Metric.Exception, e);
asyncResult.Metrics.StopEvent(Metric.ClientExecuteTime);
shouldRetry = false;
if (Config.LogMetrics)
{
logger.InfoFormat("Request metrics: {0}", asyncResult.Metrics);
}
ProcessExceptionHandlers(e, asyncResult.Request);
logger.Error(e, "Error configuring web request {0} to {1}.", asyncResult.RequestName, asyncResult.Request.Endpoint.ToString());
}
finally
{
if (!shouldRetry)
{
var responseData = context == null ? null : context.ResponseData;
ProcessResponseHandlers(response, asyncResult.Request, responseData);
asyncResult.InvokeCallback();
}
}
}
void getRequestStreamCallback(IAsyncResult result)
{
AsyncResult asyncResult = result as AsyncResult;
if (asyncResult == null)
{
asyncResult = result.AsyncState as AsyncResult;
}
asyncResult.RequestState.GetRequestStreamCallbackCalled = true;
try
{
try
{
AsyncResult.AsyncRequestState state = asyncResult.RequestState;
if (asyncResult != null &&
asyncResult.RequestState != null &&
((asyncResult.RequestState.RequestData != null && asyncResult.RequestState.RequestData.Length > 0) || asyncResult.RequestState.RequestStream != null) &&
(!asyncResult.Request.UseQueryString && (asyncResult.RequestState.WebRequest.Method == "POST" || asyncResult.RequestState.WebRequest.Method == "PUT")))
{
Stream requestStream;
if (asyncResult.CompletedSynchronously)
{
requestStream = state.WebRequest.GetRequestStream();
}
else
{
requestStream = state.WebRequest.EndGetRequestStream(result);
}
using (requestStream)
{
if (asyncResult.RequestState.RequestStream == null)
{
byte[] requestData = asyncResult.RequestState.RequestData;
asyncResult.Metrics.AddProperty(Metric.RequestSize, requestData.Length);
requestStream.Write(requestData, 0, requestData.Length);
}
else
{
var originalStream = asyncResult.RequestState.RequestStream;
var callback = asyncResult.Request.OriginalRequest.StreamUploadProgressCallback;
if (callback != null)
{
var eventStream = new EventStream(originalStream, true);
var tracker = new StreamReadTracker(this, callback, originalStream.Length, this.Config.ProgressUpdateInterval);
eventStream.OnRead += tracker.ReadProgress;
originalStream = eventStream;
}
var buffer = new byte[this.Config.BufferSize];
var inputStream = asyncResult.Request.UseChunkEncoding && asyncResult.Request.AWS4SignerResult != null
? new ChunkedUploadWrapperStream(originalStream,
Config.BufferSize,
asyncResult.Request.AWS4SignerResult)
: originalStream;
int bytesRead = 0;
int bytesToRead = buffer.Length;
while ((bytesRead = inputStream.Read(buffer, 0, bytesToRead)) > 0)
{
requestStream.Write(buffer, 0, bytesRead);
}
}
}
}
if (asyncResult.CompletedSynchronously)
{
this.getResponseCallback(asyncResult);
}
else
{
IAsyncResult httpResult = state.WebRequest.BeginGetResponse(new AsyncCallback(this.getResponseCallback), asyncResult);
if (httpResult.CompletedSynchronously)
{
if (!asyncResult.RequestState.GetResponseCallbackCalled)
{
getResponseCallback(httpResult);
}
asyncResult.SetCompletedSynchronously(true);
}
}
}
catch (WebException e)
{
asyncResult.RequestState.WebRequest.Abort();
HandleHttpWebErrorResponse(asyncResult, e);
asyncResult.RetriesAttempt++;
InvokeHelper(asyncResult);
}
catch (IOException ioe)
{
if (HandleIOException(asyncResult, null, ioe))
{
asyncResult.RetriesAttempt++;
InvokeHelper(asyncResult);
}
else
{
throw;
}
}
catch (Exception e)
{
asyncResult.RequestState.WebRequest.Abort();
asyncResult.Metrics.AddProperty(Metric.Exception, e);
asyncResult.HandleException(e);
}
}
catch (Exception exception)
{
ProcessExceptionHandlers(exception, asyncResult.Request);
// Handle WebException/IOExceptionexceptions/AmazonServiceException
// thrown after retry limit is reached.
asyncResult.HandleException(exception);
}
}
void getRequestStreamCallback(IAsyncResult result)
{
AsyncResult asyncResult;
if (result is AsyncResult)
{
asyncResult = result as AsyncResult;
}
else
{
asyncResult = result.AsyncState as AsyncResult;
}
asyncResult.RequestState.GetRequestStreamCallbackCalled = true;
try
{
AsyncResult.AsyncRequestState state = asyncResult.RequestState;
if (asyncResult != null &&
asyncResult.RequestState != null &&
((asyncResult.RequestState.RequestData != null && asyncResult.RequestState.RequestData.Length > 0) || asyncResult.RequestState.RequestStream != null) &&
(!asyncResult.Request.UseQueryString && (asyncResult.RequestState.WebRequest.Method == "POST" || asyncResult.RequestState.WebRequest.Method == "PUT")))
{
Stream requestStream;
if (asyncResult.CompletedSynchronously)
{
requestStream = state.WebRequest.GetRequestStream();
}
else
{
requestStream = state.WebRequest.EndGetRequestStream(result);
}
using (requestStream)
{
if (asyncResult.RequestState.RequestStream == null)
{
byte[] requestData = asyncResult.RequestState.RequestData;
requestStream.Write(requestData, 0, requestData.Length);
}
else
{
var callback = asyncResult.Request.OriginalRequest.StreamUploadProgressCallback;
byte[] buffer = new byte[this.config.BufferSize];
int bytesRead = 0;
long totalBytesWritten = 0;
Stream inputStream = asyncResult.RequestState.RequestStream;
while ((bytesRead = inputStream.Read(buffer, 0, buffer.Length)) > 0)
{
requestStream.Write(buffer, 0, bytesRead);
totalBytesWritten += bytesRead;
if (callback != null)
{
AWSSDKUtils.InvokeInBackground(
callback,
new StreamTransferProgressArgs(bytesRead, totalBytesWritten, inputStream.Length),
this);
}
}
}
}
}
if (asyncResult.CompletedSynchronously)
{
this.getResponseCallback(asyncResult);
}
else
{
IAsyncResult httpResult = state.WebRequest.BeginGetResponse(new AsyncCallback(this.getResponseCallback), asyncResult);
if (httpResult.CompletedSynchronously)
{
if (!asyncResult.RequestState.GetResponseCallbackCalled)
{
getResponseCallback(httpResult);
}
asyncResult.SetCompletedSynchronously(true);
}
}
}
catch (WebException e)
{
try
{
asyncResult.RequestState.WebRequest.Abort();
handleHttpWebErrorResponse(asyncResult, e);
asyncResult.RetriesAttempt++;
InvokeHelper(asyncResult);
}
catch (Exception ei)
{
asyncResult.Exception = ei;
asyncResult.SignalWaitHandle();
if (asyncResult.Callback != null)
{
asyncResult.Callback(asyncResult);
}
}
}
catch (Exception e)
{
asyncResult.RequestState.WebRequest.Abort();
asyncResult.Exception = e;
asyncResult.Metrics.AddProperty(RequestMetrics.Metric.Exception, e);
asyncResult.SignalWaitHandle();
if (asyncResult.Callback != null)
{
asyncResult.Callback(asyncResult);
}
}
}
void getResponseCallback(IAsyncResult result)
{
AsyncResult asyncResult;
if (result is AsyncResult)
{
asyncResult = result as AsyncResult;
}
else
{
asyncResult = result.AsyncState as AsyncResult;
}
UnmarshallerContext context = null;
asyncResult.RequestState.GetResponseCallbackCalled = true;
bool shouldRetry = false;
try
{
AsyncResult.AsyncRequestState state = asyncResult.RequestState;
HttpWebResponse httpResponse = null;
try
{
if (asyncResult.CompletedSynchronously)
{
httpResponse = state.WebRequest.GetResponse() as HttpWebResponse;
}
else
{
httpResponse = state.WebRequest.EndGetResponse(result) as HttpWebResponse;
}
using (asyncResult.Metrics.StartEvent(RequestMetrics.Metric.ResponseProcessingTime))
{
var unmarshaller = asyncResult.Unmarshaller;
asyncResult.Metrics.AddProperty(RequestMetrics.Metric.StatusCode, httpResponse.StatusCode);
LogResponse(asyncResult, httpResponse.StatusCode);
try
{
context = unmarshaller.CreateContext(httpResponse, config.LogResponse || config.ReadEntireResponse || AWSConfigs.ResponseLogging != ResponseLoggingOption.Never, asyncResult);
AmazonWebServiceResponse response;
using (asyncResult.Metrics.StartEvent(RequestMetrics.Metric.ResponseUnmarshallTime))
{
response = unmarshaller.Unmarshall(context);
}
context.ValidateCRC32IfAvailable();
response.ContentLength = httpResponse.ContentLength;
asyncResult.FinalResponse = response;
asyncResult.Metrics.AddProperty(RequestMetrics.Metric.AWSRequestID, response.ResponseMetadata.RequestId);
LogFinishedResponse(asyncResult, context, httpResponse.ContentLength);
ProcessResponseHandlers(response, asyncResult.Request);
}
finally
{
if (!unmarshaller.HasStreamingProperty)
{
httpResponse.Close();
}
}
}
}
catch (WebException we)
{
HttpWebResponse exceptionHttpResponse = we.Response as HttpWebResponse;
if (exceptionHttpResponse != null)
{
LogResponse(asyncResult, exceptionHttpResponse.StatusCode);
}
else
{
asyncResult.Metrics.StopEvent(RequestMetrics.Metric.HttpRequestTime);
}
shouldRetry = handleHttpWebErrorResponse(asyncResult, we);
}
catch (IOException ioe)
{
LogResponse(asyncResult, HttpStatusCode.Unused);
shouldRetry = handleIOException(asyncResult, httpResponse, ioe);
}
if (shouldRetry)
{
asyncResult.RequestState.WebRequest.Abort();
asyncResult.RetriesAttempt++;
InvokeHelper(asyncResult);
}
else
{
LogFinalMetrics(asyncResult);
}
}
catch (Exception e)
{
if (context != null && AWSConfigs.ResponseLogging == ResponseLoggingOption.OnError)
{
logger.Error(e, "Received response: [{0}]", context.ResponseBody);
}
asyncResult.RequestState.WebRequest.Abort();
asyncResult.Exception = e;
asyncResult.Metrics.AddProperty(RequestMetrics.Metric.Exception, e);
asyncResult.Metrics.StopEvent(RequestMetrics.Metric.ClientExecuteTime);
shouldRetry = false;
if (config.LogMetrics)
{
logger.InfoFormat("Request metrics: {0}", asyncResult.Metrics);
}
ProcessExceptionHandlers(e, asyncResult.Request);
logger.Error(e, "Error configuring web request {0} to {1}.", asyncResult.RequestName, asyncResult.Request.Endpoint.ToString());
}
finally
{
if (!shouldRetry)
{
asyncResult.SignalWaitHandle();
if (asyncResult.Callback != null)
{
asyncResult.Callback(asyncResult);
}
}
}
}
void getResponseCallback(IAsyncResult result)
{
AsyncResult asyncResult;
if (result is AsyncResult)
{
asyncResult = result as AsyncResult;
}
else
{
asyncResult = result.AsyncState as AsyncResult;
}
asyncResult.RequestState.GetResponseCallbackCalled = true;
bool shouldRetry = false;
try
{
AsyncResult.AsyncRequestState state = asyncResult.RequestState;
HttpWebResponse httpResponse = null;
try
{
if (asyncResult.CompletedSynchronously)
{
httpResponse = state.WebRequest.GetResponse() as HttpWebResponse;
}
else
{
httpResponse = state.WebRequest.EndGetResponse(result) as HttpWebResponse;
}
var unmarshaller = asyncResult.Unmarshaller;
LogResponse(asyncResult, httpResponse.StatusCode);
try
{
var context = unmarshaller.CreateContext(httpResponse, config.LogResponse || config.ReadEntireResponse, asyncResult);
AmazonWebServiceResponse response = unmarshaller.Unmarshall(context);
context.ValidateCRC32IfAvailable();
response.ContentLength = httpResponse.ContentLength;
asyncResult.FinalResponse = response;
LogFinishedResponse(asyncResult, context, httpResponse.ContentLength);
ProcessResponseHandlers(response, asyncResult.Request);
}
finally
{
if (!unmarshaller.HasStreamingProperty)
{
httpResponse.Close();
}
}
}
catch (WebException we)
{
HttpWebResponse exceptionHttpResponse = we.Response as HttpWebResponse;
if (exceptionHttpResponse != null)
{
LogResponse(asyncResult, exceptionHttpResponse.StatusCode);
}
shouldRetry = handleHttpWebErrorResponse(asyncResult, we);
}
catch (IOException ioe)
{
LogResponse(asyncResult, HttpStatusCode.Unused);
shouldRetry = handleIOException(asyncResult, httpResponse, ioe);
}
if (shouldRetry)
{
asyncResult.RequestState.WebRequest.Abort();
asyncResult.RetriesAttempt++;
InvokeConfiguredRequest(asyncResult);
}
}
catch (Exception e)
{
asyncResult.RequestState.WebRequest.Abort();
asyncResult.Exception = e;
shouldRetry = false;
ProcessExceptionHandlers(e, asyncResult.Request);
if (logger.IsErrorEnabled)
{
logger.Error(string.Format("Error configuring web request {0} to {1}.", asyncResult.RequestName, asyncResult.Request.Endpoint.ToString()), e);
}
}
finally
{
if (!shouldRetry)
{
asyncResult.SignalWaitHandle();
if (asyncResult.Callback != null)
{
asyncResult.Callback(asyncResult);
}
}
}
}
