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

Example 16 with TaskInfo

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

the class TasksIT method testTaskStoringSuccesfulResult.

public void testTaskStoringSuccesfulResult() throws Exception {
    // Randomly create an empty index to make sure the type is created automatically
    if (randomBoolean()) {
        logger.info("creating an empty results index with custom settings");
        assertAcked(client().admin().indices().prepareCreate(TaskResultsService.TASK_INDEX));
    }
    // we need this to get task id of the process
    registerTaskManageListeners(TestTaskPlugin.TestTaskAction.NAME);
    // Start non-blocking test task
    TestTaskPlugin.TestTaskAction.INSTANCE.newRequestBuilder(client()).setShouldStoreResult(true).setShouldBlock(false).get();
    List<TaskInfo> events = findEvents(TestTaskPlugin.TestTaskAction.NAME, Tuple::v1);
    assertEquals(1, events.size());
    TaskInfo taskInfo = events.get(0);
    TaskId taskId = taskInfo.getTaskId();
    GetResponse resultDoc = client().prepareGet(TaskResultsService.TASK_INDEX, TaskResultsService.TASK_TYPE, taskId.toString()).get();
    assertTrue(resultDoc.isExists());
    Map<String, Object> source = resultDoc.getSource();
    @SuppressWarnings("unchecked") Map<String, Object> task = (Map<String, Object>) source.get("task");
    assertEquals(taskInfo.getTaskId().getNodeId(), task.get("node"));
    assertEquals(taskInfo.getAction(), task.get("action"));
    assertEquals(Long.toString(taskInfo.getId()), task.get("id").toString());
    @SuppressWarnings("unchecked") Map<String, Object> result = (Map<String, Object>) source.get("response");
    assertEquals("0", result.get("failure_count").toString());
    assertNull(source.get("failure"));
    assertNoFailures(client().admin().indices().prepareRefresh(TaskResultsService.TASK_INDEX).get());
    SearchResponse searchResponse = client().prepareSearch(TaskResultsService.TASK_INDEX).setTypes(TaskResultsService.TASK_TYPE).setSource(SearchSourceBuilder.searchSource().query(QueryBuilders.termQuery("task.action", taskInfo.getAction()))).get();
    assertEquals(1L, searchResponse.getHits().getTotalHits());
    searchResponse = client().prepareSearch(TaskResultsService.TASK_INDEX).setTypes(TaskResultsService.TASK_TYPE).setSource(SearchSourceBuilder.searchSource().query(QueryBuilders.termQuery("task.node", taskInfo.getTaskId().getNodeId()))).get();
    assertEquals(1L, searchResponse.getHits().getTotalHits());
    GetTaskResponse getResponse = expectFinishedTask(taskId);
    assertEquals(result, getResponse.getTask().getResponseAsMap());
    assertNull(getResponse.getTask().getError());
}

Example 17 with TaskInfo

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

the class TasksIT method expectFinishedTask.

/**
     * Fetch the task status from the list tasks API using it's "fallback to get from the task index" behavior. Asserts some obvious stuff
     * about the fetched task and returns a map of it's status.
     */
private GetTaskResponse expectFinishedTask(TaskId taskId) throws IOException {
    GetTaskResponse response = client().admin().cluster().prepareGetTask(taskId).get();
    assertTrue("the task should have been completed before fetching", response.getTask().isCompleted());
    TaskInfo info = response.getTask().getTask();
    assertEquals(taskId, info.getTaskId());
    // The test task doesn't have any status
    assertNull(info.getStatus());
    return response;
}

Example 18 with TaskInfo

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

the class TasksIT method testTransportBroadcastReplicationTasks.

public void testTransportBroadcastReplicationTasks() {
    // main task
    registerTaskManageListeners(RefreshAction.NAME);
    // shard level tasks
    registerTaskManageListeners(RefreshAction.NAME + "[s]");
    // primary and replica shard tasks
    registerTaskManageListeners(RefreshAction.NAME + "[s][*]");
    createIndex("test");
    // Make sure all shards are allocated
    ensureGreen("test");
    client().admin().indices().prepareRefresh("test").get();
    // the refresh operation should produce one main task
    NumShards numberOfShards = getNumShards("test");
    logger.debug("number of shards, total: [{}], primaries: [{}] ", numberOfShards.totalNumShards, numberOfShards.numPrimaries);
    logger.debug("main events {}", numberOfEvents(RefreshAction.NAME, Tuple::v1));
    logger.debug("main event node {}", findEvents(RefreshAction.NAME, Tuple::v1).get(0).getTaskId().getNodeId());
    logger.debug("[s] events {}", numberOfEvents(RefreshAction.NAME + "[s]", Tuple::v1));
    logger.debug("[s][*] events {}", numberOfEvents(RefreshAction.NAME + "[s][*]", Tuple::v1));
    logger.debug("nodes with the index {}", internalCluster().nodesInclude("test"));
    assertEquals(1, numberOfEvents(RefreshAction.NAME, Tuple::v1));
    // Because it's broadcast replication action we will have as many [s] level requests
    // as we have primary shards on the coordinating node plus we will have one task per primary outside of the
    // coordinating node due to replication.
    // If all primaries are on the coordinating node, the number of tasks should be equal to the number of primaries
    // If all primaries are not on the coordinating node, the number of tasks should be equal to the number of primaries times 2
    assertThat(numberOfEvents(RefreshAction.NAME + "[s]", Tuple::v1), greaterThanOrEqualTo(numberOfShards.numPrimaries));
    assertThat(numberOfEvents(RefreshAction.NAME + "[s]", Tuple::v1), lessThanOrEqualTo(numberOfShards.numPrimaries * 2));
    // Verify that all [s] events have the proper parent
    // This is complicated because if the shard task runs on the same node it has main task as a parent
    // but if it runs on non-coordinating node it would have another intermediate [s] task on the coordinating node as a parent
    TaskInfo mainTask = findEvents(RefreshAction.NAME, Tuple::v1).get(0);
    List<TaskInfo> sTasks = findEvents(RefreshAction.NAME + "[s]", Tuple::v1);
    for (TaskInfo taskInfo : sTasks) {
        if (mainTask.getTaskId().getNodeId().equals(taskInfo.getTaskId().getNodeId())) {
            // This shard level task runs on the same node as a parent task - it should have the main task as a direct parent
            assertParentTask(Collections.singletonList(taskInfo), mainTask);
        } else {
            String description = taskInfo.getDescription();
            // This shard level task runs on another node - it should have a corresponding shard level task on the node where main task
            // is running
            List<TaskInfo> sTasksOnRequestingNode = findEvents(RefreshAction.NAME + "[s]", event -> event.v1() && mainTask.getTaskId().getNodeId().equals(event.v2().getTaskId().getNodeId()) && description.equals(event.v2().getDescription()));
            // There should be only one parent task
            assertEquals(1, sTasksOnRequestingNode.size());
            assertParentTask(Collections.singletonList(taskInfo), sTasksOnRequestingNode.get(0));
        }
    }
    // we will have as many [s][p] and [s][r] tasks as we have primary and replica shards
    assertEquals(numberOfShards.totalNumShards, numberOfEvents(RefreshAction.NAME + "[s][*]", Tuple::v1));
    // we the [s][p] and [s][r] tasks should have a corresponding [s] task on the same node as a parent
    List<TaskInfo> spEvents = findEvents(RefreshAction.NAME + "[s][*]", Tuple::v1);
    for (TaskInfo taskInfo : spEvents) {
        List<TaskInfo> sTask;
        if (taskInfo.getAction().endsWith("[s][p]")) {
            // A [s][p] level task should have a corresponding [s] level task on the same node
            sTask = findEvents(RefreshAction.NAME + "[s]", event -> event.v1() && taskInfo.getTaskId().getNodeId().equals(event.v2().getTaskId().getNodeId()) && taskInfo.getDescription().equals(event.v2().getDescription()));
        } else {
            // A [s][r] level task should have a corresponding [s] level task on the a different node (where primary is located)
            sTask = findEvents(RefreshAction.NAME + "[s]", event -> event.v1() && taskInfo.getParentTaskId().getNodeId().equals(event.v2().getTaskId().getNodeId()) && taskInfo.getDescription().equals(event.v2().getDescription()));
        }
        // There should be only one parent task
        assertEquals(1, sTask.size());
        assertParentTask(Collections.singletonList(taskInfo), sTask.get(0));
    }
}

Example 19 with TaskInfo

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

the class TransportRethrottleActionTests method testRethrottleWithSomeSucceeded.

public void testRethrottleWithSomeSucceeded() {
    int succeeded = between(1, slices - 1);
    List<BulkByScrollTask.StatusOrException> sliceStatuses = new ArrayList<>(slices);
    for (int i = 0; i < succeeded; i++) {
        BulkByScrollTask.Status status = believeableCompletedStatus(i);
        task.onSliceResponse(neverCalled(), i, new BulkByScrollResponse(timeValueMillis(10), status, emptyList(), emptyList(), false));
        sliceStatuses.add(new BulkByScrollTask.StatusOrException(status));
    }
    List<TaskInfo> tasks = new ArrayList<>();
    for (int i = succeeded; i < slices; i++) {
        BulkByScrollTask.Status status = believeableInProgressStatus(i);
        tasks.add(new TaskInfo(new TaskId("test", 123), "test", "test", "test", status, 0, 0, true, new TaskId("test", task.getId())));
        sliceStatuses.add(new BulkByScrollTask.StatusOrException(status));
    }
    rethrottleTestCase(slices - succeeded, listener -> listener.onResponse(new ListTasksResponse(tasks, emptyList(), emptyList())), expectSuccessfulRethrottleWithStatuses(sliceStatuses));
}

Example 20 with TaskInfo

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

the class TransportRethrottleActionTests method rethrottleTestCase.

/**
     * Test rethrottling.
     * @param runningSlices the number of slices still running
     * @param simulator simulate a response from the sub-request to rethrottle the child requests
     * @param verifier verify the resulting response
     */
private void rethrottleTestCase(int runningSlices, Consumer<ActionListener<ListTasksResponse>> simulator, Consumer<ActionListener<TaskInfo>> verifier) {
    Client client = mock(Client.class);
    String localNodeId = randomAsciiOfLength(5);
    float newRequestsPerSecond = randomValueOtherThanMany(f -> f <= 0, () -> randomFloat());
    @SuppressWarnings("unchecked") ActionListener<TaskInfo> listener = mock(ActionListener.class);
    TransportRethrottleAction.rethrottle(localNodeId, client, task, newRequestsPerSecond, listener);
    // Capture the sub request and the listener so we can verify they are sane
    ArgumentCaptor<RethrottleRequest> subRequest = ArgumentCaptor.forClass(RethrottleRequest.class);
    // Magical generics incantation.....
    @SuppressWarnings({ "unchecked", "rawtypes" }) ArgumentCaptor<ActionListener<ListTasksResponse>> subListener = ArgumentCaptor.forClass((Class) ActionListener.class);
    if (runningSlices > 0) {
        verify(client).execute(eq(RethrottleAction.INSTANCE), subRequest.capture(), subListener.capture());
        assertEquals(new TaskId(localNodeId, task.getId()), subRequest.getValue().getParentTaskId());
        assertEquals(newRequestsPerSecond / runningSlices, subRequest.getValue().getRequestsPerSecond(), 0.00001f);
        simulator.accept(subListener.getValue());
    }
    verifier.accept(listener);
}