.as(Object.class) .defaultValue("UNRESOLVED") .timeout(Duration.millis(100))
Maybe<String> result = Tasks.resolving(taskFactory).as(String.class).context(app).immediately(true).getMaybe(); Asserts.assertTrue(result.isAbsent(), "result="+result);
WrappingImmediateAndDeferredSupplier wrapperExpected = new WrappingImmediateAndDeferredSupplier(failingExpected); ValueResolver<Object> resolver = Tasks.resolving(wrapperExpected) .as(Object.class) .context(app) .immediately(resolveType.isImmediate());
.as(AttributeSensor.class) .immediately(true) .context(producer)
WrappingImmediateAndDeferredSupplier o1Expected = new WrappingImmediateAndDeferredSupplier(o2Expected); ValueResolver<Integer> resolver = Tasks.resolving(o1Expected) .as(Integer.class) .context(app) .immediately(resolveType.isImmediate());
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()); } }); }
/** * 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()); }
@Test(dataProvider="resolveTypes") public void testNull(ResolveType resolveType) { ValueResolver<Void> resolver = Tasks.resolving(null) .as(Void.class) .context(app) .immediately(resolveType.isImmediate()); assertNull(resolver.get()); ValueResolverIterator<Void> iter = resolver.iterator(); assertTrue(iter.hasNext()); assertNull(iter.next().get()); assertFalse(iter.hasNext()); Maybe<Object> voidOrLast = resolver.iterator().nextOrLast(Void.class); assertNull(voidOrLast.get()); Maybe<Void> voidItem = resolver.iterator().next(Void.class); assertTrue(voidItem.isAbsent()); Maybe<Void> lastItem = resolver.iterator().last(); assertNull(lastItem.get()); }
@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(); } }
@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); } } }
private Map<Sensor<?>, Sensor<?>> resolveSensorMappings(Map<?,?> mapping) { if (mapping == null) { return MutableMap.of(); } Map<Sensor<?>, Sensor<?>> result = MutableMap.of(); for (Map.Entry<?,?> entry : mapping.entrySet()) { Object keyO = entry.getKey(); Object valueO = entry.getValue(); Sensor<?> key = Tasks.resolving(keyO).as(Sensor.class).immediately(true).context(producer).get(); Sensor<?> value = Tasks.resolving(valueO).as(Sensor.class).immediately(true).context(producer).get(); result.put(key, value); } return result; }
@Test(dataProvider="resolveTypes") public void testNextTypeNotFound(ResolveType resolveType) { FailingImmediateAndDeferredSupplier failingExpected = new FailingImmediateAndDeferredSupplier(); WrappingImmediateAndDeferredSupplier wrapperExpected = new WrappingImmediateAndDeferredSupplier(failingExpected); ValueResolver<Object> resolver = Tasks.resolving(wrapperExpected) .as(Object.class) .context(app) .immediately(resolveType.isImmediate()); ValueResolverIterator<Object> iter = resolver.iterator(); Maybe<Void> actual = iter.next(Void.class); assertFalse(actual.isPresent()); assertEquals(actual, iter.last()); } }
@Test public void testErrorsResolvingPropagatesOrSwallowedAllCorrectly() throws Exception { app.config().set(TestEntity.CONF_OBJECT, ValueResolverTest.newThrowTask(Duration.ZERO)); Task<Object> t = Tasks.builder().body(Functionals.callable(EntityFunctions.config(TestEntity.CONF_OBJECT), app)).build(); ValueResolver<Object> v = Tasks.resolving(t).as(Object.class).context(app); ValueResolverTest.assertThrowsOnGetMaybe(v); ValueResolverTest.assertThrowsOnGet(v); v.swallowExceptions(); ValueResolverTest.assertMaybeIsAbsent(v); ValueResolverTest.assertThrowsOnGet(v); v.defaultValue("foo"); ValueResolverTest.assertMaybeIsAbsent(v); assertEquals(v.clone().get(), "foo"); assertResolvesValue(v, Object.class, "foo"); }
@Test(dataProvider="resolveTypes") public void testNextTypeFound(ResolveType resolveType) { FailingImmediateAndDeferredSupplier failingExpected = new FailingImmediateAndDeferredSupplier(); WrappingImmediateAndDeferredSupplier wrapperExpected = new WrappingImmediateAndDeferredSupplier(failingExpected); ValueResolver<Object> resolver = Tasks.resolving(wrapperExpected) .as(Object.class) .context(app) .immediately(resolveType.isImmediate()); ValueResolverIterator<Object> iter = resolver.iterator(); Maybe<FailingImmediateAndDeferredSupplier> actual = iter.next(FailingImmediateAndDeferredSupplier.class); assertTrue(actual.isPresent()); assertNotEquals(actual, iter.last()); }
public void testNonRecursiveBlockingFailsOnNonObjectType() throws Exception { try { Tasks.resolving(new WrappingImmediateAndDeferredSupplier(new FailingImmediateAndDeferredSupplier())) .as(FailingImmediateAndDeferredSupplier.class) .context(app) .immediately(false) .recursive(false) .get(); Asserts.shouldHaveFailedPreviously("recursive(true) accepts only as(Object.class)"); } catch (IllegalStateException e) { Asserts.expectedFailureContains(e, "must be Object"); } }
@Test(dataProvider="resolveTypes") public void testNextOrLastNotFound(ResolveType resolveType) { FailingImmediateAndDeferredSupplier failingExpected = new FailingImmediateAndDeferredSupplier(); WrappingImmediateAndDeferredSupplier wrapperExpected = new WrappingImmediateAndDeferredSupplier(failingExpected); ValueResolver<Object> resolver = Tasks.resolving(wrapperExpected) .as(Object.class) .context(app) .immediately(resolveType.isImmediate()); ValueResolverIterator<Object> iter = resolver.iterator(); Maybe<Object> actual = iter.nextOrLast(Void.class); assertFalse(actual.isPresent()); assertEquals(actual, iter.last()); }
@Test(dataProvider="resolveTypes") public void testNextOrLastFound(ResolveType resolveType) { FailingImmediateAndDeferredSupplier failingExpected = new FailingImmediateAndDeferredSupplier(); WrappingImmediateAndDeferredSupplier wrapperExpected = new WrappingImmediateAndDeferredSupplier(failingExpected); ValueResolver<Object> resolver = Tasks.resolving(wrapperExpected) .as(Object.class) .context(app) .immediately(resolveType.isImmediate()); ValueResolverIterator<Object> iter = resolver.iterator(); Maybe<Object> actual = iter.nextOrLast(FailingImmediateAndDeferredSupplier.class); assertTrue(actual.isPresent()); assertNotEquals(actual, iter.last()); }
public void testNonRecursiveImmediateFailsOnNonObjectType() throws Exception { try { Tasks.resolving(new WrappingImmediateAndDeferredSupplier(new FailingImmediateAndDeferredSupplier())) .as(FailingImmediateAndDeferredSupplier.class) .context(app) .immediately(true) .recursive(false) .get(); Asserts.shouldHaveFailedPreviously("recursive(true) accepts only as(Object.class)"); } catch (IllegalStateException e) { Asserts.expectedFailureContains(e, "must be Object"); } }
public static ValueResolver.ResolverBuilderPretype resolving(Object v) { return new ValueResolver.ResolverBuilderPretype(v); }
@SuppressWarnings("unchecked") public static <T> ValueResolver<T> resolving(ConfigBag config, ConfigKey<T> key) { return new ValueResolver.ResolverBuilderPretype(config.getStringKey(key.getName())).as((Class<T>)key.getType()); }