Java ClusterHealthRequestBuilder类代码示例

import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequestBuilder; //导入依赖的package包/类
@Override
public Observable<Void> call(Void aVoid) {
    Elasticsearch elasticsearch = vertxContext.verticle().elasticsearch();

    ClusterHealthRequestBuilder request =
            elasticsearch.get()
                    .admin()
                    .cluster()
                    .prepareHealth(index)
                    .setWaitForStatus(validStatus)
                    .setTimeout(timeValueSeconds(2));

    return elasticsearch.execute(vertxContext, request, elasticsearch.getDefaultAdminTimeout())
            .map(Optional::get)
            .map(new ToVoid<>());
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequestBuilder; //导入依赖的package包/类
/**
 * Wait for green status for the given indices.
 * 
 * @param indices The indices to wait for.
 * @return A {@link ClusterHealthResponse} that contains the cluster health after waiting maximum 5 minutes for green status.
 */
public ClusterHealthResponse waitForGreenStatus(String... indices) {
    ClusterHealthRequestBuilder builder = new ClusterHealthRequestBuilder(this.client.admin().cluster());
    builder.setIndices(indices);
    builder.setWaitForGreenStatus();
    builder.setTimeout(TimeValue.timeValueSeconds(30));
    ClusterHealthResponse response = builder.execute().actionGet();
    LOGGER.debug("getStatus                : {}", response.getStatus());
    LOGGER.debug("getActivePrimaryShards   : {}", response.getActivePrimaryShards());
    LOGGER.debug("getActiveShards          : {}", response.getActiveShards());
    LOGGER.debug("getInitializingShards    : {}", response.getInitializingShards());
    LOGGER.debug("getNumberOfDataNodes     : {}", response.getNumberOfDataNodes());
    LOGGER.debug("getNumberOfNodes         : {}", response.getNumberOfNodes());
    LOGGER.debug("getRelocatingShards      : {}", response.getRelocatingShards());
    LOGGER.debug("getUnassignedShards      : {}", response.getUnassignedShards());
    LOGGER.debug("getAllValidationFailures : {}", response.getAllValidationFailures());
    return response;
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequestBuilder; //导入依赖的package包/类
protected void assertTimeout(ClusterHealthRequestBuilder requestBuilder) {
    ClusterHealthResponse clusterHealth = requestBuilder.get();
    if (clusterHealth.isTimedOut()) {
        logger.info("cluster health request timed out:\n{}", clusterHealth);
        fail("cluster health request timed out");
    }
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequestBuilder; //导入依赖的package包/类
private void waitForGreen0(VertxContext<Server> vertxContext, int retryCount, int maxRetries, ObservableFuture<Void> handler) {
    String indexPrefix = indexPrefix();
    ClusterHealthRequestBuilder request =
            elasticSearchClient
                    .admin()
                    .cluster()
                    .prepareHealth(indexPrefix)
                    .setWaitForStatus(ClusterHealthStatus.GREEN)
                    .setTimeout(timeValueSeconds(2));

    execute(vertxContext, request, getDefaultAdminTimeout())
            .map(Optional::get)
            .map(new ToVoid<>())
            .subscribe(new Subscriber<Void>() {

                @Override
                public void onCompleted() {
                    handler.complete(null);
                }

                @Override
                public void onError(Throwable e) {
                    int nextRetryCount = retryCount + 1;
                    long delayMs = ((long) Math.pow(2, nextRetryCount) * 100L);
                    if (retryCount < maxRetries) {
                        LOGGER.warn("Handling connect error. Retrying after " + delayMs + "ms", e);
                        vertxContext.vertx().setTimer(delayMs, event -> waitForGreen0(vertxContext, nextRetryCount, maxRetries, handler));
                    } else {
                        handler.fail(e);
                    }
                }

                @Override
                public void onNext(Void aVoid) {

                }
            });
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequestBuilder; //导入依赖的package包/类
@Override
protected void run(Bootstrap<FoxtrotServerConfiguration> bootstrap,
                   Namespace namespace,
                   FoxtrotServerConfiguration configuration) throws Exception {
    ElasticsearchConfig esConfig = configuration.getElasticsearch();
    ElasticsearchConnection connection = new ElasticsearchConnection(esConfig);
    connection.start();
    ClusterHealthResponse clusterHealth = new ClusterHealthRequestBuilder(connection.getClient().admin().cluster())
            .execute()
            .get();

    int numDataNodes = clusterHealth.getNumberOfDataNodes();
    int numReplicas = (numDataNodes < 2) ? 0 : 1;

    logger.info("# data nodes: {}, Setting replica count to: {}", numDataNodes, numReplicas);

    createMetaIndex(connection, "consoles", numDataNodes - 1);
    createMetaIndex(connection, "table-meta", numDataNodes - 1);

    PutIndexTemplateResponse response = new PutIndexTemplateRequestBuilder(connection.getClient().admin().indices(), "template_foxtrot_mappings")
            .setTemplate(String.format("%s-*",configuration.getElasticsearch().getTableNamePrefix()))
            .setSettings(
                    ImmutableSettings.builder()
                            .put("number_of_shards", 10)
                            .put("number_of_replicas", numReplicas)
            )
            .addMapping("document", ElasticsearchUtils.getDocumentMapping())
            .execute()
            .get();
    logger.info("Create mapping: {}", response.isAcknowledged());

    logger.info("Creating hbase table");
    HBaseUtil.createTable(configuration.getHbase(), configuration.getHbase().getTableName());

}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequestBuilder; //导入依赖的package包/类
@Override
public boolean isSearchEngineReady() {
	ClusterHealthStatus status = new ClusterHealthRequestBuilder(client, ClusterHealthAction.INSTANCE)
			.setIndices(configuration.getIndexName())
			.setTimeout(new TimeValue(configuration.getTimeoutMillis(), TimeUnit.MILLISECONDS))
			.request()
			.waitForStatus();
	return status != ClusterHealthStatus.RED;
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequestBuilder; //导入依赖的package包/类
public boolean flush(String indexName) {
    try {
        esClient.admin().indices().refresh(new RefreshRequest(indexName).force(true)).actionGet(10000, TimeUnit.MILLISECONDS);
        esClient.admin().indices().flush(new FlushRequest(indexName).force(true)).actionGet(10000, TimeUnit.MILLISECONDS);

        ClusterHealthRequestBuilder healthRequest = esClient.admin().cluster().prepareHealth();
        healthRequest.setIndices(indexName); // only request health of this index...
        healthRequest.setWaitForYellowStatus();
        return true;
    }
    catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequestBuilder; //导入依赖的package包/类
public static void assertNoTimeout(ClusterHealthRequestBuilder requestBuilder) {
    assertNoTimeout(requestBuilder.get());
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequestBuilder; //导入依赖的package包/类
@Override
public ClusterHealthRequestBuilder prepareHealth(String... indices) {
    return new ClusterHealthRequestBuilder(this, ClusterHealthAction.INSTANCE).setIndices(indices);
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequestBuilder; //导入依赖的package包/类
@Override
public void waitForStatus(String indexName, String waitingStatusName) {
    ClusterHealthStatus waitingStatus = ClusterHealthStatus.valueOf(waitingStatusName);

    Client client = ElasticSearch.CLIENT.get();

    if (log.isDebugEnabled()) {
        log.debug("Start waiting for " + waitingStatusName + "  status for index " + indexName);
    }

    ClusterHealthStatus status = ClusterHealthStatus.RED;

    int counter = 0;
    int maxLoops = 20;
    int waitBetweenLoops = 2000;

    while (status != waitingStatus) {
        ClusterHealthRequestBuilder healthRequest = client.admin().cluster().prepareHealth();
        healthRequest.setIndices(indexName);
        healthRequest.setWaitForGreenStatus();
        ClusterHealthResponse healthResponse = healthRequest.execute().actionGet();

        status = healthResponse.getStatus();

        if (log.isDebugEnabled()) {
            log.debug("Waiting for " + waitingStatus + " status (#" + counter + ") " + status);
        }

        try {
            Thread.sleep(waitBetweenLoops);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        if (counter > maxLoops) {
            break;
        }
        counter++;
    }

    if (log.isDebugEnabled()) {
        log.debug("Done waiting for " + waitingStatus + " status for index " + indexName);
    }
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequestBuilder; //导入依赖的package包/类
private ClusterHealthResponse waitForGreenClusterState(String index) {
    ClusterAdminClient clusterAdminClient = node.client().admin().cluster();
    ClusterHealthRequest request = (new ClusterHealthRequestBuilder(clusterAdminClient, ClusterHealthAction.INSTANCE))
            .setIndices(index).setWaitForGreenStatus().request();
    return clusterAdminClient.health(request).actionGet();
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequestBuilder; //导入依赖的package包/类
/**
 * The health of the cluster.
 */
ClusterHealthRequestBuilder prepareHealth(String... indices);