Java IndicesStatsResponse类代码示例

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
@Override
public RestChannelConsumer doCatRequest(final RestRequest request, final NodeClient 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);
    return channel -> client.admin().cluster().state(clusterStateRequest, new RestActionListener<ClusterStateResponse>(channel) {
        @Override
        public void processResponse(final ClusterStateResponse clusterStateResponse) {
            IndicesStatsRequest indicesStatsRequest = new IndicesStatsRequest();
            indicesStatsRequest.all();
            indicesStatsRequest.indices(indices);
            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);
                }
            });
        }
    });
}
 

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
@Override
protected void masterOperation(final ShrinkRequest shrinkRequest, final ClusterState state,
                               final ActionListener<ShrinkResponse> listener) {
    final String sourceIndex = indexNameExpressionResolver.resolveDateMathExpression(shrinkRequest.getSourceIndex());
    client.admin().indices().prepareStats(sourceIndex).clear().setDocs(true).execute(new ActionListener<IndicesStatsResponse>() {
        @Override
        public void onResponse(IndicesStatsResponse indicesStatsResponse) {
            CreateIndexClusterStateUpdateRequest updateRequest = prepareCreateIndexRequest(shrinkRequest, state,
                (i) -> {
                    IndexShardStats shard = indicesStatsResponse.getIndex(sourceIndex).getIndexShards().get(i);
                    return shard == null ? null : shard.getPrimary().getDocs();
                }, indexNameExpressionResolver);
            createIndexService.createIndex(updateRequest, ActionListener.wrap(response ->
                listener.onResponse(new ShrinkResponse(response.isAcknowledged(), response.isShardsAcked())), listener::onFailure));
        }

        @Override
        public void onFailure(Exception e) {
            listener.onFailure(e);
        }
    });

}
 

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
public void testAutoCreateIndexWithDateMathExpression() throws Exception {
    DateTime now = new DateTime(DateTimeZone.UTC);
    String index1 = ".marvel-" + DateTimeFormat.forPattern("YYYY.MM.dd").print(now);
    String index2 = ".marvel-" + DateTimeFormat.forPattern("YYYY.MM.dd").print(now.minusDays(1));
    String index3 = ".marvel-" + DateTimeFormat.forPattern("YYYY.MM.dd").print(now.minusDays(2));

    String dateMathExp1 = "<.marvel-{now/d}>";
    String dateMathExp2 = "<.marvel-{now/d-1d}>";
    String dateMathExp3 = "<.marvel-{now/d-2d}>";
    client().prepareIndex(dateMathExp1, "type", "1").setSource("{}", XContentType.JSON).get();
    client().prepareIndex(dateMathExp2, "type", "2").setSource("{}", XContentType.JSON).get();
    client().prepareIndex(dateMathExp3, "type", "3").setSource("{}", XContentType.JSON).get();
    refresh();

    SearchResponse searchResponse = client().prepareSearch(dateMathExp1, dateMathExp2, dateMathExp3).get();
    assertHitCount(searchResponse, 3);
    assertSearchHits(searchResponse, "1", "2", "3");

    IndicesStatsResponse indicesStatsResponse = client().admin().indices().prepareStats(dateMathExp1, dateMathExp2, dateMathExp3).get();
    assertThat(indicesStatsResponse.getIndex(index1), notNullValue());
    assertThat(indicesStatsResponse.getIndex(index2), notNullValue());
    assertThat(indicesStatsResponse.getIndex(index3), notNullValue());
}
 

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
public void testMergeStats() {
    createIndex("test1");

    ensureGreen();

    // clear all
    IndicesStatsResponse stats = client().admin().indices().prepareStats()
            .setDocs(false)
            .setStore(false)
            .setIndexing(false)
            .setFlush(true)
            .setRefresh(true)
            .setMerge(true)
            .clear() // reset defaults
            .execute().actionGet();

    assertThat(stats.getTotal().getDocs(), nullValue());
    assertThat(stats.getTotal().getStore(), nullValue());
    assertThat(stats.getTotal().getIndexing(), nullValue());
    assertThat(stats.getTotal().getGet(), nullValue());
    assertThat(stats.getTotal().getSearch(), nullValue());

    for (int i = 0; i < 20; i++) {
        client().prepareIndex("test1", "type1", Integer.toString(i)).setSource("field", "value").execute().actionGet();
        client().prepareIndex("test1", "type2", Integer.toString(i)).setSource("field", "value").execute().actionGet();
        client().admin().indices().prepareFlush().execute().actionGet();
    }
    client().admin().indices().prepareForceMerge().setMaxNumSegments(1).execute().actionGet();
    stats = client().admin().indices().prepareStats()
            .setMerge(true)
            .execute().actionGet();

    assertThat(stats.getTotal().getMerge(), notNullValue());
    assertThat(stats.getTotal().getMerge().getTotal(), greaterThan(0L));
}
 

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
public void testSegmentsStats() {
    assertAcked(prepareCreate("test1", 2, settingsBuilder().put(SETTING_NUMBER_OF_REPLICAS, between(0, 1))));
    ensureGreen();

    NumShards test1 = getNumShards("test1");

    for (int i = 0; i < 100; i++) {
        index("test1", "type1", Integer.toString(i), "field", "value");
        index("test1", "type2", Integer.toString(i), "field", "value");
    }

    IndicesStatsResponse stats = client().admin().indices().prepareStats().setSegments(true).get();
    assertThat(stats.getTotal().getSegments().getIndexWriterMemoryInBytes(), greaterThan(0L));
    assertThat(stats.getTotal().getSegments().getVersionMapMemoryInBytes(), greaterThan(0L));

    client().admin().indices().prepareFlush().get();
    client().admin().indices().prepareForceMerge().setMaxNumSegments(1).execute().actionGet();
    stats = client().admin().indices().prepareStats().setSegments(true).get();

    assertThat(stats.getTotal().getSegments(), notNullValue());
    assertThat(stats.getTotal().getSegments().getCount(), equalTo((long) test1.totalNumShards));
    assertThat(stats.getTotal().getSegments().getMemoryInBytes(), greaterThan(0L));
}
 

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
private IndicesStatsResponse createAndPopulateIndex(String name, int nodeCount, int shardCount, int replicaCount)
        throws ExecutionException, InterruptedException {

    logger.info("--> creating test index: {}", name);
    assertAcked(prepareCreate(name, nodeCount, Settings.builder().put("number_of_shards", shardCount)
            .put("number_of_replicas", replicaCount).put(Store.INDEX_STORE_STATS_REFRESH_INTERVAL_SETTING.getKey(), 0)));
    ensureGreen();

    logger.info("--> indexing sample data");
    final int numDocs = between(MIN_DOC_COUNT, MAX_DOC_COUNT);
    final IndexRequestBuilder[] docs = new IndexRequestBuilder[numDocs];

    for (int i = 0; i < numDocs; i++) {
        docs[i] = client().prepareIndex(name, INDEX_TYPE).
                setSource("foo-int", randomInt(),
                        "foo-string", randomAsciiOfLength(32),
                        "foo-float", randomFloat());
    }

    indexRandom(true, docs);
    flush();
    assertThat(client().prepareSearch(name).setSize(0).get().getHits().getTotalHits(), equalTo((long) numDocs));
    return client().admin().indices().prepareStats(name).execute().actionGet();
}
 

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
@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);
                }
            });
        }
    });
}
 

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
void preCreateIndex(Client client, IndexMetadata indexMetadata, DateTime dateTime) throws UnsupportedAutoIndexException {
    logger.info("Pre-creating indices for {}*", indexMetadata.getIndexName());

    IndicesStatsResponse indicesStatsResponse = getIndicesStatsResponse(client);
    Map<String, IndexStats> indexStatsMap = indicesStatsResponse.getIndices();

    if (indexStatsMap == null || indexStatsMap.isEmpty()) {
        logger.info("No existing indices, no need to pre-create");
        return;
    }

    indexStatsMap.keySet().stream().filter(indexName -> indexMetadata.getIndexNameFilter().filter(indexName) &&
            indexMetadata.getIndexNameFilter().getNamePart(indexName).equalsIgnoreCase(indexMetadata.getIndexName()))
            .findFirst().ifPresent(indexName -> {
        try {
            createIndex(client, IndexUtils.getIndexNameToPreCreate(indexMetadata, dateTime));
        } catch (UnsupportedAutoIndexException e) {
            logger.error("Invalid index metadata: " + indexMetadata.toString(), e);
        }
    });
}
 

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
@Test
public void testRunIndexManagement_NotActionable_NoIndex() throws Exception {
    String serializedIndexMetadata = "[{\"retentionType\": \"yearly\", \"retentionPeriod\": 20}]";
    when(config.getIndexMetadata()).thenReturn(serializedIndexMetadata);

    Map<String, IndexStats> indexStats = new HashMap<>();
    indexStats.put("nf_errors_log2018", new IndexStats("nf_errors_log2018", new ShardStats[]{}));

    IndicesStatsResponse indicesStatsResponse = mock(IndicesStatsResponse.class);
    when(indicesStatsResponse.getIndices()).thenReturn(indexStats);

    doReturn(indicesStatsResponse).when(elasticsearchIndexManager).getIndicesStatsResponse(elasticsearchClient);

    elasticsearchIndexManager.runIndexManagement();

    verify(elasticsearchIndexManager, times(0)).checkIndexRetention(any(Client.class), anySet(), any(IndexMetadata.class), any(DateTime.class));
    verify(elasticsearchIndexManager, times(0)).preCreateIndex(any(Client.class), any(IndexMetadata.class), any(DateTime.class));
}
 

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
@Test
public void testRunIndexManagement_NotActionable_NoRetentionPeriod() throws Exception {
    String serializedIndexMetadata = "[{\"retentionType\": \"yearly\", \"indexName\": \"nf_errors_log\"}]";
    when(config.getIndexMetadata()).thenReturn(serializedIndexMetadata);

    Map<String, IndexStats> indexStats = new HashMap<>();
    indexStats.put("nf_errors_log2018", new IndexStats("nf_errors_log2018", new ShardStats[]{}));

    IndicesStatsResponse indicesStatsResponse = mock(IndicesStatsResponse.class);
    when(indicesStatsResponse.getIndices()).thenReturn(indexStats);

    doReturn(indicesStatsResponse).when(elasticsearchIndexManager).getIndicesStatsResponse(elasticsearchClient);

    elasticsearchIndexManager.runIndexManagement();

    verify(elasticsearchIndexManager, times(0)).checkIndexRetention(any(Client.class), anySet(), any(IndexMetadata.class), any(DateTime.class));
    verify(elasticsearchIndexManager, times(0)).preCreateIndex(any(Client.class), any(IndexMetadata.class), any(DateTime.class));
}
 

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
@Test
public void testCheckIndexRetention_Overlapping() throws Exception {
    String serializedIndexMetadata = "[{\"preCreate\": false, \"retentionType\": \"hourly\", \"retentionPeriod\": 2, \"indexName\": \"nf_errors_log\"}," +
            "{\"preCreate\": false, \"retentionType\": \"yearly\", \"retentionPeriod\": 3, \"indexName\": \"nf_errors_log201712\"}]";
    List<IndexMetadata> indexMetadataList = IndexUtils.parseIndexMetadata(serializedIndexMetadata);

    Map<String, IndexStats> indexStats = new HashMap<>();
    indexStats.put("nf_errors_log2017121110", new IndexStats("nf_errors_log2017121110", new ShardStats[]{}));
    indexStats.put("nf_errors_log2017121111", new IndexStats("nf_errors_log2017121111", new ShardStats[]{}));
    indexStats.put("nf_errors_log2017121112", new IndexStats("nf_errors_log2017121112", new ShardStats[]{}));
    indexStats.put("nf_errors_log2017121113", new IndexStats("nf_errors_log2017121113", new ShardStats[]{}));
    indexStats.put("nf_errors_log2017121114", new IndexStats("nf_errors_log2017121114", new ShardStats[]{}));

    IndicesStatsResponse indicesStatsResponse = mock(IndicesStatsResponse.class);
    when(indicesStatsResponse.getIndices()).thenReturn(indexStats);

    doReturn(indicesStatsResponse).when(elasticsearchIndexManager).getIndicesStatsResponse(elasticsearchClient);

    elasticsearchIndexManager.runIndexManagement(elasticsearchClient, indexMetadataList, new DateTime("2017-12-11T13:30Z"));

    verify(elasticsearchIndexManager, times(2)).checkIndexRetention(any(Client.class), anySet(), any(IndexMetadata.class), any(DateTime.class));
}
 

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
@Test
public void testIndicesStats() throws FoxtrotException, ExecutionException, InterruptedException {
    List<Document> documents = Lists.newArrayList();
    for (int i = 0; i < 10; i++) {
        documents.add(createDummyDocument());
    }
    doReturn(documents).when(dataStore).saveAll(any(Table.class), anyListOf(Document.class));

    queryStore.save(TestUtils.TEST_TABLE_NAME, documents);
    elasticsearchServer.refresh(ElasticsearchUtils.getIndices(TestUtils.TEST_TABLE_NAME));
    IndicesStatsResponse clusterHealth = queryStore.getIndicesStats();
    assertEquals(10, clusterHealth.getPrimaries().getDocs().getCount());
    assertNotEquals(0, clusterHealth.getTotal().getStore().getSizeInBytes());
    assertNotEquals(0, clusterHealth.getPrimaries().getStore().getSizeInBytes());

}
 

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
private long getIndexSize(){
    long indexSize = 0L;
    final String indexName = indexLocationStrategy.getIndexInitialName();
    try {
        final IndicesStatsResponse statsResponse = esProvider.getClient()
            .admin()
            .indices()
            .prepareStats(indexName)
            .all()
            .execute()
            .actionGet();
        final CommonStats indexStats = statsResponse.getIndex(indexName).getTotal();
        indexSize = indexStats.getStore().getSizeInBytes();
    } catch (IndexMissingException e) {
        // if for some reason the index size does not exist,
        // log an error and we can assume size is 0 as it doesn't exist
        logger.error("Unable to get size for index {} due to IndexMissingException for app {}",
            indexName, indexLocationStrategy.getApplicationScope().getApplication().getUuid());
    }
    return indexSize;
}
 

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
/**
 * 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);

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

import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse; //导入依赖的package包/类
public void testNonThrottleStats() throws Exception {
    assertAcked(prepareCreate("test")
            .setSettings(settingsBuilder()
                            .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, "1")
                            .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, "0")
                            .put(MergePolicyConfig.INDEX_MERGE_POLICY_MAX_MERGE_AT_ONCE_SETTING.getKey(), "2")
                            .put(MergePolicyConfig.INDEX_MERGE_POLICY_SEGMENTS_PER_TIER_SETTING.getKey(), "2")
                            .put(MergeSchedulerConfig.MAX_THREAD_COUNT_SETTING.getKey(), "1")
                            .put(MergeSchedulerConfig.MAX_MERGE_COUNT_SETTING.getKey(), "10000")
            ));
    ensureGreen();
    long termUpto = 0;
    IndicesStatsResponse stats;
    // Provoke slowish merging by making many unique terms:
    for(int i=0; i<100; i++) {
        StringBuilder sb = new StringBuilder();
        for(int j=0; j<100; j++) {
            sb.append(' ');
            sb.append(termUpto++);
            sb.append(" some random text that keeps repeating over and over again hambone");
        }
        client().prepareIndex("test", "type", ""+termUpto).setSource("field" + (i%10), sb.toString()).get();
    }
    refresh();
    stats = client().admin().indices().prepareStats().execute().actionGet();
    //nodesStats = client().admin().cluster().prepareNodesStats().setIndices(true).get();

    stats = client().admin().indices().prepareStats().execute().actionGet();
    assertThat(stats.getPrimaries().getIndexing().getTotal().getThrottleTime().millis(), equalTo(0L));
}