import com.amazonaws.Response; //导入依赖的package包/类
private void populateAndEndSubsegment(Subsegment currentSubsegment, Request<?> request, Response<?> response) {
    if (null != response) {
        String requestId = null;
        if (response.getAwsResponse() instanceof AmazonWebServiceResult<?>) { // Not all services return responses extending AmazonWebServiceResult (e.g. S3)
            ResponseMetadata metadata = ((AmazonWebServiceResult<?>) response.getAwsResponse()).getSdkResponseMetadata();
            if (null != metadata) {
                requestId = metadata.getRequestId();
                if (null != requestId) {
                    currentSubsegment.putAws(REQUEST_ID_SUBSEGMENT_KEY, requestId);
                }
            }
        } else if (null != response.getHttpResponse()) { // S3 does not follow request id header convention
            if (null != response.getHttpResponse().getHeader(S3_REQUEST_ID_HEADER_KEY)) {
                currentSubsegment.putAws(REQUEST_ID_SUBSEGMENT_KEY, response.getHttpResponse().getHeader(S3_REQUEST_ID_HEADER_KEY));
            }
            if (null != response.getHttpResponse().getHeader(S3_EXTENDED_REQUEST_ID_HEADER_KEY)) {
                currentSubsegment.putAws(EXTENDED_REQUEST_ID_SUBSEGMENT_KEY, response.getHttpResponse().getHeader(S3_EXTENDED_REQUEST_ID_HEADER_KEY));
            }
        }
        currentSubsegment.putAllAws(extractResponseParameters(request, response.getAwsResponse()));
        currentSubsegment.putAllHttp(extractHttpResponseInformation(response.getHttpResponse()));
    }

    finalizeSubsegment(request);
}
 

import com.amazonaws.Response; //导入依赖的package包/类
/**
 * Executes the request and returns the result.
 *
 * @param request              The AmazonWebServices request to send to the remote server
 * @param responseHandler      A response handler to accept a successful response from the
 *                             remote server
 * @param errorResponseHandler A response handler to accept an unsuccessful response from the
 *                             remote server
 * @param executionContext     Additional information about the context of this web service
 *                             call
 * @deprecated Use {@link #requestExecutionBuilder()} to configure and execute a HTTP request.
 */
@Deprecated
public <T> Response<T> execute(Request<?> request,
                               HttpResponseHandler<AmazonWebServiceResponse<T>> responseHandler,
                               HttpResponseHandler<AmazonServiceException> errorResponseHandler,
                               ExecutionContext executionContext) {
    HttpResponseHandler<T> adaptedRespHandler = new AwsResponseHandlerAdapter<T>(
            getNonNullResponseHandler(responseHandler),
            request,
            executionContext.getAwsRequestMetrics(),
            responseMetadataCache);
    return requestExecutionBuilder()
            .request(request)
            .requestConfig(new AmazonWebServiceRequestAdapter(request.getOriginalRequest()))
            .errorResponseHandler(new AwsErrorResponseHandler(errorResponseHandler, executionContext.getAwsRequestMetrics()))
            .executionContext(executionContext)
            .execute(adaptedRespHandler);
}
 

import com.amazonaws.Response; //导入依赖的package包/类
private void execRequest(String endpoint, int status) {
  AWSRequestMetrics metrics = new AWSRequestMetricsFullSupport();
  metrics.addProperty(AWSRequestMetrics.Field.ServiceName, "AmazonCloudWatch");
  metrics.addProperty(AWSRequestMetrics.Field.ServiceEndpoint, endpoint);
  metrics.addProperty(AWSRequestMetrics.Field.StatusCode, "" + status);
  if (status == 503) {
    metrics.addProperty(AWSRequestMetrics.Field.AWSErrorCode, "Throttled");
  }
  String counterName = "BytesProcessed";
  String timerName = "ClientExecuteTime";
  metrics.setCounter(counterName, 12345);
  metrics.getTimingInfo().addSubMeasurement(timerName, TimingInfo.unmodifiableTimingInfo(100000L, 200000L));

  Request<?> req = new DefaultRequest(new ListMetricsRequest(), "AmazonCloudWatch");
  req.setAWSRequestMetrics(metrics);
  req.setEndpoint(URI.create(endpoint));

  HttpResponse hr = new HttpResponse(req, new HttpPost(endpoint));
  hr.setStatusCode(status);
  Response<?> resp = new Response<>(null, new HttpResponse(req, new HttpPost(endpoint)));

  collector.collectMetrics(req, resp);
}
 

import com.amazonaws.Response; //导入依赖的package包/类
private <T> T invoke(HttpMethodName httpMethodName, String resourcePath, Object representation,
                     HttpResponseHandler<AmazonWebServiceResponse<T>> responseHandler)
        throws AmazonClientException {
    ExecutionContext executionContext = createExecutionContext();
    AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();

    awsRequestMetrics.startEvent(AWSRequestMetrics.Field.RequestMarshallTime.name());
    Request request = buildRequest(httpMethodName, resourcePath, representation);
    awsRequestMetrics.endEvent(AWSRequestMetrics.Field.RequestMarshallTime.name());

    awsRequestMetrics.startEvent(AWSRequestMetrics.Field.CredentialsRequestTime.name());
    AWSCredentials credentials = awsCredentialsProvider.getCredentials();
    awsRequestMetrics.endEvent(AWSRequestMetrics.Field.CredentialsRequestTime.name());

    executionContext.setCredentials(credentials);

    awsRequestMetrics.startEvent(AWSRequestMetrics.Field.ClientExecuteTime.name());
    Response<T> response = client.execute(request, responseHandler, errorResponseHandler, executionContext);
    awsRequestMetrics.endEvent(AWSRequestMetrics.Field.ClientExecuteTime.name());

    awsRequestMetrics.log();

    return response.getAwsResponse();
}
 

import com.amazonaws.Response; //导入依赖的package包/类
@Override
public void afterResponse(Request<?> request, Response<?> response) {
    if (isSubsegmentDuplicate(recorder.getCurrentSubsegmentOptional(), request)) {
        Optional<Subsegment> currentSubsegmentOptional = recorder.getCurrentSubsegmentOptional();
        if (!currentSubsegmentOptional.isPresent()) {
            return;
        }
        Subsegment currentSubsegment = currentSubsegmentOptional.get();
        populateAndEndSubsegment(currentSubsegment, request, response, null);
    }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
/**
 * Start and end client execution timer around the execution of the request. It's important
 * that the client execution task is canceled before the InterruptedExecption is handled by
 * {@link #execute()} so * the interrupt status doesn't leak out to the callers code
 */
private Response<Output> executeWithTimer() throws InterruptedException {
    try {
        executionContext.setClientExecutionTrackerTask(
                clientExecutionTimer.startTimer(getClientExecutionTimeout(requestConfig)));
        return doExecute();
    } finally {
        executionContext.getClientExecutionTrackerTask().cancelTask();
    }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
private Response<Output> doExecute() throws InterruptedException {
    runBeforeRequestHandlers();
    setSdkTransactionId(request);
    setUserAgent(request);

    ProgressListener listener = requestConfig.getProgressListener();
    // add custom headers
    request.getHeaders().putAll(config.getHeaders());
    request.getHeaders().putAll(requestConfig.getCustomRequestHeaders());
    // add custom query parameters
    mergeQueryParameters(requestConfig.getCustomQueryParameters());
    Response<Output> response = null;
    final InputStream origContent = request.getContent();
    final InputStream toBeClosed = beforeRequest(); // for progress tracking
    // make "notCloseable", so reset would work with retries
    final InputStream notCloseable = (toBeClosed == null) ? null
            : ReleasableInputStream.wrap(toBeClosed).disableClose();
    request.setContent(notCloseable);
    try {
        publishProgress(listener, ProgressEventType.CLIENT_REQUEST_STARTED_EVENT);
        response = executeHelper();
        publishProgress(listener, ProgressEventType.CLIENT_REQUEST_SUCCESS_EVENT);
        awsRequestMetrics.getTimingInfo().endTiming();
        afterResponse(response);
        return response;
    } catch (AmazonClientException e) {
        publishProgress(listener, ProgressEventType.CLIENT_REQUEST_FAILED_EVENT);
        afterError(response, e);
        throw e;
    } finally {
        // Always close so any progress tracking would get the final events propagated.
        closeQuietly(toBeClosed, log);
        request.setContent(origContent); // restore the original content
    }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
private void afterError(Response<?> response,
                        AmazonClientException e) throws InterruptedException {
    for (RequestHandler2 handler2 : requestHandler2s) {
        handler2.afterError(request, response, e);
        checkInterrupted(response);
    }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
@Override
public <Input, Output> Output execute(
        ClientExecutionParams<Input, Output> executionParams) {
    final Input input = executionParams.getInput();
    ExecutionContext executionContext = createExecutionContext(
            executionParams.getRequestConfig());
    AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
    awsRequestMetrics.startEvent(AWSRequestMetrics.Field.ClientExecuteTime);
    Request<Input> request = null;
    Response<Output> response = null;

    try {
        awsRequestMetrics.startEvent(AWSRequestMetrics.Field.RequestMarshallTime);
        try {
            request = executionParams.getMarshaller().marshall(input);
            request.setAWSRequestMetrics(awsRequestMetrics);
        } finally {
            awsRequestMetrics.endEvent(AWSRequestMetrics.Field.RequestMarshallTime);
        }

        response = invoke(request,
                          executionParams.getRequestConfig(),
                          executionContext,
                          executionParams.getResponseHandler(),
                          executionParams.getErrorResponseHandler());

        return response.getAwsResponse();

    } finally {

        endClientExecution(awsRequestMetrics,
                           executionParams.getRequestConfig(),
                           request,
                           response);
    }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
/**
 * Normal invoke with authentication. Credentials are required and may be overriden at the
 * request level.
 **/
private <Output, Input> Response<Output> invoke(Request<Input> request,
                                                RequestConfig requestConfig,
                                                ExecutionContext executionContext,
                                                HttpResponseHandler<Output> responseHandler,
                                                HttpResponseHandler<? extends SdkBaseException> errorResponseHandler) {

    executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(
            requestConfig, awsCredentialsProvider));

    return doInvoke(request, requestConfig, executionContext, responseHandler,
                    errorResponseHandler);
}
 

import com.amazonaws.Response; //导入依赖的package包/类
/**
 * Invoke the request using the http client. Assumes credentials (or lack thereof) have been
 * configured in the ExecutionContext beforehand.
 **/
private <Output, Input> Response<Output> doInvoke(Request<Input> request,
                                                  RequestConfig requestConfig,
                                                  ExecutionContext executionContext,
                                                  HttpResponseHandler<Output> responseHandler,
                                                  HttpResponseHandler<? extends SdkBaseException> errorResponseHandler) {
    request.setEndpoint(endpoint);
    return client.requestExecutionBuilder()
            .request(request)
            .requestConfig(requestConfig)
            .executionContext(executionContext)
            .errorResponseHandler(errorResponseHandler)
            .execute(responseHandler);
}
 

import com.amazonaws.Response; //导入依赖的package包/类
/**
 * Convenient method to end the client execution without logging the awsRequestMetrics.
 */
private void endClientExecution(AWSRequestMetrics awsRequestMetrics,
                                      RequestConfig requestConfig,
                                      Request<?> request,
                                      Response<?> response) {
    if (request != null) {
        awsRequestMetrics.endEvent(AWSRequestMetrics.Field.ClientExecuteTime);
        awsRequestMetrics.getTimingInfo().endTiming();
        RequestMetricCollector metricCollector = findRequestMetricCollector(requestConfig);
        metricCollector.collectMetrics(request, response);
        awsRequestMetrics.log();
    }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
@SuppressWarnings("deprecation")
@Override
public void afterResponse(Request<?> request, Response<?> response) {
    AWSRequestMetrics awsRequestMetrics = request == null ? null : request
            .getAWSRequestMetrics();
    Object awsResponse = response == null ? null : response
            .getAwsResponse();
    TimingInfo timingInfo = awsRequestMetrics == null ? null
            : awsRequestMetrics.getTimingInfo();
    old.afterResponse(request, awsResponse, timingInfo);
}
 

import com.amazonaws.Response; //导入依赖的package包/类
@Before
public void setup() {
    MockitoAnnotations.initMocks(this);
    stackedRequestHandler = new StackedRequestHandler(new ArrayList<RequestHandler2>());

    response = new Response<String>("Dummy response", new HttpResponse(request, new HttpGet()));
}
 

import com.amazonaws.Response; //导入依赖的package包/类
/**
 * Perform this request.	
 */
@Override
public T perform() {
    final Response<T> rsp = new AmazonHttpClient(new ClientConfiguration())
        .requestExecutionBuilder()
        .executionContext(new ExecutionContext(true))
        .request(this.request)
        .errorResponseHandler(this.errHandler)
        .execute(this.respHandler);
    return rsp.getAwsResponse();
}
 

import com.amazonaws.Response; //导入依赖的package包/类
@Override
public void collectMetrics(Request<?> request, Response<?> response)
{
    AWSRequestMetrics metrics = request.getAWSRequestMetrics();

    TimingInfo timingInfo = metrics.getTimingInfo();
    Number requestCounts = timingInfo.getCounter(Field.RequestCount.name());
    Number retryCounts = timingInfo.getCounter(Field.HttpClientRetryCount.name());
    Number throttleExceptions = timingInfo.getCounter(Field.ThrottleException.name());
    TimingInfo requestTime = timingInfo.getSubMeasurement(Field.HttpRequestTime.name());

    if (requestCounts != null) {
        stats.updateAwsRequestCount(requestCounts.longValue());
    }

    if (retryCounts != null) {
        stats.updateAwsRetryCount(retryCounts.longValue());
    }

    if (throttleExceptions != null) {
        stats.updateAwsThrottleExceptionsCount(throttleExceptions.longValue());
    }

    if (requestTime != null && requestTime.getTimeTakenMillisIfKnown() != null) {
        stats.addAwsRequestTime(new Duration(requestTime.getTimeTakenMillisIfKnown(), MILLISECONDS));
    }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
@Override
public void collectMetrics(Request<?> request, Response<?> response) {
  final AWSRequestMetrics metrics = request.getAWSRequestMetrics();
  if (metrics.isEnabled()) {
    final Map<String, String> baseTags = getBaseTags(request);
    final TimingInfo timing = metrics.getTimingInfo();

    for (Field counter : COUNTERS) {
      Optional.ofNullable(timing.getCounter(counter.name()))
          .filter(v -> v.longValue() > 0)
          .ifPresent(v -> registry.counter(metricId(counter, baseTags)).increment(v.longValue()));
    }

    for (Field timer : TIMERS) {
      Optional.ofNullable(timing.getLastSubMeasurement(timer.name()))
          .filter(TimingInfo::isEndTimeKnown)
          .ifPresent(t -> registry.timer(metricId(timer, baseTags))
              .record(t.getEndTimeNano() - t.getStartTimeNano(), TimeUnit.NANOSECONDS));
    }

    notEmpty(metrics.getProperty(Field.ThrottleException)).ifPresent(throttleExceptions -> {
      final Id throttling = metricId("throttling", baseTags);
      throttleExceptions.forEach(ex ->
          registry.counter(throttling.withTag("throttleException", ex.getClass().getSimpleName()))
              .increment());
    });
  }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
@Override
public CreateSpeechResult createSpeech(CreateSpeechRequest createSpeechRequest) throws AmazonServiceException,
        AmazonClientException {

    ExecutionContext executionContext = createExecutionContext(createSpeechRequest);
    Request<CreateSpeechRequest> request = CreateSpeechRequestMarshallerFactory.getMarshaller(
            createSpeechRequest.getMethodType()).marshall(createSpeechRequest);
    CreateSpeechResultUnmarshaller unmarshaller = new CreateSpeechResultUnmarshaller();
    StreamResponseHandler<CreateSpeechResult> responseHandler =
            new StreamResponseHandler<CreateSpeechResult>(unmarshaller);
    Response<CreateSpeechResult> response = invoke(request, responseHandler, executionContext);
    return response.getAwsResponse();
}
 

import com.amazonaws.Response; //导入依赖的package包/类
@Override
public ListVoicesResult listVoices(ListVoicesRequest listVoicesRequest) throws AmazonServiceException,
        AmazonClientException {

    ExecutionContext executionContext = createExecutionContext(listVoicesRequest);
    Request<ListVoicesRequest> request = ListVoicesRequestMarshallerFactory.getMarshaller(
            listVoicesRequest.getMethodType()).marshall(listVoicesRequest);
    Unmarshaller<ListVoicesResult, JsonUnmarshallerContext> unmarshaller = new ListVoicesResultJsonUnmarshaller();
    JsonResponseHandler<ListVoicesResult> responseHandler =
            new JsonResponseHandler<ListVoicesResult>(unmarshaller);
    Response<ListVoicesResult> response = invoke(request, responseHandler, executionContext);
    return response.getAwsResponse();
}
 

import com.amazonaws.Response; //导入依赖的package包/类
@Override
public GetLexiconResult getLexicon(GetLexiconRequest getLexiconRequest)
        throws AmazonServiceException, AmazonClientException {

    ExecutionContext executionContext = createExecutionContext(getLexiconRequest);
    GetLexiconRequestMarshaller marshaller = new GetLexiconPostRequestMarshaller();
    Request<GetLexiconRequest> request = marshaller.marshall(getLexiconRequest);
    Unmarshaller<GetLexiconResult, JsonUnmarshallerContext> unmarshaller = new GetLexiconResultJsonUnmarshaller();
    JsonResponseHandler<GetLexiconResult> responseHandler = new JsonResponseHandler<GetLexiconResult>(unmarshaller);

    Response<GetLexiconResult> response = invoke(request, responseHandler, executionContext);
    return response.getAwsResponse();
}