org.elasticsearch.action.admin.indices.stats.IndicesStatsRequest Java Examples

private AsyncAction(ActionListener<NodePrometheusMetricsResponse> listener) {
    this.listener = listener;

    // Note: when using ClusterHealthRequest in Java, it pulls data at the shards level, according to ES source
    // code comment this is "so it is backward compatible with the transport client behaviour".
    // hence we are explicit about ClusterHealthRequest level and do not rely on defaults.
    // https://www.elastic.co/guide/en/elasticsearch/reference/6.4/cluster-health.html#request-params
    this.healthRequest = Requests.clusterHealthRequest().local(true);
    this.healthRequest.level(ClusterHealthRequest.Level.SHARDS);

    this.nodesStatsRequest = Requests.nodesStatsRequest("_local").clear().all();

    // Indices stats request is not "node-specific", it does not support any "_local" notion
    // it is broad-casted to all cluster nodes.
    this.indicesStatsRequest = isPrometheusIndices ? new IndicesStatsRequest() : null;

    // Cluster settings are get via ClusterStateRequest (see elasticsearch RestClusterGetSettingsAction for details)
    // We prefer to send it to master node (hence local=false; it should be set by default but we want to be sure).
    this.clusterStateRequest = isPrometheusClusterSettings ? Requests.clusterStateRequest()
            .clear().metadata(true).local(false) : null;
}
 

@Override
public void doRequest(final RestRequest request, final RestChannel channel, final Client client) {
    final String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
    final ClusterStateRequest clusterStateRequest = new ClusterStateRequest();
    clusterStateRequest.local(request.paramAsBoolean("local", clusterStateRequest.local()));
    clusterStateRequest.masterNodeTimeout(request.paramAsTime("master_timeout", clusterStateRequest.masterNodeTimeout()));
    clusterStateRequest.clear().nodes(true).metaData(true).routingTable(true).indices(indices);
    client.admin().cluster().state(clusterStateRequest, new RestActionListener<ClusterStateResponse>(channel) {
        @Override
        public void processResponse(final ClusterStateResponse clusterStateResponse) {
            IndicesStatsRequest indicesStatsRequest = new IndicesStatsRequest(indices);
            indicesStatsRequest.all();
            client.admin().indices().stats(indicesStatsRequest, new RestResponseListener<IndicesStatsResponse>(channel) {
                @Override
                public RestResponse buildResponse(IndicesStatsResponse indicesStatsResponse) throws Exception {
                    return RestTable.buildResponse(buildTable(request, clusterStateResponse, indicesStatsResponse), channel);
                }
            });
        }
    });
}
 

public boolean hasIndex(String indexName) {
  Set<String> indices = getClient().admin()
      .indices()
      .stats(new IndicesStatsRequest())
      .actionGet()
      .getIndices()
      .keySet();
  return indices.contains(indexName);

}
 

/**
 * Retrieve the latest indices stats, calling the listener when complete
 * @return a latch that can be used to wait for the indices stats to complete if desired
 */
private CountDownLatch updateIndicesStats(final ActionListener<IndicesStatsResponse> listener) {
    final CountDownLatch latch = new CountDownLatch(1);
    final IndicesStatsRequest indicesStatsRequest = new IndicesStatsRequest();
    indicesStatsRequest.clear();
    indicesStatsRequest.store(true);

    client.admin().indices().stats(indicesStatsRequest, new LatchedActionListener<>(listener, latch));
    return latch;
}
 

@Override
protected XContentBuilder toXContent(IndicesStatsRequest request, IndicesStatsResponse response, XContentBuilder builder) throws IOException {
    builder.startObject();
    builder.field(Fields.OK, true);
    buildBroadcastShardsHeader(builder, response);
    response.toXContent(builder, ToXContent.EMPTY_PARAMS);
    builder.endObject();
    return builder;
}
 

/**
 * Gets the number of documents in an index.
 *
 * @deprecated
 *
 * @param indexName Name of the index
 * @return The number of documents in an index. 0 is returned if the index does not exist. -1 is returned if the
 * request fails.
 */
@Deprecated
public Long getNumberOfDocumentsInIndex(String indexName) {
    if (!clusterService.state().getRoutingTable().hasIndex(indexName)) {
        return 0L;
    }
    IndicesStatsRequest indicesStatsRequest = new IndicesStatsRequest();
    Optional<IndicesStatsResponse> response = clientUtil.timedRequest(indicesStatsRequest, logger, client.admin().indices()::stats);
    return response.map(r -> r.getIndex(indexName).getPrimaries().docs.getCount()).orElse(-1L);
}
 

/**
 * Retrieve the latest indices stats, calling the listener when complete
 * @return a latch that can be used to wait for the indices stats to complete if desired
 */
protected CountDownLatch updateIndicesStats(final ActionListener<IndicesStatsResponse> listener) {
    final CountDownLatch latch = new CountDownLatch(1);
    final IndicesStatsRequest indicesStatsRequest = new IndicesStatsRequest();
    indicesStatsRequest.clear();
    indicesStatsRequest.store(true);

    transportIndicesStatsAction.execute(indicesStatsRequest, new LatchedActionListener<>(listener, latch));
    return latch;
}
 

@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) {
    IndicesStatsRequest indicesStatsRequest = new IndicesStatsRequest();
    indicesStatsRequest.indicesOptions(IndicesOptions.fromRequest(request, indicesStatsRequest.indicesOptions()));
    indicesStatsRequest.indices(Strings.splitStringByCommaToArray(request.param("index")));
    indicesStatsRequest.types(Strings.splitStringByCommaToArray(request.param("types")));

    Set<String> metrics = Strings.splitStringByCommaToSet(request.param("metric", "_all"));
    // short cut, if no metrics have been specified in URI
    if (metrics.size() == 1 && metrics.contains("_all")) {
        indicesStatsRequest.all();
    } else {
        indicesStatsRequest.clear();
        indicesStatsRequest.docs(metrics.contains("docs"));
        indicesStatsRequest.store(metrics.contains("store"));
        indicesStatsRequest.indexing(metrics.contains("indexing"));
        indicesStatsRequest.search(metrics.contains("search"));
        indicesStatsRequest.get(metrics.contains("get"));
        indicesStatsRequest.merge(metrics.contains("merge"));
        indicesStatsRequest.refresh(metrics.contains("refresh"));
        indicesStatsRequest.flush(metrics.contains("flush"));
        indicesStatsRequest.warmer(metrics.contains("warmer"));
        indicesStatsRequest.queryCache(metrics.contains("query_cache"));
        indicesStatsRequest.percolate(metrics.contains("percolate"));
        indicesStatsRequest.segments(metrics.contains("segments"));
        indicesStatsRequest.fieldData(metrics.contains("fielddata"));
        indicesStatsRequest.completion(metrics.contains("completion"));
        indicesStatsRequest.suggest(metrics.contains("suggest"));
        indicesStatsRequest.requestCache(metrics.contains("request_cache"));
        indicesStatsRequest.recovery(metrics.contains("recovery"));
        indicesStatsRequest.translog(metrics.contains("translog"));
    }

    if (request.hasParam("groups")) {
        indicesStatsRequest.groups(Strings.splitStringByCommaToArray(request.param("groups")));
    }

    if (request.hasParam("types")) {
        indicesStatsRequest.types(Strings.splitStringByCommaToArray(request.param("types")));
    }

    if (indicesStatsRequest.completion() && (request.hasParam("fields") || request.hasParam("completion_fields"))) {
        indicesStatsRequest.completionFields(request.paramAsStringArray("completion_fields", request.paramAsStringArray("fields", Strings.EMPTY_ARRAY)));
    }

    if (indicesStatsRequest.fieldData() && (request.hasParam("fields") || request.hasParam("fielddata_fields"))) {
        indicesStatsRequest.fieldDataFields(request.paramAsStringArray("fielddata_fields", request.paramAsStringArray("fields", Strings.EMPTY_ARRAY)));
    }

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

public static <Request extends ActionRequest> List<String> getIndexFromRequest(Request request) {
	List<String> indexs = new ArrayList<>();

	if (request instanceof SingleShardRequest) {
		indexs.add(((SingleShardRequest<?>) request).index());
		return indexs;
	}

	if (request instanceof ReplicationRequest) {
		indexs.add(((ReplicationRequest<?>) request).index());
		return indexs;
	}

	if (request instanceof InstanceShardOperationRequest) {
		indexs.add(((InstanceShardOperationRequest<?>) request).index());
		return indexs;
	}

	if (request instanceof CreateIndexRequest) {
		indexs.add(((CreateIndexRequest) request).index());
		return indexs;
	}

	if (request instanceof PutMappingRequest) {
		indexs.add(((PutMappingRequest) request).getConcreteIndex().getName());
		return indexs;
	}

	if (request instanceof SearchRequest) {
		return Arrays.asList(((SearchRequest) request).indices());
	}

	if (request instanceof IndicesStatsRequest) {
		return Arrays.asList(((IndicesStatsRequest) request).indices());
	}

	if (request instanceof OpenIndexRequest) {
		return Arrays.asList(((OpenIndexRequest) request).indices());
	}

	if (request instanceof DeleteIndexRequest) {
		return Arrays.asList(((DeleteIndexRequest) request).indices());
	}

	if (request instanceof BulkRequest) {
		@SuppressWarnings("rawtypes") List<DocWriteRequest<?>> requests = ((BulkRequest) request).requests();

		if (CollectionUtils.isNotEmpty(requests)) {
			for (DocWriteRequest<?> docWriteRequest : requests) {
				indexs.add(docWriteRequest.index());
			}
			return indexs;
		}
	}

	if (request instanceof MultiGetRequest) {
		List<Item> items = ((MultiGetRequest) request).getItems();
		if (CollectionUtils.isNotEmpty(items)) {
			for (Item item : items) {
				indexs.add(item.index());
			}
			return indexs;
		}
	}

	// No matched request type to find specific index , set default value *
	indexs.add("*");
	return indexs;
}
 

public StatsRequestBuilder(Client client, JsonToString<JsonInput> jsonToString, StringToJson<JsonOutput> stringToJson) {
    super(client, new IndicesStatsRequest(), jsonToString, stringToJson);
}
 

@Override
protected ActionFuture<IndicesStatsResponse> doExecute(IndicesStatsRequest request) {
    return client.admin().indices().stats(request);
}
 

@Override
public void stats(final IndicesStatsRequest request, final ActionListener<IndicesStatsResponse> listener) {
    execute(IndicesStatsAction.INSTANCE, request, listener);
}
 

@Override
public ActionFuture<IndicesStatsResponse> stats(final IndicesStatsRequest request) {
    return execute(IndicesStatsAction.INSTANCE, request);
}
 

@Override
public void stats(final IndicesStatsRequest request, final ActionListener<IndicesStatsResponse> listener) {
    execute(IndicesStatsAction.INSTANCE, request, listener);
}
 

@Override
public ActionFuture<IndicesStatsResponse> stats(final IndicesStatsRequest request) {
    return execute(IndicesStatsAction.INSTANCE, request);
}
 

/**
 * Indices stats.
 */
void stats(IndicesStatsRequest request, ActionListener<IndicesStatsResponse> listener);
 

/**
 * Indices stats.
 */
ActionFuture<IndicesStatsResponse> stats(IndicesStatsRequest request);
 

/**
 * Indices stats.
 */
ActionFuture<IndicesStatsResponse> stats(IndicesStatsRequest request);
 

/**
 * Indices stats.
 */
void stats(IndicesStatsRequest request, ActionListener<IndicesStatsResponse> listener);