public static void EnsureSuccessStatusCode(this AmazonWebServiceResponse response)
{
if ((int)response.HttpStatusCode < 200 || (int)response.HttpStatusCode > 299)
{
throw new Exception($"AmazonWebService Response validation failed. StatusCode: {response.HttpStatusCode}");
}
}
private static void EnsureSuccess(AmazonWebServiceResponse response)
{
if (!IsSuccessStatusCode((int)response.HttpStatusCode))
{
throw new AmazonS3Exception("Request failed");
}
}
public static void ThrowIfNotSuccess(this AmazonWebServiceResponse response)
{
if (response.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
throw new Exception($"Unexpected AWS response: {response.HttpStatusCode}");
}
}
private AmazonWebServiceResponse UnmarshallResponse(UnmarshallerContext context,
IRequestContext requestContext)
{
var unmarshaller = requestContext.Unmarshaller;
AmazonWebServiceResponse response = null;
using (requestContext.Metrics.StartEvent(Metric.ResponseUnmarshallTime))
{
response = unmarshaller.UnmarshallResponse(context);
}
requestContext.Metrics.AddProperty(Metric.StatusCode, response.HttpStatusCode);
requestContext.Metrics.AddProperty(Metric.BytesProcessed, response.ContentLength);
if (response.ResponseMetadata != null)
{
requestContext.Metrics.AddProperty(Metric.AWSRequestID, response.ResponseMetadata.RequestId);
}
var logResponseBody = _supportsResponseLogging && (requestContext.ClientConfig.LogResponse ||
AWSConfigs.LoggingConfig.LogResponses == ResponseLoggingOption.Always);
if (logResponseBody)
{
this.Logger.DebugFormat("Received response: [{0}]", context.ResponseBody);
}
context.ValidateCRC32IfAvailable();
return(response);
}
public static bool DoesQueueExists(this AmazonWebServiceResponse response)
{
var statusCode = response.HttpStatusCode;
var requestId = response.ResponseMetadata.RequestId;
return(statusCode >= HttpStatusCode.OK && statusCode < HttpStatusCode.MultipleChoices);
}
/// <summary>
/// Ensure Every Response Will Have Expected HttpStatusCode
/// </summary>
/// <param name="response">Actual Response</param>
/// <param name="validHttpStatusCode">Expected Status Code</param>
private void EnsureValidResponse(AmazonWebServiceResponse actualResponse, HttpStatusCode expectedHttpStatusCode)
{
if (actualResponse.HttpStatusCode != expectedHttpStatusCode)
{
throw new Exception("Http Status Codes Aren't Consistent");
}
}
public override AmazonWebServiceResponse Unmarshall(UnmarshallerContext input)
{
XmlUnmarshallerContext context = input as XmlUnmarshallerContext;
if (context == null)
{
throw new InvalidOperationException("Unsupported UnmarshallerContext");
}
AmazonWebServiceResponse response = this.Unmarshall(context);
if (context.ResponseData.IsHeaderPresent(HeaderKeys.RequestIdHeader) &&
!string.IsNullOrEmpty(context.ResponseData.GetHeaderValue(HeaderKeys.RequestIdHeader)))
{
if (response.ResponseMetadata == null)
{
response.ResponseMetadata = new ResponseMetadata();
}
response.ResponseMetadata.RequestId = context.ResponseData.GetHeaderValue(HeaderKeys.RequestIdHeader);
}
else if (context.ResponseData.IsHeaderPresent(HeaderKeys.XAmzRequestIdHeader) &&
!string.IsNullOrEmpty(context.ResponseData.GetHeaderValue(HeaderKeys.XAmzRequestIdHeader)))
{
if (response.ResponseMetadata == null)
{
response.ResponseMetadata = new ResponseMetadata();
}
response.ResponseMetadata.RequestId = context.ResponseData.GetHeaderValue(HeaderKeys.XAmzRequestIdHeader);
}
return(response);
}
private S3WebResponse CompleteRequest(AmazonWebServiceResponse response)
{
switch (m_MethodInfo.Operation)
{
case S3Operation.GetObject:
return(new S3ObjectWebResponse <GetObjectResponse>(response));
case S3Operation.ListObject:
return(new S3ObjectWebResponse <ListObjectsResponse>(response));
case S3Operation.ListBuckets:
return(new S3ObjectWebResponse <ListBucketsResponse>(response));
case S3Operation.PutBucket:
return(new S3ObjectWebResponse <PutBucketResponse>(response));
case S3Operation.PutObject:
return(new S3ObjectWebResponse <PutObjectResponse>(response));
case S3Operation.DeleteObject:
return(new S3ObjectWebResponse <DeleteObjectResponse>(response));
case S3Operation.RemoveBucket:
return(new S3ObjectWebResponse <DeleteBucketResponse>(response));
default:
throw new NotSupportedException("S3 operation " + m_MethodInfo.Operation + " is not supported");
}
}
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);
}
}
public override AmazonWebServiceResponse Unmarshall(UnmarshallerContext input)
{
XmlUnmarshallerContext xmlUnmarshallerContext = input as XmlUnmarshallerContext;
if (xmlUnmarshallerContext == null)
{
throw new InvalidOperationException("Unsupported UnmarshallerContext");
}
AmazonWebServiceResponse amazonWebServiceResponse = Unmarshall(xmlUnmarshallerContext);
if (xmlUnmarshallerContext.ResponseData.IsHeaderPresent("x-amzn-RequestId") && !string.IsNullOrEmpty(xmlUnmarshallerContext.ResponseData.GetHeaderValue("x-amzn-RequestId")))
{
if (amazonWebServiceResponse.ResponseMetadata == null)
{
amazonWebServiceResponse.ResponseMetadata = new ResponseMetadata();
}
amazonWebServiceResponse.ResponseMetadata.RequestId = xmlUnmarshallerContext.ResponseData.GetHeaderValue("x-amzn-RequestId");
}
else if (xmlUnmarshallerContext.ResponseData.IsHeaderPresent("x-amz-request-id") && !string.IsNullOrEmpty(xmlUnmarshallerContext.ResponseData.GetHeaderValue("x-amz-request-id")))
{
if (amazonWebServiceResponse.ResponseMetadata == null)
{
amazonWebServiceResponse.ResponseMetadata = new ResponseMetadata();
}
amazonWebServiceResponse.ResponseMetadata.RequestId = xmlUnmarshallerContext.ResponseData.GetHeaderValue("x-amz-request-id");
}
return(amazonWebServiceResponse);
}
private AmazonWebServiceResponse UnmarshallResponse(UnmarshallerContext context,
IRequestContext requestContext)
{
try
{
var unmarshaller = requestContext.Unmarshaller;
AmazonWebServiceResponse response = null;
using (requestContext.Metrics.StartEvent(Metric.ResponseUnmarshallTime))
{
response = unmarshaller.UnmarshallResponse(context);
}
requestContext.Metrics.AddProperty(Metric.StatusCode, response.HttpStatusCode);
requestContext.Metrics.AddProperty(Metric.BytesProcessed, response.ContentLength);
if (response.ResponseMetadata != null)
{
requestContext.Metrics.AddProperty(Metric.AWSRequestID, response.ResponseMetadata.RequestId);
}
context.ValidateCRC32IfAvailable();
return(response);
}
finally
{
var logResponseBody = ShouldLogResponseBody(_supportsResponseLogging, requestContext);
if (logResponseBody)
{
this.Logger.DebugFormat("Received response (truncated to {0} bytes): [{1}]",
AWSConfigs.LoggingConfig.LogResponsesSizeLimit,
context.ResponseBody);
}
}
}
private static string CreateMetaString(AmazonWebServiceResponse response)
{
var meta = response.ResponseMetadata.Metadata.StringFormat();
var data = $"Status Code:{response.HttpStatusCode} Meta:{meta}";
return(data);
}
public static void EnsureSuccess(this AmazonWebServiceResponse response)
{
if (!response.IsSuccess())
{
throw new OperationFailedException <AmazonWebServiceResponse>(
"Http request not OK", response);
}
}
public void AddLogRequest(List <InputLogEvent> events)
{
var putLogEventsRequest = new PutLogEventsRequest(
_logGroup,
_logStream,
events);
var logstream = _client.DescribeLogStreams
(
new DescribeLogStreamsRequest(_logGroup)
)
.LogStreams
.Where(x => x.LogStreamName == _logStream)
.ToList();
if (!logstream.Any())
{
throw new ApplicationException("LogStream doesn't exist");
}
_nextSequence = logstream.Single().UploadSequenceToken;
lock (LockObject)
{
AmazonWebServiceResponse ret = null;
for (var i = 0; i < 10 && ret == null; i++)
{
try
{
putLogEventsRequest.SequenceToken = _nextSequence;
var putLogEventsResponse = _client.PutLogEvents(putLogEventsRequest);
if (putLogEventsResponse == null)
{
continue;
}
_nextSequence = putLogEventsResponse.NextSequenceToken;
ret = putLogEventsResponse;
}
catch (OperationAbortedException)
{
}
catch (DataAlreadyAcceptedException e)
{
var matchCollection = Regex.Matches(e.Message, @"[0-9]{20,}");
_nextSequence = matchCollection.Count > 0 ? matchCollection[0].Value : null;
}
catch (InvalidSequenceTokenException e)
{
var matchCollection = Regex.Matches(e.Message, @"[0-9]{20,}");
_nextSequence = matchCollection.Count > 0 ? matchCollection[0].Value : null;
}
}
}
}
public static HttpStatusCode EnsureSuccessStatusCode(this AmazonWebServiceResponse amazonWebServiceResponse)
{
if (amazonWebServiceResponse?.HttpStatusCode == null)
{
throw new ArgumentNullException(nameof(amazonWebServiceResponse));
}
return(amazonWebServiceResponse.HttpStatusCode.EnsureSuccessStatusCode());
}
public void Verify_Should_Raise_Exception()
{
// arrange
var response = new AmazonWebServiceResponse {
HttpStatusCode = System.Net.HttpStatusCode.BadGateway
};
// act
Assert.Throws <AWSFailedRequestException>(() => response.Verify());
}
/// <summary>
/// Sets metadata from response acquired from Amazon S3 storage to S3ObjectInfo.
/// </summary>
/// <param name="obj">Representation of the file on Amazon S3 storage.</param>
/// <param name="eTag">ETag assigned to file uploaded to Amazon S3 storage.</param>
/// <param name="response">Response acquired from Amazon S3 storage after uploading file.</param>
/// <param name="length">
/// Amazon S3 storage does not return length of the uploaded file in <paramref name="response" />,
/// if the file was uploaded via multipart upload. In case of multipart upload is <see cref="P:CMS.AmazonStorage.IS3ObjectInfo.Length" />
/// of the <paramref name="obj" /> set via this parameter.
/// </param>
private void SetS3ObjectMetadaFromResponse(IS3ObjectInfo obj, string eTag, AmazonWebServiceResponse response, long length)
{
long num = ValidationHelper.GetLong(response.ContentLength, 0L);
if (num == 0L)
{
num = length;
}
obj.ETag = eTag;
obj.Length = num;
}
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);
}
public static void CopyResponse(ServiceResponse serviceResponse, AmazonWebServiceResponse amazonResponse)
{
serviceResponse.ContentLength = amazonResponse.ContentLength;
serviceResponse.HttpStatusCode = amazonResponse.HttpStatusCode;
var metadata = new ServiceResponseMetadata();
metadata.Metadata = amazonResponse.ResponseMetadata.Metadata;
metadata.RequestId = amazonResponse.ResponseMetadata.RequestId;
serviceResponse.ResponseMetadata = metadata;
}
public static AmazonWebServiceException CreateAmazonExceptionFromResponse(this AmazonWebServiceResponse amazonWebServiceResponse, Exception exception = null)
{
var jArray = JArray.FromObject(amazonWebServiceResponse.ResponseMetadata.Metadata.ToList());
if (exception == null)
{
return(new AmazonWebServiceException($"Http status code was {amazonWebServiceResponse.HttpStatusCode}. Reponse details: {jArray.ToString(Formatting.Indented)}"));
}
return(new AmazonWebServiceException($"Http status code was {amazonWebServiceResponse.HttpStatusCode}. Reponse details: {jArray.ToString(Formatting.Indented)}", exception));
}
public void Verified_Should_Return_Same_Response_Object()
{
// arrange
var response = new AmazonWebServiceResponse {
HttpStatusCode = System.Net.HttpStatusCode.OK
};
// act
var result = response.Verify("some name");
// assert
Assert.Same(response, result);
}
/// <summary>
/// Verifies the AWS service response is successful
/// </summary>
/// <param name="queue">queue name</param>
/// <param name="action">action</param>
/// <param name="response">AWS response object</param>
protected static void VerifyActionResponse(string queue, string action, AmazonWebServiceResponse response)
{
response = Arguments.EnsureNotNull(response, nameof(response));
if (IsSuccess(response))
{
return;
}
var meta = CreateMetaString(response);
throw new InvalidOperationException($"action:{action} Queue:{queue} {meta}");
}
public void IsSuccessful_Should_Return_False()
{
// arrange
var response = new AmazonWebServiceResponse {
HttpStatusCode = System.Net.HttpStatusCode.Ambiguous
};
// act
var result = response.IsSuccessful();
// assert
Assert.False(result);
}
public static void ThrowIfUnsuccessful(this AmazonWebServiceResponse amazonWebServiceResponse)
{
if (amazonWebServiceResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new AmazonServiceException
(
message: "Failed message from amazon web services",
errorType: ErrorType.Unknown,
errorCode: null,
requestId: amazonWebServiceResponse.ResponseMetadata.RequestId,
statusCode: amazonWebServiceResponse.HttpStatusCode
);
}
}
void EnsureSuccessfulResponse(AmazonWebServiceResponse response)
{
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;
if (statusCode >= HttpStatusCode.OK && statusCode < HttpStatusCode.MultipleChoices)
{
return;
}
throw new AmazonSqsTransportException($"Received unsuccessful response ({statusCode}) from AWS endpoint. See AWS SDK logs ({requestId}) for more details: {documentationUri}");
}
public override AmazonWebServiceResponse Unmarshall(UnmarshallerContext input)
{
AmazonWebServiceResponse amazonWebServiceResponse = base.Unmarshall(input);
if (amazonWebServiceResponse.ResponseMetadata == null)
{
amazonWebServiceResponse.ResponseMetadata = new ResponseMetadata();
}
EC2UnmarshallerContext eC2UnmarshallerContext = input as EC2UnmarshallerContext;
if (eC2UnmarshallerContext != null && !string.IsNullOrEmpty(eC2UnmarshallerContext.RequestId))
{
amazonWebServiceResponse.ResponseMetadata.RequestId = eC2UnmarshallerContext.RequestId;
}
return(amazonWebServiceResponse);
}
public override AmazonWebServiceResponse Unmarshall(UnmarshallerContext input)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
AmazonWebServiceResponse val = this.Unmarshall(input);
if (val.get_ResponseMetadata() == null)
{
val.set_ResponseMetadata(new ResponseMetadata());
}
val.get_ResponseMetadata().get_Metadata().Add("x-amz-id-2", input.get_ResponseData().GetHeaderValue("x-amz-id-2"));
if (input.get_ResponseData().IsHeaderPresent("X-Amz-Cf-Id"))
{
val.get_ResponseMetadata().get_Metadata().Add("X-Amz-Cf-Id", input.get_ResponseData().GetHeaderValue("X-Amz-Cf-Id"));
}
return(val);
}
public CloudPlatformResponse DeleteBlobs(CloudPlatformRequest request)
{
var blobs = (IEnumerable <S3Object>)ListBlobs(request).Data;
AmazonWebServiceResponse response = null;
const int deleteLimit = 1000;
if (blobs.Any())
{
using (var client = new AmazonS3Client(new AmazonS3Config()))
{
try
{
var keys = blobs.Select(blob => new KeyVersion {
Key = blob.Key
}).ToList();
int num = keys.Count;
do
{
Console.WriteLine("Deleting Blobs - Remaining: {0}", num);
num -= (num < deleteLimit ? num : deleteLimit);
var takenKeys = keys.Take(deleteLimit).ToList();
response = client.DeleteObjects(new DeleteObjectsRequest()
{
BucketName = request.Source,
Objects = takenKeys
});
keys = keys.Except(takenKeys).ToList();
} while (num > 0);
}
catch (DeleteObjectsException e)
{
DeleteObjectsResponse errorResponse = e.Response;
foreach (DeleteError deleteError in errorResponse.DeleteErrors)
{
Console.WriteLine("Error deleting item " + deleteError.Key);
Console.WriteLine(" Code - " + deleteError.Code);
Console.WriteLine(" Message - " + deleteError.Message);
}
}
}
}
return(AwsCloudPlatformResponse.PopulateFrom(response));
}
public override AmazonWebServiceResponse Unmarshall(UnmarshallerContext input)
{
XmlUnmarshallerContext context = input as XmlUnmarshallerContext;
if (context == null)
{
throw new ArgumentOutOfRangeException("Unsupported UnmarshallerContext");
}
AmazonWebServiceResponse response = this.Unmarshall(context);
if (context.Headers[AWSSDKUtils.RequestIdHeader] != null)
{
response.ResponseMetadata = new ResponseMetadata();
response.ResponseMetadata.RequestId = context.Headers[AWSSDKUtils.RequestIdHeader];
}
return(response);
}
/// <summary>
/// Send a request to EMR service to terminate job
/// </summary>
/// <param name="emrClient">EMR Client to make requests to the Amazon EMR Service</param>
/// <param name="settings">Settings to replace placeholders</param>
/// <param name="jobFlowId">Existing jobflow Id, can be null for the new job.</param>
/// <returns>JobFlow Id, if request failed -> returns null</returns>
public override async Task <string> SendAsync(IAmazonElasticMapReduce emrClient, IBuilderSettings settings, string jobFlowId)
{
SetTerminationProtectionRequest setTerminationProtectionRequest = new SetTerminationProtectionRequest();
setTerminationProtectionRequest.JobFlowIds = new List <string> {
jobFlowId
};
setTerminationProtectionRequest.TerminationProtected = false;
AmazonWebServiceResponse response = await emrClient.SetTerminationProtectionAsync(setTerminationProtectionRequest);
TerminateJobFlowsRequest terminateJobRequest = new TerminateJobFlowsRequest();
terminateJobRequest.JobFlowIds = new List <string> {
jobFlowId
};
response = await emrClient.TerminateJobFlowsAsync(terminateJobRequest);
return(this.IsOk(response) ? jobFlowId : null);
}
