Examples with ListTasksResponse org.opensearch.action.admin.cluster.node.tasks.list.ListTasksResponse used on opensource projects

Example 1 with ListTasksResponse

use of org.opensearch.action.admin.cluster.node.tasks.list.ListTasksResponse in project OpenSearch by opensearch-project.

the class TasksIT method testCancelTasks.

public void testCancelTasks() throws IOException {
    ListTasksRequest listRequest = new ListTasksRequest();
    ListTasksResponse listResponse = execute(listRequest, highLevelClient().tasks()::list, highLevelClient().tasks()::listAsync);
    // in this case, probably no task will actually be cancelled.
    // this is ok, that case is covered in TasksIT.testTasksCancellation
    org.opensearch.tasks.TaskInfo firstTask = listResponse.getTasks().get(0);
    String node = listResponse.getPerNodeTasks().keySet().iterator().next();
    CancelTasksRequest cancelTasksRequest = new CancelTasksRequest.Builder().withTaskId(new TaskId(node, firstTask.getId())).build();
    CancelTasksResponse response = execute(cancelTasksRequest, highLevelClient().tasks()::cancel, highLevelClient().tasks()::cancelAsync);
    // Since the task may or may not have been cancelled, assert that we received a response only
    // The actual testing of task cancellation is covered by TasksIT.testTasksCancellation
    assertThat(response, notNullValue());
}

Example 2 with ListTasksResponse

use of org.opensearch.action.admin.cluster.node.tasks.list.ListTasksResponse in project OpenSearch by opensearch-project.

the class TasksIT method testListTasks.

public void testListTasks() throws IOException {
    ListTasksRequest request = new ListTasksRequest();
    ListTasksResponse response = execute(request, highLevelClient().tasks()::list, highLevelClient().tasks()::listAsync);
    assertThat(response, notNullValue());
    assertThat(response.getNodeFailures(), equalTo(emptyList()));
    assertThat(response.getTaskFailures(), equalTo(emptyList()));
    // It's possible that there are other tasks except 'cluster:monitor/tasks/lists[n]' and 'action":"cluster:monitor/tasks/lists'
    assertThat(response.getTasks().size(), greaterThanOrEqualTo(2));
    boolean listTasksFound = false;
    for (TaskGroup taskGroup : response.getTaskGroups()) {
        org.opensearch.tasks.TaskInfo parent = taskGroup.getTaskInfo();
        if ("cluster:monitor/tasks/lists".equals(parent.getAction())) {
            assertThat(taskGroup.getChildTasks().size(), equalTo(1));
            TaskGroup childGroup = taskGroup.getChildTasks().iterator().next();
            assertThat(childGroup.getChildTasks().isEmpty(), equalTo(true));
            org.opensearch.tasks.TaskInfo child = childGroup.getTaskInfo();
            assertThat(child.getAction(), equalTo("cluster:monitor/tasks/lists[n]"));
            assertThat(child.getParentTaskId(), equalTo(parent.getTaskId()));
            listTasksFound = true;
        }
    }
    assertTrue("List tasks were not found", listTasksFound);
}

Example 3 with ListTasksResponse

use of org.opensearch.action.admin.cluster.node.tasks.list.ListTasksResponse in project OpenSearch by opensearch-project.

the class OpenSearchRestHighLevelClientTestCase method findTaskToRethrottle.

protected static TaskId findTaskToRethrottle(String actionName, String description) throws IOException {
    long start = System.nanoTime();
    ListTasksRequest request = new ListTasksRequest();
    request.setActions(actionName);
    request.setDetailed(true);
    do {
        ListTasksResponse list = highLevelClient().tasks().list(request, RequestOptions.DEFAULT);
        list.rethrowFailures("Finding tasks to rethrottle");
        List<TaskGroup> taskGroups = list.getTaskGroups().stream().filter(taskGroup -> taskGroup.getTaskInfo().getDescription().equals(description)).collect(Collectors.toList());
        assertThat("tasks are left over from the last execution of this test", taskGroups, hasSize(lessThan(2)));
        if (0 == taskGroups.size()) {
            // The parent task hasn't started yet
            continue;
        }
        TaskGroup taskGroup = taskGroups.get(0);
        assertThat(taskGroup.getChildTasks(), empty());
        return taskGroup.getTaskInfo().getTaskId();
    } while (System.nanoTime() - start < TimeUnit.SECONDS.toNanos(10));
    throw new AssertionError("Couldn't find tasks to rethrottle. Here are the running tasks " + highLevelClient().tasks().list(request, RequestOptions.DEFAULT));
}

Example 4 with ListTasksResponse

use of org.opensearch.action.admin.cluster.node.tasks.list.ListTasksResponse in project OpenSearch by opensearch-project.

the class CRUDDocumentationIT method testReindexRethrottle.

@SuppressWarnings("unused")
public void testReindexRethrottle() throws Exception {
    RestHighLevelClient client = highLevelClient();
    TaskId taskId = new TaskId("oTUltX4IQMOUUVeiohTt8A:124");
    {
        // tag::rethrottle-disable-request
        // <1>
        RethrottleRequest request = new RethrottleRequest(taskId);
    // end::rethrottle-disable-request
    }
    {
        // tag::rethrottle-request
        // <1>
        RethrottleRequest request = new RethrottleRequest(taskId, 100.0f);
    // end::rethrottle-request
    }
    {
        RethrottleRequest request = new RethrottleRequest(taskId);
        // tag::rethrottle-request-execution
        // <1>
        client.reindexRethrottle(request, RequestOptions.DEFAULT);
        // <2>
        client.updateByQueryRethrottle(request, RequestOptions.DEFAULT);
        // <3>
        client.deleteByQueryRethrottle(request, RequestOptions.DEFAULT);
    // end::rethrottle-request-execution
    }
    ActionListener<ListTasksResponse> listener;
    // tag::rethrottle-request-async-listener
    listener = new ActionListener<ListTasksResponse>() {

        @Override
        public void onResponse(ListTasksResponse response) {
        // <1>
        }

        @Override
        public void onFailure(Exception e) {
        // <2>
        }
    };
    // end::rethrottle-request-async-listener
    // Replace the empty listener by a blocking listener in test
    final CountDownLatch latch = new CountDownLatch(3);
    listener = new LatchedActionListener<>(listener, latch);
    RethrottleRequest request = new RethrottleRequest(taskId);
    // tag::rethrottle-execute-async
    client.reindexRethrottleAsync(request, RequestOptions.DEFAULT, // <1>
    listener);
    client.updateByQueryRethrottleAsync(request, RequestOptions.DEFAULT, // <2>
    listener);
    client.deleteByQueryRethrottleAsync(request, RequestOptions.DEFAULT, // <3>
    listener);
    // end::rethrottle-execute-async
    assertTrue(latch.await(30L, TimeUnit.SECONDS));
}

Example 5 with ListTasksResponse

use of org.opensearch.action.admin.cluster.node.tasks.list.ListTasksResponse in project OpenSearch by opensearch-project.

the class RethrottleTests method testCase.

private void testCase(AbstractBulkByScrollRequestBuilder<?, ?> request, String actionName) throws Exception {
    logger.info("Starting test for [{}] with [{}] slices", actionName, request.request().getSlices());
    /* Add ten documents per slice so most slices will have many documents to process, having to go to multiple batches.
         * We can't rely on the slices being evenly sized but 10 means we have some pretty big slices.
         */
    createIndex("test");
    int numSlices = expectedSlices(request.request().getSlices(), "test");
    List<IndexRequestBuilder> docs = new ArrayList<>();
    for (int i = 0; i < numSlices * 10; i++) {
        docs.add(client().prepareIndex("test").setId(Integer.toString(i)).setSource("foo", "bar"));
    }
    indexRandom(true, docs);
    // Start a request that will never finish unless we rethrottle it
    // Throttle "forever"
    request.setRequestsPerSecond(.000001f);
    // Make sure we use multiple batches
    request.source().setSize(1);
    ActionFuture<? extends BulkByScrollResponse> responseListener = request.execute();
    TaskGroup taskGroupToRethrottle = findTaskToRethrottle(actionName, numSlices);
    TaskId taskToRethrottle = taskGroupToRethrottle.getTaskInfo().getTaskId();
    if (numSlices == 1) {
        assertThat(taskGroupToRethrottle.getChildTasks(), empty());
    } else {
        // There should be a sane number of child tasks running
        assertThat(taskGroupToRethrottle.getChildTasks(), hasSize(allOf(greaterThanOrEqualTo(1), lessThanOrEqualTo(numSlices))));
        // Wait for all of the sub tasks to start (or finish, some might finish early, all that matters is that not all do)
        assertBusy(() -> {
            BulkByScrollTask.Status parent = (BulkByScrollTask.Status) client().admin().cluster().prepareGetTask(taskToRethrottle).get().getTask().getTask().getStatus();
            long finishedSubTasks = parent.getSliceStatuses().stream().filter(Objects::nonNull).count();
            ListTasksResponse list = client().admin().cluster().prepareListTasks().setParentTaskId(taskToRethrottle).get();
            list.rethrowFailures("subtasks");
            assertThat(finishedSubTasks + list.getTasks().size(), greaterThanOrEqualTo((long) numSlices));
            assertThat(list.getTasks().size(), greaterThan(0));
        });
    }
    // Now rethrottle it so it'll finish
    // No throttle or "very fast"
    float newRequestsPerSecond = randomBoolean() ? Float.POSITIVE_INFINITY : between(1, 1000) * 100000;
    ListTasksResponse rethrottleResponse = rethrottleTask(taskToRethrottle, newRequestsPerSecond);
    BulkByScrollTask.Status status = (BulkByScrollTask.Status) rethrottleResponse.getTasks().get(0).getStatus();
    // Now check the resulting requests per second.
    if (numSlices == 1) {
        // If there is a single slice it should match perfectly
        assertEquals(newRequestsPerSecond, status.getRequestsPerSecond(), Float.MIN_NORMAL);
    } else {
        /* Check that at least one slice was rethrottled. We won't always rethrottle all of them because they might have completed.
             * With multiple slices these numbers might not add up perfectly, thus the 1.01F. */
        long unfinished = status.getSliceStatuses().stream().filter(Objects::nonNull).filter(slice -> slice.getStatus().getTotal() > slice.getStatus().getSuccessfullyProcessed()).count();
        float maxExpectedSliceRequestsPerSecond = newRequestsPerSecond == Float.POSITIVE_INFINITY ? Float.POSITIVE_INFINITY : (newRequestsPerSecond / unfinished) * 1.01F;
        float minExpectedSliceRequestsPerSecond = newRequestsPerSecond == Float.POSITIVE_INFINITY ? Float.POSITIVE_INFINITY : (newRequestsPerSecond / numSlices) * 0.99F;
        boolean oneSliceRethrottled = false;
        float totalRequestsPerSecond = 0;
        for (BulkByScrollTask.StatusOrException statusOrException : status.getSliceStatuses()) {
            if (statusOrException == null) {
                /* The slice can be null here because it was completed but hadn't reported its success back to the task when the
                     * rethrottle request came through. */
                continue;
            }
            assertNull(statusOrException.getException());
            BulkByScrollTask.Status slice = statusOrException.getStatus();
            if (slice.getTotal() > slice.getSuccessfullyProcessed()) {
                // This slice reports as not having completed so it should have been processed.
                assertThat(slice.getRequestsPerSecond(), both(greaterThanOrEqualTo(minExpectedSliceRequestsPerSecond)).and(lessThanOrEqualTo(maxExpectedSliceRequestsPerSecond)));
            }
            if (minExpectedSliceRequestsPerSecond <= slice.getRequestsPerSecond() && slice.getRequestsPerSecond() <= maxExpectedSliceRequestsPerSecond) {
                oneSliceRethrottled = true;
            }
            totalRequestsPerSecond += slice.getRequestsPerSecond();
        }
        assertTrue("At least one slice must be rethrottled", oneSliceRethrottled);
        /* Now assert that the parent request has the total requests per second. This is a much weaker assertion than that the parent
             * actually has the newRequestsPerSecond. For the most part it will. Sometimes it'll be greater because only unfinished requests
             * are rethrottled, the finished ones just keep whatever requests per second they had while they were running. But it might
             * also be less than newRequestsPerSecond because the newRequestsPerSecond is divided among running sub-requests and then the
             * requests are rethrottled. If one request finishes in between the division and the application of the new throttle then it
             * won't be rethrottled, thus only contributing its lower total. */
        assertEquals(totalRequestsPerSecond, status.getRequestsPerSecond(), totalRequestsPerSecond * 0.0001f);
    }
    // Now the response should come back quickly because we've rethrottled the request
    BulkByScrollResponse response = responseListener.get();
    // It'd be bad if the entire require completed in a single batch. The test wouldn't be testing anything.
    assertThat("Entire request completed in a single batch. This may invalidate the test as throttling is done between batches.", response.getBatches(), greaterThanOrEqualTo(numSlices));
}