Examples with Task org.elasticsearch.tasks.Task used on opensource projects

Example 11 with Task

use of org.elasticsearch.tasks.Task in project elasticsearch by elastic.

the class RequestHandlerRegistry method processMessageReceived.

public void processMessageReceived(Request request, TransportChannel channel) throws Exception {
    final Task task = taskManager.register(channel.getChannelType(), action, request);
    if (task == null) {
        handler.messageReceived(request, channel);
    } else {
        boolean success = false;
        try {
            handler.messageReceived(request, new TransportChannelWrapper(taskManager, task, channel), task);
            success = true;
        } finally {
            if (success == false) {
                taskManager.unregister(task);
            }
        }
    }
}

Example 12 with Task

use of org.elasticsearch.tasks.Task in project crate by crate.

the class RepositoryServiceTest method testRepositoryIsDroppedOnFailure.

@Test
public void testRepositoryIsDroppedOnFailure() throws Throwable {
    expectedException.expect(RepositoryException.class);
    // add repo to cluster service so that it exists..
    RepositoriesMetaData repos = new RepositoriesMetaData(new RepositoryMetaData("repo1", "fs", Settings.EMPTY));
    ClusterState state = ClusterState.builder(new ClusterName("dummy")).metaData(MetaData.builder().putCustom(RepositoriesMetaData.TYPE, repos)).build();
    ClusterService clusterService = new NoopClusterService(state);
    final ActionFilters actionFilters = mock(ActionFilters.class, Answers.RETURNS_MOCKS.get());
    IndexNameExpressionResolver indexNameExpressionResolver = new IndexNameExpressionResolver(Settings.EMPTY);
    final AtomicBoolean deleteRepoCalled = new AtomicBoolean(false);
    TransportDeleteRepositoryAction deleteRepositoryAction = new TransportDeleteRepositoryAction(Settings.EMPTY, mock(TransportService.class, Answers.RETURNS_MOCKS.get()), clusterService, mock(RepositoriesService.class), threadPool, actionFilters, indexNameExpressionResolver) {

        @Override
        protected void doExecute(Task task, DeleteRepositoryRequest request, ActionListener<DeleteRepositoryResponse> listener) {
            deleteRepoCalled.set(true);
            listener.onResponse(mock(DeleteRepositoryResponse.class));
        }
    };
    TransportPutRepositoryAction putRepo = new TransportPutRepositoryAction(Settings.EMPTY, mock(TransportService.class, Answers.RETURNS_MOCKS.get()), clusterService, mock(RepositoriesService.class), threadPool, actionFilters, indexNameExpressionResolver) {

        @Override
        protected void doExecute(Task task, PutRepositoryRequest request, ActionListener<PutRepositoryResponse> listener) {
            listener.onFailure(new RepositoryException(request.name(), "failure"));
        }
    };
    RepositoryService repositoryService = new RepositoryService(clusterService, deleteRepositoryAction, putRepo);
    try {
        repositoryService.execute(new CreateRepositoryAnalyzedStatement("repo1", "fs", Settings.EMPTY)).get(10, TimeUnit.SECONDS);
    } catch (ExecutionException e) {
        assertThat(deleteRepoCalled.get(), is(true));
        throw e.getCause();
    }
}

Example 13 with Task

use of org.elasticsearch.tasks.Task in project elasticsearch by elastic.

the class TransportAction method execute.

/**
     * Execute the transport action on the local node, returning the {@link Task} used to track its execution and accepting a
     * {@link TaskListener} which listens for the completion of the action.
     */
public final Task execute(Request request, TaskListener<Response> listener) {
    Task task = taskManager.register("transport", actionName, request);
    execute(task, request, new ActionListener<Response>() {

        @Override
        public void onResponse(Response response) {
            if (task != null) {
                taskManager.unregister(task);
            }
            listener.onResponse(task, response);
        }

        @Override
        public void onFailure(Exception e) {
            if (task != null) {
                taskManager.unregister(task);
            }
            listener.onFailure(task, e);
        }
    });
    return task;
}

Example 14 with Task

use of org.elasticsearch.tasks.Task in project elasticsearch by elastic.

the class TransportGetTaskAction method runOnNodeWithTaskIfPossible.

/**
     * Executed on the coordinating node to forward execution of the remaining work to the node that matches that requested
     * {@link TaskId#getNodeId()}. If the node isn't in the cluster then this will just proceed to
     * {@link #getFinishedTaskFromIndex(Task, GetTaskRequest, ActionListener)} on this node.
     */
private void runOnNodeWithTaskIfPossible(Task thisTask, GetTaskRequest request, ActionListener<GetTaskResponse> listener) {
    TransportRequestOptions.Builder builder = TransportRequestOptions.builder();
    if (request.getTimeout() != null) {
        builder.withTimeout(request.getTimeout());
    }
    builder.withCompress(false);
    DiscoveryNode node = clusterService.state().nodes().get(request.getTaskId().getNodeId());
    if (node == null) {
        // Node is no longer part of the cluster! Try and look the task up from the results index.
        getFinishedTaskFromIndex(thisTask, request, ActionListener.wrap(listener::onResponse, e -> {
            if (e instanceof ResourceNotFoundException) {
                e = new ResourceNotFoundException("task [" + request.getTaskId() + "] belongs to the node [" + request.getTaskId().getNodeId() + "] which isn't part of the cluster and there is no record of the task", e);
            }
            listener.onFailure(e);
        }));
        return;
    }
    GetTaskRequest nodeRequest = request.nodeRequest(clusterService.localNode().getId(), thisTask.getId());
    transportService.sendRequest(node, GetTaskAction.NAME, nodeRequest, builder.build(), new TransportResponseHandler<GetTaskResponse>() {

        @Override
        public GetTaskResponse newInstance() {
            return new GetTaskResponse();
        }

        @Override
        public void handleResponse(GetTaskResponse response) {
            listener.onResponse(response);
        }

        @Override
        public void handleException(TransportException exp) {
            listener.onFailure(exp);
        }

        @Override
        public String executor() {
            return ThreadPool.Names.SAME;
        }
    });
}

Example 15 with Task

use of org.elasticsearch.tasks.Task in project elasticsearch by elastic.

the class TransportTasksActionTests method testTaskLevelActionFailures.

public void testTaskLevelActionFailures() throws ExecutionException, InterruptedException, IOException {
    setupTestNodes(Settings.EMPTY);
    connectNodes(testNodes);
    CountDownLatch checkLatch = new CountDownLatch(1);
    ActionFuture<NodesResponse> future = startBlockingTestNodesAction(checkLatch);
    TestTasksAction[] tasksActions = new TestTasksAction[nodesCount];
    final int failTaskOnNode = randomIntBetween(1, nodesCount - 1);
    for (int i = 0; i < testNodes.length; i++) {
        final int node = i;
        // Simulate task action that fails on one of the tasks on one of the nodes
        tasksActions[i] = new TestTasksAction(CLUSTER_SETTINGS, "testTasksAction", threadPool, testNodes[i].clusterService, testNodes[i].transportService) {

            @Override
            protected void taskOperation(TestTasksRequest request, Task task, ActionListener<TestTaskResponse> listener) {
                logger.info("Task action on node {}", node);
                if (failTaskOnNode == node && task.getParentTaskId().isSet()) {
                    logger.info("Failing on node {}", node);
                    // Fail in a random way to make sure we can handle all these ways
                    Runnable failureMode = randomFrom(() -> {
                        logger.info("Throwing exception from taskOperation");
                        throw new RuntimeException("Task level failure (direct)");
                    }, () -> {
                        logger.info("Calling listener synchronously with exception from taskOperation");
                        listener.onFailure(new RuntimeException("Task level failure (sync listener)"));
                    }, () -> {
                        logger.info("Calling listener asynchronously with exception from taskOperation");
                        threadPool.generic().execute(() -> listener.onFailure(new RuntimeException("Task level failure (async listener)")));
                    });
                    failureMode.run();
                } else {
                    if (randomBoolean()) {
                        listener.onResponse(new TestTaskResponse("Success on node (sync)" + node));
                    } else {
                        threadPool.generic().execute(() -> listener.onResponse(new TestTaskResponse("Success on node (async)" + node)));
                    }
                }
            }
        };
    }
    // Run task action on node tasks that are currently running
    // should be successful on all nodes except one
    TestTasksRequest testTasksRequest = new TestTasksRequest();
    // pick all test actions
    testTasksRequest.setActions("testAction[n]");
    TestTasksResponse response = tasksActions[0].execute(testTasksRequest).get();
    // one task failed
    assertThat(response.getTaskFailures(), hasSize(1));
    assertThat(response.getTaskFailures().get(0).getReason(), containsString("Task level failure"));
    // Get successful responses from all nodes except one
    assertEquals(testNodes.length - 1, response.tasks.size());
    // no nodes failed
    assertEquals(0, response.getNodeFailures().size());
    // Release all node tasks and wait for response
    checkLatch.countDown();
    NodesResponse responses = future.get();
    assertEquals(0, responses.failureCount());
}