Examples with CancelTasksRequest org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequest used on opensource projects

Example 1 with CancelTasksRequest

use of org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequest in project OpenSearch by opensearch-project.

the class TransportSearchAction method cancelTask.

private void cancelTask(SearchTask task, Exception exc) {
    String errorMsg = exc.getMessage() != null ? exc.getMessage() : "";
    CancelTasksRequest req = new CancelTasksRequest().setTaskId(new TaskId(client.getLocalNodeId(), task.getId())).setReason("Fatal failure during search: " + errorMsg);
    // force the origin to execute the cancellation as a system user
    new OriginSettingClient(client, TASKS_ORIGIN).admin().cluster().cancelTasks(req, ActionListener.wrap(() -> {
    }));
}

Example 2 with CancelTasksRequest

use of org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequest in project OpenSearch by opensearch-project.

the class TimeoutTaskCancellationUtility method wrapWithCancellationListener.

/**
 * Wraps a listener with a timeout listener {@link TimeoutRunnableListener} to schedule the task cancellation for provided tasks on
 * generic thread pool
 * @param client - {@link NodeClient}
 * @param taskToCancel - task to schedule cancellation for
 * @param clusterSettings - {@link ClusterSettings}
 * @param listener - original listener associated with the task
 * @return wrapped listener
 */
public static <Response> ActionListener<Response> wrapWithCancellationListener(NodeClient client, CancellableTask taskToCancel, ClusterSettings clusterSettings, ActionListener<Response> listener) {
    final TimeValue globalTimeout = clusterSettings.get(SEARCH_CANCEL_AFTER_TIME_INTERVAL_SETTING);
    final TimeValue timeoutInterval = (taskToCancel.getCancellationTimeout() == null) ? globalTimeout : taskToCancel.getCancellationTimeout();
    // Note: -1 (or no timeout) will help to turn off cancellation. The combinations will be request level set at -1 or request level
    // set to null and cluster level set to -1.
    ActionListener<Response> listenerToReturn = listener;
    if (timeoutInterval.equals(SearchService.NO_TIMEOUT)) {
        return listenerToReturn;
    }
    try {
        final TimeoutRunnableListener<Response> wrappedListener = new TimeoutRunnableListener<>(timeoutInterval, listener, () -> {
            final CancelTasksRequest cancelTasksRequest = new CancelTasksRequest();
            cancelTasksRequest.setTaskId(new TaskId(client.getLocalNodeId(), taskToCancel.getId()));
            cancelTasksRequest.setReason("Cancellation timeout of " + timeoutInterval + " is expired");
            // force the origin to execute the cancellation as a system user
            new OriginSettingClient(client, TASKS_ORIGIN).admin().cluster().cancelTasks(cancelTasksRequest, ActionListener.wrap(r -> logger.debug("Scheduled cancel task with timeout: {} for original task: {} is successfully completed", timeoutInterval, cancelTasksRequest.getTaskId()), e -> logger.error(new ParameterizedMessage("Scheduled cancel task with timeout: {} for original task: {} is failed", timeoutInterval, cancelTasksRequest.getTaskId()), e)));
        });
        wrappedListener.cancellable = client.threadPool().schedule(wrappedListener, timeoutInterval, ThreadPool.Names.GENERIC);
        listenerToReturn = wrappedListener;
    } catch (Exception ex) {
        // if there is any exception in scheduling the cancellation task then continue without it
        logger.warn("Failed to schedule the cancellation task for original task: {}, will continue without it", taskToCancel.getId());
    }
    return listenerToReturn;
}

Example 3 with CancelTasksRequest

use of org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequest in project OpenSearch by opensearch-project.

the class PersistentTasksService method sendCancelRequest.

/**
 * Cancels a locally running task using the Task Manager API
 */
void sendCancelRequest(final long taskId, final String reason, final ActionListener<CancelTasksResponse> listener) {
    CancelTasksRequest request = new CancelTasksRequest();
    request.setTaskId(new TaskId(clusterService.localNode().getId(), taskId));
    request.setReason(reason);
    try {
        client.admin().cluster().cancelTasks(request, listener);
    } catch (Exception e) {
        listener.onFailure(e);
    }
}

Example 4 with CancelTasksRequest

use of org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequest in project OpenSearch by opensearch-project.

the class CancellableTasksTests method testNonExistingTaskCancellation.

public void testNonExistingTaskCancellation() throws Exception {
    setupTestNodes(Settings.EMPTY);
    connectNodes(testNodes);
    // Cancel a task that doesn't exist
    CancelTasksRequest request = new CancelTasksRequest();
    request.setReason("Testing Cancellation");
    request.setActions("do-not-match-anything");
    request.setNodes(randomSubsetOf(randomIntBetween(1, testNodes.length - 1), testNodes).stream().map(TestNode::getNodeId).toArray(String[]::new));
    // And send the cancellation request to a random node
    CancelTasksResponse response = ActionTestUtils.executeBlocking(testNodes[randomIntBetween(1, testNodes.length - 1)].transportCancelTasksAction, request);
    // Shouldn't have cancelled anything
    assertThat(response.getTasks().size(), equalTo(0));
    assertBusy(() -> {
        // Make sure that main task is no longer running
        ListTasksResponse listTasksResponse = ActionTestUtils.executeBlocking(testNodes[randomIntBetween(0, testNodes.length - 1)].transportListTasksAction, new ListTasksRequest().setActions(CancelTasksAction.NAME + "*"));
        assertEquals(0, listTasksResponse.getTasks().size());
    });
}

Example 5 with CancelTasksRequest

use of org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequest in project OpenSearch by opensearch-project.

the class CancellableTasksTests method testChildTasksCancellation.

public void testChildTasksCancellation() throws Exception {
    setupTestNodes(Settings.EMPTY);
    connectNodes(testNodes);
    CountDownLatch responseLatch = new CountDownLatch(1);
    final AtomicReference<NodesResponse> responseReference = new AtomicReference<>();
    final AtomicReference<Throwable> throwableReference = new AtomicReference<>();
    int runNodesCount = randomIntBetween(1, nodesCount);
    int blockedNodesCount = randomIntBetween(0, runNodesCount);
    Task mainTask = startCancellableTestNodesAction(true, runNodesCount, blockedNodesCount, new ActionListener<NodesResponse>() {

        @Override
        public void onResponse(NodesResponse listTasksResponse) {
            responseReference.set(listTasksResponse);
            responseLatch.countDown();
        }

        @Override
        public void onFailure(Exception e) {
            throwableReference.set(e);
            responseLatch.countDown();
        }
    });
    // Cancel all child tasks without cancelling the main task, which should quit on its own
    CancelTasksRequest request = new CancelTasksRequest();
    request.setReason("Testing Cancellation");
    request.setParentTaskId(new TaskId(testNodes[0].getNodeId(), mainTask.getId()));
    // And send the cancellation request to a random node
    CancelTasksResponse response = ActionTestUtils.executeBlocking(testNodes[randomIntBetween(1, testNodes.length - 1)].transportCancelTasksAction, request);
    // Awaiting for the main task to finish
    responseLatch.await();
    // Should have cancelled tasks at least on all nodes where it was blocked
    assertThat(response.getTasks().size(), lessThanOrEqualTo(runNodesCount));
    // but may also encounter some nodes where it was still running
    assertThat(response.getTasks().size(), greaterThanOrEqualTo(blockedNodesCount));
    assertBusy(() -> {
        // Make sure that main task is no longer running
        ListTasksResponse listTasksResponse = ActionTestUtils.executeBlocking(testNodes[randomIntBetween(0, testNodes.length - 1)].transportListTasksAction, new ListTasksRequest().setTaskId(new TaskId(testNodes[0].getNodeId(), mainTask.getId())));
        assertEquals(0, listTasksResponse.getTasks().size());
    });
}