/** returns how much time is left (negative if {@link #isExpired()}) */ public Duration getDurationRemaining() { return Duration.millis(limit.toMilliseconds() - stopwatch.elapsed(TimeUnit.MILLISECONDS)); }
private static Duration toDuration(Object duration, Duration defaultVal) { if (duration == null) return defaultVal; else return Duration.of(duration); }
public static Duration of(long value, TimeUnit unit) { return new Duration(value, unit); }
/** tries to convert given object to a Duration, parsing strings, treating numbers as millis, etc; * throws IAE if not convertable */ public static Duration of(Object o) { if (o==null) return null; if (o instanceof Duration) return (Duration)o; if (o instanceof String) return parse((String)o); if (o instanceof Number) return millis((Number)o); try { // this allows it to work with groovy TimeDuration Method millisMethod = o.getClass().getMethod("toMilliseconds"); return millis((Long)millisMethod.invoke(o)); } catch (Exception e) { // probably no such method } throw new IllegalArgumentException("Cannot convert "+o+" (type "+o.getClass()+") to a duration"); }
/** * @param timeToConsider Time for recent attempts (discard any attempts older than this) * @param criticalityPredicate What constitutes a critical cause * @param numTimes Number of "critical causes" that must happen within the time period, to consider failed */ public CriticalCauseZoneFailureDetector(Duration timeToConsider, Predicate<? super Throwable> criticalityPredicate, int numTimes) { this.timeToConsider = timeToConsider.toMilliseconds(); this.criticalityPredicate = criticalityPredicate; this.numTimes = numTimes; }
/** @deprecated since 0.6.0 use Duration parameter rather than long with millis */ public RollingTimeWindowMeanEnricher(Entity producer, AttributeSensor<T> source, AttributeSensor<Double> target, long timePeriod) { this(producer, source, target, Duration.millis(timePeriod)); }
@Override public int compareTo(Duration o) { return ((Long)toNanoseconds()).compareTo(o.toNanoseconds()); }
/** as {@link #sleep(long)} */ public static void sleep(Duration duration) { Time.sleep(duration.toMillisecondsRoundingUp()); }
public ProportionalZoneFailureDetector(int minDatapoints, Duration timeToConsider, double maxProportionFailures, Ticker ticker) { super(ticker); this.minDatapoints = minDatapoints; this.timeToConsider = timeToConsider.toMilliseconds(); this.maxProportionFailures = maxProportionFailures; }
/** returns the duration elapsed since the given timestamp (UTC) */ public static Duration elapsedSince(long timestamp) { return Duration.millis(System.currentTimeMillis() - timestamp); }
/** @see #makeTimeString(long, boolean) */ public static String makeTimeStringExact(Duration d) { return makeTimeStringNanoExact(d.toNanoseconds()); } /** @see #makeTimeString(long, boolean) */
@Override public synchronized boolean blockUntilStarted(Duration timeout) { Long endTime = timeout==null ? null : System.currentTimeMillis() + timeout.toMillisecondsRoundingUp(); while (true) { if (cancelled) throw new CancellationException(); if (result==null) try { if (timeout==null) { wait(); } else { long remaining = endTime - System.currentTimeMillis(); if (remaining>0) wait(remaining); else return false; } } catch (InterruptedException e) { Thread.currentThread().interrupt(); Throwables.propagate(e); } if (result!=null) return true; } }
public static <T> void continually(Map<String,?> flags, Supplier<? extends T> supplier, Predicate<T> predicate, String errMsg) { Duration duration = toDuration(flags.get("timeout"), Duration.ONE_SECOND); Duration period = toDuration(flags.get("period"), Duration.millis(10)); long periodMs = period.toMilliseconds(); long startTime = System.currentTimeMillis(); long expireTime = startTime+duration.toMilliseconds(); boolean first = true; while (first || System.currentTimeMillis() <= expireTime) { assertTrue(predicate.apply(supplier.get()), "supplied="+supplier.get()+"; predicate="+predicate+(errMsg!=null?"; "+errMsg:"")); if (periodMs > 0) sleep(periodMs); first = false; } }
@Override public boolean equals(Object o) { if (!(o instanceof Duration)) return false; return toMilliseconds() == ((Duration)o).toMilliseconds(); }
@Override public Duration apply(final Object input) { return brooklyn.util.time.Duration.of(input); } });
public ScheduledTask delay(long val) { return delay(Duration.millis(val)); }
/** creates new {@link Duration} instance of the given length of time */ public static Duration nanos(Number n) { return new Duration( n.longValue(), TimeUnit.NANOSECONDS ); }
/** @see #makeTimeString(long, boolean) */ public static String makeTimeStringRounded(Duration d) { return makeTimeStringNanoRounded(d.toNanoseconds()); } /** given an elapsed time, makes it readable, eg 44d 6h, or 8s 923ms, optionally rounding */
@Override public T get(Duration duration) throws InterruptedException, ExecutionException, TimeoutException { long start = System.currentTimeMillis(); Long end = duration==null ? null : start + duration.toMillisecondsRoundingUp(); while (end==null || end > System.currentTimeMillis()) { if (cancelled) throw new CancellationException(); if (result == null) { synchronized (this) { long remaining = end - System.currentTimeMillis(); if (result==null && remaining>0) wait(remaining); } } if (result != null) break; } Long remaining = end==null ? null : end - System.currentTimeMillis(); if (isDone()) { return result.get(1, TimeUnit.MILLISECONDS); } else if (remaining == null) { return result.get(); } else if (remaining > 0) { return result.get(remaining, TimeUnit.MILLISECONDS); } else { throw new TimeoutException(); } }
lastSuccessTime!=null ? lastSuccessTime+logWarningGraceTime.toMilliseconds() : currentProblemStartTimeCache!=null ? currentProblemStartTimeCache+logWarningGraceTimeOnStartup.toMilliseconds() : nowTime+logWarningGraceTimeOnStartup.toMilliseconds(); if (!lastWasProblem) { if (expiryTime <= nowTime) { currentProblemLoggedAsWarning = true; log.warn("Read of " + entity + "->" + sensor + " gave " + type + " (grace period expired, occurring for "+Duration.millis(nowTime - currentProblemStartTimeCache)+")"+ ": " + val); if (log.isDebugEnabled() && val instanceof Throwable)