/** Invokes the effector so that its progress is tracked. */
public static <T> T invokeEffector(Entity entity, Effector<T> eff, Object[] args) {
String id = entity.getId();
String name = eff.getName();
try {
if (log.isDebugEnabled())
log.debug("Invoking effector {} on {}", new Object[] {name, entity});
if (log.isTraceEnabled())
log.trace("Invoking effector {} on {} with args {}", new Object[] {name, entity, args});
EntityManagementSupport mgmtSupport = ((EntityInternal) entity).getManagementSupport();
if (!mgmtSupport.isDeployed()) {
mgmtSupport.attemptLegacyAutodeployment(name);
}
ManagementContextInternal mgmtContext =
(ManagementContextInternal) ((EntityInternal) entity).getManagementContext();
mgmtSupport.getEntityChangeListener().onEffectorStarting(eff);
try {
return mgmtContext.invokeEffectorMethodSync(entity, eff, args);
} finally {
mgmtSupport.getEntityChangeListener().onEffectorCompleted(eff);
}
} catch (CancellationException ce) {
log.info("Execution of effector {} on entity {} was cancelled", name, id);
throw ce;
} catch (ExecutionException ee) {
log.info("Execution of effector {} on entity {} failed with {}", new Object[] {name, id, ee});
// Exceptions thrown in Futures are wrapped
// FIXME Shouldn't pretend exception came from this thread?! Should we remove this unwrapping?
if (ee.getCause() != null) throw Exceptions.propagate(ee.getCause());
else throw Exceptions.propagate(ee);
}
}
public static <T> Task<T> invokeEffectorAsync(
AbstractEntity entity, Effector<T> eff, Map<String, ?> parameters) {
String id = entity.getId();
String name = eff.getName();
if (log.isDebugEnabled())
log.debug("Invoking-async effector {} on {}", new Object[] {name, entity});
if (log.isTraceEnabled())
log.trace(
"Invoking-async effector {} on {} with args {}", new Object[] {name, entity, parameters});
EntityManagementSupport mgmtSupport = ((EntityInternal) entity).getManagementSupport();
if (!mgmtSupport.isDeployed()) {
mgmtSupport.attemptLegacyAutodeployment(name);
}
ManagementContextInternal mgmtContext =
(ManagementContextInternal) ((EntityInternal) entity).getManagementContext();
mgmtSupport.getEntityChangeListener().onEffectorStarting(eff);
try {
return mgmtContext.invokeEffector(entity, eff, parameters);
} finally {
mgmtSupport.getEntityChangeListener().onEffectorCompleted(eff);
}
}
private <T> T resolve(ConfigKey<T> key, Object value) {
Object transformed = transform(key, value);
Object result;
if (transformed instanceof DeferredSupplier) {
ExecutionContext exec = mgmt.getServerExecutionContext();
try {
result = Tasks.resolveValue(transformed, key.getType(), exec);
} catch (ExecutionException | InterruptedException e) {
throw Exceptions.propagate(e);
}
} else {
result = transformed;
}
return TypeCoercions.coerce(result, key.getTypeToken());
}
private Object transform(ConfigKey<?> key, Object value) {
if (value instanceof CharSequence) {
String raw = value.toString();
if (raw.startsWith(BROOKLYN_YAML_PREFIX)) {
CampYamlParser parser = mgmt.getConfig().getConfig(CampYamlParser.YAML_PARSER_KEY);
if (parser == null) {
// TODO Should we fail or return the untransformed value?
// Problem is this gets called during initialisation, e.g. by BrooklynFeatureEnablement
// calling asMapWithStringKeys()
// throw new IllegalStateException("Cannot parse external-config for "+key+" because no
// camp-yaml parser available");
LOG.debug("Not transforming external-config {}, as no camp-yaml parser available", key);
return value;
}
return parser.parse(raw);
}
}
return value;
}
