software.amazon.awssdk.core.retry.conditions.RetryCondition Java Examples

@Test
public void conditionsAreEvaluatedInOrder() {
    int numConditions = 1000;
    int firstTrueCondition = 500;

    RetryCondition[] conditions = new RetryCondition[numConditions];
    for (int i = 0; i < numConditions; ++i) {
        RetryCondition mock = Mockito.mock(RetryCondition.class);
        when(mock.shouldRetry(RetryPolicyContexts.EMPTY)).thenReturn(i == firstTrueCondition);
        conditions[i] = mock;
    }

    assertTrue(OrRetryCondition.create(conditions).shouldRetry(RetryPolicyContexts.EMPTY));

    for (int i = 0; i < numConditions; ++i) {
        int timesExpected = i <= firstTrueCondition ? 1 : 0;
        Mockito.verify(conditions[i], times(timesExpected)).shouldRetry(RetryPolicyContexts.EMPTY);
    }
}
 

@Test
public void conditionsAreEvaluatedInOrder() {
    int numConditions = 1000;
    int firstFalseCondition = 500;

    RetryCondition[] conditions = new RetryCondition[numConditions];
    for (int i = 0; i < numConditions; ++i) {
        RetryCondition mock = Mockito.mock(RetryCondition.class);
        when(mock.shouldRetry(RetryPolicyContexts.EMPTY)).thenReturn(i != firstFalseCondition);
        conditions[i] = mock;
    }

    assertFalse(AndRetryCondition.create(conditions).shouldRetry(RetryPolicyContexts.EMPTY));

    for (int i = 0; i < numConditions; ++i) {
        int timesExpected = i <= firstFalseCondition ? 1 : 0;
        Mockito.verify(conditions[i], times(timesExpected)).shouldRetry(RetryPolicyContexts.EMPTY);
    }
}
 

private StsWebIdentityCredentialsProvider(WebIdentityTokenCredentialProperties credentialProperties) {
    String roleSessionName = credentialProperties.roleSessionName();
    String sessionName = roleSessionName != null ? roleSessionName : "aws-sdk-java-" + System.currentTimeMillis();

    OrRetryCondition retryCondition = OrRetryCondition.create(new StsRetryCondition(),
                                                              RetryCondition.defaultRetryCondition());

    this.stsClient = StsClient.builder()
                              .applyMutation(this::configureEndpoint)
                              .credentialsProvider(AnonymousCredentialsProvider.create())
                              .overrideConfiguration(o -> o.retryPolicy(r -> r.retryCondition(retryCondition)))
                              .build();

    AssumeRoleWithWebIdentityRequest request = AssumeRoleWithWebIdentityRequest.builder()
                                                                               .roleArn(credentialProperties.roleArn())
                                                                               .roleSessionName(sessionName)
                                                                               .build();

    AssumeRoleWithWebIdentityRequestSupplier supplier =
        new AssumeRoleWithWebIdentityRequestSupplier(request,
                                                     credentialProperties.webIdentityTokenFile());

    this.credentialsProvider =
        StsAssumeRoleWithWebIdentityCredentialsProvider.builder()
                                                       .stsClient(stsClient)
                                                       .refreshRequest(supplier)
                                                       .build();
}
 

/**
 * Create a {@link RetryPolicy} that will NEVER retry.
 */
public static RetryPolicy none() {
    return RetryPolicy.builder()
                      .numRetries(0)
                      .backoffStrategy(BackoffStrategy.none())
                      .throttlingBackoffStrategy(BackoffStrategy.none())
                      .retryCondition(RetryCondition.none())
                      .additionalRetryConditionsAllowed(false)
                      .build();
}
 

private RetryCondition generateAggregateRetryCondition() {
    RetryCondition aggregate = AndRetryCondition.create(MaxNumberOfRetriesCondition.create(numRetries),
                                                        retryCondition);
    if (retryCapacityCondition != null) {
        return AndRetryCondition.create(aggregate, retryCapacityCondition);
    }
    return aggregate;
}
 

private BuilderImpl(RetryMode retryMode) {
    this.retryMode = retryMode;
    this.numRetries = SdkDefaultRetrySetting.maxAttempts(retryMode) - 1;
    this.additionalRetryConditionsAllowed = true;
    this.backoffStrategy = BackoffStrategy.defaultStrategy();
    this.throttlingBackoffStrategy = BackoffStrategy.defaultThrottlingStrategy();
    this.retryCondition = RetryCondition.defaultRetryCondition();
    this.retryCapacityCondition = TokenBucketRetryCondition.forRetryMode(retryMode);
}
 

/**
 * Retrieve the {@link RetryCondition#defaultRetryCondition()} with AWS-specific conditions added.
 */
public static RetryCondition defaultRetryCondition() {
    return OrRetryCondition.create(RetryCondition.defaultRetryCondition(), awsRetryCondition());
}
 

private RetryPolicy buildRetryPolicy(RetryPolicyConfiguration config) {
  RetryPolicy retryPolicy;

  if (config == null) {
    retryPolicy = RetryPolicy.none();
  } else {
    switch (config.getPolicy()) {
      case DEFAULT:
        retryPolicy = RetryPolicy.defaultRetryPolicy();
        break;
      case NONE:
        retryPolicy = RetryPolicy.none();
        break;
      default:
        RetryCondition condition;
        BackoffStrategy strategy;

        switch (config.getCondition()) {
          case DEFAULT:
            condition = RetryCondition.defaultRetryCondition();
            break;
          case MAX_NUM:
            condition = MaxNumberOfRetriesCondition.create(config.getNumRetries());
            break;
          default:
            condition = RetryCondition.none();
        }

        switch (config.getBackOff()) {
          case FULL_JITTER:
            strategy =
                FullJitterBackoffStrategy.builder()
                    .baseDelay(Duration.ofMillis(config.getBaseDelay()))
                    .maxBackoffTime(Duration.ofMillis(config.getMaximumBackoffTime()))
                    .build();
            break;
          case EQUAL_JITTER:
            strategy =
                EqualJitterBackoffStrategy.builder()
                    .baseDelay(Duration.ofMillis(config.getBaseDelay()))
                    .maxBackoffTime(Duration.ofMillis(config.getMaximumBackoffTime()))
                    .build();
            break;
          case FIXED_DELAY:
            strategy = FixedDelayBackoffStrategy.create(Duration.ofMillis(config.getBaseDelay()));
            break;
          case DEFAULT:
            strategy = BackoffStrategy.defaultStrategy();
            break;
          case DEFAULT_THROTTLE:
            strategy = BackoffStrategy.defaultThrottlingStrategy();
            break;
          default:
            strategy = BackoffStrategy.none();
        }

        retryPolicy =
            RetryPolicy.builder()
                .numRetries(config.getNumRetries())
                .retryCondition(condition)
                .backoffStrategy(strategy)
                .build();
    }
  }

  return retryPolicy;
}
 

private boolean shouldRetry(Consumer<RetryPolicyContext.Builder> builder) {
    return RetryCondition.defaultRetryCondition().shouldRetry(RetryPolicyContext.builder()
                                                                .applyMutation(builder)
                                                                .build());
}
 

@Test
public void noStatusCodesInList_ReturnsFalse() {
    final RetryCondition noStatusCodes = RetryOnStatusCodeCondition.create(Collections.emptySet());
    assertFalse(noStatusCodes.shouldRetry(RetryPolicyContexts.withStatusCode(404)));
}
 

@Override
public RetryCondition retryCapacityCondition() {
    return this.retryCapacityCondition;
}
 

public void setRetryCapacityCondition(RetryCondition retryCapacityCondition) {
    retryCapacityCondition(retryCapacityCondition);
}
 

@Override
public RetryCondition retryCondition() {
    return retryCondition;
}
 

public void setRetryCondition(RetryCondition retryCondition) {
    retryCondition(retryCondition);
}
 

/**
 * Retrieve the {@link Builder#retryCondition(RetryCondition)} configured on the builder.
 */
public RetryCondition retryCondition() {
    return retryCondition;
}
 

/**
 * @see #retryCapacityCondition(RetryCondition)
 */
RetryCondition retryCapacityCondition();
 

/**
 * @see #retryCondition(RetryCondition)
 */
RetryCondition retryCondition();
 

/**
 * Retrieve the retry condition that aggregates the {@link Builder#retryCondition(RetryCondition)},
 * {@link Builder#numRetries(Integer)} and {@link Builder#retryCapacityCondition(RetryCondition)} configured on the builder.
 */
public RetryCondition aggregateRetryCondition() {
    return aggregateRetryCondition;
}