internal AmazonServiceResult(AmazonWebServiceRequest request, AmazonWebServiceResponse response,
Exception exception, object state)
{
this.Request = request;
this.Response = response;
this.Exception = exception;
this.State = state;
}
internal static WebServiceResponseEventArgs Create(AmazonWebServiceResponse response, IRequest request)
{
WebServiceResponseEventArgs args = new WebServiceResponseEventArgs
{
Headers = request.Headers,
Parameters = request.Parameters,
ServiceName = request.ServiceName,
Request = request.OriginalRequest,
Endpoint = request.Endpoint,
Response = response
};
return args;
}
protected virtual void ProcessResponseHandlers(AmazonWebServiceResponse response, IRequest request)
{
if (response == null)
{
throw new ArgumentNullException("response");
}
WebServiceResponseEventArgs args = WebServiceResponseEventArgs.Create(response, request);
if (AfterResponseEvent != null)
{
AfterResponseEvent(this, args);
}
}
/// <summary>
/// Ensure the request was successful.
/// </summary>
/// <param name="response">The <see cref="AmazonWebServiceResponse"/> to check.</param>
/// <exception cref="AmazonSqsTransportException">If the request was not successful.</exception>
public static void EnsureSuccess(this AmazonWebServiceResponse response)
{
if (response.Successful())
{
return;
}
const string documentationUri = "https://aws.amazon.com/blogs/developer/logging-with-the-aws-sdk-for-net/";
var statusCode = response.HttpStatusCode;
var requestId = response.ResponseMetadata.RequestId;
throw new AmazonSqsTransportException($"Received unsuccessful response ({statusCode}) from AWS endpoint.\n" +
$"See AWS SDK logs ({requestId}) for more details: {documentationUri}");
}
public static void Write(AmazonWebServiceResponse response, bool verbose) {
if (response is GetSendStatisticsResponse) {
Write((GetSendStatisticsResponse)response, verbose);
}
if (response is ListVerifiedEmailAddressesResponse) {
Write((ListVerifiedEmailAddressesResponse) response,verbose);
}
if (response is GetSendQuotaResponse) {
Write((GetSendQuotaResponse)response, verbose);
}
}
internal static WebServiceResponseEventArgs Create(AmazonWebServiceResponse response, IRequest request)
{
WebServiceResponseEventArgs args = new WebServiceResponseEventArgs
{
Headers = request.Headers,
Parameters = request.Parameters,
ServiceName = request.ServiceName,
Request = request.OriginalRequest,
Endpoint = request.Endpoint,
Response = response
};
return(args);
}
private async Task <AmazonWebServiceResponse> HandleHttpContentAsync(WebRequestState state, HttpResponseMessage httpResponse)
{
LogResponse(state.Metrics, state.Request, httpResponse.StatusCode);
AmazonWebServiceResponse response = null;
HttpClientResponseData responseData = new HttpClientResponseData(httpResponse);
UnmarshallerContext context = null;
try
{
var responseStream = await responseData.OpenResponseAsync()
.ConfigureAwait(continueOnCapturedContext: false);
context = state.Unmarshaller.CreateContext(responseData,
this.SupportResponseLogging &&
(Config.LogResponse || Config.ReadEntireResponse || AWSConfigs.ResponseLogging != ResponseLoggingOption.Never),
responseStream,
state.Metrics);
using (state.Metrics.StartEvent(Metric.ResponseUnmarshallTime))
{
response = state.Unmarshaller.Unmarshall(context);
}
context.ValidateCRC32IfAvailable();
var contentHeaders = httpResponse.Content.Headers as HttpContentHeaders;
if (contentHeaders != null)
{
response.ContentLength = contentHeaders.ContentLength.GetValueOrDefault();
response.HttpStatusCode = httpResponse.StatusCode;
}
if (response.ResponseMetadata != null)
{
state.Metrics.AddProperty(Metric.AWSRequestID, response.ResponseMetadata.RequestId);
}
LogFinishedResponse(state.Metrics, context, response.ContentLength);
return(response);
}
finally
{
if (!state.Unmarshaller.HasStreamingProperty)
{
httpResponse.Dispose();
}
ProcessResponseHandlers(response, state.Request, responseData);
}
}
protected virtual void ProcessResponseHandlers(AmazonWebServiceResponse response, IRequest request, IWebResponseData webResponseData)
{
if (request == null)
{
return;
}
if (AfterResponseEvent == null)
{
return;
}
WebServiceResponseEventArgs args = WebServiceResponseEventArgs.Create(response, request, webResponseData);
AfterResponseEvent(this, args);
}
internal static WebServiceResponseEventArgs Create(AmazonWebServiceResponse response, IRequest request, IWebResponseData webResponseData)
{
WebServiceResponseEventArgs args = new WebServiceResponseEventArgs
{
RequestHeaders = request.Headers,
Parameters = request.Parameters,
ServiceName = request.ServiceName,
Request = request.OriginalRequest,
Endpoint = request.Endpoint,
Response = response
};
args.ResponseHeaders = new Dictionary<string, string>();
var headerNames = webResponseData.GetHeaderNames();
foreach (var responseHeaderName in headerNames)
{
string responseHeaderValue = webResponseData.GetHeaderValue(responseHeaderName);
args.ResponseHeaders[responseHeaderName] = responseHeaderValue;
}
return args;
}
internal static WebServiceResponseEventArgs Create(AmazonWebServiceResponse response, IRequest request, IWebResponseData webResponseData)
{
WebServiceResponseEventArgs args = new WebServiceResponseEventArgs
{
RequestHeaders = request.Headers,
Parameters = request.Parameters,
ServiceName = request.ServiceName,
Request = request.OriginalRequest,
Endpoint = request.Endpoint,
Response = response
};
args.ResponseHeaders = new Dictionary <string, string>();
if (webResponseData != null)
{
var headerNames = webResponseData.GetHeaderNames();
foreach (var responseHeaderName in headerNames)
{
string responseHeaderValue = webResponseData.GetHeaderValue(responseHeaderName);
args.ResponseHeaders[responseHeaderName] = responseHeaderValue;
}
}
return(args);
}
protected override void ProcessResponseHandlers(AmazonWebServiceResponse response, IRequest request, IWebResponseData webResponseData)
{
base.ProcessResponseHandlers(response, request, webResponseData);
ReceiveMessageResponse receiveMessageResponse = response as ReceiveMessageResponse;
if (receiveMessageResponse != null)
{
ValidateReceiveMessage(receiveMessageResponse);
}
SendMessageResponse sendMessageResponse = response as SendMessageResponse;
SendMessageRequest sendMessageRequest = request.OriginalRequest as SendMessageRequest;
if (sendMessageRequest != null && sendMessageResponse != null)
{
ValidateSendMessage(sendMessageRequest, sendMessageResponse);
}
SendMessageBatchRequest sendMessageBatchRequest = request.OriginalRequest as SendMessageBatchRequest;
SendMessageBatchResponse sendMessageBatchResponse = response as SendMessageBatchResponse;
if (sendMessageBatchRequest != null && sendMessageBatchResponse != null)
{
ValidateSendMessageBatch(sendMessageBatchRequest, sendMessageBatchResponse);
}
}
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 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);
}
}
}
}
protected override void ProcessResponseHandlers(AmazonWebServiceResponse response, IRequest request, Runtime.Internal.Transform.IWebResponseData webResponseData)
{
base.ProcessResponseHandlers(response, request, webResponseData);
CleanupRequest(request);
}
/// <summary>
/// Checks if the request was successful.
/// </summary>
/// <param name="response">The <see cref="AmazonWebServiceResponse"/> to check.</param>
/// <returns></returns>
public static bool Successful(this AmazonWebServiceResponse response)
{
var statusCode = response.HttpStatusCode;
return(statusCode >= HttpStatusCode.OK && statusCode < HttpStatusCode.MultipleChoices);
}
private void checkResponse(AmazonWebServiceResponse response)
{
if (response.HttpStatusCode == HttpStatusCode.OK)
return;
var msg = string.Join(", ", response.ResponseMetadata.Metadata.Select(x => "{0}:{1}".F(x.Key, x.Value)).ToArray());
throw new Exception(msg);
}
/// <summary>
/// Invoked as a callback from the AmazonMainThreadDispatcher
/// Processes the http response
/// </summary>
/// <param name="state">State is expected to be AsyncResult</param>
private void ProcessHttpResponse(object state)
{
AsyncResult asyncResult = null;
try
{
asyncResult = state as AsyncResult;
AmazonWebServiceResponse response = null;
UnmarshallerContext context = null;
var responseData = asyncResult.ResponseData;
if (!String.IsNullOrEmpty(responseData.Error))
{
AmazonLogging.LogError(AmazonLogging.AmazonLoggingLevel.Critical,
asyncResult.Request.ServiceName, responseData.Error);
if (HandleWWWErrorResponse(asyncResult))
{
if (++asyncResult.RetriesAttempt >= 3)
{
if (asyncResult.Exception == null)
{
asyncResult.Exception = new AmazonServiceException("Maximum retries attempts completed");
}
// maxretries
asyncResult.IsCompleted = true;
AmazonLogging.LogException(AmazonLogging.AmazonLoggingLevel.Errors,
asyncResult.Request.ServiceName, asyncResult.Exception);
asyncResult.HandleException(asyncResult.Exception);
return;
}
else
{
// retry here
InvokeHelper(asyncResult);
return;
}
}
else
{
// non-retriable error
asyncResult.IsCompleted = true;
asyncResult.HandleException(asyncResult.Exception);
return;
}
}
else
{
using (asyncResult.Metrics.StartEvent(Metric.ResponseProcessingTime))
{
var unmarshaller = asyncResult.Unmarshaller;
LogResponse(asyncResult.Metrics, asyncResult.Request, HttpStatusCode.Accepted);
context = unmarshaller.CreateContext(responseData,
this.SupportResponseLogging &&
(Config.LogResponse || Config.ReadEntireResponse),
responseData.OpenResponse(),
asyncResult.Metrics);
try
{
using (asyncResult.Metrics.StartEvent(Metric.ResponseUnmarshallTime))
{
response = unmarshaller.Unmarshall(context);
if (responseData.IsHeaderPresent("STATUS"))
{
response.HttpStatusCode = responseData.StatusCode;
}
}
}
catch (Exception e)
{
//unmarshalling exception
asyncResult.IsCompleted = true;
asyncResult.HandleException(e);
return;
}
context.ValidateCRC32IfAvailable();
if (responseData.IsHeaderPresent(HeaderKeys.ContentLengthHeader.ToUpper()))
{
response.ContentLength = Convert.ToInt32(responseData.GetHeaderValue(HeaderKeys.ContentLengthHeader.ToUpper()));
}
else
{
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Warnings, asyncResult.Request.ServiceName, "cannot find CONTENT-LENGTH header");
}
asyncResult.ServiceResult.Response = response;
if (response.ResponseMetadata != null)
{
asyncResult.Metrics.AddProperty(Metric.AWSRequestID, response.ResponseMetadata.RequestId);
}
}
}
}
catch (Exception e)
{
AmazonLogging.LogException(AmazonLogging.AmazonLoggingLevel.Errors, asyncResult.Request.ServiceName, e);
asyncResult.HandleException(e);
}
asyncResult.IsCompleted = true;
asyncResult.InvokeCallback();
return;
}
/// <summary>
/// Performs decryption of data by getting encryption information
/// from object metadata or instruction file.
/// </summary>
/// <param name="response">AmazonWebServiceResponse on which decryption is performed</param>
/// <param name="request">IRequest</param>
/// <param name="webResponseData">IWebResponseData</param>
protected override void ProcessResponseHandlers(AmazonWebServiceResponse response, IRequest request, IWebResponseData webResponseData)
{
base.ProcessResponseHandlers(response, request, webResponseData);
var initiateMultiPartUploadRequest = request.OriginalRequest as InitiateMultipartUploadRequest;
var initiateMultiPartResponse = response as InitiateMultipartUploadResponse;
if (initiateMultiPartResponse != null)
{
byte[] envelopeKey = initiateMultiPartUploadRequest.EnvelopeKey;
byte[] iv = initiateMultiPartUploadRequest.IV;
UploadPartEncryptionContext contextForEncryption = new UploadPartEncryptionContext();
contextForEncryption.EnvelopeKey = envelopeKey;
contextForEncryption.NextIV = iv;
contextForEncryption.FirstIV = iv;
contextForEncryption.PartNumber = 0;
//Add context for encryption of next part
currentMultiPartUploadKeys.Add(initiateMultiPartResponse.UploadId, contextForEncryption);
}
var uploadPartRequest = request.OriginalRequest as UploadPartRequest;
var uploadPartResponse = response as UploadPartResponse;
if (uploadPartResponse != null)
{
string uploadID = uploadPartRequest.UploadId;
UploadPartEncryptionContext encryptedUploadedContext = null;
if (!currentMultiPartUploadKeys.TryGetValue(uploadID, out encryptedUploadedContext))
throw new AmazonS3Exception("encryption context for multi part upload not found");
if (uploadPartRequest.IsLastPart == false)
{
object stream = null;
if (!uploadPartRequest.RequestState.TryGetValue(S3CryptoStream, out stream))
throw new AmazonS3Exception("cannot retrieve S3 crypto stream from request state, hence cannot get Initialization vector for next uploadPart ");
var encryptionStream = stream as AESEncryptionUploadPartStream;
encryptedUploadedContext.NextIV = encryptionStream.InitializationVector;
}
}
var getObjectResponse = response as GetObjectResponse;
if (getObjectResponse != null)
{
if (EncryptionUtils.IsEncryptionInfoInMetadata(getObjectResponse) == true)
{
DecryptObjectUsingMetadata(getObjectResponse);
}
else
{
GetObjectResponse instructionFileResponse = null;
try
{
GetObjectRequest instructionFileRequest = EncryptionUtils.GetInstructionFileRequest(getObjectResponse);
instructionFileResponse = S3ClientForInstructionFile.GetObject(instructionFileRequest);
}
catch (AmazonServiceException ace)
{
throw new AmazonServiceException(string.Format(CultureInfo.InvariantCulture, "Unable to decrypt data for object {0} in bucket {1}",
getObjectResponse.Key, getObjectResponse.BucketName), ace);
}
if (EncryptionUtils.IsEncryptionInfoInInstructionFile(instructionFileResponse) == true)
{
DecryptObjectUsingInstructionFile(getObjectResponse, instructionFileResponse);
}
}
}
var completeMultiPartUploadRequest = request.OriginalRequest as CompleteMultipartUploadRequest;
var completeMultipartUploadResponse = response as CompleteMultipartUploadResponse;
if (completeMultipartUploadResponse != null)
{
if (amazonS3CryptoConfig.StorageMode == CryptoStorageMode.InstructionFile)
{
UploadPartEncryptionContext context = currentMultiPartUploadKeys[completeMultiPartUploadRequest.UploadId];
byte[] envelopeKey = context.EnvelopeKey;
byte[] iv = context.FirstIV;
byte[] encryptedEnvelopeKey = EncryptionUtils.EncryptEnvelopeKey(envelopeKey, this.encryptionMaterials);
EncryptionInstructions instructions = new EncryptionInstructions(EncryptionMaterials.EmptyMaterialsDescription, envelopeKey, encryptedEnvelopeKey, iv);
PutObjectRequest instructionFileRequest = EncryptionUtils.CreateInstructionFileRequest(completeMultiPartUploadRequest, instructions);
S3ClientForInstructionFile.PutObject(instructionFileRequest);
}
//Clear Context data since encryption is completed
currentMultiPartUploadKeys.Clear();
}
}
private static void EnsureSuccess(AmazonWebServiceResponse response)
{
if (!IsSuccessStatusCode((int)response.HttpStatusCode))
throw new AmazonS3Exception("Request failed");
}
