org.springframework.util.backoff.BackOffExecution#STOP源码实例Demo

/**
 * Apply the next back-off time using the specified {@link BackOffExecution}.
 * <p>Return {@code true} if the back-off period has been applied and a new
 * attempt to recover should be made, {@code false} if no further attempt
 * should be made.
 * @since 4.1
 */
protected boolean applyBackOffTime(BackOffExecution execution) {
	if (this.recovering && this.interrupted) {
		// Interrupted right before and still failing... give up.
		return false;
	}
	long interval = execution.nextBackOff();
	if (interval == BackOffExecution.STOP) {
		return false;
	}
	else {
		try {
			synchronized (this.lifecycleMonitor) {
				this.lifecycleMonitor.wait(interval);
			}
		}
		catch (InterruptedException interEx) {
			// Re-interrupt current thread, to allow other threads to react.
			Thread.currentThread().interrupt();
			if (this.recovering) {
				this.interrupted = true;
			}
		}
		return true;
	}
}
 

/**
 * Apply the next back-off time using the specified {@link BackOffExecution}.
 * <p>Return {@code true} if the back-off period has been applied and a new
 * attempt to recover should be made, {@code false} if no further attempt
 * should be made.
 * @since 4.1
 */
protected boolean applyBackOffTime(BackOffExecution execution) {
	if (this.recovering && this.interrupted) {
		// Interrupted right before and still failing... give up.
		return false;
	}
	long interval = execution.nextBackOff();
	if (interval == BackOffExecution.STOP) {
		return false;
	}
	else {
		try {
			synchronized (this.lifecycleMonitor) {
				this.lifecycleMonitor.wait(interval);
			}
		}
		catch (InterruptedException interEx) {
			// Re-interrupt current thread, to allow other threads to react.
			Thread.currentThread().interrupt();
			if (this.recovering) {
				this.interrupted = true;
			}
		}
		return true;
	}
}
 

/**
 * Apply the next back off time using the specified {@link BackOffExecution}.
 * <p>Return {@code true} if the back off period has been applied and a new
 * attempt to recover should be made, {@code false} if no further attempt
 * should be made.
 */
protected boolean applyBackOffTime(BackOffExecution execution) {
	long interval = execution.nextBackOff();
	if (interval == BackOffExecution.STOP) {
		return false;
	}
	else {
		try {
			Thread.sleep(interval);
		}
		catch (InterruptedException interEx) {
			// Re-interrupt current thread, to allow other threads to react.
			Thread.currentThread().interrupt();
		}
	}
	return true;
}
 

public <T> T retry(String description, Callable<T> callable) throws Exception {
  ExponentialBackOff backOff =
      new ExponentialBackOff(
          retryConfiguration.getInitialBackoffMillis(),
          retryConfiguration.getRetryMultiplier());
  backOff.setMaxElapsedTime(retryConfiguration.getMaxBackoffMillis());
  BackOffExecution backOffExec = backOff.start();
  while (true) {
    try {
      return callable.call();
    } catch (Throwable e) {
      long waitTime = backOffExec.nextBackOff();
      if (waitTime == BackOffExecution.STOP) {
        throw e;
      }
      log.warn(description + " failed. Retrying in " + waitTime + "ms", e);
      TimeUnit.MILLISECONDS.sleep(waitTime);
    }
  }
}
 

@Override
public Response intercept(Chain chain) throws IOException {
  ExponentialBackOff backoff = new ExponentialBackOff();
  backoff.setMaxElapsedTime(maxElapsedBackoffMs);
  BackOffExecution backOffExec = backoff.start();

  Response response = null;
  long waitTime = 0;
  while (waitTime != BackOffExecution.STOP) {
    Request request = chain.request();
    response = chain.proceed(request);
    if (response.isSuccessful()
        || NON_RETRYABLE_METHODS.contains(request.method())
        || response.code() == 404) {
      return response;
    }

    try {
      waitTime = backOffExec.nextBackOff();
      if (waitTime != BackOffExecution.STOP) {
        if (response.body() != null) {
          response.body().close();
        }
        log.warn(
            "Request for "
                + request.url().toString()
                + " failed. Backing off for "
                + waitTime
                + "ms");
        Thread.sleep(waitTime);
      }
    } catch (Throwable ignored) {
      break;
    }
  }
  return response;
}
 

public long syncAndReturn(List<String> roles) {
  FixedBackOff backoff = new FixedBackOff();
  backoff.setInterval(retryIntervalMs);
  backoff.setMaxAttempts(Math.floorDiv(syncDelayTimeoutMs, retryIntervalMs) + 1);
  BackOffExecution backOffExec = backoff.start();

  // after this point the execution will get rescheduled
  final long timeout = System.currentTimeMillis() + syncDelayTimeoutMs;

  if (!isServerHealthy()) {
    log.warn(
        "Server is currently UNHEALTHY. User permission role synchronization and "
            + "resolution may not complete until this server becomes healthy again.");
  }

  // Ensure we're going to reload app and service account definitions
  permissionsResolver.clearCache();

  while (true) {
    try {
      Map<String, UserPermission> combo = new HashMap<>();
      // force a refresh of the unrestricted user in case the backing repository is empty:
      combo.put(UnrestrictedResourceConfig.UNRESTRICTED_USERNAME, new UserPermission());
      Map<String, UserPermission> temp;
      if (!(temp = getUserPermissions(roles)).isEmpty()) {
        combo.putAll(temp);
      }
      if (!(temp = getServiceAccountsAsMap(roles)).isEmpty()) {
        combo.putAll(temp);
      }

      return updateUserPermissions(combo);
    } catch (ProviderException | PermissionResolutionException ex) {
      registry
          .counter(metricName("syncFailure"), "cause", ex.getClass().getSimpleName())
          .increment();
      Status status = healthIndicator.health().getStatus();
      long waitTime = backOffExec.nextBackOff();
      if (waitTime == BackOffExecution.STOP || System.currentTimeMillis() > timeout) {
        String cause = (waitTime == BackOffExecution.STOP) ? "backoff-exhausted" : "timeout";
        registry.counter("syncAborted", "cause", cause).increment();
        log.error("Unable to resolve service account permissions.", ex);
        return 0;
      }
      String message =
          new StringBuilder("User permission sync failed. ")
              .append("Server status is ")
              .append(status)
              .append(". Trying again in ")
              .append(waitTime)
              .append(" ms. Cause:")
              .append(ex.getMessage())
              .toString();
      if (log.isDebugEnabled()) {
        log.debug(message, ex);
      } else {
        log.warn(message);
      }

      try {
        Thread.sleep(waitTime);
      } catch (InterruptedException ignored) {
      }
    } finally {
      isServerHealthy();
    }
  }
}