import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
@Test
public void should_create_index_with_settings() throws ExecutionException, InterruptedException {
    String settings = TestFilesUtils.readFromClasspath("com/github/obourgain/elasticsearch/http/handler/admin/indices/create_index_with_settings.json");

    CreateIndexResponse response = httpClient.admin().indices()
            .createIndex(Requests.createIndexRequest(THE_INDEX)
            .settings(settings))
            .get();
    Assertions.assertThat(response.isAcknowledged()).isTrue();

    GetSettingsResponse getSettingsResponse = transportClient.admin().indices().getSettings(new GetSettingsRequest().indices(THE_INDEX)).actionGet();
    ImmutableOpenMap<String, Settings> indexToSettings = getSettingsResponse.getIndexToSettings();
    Assertions.assertThat(indexToSettings.iterator().hasNext()).isTrue();
    Assertions.assertThat(indexToSettings.iterator().next().key).isEqualTo(THE_INDEX);

    Settings expectedSettings = ImmutableSettings.builder().loadFromSource(settings).build();
    Settings actualSettings = indexToSettings.get(THE_INDEX);
    assertSettingsEquals(expectedSettings, actualSettings);
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
@Test
public void should_update_settings() throws Exception {
    String index = "to_update_indices";
    createIndex(index);
    GetSettingsResponse initial = transportClient.admin().indices().getSettings(new GetSettingsRequest().indices(index)).actionGet();
    Assertions.assertThat(initial.getIndexToSettings().get(index).get("index.number_of_replicas")).isNotEqualTo("5");

    UpdateSettingsResponse response = httpClient.admin().indices().updateSettings(
            new UpdateSettingsRequest(index)
                    .settings(singletonMap("index.number_of_replicas", 5))
    ).get();

    Assertions.assertThat(response.isAcknowledged()).isTrue();

    GetSettingsResponse expected = transportClient.admin().indices().getSettings(new GetSettingsRequest().indices(index)).actionGet();
    Assertions.assertThat(expected.getIndexToSettings().get(index).get("index.number_of_replicas")).isEqualTo("5");
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    final String[] names = request.paramAsStringArrayOrEmptyIfAll("name");
    final boolean renderDefaults = request.paramAsBoolean("include_defaults", false);
    GetSettingsRequest getSettingsRequest = new GetSettingsRequest()
            .indices(Strings.splitStringByCommaToArray(request.param("index")))
            .indicesOptions(IndicesOptions.fromRequest(request, IndicesOptions.strictExpandOpen()))
            .humanReadable(request.hasParam("human"))
            .names(names);
    getSettingsRequest.local(request.paramAsBoolean("local", getSettingsRequest.local()));

    return channel -> client.admin().indices().getSettings(getSettingsRequest, new RestBuilderListener<GetSettingsResponse>(channel) {

        @Override
        public RestResponse buildResponse(GetSettingsResponse getSettingsResponse, XContentBuilder builder) throws Exception {
            builder.startObject();
            for (ObjectObjectCursor<String, Settings> cursor : getSettingsResponse.getIndexToSettings()) {
                // no settings, jump over it to shorten the response data
                if (cursor.value.isEmpty()) {
                    continue;
                }
                builder.startObject(cursor.key);
                builder.startObject("settings");
                cursor.value.toXContent(builder, request);
                builder.endObject();
                if (renderDefaults) {
                    builder.startObject("defaults");
                    settingsFilter.filter(indexScopedSettings.diff(cursor.value, settings)).toXContent(builder, request);
                    builder.endObject();
                }
                builder.endObject();
            }
            builder.endObject();
            return new BytesRestResponse(OK, builder);
        }
    });
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
public void testGetSettings() {
    interceptTransportActions(GetSettingsAction.NAME);

    GetSettingsRequest getSettingsRequest = new GetSettingsRequest().indices(randomIndicesOrAliases());
    internalCluster().coordOnlyNodeClient().admin().indices().getSettings(getSettingsRequest).actionGet();

    clearInterceptedActions();
    assertSameIndices(getSettingsRequest, GetSettingsAction.NAME);
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) {
    final String[] names = request.paramAsStringArrayOrEmptyIfAll("name");
    GetSettingsRequest getSettingsRequest = new GetSettingsRequest()
            .indices(Strings.splitStringByCommaToArray(request.param("index")))
            .indicesOptions(IndicesOptions.fromRequest(request, IndicesOptions.strictExpandOpen()))
            .humanReadable(request.hasParam("human"))
            .names(names);
    getSettingsRequest.local(request.paramAsBoolean("local", getSettingsRequest.local()));

    client.admin().indices().getSettings(getSettingsRequest, new RestBuilderListener<GetSettingsResponse>(channel) {

        @Override
        public RestResponse buildResponse(GetSettingsResponse getSettingsResponse, XContentBuilder builder) throws Exception {
            builder.startObject();
            for (ObjectObjectCursor<String, Settings> cursor : getSettingsResponse.getIndexToSettings()) {
                // no settings, jump over it to shorten the response data
                if (cursor.value.getAsMap().isEmpty()) {
                    continue;
                }
                builder.startObject(cursor.key, XContentBuilder.FieldCaseConversion.NONE);
                builder.startObject(Fields.SETTINGS);
                cursor.value.toXContent(builder, request);
                builder.endObject();
                builder.endObject();
            }
            builder.endObject();
            return new BytesRestResponse(OK, builder);
        }
    });
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
@Test
public void testIndexCreationOptions() throws InterruptedException, BackendException {
    final int shards = 77;

    ElasticsearchRunner esr = new ElasticsearchRunner(".", "indexCreationOptions.yml");
    esr.start();
    CommonsConfiguration cc = new CommonsConfiguration(new BaseConfiguration());
    cc.set("index." + INDEX_NAME + ".elasticsearch.create.ext.number_of_shards", String.valueOf(shards));
    cc.set("index." + INDEX_NAME + ".elasticsearch.ext.cluster.name", "indexCreationOptions");
    ModifiableConfiguration config =
            new ModifiableConfiguration(GraphDatabaseConfiguration.ROOT_NS,
                    cc, BasicConfiguration.Restriction.NONE);
    config.set(INTERFACE, ElasticSearchSetup.NODE.toString(), INDEX_NAME);
    Configuration indexConfig = config.restrictTo(INDEX_NAME);
    IndexProvider idx = new ElasticSearchIndex(indexConfig);
    simpleWriteAndQuery(idx);



    ImmutableSettings.Builder settingsBuilder = ImmutableSettings.settingsBuilder();
    settingsBuilder.put("discovery.zen.ping.multicast.enabled", "false");
    settingsBuilder.put("discovery.zen.ping.unicast.hosts", "localhost,127.0.0.1:9300");
    settingsBuilder.put("cluster.name", "indexCreationOptions");
    NodeBuilder nodeBuilder = NodeBuilder.nodeBuilder().settings(settingsBuilder.build());
    nodeBuilder.client(true).data(false).local(false);
    Node n = nodeBuilder.build().start();

    GetSettingsResponse response = n.client().admin().indices().getSettings(new GetSettingsRequest().indices("titan")).actionGet();
    assertEquals(String.valueOf(shards), response.getSetting("titan", "index.number_of_shards"));

    idx.close();
    n.stop();
    esr.stop();
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
public SearchResponse prepareSearchScrollRequest() {
  // find out how many indices and shards are affected by this query to not get huge result sets when there are very many indices affected by the name, e.g. when wildcards are used
  // otherwise we regularly run into OOMs when a query goes against a large number of indices
  // I did not find a better way to find out the number of shards than to query a list of indices and for each index query the number of shards via the settings
  GetSettingsResponse getSettingsResponse = client.admin().indices().getSettings(new GetSettingsRequest().indices(dataPointer.getIndexName())).actionGet();
  int numShards = 0, numIndices = 0;
  for(ObjectCursor<Settings> settings : getSettingsResponse.getIndexToSettings().values()) {
    numShards += settings.value.getAsInt("index.number_of_shards", 0);
    numIndices++;
  }

  int sizePerShard = (int)Math.ceil((double)SCROLL_SHARD_LIMIT/numShards);
  logger.info("Found " + numIndices + " indices and " + numShards + " shards matching the index-pattern, thus setting the sizePerShard to " + sizePerShard);

  SearchRequestBuilder searchRequestBuilder = client.prepareSearch(dataPointer.getIndexName())
      .setTypes(dataPointer.getTypeName())
      .setSearchType(SearchType.SCAN)
      .addFields("_ttl", "_source")
      .setScroll(new TimeValue(SCROLL_TIME_LIMIT))
      .setSize(sizePerShard);

  if (!Strings.isNullOrEmpty(query.getQuery())) {
    searchRequestBuilder.setQuery(query.getQuery());
  }
  if (!Strings.isNullOrEmpty(query.getSortField())) {
    searchRequestBuilder.addSort(new FieldSortBuilder(query.getSortField()).order(query.getSortOrder()));
  }

  bound.map(resolvedBound -> boundedFilterFactory.createBoundedFilter(segmentationField.get(), resolvedBound))
      .ifPresent(searchRequestBuilder::setQuery);

  return searchRequestBuilder.execute().actionGet();
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
@Test
public void testElasticsearchReplicaHandlingInScrolls() {
  // given
  indexWithSampleData(200);
  ElasticDataPointer sourceDataPointer = embeddedElasticsearchCluster.createDataPointer(SOURCE_INDEX);
  Client sourceClient = ElasticSearchClientFactory.createClient(sourceDataPointer);

  GetSettingsResponse indexSettings = sourceClient.admin().indices().getSettings(new GetSettingsRequest().indices(SOURCE_INDEX)).actionGet();
  assertEquals("We should have an index with 5 shards now",
          "5", indexSettings.getIndexToSettings().get(SOURCE_INDEX).get("index.number_of_shards"));
  assertEquals("We should have an index with one replica now",
          "1", indexSettings.getIndexToSettings().get(SOURCE_INDEX).get("index.number_of_replicas"));

  // when
  SearchRequestBuilder searchRequestBuilder = sourceClient.prepareSearch(sourceDataPointer.getIndexName())
          .setTypes(DATA_TYPE)
          .setSearchType(SearchType.SCAN)
          .addFields("_ttl", "_source")
          .setScroll(new TimeValue(QueryComponent.SCROLL_TIME_LIMIT))
          .setSize(10);
  assertNotNull(searchRequestBuilder);

  // then
  SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
  assertEquals("Overall there should be 200 hits",
          200L, searchResponse.getHits().getTotalHits());
  assertEquals("Initially zero documents are loaded",
          0L, searchResponse.getHits().getHits().length);

  // when
  searchResponse = sourceClient.prepareSearchScroll(searchResponse.getScrollId())
          .setScroll(new TimeValue(QueryComponent.SCROLL_TIMEOUT))
          .get();

  // then
  assertEquals(200L, searchResponse.getHits().getTotalHits());
  assertEquals(50L, searchResponse.getHits().getHits().length);
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
@Test
public void testIndexCreationOptions() throws InterruptedException, BackendException {
    final int shards = 77;

    ElasticsearchRunner esr = new ElasticsearchRunner();
    esr.start();
    CommonsConfiguration cc = new CommonsConfiguration(new BaseConfiguration());
    cc.set("index." + INDEX_NAME + ".elasticsearch.create.ext.number_of_shards", String.valueOf(shards));
    ModifiableConfiguration config =
            new ModifiableConfiguration(GraphDatabaseConfiguration.ROOT_NS,
                    cc, BasicConfiguration.Restriction.NONE);
    config.set(INTERFACE, ElasticSearchSetup.NODE, INDEX_NAME);
    Configuration indexConfig = config.restrictTo(INDEX_NAME);
    IndexProvider idx = new ElasticSearchIndex(indexConfig);
    simpleWriteAndQuery(idx);
    idx.close();


    ImmutableSettings.Builder settingsBuilder = ImmutableSettings.settingsBuilder();
    settingsBuilder.put("discovery.zen.ping.multicast.enabled", "false");
    settingsBuilder.put("discovery.zen.ping.unicast.hosts", "localhost,127.0.0.1:9300");
    NodeBuilder nodeBuilder = NodeBuilder.nodeBuilder().settings(settingsBuilder.build());
    nodeBuilder.client(true).data(false).local(false);
    Node n = nodeBuilder.build().start();
    GetSettingsRequest request = new GetSettingsRequestBuilder((NodeClient)n.client(), "titan").request();
    GetSettingsResponse response = n.client().admin().indices().getSettings(request).actionGet();
    assertEquals(String.valueOf(shards), response.getSetting("titan", "index.number_of_shards"));

    n.stop();
    esr.stop();
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
public void execute(GetSettingsRequest request, final ActionListener<GetSettingsResponse> listener) {
    logger.debug("get settings request {}", request);
    try {
        // lots of url patterns are accepted, but this one is the most practical for a generic impl
        String indices = HttpRequestUtils.indicesOrAll(request);
        RequestUriBuilder uriBuilder = new RequestUriBuilder(indices);

        String names = Strings.arrayToCommaDelimitedString(request.names());
        if (!names.isEmpty()) {
            names = "/" + names;
        }
        uriBuilder.addEndpoint("_settings" + names);

        uriBuilder.addQueryParameter("master_timeout", request.masterNodeTimeout().toString())
                .addIndicesOptions(request);

        indicesAdminClient.getHttpClient().submit(HttpClientRequest.createGet(uriBuilder.toString()))
                .flatMap(ErrorHandler.AS_FUNC)
                .flatMap(new Func1<HttpClientResponse<ByteBuf>, Observable<GetSettingsResponse>>() {
                    @Override
                    public Observable<GetSettingsResponse> call(HttpClientResponse<ByteBuf> response) {
                        return response.getContent().flatMap(new Func1<ByteBuf, Observable<GetSettingsResponse>>() {
                            @Override
                            public Observable<GetSettingsResponse> call(ByteBuf byteBuf) {
                                return GetSettingsResponse.parse(byteBuf);
                            }
                        });
                    }
                })
                .single()
                .subscribe(new ListenerCompleterObserver<>(listener));

    } catch (Exception e) {
        listener.onFailure(e);
    }
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
@Test
public void should_get_settings() throws Exception {
    GetSettingsResponse response = httpClient.admin().indices().getSettings(new GetSettingsRequest().indices(THE_INDEX)).get();

    Assertions.assertThat(response.getIndexToSettings()).hasSize(1);

    org.elasticsearch.action.admin.indices.settings.get.GetSettingsResponse transportResponse = transportClient.admin().indices().getSettings(new GetSettingsRequest().indices(THE_INDEX)).actionGet();
    Settings expected = transportResponse.getIndexToSettings().get(THE_INDEX);

    Assertions.assertThat(response.getIndexToSettings().get(THE_INDEX)).isEqualTo(expected);
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
public ActionFuture<String> getRefreshInterval(final String index) {
    AdapterActionFuture<String, GetSettingsResponse> future = new AdapterActionFuture<String, GetSettingsResponse>() {
        @Override
        protected String convert(GetSettingsResponse listenerResponse) {
            return listenerResponse.getSetting(index, "index.refresh_interval");
        }
    };
    client.admin().indices().getSettings(new GetSettingsRequest().indices(index), future);
    return future;
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
public ActionFuture<Integer> getReplicas(final String index) {
    AdapterActionFuture<Integer, GetSettingsResponse> future = new AdapterActionFuture<Integer, GetSettingsResponse>() {
        @Override
        protected Integer convert(GetSettingsResponse listenerResponse) {
            return Integer.valueOf(listenerResponse.getSetting(index, "index.refresh_interval"));
        }
    };
    client.admin().indices().getSettings(new GetSettingsRequest().indices(index), future);
    return future;
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
@Override
public ActionFuture<GetSettingsResponse> getSettings(GetSettingsRequest request) {
    return execute(GetSettingsAction.INSTANCE, request);
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
private static void showIndexSettings(IndicesAdminClient indicesAdminClient, String indexName) {
        GetSettingsResponse settingInfo = indicesAdminClient.getSettings(new GetSettingsRequest().indices(indexName)).actionGet();
//        log.info("显示 index setting:{}", settingInfo.getIndexToSettings().get(indexName).getAsMap());
    }
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
@Test
public void testQueryWithData() {
  // given
  indexWithSampleData(7000);
  ElasticDataPointer sourceDataPointer = embeddedElasticsearchCluster.createDataPointer(SOURCE_INDEX);
  Client sourceClient = ElasticSearchClientFactory.createClient(sourceDataPointer);
  ElasticSearchQuery elasticSearchQuery = embeddedElasticsearchCluster.createInitialQuery("");

  GetSettingsResponse indexSettings = sourceClient.admin().indices().getSettings(new GetSettingsRequest().indices(SOURCE_INDEX)).actionGet();
  assertEquals("We should have an index with 5 shards now",
          "5", indexSettings.getIndexToSettings().get(SOURCE_INDEX).get("index.number_of_shards"));
  assertEquals("We should have an index with one replica now",
          "1", indexSettings.getIndexToSettings().get(SOURCE_INDEX).get("index.number_of_replicas"));

  // when
  QueryComponent component = QueryComponentBuilder.builder()
          .setClient(sourceClient)
          .setDataPointer(sourceDataPointer)
          .setQuery(elasticSearchQuery)
          .createQueryComponent();
  SearchResponse searchResponse = component.prepareSearchScrollRequest();

  // then
  assertEquals("Overall there should be 7000 hits",
          7000L, searchResponse.getHits().getTotalHits());
  assertEquals("Initially zero documents are loaded",
          0L, searchResponse.getHits().getHits().length);
  assertEquals("Initially zero documents are loaded",
          0L, component.getResponseSize(searchResponse));
  assertTrue("Some documents are found",
          component.searchResultsNotEmpty(searchResponse));

  // when
  searchResponse = component.getNextScrolledSearchResults(searchResponse.getScrollId());

  // then
  assertEquals("Overall there should be 7000 hits",
          7000L, searchResponse.getHits().getTotalHits());
  assertEquals("QueryComponent tries to compute the hits to be 5000 on evenly distributed documents, never more!",
          5000L, searchResponse.getHits().getHits().length);
  assertEquals("QueryComponent tries to compute the hits to be 5000 on evenly distributed documents, never more!",
          5000L, component.getResponseSize(searchResponse));
  assertTrue("Some documents are found",
          component.searchResultsNotEmpty(searchResponse));
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
public void getSettings(GetSettingsRequest request, ActionListener<GetSettingsResponse> listener) {
    getSettingsActionHandler.execute(request, listener);
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
private GetSettingsResponse getSettings() {
    return client().admin().indices().getSettings(new GetSettingsRequest().indices(INDEX)).actionGet();
}
 

import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; //导入依赖的package包/类
/**
 * Executed a per index settings get request and returns the settings for the indices specified.
 * Note: this is a per index request and will not include settings that are set on the cluster
 * level. This request is not exhaustive, it will not return default values for setting.
 */
void getSettings(GetSettingsRequest request, ActionListener<GetSettingsResponse> listener);