import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
@Override
public void restore() {
  // Failing here means restarting the styx scheduler and replaying all events again. This is quite time consuming
  // and distressing when deploying, so try hard.
  final Retryer<Object> retryer = RetryerBuilder.newBuilder()
      .retryIfException()
      .withWaitStrategy(WaitStrategies.exponentialWait(10, TimeUnit.SECONDS))
      .withStopStrategy(StopStrategies.stopAfterAttempt(10))
      .withRetryListener(this::onRestorePollPodsAttempt)
      .build();

  try {
    retryer.call(Executors.callable(this::tryPollPods));
  } catch (ExecutionException | RetryException e) {
    throw new RuntimeException(e);
  }
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
private String executeFunctionWithRetrying(Callable<String> callable) throws RetryException, ExecutionException {
    try {
        Retryer<String> retryer = RetryerBuilder.<String>newBuilder()
                .retryIfExceptionOfType(TemporaryWriteException.class)
                .withRetryListener(retryLogger)
                .withWaitStrategy(WaitStrategies.exponentialWait(100, 5, TimeUnit.MINUTES))
                .withStopStrategy(StopStrategies.stopAfterAttempt(MAX_RETRY))
                .build();

        return retryer.call(callable);
    } catch (ExecutionException e) {
        Throwable cause = e.getCause();
        if (cause instanceof RuntimeException) {
            throw (RuntimeException) cause;
        } else {
            throw e;
        }
    }
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
@Inject
RetryHelper(
    @GerritServerConfig Config cfg,
    Metrics metrics,
    NotesMigration migration,
    ReviewDbBatchUpdate.AssistedFactory reviewDbBatchUpdateFactory,
    NoteDbBatchUpdate.AssistedFactory noteDbBatchUpdateFactory) {
  this.metrics = metrics;
  this.migration = migration;
  this.updateFactory =
      new BatchUpdate.Factory(migration, reviewDbBatchUpdateFactory, noteDbBatchUpdateFactory);
  this.defaultTimeout =
      Duration.ofMillis(
          cfg.getTimeUnit("noteDb", null, "retryTimeout", SECONDS.toMillis(20), MILLISECONDS));
  this.waitStrategy =
      WaitStrategies.join(
          WaitStrategies.exponentialWait(
              cfg.getTimeUnit("noteDb", null, "retryMaxWait", SECONDS.toMillis(5), MILLISECONDS),
              MILLISECONDS),
          WaitStrategies.randomWait(50, MILLISECONDS));
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
private Retryer<NoteDbChangeState> ensureRebuiltRetryer(Stopwatch sw) {
  if (testEnsureRebuiltRetryer != null) {
    return testEnsureRebuiltRetryer;
  }
  // Retry the ensureRebuilt step with backoff until half the timeout has
  // expired, leaving the remaining half for the rest of the steps.
  long remainingNanos = (MILLISECONDS.toNanos(timeoutMs) / 2) - sw.elapsed(NANOSECONDS);
  remainingNanos = Math.max(remainingNanos, 0);
  return RetryerBuilder.<NoteDbChangeState>newBuilder()
      .retryIfException(e -> (e instanceof IOException) || (e instanceof OrmException))
      .withWaitStrategy(
          WaitStrategies.join(
              WaitStrategies.exponentialWait(250, MILLISECONDS),
              WaitStrategies.randomWait(50, MILLISECONDS)))
      .withStopStrategy(StopStrategies.stopAfterDelay(remainingNanos, NANOSECONDS))
      .build();
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
@Override
public RemoteConnection createRemoteConnection(String remoteAddress, RemoteType remoteType,
    LoginCredential loginCredential, int port) {

  Callable<RemoteConnection> callable = () -> remoteConnectionFactory
      .createRemoteConnection(remoteAddress, remoteType, loginCredential, port);

  Retryer<RemoteConnection> remoteConnectionRetryer =
      RetryerBuilder.<RemoteConnection>newBuilder().retryIfRuntimeException()
          .retryIfException(throwable -> throwable instanceof RemoteException)
          .withStopStrategy(StopStrategies.stopAfterAttempt(connectionRetries))
          .withWaitStrategy(WaitStrategies
              .exponentialWait(exponentialMultiplier, exponentialMaxTime, TimeUnit.SECONDS))
          .build();

  try {
    return remoteConnectionRetryer.call(callable);
  } catch (ExecutionException | RetryException e) {
    throw new RuntimeException(e);
  }
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
public BaseJdbcBufferedInserter(State state, Connection conn) {
  this.conn = conn;
  this.batchSize = state.getPropAsInt(WRITER_JDBC_INSERT_BATCH_SIZE, DEFAULT_WRITER_JDBC_INSERT_BATCH_SIZE);
  if (this.batchSize < 1) {
    throw new IllegalArgumentException(WRITER_JDBC_INSERT_BATCH_SIZE + " should be a positive number");
  }

  int maxWait = state.getPropAsInt(WRITER_JDBC_INSERT_RETRY_TIMEOUT, DEFAULT_WRITER_JDBC_INSERT_RETRY_TIMEOUT);
  int maxAttempts =
      state.getPropAsInt(WRITER_JDBC_INSERT_RETRY_MAX_ATTEMPT, DEFAULT_WRITER_JDBC_INSERT_RETRY_MAX_ATTEMPT);

  //retry after 2, 4, 8, 16... sec, allow at most maxWait sec delay
  this.retryer = RetryerBuilder.<Boolean> newBuilder().retryIfException()
      .withWaitStrategy(WaitStrategies.exponentialWait(1000, maxWait, TimeUnit.SECONDS))
      .withStopStrategy(StopStrategies.stopAfterAttempt(maxAttempts)).build();
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
/**
 * @return RetryerBuilder that retries on all exceptions except NonTransientException with exponential back off
 */
public static RetryerBuilder<Void> createRetryBuilder(State state) {
  Predicate<Throwable> transients = new Predicate<Throwable>() {
    @Override
    public boolean apply(Throwable t) {
      return !(t instanceof NonTransientException);
    }
  };

  long multiplier = state.getPropAsLong(RETRY_MULTIPLIER, 500L);
  long maxWaitMsPerInterval = state.getPropAsLong(RETRY_MAX_WAIT_MS_PER_INTERVAL, 10000);
  int maxAttempts = state.getPropAsInt(RETRY_MAX_ATTEMPTS, 5);
  return RetryerBuilder.<Void> newBuilder()
      .retryIfException(transients)
      .withWaitStrategy(WaitStrategies.exponentialWait(multiplier, maxWaitMsPerInterval, TimeUnit.MILLISECONDS)) //1, 2, 4, 8, 16 seconds delay
      .withStopStrategy(StopStrategies.stopAfterAttempt(maxAttempts)); //Total 5 attempts and fail.
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
public static void mock() {
    Waits.setInstance(new Wait() {
        @Override
        public void time(Duration waitTime) {
            // don't wait
        }

        @Override
        @SuppressWarnings("unchecked")
        protected <T> Retryer<T> getRetryer(Predicate<? super T> predicate, Duration timeout, Duration interval) {
            int numRetries = (int) (timeout.getTime() / interval.getTime());
            // we emulate the number of retries
            return RetryerBuilder.<T> newBuilder()
                    .retryIfResult(Predicates.not((Predicate<T>) predicate))
                    .retryIfRuntimeException()
                    .withWaitStrategy(WaitStrategies.noWait())
                    .withStopStrategy(StopStrategies.stopAfterAttempt(numRetries))
                    .build();
        }
    });
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
public SingularityClient(String contextPath, HttpClient httpClient, Provider<List<String>> hostsProvider, Optional<SingularityClientCredentials> credentials, boolean ssl, int retryAttempts, Predicate<HttpResponse> retryStrategy) {
  this.httpClient = httpClient;
  this.contextPath = contextPath;

  this.hostsProvider = hostsProvider;
  this.random = new Random();

  this.credentials = credentials;
  this.ssl = ssl;

  this.httpResponseRetryer = RetryerBuilder.<HttpResponse>newBuilder()
      .withStopStrategy(StopStrategies.stopAfterAttempt(retryAttempts))
      .withWaitStrategy(WaitStrategies.exponentialWait())
      .retryIfResult(retryStrategy::test)
      .retryIfException()
      .build();
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
public void notifyService(String action) throws Exception {
  long start = System.currentTimeMillis();
  Retryer<AgentCheckInResponse> retryer = RetryerBuilder.<AgentCheckInResponse>newBuilder()
      .retryIfException()
      .withStopStrategy(StopStrategies.stopAfterAttempt(configuration.getMaxNotifyServiceAttempts()))
      .withWaitStrategy(WaitStrategies.exponentialWait(1, TimeUnit.SECONDS))
      .build();

  AgentCheckInResponse agentCheckInResponse = retryer.call(checkInCallable(action, false));
  while ((agentCheckInResponse.getState() != TrafficSourceState.DONE
      && System.currentTimeMillis() - start < configuration.getAgentCheckInTimeoutMs())) {
    try {
      Thread.sleep(agentCheckInResponse.getWaitTime());
    } catch (InterruptedException ie) {
      LOG.error("Interrupted waiting for check in with service, shutting down early");
      break;
    }
    agentCheckInResponse = retryer.call(checkInCallable(action, true));
  }
  LOG.info("Finished agent check in");
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
private Collection<BaragonServiceState> getGlobalStateWithRetry() throws AgentServiceNotifyException {
  Callable<Collection<BaragonServiceState>> callable = new Callable<Collection<BaragonServiceState>>() {
    public Collection<BaragonServiceState> call() throws Exception {
      return getGlobalState();
    }
  };

  Retryer<Collection<BaragonServiceState>> retryer = RetryerBuilder.<Collection<BaragonServiceState>>newBuilder()
      .retryIfException()
      .withStopStrategy(StopStrategies.stopAfterAttempt(configuration.getMaxGetGloablStateAttempts()))
      .withWaitStrategy(WaitStrategies.exponentialWait(1, TimeUnit.SECONDS))
      .build();

  try {
    return retryer.call(callable);
  } catch (Exception e) {
    LOG.error("Could not get global state from Baragon Service");
    throw Throwables.propagate(e);
  }
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
private Retryer<Response> buildResponseRetryer() {
	final RetryListener retryListener = new RetryListener() {
		@Override
		public <V> void onRetry(Attempt<V> attempt) {
			final long attemptNumber = attempt.getAttemptNumber();
			if (attemptNumber > ONE) {
				final long delaySinceFirstAttemptInMilliseconds = attempt.getDelaySinceFirstAttempt();
				final long delaySinceFirstAttemptInSeconds = TimeUnit.SECONDS
						.convert(delaySinceFirstAttemptInMilliseconds, TimeUnit.MILLISECONDS);
				final Response response = (Response) attempt.getResult();
				response.bufferEntity();
				LOGGER.warn(String.format(RETRY_ATTEMPT_MESSAGE, delaySinceFirstAttemptInSeconds, attemptNumber,
						response.getStatus(), response.readEntity(String.class)));
			}
		}
	};

	final long maximumWaitDuration = requestRetryConfiguration.getMininumWaitDuration() * TWO;
	return RetryerBuilder.<Response> newBuilder().retryIfResult(this::shouldRetryResponse)
			.withWaitStrategy(WaitStrategies.randomWait(requestRetryConfiguration.getMininumWaitDuration(),
					requestRetryConfiguration.getMininumWaitUnit(), maximumWaitDuration,
					requestRetryConfiguration.getMininumWaitUnit()))
			.withRetryListener(retryListener)
			.withStopStrategy(StopStrategies.stopAfterDelay(requestRetryConfiguration.getTimeoutDuration(),
					requestRetryConfiguration.getTimeoutUnit()))
			.build();
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
private void uploadSingle(int sequence, Path file) throws Exception {
  Callable<Boolean> uploader = new Uploader(sequence, file);

  Retryer<Boolean> retryer = RetryerBuilder.<Boolean>newBuilder()
    .retryIfExceptionOfType(S3ServiceException.class)
    .retryIfRuntimeException()
    .withWaitStrategy(WaitStrategies.fixedWait(configuration.getRetryWaitMs(), TimeUnit.MILLISECONDS))
    .withStopStrategy(StopStrategies.stopAfterAttempt(configuration.getRetryCount()))
    .build();
  retryer.call(uploader);
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
@Override
public void interrupt() throws UnableToInterruptJobException {

    if (!isRunning()) throw new UnableToInterruptJobException("Job is not running!");

    synchronized (updateLock) {
        interruptRequested = true;

        executeThread.interrupt();
    }

    final Callable<Boolean> callable = new Callable<Boolean>() {
        @Override
        public Boolean call() throws Exception {
            return AbstractStatusInterruptableJob.this.isRunning();
        }
    };

    Retryer<Boolean> retryer = RetryerBuilder.<Boolean>newBuilder()
            .retryIfResult(Predicates.equalTo(true))
            .withWaitStrategy(WaitStrategies.fixedWait(1, TimeUnit.SECONDS))
            .withStopStrategy(StopStrategies.stopAfterDelay(10, TimeUnit.MINUTES))
            .build();
    try {
        retryer.call(callable);
    }
    catch (Exception e) {
        throw new UnableToInterruptJobException(e);
    }

    if (isRunning()) throw new UnableToInterruptJobException("Unable to stop job....");

}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
CommandQueries(List<QueryRequest> queries, Keyspace keyspace) {
    super(Setter
            .withGroupKey(HystrixCommandGroupKey.Factory.asKey("BatchExecutor"))
            .andThreadPoolPropertiesDefaults(
                    HystrixThreadPoolProperties.Setter()
                            .withCoreSize(threadPoolCoreSize)
                            // Sizing these two based on the thread pool core size
                            .withQueueSizeRejectionThreshold(
                                    threadPoolCoreSize * QUEUE_MULTIPLIER)
                            .withMaxQueueSize(threadPoolCoreSize * QUEUE_MULTIPLIER))
            .andCommandPropertiesDefaults(
                    HystrixCommandProperties.Setter()
                            .withExecutionTimeoutEnabled(false)
                            .withExecutionTimeoutInMilliseconds(timeoutMs)
                            .withRequestLogEnabled(requestLogEnabled)));

    this.queries = queries;
    this.keyspace = keyspace;
    this.graqlExecuteTimer = metricRegistry.timer(name(this.getClass(), "execute"));
    this.attemptMeter = metricRegistry.meter(name(this.getClass(), "attempt"));
    this.retryer = RetryerBuilder.<List<QueryResponse>>newBuilder()
            .retryIfException((throwable) ->
                    throwable instanceof GraknClientException
                            && ((GraknClientException) throwable).isRetriable())
            .retryIfExceptionOfType(ConnectException.class)
            .withWaitStrategy(WaitStrategies.exponentialWait(10, 1, TimeUnit.MINUTES))
            .withStopStrategy(StopStrategies.stopAfterAttempt(maxRetries + 1))
            .withRetryListener(new RetryListener() {
                @Override
                public <V> void onRetry(Attempt<V> attempt) {
                    attemptMeter.mark();
                }
            })
            .build();
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
public InfiniteRetryStrategy() {
    this.retryer = init(RetryerBuilder.<V>newBuilder()
            .retryIfResult(Predicates.equalTo((V)null))
            .retryIfException()
            .withWaitStrategy(WaitStrategies.fibonacciWait(100, 2, TimeUnit.MINUTES))
            .withStopStrategy(StopStrategies.neverStop()));
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
protected InvokeBinaryResult invokeToBinaryEndpoint(String httpMethod, String path) {
    InvokeBinaryResult returnResult = new InvokeBinaryResult();
    returnResult.setSuccess(true);

    try {
        URL url = connectorSettings
                .getUri()
                .resolve(path)
                .toURL();

        HttpURLConnection conn = getConnection(url, httpMethod);

        // Retrieves with connection status code
        String statusCode = getStatusCode(conn);
        returnResult.setStatusCode(statusCode);

        // Retry pattern for x times invoke if read input fails
        final HttpURLConnection finalConn = conn;
        Callable<byte[]> callable = () -> readBinaryInputFromConnection(finalConn);
        Retryer<byte[]> retryer = RetryerBuilder.<byte[]>newBuilder()
                .retryIfResult(Predicates.<byte[]>isNull())
                .retryIfExceptionOfType(IOException.class)
                .retryIfRuntimeException()
                .withWaitStrategy(WaitStrategies.fixedWait(RETRY_WAIT_TIME, TimeUnit.MILLISECONDS))
                .withStopStrategy(StopStrategies.stopAfterAttempt(connectorSettings.getRetryCount()))
                .build();

        // Reads the response from connection
        byte[] returnValue = retryer.call(callable);
        returnResult.setResult(returnValue);

    } catch (ExecutionException | RetryException |ServerIsNotAvailableException |IOException | NoSuchAlgorithmException | KeyManagementException e) {
        return (InvokeBinaryResult)invokeExceptionResult(returnResult, e);
    }
    return returnResult;
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
private VirtualMachine cloneMaster(VirtualMachine master, String tag, String name, VirtualMachineCloneSpec cloneSpec, String folderName) {

      VirtualMachine cloned = null;
      try {
         FolderNameToFolderManagedEntity toFolderManagedEntity = new FolderNameToFolderManagedEntity(serviceInstance, master);
         Folder folder = toFolderManagedEntity.apply(folderName);
         Task task = master.cloneVM_Task(folder, name, cloneSpec);
         String result = task.waitForTask();
         if (result.equals(Task.SUCCESS)) {
            logger.trace("<< after clone search for VM with name: " + name);
            Retryer<VirtualMachine> retryer = RetryerBuilder.<VirtualMachine>newBuilder()
                    .retryIfResult(Predicates.<VirtualMachine>isNull())
                    .withStopStrategy(StopStrategies.stopAfterAttempt(5))
                    .retryIfException().withWaitStrategy(WaitStrategies.fixedWait(1, TimeUnit.SECONDS))
                    .build();
            cloned = retryer.call(new GetVirtualMachineCallable(name, folder, serviceInstance.get().getInstance().getRootFolder()));
         } else {
            String errorMessage = task.getTaskInfo().getError().getLocalizedMessage();
            logger.error(errorMessage);
         }
      } catch (Exception e) {
         if (e instanceof NoPermission){
            NoPermission noPermission = (NoPermission)e;
            logger.error("NoPermission: " + noPermission.getPrivilegeId());
         }
         logger.error("Can't clone vm: " + e.toString(), e);
         propagate(e);
      }
      if (cloned == null)
         logger.error("<< Failed to get cloned VM. " + name);
      return checkNotNull(cloned, "cloned");
   }
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
public void testRetryer() throws ExecutionException, RetryException {
   Retryer<Boolean> retryer = RetryerBuilder.<Boolean>newBuilder()
           .retryIfResult(new Predicate<Boolean>() {
              @Override
              public boolean apply(@Nullable Boolean aBoolean) {
                 return aBoolean.equals(false);
              }
           })
           .withStopStrategy(StopStrategies.stopAfterAttempt(5))
           .retryIfException().withWaitStrategy(WaitStrategies.fixedWait(500, TimeUnit.MILLISECONDS))
           .build();

   Assert.assertTrue(retryer.call(new TempCallable()), "Should return true");
}
 

import com.github.rholder.retry.WaitStrategies; //导入依赖的package包/类
/**
 * @throws Exception If failed.
 */
public void testConnectionStatusWithBrokerDisconnection() throws Exception {
    fail("https://issues.apache.org/jira/browse/IGNITE-2255");

    // Configure streamer.
    streamer.setSingleTupleExtractor(singleTupleExtractor());
    streamer.setTopic(SINGLE_TOPIC_NAME);
    streamer.setBlockUntilConnected(true);
    streamer.setRetryWaitStrategy(WaitStrategies.noWait());

    streamer.start();

    // Action time: repeat 5 times; make sure the connection state is kept correctly every time.
    for (int i = 0; i < 5; i++) {
        log.info("Iteration: " + i);

        assertTrue(streamer.isConnected());

        broker.stop();

        assertFalse(streamer.isConnected());

        broker.start(true);
        broker.waitUntilStarted();

        Thread.sleep(500);
    }
}