Java ClusterHealthResponse.getStatus方法代码示例

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
/**
 * Waits for all relocating shards to become active and the cluster has reached the given health status
 * using the cluster health API.
 */
public ClusterHealthStatus waitForRelocation(ClusterHealthStatus status) {
    ClusterHealthRequest request = Requests.clusterHealthRequest().waitForNoRelocatingShards(true);
    if (status != null) {
        request.waitForStatus(status);
    }
    ClusterHealthResponse actionGet = client().admin().cluster()
        .health(request).actionGet();
    if (actionGet.isTimedOut()) {
        logger.info("waitForRelocation timed out (status={}), cluster state:\n{}\n{}", status,
            client().admin().cluster().prepareState().get().getState(), client().admin().cluster().preparePendingClusterTasks().get());
        assertThat("timed out waiting for relocation", actionGet.isTimedOut(), equalTo(false));
    }
    if (status != null) {
        assertThat(actionGet.getStatus(), equalTo(status));
    }
    return actionGet.getStatus();
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
private void waitForCluster(Client client, long timeoutInSec) {
	long start = System.currentTimeMillis();
	// Wait until the cluster is ready
	while (true) {
		if ((System.currentTimeMillis() - start) / 1000 > timeoutInSec) {
			log.debug("Timeout of {" + timeoutInSec + "} reached.");
			break;
		}
		log.debug("Checking elasticsearch status...");
		ClusterHealthResponse response = client.admin().cluster().prepareHealth().get(TimeValue.timeValueSeconds(10));
		log.debug("Elasticsearch status is: " + response.getStatus());
		if (response.getStatus() != ClusterHealthStatus.RED) {
			log.info("Elasticsearch status {" + response.getStatus() + "}. Releasing lock after " + (System.currentTimeMillis() - start) + " ms");
			return;
		}
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}
	throw new RuntimeException("Elasticsearch was not ready within set timeout of {" + timeoutInSec + "} seconds.");

}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
/**
 * Ensures the cluster has a green state via the cluster health API. This method will also wait for relocations.
 * It is useful to ensure that all action on the cluster have finished and all shards that were currently relocating
 * are now allocated and started.
 *
 * @param timeout
 *            time out value to set on {@link org.elasticsearch.action.admin.cluster.health.ClusterHealthRequest}
 */
public ClusterHealthStatus ensureGreen(final TimeValue timeout, final String... indices) {
    final ClusterHealthResponse actionGet = client()
            .admin()
            .cluster()
            .health(Requests.clusterHealthRequest(indices).timeout(timeout).waitForGreenStatus().waitForEvents(Priority.LANGUID)
                    .waitForRelocatingShards(0)).actionGet();
    if (actionGet.isTimedOut()) {
        logger.info("ensureGreen timed out, cluster state:\n{}\n{}", client().admin().cluster().prepareState().get().getState()
                .prettyPrint(), client().admin().cluster().preparePendingClusterTasks().get().prettyPrint());
        assertThat("timed out waiting for green state", actionGet.isTimedOut(), equalTo(false));
    }
    assertThat(actionGet.getStatus(), equalTo(ClusterHealthStatus.GREEN));
    logger.debug("indices {} are green", indices.length == 0 ? "[_all]" : indices);
    return actionGet.getStatus();
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
/**
 * Waits for all relocating shards to become active and the cluster has reached the given health status
 * using the cluster health API.
 */
public ClusterHealthStatus waitForRelocation(final ClusterHealthStatus status) {
    final ClusterHealthRequest request = Requests.clusterHealthRequest().waitForRelocatingShards(0);
    if (status != null) {
        request.waitForStatus(status);
    }
    final ClusterHealthResponse actionGet = client().admin().cluster().health(request).actionGet();
    if (actionGet.isTimedOut()) {
        logger.info("waitForRelocation timed out (status={}), cluster state:\n{}\n{}", status, client().admin().cluster()
                .prepareState().get().getState().prettyPrint(), client().admin().cluster().preparePendingClusterTasks().get()
                .prettyPrint());
        assertThat("timed out waiting for relocation", actionGet.isTimedOut(), equalTo(false));
    }
    if (status != null) {
        assertThat(actionGet.getStatus(), equalTo(status));
    }
    return actionGet.getStatus();
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
/**
 * Wait for green state of a cluster.
 *
 * @param indices
 * @return
 */
public ClusterHealthStatus ensureGreen(final String... indices) {
    final ClusterHealthResponse actionGet = client().admin().cluster()
            .health(Requests.clusterHealthRequest(indices)
                    .waitForGreenStatus().waitForEvents(Priority.LANGUID)
                    .waitForNoRelocatingShards(true))
            .actionGet();
    if (actionGet.isTimedOut()) {
        onFailure("ensureGreen timed out, cluster state:\n"
                + client().admin().cluster().prepareState().get().getState()
                + "\n" + client().admin().cluster()
                        .preparePendingClusterTasks().get(),
                actionGet);
    }
    return actionGet.getStatus();
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
/**
 * Wait for yellow state of a cluster.
 *
 * @param indices
 * @return
 */
public ClusterHealthStatus ensureYellow(final String... indices) {
    final ClusterHealthResponse actionGet = client().admin().cluster()
            .health(Requests.clusterHealthRequest(indices)
                    .waitForNoRelocatingShards(true).waitForYellowStatus()
                    .waitForEvents(Priority.LANGUID))
            .actionGet();
    if (actionGet.isTimedOut()) {
        onFailure("ensureYellow timed out, cluster state:\n" + "\n"
                + client().admin().cluster().prepareState().get().getState()
                + "\n" + client().admin().cluster()
                        .preparePendingClusterTasks().get(),
                actionGet);
    }
    return actionGet.getStatus();
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
/**
   * Waits for all relocating shards to become active and the cluster has reached the given health status
   * using the cluster health API.
   */
  public ClusterHealthStatus waitForRelocation(ClusterHealthStatus status) {
    ClusterHealthRequest request = Requests.clusterHealthRequest().waitForRelocatingShards(0);
    if (status != null) {
      request.waitForStatus(status);
    }
    ClusterHealthResponse actionGet = adminClient.cluster()
        .health(request).actionGet();
    if (actionGet.isTimedOut()) {
//      logger.info("waitForRelocation timed out (status={}), cluster state:\n{}\n{}", status, adminClient.cluster().prepareState().get().getState().prettyPrint(), adminClient.cluster().preparePendingClusterTasks().get().prettyPrint());
      assertThat("timed out waiting for relocation", actionGet.isTimedOut(), equalTo(false));
    }
    if (status != null) {
      assertThat(actionGet.getStatus(), equalTo(status));
    }
    return actionGet.getStatus();
  }
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
private ClusterHealthStatus ensureColor(ClusterHealthStatus clusterHealthStatus, TimeValue timeout, String... indices) {
    String color = clusterHealthStatus.name().toLowerCase(Locale.ROOT);
    String method = "ensure" + Strings.capitalize(color);

    ClusterHealthRequest healthRequest = Requests.clusterHealthRequest(indices)
        .timeout(timeout)
        .waitForStatus(clusterHealthStatus)
        .waitForEvents(Priority.LANGUID)
        .waitForNoRelocatingShards(true)
        // We currently often use ensureGreen or ensureYellow to check whether the cluster is back in a good state after shutting down
        // a node. If the node that is stopped is the master node, another node will become master and publish a cluster state where it
        // is master but where the node that was stopped hasn't been removed yet from the cluster state. It will only subsequently
        // publish a second state where the old master is removed. If the ensureGreen/ensureYellow is timed just right, it will get to
        // execute before the second cluster state update removes the old master and the condition ensureGreen / ensureYellow will
        // trivially hold if it held before the node was shut down. The following "waitForNodes" condition ensures that the node has
        // been removed by the master so that the health check applies to the set of nodes we expect to be part of the cluster.
        .waitForNodes(Integer.toString(cluster().size()));

    ClusterHealthResponse actionGet = client().admin().cluster().health(healthRequest).actionGet();
    if (actionGet.isTimedOut()) {
        logger.info("{} timed out, cluster state:\n{}\n{}",
            method,
            client().admin().cluster().prepareState().get().getState(),
            client().admin().cluster().preparePendingClusterTasks().get());
        fail("timed out waiting for " + color + " state");
    }
    assertThat("Expected at least " + clusterHealthStatus + " but got " + actionGet.getStatus(),
        actionGet.getStatus().value(), lessThanOrEqualTo(clusterHealthStatus.value()));
    logger.debug("indices {} are {}", indices.length == 0 ? "[_all]" : indices, color);
    return actionGet.getStatus();
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
/**
 * Ensures the cluster has a green state via the cluster health API. This method will also wait for relocations.
 * It is useful to ensure that all action on the cluster have finished and all shards that were currently relocating
 * are now allocated and started.
 *
 * @param timeout time out value to set on {@link org.elasticsearch.action.admin.cluster.health.ClusterHealthRequest}
 */
public ClusterHealthStatus ensureGreen(TimeValue timeout, String... indices) {
    ClusterHealthResponse actionGet = client().admin().cluster()
            .health(Requests.clusterHealthRequest(indices).timeout(timeout).waitForGreenStatus().waitForEvents(Priority.LANGUID)
                    .waitForNoRelocatingShards(true)).actionGet();
    if (actionGet.isTimedOut()) {
        logger.info("ensureGreen timed out, cluster state:\n{}\n{}", client().admin().cluster().prepareState().get().getState(),
            client().admin().cluster().preparePendingClusterTasks().get());
        assertThat("timed out waiting for green state", actionGet.isTimedOut(), equalTo(false));
    }
    assertThat(actionGet.getStatus(), equalTo(ClusterHealthStatus.GREEN));
    logger.debug("indices {} are green", indices.length == 0 ? "[_all]" : indices);
    return actionGet.getStatus();
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
@Override
protected void doHealthCheck(Health.Builder builder) throws Exception {
	List<String> indices = this.properties.getIndices();
	ClusterHealthResponse response = this.client.admin().cluster()
			.health(Requests.clusterHealthRequest(indices.isEmpty() ? allIndices
					: indices.toArray(new String[indices.size()])))
			.actionGet(this.properties.getResponseTimeout());

	switch (response.getStatus()) {
	case GREEN:
	case YELLOW:
		builder.up();
		break;
	case RED:
	default:
		builder.down();
		break;
	}
	builder.withDetail("clusterName", response.getClusterName());
	builder.withDetail("numberOfNodes", response.getNumberOfNodes());
	builder.withDetail("numberOfDataNodes", response.getNumberOfDataNodes());
	builder.withDetail("activePrimaryShards", response.getActivePrimaryShards());
	builder.withDetail("activeShards", response.getActiveShards());
	builder.withDetail("relocatingShards", response.getRelocatingShards());
	builder.withDetail("initializingShards", response.getInitializingShards());
	builder.withDetail("unassignedShards", response.getUnassignedShards());
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
@Override
public void run() {
	while(true) {
   	    try {
   	        logger.debug("getting es cluster health.");
   	        ActionFuture<ClusterHealthResponse> healthFuture = transportClient.admin().cluster().health(Requests.clusterHealthRequest());
   	        ClusterHealthResponse healthResponse = healthFuture.get(5, TimeUnit.SECONDS);
   	        
   	        if(healthResponse.getStatus() == ClusterHealthStatus.RED){//es集群处于不健康状态给提示
   	        	logger.error("elasticsearch info num of node:{}", healthResponse.getNumberOfNodes());
	    	        logger.error("elasticsearch info cluster health:{} ", healthResponse.getStatus());
   	        }
   	        
   	        isClusterOn.set(true);
   	    } catch(Throwable t) {
   	        if(t instanceof NoNodeAvailableException){//集群不可用
   	        	logger.error("the cluster no node avaliable.");
                  	isClusterOn.set(false);
                  }else{
                  	isClusterOn.set(true);
                  }
   	    }
   	    try {
   	        Thread.sleep(3000);//FIXME
   	    } catch (InterruptedException ie) { 
   	    	ie.printStackTrace(); 
   	    }
   	}
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
/**
 * Ensures the cluster has a yellow state via the cluster health API.
 */
public ClusterHealthStatus ensureYellow(final String... indices) {
    final ClusterHealthResponse actionGet = client()
            .admin()
            .cluster()
            .health(Requests.clusterHealthRequest(indices).waitForRelocatingShards(0).waitForYellowStatus()
                    .waitForEvents(Priority.LANGUID)).actionGet();
    if (actionGet.isTimedOut()) {
        logger.info("ensureYellow timed out, cluster state:\n{}\n{}", client().admin().cluster().prepareState().get().getState()
                .prettyPrint(), client().admin().cluster().preparePendingClusterTasks().get().prettyPrint());
        assertThat("timed out waiting for yellow", actionGet.isTimedOut(), equalTo(false));
    }
    logger.debug("indices {} are yellow", indices.length == 0 ? "[_all]" : indices);
    return actionGet.getStatus();
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
public ClusterHealthStatus waitForRelocation() {
    final ClusterHealthRequest request = Requests.clusterHealthRequest()
            .waitForNoRelocatingShards(true);
    final ClusterHealthResponse actionGet = client().admin().cluster()
            .health(request).actionGet();
    if (actionGet.isTimedOut()) {
        onFailure("waitForRelocation timed out, cluster state:\n" + "\n"
                + client().admin().cluster().prepareState().get().getState()
                + "\n" + client().admin().cluster()
                        .preparePendingClusterTasks().get(),
                actionGet);
    }
    return actionGet.getStatus();
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
public boolean clusterReady() {
    if (clusterReadyCache) return true;
    ClusterHealthResponse chr = elasticsearchClient.admin().cluster().prepareHealth().get();
    clusterReadyCache = chr.getStatus() != ClusterHealthStatus.RED;
    return clusterReadyCache;
}
 

import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse; //导入方法依赖的package包/类
private Client createInProcessNode(ElasticsearchSearchIndexConfiguration config) {
    Settings settings = tryReadSettingsFromFile(config);
    if (settings == null) {
        String homePath = config.getInProcessNodeHomePath();
        checkNotNull(homePath, ElasticsearchSearchIndexConfiguration.IN_PROCESS_NODE_HOME_PATH + " is required for in process Elasticsearch node");

        Map<String, String> mapSettings = new HashMap<>();
        mapSettings.put("transport.type", "local");
        mapSettings.put("path.home", homePath);
        mapSettings.put("http.enabled", "false");
        mapSettings.put("discovery.zen.ping.unicast.hosts", "localhost");
        if (config.getClusterName() != null) {
            mapSettings.put("cluster.name", config.getClusterName());
        }

        mapSettings.putAll(config.getInProcessNodeAdditionalSettings());

        settings = Settings.builder()
                .put(mapSettings)
                .build();
    }

    this.inProcessNode = new Node(settings);
    try {
        inProcessNode.start();
    } catch (NodeValidationException ex) {
        throw new MemgraphException("Could not start in process node", ex);
    }
    Client client = inProcessNode.client();

    long startTime = System.currentTimeMillis();
    while (true) {
        if (System.currentTimeMillis() > startTime + IN_PROCESS_NODE_WAIT_TIME_MS) {
            throw new MemgraphException("Status failed to exit red status after waiting " + IN_PROCESS_NODE_WAIT_TIME_MS + "ms. Giving up.");
        }
        ClusterHealthResponse health = client.admin().cluster().prepareHealth().get();
        if (health.getStatus() != ClusterHealthStatus.RED) {
            break;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new MemgraphException("Could not sleep", e);
        }
        LOGGER.info("Status is %s, waiting...", health.getStatus());
    }
    return client;
}