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

Example 11 with TaskInfo

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

the class TransportTasksActionTests method testFindChildTasks.

public void testFindChildTasks() throws Exception {
    setupTestNodes(Settings.EMPTY);
    connectNodes(testNodes);
    CountDownLatch checkLatch = new CountDownLatch(1);
    ActionFuture<NodesResponse> future = startBlockingTestNodesAction(checkLatch);
    TestNode testNode = testNodes[randomIntBetween(0, testNodes.length - 1)];
    // Get the parent task
    ListTasksRequest listTasksRequest = new ListTasksRequest();
    listTasksRequest.setActions("testAction");
    ListTasksResponse response = testNode.transportListTasksAction.execute(listTasksRequest).get();
    assertEquals(1, response.getTasks().size());
    String parentNode = response.getTasks().get(0).getTaskId().getNodeId();
    long parentTaskId = response.getTasks().get(0).getId();
    // Find tasks with common parent
    listTasksRequest = new ListTasksRequest();
    listTasksRequest.setParentTaskId(new TaskId(parentNode, parentTaskId));
    response = testNode.transportListTasksAction.execute(listTasksRequest).get();
    assertEquals(testNodes.length, response.getTasks().size());
    for (TaskInfo task : response.getTasks()) {
        assertEquals("testAction[n]", task.getAction());
        assertEquals(parentNode, task.getParentTaskId().getNodeId());
        assertEquals(parentTaskId, task.getParentTaskId().getId());
    }
    // Release all tasks and wait for response
    checkLatch.countDown();
    NodesResponse responses = future.get();
    assertEquals(0, responses.failureCount());
}

Example 12 with TaskInfo

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

the class TasksIT method testSearchTaskDescriptions.

public void testSearchTaskDescriptions() {
    // main task
    registerTaskManageListeners(SearchAction.NAME);
    // shard task
    registerTaskManageListeners(SearchAction.NAME + "[*]");
    createIndex("test");
    // Make sure all shards are allocated to catch replication tasks
    ensureGreen("test");
    client().prepareIndex("test", "doc", "test_id").setSource("{\"foo\": \"bar\"}", XContentType.JSON).setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE).get();
    assertSearchResponse(client().prepareSearch("test").setTypes("doc").setQuery(QueryBuilders.matchAllQuery()).get());
    // the search operation should produce one main task
    List<TaskInfo> mainTask = findEvents(SearchAction.NAME, Tuple::v1);
    assertEquals(1, mainTask.size());
    assertThat(mainTask.get(0).getDescription(), startsWith("indices[test], types[doc], search_type["));
    assertThat(mainTask.get(0).getDescription(), containsString("\"query\":{\"match_all\""));
    // check that if we have any shard-level requests they all have non-zero length description
    List<TaskInfo> shardTasks = findEvents(SearchAction.NAME + "[*]", Tuple::v1);
    for (TaskInfo taskInfo : shardTasks) {
        assertThat(taskInfo.getParentTaskId(), notNullValue());
        assertEquals(mainTask.get(0).getTaskId(), taskInfo.getParentTaskId());
        switch(taskInfo.getAction()) {
            case SearchTransportService.QUERY_ACTION_NAME:
            case SearchTransportService.DFS_ACTION_NAME:
                assertTrue(taskInfo.getDescription(), Regex.simpleMatch("shardId[[test][*]]", taskInfo.getDescription()));
                break;
            case SearchTransportService.QUERY_ID_ACTION_NAME:
                assertTrue(taskInfo.getDescription(), Regex.simpleMatch("id[*], indices[test]", taskInfo.getDescription()));
                break;
            case SearchTransportService.FETCH_ID_ACTION_NAME:
                assertTrue(taskInfo.getDescription(), Regex.simpleMatch("id[*], size[1], lastEmittedDoc[null]", taskInfo.getDescription()));
                break;
            default:
                fail("Unexpected action [" + taskInfo.getAction() + "] with description [" + taskInfo.getDescription() + "]");
        }
        // assert that all task descriptions have non-zero length
        assertThat(taskInfo.getDescription().length(), greaterThan(0));
    }
}

Example 13 with TaskInfo

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

the class TasksIT method testTaskStoringFailureResult.

public void testTaskStoringFailureResult() throws Exception {
    // we need this to get task id of the process
    registerTaskManageListeners(TestTaskPlugin.TestTaskAction.NAME);
    // Start non-blocking test task that should fail
    assertThrows(TestTaskPlugin.TestTaskAction.INSTANCE.newRequestBuilder(client()).setShouldFail(true).setShouldStoreResult(true).setShouldBlock(false), IllegalStateException.class);
    List<TaskInfo> events = findEvents(TestTaskPlugin.TestTaskAction.NAME, Tuple::v1);
    assertEquals(1, events.size());
    TaskInfo failedTaskInfo = events.get(0);
    TaskId failedTaskId = failedTaskInfo.getTaskId();
    GetResponse failedResultDoc = client().prepareGet(TaskResultsService.TASK_INDEX, TaskResultsService.TASK_TYPE, failedTaskId.toString()).get();
    assertTrue(failedResultDoc.isExists());
    Map<String, Object> source = failedResultDoc.getSource();
    @SuppressWarnings("unchecked") Map<String, Object> task = (Map<String, Object>) source.get("task");
    assertEquals(failedTaskInfo.getTaskId().getNodeId(), task.get("node"));
    assertEquals(failedTaskInfo.getAction(), task.get("action"));
    assertEquals(Long.toString(failedTaskInfo.getId()), task.get("id").toString());
    @SuppressWarnings("unchecked") Map<String, Object> error = (Map<String, Object>) source.get("error");
    assertEquals("Simulating operation failure", error.get("reason"));
    assertEquals("illegal_state_exception", error.get("type"));
    assertNull(source.get("result"));
    GetTaskResponse getResponse = expectFinishedTask(failedTaskId);
    assertNull(getResponse.getTask().getResponse());
    assertEquals(error, getResponse.getTask().getErrorAsMap());
}

Example 14 with TaskInfo

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

the class TasksIT method testTransportBulkTasks.

public void testTransportBulkTasks() {
    // main task
    registerTaskManageListeners(BulkAction.NAME);
    // shard task
    registerTaskManageListeners(BulkAction.NAME + "[s]");
    // shard task on primary
    registerTaskManageListeners(BulkAction.NAME + "[s][p]");
    // shard task on replica
    registerTaskManageListeners(BulkAction.NAME + "[s][r]");
    createIndex("test");
    // Make sure all shards are allocated to catch replication tasks
    ensureGreen("test");
    client().prepareBulk().add(client().prepareIndex("test", "doc", "test_id").setSource("{\"foo\": \"bar\"}", XContentType.JSON)).get();
    // the bulk operation should produce one main task
    List<TaskInfo> topTask = findEvents(BulkAction.NAME, Tuple::v1);
    assertEquals(1, topTask.size());
    assertEquals("requests[1], indices[test]", topTask.get(0).getDescription());
    // we should also get 1 or 2 [s] operation with main operation as a parent
    // in case the primary is located on the coordinating node we will have 1 operation, otherwise - 2
    List<TaskInfo> shardTasks = findEvents(BulkAction.NAME + "[s]", Tuple::v1);
    assertThat(shardTasks.size(), allOf(lessThanOrEqualTo(2), greaterThanOrEqualTo(1)));
    // Select the effective shard task
    TaskInfo shardTask;
    if (shardTasks.size() == 1) {
        // we have only one task - it's going to be the parent task for all [s][p] and [s][r] tasks
        shardTask = shardTasks.get(0);
        // and it should have the main task as a parent
        assertParentTask(shardTask, findEvents(BulkAction.NAME, Tuple::v1).get(0));
        assertEquals("requests[1], index[test]", shardTask.getDescription());
    } else {
        if (shardTasks.get(0).getParentTaskId().equals(shardTasks.get(1).getTaskId())) {
            // task 1 is the parent of task 0, that means that task 0 will control [s][p] and [s][r] tasks
            shardTask = shardTasks.get(0);
            // in turn the parent of the task 1 should be the main task
            assertParentTask(shardTasks.get(1), findEvents(BulkAction.NAME, Tuple::v1).get(0));
            assertEquals("requests[1], index[test]", shardTask.getDescription());
        } else {
            // otherwise task 1 will control [s][p] and [s][r] tasks
            shardTask = shardTasks.get(1);
            // in turn the parent of the task 0 should be the main task
            assertParentTask(shardTasks.get(0), findEvents(BulkAction.NAME, Tuple::v1).get(0));
            assertEquals("requests[1], index[test]", shardTask.getDescription());
        }
    }
    // we should also get one [s][p] operation with shard operation as a parent
    assertEquals(1, numberOfEvents(BulkAction.NAME + "[s][p]", Tuple::v1));
    assertParentTask(findEvents(BulkAction.NAME + "[s][p]", Tuple::v1), shardTask);
    // we should get as many [s][r] operations as we have replica shards
    // they all should have the same shard task as a parent
    assertEquals(getNumShards("test").numReplicas, numberOfEvents(BulkAction.NAME + "[s][r]", Tuple::v1));
    assertParentTask(findEvents(BulkAction.NAME + "[s][r]", Tuple::v1), shardTask);
}

Example 15 with TaskInfo

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

the class TasksIT method testCanFetchIndexStatus.

/**
     * Very basic "is it plugged in" style test that indexes a document and makes sure that you can fetch the status of the process. The
     * goal here is to verify that the large moving parts that make fetching task status work fit together rather than to verify any
     * particular status results from indexing. For that, look at {@link TransportReplicationActionTests}. We intentionally don't use the
     * task recording mechanism used in other places in this test so we can make sure that the status fetching works properly over the wire.
     */
public void testCanFetchIndexStatus() throws Exception {
    // First latch waits for the task to start, second on blocks it from finishing.
    CountDownLatch taskRegistered = new CountDownLatch(1);
    CountDownLatch letTaskFinish = new CountDownLatch(1);
    Thread index = null;
    try {
        for (TransportService transportService : internalCluster().getInstances(TransportService.class)) {
            ((MockTaskManager) transportService.getTaskManager()).addListener(new MockTaskManagerListener() {

                @Override
                public void onTaskRegistered(Task task) {
                    if (task.getAction().startsWith(IndexAction.NAME)) {
                        taskRegistered.countDown();
                        logger.debug("Blocking [{}] starting", task);
                        try {
                            assertTrue(letTaskFinish.await(10, TimeUnit.SECONDS));
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }

                @Override
                public void onTaskUnregistered(Task task) {
                }

                @Override
                public void waitForTaskCompletion(Task task) {
                }
            });
        }
        // Need to run the task in a separate thread because node client's .execute() is blocked by our task listener
        index = new Thread(() -> {
            IndexResponse indexResponse = client().prepareIndex("test", "test").setSource("test", "test").get();
            assertArrayEquals(ReplicationResponse.EMPTY, indexResponse.getShardInfo().getFailures());
        });
        index.start();
        // waiting for at least one task to be registered
        assertTrue(taskRegistered.await(10, TimeUnit.SECONDS));
        ListTasksResponse listResponse = client().admin().cluster().prepareListTasks().setActions("indices:data/write/index*").setDetailed(true).get();
        assertThat(listResponse.getTasks(), not(empty()));
        for (TaskInfo task : listResponse.getTasks()) {
            assertNotNull(task.getStatus());
            GetTaskResponse getResponse = client().admin().cluster().prepareGetTask(task.getTaskId()).get();
            assertFalse("task should still be running", getResponse.getTask().isCompleted());
            TaskInfo fetchedWithGet = getResponse.getTask().getTask();
            assertEquals(task.getId(), fetchedWithGet.getId());
            assertEquals(task.getType(), fetchedWithGet.getType());
            assertEquals(task.getAction(), fetchedWithGet.getAction());
            assertEquals(task.getDescription(), fetchedWithGet.getDescription());
            assertEquals(task.getStatus(), fetchedWithGet.getStatus());
            assertEquals(task.getStartTime(), fetchedWithGet.getStartTime());
            assertThat(fetchedWithGet.getRunningTimeNanos(), greaterThanOrEqualTo(task.getRunningTimeNanos()));
            assertEquals(task.isCancellable(), fetchedWithGet.isCancellable());
            assertEquals(task.getParentTaskId(), fetchedWithGet.getParentTaskId());
        }
    } finally {
        letTaskFinish.countDown();
        if (index != null) {
            index.join();
        }
        assertBusy(() -> {
            assertEquals(emptyList(), client().admin().cluster().prepareListTasks().setActions("indices:data/write/index*").get().getTasks());
        });
    }
}