org.elasticsearch.action.admin.cluster.health.ClusterHealthAction Java Examples

public static void waitForCluster(Client client, ClusterHealthStatus statusThreshold,
    String timeout) throws UnableToStartException {
  try {
    ClusterHealthResponse healthResponse = (ClusterHealthResponse) client
        .execute(ClusterHealthAction.INSTANCE,
            new ClusterHealthRequest().waitForStatus(statusThreshold).timeout(timeout))
        .actionGet();
    if (healthResponse != null && healthResponse.isTimedOut()) {
      throw new UnableToStartException("cluster state is " + healthResponse.getStatus().name()
          + " and not " + statusThreshold.name()
          + ", from here on, everything will fail!");
    }
  } catch (ElasticsearchTimeoutException e) {
    throw new UnableToStartException(
        "timeout, cluster does not respond to health request, cowardly refusing to continue with operations");
  }
}
 

@Before
public void startNodes() {
    try {
        logger.info("starting");
        setClusterName();
        startNode("1");
        findNodeAddress();
        try {
            ClusterHealthResponse healthResponse = client("1").execute(ClusterHealthAction.INSTANCE,
                            new ClusterHealthRequest().waitForStatus(ClusterHealthStatus.GREEN).timeout(TimeValue.timeValueSeconds(30))).actionGet();
            if (healthResponse != null && healthResponse.isTimedOut()) {
                throw new IOException("cluster state is " + healthResponse.getStatus().name()
                        + ", from here on, everything will fail!");
            }
        } catch (ElasticsearchTimeoutException e) {
            throw new IOException("timeout, cluster does not respond to health request, cowardly refusing to continue with operations");
        }
    } catch (Throwable t) {
        logger.error("startNodes failed", t);
    }
}
 

public void waitForCluster(String statusString, TimeValue timeout) throws IOException {
    if (client() == null) {
        return;
    }
    try {
        ClusterHealthStatus status = ClusterHealthStatus.fromString(statusString);
        ClusterHealthResponse healthResponse =
                client().execute(ClusterHealthAction.INSTANCE, new ClusterHealthRequest().waitForStatus(status).timeout(timeout)).actionGet();
        if (healthResponse != null && healthResponse.isTimedOut()) {
            throw new IOException("cluster state is " + healthResponse.getStatus().name()
                    + " and not " + status.name()
                    + ", from here on, everything will fail!");
        }
    } catch (ElasticsearchTimeoutException e) {
        throw new IOException("timeout, cluster does not respond to health request, cowardly refusing to continue with operations");
    }
}
 

@Before
public void startNodes() {
    try {
        logger.info("starting");
        setClusterName();
        startNode("1");
        findNodeAddress();
        try {
            ClusterHealthResponse healthResponse = client("1").execute(ClusterHealthAction.INSTANCE,
                            new ClusterHealthRequest().waitForStatus(ClusterHealthStatus.GREEN).timeout(TimeValue.timeValueSeconds(30))).actionGet();
            if (healthResponse != null && healthResponse.isTimedOut()) {
                throw new IOException("cluster state is " + healthResponse.getStatus().name()
                        + ", from here on, everything will fail!");
            }
        } catch (ElasticsearchTimeoutException e) {
            throw new IOException("timeout, cluster does not respond to health request, cowardly refusing to continue with operations");
        }
    } catch (Throwable t) {
        logger.error("startNodes failed", t);
    }
}
 

@Before
public void startNodes() {
    try {
        logger.info("starting");
        setClusterName();
        startNode("1");
        findNodeAddress();
        try {
            ClusterHealthResponse healthResponse = client("1").execute(ClusterHealthAction.INSTANCE,
                            new ClusterHealthRequest().waitForStatus(ClusterHealthStatus.GREEN).timeout(TimeValue.timeValueSeconds(30))).actionGet();
            if (healthResponse != null && healthResponse.isTimedOut()) {
                throw new IOException("cluster state is " + healthResponse.getStatus().name()
                        + ", from here on, everything will fail!");
            }
        } catch (ElasticsearchTimeoutException e) {
            throw new IOException("timeout, cluster does not respond to health request, cowardly refusing to continue with operations");
        }
    } catch (Throwable t) {
        logger.error("startNodes failed", t);
    }
}
 

@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;
}
 

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;
}
 

@Override
public ActionFuture<ClusterHealthResponse> health(final ClusterHealthRequest request) {
    return execute(ClusterHealthAction.INSTANCE, request);
}
 

@Override
public void health(final ClusterHealthRequest request, final ActionListener<ClusterHealthResponse> listener) {
    execute(ClusterHealthAction.INSTANCE, request, listener);
}
 

@Override
public ClusterHealthRequestBuilder prepareHealth(String... indices) {
    return new ClusterHealthRequestBuilder(this, ClusterHealthAction.INSTANCE).setIndices(indices);
}
 

@Override
public ActionFuture<ClusterHealthResponse> health(final ClusterHealthRequest request) {
    return execute(ClusterHealthAction.INSTANCE, request);
}
 

@Override
public ClusterHealthRequestBuilder prepareHealth(String... indices) {
    return new ClusterHealthRequestBuilder(this, ClusterHealthAction.INSTANCE).setIndices(indices);
}
 

static Map<String, ActionHandler<?, ?>> setupActions(List<ActionPlugin> actionPlugins) {
    // Subclass NamedRegistry for easy registration
    class ActionRegistry extends NamedRegistry<ActionHandler<?, ?>> {
        ActionRegistry() {
            super("action");
        }

        public void register(ActionHandler<?, ?> handler) {
            register(handler.getAction().name(), handler);
        }

        public <Request extends TransportRequest, Response extends TransportResponse> void register(
                GenericAction<Request, Response> action, Class<? extends TransportAction<Request, Response>> transportAction,
                Class<?>... supportTransportActions) {
            register(new ActionHandler<>(action, transportAction, supportTransportActions));
        }
    }

    ActionRegistry actions = new ActionRegistry();
    actions.register(ClusterStateAction.INSTANCE, TransportClusterStateAction.class);
    actions.register(ClusterHealthAction.INSTANCE, TransportClusterHealthAction.class);
    actions.register(ClusterUpdateSettingsAction.INSTANCE, TransportClusterUpdateSettingsAction.class);
    actions.register(ClusterRerouteAction.INSTANCE, TransportClusterRerouteAction.class);
    actions.register(PendingClusterTasksAction.INSTANCE, TransportPendingClusterTasksAction.class);
    actions.register(PutRepositoryAction.INSTANCE, TransportPutRepositoryAction.class);
    actions.register(DeleteRepositoryAction.INSTANCE, TransportDeleteRepositoryAction.class);
    actions.register(GetSnapshotsAction.INSTANCE, TransportGetSnapshotsAction.class);
    actions.register(DeleteSnapshotAction.INSTANCE, TransportDeleteSnapshotAction.class);
    actions.register(CreateSnapshotAction.INSTANCE, TransportCreateSnapshotAction.class);
    actions.register(RestoreSnapshotAction.INSTANCE, TransportRestoreSnapshotAction.class);
    actions.register(IndicesStatsAction.INSTANCE, TransportIndicesStatsAction.class);
    actions.register(CreateIndexAction.INSTANCE, TransportCreateIndexAction.class);
    actions.register(ResizeAction.INSTANCE, TransportResizeAction.class);
    actions.register(DeleteIndexAction.INSTANCE, TransportDeleteIndexAction.class);
    actions.register(PutMappingAction.INSTANCE, TransportPutMappingAction.class);
    actions.register(UpdateSettingsAction.INSTANCE, TransportUpdateSettingsAction.class);
    actions.register(PutIndexTemplateAction.INSTANCE, TransportPutIndexTemplateAction.class);
    actions.register(GetIndexTemplatesAction.INSTANCE, TransportGetIndexTemplatesAction.class);
    actions.register(DeleteIndexTemplateAction.INSTANCE, TransportDeleteIndexTemplateAction.class);
    actions.register(RefreshAction.INSTANCE, TransportRefreshAction.class);
    actions.register(SyncedFlushAction.INSTANCE, TransportSyncedFlushAction.class);
    actions.register(ForceMergeAction.INSTANCE, TransportForceMergeAction.class);
    actions.register(UpgradeAction.INSTANCE, TransportUpgradeAction.class);
    actions.register(UpgradeSettingsAction.INSTANCE, TransportUpgradeSettingsAction.class);
    actions.register(RecoveryAction.INSTANCE, TransportRecoveryAction.class);
    actions.register(AddVotingConfigExclusionsAction.INSTANCE, TransportAddVotingConfigExclusionsAction.class);
    actions.register(ClearVotingConfigExclusionsAction.INSTANCE, TransportClearVotingConfigExclusionsAction.class);
    actions.register(NodesStatsAction.INSTANCE, TransportNodesStatsAction.class);

    actionPlugins.stream().flatMap(p -> p.getActions().stream()).forEach(actions::register);

    return unmodifiableMap(actions.getRegistry());
}