use constants for wait periods/limits in code
Project: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/commit/8df4cdfd Tree: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/tree/8df4cdfd Diff: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/diff/8df4cdfd Branch: refs/heads/master Commit: 8df4cdfd130103776a0abfbb77ddc10177fd004c Parents: 8e99674 Author: Alex Heneveld <[email protected]> Authored: Tue Jun 23 23:36:06 2015 -0700 Committer: Alex Heneveld <[email protected]> Committed: Wed Jun 24 01:04:24 2015 -0700 ---------------------------------------------------------------------- .../brooklyn/enricher/basic/Propagator.java | 4 ++-- .../brooklyn/enricher/basic/Transformer.java | 6 +++--- .../entity/basic/ServiceStateLogic.java | 3 ++- .../rebind/PeriodicDeltaChangeListener.java | 3 ++- .../event/basic/DependentConfiguration.java | 10 ++++++---- .../src/main/java/brooklyn/util/task/Tasks.java | 2 +- .../java/brooklyn/util/task/ValueResolver.java | 20 ++++++++++++++++++++ .../effector/SelectMasterEffectorBody.java | 2 +- .../brooklyn/entity/software/StaticSensor.java | 18 ++++++++++++++++-- .../nosql/couchbase/CouchbaseNodeSshDriver.java | 2 +- .../rest/resources/EntityConfigResource.java | 3 ++- .../brooklyn/rest/resources/SensorResource.java | 3 ++- .../rest/transform/EffectorTransformer.java | 5 ++--- .../java/brooklyn/util/repeat/Repeater.java | 7 +++++++ 14 files changed, 67 insertions(+), 21 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/core/src/main/java/brooklyn/enricher/basic/Propagator.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/brooklyn/enricher/basic/Propagator.java b/core/src/main/java/brooklyn/enricher/basic/Propagator.java index 86795c6..06f63c4 100644 --- a/core/src/main/java/brooklyn/enricher/basic/Propagator.java +++ b/core/src/main/java/brooklyn/enricher/basic/Propagator.java @@ -37,7 +37,7 @@ import brooklyn.event.SensorEventListener; import brooklyn.util.collections.MutableMap; import brooklyn.util.flags.SetFromFlag; import brooklyn.util.task.Tasks; -import brooklyn.util.time.Duration; +import brooklyn.util.task.ValueResolver; import com.google.common.base.Preconditions; import com.google.common.base.Predicate; @@ -96,7 +96,7 @@ public class Propagator extends AbstractEnricher implements SensorEventListener< } for (Object sensorO : getConfig(PROPAGATING)) { - Sensor<?> sensor = Tasks.resolving(sensorO).as(Sensor.class).timeout(Duration.millis(50)).context(producer).get(); + Sensor<?> sensor = Tasks.resolving(sensorO).as(Sensor.class).timeout(ValueResolver.REAL_QUICK_WAIT).context(producer).get(); if (!sensorMappingTemp.containsKey(sensor)) { sensorMappingTemp.put(sensor, sensor); } http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/core/src/main/java/brooklyn/enricher/basic/Transformer.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/brooklyn/enricher/basic/Transformer.java b/core/src/main/java/brooklyn/enricher/basic/Transformer.java index 0f6c409..6b2f7a8 100644 --- a/core/src/main/java/brooklyn/enricher/basic/Transformer.java +++ b/core/src/main/java/brooklyn/enricher/basic/Transformer.java @@ -28,7 +28,7 @@ import brooklyn.entity.basic.ConfigKeys; import brooklyn.event.SensorEvent; import brooklyn.util.collections.MutableSet; import brooklyn.util.task.Tasks; -import brooklyn.util.time.Duration; +import brooklyn.util.task.ValueResolver; import com.google.common.base.Function; import com.google.common.reflect.TypeToken; @@ -84,7 +84,7 @@ public class Transformer<T,U> extends AbstractTransformer<T,U> { return new Function<SensorEvent<T>, U>() { @Override public U apply(SensorEvent<T> input) { // evaluate immediately, or return null - // 200ms seems a reasonable compromise for tasks which require BG evaluation + // PRETTY_QUICK/200ms seems a reasonable compromise for tasks which require BG evaluation // but which are non-blocking // TODO better would be to have a mode in which tasks are not permitted to block on // external events; they can submit tasks and block on them (or even better, have a callback architecture); @@ -92,7 +92,7 @@ public class Transformer<T,U> extends AbstractTransformer<T,U> { return (U) Tasks.resolving(targetValueRaw).as(targetSensor.getType()) .context(entity) .description("Computing sensor "+targetSensor+" from "+targetValueRaw) - .timeout(Duration.millis(200)) + .timeout(ValueResolver.PRETTY_QUICK_WAIT) .getMaybe().orNull(); } public String toString() { http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/core/src/main/java/brooklyn/entity/basic/ServiceStateLogic.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/brooklyn/entity/basic/ServiceStateLogic.java b/core/src/main/java/brooklyn/entity/basic/ServiceStateLogic.java index 75bf9a6..eff8e2d 100644 --- a/core/src/main/java/brooklyn/entity/basic/ServiceStateLogic.java +++ b/core/src/main/java/brooklyn/entity/basic/ServiceStateLogic.java @@ -56,6 +56,7 @@ import brooklyn.util.collections.QuorumCheck; import brooklyn.util.guava.Functionals; import brooklyn.util.guava.Maybe; import brooklyn.util.repeat.Repeater; +import brooklyn.util.task.ValueResolver; import brooklyn.util.text.Strings; import brooklyn.util.time.Duration; @@ -148,7 +149,7 @@ public class ServiceStateLogic { if (!Boolean.TRUE.equals(up) && !Boolean.TRUE.equals(Entities.isReadOnly(entity))) { // pause briefly to allow any recent problem-clearing processing to complete Stopwatch timer = Stopwatch.createStarted(); - boolean nowUp = Repeater.create().every(Duration.millis(10)).limitTimeTo(Duration.millis(200)).until(entity, + boolean nowUp = Repeater.create().every(ValueResolver.REAL_QUICK_PERIOD).limitTimeTo(ValueResolver.PRETTY_QUICK_WAIT).until(entity, EntityPredicates.attributeEqualTo(Attributes.SERVICE_UP, true)).run(); if (nowUp) { log.debug("Had to wait "+Duration.of(timer)+" for "+entity+" "+Attributes.SERVICE_UP+" to be true before setting "+state); http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/core/src/main/java/brooklyn/entity/rebind/PeriodicDeltaChangeListener.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/brooklyn/entity/rebind/PeriodicDeltaChangeListener.java b/core/src/main/java/brooklyn/entity/rebind/PeriodicDeltaChangeListener.java index 2c3271d..0d88330 100644 --- a/core/src/main/java/brooklyn/entity/rebind/PeriodicDeltaChangeListener.java +++ b/core/src/main/java/brooklyn/entity/rebind/PeriodicDeltaChangeListener.java @@ -50,6 +50,7 @@ import brooklyn.util.collections.MutableMap; import brooklyn.util.collections.MutableSet; import brooklyn.util.exceptions.Exceptions; import brooklyn.util.exceptions.RuntimeInterruptedException; +import brooklyn.util.repeat.Repeater; import brooklyn.util.task.ScheduledTask; import brooklyn.util.task.Tasks; import brooklyn.util.time.CountdownTimer; @@ -279,7 +280,7 @@ public class PeriodicDeltaChangeListener implements ChangeListener { Duration left = timer.getDurationRemaining(); if (left.isPositive()) { synchronized(writeCount) { - writeCount.wait(left.lowerBound(Duration.millis(10)).toMilliseconds()); + writeCount.wait(left.lowerBound(Repeater.DEFAULT_REAL_QUICK_PERIOD).toMilliseconds()); } } else { throw new TimeoutException("Timeout waiting for independent write of rebind-periodic-delta, after "+timer.getDurationElapsed()); http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/core/src/main/java/brooklyn/event/basic/DependentConfiguration.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/brooklyn/event/basic/DependentConfiguration.java b/core/src/main/java/brooklyn/event/basic/DependentConfiguration.java index b462107..14a159d 100644 --- a/core/src/main/java/brooklyn/event/basic/DependentConfiguration.java +++ b/core/src/main/java/brooklyn/event/basic/DependentConfiguration.java @@ -70,6 +70,7 @@ import brooklyn.util.task.DynamicTasks; import brooklyn.util.task.ParallelTask; import brooklyn.util.task.TaskInternal; import brooklyn.util.task.Tasks; +import brooklyn.util.task.ValueResolver; import brooklyn.util.text.Strings; import brooklyn.util.time.CountdownTimer; import brooklyn.util.time.Duration; @@ -297,8 +298,8 @@ public class DependentConfiguration { } CountdownTimer timer = timeout!=null ? timeout.countdownTimer() : null; - Duration maxPeriod = Duration.millis(200); - Duration nextPeriod = Duration.millis(10); + Duration maxPeriod = ValueResolver.PRETTY_QUICK_WAIT; + Duration nextPeriod = ValueResolver.REAL_QUICK_PERIOD; while (true) { // check the source on initial run (could be done outside the loop) // and also (optionally) on each iteration in case it is more recent @@ -407,7 +408,7 @@ public class DependentConfiguration { /** Returns a task which waits for multiple other tasks (submitting if necessary) * and performs arbitrary computation over the List of results. * @see #transform(Task, Function) but note argument order is reversed (counterintuitive) to allow for varargs */ - public static <U,T> Task<T> transformMultiple(Function<List<U>,T> transformer, TaskAdaptable<U> ...tasks) { + public static <U,T> Task<T> transformMultiple(Function<List<U>,T> transformer, @SuppressWarnings("unchecked") TaskAdaptable<U> ...tasks) { return transformMultiple(MutableMap.of("displayName", "transforming multiple"), transformer, tasks); } @@ -425,7 +426,7 @@ public class DependentConfiguration { /** @see #transformMultiple(Function, TaskAdaptable...) */ @SuppressWarnings({ "rawtypes" }) - public static <U,T> Task<T> transformMultiple(Map flags, final Function<List<U>,T> transformer, TaskAdaptable<U> ...tasks) { + public static <U,T> Task<T> transformMultiple(Map flags, final Function<List<U>,T> transformer, @SuppressWarnings("unchecked") TaskAdaptable<U> ...tasks) { return transformMultiple(flags, transformer, Arrays.asList(tasks)); } @SuppressWarnings({ "rawtypes" }) @@ -687,6 +688,7 @@ public class DependentConfiguration { validate(); return new WaitInTaskForAttributeReady<T,V>(this).call(); } + @SuppressWarnings({ "unchecked", "rawtypes" }) private void validate() { checkNotNull(source, "Entity source"); checkNotNull(sensor, "Sensor"); http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/core/src/main/java/brooklyn/util/task/Tasks.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/brooklyn/util/task/Tasks.java b/core/src/main/java/brooklyn/util/task/Tasks.java index 573b342..f59e2d1 100644 --- a/core/src/main/java/brooklyn/util/task/Tasks.java +++ b/core/src/main/java/brooklyn/util/task/Tasks.java @@ -421,7 +421,7 @@ public class Tasks { } if (timer.isExpired()) return false; - Time.sleep(Duration.millis(10)); + Time.sleep(Repeater.DEFAULT_REAL_QUICK_PERIOD); } } http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/core/src/main/java/brooklyn/util/task/ValueResolver.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/brooklyn/util/task/ValueResolver.java b/core/src/main/java/brooklyn/util/task/ValueResolver.java index 71b34a0..0670ad6 100644 --- a/core/src/main/java/brooklyn/util/task/ValueResolver.java +++ b/core/src/main/java/brooklyn/util/task/ValueResolver.java @@ -38,6 +38,7 @@ import brooklyn.util.exceptions.Exceptions; import brooklyn.util.flags.TypeCoercions; import brooklyn.util.guava.Maybe; import brooklyn.util.javalang.JavaClassNames; +import brooklyn.util.repeat.Repeater; import brooklyn.util.time.CountdownTimer; import brooklyn.util.time.Duration; import brooklyn.util.time.Durations; @@ -57,6 +58,25 @@ import com.google.common.reflect.TypeToken; */ public class ValueResolver<T> implements DeferredSupplier<T> { + /** + * Period to wait if we're expected to return real quick + * but we want fast things to have time to finish. + * <p> + * Timings are always somewhat arbitrary but this at least + * allows some intention to be captured in code rather than arbitrary values. */ + public static Duration REAL_QUICK_WAIT = Duration.millis(50); + /** + * Period to wait if we're expected to return quickly + * but we want to be a bit more generous for things to finish, + * without letting a caller get annoyed. + * <p> + * See {@link #REAL_QUICK_WAIT}. */ + public static Duration PRETTY_QUICK_WAIT = Duration.millis(200); + + /** Period to wait when we have to poll but want to give the illusion of no wait. + * See {@link Repeater#DEFAULT_REAL_QUICK_PERIOD} */ + public static Duration REAL_QUICK_PERIOD = Repeater.DEFAULT_REAL_QUICK_PERIOD; + private static final Logger log = LoggerFactory.getLogger(ValueResolver.class); final Object value; http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/software/base/src/main/java/brooklyn/entity/brooklynnode/effector/SelectMasterEffectorBody.java ---------------------------------------------------------------------- diff --git a/software/base/src/main/java/brooklyn/entity/brooklynnode/effector/SelectMasterEffectorBody.java b/software/base/src/main/java/brooklyn/entity/brooklynnode/effector/SelectMasterEffectorBody.java index 7ed3cb8..af07f3a 100644 --- a/software/base/src/main/java/brooklyn/entity/brooklynnode/effector/SelectMasterEffectorBody.java +++ b/software/base/src/main/java/brooklyn/entity/brooklynnode/effector/SelectMasterEffectorBody.java @@ -107,7 +107,7 @@ public class SelectMasterEffectorBody extends EffectorBody<Void> implements Sele private void waitMasterHandover(final Entity oldMaster, final Entity newMaster) { boolean masterChanged = Repeater.create() - .backoff(Duration.millis(50), 1.5, Duration.FIVE_SECONDS) + .backoff(Repeater.DEFAULT_REAL_QUICK_PERIOD, 1.5, Duration.FIVE_SECONDS) .limitTimeTo(Duration.ONE_MINUTE) .until(new Callable<Boolean>() { @Override http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/software/base/src/main/java/brooklyn/entity/software/StaticSensor.java ---------------------------------------------------------------------- diff --git a/software/base/src/main/java/brooklyn/entity/software/StaticSensor.java b/software/base/src/main/java/brooklyn/entity/software/StaticSensor.java index 8688ec8..4b7c9d6 100644 --- a/software/base/src/main/java/brooklyn/entity/software/StaticSensor.java +++ b/software/base/src/main/java/brooklyn/entity/software/StaticSensor.java @@ -22,14 +22,28 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import brooklyn.config.ConfigKey; +import brooklyn.enricher.basic.Propagator; import brooklyn.entity.basic.ConfigKeys; import brooklyn.entity.basic.EntityLocal; import brooklyn.entity.effector.AddSensor; +import brooklyn.management.Task; import brooklyn.util.config.ConfigBag; import brooklyn.util.guava.Maybe; import brooklyn.util.task.Tasks; -import brooklyn.util.time.Duration; +import brooklyn.util.task.ValueResolver; +import com.google.common.base.Supplier; + +/** + * Provides an initializer/feed which simply sets a given value. + * <p> + * {@link Task}/{@link Supplier} values are resolved when written, + * unlike config values which are resolved on each read. + * <p> + * This supports a {@link StaticSensor#SENSOR_PERIOD} + * which can be useful if the supplied value is such a function. + * However when the source is another sensor, + * consider using {@link Propagator} which listens for changes instead. */ public class StaticSensor<T> extends AddSensor<T> { private static final Logger log = LoggerFactory.getLogger(StaticSensor.class); @@ -48,7 +62,7 @@ public class StaticSensor<T> extends AddSensor<T> { public void apply(EntityLocal entity) { super.apply(entity); - Maybe<T> v = Tasks.resolving(value).as((Class<T>)sensor.getType()).timeout(Duration.millis(200)).getMaybe(); + Maybe<T> v = Tasks.resolving(value).as((Class<T>)sensor.getType()).timeout(ValueResolver.PRETTY_QUICK_WAIT).getMaybe(); if (v.isPresent()) { log.debug(this+" setting sensor "+sensor+" to "+v.get()); entity.setAttribute(sensor, v.get()); http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/software/nosql/src/main/java/brooklyn/entity/nosql/couchbase/CouchbaseNodeSshDriver.java ---------------------------------------------------------------------- diff --git a/software/nosql/src/main/java/brooklyn/entity/nosql/couchbase/CouchbaseNodeSshDriver.java b/software/nosql/src/main/java/brooklyn/entity/nosql/couchbase/CouchbaseNodeSshDriver.java index 129bf3d..6dd97d6 100644 --- a/software/nosql/src/main/java/brooklyn/entity/nosql/couchbase/CouchbaseNodeSshDriver.java +++ b/software/nosql/src/main/java/brooklyn/entity/nosql/couchbase/CouchbaseNodeSshDriver.java @@ -344,7 +344,7 @@ public class CouchbaseNodeSshDriver extends AbstractSoftwareProcessSshDriver imp // wait until the re-balance is started // (if it's quick, this might miss it, but it will only block for 30s if so) Repeater.create() - .backoff(Duration.millis(10), 2, Duration.millis(500)) + .backoff(Repeater.DEFAULT_REAL_QUICK_PERIOD, 2, Duration.millis(500)) .limitTimeTo(Duration.THIRTY_SECONDS) .until(new Callable<Boolean>() { @Override http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/usage/rest-server/src/main/java/brooklyn/rest/resources/EntityConfigResource.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/brooklyn/rest/resources/EntityConfigResource.java b/usage/rest-server/src/main/java/brooklyn/rest/resources/EntityConfigResource.java index 219d67a..e7104c9 100644 --- a/usage/rest-server/src/main/java/brooklyn/rest/resources/EntityConfigResource.java +++ b/usage/rest-server/src/main/java/brooklyn/rest/resources/EntityConfigResource.java @@ -39,6 +39,7 @@ import brooklyn.rest.filter.HaHotStateRequired; import brooklyn.rest.transform.EntityTransformer; import brooklyn.rest.util.WebResourceUtils; import brooklyn.util.flags.TypeCoercions; +import brooklyn.util.task.ValueResolver; import brooklyn.util.text.Strings; import brooklyn.util.time.Duration; @@ -96,7 +97,7 @@ public class EntityConfigResource extends AbstractBrooklynRestResource implement EntityLocal entity = brooklyn().getEntity(application, entityToken); ConfigKey<?> ck = findConfig(entity, configKeyName); Object value = ((EntityInternal)entity).config().getRaw(ck).orNull(); - return resolving(value).preferJson(preferJson).asJerseyOutermostReturnValue(true).raw(raw).context(entity).timeout(Duration.millis(100)).renderAs(ck).resolve(); + return resolving(value).preferJson(preferJson).asJerseyOutermostReturnValue(true).raw(raw).context(entity).timeout(ValueResolver.PRETTY_QUICK_WAIT).renderAs(ck).resolve(); } private ConfigKey<?> findConfig(EntityLocal entity, String configKeyName) { http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/usage/rest-server/src/main/java/brooklyn/rest/resources/SensorResource.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/brooklyn/rest/resources/SensorResource.java b/usage/rest-server/src/main/java/brooklyn/rest/resources/SensorResource.java index 6e49acc..05bf73e 100644 --- a/usage/rest-server/src/main/java/brooklyn/rest/resources/SensorResource.java +++ b/usage/rest-server/src/main/java/brooklyn/rest/resources/SensorResource.java @@ -38,6 +38,7 @@ import brooklyn.rest.domain.SensorSummary; import brooklyn.rest.filter.HaHotStateRequired; import brooklyn.rest.transform.SensorTransformer; import brooklyn.rest.util.WebResourceUtils; +import brooklyn.util.task.ValueResolver; import brooklyn.util.text.Strings; import brooklyn.util.time.Duration; @@ -83,7 +84,7 @@ public class SensorResource extends AbstractBrooklynRestResource implements Sens final EntityLocal entity = brooklyn().getEntity(application, entityToken); AttributeSensor<?> sensor = findSensor(entity, sensorName); Object value = entity.getAttribute(sensor); - return resolving(value).preferJson(preferJson).asJerseyOutermostReturnValue(true).raw(raw).context(entity).timeout(Duration.millis(100)).renderAs(sensor).resolve(); + return resolving(value).preferJson(preferJson).asJerseyOutermostReturnValue(true).raw(raw).context(entity).timeout(ValueResolver.PRETTY_QUICK_WAIT).renderAs(sensor).resolve(); } @Override http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/usage/rest-server/src/main/java/brooklyn/rest/transform/EffectorTransformer.java ---------------------------------------------------------------------- diff --git a/usage/rest-server/src/main/java/brooklyn/rest/transform/EffectorTransformer.java b/usage/rest-server/src/main/java/brooklyn/rest/transform/EffectorTransformer.java index 925ed8f..c71680a 100644 --- a/usage/rest-server/src/main/java/brooklyn/rest/transform/EffectorTransformer.java +++ b/usage/rest-server/src/main/java/brooklyn/rest/transform/EffectorTransformer.java @@ -26,7 +26,6 @@ import javax.annotation.Nullable; import brooklyn.entity.Effector; import brooklyn.entity.Entity; import brooklyn.entity.ParameterType; -import brooklyn.entity.basic.EntityInternal; import brooklyn.entity.basic.EntityLocal; import brooklyn.rest.domain.EffectorSummary; import brooklyn.rest.domain.EffectorSummary.ParameterSummary; @@ -34,7 +33,7 @@ import brooklyn.rest.util.WebResourceUtils; import brooklyn.util.exceptions.Exceptions; import brooklyn.util.guava.Maybe; import brooklyn.util.task.Tasks; -import brooklyn.util.time.Duration; +import brooklyn.util.task.ValueResolver; import com.google.common.base.Function; import com.google.common.collect.ImmutableMap; @@ -76,7 +75,7 @@ public class EffectorTransformer { protected static EffectorSummary.ParameterSummary<?> parameterSummary(Entity entity, ParameterType<?> parameterType) { try { Maybe<?> defaultValue = Tasks.resolving(parameterType.getDefaultValue()).as(parameterType.getParameterClass()) - .context(entity).timeout(Duration.millis(50)).getMaybe(); + .context(entity).timeout(ValueResolver.REAL_QUICK_WAIT).getMaybe(); return new ParameterSummary(parameterType.getName(), parameterType.getParameterClassName(), parameterType.getDescription(), WebResourceUtils.getValueForDisplay(defaultValue.orNull(), true, false)); http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/8df4cdfd/utils/common/src/main/java/brooklyn/util/repeat/Repeater.java ---------------------------------------------------------------------- diff --git a/utils/common/src/main/java/brooklyn/util/repeat/Repeater.java b/utils/common/src/main/java/brooklyn/util/repeat/Repeater.java index bd76ea8..a80bb27 100644 --- a/utils/common/src/main/java/brooklyn/util/repeat/Repeater.java +++ b/utils/common/src/main/java/brooklyn/util/repeat/Repeater.java @@ -83,6 +83,13 @@ public class Repeater { private static final Logger log = LoggerFactory.getLogger(Repeater.class); + /** A small initial duration that something should wait between repeats, + * e.g. when doing {@link #backoffTo(Duration)}. + * <p> + * Chosen to be small enough that a user won't notice at all, + * but we're not going to be chewing up CPU while waiting. */ + public static final Duration DEFAULT_REAL_QUICK_PERIOD = Duration.millis(10); + private final String description; private Callable<?> body = Callables.returning(null); private Callable<Boolean> exitCondition;
