Java RecoveryResponse类代码示例

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {

    final RecoveryRequest recoveryRequest = new RecoveryRequest(Strings.splitStringByCommaToArray(request.param("index")));
    recoveryRequest.detailed(request.paramAsBoolean("detailed", false));
    recoveryRequest.activeOnly(request.paramAsBoolean("active_only", false));
    recoveryRequest.indicesOptions(IndicesOptions.fromRequest(request, recoveryRequest.indicesOptions()));

    return channel -> client.admin().indices().recoveries(recoveryRequest, new RestBuilderListener<RecoveryResponse>(channel) {
        @Override
        public RestResponse buildResponse(RecoveryResponse response, XContentBuilder builder) throws Exception {
            response.detailed(recoveryRequest.detailed());
            builder.startObject();
            response.toXContent(builder, request);
            builder.endObject();
            return new BytesRestResponse(OK, builder);
        }
    });

}
 

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
public void testGatewayRecovery() throws Exception {
    logger.info("--> start nodes");
    String node = internalCluster().startNode();

    createAndPopulateIndex(INDEX_NAME, 1, SHARD_COUNT, REPLICA_COUNT);

    logger.info("--> restarting cluster");
    internalCluster().fullRestart();
    ensureGreen();

    logger.info("--> request recoveries");
    RecoveryResponse response = client().admin().indices().prepareRecoveries(INDEX_NAME).execute().actionGet();
    assertThat(response.shardRecoveryStates().size(), equalTo(SHARD_COUNT));
    assertThat(response.shardRecoveryStates().get(INDEX_NAME).size(), equalTo(1));

    List<RecoveryState> recoveryStates = response.shardRecoveryStates().get(INDEX_NAME);
    assertThat(recoveryStates.size(), equalTo(1));

    RecoveryState recoveryState = recoveryStates.get(0);

    assertRecoveryState(recoveryState, 0, StoreRecoverySource.EXISTING_STORE_INSTANCE, true, Stage.DONE, null, node);

    validateIndexRecoveryState(recoveryState.getIndex());
}
 

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
public void testGatewayRecoveryTestActiveOnly() throws Exception {
    logger.info("--> start nodes");
    internalCluster().startNode();

    createAndPopulateIndex(INDEX_NAME, 1, SHARD_COUNT, REPLICA_COUNT);

    logger.info("--> restarting cluster");
    internalCluster().fullRestart();
    ensureGreen();

    logger.info("--> request recoveries");
    RecoveryResponse response = client().admin().indices().prepareRecoveries(INDEX_NAME).setActiveOnly(true).execute().actionGet();

    List<RecoveryState> recoveryStates = response.shardRecoveryStates().get(INDEX_NAME);
    assertThat(recoveryStates.size(), equalTo(0));  // Should not expect any responses back
}
 

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
private void ensureActiveShardCopies(final int shardId, final int copyCount) throws Exception {
    assertBusy(new Runnable() {
        @Override
        public void run() {
            ClusterState state = client().admin().cluster().prepareState().get().getState();
            assertThat(state.routingTable().index("idx"), not(nullValue()));
            assertThat(state.routingTable().index("idx").shard(shardId), not(nullValue()));
            assertThat(state.routingTable().index("idx").shard(shardId).activeShards().size(), equalTo(copyCount));

            ClusterHealthResponse healthResponse = client().admin().cluster().prepareHealth("idx")
                    .setWaitForNoRelocatingShards(true)
                    .get();
            assertThat(healthResponse.isTimedOut(), equalTo(false));

            RecoveryResponse recoveryResponse = client().admin().indices().prepareRecoveries("idx")
                    .setActiveOnly(true)
                    .get();
            assertThat(recoveryResponse.shardRecoveryStates().get("idx").size(), equalTo(0));
        }
    });
}
 

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) {

    final RecoveryRequest recoveryRequest = new RecoveryRequest(Strings.splitStringByCommaToArray(request.param("index")));
    recoveryRequest.detailed(request.paramAsBoolean("detailed", false));
    recoveryRequest.activeOnly(request.paramAsBoolean("active_only", false));
    recoveryRequest.indicesOptions(IndicesOptions.fromRequest(request, recoveryRequest.indicesOptions()));

    client.admin().indices().recoveries(recoveryRequest, new RestBuilderListener<RecoveryResponse>(channel) {
        @Override
        public RestResponse buildResponse(RecoveryResponse response, XContentBuilder builder) throws Exception {
            response.detailed(recoveryRequest.detailed());
            builder.startObject();
            response.toXContent(builder, request);
            builder.endObject();
            return new BytesRestResponse(OK, builder);
        }
    });

}
 

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
@Override
public RestChannelConsumer doCatRequest(final RestRequest request, final NodeClient client) {
    final RecoveryRequest recoveryRequest = new RecoveryRequest(Strings.splitStringByCommaToArray(request.param("index")));
    recoveryRequest.detailed(request.paramAsBoolean("detailed", false));
    recoveryRequest.activeOnly(request.paramAsBoolean("active_only", false));
    recoveryRequest.indicesOptions(IndicesOptions.fromRequest(request, recoveryRequest.indicesOptions()));

    return channel -> client.admin().indices().recoveries(recoveryRequest, new RestResponseListener<RecoveryResponse>(channel) {
        @Override
        public RestResponse buildResponse(final RecoveryResponse response) throws Exception {
            return RestTable.buildResponse(buildRecoveryTable(request, response), channel);
        }
    });
}
 

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
public void testReplicaRecovery() throws Exception {
    logger.info("--> start node A");
    String nodeA = internalCluster().startNode();

    logger.info("--> create index on node: {}", nodeA);
    createAndPopulateIndex(INDEX_NAME, 1, SHARD_COUNT, REPLICA_COUNT);

    logger.info("--> start node B");
    String nodeB = internalCluster().startNode();
    ensureGreen();

    // force a shard recovery from nodeA to nodeB
    logger.info("--> bump replica count");
    client().admin().indices().prepareUpdateSettings(INDEX_NAME)
            .setSettings(Settings.builder().put("number_of_replicas", 1)).execute().actionGet();
    ensureGreen();

    logger.info("--> request recoveries");
    RecoveryResponse response = client().admin().indices().prepareRecoveries(INDEX_NAME).execute().actionGet();

    // we should now have two total shards, one primary and one replica
    List<RecoveryState> recoveryStates = response.shardRecoveryStates().get(INDEX_NAME);
    assertThat(recoveryStates.size(), equalTo(2));

    List<RecoveryState> nodeAResponses = findRecoveriesForTargetNode(nodeA, recoveryStates);
    assertThat(nodeAResponses.size(), equalTo(1));
    List<RecoveryState> nodeBResponses = findRecoveriesForTargetNode(nodeB, recoveryStates);
    assertThat(nodeBResponses.size(), equalTo(1));

    // validate node A recovery
    RecoveryState nodeARecoveryState = nodeAResponses.get(0);
    assertRecoveryState(nodeARecoveryState, 0, StoreRecoverySource.EMPTY_STORE_INSTANCE, true, Stage.DONE, null, nodeA);
    validateIndexRecoveryState(nodeARecoveryState.getIndex());

    // validate node B recovery
    RecoveryState nodeBRecoveryState = nodeBResponses.get(0);
    assertRecoveryState(nodeBRecoveryState, 0, PeerRecoverySource.INSTANCE, false, Stage.DONE, nodeA, nodeB);
    validateIndexRecoveryState(nodeBRecoveryState.getIndex());
}
 

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
@Override
public void doRequest(final RestRequest request, final RestChannel channel, final Client client) {
    final RecoveryRequest recoveryRequest = new RecoveryRequest(Strings.splitStringByCommaToArray(request.param("index")));
    recoveryRequest.detailed(request.paramAsBoolean("detailed", false));
    recoveryRequest.activeOnly(request.paramAsBoolean("active_only", false));
    recoveryRequest.indicesOptions(IndicesOptions.fromRequest(request, recoveryRequest.indicesOptions()));

    client.admin().indices().recoveries(recoveryRequest, new RestResponseListener<RecoveryResponse>(channel) {
        @Override
        public RestResponse buildResponse(final RecoveryResponse response) throws Exception {
            return RestTable.buildResponse(buildRecoveryTable(request, response), channel);
        }
    });
}
 

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
public static int waitForRecovery(Client client, String index) throws IOException {
    if (index == null) {
        throw new IOException("unable to waitfor recovery, index not set");
    }
    RecoveryResponse response = client.admin().indices().prepareRecoveries(index).execute().actionGet();
    int shards = response.getTotalShards();
    client.admin().cluster().prepareHealth(index).setWaitForActiveShards(shards).execute().actionGet();
    return shards;
}
 

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
public int waitForRecovery(String index) throws IOException {
    if (client() == null) {
        return -1;
    }
    if (index == null) {
        throw new IOException("unable to waitfor recovery, index not set");
    }
    RecoveryResponse response = client().execute(RecoveryAction.INSTANCE, new RecoveryRequest(index)).actionGet();
    int shards = response.getTotalShards();
    client().execute(ClusterHealthAction.INSTANCE, new ClusterHealthRequest(index).waitForActiveShards(shards)).actionGet();
    return shards;
}
 

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
@Override
public ActionFuture<RecoveryResponse> recoveries(final RecoveryRequest request) {
    return execute(RecoveryAction.INSTANCE, request);
}
 

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
public void testNoShardRelocationsOccurWhenElectedMasterNodeFails() throws Exception {
    Settings defaultSettings = Settings.builder()
            .put(FaultDetection.PING_TIMEOUT_SETTING.getKey(), "1s")
            .put(FaultDetection.PING_RETRIES_SETTING.getKey(), "1")
            .build();

    Settings masterNodeSettings = Settings.builder()
            .put(Node.NODE_DATA_SETTING.getKey(), false)
            .put(defaultSettings)
            .build();
    internalCluster().startNodes(2, masterNodeSettings);
    Settings dateNodeSettings = Settings.builder()
            .put(Node.NODE_MASTER_SETTING.getKey(), false)
            .put(defaultSettings)
            .build();
    internalCluster().startNodes(2, dateNodeSettings);
    ClusterHealthResponse clusterHealthResponse = client().admin().cluster().prepareHealth()
            .setWaitForEvents(Priority.LANGUID)
            .setWaitForNodes("4")
            .setWaitForNoRelocatingShards(true)
            .get();
    assertThat(clusterHealthResponse.isTimedOut(), is(false));

    createIndex("test");
    ensureSearchable("test");
    RecoveryResponse r = client().admin().indices().prepareRecoveries("test").get();
    int numRecoveriesBeforeNewMaster = r.shardRecoveryStates().get("test").size();

    final String oldMaster = internalCluster().getMasterName();
    internalCluster().stopCurrentMasterNode();
    assertBusy(() -> {
        String current = internalCluster().getMasterName();
        assertThat(current, notNullValue());
        assertThat(current, not(equalTo(oldMaster)));
    });
    ensureSearchable("test");

    r = client().admin().indices().prepareRecoveries("test").get();
    int numRecoveriesAfterNewMaster = r.shardRecoveryStates().get("test").size();
    assertThat(numRecoveriesAfterNewMaster, equalTo(numRecoveriesBeforeNewMaster));
}
 

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
void assertIndexSanity(String indexName, Version indexCreated) {
    GetIndexResponse getIndexResponse = client().admin().indices().prepareGetIndex().addIndices(indexName).get();
    assertEquals(1, getIndexResponse.indices().length);
    assertEquals(indexName, getIndexResponse.indices()[0]);
    Version actualVersionCreated = Version.indexCreated(getIndexResponse.getSettings().get(indexName));
    assertEquals(indexCreated, actualVersionCreated);
    ensureYellow(indexName);
    RecoveryResponse recoveryResponse = client().admin().indices().prepareRecoveries(indexName)
        .setDetailed(true).setActiveOnly(false).get();
    boolean foundTranslog = false;
    for (List<RecoveryState> states : recoveryResponse.shardRecoveryStates().values()) {
        for (RecoveryState state : states) {
            if (state.getStage() == RecoveryState.Stage.DONE
                && state.getPrimary()
                && state.getRecoverySource().getType() == RecoverySource.Type.EXISTING_STORE) {
                assertFalse("more than one primary recoverd?", foundTranslog);
                assertNotEquals(0, state.getTranslog().recoveredOperations());
                foundTranslog = true;
            }
        }
    }
    assertTrue("expected translog but nothing was recovered", foundTranslog);
    IndicesSegmentResponse segmentsResponse = client().admin().indices().prepareSegments(indexName).get();
    IndexSegments segments = segmentsResponse.getIndices().get(indexName);
    int numCurrent = 0;
    int numBWC = 0;
    for (IndexShardSegments indexShardSegments : segments) {
        for (ShardSegments shardSegments : indexShardSegments) {
            for (Segment segment : shardSegments) {
                if (indexCreated.luceneVersion.equals(segment.version)) {
                    numBWC++;
                    if (Version.CURRENT.luceneVersion.equals(segment.version)) {
                        numCurrent++;
                    }
                } else if (Version.CURRENT.luceneVersion.equals(segment.version)) {
                    numCurrent++;
                } else {
                    fail("unexpected version " + segment.version);
                }
            }
        }
    }
    assertNotEquals("expected at least 1 current segment after translog recovery", 0, numCurrent);
    assertNotEquals("expected at least 1 old segment", 0, numBWC);
    SearchResponse test = client().prepareSearch(indexName).get();
    assertThat(test.getHits().getTotalHits(), greaterThanOrEqualTo(1L));
}
 

import org.elasticsearch.action.admin.indices.recovery.RecoveryResponse; //导入依赖的package包/类
/**
 * Indices recoveries
 */
ActionFuture<RecoveryResponse> recoveries(RecoveryRequest request);