/** Finds the entity where this task is running * @throws NullPointerException if there is none (no task, or no context entity for that task) */ public static Entity findEntity() { return Preconditions.checkNotNull(BrooklynTasks.getTargetOrContextEntity(Tasks.current()), "This must be executed in a task whose execution context has a target or context entity " + "(i.e. it must be run from within an effector)"); }
public static void setTransient(Task<?> task) { addTagDynamically(task, ManagementContextInternal.TRANSIENT_TASK_TAG); }
public static Entity getContextEntity(Task<?> task) { return getWrappedEntityOfType(task, CONTEXT_ENTITY); }
public void onUnmanaged(Entity entity) { // remove all references to this entity from tasks executionManager.deleteTag(entity); executionManager.deleteTag(BrooklynTasks.tagForContextEntity(entity)); executionManager.deleteTag(BrooklynTasks.tagForCallerEntity(entity)); executionManager.deleteTag(BrooklynTasks.tagForTargetEntity(entity)); }
stdin.write("\n".getBytes()); tb.tag(BrooklynTasks.tagForStream(BrooklynTasks.STREAM_STDIN, stdin)); } catch (IOException e) { log.warn("Error registering stream "+BrooklynTasks.STREAM_STDIN+" on "+tb+": "+e, e); tb.tag(BrooklynTasks.tagForStream(BrooklynTasks.STREAM_STDOUT, stdout)); stderr = new ByteArrayOutputStream(); tb.tag(BrooklynTasks.tagForStream(BrooklynTasks.STREAM_STDERR, stderr)); if (isTransient) BrooklynTasks.setTransient(task); return task;
public static TaskSummary taskSummary(Task<?> task) { try { Preconditions.checkNotNull(task); Entity entity = BrooklynTasks.getContextEntity(task); String entityId; String entityDisplayName; for (WrappedStream stream: BrooklynTasks.streams(task)) { MutableMap<String, Object> metadata = MutableMap.<String,Object>of("name", stream.streamType); if (stream.streamSize.get()!=null) {
@SuppressWarnings("unchecked") protected ProcessTaskWrapper(AbstractProcessTaskFactory<?,RET> constructor) { super(constructor); TaskBuilder<Object> tb = constructor.constructCustomizedTaskBuilder(); if (stdout!=null) tb.tag(BrooklynTasks.tagForStream(BrooklynTasks.STREAM_STDOUT, stdout)); if (stderr!=null) tb.tag(BrooklynTasks.tagForStream(BrooklynTasks.STREAM_STDERR, stderr)); task = (Task<RET>) tb.body(new ProcessTaskInternalJob()).build(); }
/** * Method for entity to make effector happen with correct semantics (right place, right task context), * when a method is called on that entity. * @throws ExecutionException */ public <T> T invokeEffectorMethodSync(final Entity entity, final Effector<T> eff, final Object args) throws ExecutionException { try { Task<?> current = Tasks.current(); if (current == null || !entity.equals(BrooklynTasks.getContextEntity(current)) || !isManagedLocally(entity)) { manageIfNecessary(entity, eff.getName()); // Wrap in a task if we aren't already in a task that is tagged with this entity Task<T> task = runAtEntity( EffectorUtils.getTaskFlagsForEffectorInvocation(entity, eff), entity, new Callable<T>() { public T call() { return invokeEffectorMethodLocal(entity, eff, args); }}); return task.get(); } else { return invokeEffectorMethodLocal(entity, eff, args); } } catch (Exception e) { // don't need to attach any message or warning because the Effector impl hierarchy does that (see calls to EffectorUtils.handleException) throw new ExecutionException(e); } }
Entity target = BrooklynTasks.getWrappedEntityOfType(taskTags, BrooklynTasks.TARGET_ENTITY); if (target!=null && !tags.contains(BrooklynTasks.tagForContextEntity(target))) {
"displayName", effector.getName()+" (parallel)", "description", "Invoking effector \""+effector.getName()+"\" on "+tasks.size()+(tasks.size() == 1 ? " entity" : " entities"), "tag", BrooklynTasks.tagForCallerEntity(callingEntity)), tasks); ((EntityInternal)callingEntity).getManagementSupport().getExecutionContext().submit(invoke);
@Override public Iterable<TaskSummary> listTasks(String applicationId, String entityId) { Entity entity = brooklyn().getEntity(applicationId, entityId); Set<Task<?>> tasks = BrooklynTasks.getTasksInEntityContext(mgmt().getExecutionManager(), entity); return Collections2.transform(tasks, TaskTransformer.FROM_TASK); }
public String stream(String taskId, String streamId) { Task<?> t = mgmt().getExecutionManager().getTask(taskId); if (t==null) throw WebResourceUtils.notFound("Cannot find task '%s'", taskId); WrappedStream stream = BrooklynTasks.stream(t, streamId); if (stream==null) throw WebResourceUtils.notFound("Cannot find stream '%s' in task '%s'", streamId, taskId); return stream.streamContents.get(); }
/** creates the TaskBuilder which can be further customized; typically invoked by the initial {@link #newTask()} */ public TaskBuilder<Object> constructCustomizedTaskBuilder() { TaskBuilder<Object> tb = TaskBuilder.builder().dynamic(false).name("ssh: "+getSummary()); tb.tag(BrooklynTasks.tagForStream(BrooklynTasks.STREAM_STDIN, Streams.byteArrayOfString(Strings.join(commands, "\n")))); return tb; }
public static LinkWithMetadata asLink(Task<?> t) { if (t==null) return null; MutableMap<String,Object> data = new MutableMap<String,Object>(); data.put("id", t.getId()); if (t.getDisplayName()!=null) data.put("taskName", t.getDisplayName()); Entity entity = BrooklynTasks.getContextEntity(t); if (entity!=null) { data.put("entityId", entity.getId()); if (entity.getDisplayName()!=null) data.put("entityDisplayName", entity.getDisplayName()); } return new LinkWithMetadata("/v1/activities/"+t.getId(), data); }
public static <T> Task<T> invokeEffector(EntityLocal callingEntity, Entity entityToCall, final Effector<T> effector, final Map<String,?> parameters) { Task<T> t = Effectors.invocation(entityToCall, effector, parameters).asTask(); // we pass to callingEntity for consistency above, but in exec-context it should be // re-dispatched to targetEntity ((EntityInternal)callingEntity).getManagementSupport().getExecutionContext().submit( MutableMap.of("tag", BrooklynTasks.tagForCallerEntity(callingEntity)), t); return t; } @SuppressWarnings("unchecked")
@Nullable /** callers should allow this to be null so task can be used outside of an entity */ protected Entity entity() { return BrooklynTasks.getTargetOrContextEntity(Tasks.current()); } protected <T> T entityConfig(ConfigKey<T> key) {
public static Entity getTargetOrContextEntity(Task<?> t) { if (t==null) return null; Entity result = getWrappedEntityOfType(t, CONTEXT_ENTITY); if (result!=null) return result; result = getWrappedEntityOfType(t, TARGET_ENTITY); if (result!=null) { log.warn("Context entity found by looking at target entity tag, not context entity"); return result; } result = Tasks.tag(t, Entity.class, false); if (result!=null) { log.warn("Context entity found by looking at 'Entity' tag, not wrapped entity"); } return result; }
protected EntityInternal entity() { return (EntityInternal) BrooklynTasks.getTargetOrContextEntity(Tasks.current()); }
public static Entity getWrappedEntityOfType(Task<?> t, String wrappingType) { if (t==null) return null; return getWrappedEntityOfType(t.getTags(), wrappingType); } public static Entity getWrappedEntityOfType(Collection<?> tags, String wrappingType) {
protected EntityInternal entity() { return (EntityInternal) BrooklynTasks.getTargetOrContextEntity(Tasks.current()); }