/**
* Handles a successful response from a service call by unmarshalling the results using the
* specified response handler.
*
* @param <T> The type of object expected in the response.
* @param request The original request that generated the response being handled.
* @param responseHandler The response unmarshaller used to interpret the contents of the
* response.
* @param method The HTTP method that was invoked, and contains the contents of the response.
* @param executionContext Extra state information about the request currently being executed.
* @return The contents of the response, unmarshalled using the specified response handler.
* @throws IOException If any problems were encountered reading the response contents from the
* HTTP method object.
*/
private <T> T handleResponse(
Request<?> request,
HttpResponseHandler<AmazonWebServiceResponse<T>> responseHandler,
HttpRequestBase method,
org.apache.http.HttpResponse apacheHttpResponse,
ExecutionContext executionContext)
throws IOException {
HttpResponse httpResponse = createResponse(method, request, apacheHttpResponse);
if (responseHandler.needsConnectionLeftOpen() && method instanceof HttpEntityEnclosingRequest) {
HttpEntityEnclosingRequest httpEntityEnclosingRequest = (HttpEntityEnclosingRequest) method;
httpResponse.setContent(new HttpMethodReleaseInputStream(httpEntityEnclosingRequest));
}
try {
CountingInputStream countingInputStream = null;
if (System.getProperty(PROFILING_SYSTEM_PROPERTY) != null) {
countingInputStream = new CountingInputStream(httpResponse.getContent());
httpResponse.setContent(countingInputStream);
}
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ResponseProcessingTime.name());
AmazonWebServiceResponse<? extends T> awsResponse = responseHandler.handle(httpResponse);
awsRequestMetrics.endEvent(Field.ResponseProcessingTime.name());
if (countingInputStream != null) {
awsRequestMetrics.setCounter(
Field.BytesProcessed.name(), countingInputStream.getByteCount());
}
if (awsResponse == null) throw new RuntimeException("Unable to unmarshall response metadata");
responseMetadataCache.add(request.getOriginalRequest(), awsResponse.getResponseMetadata());
if (requestLog.isDebugEnabled()) {
requestLog.debug(
"Received successful response: "
+ apacheHttpResponse.getStatusLine().getStatusCode()
+ ", AWS Request ID: "
+ awsResponse.getRequestId());
}
awsRequestMetrics.addProperty(Field.AWSRequestID.name(), awsResponse.getRequestId());
return awsResponse.getResult();
} catch (CRC32MismatchException e) {
throw e;
} catch (Exception e) {
String errorMessage = "Unable to unmarshall response (" + e.getMessage() + ")";
throw new AmazonClientException(errorMessage, e);
}
}
/**
* Internal method to execute the HTTP method given.
*
* @see AmazonHttpClient#execute(Request, HttpResponseHandler, HttpResponseHandler)
* @see AmazonHttpClient#execute(Request, HttpResponseHandler, HttpResponseHandler,
* ExecutionContext)
*/
private <T extends Object> T executeHelper(
Request<?> request,
HttpResponseHandler<AmazonWebServiceResponse<T>> responseHandler,
HttpResponseHandler<AmazonServiceException> errorResponseHandler,
ExecutionContext executionContext)
throws AmazonClientException, AmazonServiceException {
/*
* Depending on which response handler we end up choosing to handle the
* HTTP response, it might require us to leave the underlying HTTP
* connection open, depending on whether or not it reads the complete
* HTTP response stream from the HTTP connection, or if delays reading
* any of the content until after a response is returned to the caller.
*/
boolean leaveHttpConnectionOpen = false;
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
/* add the service endpoint to the logs. You can infer service name from service endpoint */
awsRequestMetrics.addProperty(Field.ServiceName.name(), request.getServiceName());
awsRequestMetrics.addProperty(Field.ServiceEndpoint.name(), request.getEndpoint());
// Apply whatever request options we know how to handle, such as user-agent.
applyRequestData(request);
int retryCount = 0;
URI redirectedURI = null;
HttpEntity entity = null;
AmazonServiceException exception = null;
// Make a copy of the original request params and headers so that we can
// permute it in this loop and start over with the original every time.
Map<String, String> originalParameters = new HashMap<String, String>();
originalParameters.putAll(request.getParameters());
Map<String, String> originalHeaders = new HashMap<String, String>();
originalHeaders.putAll(request.getHeaders());
while (true) {
awsRequestMetrics.setCounter(Field.AttemptCount.name(), retryCount + 1);
if (retryCount > 0) {
request.setParameters(originalParameters);
request.setHeaders(originalHeaders);
}
HttpRequestBase httpRequest = null;
org.apache.http.HttpResponse response = null;
try {
// Sign the request if a signer was provided
if (executionContext.getSigner() != null && executionContext.getCredentials() != null) {
awsRequestMetrics.startEvent(Field.RequestSigningTime.name());
executionContext.getSigner().sign(request, executionContext.getCredentials());
awsRequestMetrics.endEvent(Field.RequestSigningTime.name());
}
if (requestLog.isDebugEnabled()) {
requestLog.debug("Sending Request: " + request.toString());
}
httpRequest =
httpRequestFactory.createHttpRequest(request, config, entity, executionContext);
if (httpRequest instanceof HttpEntityEnclosingRequest) {
entity = ((HttpEntityEnclosingRequest) httpRequest).getEntity();
}
if (redirectedURI != null) {
httpRequest.setURI(redirectedURI);
}
if (retryCount > 0) {
awsRequestMetrics.startEvent(Field.RetryPauseTime.name());
pauseExponentially(retryCount, exception, executionContext.getCustomBackoffStrategy());
awsRequestMetrics.endEvent(Field.RetryPauseTime.name());
}
if (entity != null) {
InputStream content = entity.getContent();
if (retryCount > 0) {
if (content.markSupported()) {
content.reset();
content.mark(-1);
}
} else {
if (content.markSupported()) {
content.mark(-1);
}
}
}
exception = null;
awsRequestMetrics.startEvent(Field.HttpRequestTime.name());
response = httpClient.execute(httpRequest);
awsRequestMetrics.endEvent(Field.HttpRequestTime.name());
if (isRequestSuccessful(response)) {
awsRequestMetrics.addProperty(
Field.StatusCode.name(), response.getStatusLine().getStatusCode());
/*
* If we get back any 2xx status code, then we know we should
* treat the service call as successful.
*/
leaveHttpConnectionOpen = responseHandler.needsConnectionLeftOpen();
return handleResponse(request, responseHandler, httpRequest, response, executionContext);
} else if (isTemporaryRedirect(response)) {
/*
* S3 sends 307 Temporary Redirects if you try to delete an
* EU bucket from the US endpoint. If we get a 307, we'll
* point the HTTP method to the redirected location, and let
* the next retry deliver the request to the right location.
*/
Header[] locationHeaders = response.getHeaders("location");
String redirectedLocation = locationHeaders[0].getValue();
log.debug("Redirecting to: " + redirectedLocation);
redirectedURI = URI.create(redirectedLocation);
httpRequest.setURI(redirectedURI);
awsRequestMetrics.addProperty(
Field.StatusCode.name(), response.getStatusLine().getStatusCode());
awsRequestMetrics.addProperty(Field.RedirectLocation.name(), redirectedLocation);
awsRequestMetrics.addProperty(Field.AWSRequestID.name(), null);
} else {
leaveHttpConnectionOpen = errorResponseHandler.needsConnectionLeftOpen();
exception = handleErrorResponse(request, errorResponseHandler, httpRequest, response);
awsRequestMetrics.addProperty(Field.AWSRequestID.name(), exception.getRequestId());
awsRequestMetrics.addProperty(Field.AWSErrorCode.name(), exception.getErrorCode());
awsRequestMetrics.addProperty(Field.StatusCode.name(), exception.getStatusCode());
if (!shouldRetry(httpRequest, exception, retryCount)) {
throw exception;
}
resetRequestAfterError(request, exception);
}
} catch (IOException ioe) {
log.info("Unable to execute HTTP request: " + ioe.getMessage(), ioe);
awsRequestMetrics.addProperty(Field.Exception.name(), ioe.toString());
awsRequestMetrics.addProperty(Field.AWSRequestID.name(), null);
if (!shouldRetry(httpRequest, ioe, retryCount)) {
throw new AmazonClientException(
"Unable to execute HTTP request: " + ioe.getMessage(), ioe);
}
resetRequestAfterError(request, ioe);
} finally {
retryCount++;
/*
* Some response handlers need to manually manage the HTTP
* connection and will take care of releasing the connection on
* their own, but if this response handler doesn't need the
* connection left open, we go ahead and release the it to free
* up resources.
*/
if (!leaveHttpConnectionOpen) {
try {
response.getEntity().getContent().close();
} catch (Throwable t) {
}
}
}
} /* end while (true) */
}
