com.communote.server.core.tasks

Class TaskSchedulingContext

java.lang.Object

com.communote.server.core.tasks.TaskSchedulingContext

All Implemented Interfaces:

EventListener<TaskScheduledEvent>

public class TaskSchedulingContext
extends Object
implements EventListener<TaskScheduledEvent>

Object holding some data which the RunScheduledTasksJob needs for scheduling the task handlers. This instance also acts as listener for TaskAddedEvents

Author:

Communote GmbH - http://www.communote.com/

Field Summary

Fields

Modifier and Type	Field and Description
static String	KEY_TASK_SCHEDULING_CONTEXT Key under which this instance is stored in the context of the scheduler instance

Constructor Summary

Constructors

Constructor and Description
TaskSchedulingContext(org.quartz.Trigger trigger, EventDispatcher eventDispatcher) Creates a new scheduling context for the provided trigger.

Method Summary

Modifier and Type	Method and Description
List<ClientTO>	getClientsWithNewTasksOrRescheduleJob(org.quartz.Trigger oldTrigger) Try to reschedule the task scheduling job after all task handlers for all clients have been scheduled.
Collection<Long>	getCurrentlyScheduledTaskIds(ClientTO client) Returns the tasks IDs of the currently scheduled tasks
Date	getNextFireTime()
Class<TaskScheduledEvent>	getObservedEvent() Defines the types of events about which this listener will be informed.
long	getTaskExecutionVariance()
void	handle(TaskScheduledEvent event) Is called by the EventDispatcher when the observed event was fired.
void	incrementTaskExecutionVariance() Increment an offset that will be used when setting the start time of a task execution.
void	jobStarted(org.quartz.Trigger trigger) Callback to inform the scheduling context that the task scheduling job has been started.
void	rescheduleJobOnFailure(org.quartz.Trigger oldTrigger) Reschedule the task scheduling job for cases where the scheduling of tasks resulted in an error.
void	scheduledAllTaskHandlersSince(Date queryTime) Callback to inform the task scheduling context that the handlers for all tasks of the current client that were available at a specific point of time have been scheduled
void	scheduledTaskProcessed(TaskTO task, ClientTO client) Callback to inform the context that a previously scheduled handler was processed.
void	taskHandlerScheduled(TaskTO task, ClientTO client) Callback to inform the task scheduling context that the handler for a specific task has been scheduled

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

KEY_TASK_SCHEDULING_CONTEXT

public static final String KEY_TASK_SCHEDULING_CONTEXT

Key under which this instance is stored in the context of the scheduler instance

See Also:

Constant Field Values

Constructor Detail

TaskSchedulingContext

public TaskSchedulingContext(org.quartz.Trigger trigger,
                             EventDispatcher eventDispatcher)

Creates a new scheduling context for the provided trigger. The new instance is automatically registered at the event dispatcher.

Parameters:

trigger - the trigger of the task scheduling job

eventDispatcher - The event dispatcher to register this bean.

Method Detail

getClientsWithNewTasksOrRescheduleJob

public List<ClientTO> getClientsWithNewTasksOrRescheduleJob(org.quartz.Trigger oldTrigger)
                                                     throws org.quartz.SchedulerException

Try to reschedule the task scheduling job after all task handlers for all clients have been scheduled. If other threads added new urgent tasks in the mean time the job won't be rescheduled and the clients for which new tasks were added will be returned.

Parameters:

oldTrigger - the trigger that started the task scheduling job

Returns:

a collection of clients for which new tasks exist that must be processed before the job can be rescheduled. If null is returned the job was rescheduled.

Throws:

org.quartz.SchedulerException - in case the scheduling failed

getCurrentlyScheduledTaskIds

public Collection<Long> getCurrentlyScheduledTaskIds(ClientTO client)

Returns the tasks IDs of the currently scheduled tasks

Parameters:

client - the client for which the scheduled tasks should be returned

Returns:

the scheduled task IDs

getNextFireTime

public Date getNextFireTime()

Returns:

Now.

getObservedEvent

public Class<TaskScheduledEvent> getObservedEvent()

Defines the types of events about which this listener will be informed.

Specified by:

getObservedEvent in interface EventListener<TaskScheduledEvent>

Returns:

the class of the observed event

getTaskExecutionVariance

public long getTaskExecutionVariance()

Returns:

the current task execution variance in milliseconds

See Also:

incrementTaskExecutionVariance()

handle

public void handle(TaskScheduledEvent event)

Is called by the EventDispatcher when the observed event was fired.

Specified by:

handle in interface EventListener<TaskScheduledEvent>

Parameters:

event - the event that was fired

incrementTaskExecutionVariance

public void incrementTaskExecutionVariance()

Increment an offset that will be used when setting the start time of a task execution. Calling this method is usually only useful in a clustered environment where different nodes compete for task executions. The variance can help to reduce the possibility of a parallel executions which would be blocked anyway.

jobStarted

public void jobStarted(org.quartz.Trigger trigger)

Callback to inform the scheduling context that the task scheduling job has been started.

Parameters:

trigger - the trigger that started the job

rescheduleJobOnFailure

public void rescheduleJobOnFailure(org.quartz.Trigger oldTrigger)
                            throws org.quartz.SchedulerException

Reschedule the task scheduling job for cases where the scheduling of tasks resulted in an error.

Parameters:

oldTrigger - the trigger that started the task scheduling job

Throws:

org.quartz.SchedulerException - in case the rescheduling failed

scheduledAllTaskHandlersSince

public void scheduledAllTaskHandlersSince(Date queryTime)

Callback to inform the task scheduling context that the handlers for all tasks of the current client that were available at a specific point of time have been scheduled

Parameters:

queryTime - the time at which the caller checked for available tasks

scheduledTaskProcessed

public void scheduledTaskProcessed(TaskTO task,
                                   ClientTO client)

Callback to inform the context that a previously scheduled handler was processed.

Parameters:

task - the task that was started

client - the client on which the task is running

taskHandlerScheduled

public void taskHandlerScheduled(TaskTO task,
                                 ClientTO client)

Callback to inform the task scheduling context that the handler for a specific task has been scheduled

Parameters:

task - the task for which the handler has been scheduled

client - the client for which the handler was scheduled