How to use

roundTo

method

in

com.proofpoint.units.Duration

private FlushingFileAppender(Duration flushInterval)
{
  this.flushIntervalNanos = flushInterval.roundTo(NANOSECONDS);
}

public DecorrelatedJitteredBackoffPolicy(Duration min, Duration max)
{
  this.min = min.roundTo(TimeUnit.NANOSECONDS);
  this.max = max.roundTo(TimeUnit.NANOSECONDS);
  checkArgument(this.min <= this.max, "min is greater than max");
}

LeakyTokenBucket(Duration ttl, int reserve, Ticker ticker)
{
  windowedAdder = new WindowedAdder(ttl.roundTo(NANOSECONDS), 10, ticker);
  this.reserve = reserve;
}

  @Override
  public Duration backoff(Duration previousBackoff)
  {
    long prev = previousBackoff.roundTo(TimeUnit.NANOSECONDS);
    long range = Math.abs(prev * 3 - min);
    long randBackoff;
    if (range == 0) {
      randBackoff = min;
    } else {
      randBackoff = min + ThreadLocalRandom.current().nextLong(range);
    }
    long backoff = Math.min(max, randBackoff);

    return new Duration(backoff, TimeUnit.NANOSECONDS);
  }
}

private TokenRetryBudget(BigDecimal retryBudgetRatio, Duration retryBudgetRatioPeriod, int retryBudgetMinPerSecond, Ticker ticker)
{
  // if you only have minRetries, everything costs 1 but you
  // get no credit for requests. all credits come via time.
  if (retryBudgetRatio.equals(ZERO)) {
    depositAmount = 0;
    withdrawalAmount = 1;
  }
  else {
    depositAmount = SCALE_FACTOR.intValue();
    withdrawalAmount = SCALE_FACTOR.divide(retryBudgetRatio, ROUND_HALF_UP).intValue();
  }
  // compute the reserve by scaling retryBudgetMinPerSecond by retryBudgetRatioPeriod and retry cost
  // to allow for clients that've just started or have low rps
  int reserve = retryBudgetMinPerSecond * Ints.checkedCast(retryBudgetRatioPeriod.roundTo(SECONDS)) * withdrawalAmount;
  tokenBucket = new LeakyTokenBucket(retryBudgetRatioPeriod, reserve, ticker);
}

@Managed
public void setKeepAliveTime(String duration)
{
  requireNonNull(duration, "duration is null");
  threadPoolExecutor.setKeepAliveTime(Duration.valueOf(duration).roundTo(NANOSECONDS), NANOSECONDS);
}

  @Override
  public void mark(boolean isFailure, InstanceState uriState, HttpServiceAttemptImpl attempt, HttpServiceBalancerImpl balancer)
  {
    if (isFailure) {
      if (++uriState.numFailures >= balancer.consecutiveFailures) {
        uriState.liveness = DEAD;
        uriState.backoffPolicy = balancer.backoffPolicy;
        uriState.lastBackoff = uriState.backoffPolicy.backoff(ZERO_DURATION);
        uriState.deadUntil = balancer.ticker.read() + uriState.lastBackoff.roundTo(NANOSECONDS);
        balancer.httpServiceBalancerStats.removal(attempt.uri).add(uriState.lastBackoff);
      }
    }
    else {
      uriState.numFailures = 0;
    }
  }
},

  @Override
  public void mark(boolean isFailure, InstanceState uriState, HttpServiceAttemptImpl attempt, HttpServiceBalancerImpl balancer)
  {
    if (isFailure) {
      uriState.liveness = DEAD;
      uriState.backoffPolicy = uriState.backoffPolicy.nextAttempt();
      uriState.lastBackoff = uriState.backoffPolicy.backoff(uriState.lastBackoff);
      uriState.deadUntil = balancer.ticker.read() + uriState.lastBackoff.roundTo(NANOSECONDS);
      balancer.httpServiceBalancerStats.removal(attempt.uri).add(uriState.lastBackoff);
    }
    else {
      uriState.liveness = ALIVE;
      uriState.numFailures = 0;
      uriState.backoffPolicy = null;
      uriState.lastBackoff = null;
      balancer.httpServiceBalancerStats.revival(attempt.uri).add(1);
    }
  }
};

attempt.markBad(e.getFailureCategory());
Duration backoff = attemptBackoffPolicy.backoff(previousBackoff);
long millis = backoff.roundTo(MILLISECONDS);
try {
  Thread.sleep(millis);

}, backoff.roundTo(MILLISECONDS), MILLISECONDS);
subFuture = new RetryDelayFuture<>(scheduledFuture, attempt);