Constructor Detail

• Tasks

  public Tasks()

Method Detail

• setBlockingDetails

  public static java.lang.String setBlockingDetails(java.lang.String description)

  convenience for setting "blocking details" on any task where the current thread is running; typically invoked prior to a wait, for transparency to a user; then invoked with 'null' just after the wait

• resetBlockingDetails

  public static void resetBlockingDetails()

• setBlockingTask

  public static Task<?> setBlockingTask(Task<?> blocker)

• resetBlockingTask

  public static void resetBlockingTask()

• withBlockingDetails

  public static <T> T withBlockingDetails(java.lang.String description,
                          java.util.concurrent.Callable<T> code)
                               throws java.lang.Exception

  convenience for setting "blocking details" on any task where the current thread is running, while the passed code is executed; often used from groovy as

  withBlockingDetails("sleeping 5s") { Thread.sleep(5000); } 

  If code block is null, the description is set until further notice (not cleareed).

  Throws:

  java.lang.Exception

• current

  public static Task current()

  the Task where the current thread is executing, if executing in a Task, otherwise null; if the current task is a proxy, this returns the target of that proxy

• getFinalProxyTarget

  public static Task<?> getFinalProxyTarget(Task<?> task)

• resolving

  public static <T> ValueResolver<T> resolving(java.lang.Object v,
                               java.lang.Class<T> type)

  creates a ValueResolver instance which allows significantly more customization than the various resolveValue(Object, Class, ExecutionContext) methods here

• resolving

  public static ValueResolver.ResolverBuilderPretype resolving(java.lang.Object v)

• resolveValue

  public static <T> T resolveValue(java.lang.Object v,
                   java.lang.Class<T> type,
                   @Nullable
                   ExecutionContext exec)
                        throws java.util.concurrent.ExecutionException,
                               java.lang.InterruptedException

  Throws:

  java.util.concurrent.ExecutionException

  java.lang.InterruptedException

  See Also:

  resolveValue(Object, Class, ExecutionContext, String)

• resolveValue

  public static <T> T resolveValue(java.lang.Object v,
                   java.lang.Class<T> type,
                   @Nullable
                   ExecutionContext exec,
                   java.lang.String contextMessage)
                        throws java.util.concurrent.ExecutionException,
                               java.lang.InterruptedException

  attempt to resolve the given value as the given type, waiting on futures, submitting if necessary, and coercing as allowed by TypeCoercions; contextMessage (optional) will be displayed in status reports while it waits (e.g. the name of the config key being looked up). if no execution context supplied (null) this method will throw an exception if the object is an unsubmitted task

  Throws:

  java.util.concurrent.ExecutionException

  java.lang.InterruptedException

• resolveDeepValue

  public static java.lang.Object resolveDeepValue(java.lang.Object v,
                                  java.lang.Class<?> type,
                                  ExecutionContext exec)
                                           throws java.util.concurrent.ExecutionException,
                                                  java.lang.InterruptedException

  Throws:

  java.util.concurrent.ExecutionException

  java.lang.InterruptedException

  See Also:

  resolveDeepValue(Object, Class, ExecutionContext, String)

• resolveDeepValue

  public static <T> T resolveDeepValue(java.lang.Object v,
                       java.lang.Class<T> type,
                       ExecutionContext exec,
                       java.lang.String contextMessage)
                            throws java.util.concurrent.ExecutionException,
                                   java.lang.InterruptedException

  Resolves the given object, blocking on futures and coercing it to the given type. If the object is a map or iterable (or a list of map of maps, etc, etc) then walks these maps/iterables to convert all of their values to the given type. For example, the following will return a list containing a map with "1"="true": Object result = resolveDeepValue(ImmutableList.of(ImmutableMap.of(1, true)), String.class, exec) To perform a deep conversion of futures contained within Iterables or Maps without coercion of each element, the type should normally be Object, not the type of the collection. This differs from resolveValue(Object, Class, ExecutionContext, String) which will accept Map and Iterable as the required type.

  Throws:

  java.util.concurrent.ExecutionException

  java.lang.InterruptedException

• setExtraStatusDetails

  public static void setExtraStatusDetails(java.lang.String notes)

  sets extra status details on the current task, if possible (otherwise does nothing). the extra status is presented in Task.getStatusDetails(true)

• builder

  public static <T> TaskBuilder<T> builder()

• parallel

  public static Task<java.util.List<?>> parallel(TaskAdaptable<?>... tasks)

• parallel

  public static Task<java.util.List<?>> parallel(java.lang.String name,
                                 TaskAdaptable<?>... tasks)

• parallel

  public static Task<java.util.List<?>> parallel(java.lang.Iterable<? extends TaskAdaptable<?>> tasks)

• parallel

  public static Task<java.util.List<?>> parallel(java.lang.String name,
                                 java.lang.Iterable<? extends TaskAdaptable<?>> tasks)

• sequential

  public static Task<java.util.List<?>> sequential(TaskAdaptable<?>... tasks)

• sequential

  public static Task<java.util.List<?>> sequential(java.lang.String name,
                                   TaskAdaptable<?>... tasks)

• sequential

  public static TaskFactory<?> sequential(TaskFactory<?>... taskFactories)

• sequential

  public static TaskFactory<?> sequential(java.lang.String name,
                          TaskFactory<?>... taskFactories)

• sequential

  public static Task<java.util.List<?>> sequential(java.util.List<? extends TaskAdaptable<?>> tasks)

• sequential

  public static Task<java.util.List<?>> sequential(java.lang.String name,
                                   java.util.List<? extends TaskAdaptable<?>> tasks)

• tag

  public static <T> T tag(@Nullable
          Task<?> task,
          java.lang.Class<T> type,
          boolean recurseHierarchy)

  returns the first tag found on the given task which matches the given type, looking up the submission hierarachy if necessary

• isAncestorCancelled

  public static boolean isAncestorCancelled(Task<?> t)

• isQueued

  public static boolean isQueued(TaskAdaptable<?> task)

• isSubmitted

  public static boolean isSubmitted(TaskAdaptable<?> task)

• isQueuedOrSubmitted

  public static boolean isQueuedOrSubmitted(TaskAdaptable<?> task)

• tryQueueing

  public static boolean tryQueueing(TaskQueueingContext adder,
                    TaskAdaptable<?> task)

  Adds the given task to the given context. Does not throw an exception if the addition fails.

  Returns:

  true if the task was added, false otherwise.

• supplier

  public static <T> com.google.common.base.Supplier<T> supplier(TaskAdaptable<T> task)

  see also resolving(Object) which gives much more control about submission, timeout, etc

• children

  public static java.lang.Iterable<Task<?>> children(Task<?> task)

  return all children tasks of the given tasks, if it has children, else empty list

• failed

  public static java.lang.Iterable<Task<?>> failed(java.lang.Iterable<Task<?>> subtasks)

  returns failed tasks

• descendants

  public static java.lang.Iterable<Task<?>> descendants(Task<?> root,
                                        boolean parentFirst)

  returns the task, its children, and all its children, and so on;

  Parameters:

  root - task whose descendants should be iterated

  parentFirst - whether to put parents before children or after

• getError

  public static java.lang.Throwable getError(Task<?> t)

  returns the error thrown by the task if Task.isError(), or null if no error or not done

• fail

  public static Task<java.lang.Void> fail(java.lang.String name,
                          java.lang.Throwable optionalError)

• warning

  public static Task<java.lang.Void> warning(java.lang.String message,
                             java.lang.Throwable optionalError)

• markInessential

  public static void markInessential()

  marks the current task inessential; this mainly matters if the task is running in a parent TaskQueueingContext and we don't want the parent to fail if this task fails

  no-op (silently ignored) if not in a task

• swallowChildrenFailures

  @Beta
  public static void swallowChildrenFailures()

  causes failures in subtasks of the current task not to fail the parent; no-op if not in a TaskQueueingContext.

  essentially like a markInessential() on all tasks in the current TaskQueueingContext, including tasks queued subsequently

• addTagDynamically

  public static void addTagDynamically(java.lang.Object tag)

  as TaskTags.addTagDynamically(TaskAdaptable, Object) but for current task, skipping if no current task

• blockUntilInternalTasksEnded

  @Beta
  public static boolean blockUntilInternalTasksEnded(Task<?> t,
                                          Duration timeout)

  Workaround for limitation described at Task.cancel(boolean); internal method used to allow callers to wait for underlying tasks to finished in the case of cancellation.

  It is irritating that FutureTask sync's object clears the runner thread, so even if BasicTask.getInternalFuture() is used, there is no means of determining if the underlying object is done. The Task.getEndTimeUtc() seems the only way.

  Returns:

  true if tasks ended; false if timed out

• isInterrupted

  public static boolean isInterrupted()

  returns true if either the current thread or the current task is interrupted/cancelled

• testing

  public static TaskBuilder<java.lang.Boolean> testing(Repeater repeater)

  Returns:

  a TaskBuilder which tests whether the repeater terminates with success in its configured timeframe, returning true or false depending on whether repeater succeed

• requiring

  public static TaskBuilder<?> requiring(Repeater repeater)

  Returns:

  a TaskBuilder which requires that the repeater terminate with success in its configured timeframe, throwing if it does not