DynamicTasks (Apache Brooklyn)

java.lang.Object
- brooklyn.util.task.DynamicTasks

```
@Beta
public class DynamicTasks
extends java.lang.Object
```
Contains static methods which detect and use the current TaskQueueingContext to execute tasks.

Since:

0.6.0

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class DynamicTasks.TaskQueueingResult<T>

Nested Classes
Modifier and Type	Class and Description
`static class`	`DynamicTasks.TaskQueueingResult<T>`

Constructor Summary

Constructors
Constructor and Description

DynamicTasks()

Constructors
Constructor and Description
`DynamicTasks()`

Method Summary

Methods
Modifier and Type	Method and Description
`static TaskQueueingContext`	`drain(Duration optionalTimeout, boolean throwFirstError)` Calls `TaskQueueingContext.drain(Duration, boolean, boolean)` on the current task context
`static <T> T`	`get(TaskAdaptable<T> t)` submits/queues the given task if needed, and gets the result (unchecked) only permitted in a queueing context (ie a DST main job) if the task is not yet submitted
`static TaskQueueingContext`	`getTaskQueuingContext()`
`static TaskQueueingContext`	`getThreadTaskQueuingContext()`
`static void`	`markInessential()` same as `Tasks.markInessential()` (but included here for convenience as it is often used in conjunction with `DynamicTasks`)
`static <T> Task<T>`	`queue(java.lang.String name, java.util.concurrent.Callable<T> job)`
`static <T> Task<T>`	`queue(java.lang.String name, java.lang.Runnable job)`
`static void`	`queue(TaskAdaptable<?> task1, TaskAdaptable<?> task2, TaskAdaptable<?>... tasks)`
`static void`	`queue(TaskFactory<?> task1, TaskFactory<?> task2, TaskFactory<?>... tasks)`
`static <T extends TaskAdaptable<?>> T`	`queue(TaskFactory<T> taskFactory)`
`static <V extends TaskAdaptable<?>> V`	`queue(V task)` Queues the given task.
`static <T extends TaskAdaptable<?>> T`	`queueIfNeeded(T task)` queues the task if needed, i.e.
`static <T> DynamicTasks.TaskQueueingResult<T>`	`queueIfPossible(TaskAdaptable<T> task)` Tries to add the task to the current addition context if there is one, otherwise does nothing.
`static <T> DynamicTasks.TaskQueueingResult<T>`	`queueIfPossible(TaskFactory<? extends TaskAdaptable<T>> task)`
`static <T> Task<T>`	`queueInTaskHierarchy(Task<T> task)` adds the given task to the nearest task addition context, either set as a thread-local, or in the current task, or the submitter of the task, etc
`static void`	`removeTaskQueueingContext()`
`static void`	`setTaskQueueingContext(TaskQueueingContext newTaskQC)`
`static <T> Task<T>`	`submit(TaskAdaptable<T> task, Entity entity)` queues the task if possible, otherwise submits it asynchronously; returns the task for callers to `Task.getUnchecked()` or `Task.blockUntilEnded()`
`static void`	`swallowChildrenFailures()` as `Tasks.swallowChildrenFailures()` but requiring a `TaskQueueingContext`.
`static Task<?>`	`waitForLast()` As `drain(Duration, boolean)` waiting forever and throwing the first error (excluding errors in inessential tasks), then returning the last task in the queue (which is guaranteed to have finished without error, if this method returns without throwing)

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DynamicTasks
```
public DynamicTasks()
```
- Method Detail
  - setTaskQueueingContext
```
public static void setTaskQueueingContext(TaskQueueingContext newTaskQC)
```
  - getThreadTaskQueuingContext
```
public static TaskQueueingContext getThreadTaskQueuingContext()
```
  - getTaskQueuingContext
```
public static TaskQueueingContext getTaskQueuingContext()
```
  - removeTaskQueueingContext
```
public static void removeTaskQueueingContext()
```
  - queueIfPossible
```
public static <T> DynamicTasks.TaskQueueingResult<T> queueIfPossible(TaskAdaptable<T> task)
```
    Tries to add the task to the current addition context if there is one, otherwise does nothing.
    Call orSubmitAsync() on the returned TaskQueueingResult to handle execution of tasks in a BasicExecutionContext.
  - queueIfPossible
```
public static <T> DynamicTasks.TaskQueueingResult<T> queueIfPossible(TaskFactory<? extends TaskAdaptable<T>> task)
```
    See Also:
    queueIfPossible(TaskAdaptable)
  - queueInTaskHierarchy
```
public static <T> Task<T> queueInTaskHierarchy(Task<T> task)
```
    adds the given task to the nearest task addition context, either set as a thread-local, or in the current task, or the submitter of the task, etc
    throws if it cannot add
  - queue
```
public static <V extends TaskAdaptable<?>> V queue(V task)
```
    Queues the given task.
    This method is only valid within a dynamic task. Use queueIfPossible(TaskAdaptable) and DynamicTasks.TaskQueueingResult.orSubmitAsync() if the calling context is a basic task.
    
    Parameters:
    task - The task to queue
    
    Returns:
    The queued task
    
    Throws:
    
    java.lang.IllegalStateException - if no task queueing context is available
  - queue
```
public static void queue(TaskAdaptable<?> task1,
         TaskAdaptable<?> task2,
         TaskAdaptable<?>... tasks)
```
    See Also:
    queue(brooklyn.management.TaskAdaptable)
  - queue
```
public static <T extends TaskAdaptable<?>> T queue(TaskFactory<T> taskFactory)
```
    See Also:
    queue(brooklyn.management.TaskAdaptable)
  - queue
```
public static void queue(TaskFactory<?> task1,
         TaskFactory<?> task2,
         TaskFactory<?>... tasks)
```
    See Also:
    queue(brooklyn.management.TaskAdaptable)
  - queue
```
public static <T> Task<T> queue(java.lang.String name,
                java.util.concurrent.Callable<T> job)
```
    See Also:
    queue(brooklyn.management.TaskAdaptable)
  - queue
```
public static <T> Task<T> queue(java.lang.String name,
                java.lang.Runnable job)
```
    See Also:
    queue(brooklyn.management.TaskAdaptable)
  - queueIfNeeded
```
public static <T extends TaskAdaptable<?>> T queueIfNeeded(T task)
```
    queues the task if needed, i.e. if it is not yet submitted (so it will run), or if it is submitted but not queued and we are in a queueing context (so it is available for informational purposes)
  - get
```
public static <T> T get(TaskAdaptable<T> t)
```
    submits/queues the given task if needed, and gets the result (unchecked) only permitted in a queueing context (ie a DST main job) if the task is not yet submitted
  - waitForLast
```
public static Task<?> waitForLast()
```
    As drain(Duration, boolean) waiting forever and throwing the first error (excluding errors in inessential tasks), then returning the last task in the queue (which is guaranteed to have finished without error, if this method returns without throwing)
  - drain
```
public static TaskQueueingContext drain(Duration optionalTimeout,
                        boolean throwFirstError)
```
    Calls TaskQueueingContext.drain(Duration, boolean, boolean) on the current task context
  - swallowChildrenFailures
```
@Beta
public static void swallowChildrenFailures()
```
    as Tasks.swallowChildrenFailures() but requiring a TaskQueueingContext.
  - markInessential
```
public static void markInessential()
```
    same as Tasks.markInessential() (but included here for convenience as it is often used in conjunction with DynamicTasks)
  - submit
```
public static <T> Task<T> submit(TaskAdaptable<T> task,
                 Entity entity)
```
    queues the task if possible, otherwise submits it asynchronously; returns the task for callers to Task.getUnchecked() or Task.blockUntilEnded()

Class DynamicTasks

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DynamicTasks

Method Detail

setTaskQueueingContext

getThreadTaskQueuingContext

getTaskQueuingContext

removeTaskQueueingContext

queueIfPossible

queueIfPossible

queueInTaskHierarchy

queue

queue

queue

queue

queue

queue

queueIfNeeded

get

waitForLast

drain

swallowChildrenFailures

markInessential

submit