@Override public T get() { Maybe<T> m = getMaybe(); if (m.isPresent()) return m.get(); if (returnDefaultOnGet) return defaultValue; return m.get(); }
private Maybe<Entity> resolveTarget() { return Tasks.resolving(target, Entity.class) .context(entity()) .getMaybe(); }
public static Exception assertThrowsOnGetMaybe(ValueResolver<?> result) { try { result = result.clone(); result.getMaybe(); Assert.fail("should have thrown"); return null; } catch (Exception e) { return e; } }
public static <T> Maybe<T> assertMaybeIsAbsent(ValueResolver<T> result) { result = result.clone(); Maybe<T> maybe = result.getMaybe(); Assert.assertFalse(maybe.isPresent()); return maybe; }
public void testUnsubmittedTaskWhenNoExecutionContextFails() { Task<String> t = newSleepTask(Duration.ZERO, "foo"); // Below, we call ValueResolver.getMaybe() with no execution context. Therefore it will not execute the task. Maybe<String> result = Tasks.resolving(t).as(String.class).timeout(Duration.ZERO).getMaybe(); Assert.assertTrue(result.isAbsent(), "result="+result); Exception exception = Maybe.getException(result); Assert.assertTrue(exception.toString().contains("no execution context available"), "exception="+exception); }
@Override public Maybe<String> call() throws Exception { return Tasks.resolving(t).as(String.class).timeout(Asserts.DEFAULT_LONG_TIMEOUT).getMaybe(); }}) .getUnchecked();
@Override public Maybe<String> call() throws Exception { return Tasks.resolving(t).as(String.class).timeout(Duration.ZERO).getMaybe(); }}) .getUnchecked();
@SuppressWarnings("unchecked") private U resolveImmediately(Object rawVal, Sensor<U> targetSensor) { if (rawVal == Entities.UNCHANGED || rawVal == Entities.REMOVE) { // If it's a special marker-object, then don't try to transform it return (U) rawVal; } // evaluate immediately, or return null. // For vals that implement ImmediateSupplier, we'll use that to get the value // (or Maybe.absent) without blocking. // Otherwise, the Tasks.resolving will give it its best shot at resolving without // blocking on external events (such as waiting for another entity's sensor). return (U) Tasks.resolving(rawVal).as(targetSensor.getType()) .context(entity) .description("Computing sensor "+targetSensor+" from "+rawVal) .immediately(true) .getMaybe().orNull(); } }
public void testTimeoutZero() { Maybe<String> result = Tasks.resolving(newSleepTask(Duration.TEN_SECONDS, "foo")).as(String.class).context(app).timeout(Duration.ZERO).getMaybe(); Assert.assertFalse(result.isPresent()); }
public void testTimeoutBig() { Maybe<String> result = Tasks.resolving(newSleepTask(Duration.ZERO, "foo")).as(String.class).context(app).timeout(Duration.TEN_SECONDS).getMaybe(); Assert.assertEquals(result.get(), "foo"); }
static Maybe<?> execDslEventually(BrooklynDslDeferredSupplier<?> dsl, Class<?> type, Entity context, Duration timeout) { return Tasks.resolving(dsl).as(type) .context(context) .description("Computing "+dsl) .timeout(timeout) .getMaybe(); } }
@Override public Maybe<?> call() throws Exception { return Tasks.resolving(dsl).as(type) .context(context) .description("Computing "+dsl) .immediately(true) .getMaybe(); } };
private void fetchNext() { if (next == NEXT_VALUE) { if (prev.isPresent()) { Object prevValue = prev.get(); if (prevValue != null) { ValueResolver<Object> nextResolver = createIterativeResolver(prevValue); try { next = nextResolver.getMaybe(); } catch (Exception e) { Exceptions.propagateIfFatal(e); next = Maybe.absent("Failed resolving " + prev + " with resolver " + resolver, e); } if (next.isPresent() && next.get() == prev.get()) { // Resolved value same as previous value, last element reached next = null; } } else { // Can't resolve null further // Same as previous case, just cuts on on the resolver calls next = null; } } else { // Resolve error, can't continue next = null; } } }
@SuppressWarnings({ "unchecked", "rawtypes" }) protected static EffectorSummary.ParameterSummary<?> parameterSummary(Entity entity, ParameterType<?> parameterType) { try { Maybe<?> defaultValue = Tasks.resolving(parameterType.getDefaultValue()) .as(parameterType.getParameterClass()) .context(entity) .immediately(true) .getMaybe(); return new ParameterSummary(parameterType.getName(), parameterType.getParameterClassName(), parameterType.getDescription(), WebResourceUtils.getValueForDisplay(defaultValue.orNull(), true, false), Sanitizer.IS_SECRET_PREDICATE.apply(parameterType.getName())); } catch (Exception e) { throw Exceptions.propagate(e); } } }
public void testCompletedTaskReturnsResultImmediately() { Task<String> t = newSleepTask(Duration.ZERO, "foo"); app.getExecutionContext().submit(t).getUnchecked(); // Below, we call ValueResolver.getMaybe() from this thread, which has no execution context. // However, the task has already been submitted and we have waited for it to complete. // Therefore the ValueResolver can simply check for task.isDone() and return its result immediately. Maybe<String> result = Tasks.resolving(t).as(String.class).timeout(Duration.ZERO).getMaybe(); Assert.assertEquals(result.get(), "foo"); }
private Maybe<Entity> getResolvedConfigInTask(final Entity entity, final ConfigKey<Entity> key) { return Tasks.resolving(Tasks.<Entity>builder().body( Functionals.callable(Suppliers.compose(EntityFunctions.config(key), Suppliers.ofInstance(entity))) ).build()) .as(Entity.class) .context(entity).embedResolutionInTask(true) .getMaybe(); }
public void testTaskFactoryGetImmediatelyDoesNotBlock() { final AtomicBoolean executing = new AtomicBoolean(); TaskFactory<TaskAdaptable<String>> taskFactory = new TaskFactory<TaskAdaptable<String>>() { @Override public TaskAdaptable<String> newTask() { return new BasicTask<>(new Callable<String>() { public String call() { executing.set(true); try { Time.sleep(Duration.ONE_MINUTE); return "myval"; } finally { executing.set(false); } }}); } }; Maybe<String> result = Tasks.resolving(taskFactory).as(String.class).context(app).immediately(true).getMaybe(); Asserts.assertTrue(result.isAbsent(), "result="+result); // the call below default times out after 30s while the task above is still running Asserts.succeedsEventually(new Runnable() { public void run() { Asserts.assertFalse(executing.get()); } }); }
Maybe<String> result = Tasks.resolving(taskFactory).as(String.class).context(app).immediately(true).getMaybe(); Asserts.assertTrue(result.isAbsent(), "result="+result);
/** * For resolving a "simple" config key - i.e. where there's not custom logic inside a * {@link StructuredConfigKey} such as a {@link MapConfigKey}. For those, we'd need to do the * same as is in {@link #get(ConfigKey)}, but non-blocking! * See {@link #getNonBlockingResolvingStructuredKey(ConfigKey)}. */ protected <T> Maybe<T> getNonBlockingResolvingSimple(ConfigKey<T> key) { // TODO See AbstractConfigMapImpl.getConfigImpl, for how it looks up the "container" of the // key, so that it gets the right context entity etc. // getRaw returns Maybe(val) if the key was explicitly set (where val can be null) // or Absent if the config key was unset. Object unresolved = getRaw(key).or(key.getDefaultValue()); Maybe<Object> resolved = Tasks.resolving(unresolved) .as(Object.class) .immediately(true) .deep(true) .context(getContext()) .getMaybe(); if (resolved.isAbsent()) return Maybe.Absent.<T>castAbsent(resolved); // likely we don't need this coercion if we set as(key.getType()) above, // but that needs confirmation and quite a lot of testing return TypeCoercions.tryCoerce(resolved.get(), key.getTypeToken()); }
public void testGetImmediatelyDoesntFallBackToDeferredCallOnNotAvailable() throws Exception { final MyImmediateAndDeferredSupplier supplier = new MyImmediateAndDeferredSupplier(new ImmediateSupplier.ImmediateValueNotAvailableException()); Maybe<CallInfo> callInfo = Tasks.resolving(supplier).as(CallInfo.class).context(app).immediately(true).getMaybe(); Asserts.assertNotPresent(callInfo); try { callInfo.get(); Asserts.shouldHaveFailedPreviously("resolution should have failed now the ImmediateSupplier is not expected to fallback to other evaluation forms; instead got "+callInfo); } catch (Exception e) { Asserts.expectedFailureOfType(e, ImmediateValueNotAvailableException.class); } }