Java ListenableActionFuture.get方法代码示例

import org.elasticsearch.action.ListenableActionFuture; //导入方法依赖的package包/类
public void testTasksCancellation() throws Exception {
    // Start blocking test task
    // Get real client (the plugin is not registered on transport nodes)
    ListenableActionFuture<TestTaskPlugin.NodesResponse> future = TestTaskPlugin.TestTaskAction.INSTANCE.newRequestBuilder(client())
            .execute();
    logger.info("--> started test tasks");

    // Wait for the task to start on all nodes
    assertBusy(() -> assertEquals(internalCluster().size(),
        client().admin().cluster().prepareListTasks().setActions(TestTaskPlugin.TestTaskAction.NAME + "[n]").get().getTasks().size()));

    logger.info("--> cancelling the main test task");
    CancelTasksResponse cancelTasksResponse = client().admin().cluster().prepareCancelTasks()
            .setActions(TestTaskPlugin.TestTaskAction.NAME).get();
    assertEquals(1, cancelTasksResponse.getTasks().size());

    future.get();

    logger.info("--> checking that test tasks are not running");
    assertEquals(0,
            client().admin().cluster().prepareListTasks().setActions(TestTaskPlugin.TestTaskAction.NAME + "*").get().getTasks().size());
}
 

import org.elasticsearch.action.ListenableActionFuture; //导入方法依赖的package包/类
public void testTasksUnblocking() throws Exception {
    // Start blocking test task
    ListenableActionFuture<TestTaskPlugin.NodesResponse> future = TestTaskPlugin.TestTaskAction.INSTANCE.newRequestBuilder(client())
            .execute();
    // Wait for the task to start on all nodes
    assertBusy(() -> assertEquals(internalCluster().size(),
        client().admin().cluster().prepareListTasks().setActions(TestTaskPlugin.TestTaskAction.NAME + "[n]").get().getTasks().size()));

    TestTaskPlugin.UnblockTestTasksAction.INSTANCE.newRequestBuilder(client()).get();

    future.get();
    assertEquals(0, client().admin().cluster().prepareListTasks().setActions(TestTaskPlugin.TestTaskAction.NAME + "[n]").get()
            .getTasks().size());
}
 

import org.elasticsearch.action.ListenableActionFuture; //导入方法依赖的package包/类
/**
 * Test waiting for a task that times out.
 * @param wait wait for the running task and return all the failures you accumulated waiting for it
 */
private void waitForTimeoutTestCase(Function<TaskId, ? extends Iterable<? extends Throwable>> wait) throws Exception {
    // Start blocking test task
    ListenableActionFuture<TestTaskPlugin.NodesResponse> future = TestTaskPlugin.TestTaskAction.INSTANCE.newRequestBuilder(client())
            .execute();
    try {
        TaskId taskId = waitForTestTaskStartOnAllNodes();

        // Wait for the task to start
        assertBusy(() -> client().admin().cluster().prepareGetTask(taskId).get());

        // Spin up a request that should wait for those tasks to finish
        // It will timeout because we haven't unblocked the tasks
        Iterable<? extends Throwable> failures = wait.apply(taskId);

        for (Throwable failure : failures) {
            assertNotNull(
                    ExceptionsHelper.unwrap(failure, ElasticsearchTimeoutException.class, ReceiveTimeoutTransportException.class));
        }
    } finally {
        // Now we can unblock those requests
        TestTaskPlugin.UnblockTestTasksAction.INSTANCE.newRequestBuilder(client()).get();
    }
    future.get();
}
 

import org.elasticsearch.action.ListenableActionFuture; //导入方法依赖的package包/类
public IndexDeleteByQueryResponse truncateIndex() throws InterruptedException, ExecutionException {
    try (Client client = getClient()) {
        QueryBuilder queryBuilder = new MatchAllQueryBuilder();
        ListenableActionFuture<DeleteByQueryResponse> response = client.prepareDeleteByQuery(INDEX_NAME)
                .setTypes(DOCUMENT_TYPE).setQuery(queryBuilder).execute();
        DeleteByQueryResponse deleteByQueryResponse = response.get();
        IndexDeleteByQueryResponse indexResult = deleteByQueryResponse.getIndex(INDEX_NAME);
        return indexResult;
    }
}
 

import org.elasticsearch.action.ListenableActionFuture; //导入方法依赖的package包/类
public void testCloseIndexDuringRestore() throws Exception {
    Client client = client();

    logger.info("-->  creating repository");
    assertAcked(client.admin().cluster().preparePutRepository("test-repo")
        .setType("mock").setSettings(Settings.builder()
            .put("location", randomRepoPath())
            .put("compress", randomBoolean())
            .put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
        ));

    createIndex("test-idx-1", "test-idx-2");
    ensureGreen();

    logger.info("--> indexing some data");
    for (int i = 0; i < 100; i++) {
        index("test-idx-1", "doc", Integer.toString(i), "foo", "bar" + i);
        index("test-idx-2", "doc", Integer.toString(i), "foo", "baz" + i);
    }
    refresh();
    assertThat(client.prepareSearch("test-idx-1").setSize(0).get().getHits().getTotalHits(), equalTo(100L));
    assertThat(client.prepareSearch("test-idx-2").setSize(0).get().getHits().getTotalHits(), equalTo(100L));

    logger.info("--> snapshot");
    assertThat(client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap")
        .setIndices("test-idx-*").setWaitForCompletion(true).get().getSnapshotInfo().state(), equalTo(SnapshotState.SUCCESS));

    logger.info("--> deleting indices before restoring");
    assertAcked(client.admin().indices().prepareDelete("test-idx-*").get());

    blockAllDataNodes("test-repo");
    logger.info("--> execution will be blocked on all data nodes");

    final ListenableActionFuture<RestoreSnapshotResponse> restoreFut;
    try {
        logger.info("--> start restore");
        restoreFut = client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap")
            .setWaitForCompletion(true)
            .execute();

        logger.info("--> waiting for block to kick in");
        waitForBlockOnAnyDataNode("test-repo", TimeValue.timeValueMinutes(1));

        logger.info("--> close index while restore is running");
        try {
            client.admin().indices().prepareClose("test-idx-1").get();
            fail("Expected closing index to fail during restore");
        } catch (IllegalArgumentException e) {
            assertThat(e.getMessage(), containsString("Cannot close indices that are being restored: [[test-idx-1/"));
        }
    } finally {
        // unblock even if the try block fails otherwise we will get bogus failures when we delete all indices in test teardown.
        logger.info("--> unblocking all data nodes");
        unblockAllDataNodes("test-repo");
    }

    logger.info("--> wait for restore to finish");
    RestoreSnapshotResponse restoreSnapshotResponse = restoreFut.get();
    logger.info("--> check that all shards were recovered");
    assertThat(restoreSnapshotResponse.getRestoreInfo().totalShards(), greaterThan(0));
    assertThat(restoreSnapshotResponse.getRestoreInfo().successfulShards(), greaterThan(0));
    assertThat(restoreSnapshotResponse.getRestoreInfo().failedShards(), equalTo(0));
}
 

import org.elasticsearch.action.ListenableActionFuture; //导入方法依赖的package包/类
public void testDeleteSnapshotWhileRestoringFails() throws Exception {
    Client client = client();

    logger.info("-->  creating repository");
    final String repoName = "test-repo";
    assertAcked(client.admin().cluster().preparePutRepository(repoName)
                    .setType("mock")
                    .setSettings(Settings.builder().put("location", randomRepoPath())));

    logger.info("--> creating index");
    final String indexName = "test-idx";
    assertAcked(prepareCreate(indexName).setWaitForActiveShards(ActiveShardCount.ALL));

    logger.info("--> indexing some data");
    for (int i = 0; i < 100; i++) {
        index(indexName, "doc", Integer.toString(i), "foo", "bar" + i);
    }
    refresh();
    assertThat(client.prepareSearch(indexName).setSize(0).get().getHits().getTotalHits(), equalTo(100L));

    logger.info("--> take snapshots");
    final String snapshotName = "test-snap";
    assertThat(client.admin().cluster().prepareCreateSnapshot(repoName, snapshotName)
                   .setIndices(indexName).setWaitForCompletion(true).get().getSnapshotInfo().state(), equalTo(SnapshotState.SUCCESS));
    final String snapshotName2 = "test-snap-2";
    assertThat(client.admin().cluster().prepareCreateSnapshot(repoName, snapshotName2)
                   .setIndices(indexName).setWaitForCompletion(true).get().getSnapshotInfo().state(), equalTo(SnapshotState.SUCCESS));

    logger.info("--> delete index before restoring");
    assertAcked(client.admin().indices().prepareDelete(indexName).get());

    logger.info("--> execution will be blocked on all data nodes");
    blockAllDataNodes(repoName);

    final ListenableActionFuture<RestoreSnapshotResponse> restoreFut;
    try {
        logger.info("--> start restore");
        restoreFut = client.admin().cluster().prepareRestoreSnapshot(repoName, snapshotName)
                         .setWaitForCompletion(true)
                         .execute();

        logger.info("--> waiting for block to kick in");
        waitForBlockOnAnyDataNode(repoName, TimeValue.timeValueMinutes(1));

        logger.info("--> try deleting the snapshot while the restore is in progress (should throw an error)");
        ConcurrentSnapshotExecutionException e = expectThrows(ConcurrentSnapshotExecutionException.class, () ->
            client().admin().cluster().prepareDeleteSnapshot(repoName, snapshotName).get());
        assertEquals(repoName, e.getRepositoryName());
        assertEquals(snapshotName, e.getSnapshotName());
        assertThat(e.getMessage(), containsString("cannot delete snapshot during a restore"));

        logger.info("-- try deleting another snapshot while the restore is in progress (should throw an error)");
        e = expectThrows(ConcurrentSnapshotExecutionException.class, () ->
            client().admin().cluster().prepareDeleteSnapshot(repoName, snapshotName2).get());
        assertEquals(repoName, e.getRepositoryName());
        assertEquals(snapshotName2, e.getSnapshotName());
        assertThat(e.getMessage(), containsString("cannot delete snapshot during a restore"));
    } finally {
        // unblock even if the try block fails otherwise we will get bogus failures when we delete all indices in test teardown.
        logger.info("--> unblocking all data nodes");
        unblockAllDataNodes(repoName);
    }

    logger.info("--> wait for restore to finish");
    restoreFut.get();
}