private HashMap<String, Object> extractHttpResponseParameters(SdkHttpResponse httpResponse) {
    HashMap<String, Object> parameters = new HashMap<>();
    HashMap<String, Object> responseData = new HashMap<>();

    responseData.put(EntityDataKeys.HTTP.STATUS_CODE_KEY, httpResponse.statusCode());

    try {
        if (httpResponse.headers().containsKey(EntityHeaderKeys.HTTP.CONTENT_LENGTH_HEADER)) {
            responseData.put(EntityDataKeys.HTTP.CONTENT_LENGTH_KEY, Long.parseLong(
                    httpResponse.headers().get(EntityHeaderKeys.HTTP.CONTENT_LENGTH_HEADER).get(0))
            );
        }
    } catch (NumberFormatException e) {
        logger.warn("Unable to parse Content-Length header.", e);
    }

    parameters.put(EntityDataKeys.HTTP.RESPONSE_KEY, responseData);
    return parameters;
}
 

private void parseRetryHeaderTest(String expected, String header) {
  SdkHttpRequest request = SdkHttpRequest.builder()
      .method(SdkHttpMethod.POST)
      .uri(URI.create("https://ec2.us-east-1.amazonaws.com"))
      .appendHeader("amz-sdk-retry", header)
      .build();
  SdkHttpResponse response = SdkHttpResponse.builder()
      .statusCode(200)
      .build();
  TestContext context = new TestContext(request, response);
  execute(context, createAttributes("EC2", "DescribeInstances"), millis(30));
  Assertions.assertEquals(1, registry.timers().count());

  Timer t = registry.timers().findFirst().orElse(null);
  Assertions.assertNotNull(t);
  Assertions.assertEquals(1, t.count());
  Assertions.assertEquals(millis(30), t.totalTime());
  Assertions.assertEquals(expected, get(t.id(), "ipc.attempt"));
}
 

@Override
public boolean isClockSkewException() {
    if (super.isClockSkewException()) {
        return true;
    }

    if (awsErrorDetails == null) {
        return false;
    }

    if (AwsErrorCode.isDefiniteClockSkewErrorCode(awsErrorDetails.errorCode())) {
        return true;
    }

    SdkHttpResponse sdkHttpResponse = awsErrorDetails.sdkHttpResponse();

    if (clockSkew == null || sdkHttpResponse == null) {
        return false;
    }

    boolean isPossibleClockSkewError = AwsErrorCode.isPossibleClockSkewErrorCode(awsErrorDetails.errorCode()) ||
                                       AwsStatusCode.isPossibleClockSkewStatusCode(statusCode());

    return isPossibleClockSkewError && ClockSkew.isClockSkewed(Instant.now().minus(clockSkew),
                                                               ClockSkew.getServerTime(sdkHttpResponse).orElse(null));
}
 

/**
 * S3 currently returns content-range in two possible headers: Content-Range or x-amz-content-range based on the x-amz-te
 * in the request. This will check the x-amz-content-range if the modeled header (Content-Range) wasn't populated.
 */
private SdkResponse fixContentRange(SdkResponse sdkResponse, SdkHttpResponse httpResponse) {
    // Use the modeled content range header, if the service returned it.
    GetObjectResponse getObjectResponse = (GetObjectResponse) sdkResponse;
    if (getObjectResponse.contentRange() != null) {
        return getObjectResponse;
    }

    // If the service didn't use the modeled content range header, check the x-amz-content-range header.
    Optional<String> xAmzContentRange = httpResponse.firstMatchingHeader("x-amz-content-range");
    if (!xAmzContentRange.isPresent()) {
        return getObjectResponse;
    }

    return getObjectResponse.copy(r -> r.contentRange(xAmzContentRange.get()));
}
 

/**
 * @return A mocked result for the ListObjects operation.
 */
public static HttpExecuteResponse mockListObjectsResponse() throws UnsupportedEncodingException {
    return HttpExecuteResponse.builder().response(SdkHttpResponse.builder().statusCode(200).build()).responseBody(
        AbortableInputStream.create(new StringInputStream(
            "<ListBucketResult xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">\n" +
            "  <Name>example-bucket</Name>\n" +
            "  <Prefix>photos/2006/</Prefix>\n" +
            "  <Marker></Marker>\n" +
            "  <MaxKeys>1000</MaxKeys>\n" +
            "  <Delimiter>/</Delimiter>\n" +
            "  <IsTruncated>false</IsTruncated>\n" +
            "\n" +
            "  <CommonPrefixes>\n" +
            "    <Prefix>photos/2006/February/</Prefix>\n" +
            "  </CommonPrefixes>\n" +
            "  <CommonPrefixes>\n" +
            "    <Prefix>photos/2006/January/</Prefix>\n" +
            "  </CommonPrefixes>\n" +
            "</ListBucketResult>")))
                              .build();
}
 

@Test
public void afterUnmarshalling_putObjectRequest_with_SSE_shouldNotValidateChecksum() {
    SdkHttpResponse sdkHttpResponse = getSdkHttpResponseWithChecksumHeader();

    PutObjectResponse response = PutObjectResponse.builder()
                                                  .eTag(INVALID_CHECKSUM)
                                                  .build();

    PutObjectRequest putObjectRequest = PutObjectRequest.builder().build();

    SdkHttpRequest sdkHttpRequest = SdkHttpFullRequest.builder()
                                                      .putHeader(SERVER_SIDE_ENCRYPTION_HEADER, AWS_KMS.toString())
                                                      .putHeader("x-amz-server-side-encryption-aws-kms-key-id", ENABLE_MD5_CHECKSUM_HEADER_VALUE)
                                                      .uri(URI.create("http://localhost:8080"))
                                                      .method(SdkHttpMethod.PUT)
                                                      .build();

    Context.AfterUnmarshalling afterUnmarshallingContext =
        InterceptorTestUtils.afterUnmarshallingContext(putObjectRequest, sdkHttpRequest, response, sdkHttpResponse);

    interceptor.afterUnmarshalling(afterUnmarshallingContext, getExecutionAttributesWithChecksum());
}
 

@Test
public void awsFailure() {
  SdkHttpRequest request = SdkHttpRequest.builder()
      .method(SdkHttpMethod.POST)
      .uri(URI.create("https://ec2.us-east-1.amazonaws.com"))
      .build();
  SdkHttpResponse response = SdkHttpResponse.builder()
      .statusCode(403)
      .build();
  Throwable error = AwsServiceException.builder()
      .awsErrorDetails(AwsErrorDetails.builder()
          .errorCode("AccessDenied")
          .errorMessage("credentials have expired")
          .build())
      .build();
  TestContext context = new TestContext(request, response, error);
  execute(context, createAttributes("EC2", "DescribeInstances"), millis(30));
  Assertions.assertEquals(1, registry.timers().count());

  Timer t = registry.timers().findFirst().orElse(null);
  Assertions.assertNotNull(t);
  Assertions.assertEquals(1, t.count());
  Assertions.assertEquals(millis(30), t.totalTime());
  Assertions.assertEquals("403", get(t.id(), "http.status"));
  Assertions.assertEquals("AccessDenied", get(t.id(), "ipc.status.detail"));
}
 

@Test
public void afterUnmarshalling_putObjectRequest_shouldValidateChecksum() {
    SdkHttpResponse sdkHttpResponse = getSdkHttpResponseWithChecksumHeader();

    PutObjectResponse response = PutObjectResponse.builder()
                                                  .eTag(VALID_CHECKSUM)
                                                  .build();

    PutObjectRequest putObjectRequest = PutObjectRequest.builder()
                                                        .build();

    SdkHttpRequest sdkHttpRequest = SdkHttpFullRequest.builder()
                                                      .uri(URI.create("http://localhost:8080"))
                                                      .method(SdkHttpMethod.PUT)
                                                      .build();

    Context.AfterUnmarshalling afterUnmarshallingContext =
        InterceptorTestUtils.afterUnmarshallingContext(putObjectRequest, sdkHttpRequest, response, sdkHttpResponse);

    interceptor.afterUnmarshalling(afterUnmarshallingContext, getExecutionAttributesWithChecksum());
}
 

@Test
public void afterUnmarshalling_putObjectRequest_with_SSE_shouldNotValidateChecksum() {
    SdkHttpResponse sdkHttpResponse = getSdkHttpResponseWithChecksumHeader();

    PutObjectResponse response = PutObjectResponse.builder()
                                                  .eTag(INVALID_CHECKSUM)
                                                  .build();

    PutObjectRequest putObjectRequest = PutObjectRequest.builder().build();

    SdkHttpRequest sdkHttpRequest = SdkHttpFullRequest.builder()
                                                      .putHeader(SERVER_SIDE_ENCRYPTION_HEADER, AWS_KMS.toString())
                                                      .putHeader("x-amz-server-side-encryption-aws-kms-key-id", ENABLE_MD5_CHECKSUM_HEADER_VALUE)
                                                      .uri(URI.create("http://localhost:8080"))
                                                      .method(SdkHttpMethod.PUT)
                                                      .build();

    Context.AfterUnmarshalling afterUnmarshallingContext =
        InterceptorTestUtils.afterUnmarshallingContext(putObjectRequest, sdkHttpRequest, response, sdkHttpResponse);

    interceptor.afterUnmarshalling(afterUnmarshallingContext, getExecutionAttributesWithChecksum());
}
 

private AwsServiceException exception(int clientSideTimeOffset, String errorCode, int statusCode, String serverDate) {
    SdkHttpResponse httpResponse =
            SdkHttpFullResponse.builder()
                               .statusCode(statusCode)
                               .applyMutation(r -> {
                                   if (serverDate != null) {
                                       r.putHeader("Date", serverDate);
                                   }
                               })
                               .build();
    AwsErrorDetails errorDetails =
            AwsErrorDetails.builder()
                           .errorCode(errorCode)
                           .sdkHttpResponse(httpResponse)
                           .build();

    return AwsServiceException.builder()
                              .clockSkew(Duration.ofSeconds(clientSideTimeOffset))
                              .awsErrorDetails(errorDetails)
                              .statusCode(statusCode)
                              .build();
}
 

@Test
public void successfulExecutionCallsResponseHandler() throws Exception {

    SdkResponse expected = VoidSdkResponse.builder().build();
    Map<String, List<String>> headers = new HashMap<>();
    headers.put("foo", Arrays.asList("bar"));

    // Given
    expectRetrievalFromMocks();
    when(httpClientCall.call()).thenReturn(HttpExecuteResponse.builder()
                                                              .response(SdkHttpResponse.builder()
                                                                                   .statusCode(200)
                                                                                   .headers(headers)
                                                                                   .build())
                                                              .build()); // Successful HTTP call
    when(responseHandler.handle(any(), any())).thenReturn(expected); // Response handler call

    // When
    SdkResponse actual = syncClientHandler.execute(clientExecutionParams());

    // Then
    verifyNoMoreInteractions(errorResponseHandler); // No error handler calls
    assertThat(actual.sdkHttpResponse().statusCode()).isEqualTo(200);
    assertThat(actual.sdkHttpResponse().headers()).isEqualTo(headers);
}
 

public InterceptorContext modifyHttpResponse(InterceptorContext context,
                                             ExecutionAttributes executionAttributes) {
    InterceptorContext result = context;

    for (int i = interceptors.size() - 1; i >= 0; i--) {
        SdkHttpResponse interceptorResult =
            interceptors.get(i).modifyHttpResponse(result, executionAttributes);
        validateInterceptorResult(result.httpResponse(), interceptorResult, interceptors.get(i), "modifyHttpResponse");

        InputStream response = interceptors.get(i).modifyHttpResponseContent(result, executionAttributes).orElse(null);

        result = result.toBuilder().httpResponse(interceptorResult).responseBody(response).build();
    }

    return result;
}
 

@Test
public void badRequest() {
    final AmazonWebServicesClientProxy proxy = new AmazonWebServicesClientProxy(mock(LoggerProxy.class), MOCK,
                                                                                () -> Duration.ofMinutes(2).toMillis() // just
                                                                                                                       // keep
                                                                                                                       // going

    );
    final Model model = new Model();
    model.setRepoName("NewRepo");
    final StdCallbackContext context = new StdCallbackContext();
    final SdkHttpResponse sdkHttpResponse = mock(SdkHttpResponse.class);
    when(sdkHttpResponse.statusCode()).thenReturn(400);
    final ProgressEvent<Model,
        StdCallbackContext> result = proxy
            .initiate("client:createRespository", proxy.newProxy(() -> mock(ServiceClient.class)), model, context)
            .translateToServiceRequest(m -> new CreateRequest.Builder().repoName(m.getRepoName()).build())
            .makeServiceCall((r, c) -> {
                throw new BadRequestException(mock(AwsServiceException.Builder.class)) {
                    private static final long serialVersionUID = 1L;

                    @Override
                    public AwsErrorDetails awsErrorDetails() {
                        return AwsErrorDetails.builder().errorCode("BadRequest").errorMessage("Bad Parameter in request")
                            .sdkHttpResponse(sdkHttpResponse).build();
                    }
                };
            }).done(o -> ProgressEvent.success(model, context));
    assertThat(result.getStatus()).isEqualTo(OperationStatus.FAILED);
    assertThat(result.getMessage()).contains("BadRequest");
}
 

@Test
public void accessDenied() {
    final AmazonWebServicesClientProxy proxy = new AmazonWebServicesClientProxy(mock(LoggerProxy.class), MOCK,
                                                                                () -> Duration.ofMinutes(2).toMillis() // just
                                                                                                                       // keep
                                                                                                                       // going
    );
    final Model model = new Model();
    model.setRepoName("NewRepo");
    final StdCallbackContext context = new StdCallbackContext();
    final SdkHttpResponse sdkHttpResponse = mock(SdkHttpResponse.class);
    when(sdkHttpResponse.statusCode()).thenReturn(401);
    ProgressEvent<Model,
        StdCallbackContext> result = proxy
            .initiate("client:createRespository", proxy.newProxy(() -> mock(ServiceClient.class)), model, context)
            .translateToServiceRequest(m -> new CreateRequest.Builder().repoName(m.getRepoName()).build())
            .makeServiceCall((r, c) -> {
                throw new AccessDenied(AwsServiceException.builder()) {
                    private static final long serialVersionUID = 1L;

                    @Override
                    public AwsErrorDetails awsErrorDetails() {
                        return AwsErrorDetails.builder().errorCode("AccessDenied: 401").errorMessage("Token Invalid")
                            .sdkHttpResponse(sdkHttpResponse).build();
                    }

                };
            }).done(o -> ProgressEvent.success(model, context));
    assertThat(result.getStatus()).isEqualTo(OperationStatus.FAILED);
    assertThat(result.getMessage()).contains("AccessDenied");
}
 

@Override
public GetTopicAttributesResponse getTopicAttributes(
    GetTopicAttributesRequest topicAttributesRequest) {
  GetTopicAttributesResponse response = Mockito.mock(GetTopicAttributesResponse.class);
  SdkHttpResponse metadata = Mockito.mock(SdkHttpResponse.class);

  Mockito.when(metadata.statusCode()).thenReturn(200);
  Mockito.when(response.sdkHttpResponse()).thenReturn(metadata);

  return response;
}
 

@Override
public void afterTransmission(Context.AfterTransmission context, ExecutionAttributes attrs) {
  SdkHttpResponse response = context.httpResponse();
  IpcLogEntry logEntry = attrs.getAttribute(LOG_ENTRY)
      .markEnd()
      .withHttpStatus(response.statusCode());
  attrs.putAttribute(STATUS_IS_SET, true);

  response.headers().forEach((k, vs) -> vs.forEach(v -> logEntry.addResponseHeader(k, v)));
}
 

private String extractRequestIdFromHttp(SdkHttpResponse httpResponse) {
    Map<String, List<String>> headers = httpResponse.headers();
    Set<String> headerKeys = headers.keySet();
    String requestIdKey = headerKeys
            .stream()
            .filter(key -> REQUEST_ID_KEYS.contains(key.toLowerCase()))
            .findFirst()
            .orElse(null);
    return requestIdKey != null ? headers.get(requestIdKey).get(0) : null;
}
 

@Override
public GetTopicAttributesResponse getTopicAttributes(
    GetTopicAttributesRequest topicAttributesRequest) {
  GetTopicAttributesResponse response = Mockito.mock(GetTopicAttributesResponse.class);
  SdkHttpResponse metadata = Mockito.mock(SdkHttpResponse.class);

  Mockito.when(metadata.statusCode()).thenReturn(200);
  Mockito.when(response.sdkHttpResponse()).thenReturn(metadata);

  return response;
}
 

public DownloadFailedException(SdkResponse response) {

        SdkHttpResponse httpResponse = response.sdkHttpResponse();
        if (httpResponse != null) {
            this.statusCode = httpResponse.statusCode();
            this.statusText = httpResponse.statusText();
        } else {
            this.statusCode = HttpStatus.INTERNAL_SERVER_ERROR.value();
            this.statusText = Optional.of("UNKNOWN");
        }

    }
 

HttpClientResponse(
    @Nullable SdkHttpRequest request,
    @Nullable SdkHttpResponse response,
    @Nullable Throwable error
) {
  if (response == null && error == null) {
    throw new NullPointerException("response == null && error == null");
  }
  this.request = request;
  this.response = response;
  this.error = error;
}
 

private SdkHttpClient mockSdkHttpClient(SdkHttpResponse response, String body) throws Exception {
    ExecutableHttpRequest abortableCallable = Mockito.mock(ExecutableHttpRequest.class);
    SdkHttpClient mockClient = Mockito.mock(SdkHttpClient.class);

    Mockito.when(mockClient.prepareRequest(Mockito.any())).thenReturn(abortableCallable);
    Mockito.when(abortableCallable.call()).thenReturn(HttpExecuteResponse.builder()
            .response(response)
            .responseBody(AbortableInputStream.create(
                    new ByteArrayInputStream(body.getBytes(StandardCharsets.UTF_8))
            ))
            .build()
    );
    return mockClient;
}
 

private SdkAsyncHttpClient mockSdkAsyncHttpClient(SdkHttpResponse response) {
    SdkAsyncHttpClient mockClient = Mockito.mock(SdkAsyncHttpClient.class);
    Mockito.when(mockClient.execute(Mockito.any(AsyncExecuteRequest.class)))
           .thenAnswer((Answer<CompletableFuture<Void>>) invocationOnMock -> {
               AsyncExecuteRequest request = invocationOnMock.getArgument(0);
               SdkAsyncHttpResponseHandler handler = request.responseHandler();
               handler.onHeaders(response);
               handler.onStream(new EmptyPublisher<>());

               return CompletableFuture.completedFuture(null);
           });

    return mockClient;
}
 

private SdkHttpResponse generateLambdaInvokeResponse(int statusCode) {
    return SdkHttpResponse.builder()
            .statusCode(statusCode)
            .putHeader("x-amz-request-id", "1111-2222-3333-4444")
            .putHeader("x-amz-id-2", "extended")
            .putHeader("Content-Length", "2")
            .putHeader("X-Amz-Function-Error", "Failure")
            .build();
}
 

private static SdkHttpResponse convert(ResponseHeaders headers) {
  SdkHttpResponse.Builder builder =
      SdkHttpResponse.builder()
          .statusCode(headers.status().code())
          .statusText(headers.status().reasonPhrase());
  fillHeaders(headers, builder);
  return builder.build();
}
 

private void verifyHttpMetadata(SubscribeToShardResponse response) {
    SdkHttpResponse sdkHttpResponse = response.sdkHttpResponse();
    assertThat(sdkHttpResponse).isNotNull();
    assertThat(sdkHttpResponse.isSuccessful()).isTrue();
    assertThat(sdkHttpResponse.headers()).isNotEmpty();
    assertThat(response.responseMetadata()).isNotNull();
    assertThat(response.responseMetadata().extendedRequestId()).isNotEqualTo("UNKNOWN");
    assertThat(response.responseMetadata().requestId()).isNotEqualTo("UNKNOWN");
}
 

@Test
public void responseChecksumIsValid_serverSideCustomerEncryption_false() {
    SdkHttpResponse response = SdkHttpResponse.builder()
                                              .putHeader(SERVER_SIDE_CUSTOMER_ENCRYPTION_HEADER, "test")
                                              .build();

    assertThat(responseChecksumIsValid(response)).isFalse();
}
 

@Test
public void responseChecksumIsValid_serverSideEncryption_false() {
    SdkHttpResponse response = SdkHttpResponse.builder()
                                              .putHeader(SERVER_SIDE_ENCRYPTION_HEADER, AWS_KMS.toString())
                                              .build();

    assertThat(responseChecksumIsValid(response)).isFalse();
}
 

@Before
public void setup() throws Exception {
    when(sdkHttpClient.prepareRequest(any())).thenReturn(abortableCallable);
    httpClient = HttpTestUtils.testClientBuilder().httpClient(sdkHttpClient)
                              .apiCallTimeout(Duration.ofMillis(1000))
                              .build();
    when(abortableCallable.call()).thenReturn(HttpExecuteResponse.builder().response(SdkHttpResponse.builder()
                                                                                                    .statusCode(200)
                                                                                                    .build())
                                                                 .build());
}
 

/**
 * Returns the recommended clock adjustment that should be used for future requests (in seconds). The result has the same
 * semantics of {@link HttpClientDependencies#timeOffset()}. Positive values imply the client clock is "fast" and negative
 * values imply the client clock is "slow".
 */
public Integer getAdjustmentInSeconds(SdkHttpResponse response) {
    Instant now = Instant.now();
    Instant serverTime = ClockSkew.getServerTime(response).orElse(null);
    Duration skew = ClockSkew.getClockSkew(now, serverTime);
    try {
        return Math.toIntExact(skew.getSeconds());
    } catch (ArithmeticException e) {
        log.warn(() -> "The clock skew between the client and server was too large to be compensated for (" + now +
                       " versus " + serverTime + ").");
        return 0;
    }
}
 

@Test
public void modifyAsyncHttpResponseContent_getObjectRequest_responseDoesNotContainChecksum_shouldNotModify() {
    ExecutionAttributes executionAttributes = getExecutionAttributesWithChecksumDisabled();
    SdkHttpResponse sdkHttpResponse = SdkHttpResponse.builder()
                                                     .putHeader(CONTENT_LENGTH_HEADER, "100")
                                                     .build();
    Context.ModifyHttpResponse modifyHttpResponse =
        InterceptorTestUtils.modifyHttpResponse(GetObjectRequest.builder().build(), sdkHttpResponse);
    Optional<Publisher<ByteBuffer>> publisher = interceptor.modifyAsyncHttpResponseContent(modifyHttpResponse,
                                                                                           executionAttributes);
    assertThat(publisher).isEqualTo(modifyHttpResponse.responsePublisher());
}