What causes "Call was interrupted" in flowable/flowable-engine?

Check why the executing thread was interrupted (shutdown, cancellation, timeout) and address the upstream trigger.

flowable/flowable-engine · error · FlowableException

Call was interrupted

Error message

Call was interrupted

What it means

AsyncExecutableHttpRequest.call() blocks on callAsync().get(). If the waiting thread is interrupted while blocked, the library re-asserts the interrupt flag and wraps the InterruptedException in a FlowableException with message "Call was interrupted".

Solutions

Check why the executing thread was interrupted (shutdown, cancellation, timeout) and address the upstream trigger.
Preserve cancellation semantics: do not swallow the exception; let the FlowableException propagate or retry the call if the operation is idempotent.
Avoid interrupting worker threads that run HTTP activities, or use callAsync() with a timeout instead of blocking call().

Defensive patterns

Strategy: try-catch

Try / catch

try {
    HttpResponse response = request.call();
} catch (FlowableException e) {
    if (e.getCause() instanceof InterruptedException) {
        Thread.currentThread().interrupt(); // restore interrupt status
        // abort or reschedule the work
    }
}

Prevention

Avoid interrupting threads that execute blocking HTTP calls during shutdown; drain gracefully
Prefer callAsync() with a timeout over interrupt-based cancellation
Keep the interrupt status when catching InterruptedException in surrounding code
Make the HTTP operation idempotent so it can be safely retried after cancellation

When it happens

Trigger: A thread executing the asynchronous HTTP call synchronously via call() is interrupted (Thread.interrupt()) while parked in CompletableFuture.get().

Common situations: Flowable engine shutting down or cancelling a job/executing thread pool; timeouts in the surrounding framework that interrupt worker threads; application shutdown interrupting in-flight HTTP activity executions.

Understand the failure class

Background: Request timed out: what client-side request timeouts mean across libraries (Request timed out, TIMED_OUT, APITimeoutError) — this error's family across 39 libraries.

Related errors

AI-assisted analysis of flowable/flowable-engine@d6d39ce1c6 (2026-09-11). Data as JSON: /api/errors/84fa28649141becd. Report an issue: GitHub.

Appendix: source

Thrown at modules/flowable-http-common/src/main/java/org/flowable/http/common/api/client/AsyncExecutableHttpRequest.java:33

import java.io.IOException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

import org.flowable.common.engine.api.FlowableException;
import org.flowable.http.common.api.HttpResponse;

/**
 * @author Filip Hrisafov
 */
public interface AsyncExecutableHttpRequest extends ExecutableHttpRequest {

    @Override
    default HttpResponse call() {
        try {
            return callAsync().get();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new FlowableException("Call was interrupted", e);
        } catch (ExecutionException e) {
            Throwable cause = e.getCause();
            if (cause instanceof RuntimeException) {
                throw (RuntimeException) cause;
            } else if (cause instanceof IOException) {
                throw new FlowableException("IO exception occurred", cause);
            } else {
                throw new FlowableException("execution exception", cause);
            }
        }
    }

    CompletableFuture<HttpResponse> callAsync();
}

View on GitHub (pinned to d6d39ce1c6)