Unable to Cancel Currently Picked Task

[antoineghigny]

Hello,

We are experiencing issues with db-scheduler where it seems impossible to cancel a task that is currently being executed ("currently picked"). This is causing problems in our application as it occurs frequently.

Error messages encountered:

• Expected one execution to be removed, but removed 0. Indicates a bug.
• Cannot use SchedulerClient to modify a task-instance that is currently executing. If this occurs often, consider only modifying executions not picked that has the next execution-time a certain time into the future.

Has anyone encountered a similar issue or have any suggestions for a solution? We are specifically looking for a way to cancel tasks even if they are currently being executed. We are interested in implementing a "mark as cancelled" functionality, where tasks can be flagged as cancelled without attempting to modify them directly during execution. If direct cancellation is not possible, are there recommended strategies to handle this scenario effectively?

Thank you for your help.

[kagkarlsson]

Yeah, cancellation is currently not supported, hence the error-message. It is a bit tricky to implement. If you have some sort of loop in your ExecutionHandler, you could regularly check for cancellation-request (stored in a custom table?), and if present, terminate the loop and return from the handler with a suitable CompletionHandler

[antoineghigny]

Hi,

Yesterday, I delved into investigating how to handle task cancellation within our application using db-scheduler. While exploring potential solutions, I stumbled upon a method that I'd like to run by you for your insights and expertise.

Here's a simplified overview of what we've implemented as a proof-of-concept:

public Task<ReplicationTaskData> replicationTask() {
    // Configuration of the task omitted for brevity

    return Tasks.custom("ReplicationTask", ReplicationTaskData.class)
            .onFailureReschedule(schedule)
            .onDeadExecutionRevive()
            .execute((inst, ctx) -> {
                // Logic for fetching task data omitted for brevity

                return (executionComplete, executionOperations) -> {
                    // Logic for handling task execution omitted for brevity
                    
                    // Simplified check conditions
                    if (condition1 && condition2) {
                        // If conditions are met, remove the execution
                        executionOperations.remove();
                    } else {
                        // Otherwise, reschedule the task
                        executionOperations.reschedule(executionComplete, nextSchedule, taskData);
                    }
                };
            });
}

In this approach, we handle both removal and rescheduling of tasks based on certain conditions.

Do you believe this is a suitable method for handling task cancellation within db-scheduler?
Are there any potential issues or risks associated with this approach, especially if an execution fails to reschedule?

Thank you for taking the time to review this approach.

[kagkarlsson]

Sorry I missed this one. Yeah I think that this approach (regularly rescheduling) is preferred to actively trying to cancel a running task. You should be able to implement this by regularly checking a condition in the loop, and if time to cancel, for example reschedule to now()

[tstavinoha]

Hello,

Mixing cancellation logic with the business logic of the task feels wrong, and will probably lead to unwanted duplication as every task needs to have its own check of premature termination condition.

Also sometimes even though there is a loop, each iteration takes a couple of minutes, creating a large gap between issuing a cancel command and the task actually being cancelled.

However, taking into account Java threading model limitations, is there any chance of this feature being supported on library level at all? Could you expand on what parts of implementation are tricky?

Thanks

[kagkarlsson]

Also sometimes even though there is a loop, each iteration takes a couple of minutes

Why cancel rather than letting the loop finish the iteration?

I am not sure how I would implement active cancellation. I feel i builds a bit too much complexity for my taste..