AsyncCoordinator (stallion-core 1.0.0-SNAPSHOT API)

java.lang.Object
- java.lang.Thread
- - io.stallion.asyncTasks.AsyncCoordinator

All Implemented Interfaces:

Runnable

Direct Known Subclasses:

AsyncFileCoordinator
```
public abstract class AsyncCoordinator
extends Thread
```
The AsyncCoordinator handles the running of asychronous tasks. The coordinator continuously polls for new tasks, and dispatches them to an executable pool. If the task fails, it is marked for a later retry.

Nested Class Summary
- Nested classes/interfaces inherited from class java.lang.Thread
  Thread.State, Thread.UncaughtExceptionHandler

Field Summary
- Fields inherited from class java.lang.Thread
  MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY

Constructor Summary

Constructors
Modifier Constructor and Description

protected AsyncCoordinator()

Constructors
Modifier	Constructor and Description
`protected`	`AsyncCoordinator()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`abstract void`	`enqueue(AsyncTask task)` Enqueue a task object, normally you enqueue using task handler, which will then call this method.
`abstract AsyncTask`	`enqueue(AsyncTaskHandler handler)` Enqueue a new task runner; a task object will automatically be created for this handler.
`abstract AsyncTask`	`enqueue(AsyncTaskHandler handler, String customKey, long executeAt)` Enque a new task handler.
`boolean`	`executeNext()` Execute the text in the queue, if any exists.
`boolean`	`executeNext(Long now)` Execute the next task, passing in the current time.
`protected abstract AsyncTask`	`findAndLockNextTask(Long now)` Find the next task that is unlocked and ready for execution, lock it, and return it.
`List<ClassLoader>`	`getExtraClassLoaders()`
`abstract int`	`getPendingTaskCount()` Get the number of tasks waiting to be executed.
`abstract AsyncTaskPersister`	`getTaskPersister()`
`static void`	`gracefulShutdown()` Shutdown, while waiting for all task handlers to finish executing.
`abstract boolean`	`hasPendingTaskWithCustomKey(String key)` Has an unexecuted task with the given custom key
`abstract boolean`	`hasTaskWithCustomKey(String key)` Has any task, pending or already run, with the given custom key
`abstract boolean`	`hasTaskWithId(Long taskId)` Check to see if the task with the given id exists in the queue
`static void`	`init()` Load the coordinator class so that tasks and handlers can be registered, but don't actually execute any tasks.
`static void`	`initAndStart()`
`static void`	`initEphemeralSynchronousForTests()`
`static void`	`initForTests()`
`static AsyncCoordinator`	`instance()`
`boolean`	`isSynchronousMode()` true if is in test mode, where we run tests synchronously rather than in a background thread
`abstract boolean`	`markCompleted(AsyncTask task)` Mark the task as completed.
`abstract boolean`	`markFailed(AsyncTask task, Throwable throwable)` Mark the task as failed.
`abstract void`	`onLoadTaskOnBoot(AsyncTask task)` Called when a task is loaded from the data store during the boot phase.
`void`	`registerClassLoader(ClassLoader loader)`
`void`	`registerHandler(Class<JsAsyncTaskHandler> handler)` Register a handler that will run tasks of a given name.
`void`	`registerHandler(String name, Class cls)` Register a handler that will run tasks of a given name.
`void`	`run()`
`void`	`runTaskForId(Long taskId, boolean force)` Directly, synchronously execute the task with the given ID, regardless of whether it has errored out or is scheduled for the future.
`protected abstract void`	`saveNewTask(AsyncTask task)` Save a new task to the data store
`static void`	`shutDownForTests()`
`static void`	`startup()` Actually start the loop to poll for tasks and execute them.
`abstract void`	`updateTask(AsyncTask task, boolean executeAtChanged)` Update a task with new information.

Methods inherited from class java.lang.Thread
activeCount, checkAccess, clone, countStackFrames, currentThread, destroy, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, join, join, join, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, start, stop, stop, suspend, toString, yield

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

- Constructor Detail
  - AsyncCoordinator
```
protected AsyncCoordinator()
```
- Method Detail
  - instance
```
public static AsyncCoordinator instance()
```
  - initAndStart
```
public static void initAndStart()
```
  - init
```
public static void init()
```
    Load the coordinator class so that tasks and handlers can be registered, but don't actually execute any tasks.
  - initEphemeralSynchronousForTests
```
public static void initEphemeralSynchronousForTests()
```
  - initForTests
```
public static void initForTests()
```
  - startup
```
public static void startup()
```
    Actually start the loop to poll for tasks and execute them.
  - run
```
public void run()
```
    Specified by:
    
    run in interface Runnable
    
    Overrides:
    
    run in class Thread
  - executeNext
```
public boolean executeNext()
```
    Execute the text in the queue, if any exists.
    
    Returns:
  - executeNext
```
public boolean executeNext(Long now)
```
    Execute the next task, passing in the current time. For purposes of running tests, you can pass in any time you want.
    
    Parameters:
    
    now - - milliseconds since the epoch.
    
    Returns:
  - registerHandler
```
public void registerHandler(String name,
                            Class cls)
```
    Register a handler that will run tasks of a given name.
    
    Parameters:
    
    name -
    
    cls -
  - registerHandler
```
public void registerHandler(Class<JsAsyncTaskHandler> handler)
```
    Register a handler that will run tasks of a given name.
    
    Parameters:
    
    handler -
  - findAndLockNextTask
```
protected abstract AsyncTask findAndLockNextTask(Long now)
```
    Find the next task that is unlocked and ready for execution, lock it, and return it.
    
    Parameters:
    
    now -
    
    Returns:
  - saveNewTask
```
protected abstract void saveNewTask(AsyncTask task)
```
    Save a new task to the data store
    
    Parameters:
    
    task -
  - updateTask
```
public abstract void updateTask(AsyncTask task,
                                boolean executeAtChanged)
```
    Update a task with new information.
    
    Parameters:
    
    task -
    
    executeAtChanged -
  - markCompleted
```
public abstract boolean markCompleted(AsyncTask task)
```
    Mark the task as completed.
    
    Parameters:
    
    task -
    
    Returns:
  - runTaskForId
```
public void runTaskForId(Long taskId,
                         boolean force)
```
    Directly, synchronously execute the task with the given ID, regardless of whether it has errored out or is scheduled for the future.
    
    Parameters:
    
    taskId -
    
    force - -- if true, will run the job even if it is locked
  - markFailed
```
public abstract boolean markFailed(AsyncTask task,
                                   Throwable throwable)
```
    Mark the task as failed.
    
    Parameters:
    
    task -
    
    throwable -
    
    Returns:
  - enqueue
```
public abstract AsyncTask enqueue(AsyncTaskHandler handler)
```
    Enqueue a new task runner; a task object will automatically be created for this handler.
    
    Parameters:
    
    handler -
    
    Returns:
  - enqueue
```
public abstract AsyncTask enqueue(AsyncTaskHandler handler,
                                  String customKey,
                                  long executeAt)
```
    Enque a new task handler. CustomKey should be a globally unique key. It can be later used to update the task, or to prevent double enqueuing. For instance, if you were writing a calendar application, you might create a task to notify people 1 hour before each event. You could create a customKey with the user and event id in it. Then if the user changes the event time, you can use the customKey to find the task, and update it with a new executeAt time.
    
    Parameters:
    
    handler - - the task handler that will be executed.
    
    customKey - - a user generated unique key that allows you to prevent dupes or later update the task
    
    executeAt - - when you want the task to execute, in epoch milliseconds
    
    Returns:
  - enqueue
```
public abstract void enqueue(AsyncTask task)
```
    Enqueue a task object, normally you enqueue using task handler, which will then call this method.
    
    Parameters:
    
    task -
  - onLoadTaskOnBoot
```
public abstract void onLoadTaskOnBoot(AsyncTask task)
```
    Called when a task is loaded from the data store during the boot phase.
    
    Parameters:
    
    task -
  - getPendingTaskCount
```
public abstract int getPendingTaskCount()
```
    Get the number of tasks waiting to be executed.
    
    Returns:
  - getTaskPersister
```
public abstract AsyncTaskPersister getTaskPersister()
```
  - hasTaskWithId
```
public abstract boolean hasTaskWithId(Long taskId)
```
    Check to see if the task with the given id exists in the queue
    
    Parameters:
    
    taskId -
    
    Returns:
  - hasPendingTaskWithCustomKey
```
public abstract boolean hasPendingTaskWithCustomKey(String key)
```
    Has an unexecuted task with the given custom key
    
    Parameters:
    
    key -
    
    Returns:
  - hasTaskWithCustomKey
```
public abstract boolean hasTaskWithCustomKey(String key)
```
    Has any task, pending or already run, with the given custom key
    
    Parameters:
    
    key -
    
    Returns:
  - shutDownForTests
```
public static void shutDownForTests()
```
  - gracefulShutdown
```
public static void gracefulShutdown()
```
    Shutdown, while waiting for all task handlers to finish executing.
  - isSynchronousMode
```
public boolean isSynchronousMode()
```
    true if is in test mode, where we run tests synchronously rather than in a background thread
    
    Returns:
  - registerClassLoader
```
public void registerClassLoader(ClassLoader loader)
```
  - getExtraClassLoaders
```
public List<ClassLoader> getExtraClassLoaders()
```

Class AsyncCoordinator

Nested Class Summary

Nested classes/interfaces inherited from class java.lang.Thread

Field Summary

Fields inherited from class java.lang.Thread

Constructor Summary

Method Summary

Methods inherited from class java.lang.Thread

Methods inherited from class java.lang.Object

Constructor Detail

AsyncCoordinator

Method Detail

instance

initAndStart

init

initEphemeralSynchronousForTests

initForTests

startup

run

executeNext

executeNext

registerHandler

registerHandler

findAndLockNextTask

saveNewTask

updateTask

markCompleted

runTaskForId

markFailed

enqueue

enqueue

enqueue

onLoadTaskOnBoot

getPendingTaskCount

getTaskPersister

hasTaskWithId

hasPendingTaskWithCustomKey

hasTaskWithCustomKey

shutDownForTests

gracefulShutdown

isSynchronousMode

registerClassLoader

getExtraClassLoaders