TaskManagerQuartzImpl (midPoint Project 3.4.1 API)

java.lang.Object
- com.evolveum.midpoint.task.quartzimpl.TaskManagerQuartzImpl

All Implemented Interfaces:

TaskManager, org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanFactoryAware
```
@Service(value="taskManager")
@DependsOn(value="repositoryService")
public class TaskManagerQuartzImpl
extends Object
implements TaskManager, org.springframework.beans.factory.BeanFactoryAware
```
Task Manager implementation using Quartz scheduler. Main classes: - TaskManagerQuartzImpl - TaskQuartzImpl Helper classes: - ExecutionManager: node-related functions (start, stop, query status), task-related functions (stop, query status) - LocalNodeManager and RemoteExecutionManager (specific methods for local node and remote nodes) - TaskManagerConfiguration: access to config gathered from various places (midpoint config, sql repo config, system properties) - ClusterManager: keeps cluster nodes synchronized and verifies cluster configuration sanity - JmxClient: used to invoke remote JMX agents - JmxServer: provides a JMX agent for midPoint - TaskSynchronizer: synchronizes information about tasks between midPoint repo and Quartz Job Store - Initializer: contains TaskManager initialization code (quite complex)

Author:

Pavol Mederly

Field Summary
- Fields inherited from interface com.evolveum.midpoint.task.api.TaskManager
  DO_NOT_STOP, DO_NOT_WAIT, WAIT_INDEFINITELY

Constructor Summary

Constructors
Constructor and Description

TaskManagerQuartzImpl()

Constructors
Constructor and Description
`TaskManagerQuartzImpl()`

Method Summary

Methods
Modifier and Type	Method and Description
`String`	`addTask(PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.TaskType> taskPrism, OperationResult parentResult)` Add new task.
`void`	`checkStalledTasks(OperationResult result)`
`void`	`checkWaitingTasks(OperationResult result)`
`void`	`cleanupTasks(com.evolveum.midpoint.xml.ns._public.common.common_3.CleanupPolicyType policy, Task executionTask, OperationResult parentResult)` Deletes obsolete tasks, as specified in the policy.
`void`	`closeTask(Task task, OperationResult parentResult)`
`void`	`closeTaskWithoutSavingState(Task task, OperationResult parentResult)`
`<T extends com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectType> int`	`countObjects(Class<T> type, ObjectQuery query, OperationResult parentResult)` Counts the number of objects.
`Task`	`createTaskInstance()` Creates new transient, running task instance.
`Task`	`createTaskInstance(PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.TaskType> taskPrism, OperationResult parentResult)` Creates task instance from the XML task representation.
`Task`	`createTaskInstance(PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.TaskType> taskPrism, String operationName, OperationResult parentResult)` Creates task instance from the XML task representation.
`Task`	`createTaskInstance(String operationName)` Creates new transient, running task instance.
`boolean`	`deactivateServiceThreads(long timeToWait, OperationResult parentResult)` Deactivates service threads (temporarily).
`void`	`deleteNode(String nodeOid, OperationResult result)` Deletes a node from the repository.
`void`	`deleteTask(String oid, OperationResult parentResult)` Deletes task with provided OID.
`List<String>`	`getAllTaskCategories()` Gets a list of all task categories.
`org.springframework.beans.factory.BeanFactory`	`getBeanFactory()`
`ClusterManager`	`getClusterManager()`
`TaskManagerConfiguration`	`getConfiguration()`
`ExecutionManager`	`getExecutionManager()`
`TaskHandler`	`getHandler(String uri)`
`String`	`getHandlerUriForCategory(String category)` Returns a default handler URI for a given task category.
`Task`	`getLocallyRunningTaskByIdentifier(String lightweightIdentifier)` Returns locally-run task by identifier.
`Map<String,TaskQuartzImpl>`	`getLocallyRunningTaskInstances()`
`Set<Task>`	`getLocallyRunningTasks(OperationResult parentResult)` Returns tasks that currently run on this node.
`com.evolveum.midpoint.xml.ns._public.common.common_3.NodeErrorStatusType`	`getLocalNodeErrorStatus()`
`MidpointConfiguration`	`getMidpointConfiguration()`
`Long`	`getNextRunStartTime(String oid, OperationResult parentResult)` Gets next scheduled execution time for a given task.
`String`	`getNodeId()` Returns identifier for current node.
`<T extends com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectType> PrismObject<T>`	`getObject(Class<T> type, String oid, Collection<SelectorOptions<GetOperationOptions>> options, OperationResult parentResult)` TODO
`PrismContext`	`getPrismContext()`
`RepositoryService`	`getRepositoryService()`
`SecurityEnforcer`	`getSecurityEnforcer()`
`boolean`	`getServiceThreadsActivationState()` Returns true if the service threads are running.
`Task`	`getTask(String taskOid, OperationResult parentResult)` Returns a task with specified OID.
`Task`	`getTaskByIdentifier(String identifier, OperationResult parentResult)` Returns a task with a given identifier.
`PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.TaskType>`	`getTaskTypeByIdentifier(String identifier, Collection<SelectorOptions<GetOperationOptions>> options, OperationResult parentResult)` TODO
`Collection<Task>`	`getTransientSubtasks(TaskQuartzImpl task)`
`void`	`init()` Initialization.
`boolean`	`isCurrentNode(PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.NodeType> node)` Checks whether supplied node is the current node.
`boolean`	`isInErrorState()`
`boolean`	`isRunning()`
`List<PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.TaskType>>`	`listSubtasksForTask(String taskIdentifier, OperationResult result)`
`void`	`modifyTask(String oid, Collection<? extends ItemDelta> modifications, OperationResult parentResult)` Modifies task using relative change description.
`void`	`notifyTaskFinish(Task task, TaskRunResult runResult)`
`void`	`notifyTaskStart(Task task)`
`void`	`notifyTaskThreadFinish(Task task)`
`void`	`notifyTaskThreadStart(Task task, boolean isRecovering)`
`void`	`onTaskCreate(String oid, OperationResult parentResult)` This is a signal to task manager that a new task was created in the repository.
`void`	`onTaskDelete(String oid, OperationResult parentResult)` This is a signal to task manager that a task was removed from the repository.
`void`	`pauseTask(Task task, TaskWaitingReason reason, OperationResult parentResult)` Puts a runnable/running task into WAITING state.
`void`	`postInit(OperationResult parentResult)` Post initialization, e.g.
`void`	`reactivateServiceThreads(OperationResult parentResult)` Re-activates the service threads after they have been deactivated.
`void`	`registerHandler(String uri, TaskHandler handler)` Registers a handler for a specified handler URI.
`void`	`registerRunningTask(TaskQuartzImpl task)`
`void`	`registerTaskDeletionListener(TaskDeletionListener listener)`
`void`	`registerTaskListener(TaskListener taskListener)` Registers a task listener that will be notified on task-related events.
`void`	`resumeTask(Task task, OperationResult parentResult)` Resume suspended task.
`void`	`resumeTasks(Collection<String> taskOids, OperationResult parentResult)` Resume suspended tasks.
`void`	`scheduleRunnableTaskNow(Task task, OperationResult parentResult)`
`void`	`scheduleTaskNow(Task task, OperationResult parentResult)` Schedules a RUNNABLE task or CLOSED single-run task to be run immediately.
`void`	`scheduleTasksNow(Collection<String> taskOids, OperationResult parentResult)` Schedules a RUNNABLE/CLOSED tasks to be run immediately.
`<T extends com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectType> SearchResultList<PrismObject<T>>`	`searchObjects(Class<T> type, ObjectQuery query, Collection<SelectorOptions<GetOperationOptions>> options, OperationResult parentResult)`
`SearchResultList<PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.TaskType>>`	`searchTasks(ObjectQuery query, Collection<SelectorOptions<GetOperationOptions>> options, OperationResult result)`
`void`	`setBeanFactory(org.springframework.beans.factory.BeanFactory beanFactory)`
`void`	`setConfiguration(TaskManagerConfiguration configuration)`
`void`	`setNodeErrorStatus(com.evolveum.midpoint.xml.ns._public.common.common_3.NodeErrorStatusType nodeErrorStatus)`
`void`	`shutdown()` Shuts down current node.
`void`	`startLightweightTask(TaskQuartzImpl task)`
`void`	`startScheduler(String nodeIdentifier, OperationResult parentResult)` Starts the scheduler on a given node.
`void`	`startSchedulers(Collection<String> nodeIdentifiers, OperationResult parentResult)`
`void`	`stopScheduler(String nodeIdentifier, OperationResult parentResult)` Stops the scheduler on a given node.
`void`	`stopSchedulers(Collection<String> nodeIdentifiers, OperationResult parentResult)`
`boolean`	`stopSchedulersAndTasks(Collection<String> nodeIdentifiers, long timeToWait, OperationResult result)` Stops a set of schedulers (on their nodes) and tasks that are executing on these nodes.
`void`	`suspendAndDeleteTasks(Collection<String> taskOids, long suspendTimeout, boolean alsoSubtasks, OperationResult parentResult)` Suspends tasks and deletes them.
`boolean`	`suspendTask(Task task, long waitTime, OperationResult parentResult)` Suspend a task.
`boolean`	`suspendTasks(Collection<String> taskOids, long waitForStop, OperationResult parentResult)` Suspends a set of tasks.
`boolean`	`suspendTasksResolved(Collection<Task> tasks, long waitForStop, OperationResult parentResult)`
`void`	`switchToBackground(Task task, OperationResult parentResult)` Switches the provided task to background, making it asynchronous.
`void`	`synchronizeTasks(OperationResult result)` Synchronizes information in midPoint repository and task scheduling database.
`void`	`unpauseTask(Task task, OperationResult parentResult)` Puts a WAITING task back into RUNNABLE state.
`void`	`unregisterRunningTask(TaskQuartzImpl task)`
`void`	`unregisterTaskListener(TaskListener taskListener)` Unregisters a task listener.
`void`	`unscheduleTask(Task task, OperationResult parentResult)`
`ParseException`	`validateCronExpression(String cron)` Validates a cron expression for scheduling tasks - without context of any given task.
`void`	`waitForTransientChildren(Task task, OperationResult result)`

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

- Constructor Detail
  - TaskManagerQuartzImpl
```
public TaskManagerQuartzImpl()
```
- Method Detail
  - init
```
@PostConstruct
public void init()
```
    Initialization. TaskManager can work in two modes: - "stop on initialization failure" - it means that if TaskManager initialization fails, the midPoint will not be started (implemented by throwing SystemException). This is a safe approach, however, midPoint could be used also without Task Manager, so it is perhaps too harsh to do it this way. - "continue on initialization failure" - after such a failure midPoint initialization simply continues; however, task manager is switched to "Error" state, in which the scheduler cannot be started; Moreover, actually almost none Task Manager methods can be invoked, to prevent a damage. This second mode is EXPERIMENTAL, should not be used in production for now. --- So, (A) Generally, when not initialized, we refuse to execute almost all operations (knowing for sure that the scheduler is not running). (B) When initialized, but in error state (typically because of cluster misconfiguration not related to this node), we refuse to start the scheduler on this node. Other methods are OK.
  - postInit
```
public void postInit(OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    Post initialization, e.g. starts the actual scheduling of tasks on this node.
    
    Specified by:
    
    postInit in interface TaskManager
  - shutdown
```
@PreDestroy
public void shutdown()
```
    Description copied from interface: TaskManager
    
    Shuts down current node. Stops all tasks and cluster manager thread as well. Waits until all tasks on this node finish.
    
    Specified by:
    
    shutdown in interface TaskManager
  - isRunning
```
public boolean isRunning()
```
  - isInErrorState
```
public boolean isInErrorState()
```
  - deactivateServiceThreads
```
public boolean deactivateServiceThreads(long timeToWait,
                               OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    Deactivates service threads (temporarily). This will suspend all background activity such as scanning threads, heartbeats and similar mechanisms. Note: The threads are normally activated after task manager implementation starts. This methods should not be used in a normal case. WARNING: this feature is intended for development-time diagnostics and should not be used on production environments. Suspending the threads may affect correct behavior of the system (such as timeouts on heartbeats). Use this feature only if you really know what you are doing. timeToWait is only for orientation = it may be so that the implementation would wait 2 or 3 times this value (if it waits separately for several threads completion)
    
    Specified by:
    
    deactivateServiceThreads in interface TaskManager
  - reactivateServiceThreads
```
public void reactivateServiceThreads(OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    Re-activates the service threads after they have been deactivated.
    
    Specified by:
    
    reactivateServiceThreads in interface TaskManager
  - getServiceThreadsActivationState
```
public boolean getServiceThreadsActivationState()
```
    Description copied from interface: TaskManager
    
    Returns true if the service threads are running. This method returns true in a normal case. It returns false is the threads were temporarily suspended.
    
    Specified by:
    
    getServiceThreadsActivationState in interface TaskManager
    
    Returns:
    true if the service threads are running.
  - suspendTask
```
public boolean suspendTask(Task task,
                  long waitTime,
                  OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    Suspend a task. The same as above - stops one-member set.
    
    Specified by:
    
    suspendTask in interface TaskManager
  - suspendTasks
```
public boolean suspendTasks(Collection<String> taskOids,
                   long waitForStop,
                   OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    Suspends a set of tasks. Sets their execution status to SUSPENDED. Stops their execution (unless doNotStop is set).
    
    Specified by:
    
    suspendTasks in interface TaskManager
    
    Parameters:
    taskOids - a collection of OIDs of tasks that have to be suspended
    
    Returns:
    true if all the tasks were stopped, false if some tasks continue to run or if stopping was not requested (DO_NOT_STOP option)
  - suspendTasksResolved
```
public boolean suspendTasksResolved(Collection<Task> tasks,
                           long waitForStop,
                           OperationResult parentResult)
```
  - pauseTask
```
public void pauseTask(Task task,
             TaskWaitingReason reason,
             OperationResult parentResult)
               throws ObjectNotFoundException,
                      SchemaException
```
    Description copied from interface: TaskManager
    
    Puts a runnable/running task into WAITING state.
    
    Specified by:
    
    pauseTask in interface TaskManager
    
    Parameters:
    task - a runnable/running task
    reason - the reason for waiting, which is stored into the repository
    
    Throws:
    
    ObjectNotFoundException
    
    SchemaException
  - unpauseTask
```
public void unpauseTask(Task task,
               OperationResult parentResult)
                 throws ObjectNotFoundException,
                        SchemaException
```
    Description copied from interface: TaskManager
    
    Puts a WAITING task back into RUNNABLE state.
    
    Specified by:
    
    unpauseTask in interface TaskManager
    
    Throws:
    
    ObjectNotFoundException
    
    SchemaException
  - resumeTasks
```
public void resumeTasks(Collection<String> taskOids,
               OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    Resume suspended tasks.
    
    Specified by:
    
    resumeTasks in interface TaskManager
    
    Parameters:
    taskOids - a collection of OIDs of tasks that have to be resumed
  - resumeTask
```
public void resumeTask(Task task,
              OperationResult parentResult)
                throws ObjectNotFoundException,
                       SchemaException
```
    Description copied from interface: TaskManager
    
    Resume suspended task.
    
    Specified by:
    
    resumeTask in interface TaskManager
    
    Parameters:
    task - task instance to be resumed.
    
    Throws:
    
    ObjectNotFoundException
    
    SchemaException
  - createTaskInstance
```
public Task createTaskInstance()
```
    Description copied from interface: TaskManager
    
    Creates new transient, running task instance. This is fact creates usual "synchronous" task. This is useful for normal day-to-day tasks that are either synchronous or start as a synchronous and are switched to asynchronous task later.
    
    Specified by:
    
    createTaskInstance in interface TaskManager
    
    Returns:
    transient, running task instance
  - createTaskInstance
```
public Task createTaskInstance(String operationName)
```
    Description copied from interface: TaskManager
    
    Creates new transient, running task instance. This is fact creates usual "synchronous" task. This is useful for normal day-to-day tasks that are either synchronous or start as a synchronous and are switched to asynchronous task later. The result inside the task will be initialized with specified operation name.
    
    Specified by:
    
    createTaskInstance in interface TaskManager
    
    Parameters:
    operationName - operation name to use as a root for new result in task
    
    Returns:
    new Java representation of the task
  - createTaskInstance
```
public Task createTaskInstance(PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.TaskType> taskPrism,
                      OperationResult parentResult)
                        throws SchemaException
```
    Description copied from interface: TaskManager
    
    Creates task instance from the XML task representation.
    
    Specified by:
    
    createTaskInstance in interface TaskManager
    
    Parameters:
    taskPrism - JAXB (XML) representation of the task
    
    Returns:
    new Java representation of the task
    
    Throws:
    
    SchemaException - The provided taskType is not compliant to schema
  - createTaskInstance
```
public Task createTaskInstance(PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.TaskType> taskPrism,
                      String operationName,
                      OperationResult parentResult)
                        throws SchemaException
```
    Description copied from interface: TaskManager
    
    Creates task instance from the XML task representation. If there is not a result inside the task, it will create the result with specified operation name.
    
    Specified by:
    
    createTaskInstance in interface TaskManager
    
    Parameters:
    taskPrism - Prism representation of the task
    operationName - operation name to use as a root for new result in task
    
    Returns:
    new Java representation of the task
    
    Throws:
    
    SchemaException - The provided taskType is not compliant to schema
  - getTask
```
public Task getTask(String taskOid,
           OperationResult parentResult)
             throws ObjectNotFoundException,
                    SchemaException
```
    Description copied from interface: TaskManager
    
    Returns a task with specified OID. This operation will look up a task instance in the repository and return it in a form of Task object. Works only on persistent tasks.
    
    Specified by:
    
    getTask in interface TaskManager
    
    Parameters:
    taskOid - OID of the persistent task.
    
    Returns:
    Task instance
    
    Throws:
    
    ObjectNotFoundException - wrong OID format, etc.
    
    SchemaException - error dealing with resource schema
  - switchToBackground
```
public void switchToBackground(Task task,
                      OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    Switches the provided task to background, making it asynchronous. The provided task will be "released" to other nodes to execute. There is no guarantee that the task will execute on the same node that called the switchToBackground() method.
    
    Specified by:
    
    switchToBackground in interface TaskManager
    
    Parameters:
    task - task to switch to background.
  - addTask
```
public String addTask(PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.TaskType> taskPrism,
             OperationResult parentResult)
               throws ObjectAlreadyExistsException,
                      SchemaException
```
    Description copied from interface: TaskManager
    
    Add new task. The OID provided in the task may be empty. In that case the OID will be assigned by the implementation of this method and it will be provided as return value. This operation should fail if such object already exists (if object with the provided OID already exists). The operation may fail if provided OID is in an unusable format for the storage. Generating own OIDs and providing them to this method is not recommended for normal operation. Should be atomic. Should not allow creation of two objects with the same OID (even if created in parallel). The operation may fail if the object to be created does not conform to the underlying schema of the storage system or the schema enforced by the implementation.
    
    Specified by:
    
    addTask in interface TaskManager
    
    Parameters:
    taskPrism - object to create
    parentResult - parent OperationResult (in/out)
    
    Returns:
    OID assigned to the created object
    
    Throws:
    
    ObjectAlreadyExistsException - object with specified identifiers already exists, cannot add
    
    SchemaException - error dealing with storage schema, e.g. schema violation
  - modifyTask
```
public void modifyTask(String oid,
              Collection<? extends ItemDelta> modifications,
              OperationResult parentResult)
                throws ObjectNotFoundException,
                       SchemaException,
                       ObjectAlreadyExistsException
```
    Description copied from interface: TaskManager
    
    Modifies task using relative change description. Must fail if object with provided OID does not exists. Must fail if any of the described changes cannot be applied. Should be atomic. If two or more modify operations are executed in parallel, the operations should be merged. In case that the operations are in conflict (e.g. one operation adding a value and the other removing the same value), the result is not deterministic. The operation may fail if the modified object does not conform to the underlying schema of the storage system or the schema enforced by the implementation. HOWEVER, the preferred way of modifying tasks is to use methods in Task interface.
    
    Specified by:
    
    modifyTask in interface TaskManager
    
    Parameters:
    oid - OID of the task to be changed
    modifications - specification of object changes
    parentResult - parent OperationResult (in/out)
    
    Throws:
    
    ObjectNotFoundException - specified object does not exist
    
    SchemaException - resulting object would violate the schema
    
    ObjectAlreadyExistsException
  - suspendAndDeleteTasks
```
public void suspendAndDeleteTasks(Collection<String> taskOids,
                         long suspendTimeout,
                         boolean alsoSubtasks,
                         OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    Suspends tasks and deletes them.
    
    Specified by:
    
    suspendAndDeleteTasks in interface TaskManager
    
    Parameters:
    taskOids - List of task OIDs to be suspended and deleted.
    suspendTimeout - How long (in milliseconds) to wait for task suspension before proceeding with deletion.
    alsoSubtasks - Should also subtasks be deleted?
  - deleteTask
```
public void deleteTask(String oid,
              OperationResult parentResult)
                throws ObjectNotFoundException,
                       SchemaException
```
    Description copied from interface: TaskManager
    
    Deletes task with provided OID. Must fail if object with specified OID does not exists. Should be atomic. BEWARE: call this method only if you are pretty sure the task is not running. Otherwise the running thread will complain when it will try to store task result into repo. (I.e. it is a good practice to suspend the task before deleting.)
    
    Specified by:
    
    deleteTask in interface TaskManager
    
    Parameters:
    oid - OID of object to delete
    parentResult - parent OperationResult (in/out)
    
    Throws:
    
    ObjectNotFoundException - specified object does not exist
    
    SchemaException
  - registerRunningTask
```
public void registerRunningTask(TaskQuartzImpl task)
```
  - unregisterRunningTask
```
public void unregisterRunningTask(TaskQuartzImpl task)
```
  - startLightweightTask
```
public void startLightweightTask(TaskQuartzImpl task)
```
  - waitForTransientChildren
```
public void waitForTransientChildren(Task task,
                            OperationResult result)
```
    Specified by:
    
    waitForTransientChildren in interface TaskManager
  - getObject
```
public <T extends com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectType> PrismObject<T> getObject(Class<T> type,
                                                                                                   String oid,
                                                                                                   Collection<SelectorOptions<GetOperationOptions>> options,
                                                                                                   OperationResult parentResult)
                                                                                                 throws SchemaException,
                                                                                                        ObjectNotFoundException
```
    Description copied from interface: TaskManager
    
    TODO
    
    Specified by:
    
    getObject in interface TaskManager
    
    Returns:
    
    Throws:
    
    SchemaException
    
    ObjectNotFoundException
  - listSubtasksForTask
```
public List<PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.TaskType>> listSubtasksForTask(String taskIdentifier,
                                                                                                   OperationResult result)
                                                                                                     throws SchemaException
```
    Throws:
    
    SchemaException
  - searchObjects
```
public <T extends com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectType> SearchResultList<PrismObject<T>> searchObjects(Class<T> type,
                                                                                                                         ObjectQuery query,
                                                                                                                         Collection<SelectorOptions<GetOperationOptions>> options,
                                                                                                                         OperationResult parentResult)
                                                                                                                       throws SchemaException
```
    Specified by:
    
    searchObjects in interface TaskManager
    
    Returns:
    
    Throws:
    
    SchemaException - Notes: Implemented options are: - noFetch: it causes task manager NOT to ask remote nodes about node/task status. - (for tasks) TaskType.F_NEXT_RUN_START_TIMESTAMP: it can be used to disable asking Quartz for next run start time - other options that are passed down to repository
  - countObjects
```
public <T extends com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectType> int countObjects(Class<T> type,
                                                                                           ObjectQuery query,
                                                                                           OperationResult parentResult)
                 throws SchemaException
```
    Description copied from interface: TaskManager
    
    Counts the number of objects.
    
    Specified by:
    
    countObjects in interface TaskManager
    
    Returns:
    
    Throws:
    
    SchemaException
  - searchTasks
```
public SearchResultList<PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.TaskType>> searchTasks(ObjectQuery query,
                                                                                                       Collection<SelectorOptions<GetOperationOptions>> options,
                                                                                                       OperationResult result)
                                                                                                         throws SchemaException
```
    Throws:
    
    SchemaException
  - registerTaskDeletionListener
```
public void registerTaskDeletionListener(TaskDeletionListener listener)
```
    Specified by:
    
    registerTaskDeletionListener in interface TaskManager
  - registerHandler
```
public void registerHandler(String uri,
                   TaskHandler handler)
```
    Description copied from interface: TaskManager
    
    Registers a handler for a specified handler URI.
    
    Specified by:
    
    registerHandler in interface TaskManager
    
    Parameters:
    uri - URI of the handler, e.g. http://midpoint.evolveum.com/xml/ns/public/model/cleanup/handler-3
    handler - instance of the handler
  - getHandler
```
public TaskHandler getHandler(String uri)
```
  - getAllTaskCategories
```
public List<String> getAllTaskCategories()
```
    Description copied from interface: TaskManager
    
    Gets a list of all task categories.
    
    Specified by:
    
    getAllTaskCategories in interface TaskManager
    
    Returns:
  - getHandlerUriForCategory
```
public String getHandlerUriForCategory(String category)
```
    Description copied from interface: TaskManager
    
    Returns a default handler URI for a given task category.
    
    Specified by:
    
    getHandlerUriForCategory in interface TaskManager
    
    Returns:
  - onTaskCreate
```
public void onTaskCreate(String oid,
                OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    This is a signal to task manager that a new task was created in the repository. Task manager can react to it e.g. by creating shadow quartz job and trigger.
    
    Specified by:
    
    onTaskCreate in interface TaskManager
  - onTaskDelete
```
public void onTaskDelete(String oid,
                OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    This is a signal to task manager that a task was removed from the repository. Task manager can react to it e.g. by removing shadow quartz job and trigger.
    
    Specified by:
    
    onTaskDelete in interface TaskManager
  - registerTaskListener
```
public void registerTaskListener(TaskListener taskListener)
```
    Description copied from interface: TaskManager
    
    Registers a task listener that will be notified on task-related events.
    
    Specified by:
    
    registerTaskListener in interface TaskManager
    
    Parameters:
    taskListener - listener to be registered
  - unregisterTaskListener
```
public void unregisterTaskListener(TaskListener taskListener)
```
    Description copied from interface: TaskManager
    
    Unregisters a task listener.
    
    Specified by:
    
    unregisterTaskListener in interface TaskManager
    
    Parameters:
    taskListener - listener to be unregisteted
  - notifyTaskStart
```
public void notifyTaskStart(Task task)
```
  - notifyTaskFinish
```
public void notifyTaskFinish(Task task,
                    TaskRunResult runResult)
```
  - notifyTaskThreadStart
```
public void notifyTaskThreadStart(Task task,
                         boolean isRecovering)
```
  - notifyTaskThreadFinish
```
public void notifyTaskThreadFinish(Task task)
```
  - getConfiguration
```
public TaskManagerConfiguration getConfiguration()
```
  - getPrismContext
```
public PrismContext getPrismContext()
```
  - getLocalNodeErrorStatus
```
public com.evolveum.midpoint.xml.ns._public.common.common_3.NodeErrorStatusType getLocalNodeErrorStatus()
```
  - setNodeErrorStatus
```
public void setNodeErrorStatus(com.evolveum.midpoint.xml.ns._public.common.common_3.NodeErrorStatusType nodeErrorStatus)
```
  - setBeanFactory
```
public void setBeanFactory(org.springframework.beans.factory.BeanFactory beanFactory)
                    throws org.springframework.beans.BeansException
```
    Specified by:
    
    setBeanFactory in interface org.springframework.beans.factory.BeanFactoryAware
    
    Throws:
    
    org.springframework.beans.BeansException
  - getMidpointConfiguration
```
public MidpointConfiguration getMidpointConfiguration()
```
  - getBeanFactory
```
public org.springframework.beans.factory.BeanFactory getBeanFactory()
```
  - getClusterManager
```
public ClusterManager getClusterManager()
```
  - getRepositoryService
```
public RepositoryService getRepositoryService()
```
  - setConfiguration
```
public void setConfiguration(TaskManagerConfiguration configuration)
```
  - getExecutionManager
```
public ExecutionManager getExecutionManager()
```
  - getSecurityEnforcer
```
public SecurityEnforcer getSecurityEnforcer()
```
  - synchronizeTasks
```
public void synchronizeTasks(OperationResult result)
```
    Description copied from interface: TaskManager
    
    Synchronizes information in midPoint repository and task scheduling database.
    
    Specified by:
    
    synchronizeTasks in interface TaskManager
  - getNodeId
```
public String getNodeId()
```
    Description copied from interface: TaskManager
    
    Returns identifier for current node.
    
    Specified by:
    
    getNodeId in interface TaskManager
    
    Returns:
  - getLocallyRunningTasks
```
public Set<Task> getLocallyRunningTasks(OperationResult parentResult)
                                 throws TaskManagerException
```
    Description copied from interface: TaskManager
    
    Returns tasks that currently run on this node. E.g. tasks that have allocated threads. Does not look primarily into repository, but looks at runtime structures describing the task execution.
    
    Specified by:
    
    getLocallyRunningTasks in interface TaskManager
    
    Returns:
    tasks that currently run on this node.
    
    Throws:
    
    TaskManagerException
  - getLocallyRunningTaskByIdentifier
```
public Task getLocallyRunningTaskByIdentifier(String lightweightIdentifier)
```
    Description copied from interface: TaskManager
    
    Returns locally-run task by identifier. Returned instance is the same as is being used to carrying out operations. SO USE WITH CARE. EXPERIMENTAL. Should be replaced by something like "get operational information".
    
    Specified by:
    
    getLocallyRunningTaskByIdentifier in interface TaskManager
    
    Returns:
  - stopScheduler
```
public void stopScheduler(String nodeIdentifier,
                 OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    Stops the scheduler on a given node. This means that at that node no tasks will be started.
    
    Specified by:
    
    stopScheduler in interface TaskManager
    
    Parameters:
    nodeIdentifier - Node on which the scheduler should be stopped. Null means current node.
  - stopSchedulers
```
public void stopSchedulers(Collection<String> nodeIdentifiers,
                  OperationResult parentResult)
```
    Specified by:
    
    stopSchedulers in interface TaskManager
  - startScheduler
```
public void startScheduler(String nodeIdentifier,
                  OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    Starts the scheduler on a given node. A prerequisite is that the node is running and its TaskManager is not in an error state.
    
    Specified by:
    
    startScheduler in interface TaskManager
    
    Parameters:
    nodeIdentifier - Node on which the scheduler should be started. Null means current node.
  - startSchedulers
```
public void startSchedulers(Collection<String> nodeIdentifiers,
                   OperationResult parentResult)
```
    Specified by:
    
    startSchedulers in interface TaskManager
  - stopSchedulersAndTasks
```
public boolean stopSchedulersAndTasks(Collection<String> nodeIdentifiers,
                             long timeToWait,
                             OperationResult result)
```
    Description copied from interface: TaskManager
    
    Stops a set of schedulers (on their nodes) and tasks that are executing on these nodes.
    
    Specified by:
    
    stopSchedulersAndTasks in interface TaskManager
    
    Parameters:
    nodeIdentifiers - collection of node identifiers
    timeToWait - how long to wait for task shutdown, in milliseconds 0 = indefinitely -1 = do not wait at all
    
    Returns:
  - isCurrentNode
```
public boolean isCurrentNode(PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.NodeType> node)
```
    Description copied from interface: TaskManager
    
    Checks whether supplied node is the current node.
    
    Specified by:
    
    isCurrentNode in interface TaskManager
    
    Returns:
    true if node is the current node
  - deleteNode
```
public void deleteNode(String nodeOid,
              OperationResult result)
                throws SchemaException,
                       ObjectNotFoundException
```
    Description copied from interface: TaskManager
    
    Deletes a node from the repository. (Checks whether the node is not up before deleting it.)
    
    Specified by:
    
    deleteNode in interface TaskManager
    
    Throws:
    
    SchemaException
    
    ObjectNotFoundException
  - scheduleTaskNow
```
public void scheduleTaskNow(Task task,
                   OperationResult parentResult)
                     throws SchemaException,
                            ObjectNotFoundException
```
    Description copied from interface: TaskManager
    
    Schedules a RUNNABLE task or CLOSED single-run task to be run immediately. (If the task will really start immediately, depends e.g. on whether a scheduler is started, whether there are available threads, and so on.)
    
    Specified by:
    
    scheduleTaskNow in interface TaskManager
    
    Throws:
    
    SchemaException
    
    ObjectNotFoundException
  - scheduleRunnableTaskNow
```
public void scheduleRunnableTaskNow(Task task,
                           OperationResult parentResult)
```
  - scheduleTasksNow
```
public void scheduleTasksNow(Collection<String> taskOids,
                    OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    Schedules a RUNNABLE/CLOSED tasks to be run immediately. (If a task will really start immediately, depends e.g. on whether a scheduler is started, whether there are available threads, and so on.)
    
    Specified by:
    
    scheduleTasksNow in interface TaskManager
    
    Parameters:
    taskOids - a collection of OIDs of tasks that have to be scheduled
  - unscheduleTask
```
public void unscheduleTask(Task task,
                  OperationResult parentResult)
```
  - closeTask
```
public void closeTask(Task task,
             OperationResult parentResult)
               throws ObjectNotFoundException,
                      SchemaException
```
    Throws:
    
    ObjectNotFoundException
    
    SchemaException
  - closeTaskWithoutSavingState
```
public void closeTaskWithoutSavingState(Task task,
                               OperationResult parentResult)
```
  - validateCronExpression
```
public ParseException validateCronExpression(String cron)
```
    Description copied from interface: TaskManager
    
    Validates a cron expression for scheduling tasks - without context of any given task.
    
    Specified by:
    
    validateCronExpression in interface TaskManager
    
    Parameters:
    cron - expression to validate
    
    Returns:
    an exception if there's something wrong with the expression (null if it's OK).
  - getTaskByIdentifier
```
public Task getTaskByIdentifier(String identifier,
                       OperationResult parentResult)
                         throws SchemaException,
                                ObjectNotFoundException
```
    Description copied from interface: TaskManager
    
    Returns a task with a given identifier. (NOTE: Currently finds only persistent tasks. In the future, we plan to support searching for transient tasks as well.)
    
    Specified by:
    
    getTaskByIdentifier in interface TaskManager
    
    Parameters:
    identifier - task identifier to search for
    
    Returns:
    
    Throws:
    
    SchemaException
    
    ObjectNotFoundException
  - getTaskTypeByIdentifier
```
public PrismObject<com.evolveum.midpoint.xml.ns._public.common.common_3.TaskType> getTaskTypeByIdentifier(String identifier,
                                                                                                 Collection<SelectorOptions<GetOperationOptions>> options,
                                                                                                 OperationResult parentResult)
                                                                                                   throws SchemaException,
                                                                                                          ObjectNotFoundException
```
    Description copied from interface: TaskManager
    
    TODO
    
    Specified by:
    
    getTaskTypeByIdentifier in interface TaskManager
    
    Returns:
    
    Throws:
    
    SchemaException
    
    ObjectNotFoundException
  - cleanupTasks
```
public void cleanupTasks(com.evolveum.midpoint.xml.ns._public.common.common_3.CleanupPolicyType policy,
                Task executionTask,
                OperationResult parentResult)
                  throws SchemaException
```
    Description copied from interface: TaskManager
    
    Deletes obsolete tasks, as specified in the policy. This method removes whole task trees, i.e. not single tasks. A task tree is deleted if the root task is closed (assuming all tasks in the tree are closed) and was closed before at least specified time.
    
    Specified by:
    
    cleanupTasks in interface TaskManager
    
    Parameters:
    policy - specifies which tasks are to be deleted, e.g. how old they have to be
    executionTask - task, within which context the cleanup executes (used to test for interruptions)
    
    Throws:
    
    SchemaException
  - getNextRunStartTime
```
public Long getNextRunStartTime(String oid,
                       OperationResult parentResult)
```
    Description copied from interface: TaskManager
    
    Gets next scheduled execution time for a given task.
    
    Specified by:
    
    getNextRunStartTime in interface TaskManager
    
    Parameters:
    oid - OID of the task
    
    Returns:
    null if there's no next scheduled execution for a given task or if a task with given OID does not exist
  - checkStalledTasks
```
public void checkStalledTasks(OperationResult result)
```
  - checkWaitingTasks
```
public void checkWaitingTasks(OperationResult result)
                       throws SchemaException
```
    Throws:
    
    SchemaException
  - getLocallyRunningTaskInstances
```
public Map<String,TaskQuartzImpl> getLocallyRunningTaskInstances()
```
  - getTransientSubtasks
```
public Collection<Task> getTransientSubtasks(TaskQuartzImpl task)
```

Class TaskManagerQuartzImpl

Field Summary

Fields inherited from interface com.evolveum.midpoint.task.api.TaskManager

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TaskManagerQuartzImpl

Method Detail

init

postInit

shutdown

isRunning

isInErrorState

deactivateServiceThreads

reactivateServiceThreads

getServiceThreadsActivationState

suspendTask

suspendTasks

suspendTasksResolved

pauseTask

unpauseTask

resumeTasks

resumeTask

createTaskInstance

createTaskInstance

createTaskInstance

createTaskInstance

getTask

switchToBackground

addTask

modifyTask

suspendAndDeleteTasks

deleteTask

registerRunningTask

unregisterRunningTask

startLightweightTask

waitForTransientChildren

getObject

listSubtasksForTask

searchObjects

countObjects

searchTasks

registerTaskDeletionListener

registerHandler

getHandler

getAllTaskCategories

getHandlerUriForCategory

onTaskCreate

onTaskDelete

registerTaskListener

unregisterTaskListener

notifyTaskStart

notifyTaskFinish

notifyTaskThreadStart

notifyTaskThreadFinish

getConfiguration

getPrismContext

getLocalNodeErrorStatus

setNodeErrorStatus

setBeanFactory

getMidpointConfiguration

getBeanFactory

getClusterManager

getRepositoryService

setConfiguration

getExecutionManager

getSecurityEnforcer

synchronizeTasks

getNodeId

getLocallyRunningTasks

getLocallyRunningTaskByIdentifier

stopScheduler

stopSchedulers

startScheduler

startSchedulers

stopSchedulersAndTasks

isCurrentNode

deleteNode

scheduleTaskNow