Rename Execution.getWaitTime to getDelay

Author: jhalterman

src/main/java/net/jodah/failsafe/AbstractExecution.java

@@ -39,8 +39,8 @@ public abstract class AbstractExecution<R> extends ExecutionContext<R> {
   volatile boolean attemptStarted;
   // Whether the execution attempt has been recorded
   volatile boolean attemptRecorded;
-  // The wait time in nanoseconds
-  volatile long waitNanos;
+  // The delay time in nanoseconds
+  volatile long delayNanos;
   // Whether the entire Failsafe execution has been completed
   volatile boolean completed;
 
@@ -125,17 +125,17 @@ synchronized ExecutionResult postExecute(ExecutionResult result) {
       allComplete = allComplete && result.isComplete();
     }
 
-    waitNanos = result.getWaitNanos();
+    delayNanos = result.getDelay();
     completed = allComplete;
     return result;
   }
 
   /**
-   * Returns the time to wait before the next execution attempt. Returns {@code 0} if an execution has not yet
+   * Returns the time to delay before the next execution attempt. Returns {@code 0} if an execution has not yet
    * occurred.
    */
-  public Duration getWaitTime() {
-    return Duration.ofNanos(waitNanos);
+  public Duration getDelay() {
+    return Duration.ofNanos(delayNanos);
   }
 
   /**

src/main/java/net/jodah/failsafe/AsyncExecution.java

@@ -98,7 +98,7 @@ public void record(R result, Throwable failure) {
     // Guard against race with a timeout expiring
     synchronized (future) {
       if (!attemptRecorded) {
-        ExecutionResult er = new ExecutionResult(result, failure).withWaitNanos(waitNanos);
+        ExecutionResult er = new ExecutionResult(result, failure).withDelay(delayNanos);
         record(er);
       }
 

src/main/java/net/jodah/failsafe/ExecutionResult.java

@@ -38,7 +38,7 @@ public final class ExecutionResult {
   /** Whether the result represents a non result rather than a {@code null} result */
   private final boolean nonResult;
   /** The amount of time to wait prior to the next execution, according to the policy */
-  private final long waitNanos;
+  private final long delayNanos;
   /** Whether a policy has completed handling of the execution */
   private final boolean complete;
   /** Whether a policy determined the execution to be a success */
@@ -54,12 +54,12 @@ public ExecutionResult(Object result, Throwable failure) {
     this(result, failure, false, 0, true, failure == null, failure == null);
   }
 
-  private ExecutionResult(Object result, Throwable failure, boolean nonResult, long waitNanos, boolean complete,
+  private ExecutionResult(Object result, Throwable failure, boolean nonResult, long delayNanos, boolean complete,
     boolean success, Boolean successAll) {
     this.nonResult = nonResult;
     this.result = result;
     this.failure = failure;
-    this.waitNanos = waitNanos;
+    this.delayNanos = delayNanos;
     this.complete = complete;
     this.success = success;
     this.successAll = successAll;
@@ -84,8 +84,8 @@ public Throwable getFailure() {
     return failure;
   }
 
-  public long getWaitNanos() {
-    return waitNanos;
+  public long getDelay() {
+    return delayNanos;
   }
 
   public boolean isComplete() {
@@ -107,7 +107,7 @@ public boolean isSuccess() {
   ExecutionResult withNonResult() {
     return success && this.result == null && nonResult ?
       this :
-      new ExecutionResult(null, null, true, waitNanos, true, true, successAll);
+      new ExecutionResult(null, null, true, delayNanos, true, true, successAll);
   }
 
   /**
@@ -119,7 +119,7 @@ public ExecutionResult withResult(Object result) {
     boolean unchangedNotNull = this.result != null && this.result.equals(result);
     return success && (unchangedNull || unchangedNotNull) ?
       this :
-      new ExecutionResult(result, null, nonResult, waitNanos, true, true, successAll);
+      new ExecutionResult(result, null, nonResult, delayNanos, true, true, successAll);
   }
 
   /**
@@ -128,14 +128,14 @@ public ExecutionResult withResult(Object result) {
   ExecutionResult withNotComplete() {
     return !this.complete ?
       this :
-      new ExecutionResult(result, failure, nonResult, waitNanos, false, success, successAll);
+      new ExecutionResult(result, failure, nonResult, delayNanos, false, success, successAll);
   }
 
   /**
    * Returns a copy of the ExecutionResult with success value of {code false}.
    */
   ExecutionResult withFailure() {
-    return !this.success ? this : new ExecutionResult(result, failure, nonResult, waitNanos, complete, false, false);
+    return !this.success ? this : new ExecutionResult(result, failure, nonResult, delayNanos, complete, false, false);
   }
 
   /**
@@ -144,25 +144,25 @@ ExecutionResult withFailure() {
   ExecutionResult withSuccess() {
     return this.complete && this.success ?
       this :
-      new ExecutionResult(result, failure, nonResult, waitNanos, true, true, successAll);
+      new ExecutionResult(result, failure, nonResult, delayNanos, true, true, successAll);
   }
 
   /**
-   * Returns a copy of the ExecutionResult with the {@code waitNanos} value.
+   * Returns a copy of the ExecutionResult with the {@code delayNanos} value.
    */
-  public ExecutionResult withWaitNanos(long waitNanos) {
-    return this.waitNanos == waitNanos ?
+  public ExecutionResult withDelay(long delayNanos) {
+    return this.delayNanos == delayNanos ?
       this :
-      new ExecutionResult(result, failure, nonResult, waitNanos, complete, success, successAll);
+      new ExecutionResult(result, failure, nonResult, delayNanos, complete, success, successAll);
   }
 
   /**
-   * Returns a copy of the ExecutionResult with the {@code waitNanos}, {@code complete} and {@code success} values.
+   * Returns a copy of the ExecutionResult with the {@code delayNanos}, {@code complete} and {@code success} values.
    */
-  public ExecutionResult with(long waitNanos, boolean complete, boolean success) {
-    return this.waitNanos == waitNanos && this.complete == complete && this.success == success ?
+  public ExecutionResult with(long delayNanos, boolean complete, boolean success) {
+    return this.delayNanos == delayNanos && this.complete == complete && this.success == success ?
       this :
-      new ExecutionResult(result, failure, nonResult, waitNanos, complete, success,
+      new ExecutionResult(result, failure, nonResult, delayNanos, complete, success,
         successAll == null ? success : success && successAll);
   }
 
@@ -172,7 +172,7 @@ boolean getSuccessAll() {
 
   @Override
   public String toString() {
-    return "[" + "result=" + result + ", failure=" + failure + ", nonResult=" + nonResult + ", waitNanos=" + waitNanos
+    return "[" + "result=" + result + ", failure=" + failure + ", nonResult=" + nonResult + ", delayNanos=" + delayNanos
       + ", complete=" + complete + ", success=" + success + ", successAll=" + successAll + ']';
   }
 

src/main/java/net/jodah/failsafe/RetryPolicyExecutor.java

@@ -39,8 +39,8 @@ class RetryPolicyExecutor<R> extends PolicyExecutor<R, RetryPolicy<R>> {
   // Mutable state
   private volatile int failedAttempts;
   private volatile boolean retriesExceeded;
-  /** The fixed, backoff, random or computed delay time in nanoseconds. */
-  private volatile long delayNanos;
+  /** The last fixed, backoff, random or computed delay time in nanoseconds. */
+  private volatile long lastDelayNanos;
 
   // Listeners
   private final EventListener abortListener;
@@ -80,7 +80,7 @@ protected Function<Execution<R>, ExecutionResult> apply(Function<Execution<R>, E
 
           // Guard against race with Timeout so that sleep can either be skipped or interrupted
           execution.interruptState.canInterrupt = true;
-          Thread.sleep(TimeUnit.NANOSECONDS.toMillis(result.getWaitNanos()));
+          Thread.sleep(TimeUnit.NANOSECONDS.toMillis(result.getDelay()));
         } catch (InterruptedException e) {
           // Set interrupt flag if interrupt was not intended
           if (!execution.interruptState.interrupted)
@@ -155,7 +155,7 @@ public Object handleAsync(AsyncExecution<R> execution,
                       future.inject(retryExecution);
                       Callable<Object> retryFn = () -> handleAsync(retryExecution, innerFn, scheduler, future, promise,
                         previousResultRef);
-                      Future<?> scheduledRetry = scheduler.schedule(retryFn, postResult.getWaitNanos(),
+                      Future<?> scheduledRetry = scheduler.schedule(retryFn, postResult.getDelay(),
                         TimeUnit.NANOSECONDS);
                       retryExecution.innerFuture = scheduledRetry;
 
@@ -202,22 +202,22 @@ protected ExecutionResult onFailure(AbstractExecution<R> execution, ExecutionRes
       failedAttemptListener.handle(result, execution);
 
     failedAttempts++;
-    long waitNanos = delayNanos;
+    long delayNanos = lastDelayNanos;
 
     // Determine the computed delay
     Duration computedDelay = policy.computeDelay(execution);
     if (computedDelay != null) {
-      waitNanos = computedDelay.toNanos();
+      delayNanos = computedDelay.toNanos();
     } else {
       // Determine the fixed or random delay
-      waitNanos = getFixedOrRandomDelayNanos(waitNanos);
-      waitNanos = adjustForBackoff(execution, waitNanos);
-      delayNanos = waitNanos;
+      delayNanos = getFixedOrRandomDelayNanos(delayNanos);
+      delayNanos = adjustForBackoff(execution, delayNanos);
+      lastDelayNanos = delayNanos;
     }
 
-    waitNanos = adjustForJitter(waitNanos);
+    delayNanos = adjustForJitter(delayNanos);
     long elapsedNanos = execution.getElapsedTime().toNanos();
-    waitNanos = adjustForMaxDuration(waitNanos, elapsedNanos);
+    delayNanos = adjustForMaxDuration(delayNanos, elapsedNanos);
 
     // Calculate result
     boolean maxRetriesExceeded = policy.getMaxRetries() != -1 && failedAttempts > policy.getMaxRetries();
@@ -234,7 +234,7 @@ protected ExecutionResult onFailure(AbstractExecution<R> execution, ExecutionRes
     else if (retriesExceededListener != null && !success && retriesExceeded)
       retriesExceededListener.handle(result, execution);
 
-    return result.with(waitNanos, completed, success);
+    return result.with(delayNanos, completed, success);
   }
 
   /**
@@ -247,39 +247,39 @@ protected CompletableFuture<ExecutionResult> onFailureAsync(AbstractExecution<R>
     return super.onFailureAsync(execution, result.withNotComplete(), scheduler, future);
   }
 
-  private long getFixedOrRandomDelayNanos(long waitNanos) {
+  private long getFixedOrRandomDelayNanos(long delayNanos) {
     Duration delay = policy.getDelay();
     Duration delayMin = policy.getDelayMin();
     Duration delayMax = policy.getDelayMax();
 
-    if (waitNanos == 0 && delay != null && !delay.equals(Duration.ZERO))
-      waitNanos = delay.toNanos();
+    if (delayNanos == 0 && delay != null && !delay.equals(Duration.ZERO))
+      delayNanos = delay.toNanos();
     else if (delayMin != null && delayMax != null)
-      waitNanos = randomDelayInRange(delayMin.toNanos(), delayMax.toNanos(), Math.random());
-    return waitNanos;
+      delayNanos = randomDelayInRange(delayMin.toNanos(), delayMax.toNanos(), Math.random());
+    return delayNanos;
   }
 
-  private long adjustForBackoff(AbstractExecution<R> execution, long waitNanos) {
+  private long adjustForBackoff(AbstractExecution<R> execution, long delayNanos) {
     if (execution.getAttemptCount() != 1 && policy.getMaxDelay() != null)
-      waitNanos = (long) Math.min(waitNanos * policy.getDelayFactor(), policy.getMaxDelay().toNanos());
-    return waitNanos;
+      delayNanos = (long) Math.min(delayNanos * policy.getDelayFactor(), policy.getMaxDelay().toNanos());
+    return delayNanos;
   }
 
-  private long adjustForJitter(long waitNanos) {
+  private long adjustForJitter(long delayNanos) {
     if (policy.getJitter() != null)
-      waitNanos = randomDelay(waitNanos, policy.getJitter().toNanos(), Math.random());
+      delayNanos = randomDelay(delayNanos, policy.getJitter().toNanos(), Math.random());
     else if (policy.getJitterFactor() > 0.0)
-      waitNanos = randomDelay(waitNanos, policy.getJitterFactor(), Math.random());
-    return waitNanos;
+      delayNanos = randomDelay(delayNanos, policy.getJitterFactor(), Math.random());
+    return delayNanos;
   }
 
-  private long adjustForMaxDuration(long waitNanos, long elapsedNanos) {
+  private long adjustForMaxDuration(long delayNanos, long elapsedNanos) {
     if (policy.getMaxDuration() != null) {
-      long maxRemainingWaitTime = policy.getMaxDuration().toNanos() - elapsedNanos;
-      waitNanos = Math.min(waitNanos, maxRemainingWaitTime < 0 ? 0 : maxRemainingWaitTime);
-      if (waitNanos < 0)
-        waitNanos = 0;
+      long maxRemainingDelay = policy.getMaxDuration().toNanos() - elapsedNanos;
+      delayNanos = Math.min(delayNanos, maxRemainingDelay < 0 ? 0 : maxRemainingDelay);
+      if (delayNanos < 0)
+        delayNanos = 0;
     }
-    return waitNanos;
+    return delayNanos;
   }
 }

src/main/java/net/jodah/failsafe/internal/EventListener.java

@@ -58,7 +58,7 @@ static <R> EventListener ofScheduled(CheckedConsumer<? extends ExecutionSchedule
       try {
         ((CheckedConsumer<ExecutionScheduledEvent<R>>) handler).accept(
           new ExecutionScheduledEvent<>(result.getResult(), result.getFailure(),
-            Duration.ofNanos(result.getWaitNanos()), context));
+            Duration.ofNanos(result.getDelay()), context));
       } catch (Throwable ignore) {
       }
     };