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); }