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