org.elasticsearch.client.RestClientBuilder Java Examples

private void startRestClient() {
    try {
        HttpHost[] hosts = new HttpHost[] {
                // new HttpHost("10.132.161.173", 30002, "http")
                new HttpHost("127.0.0.1", 9200, "http") };
        client = RestClient.builder(hosts).setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
            @Override
            public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
                return requestConfigBuilder.setConnectTimeout(2000).setSocketTimeout(10000);
            }
        }).setMaxRetryTimeoutMillis(10000).setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
            @Override
            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                return httpClientBuilder.setMaxConnPerRoute(100).setMaxConnTotal(200);
                // return httpClientBuilder
                // .setDefaultIOReactorConfig(IOReactorConfig.custom().setIoThreadCount(1).build());
            }
        }).build();
    } catch (Exception e) {
        LOG.error(e.getMessage(), e.fillInStackTrace());
    }
}
 

@BeforeClass
public static void startElasticsearchContainerAndClient() throws IOException {
    container = new ElasticsearchContainer(ELASTICSEARCH_CONTAINER_VERSION);
    container.start();

    CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(USER_NAME, PASSWORD));

    RestClientBuilder builder = RestClient.builder(HttpHost.create(container.getHttpHostAddress()))
        .setHttpClientConfigCallback(httpClientBuilder -> httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider));

    client = new RestHighLevelClient(builder);

    client.indices().create(new CreateIndexRequest(INDEX), RequestOptions.DEFAULT);
    reporter.reset();
}
 

private RestClientBuilder buildRestClientBuilder() {
    return RestClient.builder(
            HttpHost.create(
                    elasticSearchProperties.getUrls()))
            .setRequestConfigCallback(req -> {
                req.setConnectionRequestTimeout(elasticSearchProperties.getConfig().getConnectionTimeout());
                req.setConnectTimeout(elasticSearchProperties.getConfig().getConnectionTimeout());
                req.setSocketTimeout(elasticSearchProperties.getConfig().getConnectionTimeout());
                return req;
            })
            .setMaxRetryTimeoutMillis(elasticSearchProperties.getConfig().getConnectionRetryTimeout())
            .setHttpClientConfigCallback(req -> {
                req.setMaxConnTotal(elasticSearchProperties.getConfig().getMaxTotalConnections());
                req.setMaxConnPerRoute(500);
                return req;
            });
}
 

private RestClientBuilder buildRestClientBuilder() {
    return RestClient
            .builder(HttpHost.create(elasticSearchProperties.getUrls()))
            .setRequestConfigCallback(req -> {
                req.setConnectionRequestTimeout(elasticSearchProperties.getConfig().getConnectionTimeout());
                req.setConnectTimeout(elasticSearchProperties.getConfig().getConnectionTimeout());
                req.setSocketTimeout(elasticSearchProperties.getConfig().getConnectionTimeout());
                return req;
            })
            .setMaxRetryTimeoutMillis(elasticSearchProperties.getConfig().getConnectionRetryTimeout())
            .setHttpClientConfigCallback(req -> {
                req.setMaxConnTotal(elasticSearchProperties.getConfig().getMaxTotalConnections());
                //TODO Move hardcoded value to config
                req.setMaxConnPerRoute(500);
                return req;
            });
}
 

public void init() {
    RestClientBuilder restClientBuilder = RestClient.builder(parseHttpHost(esHosts)
            .toArray(new HttpHost[0]));

    if (this.settings != null && this.settings.size() > 0 &&
            !Strings.isNullOrEmpty(this.settings.get("username"))
            && !Strings.isNullOrEmpty(this.settings.get("password"))) {
        String userName = this.settings.get("username");
        String password = this.settings.get("password");
        final CredentialsProvider credentialsProvider =
                new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY,
                new UsernamePasswordCredentials(userName, password));
        restClientBuilder.setHttpClientConfigCallback(httpAsyncClientBuilder -> {
            httpAsyncClientBuilder.disableAuthCaching();
            return httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
        });
    }
    restHighLevelClient = new RestHighLevelClient(restClientBuilder);
    this.restLowLevelClient = restHighLevelClient.getLowLevelClient();
    if (sniff) {
        sniffer = Sniffer.builder(restLowLevelClient).setSniffIntervalMillis(5 * 60 * 1000).build();
    }
}
 

public static RestClient createClient(ElasticsearchDatastoreProperties datastore) throws MalformedURLException {
    String urlStr = datastore.nodes.getValue();
    String[] urls = urlStr.split(",");
    HttpHost[] hosts = new HttpHost[urls.length];
    int i = 0;
    for (String address : urls) {
        URL url = new URL("http://" + address);
        hosts[i] = new HttpHost(url.getHost(), url.getPort(), url.getProtocol());
        i++;
    }
    RestClientBuilder restClientBuilder = RestClient.builder(hosts);
    if (datastore.auth.useAuth.getValue()) {
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY,
                new UsernamePasswordCredentials(datastore.auth.userId.getValue(), datastore.auth.password.getValue()));
        restClientBuilder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {

            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpAsyncClientBuilder) {
                return httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
            }
        });
    }
    return restClientBuilder.build();
}
 

private static void startRestClient() throws IOException {
    if (client == null) {
        RestClientBuilder builder = RestClient.builder(HttpHost.create(testCluster));
        if (testClusterUser != null) {
            final CredentialsProvider credentialsProvider =
                    new BasicCredentialsProvider();
            credentialsProvider.setCredentials(AuthScope.ANY,
                    new UsernamePasswordCredentials(testClusterUser, testClusterPass));
            builder.setHttpClientConfigCallback(httpClientBuilder -> httpClientBuilder
                    .setDefaultCredentialsProvider(credentialsProvider));
        }

        client = builder.build();
        testClusterRunning();
    }
}
 

/**
 * 异步httpclient连接数配置
 */
private void setHttpClientConfig(RestClientBuilder builder, RestClientPoolProperties poolProperties, RestClientProperties restProperties){
    builder.setHttpClientConfigCallback(httpClientBuilder -> {
        httpClientBuilder.setMaxConnTotal(poolProperties.getMaxConnectNum())
                .setMaxConnPerRoute(poolProperties.getMaxConnectPerRoute());

        PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
        map.from(restProperties::getUsername).to(username -> {
            CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
            credentialsProvider.setCredentials(AuthScope.ANY,
                    new UsernamePasswordCredentials(username, restProperties.getPassword()));
            httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
        });
        return httpClientBuilder;
    });
}
 

@Override
public RestHighLevelClient createClient(Map<String, String> clientConfig) throws IOException {
	RestClientBuilder builder = RestClient.builder(httpHosts.toArray(new HttpHost[httpHosts.size()]));
	restClientFactory.configureRestClientBuilder(builder);

	RestHighLevelClient rhlClient = new RestHighLevelClient(builder);

	if (LOG.isInfoEnabled()) {
		LOG.info("Pinging Elasticsearch cluster via hosts {} ...", httpHosts);
	}

	if (!rhlClient.ping()) {
		throw new RuntimeException("There are no reachable Elasticsearch nodes!");
	}

	if (LOG.isInfoEnabled()) {
		LOG.info("Created Elasticsearch RestHighLevelClient connected to {}", httpHosts.toString());
	}

	return rhlClient;
}
 

@Before
public void setUp() throws IOException {
    dataStoreFactory = Mockito.spy(new ElasticDataStoreFactory());
    clientBuilder = mock(RestClientBuilder.class);
    hostsCaptor = ArgumentCaptor.forClass(HttpHost[].class);
    Mockito.doReturn(clientBuilder).when(dataStoreFactory).createClientBuilder(hostsCaptor.capture());
    final RestClient restClient = mock(RestClient.class);
    when(clientBuilder.build()).thenReturn(restClient);
    final DataStore dataStore = mock(DataStore.class);
    Mockito.doReturn(dataStore).when(dataStoreFactory).createDataStore(any(RestClient.class), any(), anyMap());
    configCallbackCaptor = ArgumentCaptor.forClass(RestClientBuilder.HttpClientConfigCallback.class);
    when(clientBuilder.setHttpClientConfigCallback(configCallbackCaptor.capture())).thenReturn(clientBuilder);
    httpClientBuilder = mock(HttpAsyncClientBuilder.class);
    credentialsProviderCaptor = ArgumentCaptor.forClass(CredentialsProvider.class);
    when(httpClientBuilder.setDefaultCredentialsProvider(credentialsProviderCaptor.capture())).thenReturn(httpClientBuilder);
    threadFactoryCaptor = ArgumentCaptor.forClass(ThreadFactory.class);
    when(httpClientBuilder.setThreadFactory(threadFactoryCaptor.capture())).thenReturn(httpClientBuilder);
    requestConfigCallbackCaptor = ArgumentCaptor.forClass(RestClientBuilder.RequestConfigCallback.class);
    when(clientBuilder.setRequestConfigCallback(requestConfigCallbackCaptor.capture())).thenReturn(clientBuilder);
    requestConfigBuilder = mock(RequestConfig.Builder.class);
    when(requestConfigBuilder.setAuthenticationEnabled(true)).thenReturn(requestConfigBuilder);

    params = getParams("localhost", 9200, "admin", "proxy");
    ElasticDataStoreFactory.httpThreads.set(1);
}
 

@Before
public void init() {
    client = RestClient.builder(new HttpHost("127.0.0.1", 30002, "http"), new HttpHost("127.0.0.1", 30002, "http"))
            .setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
                @Override
                public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
                    return requestConfigBuilder.setConnectTimeout(5000).setSocketTimeout(30000);
                }
            }).setMaxRetryTimeoutMillis(30000)
            // .setHttpClientConfigCallback(new
            // RestClientBuilder.HttpClientConfigCallback() {
            // @Override
            // public HttpAsyncClientBuilder
            // customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder)
            // {
            // return httpClientBuilder
            // .setDefaultIOReactorConfig(IOReactorConfig.custom().setIoThreadCount(1).build());
            // }
            // })
            .build();
}
 

@Override
public void setup() {
  RestClientBuilder restClientBuilder =
      RestClient.builder(new HttpHost(properties.getHost(), properties.getPort(), properties.getScheme()));

  if (StringUtils.isNotEmpty(properties.getUsername()) && StringUtils.isNotEmpty(properties.getPassword())) {
    UsernamePasswordCredentials credentials =
        new UsernamePasswordCredentials(properties.getUsername(), properties.getPassword());

    CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY, credentials);

    restClientBuilder.setHttpClientConfigCallback(
        httpClientBuilder -> httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider));
  } else {
    if (StringUtils.isNotEmpty(properties.getUsername()) || StringUtils.isNotEmpty(properties.getPassword())) {
      log.warn("Both username and password must be configured to setup ES authentication.");
    }
  }

  client = new RestHighLevelClient(restClientBuilder);
}
 

@BeforeClass
public static void startElasticsearchContainerAndClient() throws IOException {
    // Start the container
    container = new ElasticsearchContainer(ELASTICSEARCH_CONTAINER_VERSION);
    container.start();

    // Create the client
    CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(USER_NAME, PASSWORD));

    RestClientBuilder builder = RestClient.builder(HttpHost.create(container.getHttpHostAddress()))
        .setHttpClientConfigCallback(httpClientBuilder -> httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider));
    client = new RestHighLevelClient(builder);

    client.indices().create(new CreateIndexRequest(INDEX), RequestOptions.DEFAULT);
    reporter.reset();
}
 

@BeforeClass
public static void startElasticsearchContainerAndClient() throws IOException {
    // Start the container
    container = new ElasticsearchContainer(ELASTICSEARCH_CONTAINER_VERSION);
    container.start();

    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(USER_NAME, PASSWORD));

    RestClientBuilder builder =  RestClient.builder(HttpHost.create(container.getHttpHostAddress()))
        .setHttpClientConfigCallback(httpClientBuilder -> httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider));
    lowLevelClient = builder.build();
    client = new RestHighLevelClient(lowLevelClient);

    lowLevelClient.performRequest("PUT", "/" + INDEX);
    reporter.reset();
}
 

@JsonCreator
public ElasticSearchFilter(@JsonProperty("hostname") String hostname, @JsonProperty("port") int port,
                           @JsonProperty("username") Optional<String> username,
                           @JsonProperty("password") Optional<String> password) {
  Header[] headers = {
    new BasicHeader(HttpHeaders.CONTENT_TYPE, "application/json"),
    new BasicHeader("Role", "Read")};
  final RestClientBuilder restClientBuilder = RestClient.builder(new HttpHost(hostname, port))
    .setDefaultHeaders(headers);
  if (username.isPresent() && !username.get().isEmpty() && password.isPresent() && !password.get().isEmpty()) {
    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();

    credentialsProvider.setCredentials(
      AuthScope.ANY,
      new UsernamePasswordCredentials(username.get(), password.get())
    );

    restClientBuilder.setHttpClientConfigCallback(b -> b.setDefaultCredentialsProvider(credentialsProvider));
  }
  restClient = restClientBuilder.build();
  mapper = new ObjectMapper();
}
 

@Before
public void setUp() throws Exception {
    /**
     * 如果es集群安装了x-pack插件则以此种方式连接集群
     * 1. java客户端的方式是以tcp协议在9300端口上进行通信
     * 2. http客户端的方式是以http协议在9200端口上进行通信
     */
    Settings settings = Settings.builder(). put("xpack.security.user", "elastic:changeme").build();
    client = new PreBuiltXPackTransportClient(settings)
            .addTransportAddress(new TransportAddress(InetAddress.getByName("localhost"),9200));
    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY,
            new UsernamePasswordCredentials("elastic", "changeme"));
    restClient = RestClient.builder(new HttpHost("localhost",9200,"http"))
            .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                @Override
                public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                    return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                }
            }).build();
}
 

@Bean
@ConditionalOnMissingBean
public RestHighLevelClient restHighLevelClient() {

    List<String> clusterNodes = elasticsearchProperties.getClusterNodes();
    clusterNodes.forEach(node -> {
        try {
            String[] parts = StringUtils.split(node, ":");
            Assert.notNull(parts, "Must defined");
            Assert.state(parts.length == 2, "Must be defined as 'host:port'");
            httpHosts.add(new HttpHost(parts[0], Integer.parseInt(parts[1]), elasticsearchProperties.getSchema()));
        } catch (Exception e) {
            throw new IllegalStateException("Invalid ES nodes " + "property '" + node + "'", e);
        }
    });
    RestClientBuilder builder = RestClient.builder(httpHosts.toArray(new HttpHost[0]));

    return getRestHighLevelClient(builder, elasticsearchProperties);
}
 

@PostConstruct
public void init() {
    try {
        log.trace("Adding elastic rest endpoint... host [{}], port [{}], scheme name [{}]",
                host, port, schemeName);
        RestClientBuilder builder = RestClient.builder(
                new HttpHost(host, port, schemeName));

        if (StringUtils.isNotEmpty(userName) &&
                StringUtils.isNotEmpty(password)) {
            log.trace("...using username [{}] and password ***", userName);
            final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
            credentialsProvider.setCredentials(AuthScope.ANY,
                    new UsernamePasswordCredentials(userName, password));
            builder.setHttpClientConfigCallback(httpClientBuilder -> httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider));
        }

        this.restClient = builder.build();
    } catch (Exception e) {
        log.error("Sink init failed!", e);
        throw new RuntimeException(e.getMessage(), e);
    }
}
 

@Override
public void prepareSink() throws Exception {
    RestClientBuilder builder = RestClient.builder(
        new HttpHost(
            "localhost",
            serviceContainer.getMappedPort(9200),
            "http"));
    elasticClient = new RestHighLevelClient(builder);
}
 

public static RestClientBuilder getESHosts() {
    if (isBlank(ES_HOSTS))
        throw new RuntimeException("Cannot get elasticSearch hosts from config! "
                + "Please check es.hosts config option.");
    String[] hosts = ES_HOSTS.split(",");
    int len;
    if ((len = hosts.length) <= 0)
        throw new RuntimeException("Cannot get elasticSearch hosts from config! "
                + "Please check es.hosts config option.");
    String host;
    String[] hostAndPort;
    LinkedList<HttpHost> httpHosts = new LinkedList<>();
    for (int i = 0; i < len; i++) {
        host = hosts[i];
        hostAndPort = host.split(":");
        if (hostAndPort.length != 2) {
            LOG.warn("Invalid es host: {}!", host);
            continue;
        }
        httpHosts.add(new HttpHost(hostAndPort[0], Integer.parseInt(hostAndPort[1]), "http"));
    }
    int size;
    HttpHost[] httpHostsArray = new HttpHost[size = httpHosts.size()];
    for (int i = 0; i < size; i++) {
        httpHostsArray[i] = httpHosts.get(i);
    }
    return RestClient.builder(httpHostsArray);
}
 

@BeforeClass
public static void startServer() throws Exception {
    System.setProperty(ElasticSearchConfiguration.EMBEDDED_PORT_PROPERTY_NAME, "9204");
    System.setProperty(ElasticSearchConfiguration.ELASTIC_SEARCH_URL_PROPERTY_NAME, "http://localhost:9204");
    System.setProperty(ElasticSearchConfiguration.ELASTIC_SEARCH_INDEX_BATCH_SIZE_PROPERTY_NAME, "1");

    configuration = new SystemPropertiesElasticSearchConfiguration();

    String host = configuration.getEmbeddedHost();
    int port = configuration.getEmbeddedPort();
    String clusterName = configuration.getEmbeddedClusterName();

    embeddedElasticSearch = new EmbeddedElasticSearchV6(clusterName, host, port);
    embeddedElasticSearch.start();

    ElasticSearchRestClientBuilderProvider restClientProvider =
            new ElasticSearchRestClientBuilderProvider(configuration);

    RestClientBuilder restClientBuilder = restClientProvider.get();
    restClient = restClientBuilder.build();

    Map<String, String> params = new HashMap<>();
    params.put("wait_for_status", "yellow");
    params.put("timeout", "30s");

    restClient.performRequest("GET", "/_cluster/health", params);

    objectMapper = new JsonMapperProvider().get();
    indexDAO = new ElasticSearchRestDAOV6(restClientBuilder, configuration, objectMapper);
}
 

private ElasticVindClient(int port, String scheme, String host, String user, String key) {
    this.port = port;
    this.host = host;
    this.scheme = scheme;
    this.user = user;
    this.key = key;

    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(user, key));
    final RestClientBuilder restClientBuilder = RestClient.builder(new HttpHost(host, port, scheme))
            .setHttpClientConfigCallback(httpClientBuilder -> httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider));

    this.client = new RestHighLevelClient(restClientBuilder);
}
 

private ElasticVindClient(String defaultIndex, int port, String scheme, String host, String user, String key) {
    this.defaultIndex = defaultIndex;
    this.port = port;
    this.host = host;
    this.scheme = scheme;
    this.user = user;
    this.key = key;

    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();

    if(Objects.nonNull(this.user) && Objects.nonNull(this.key)) {
        credentialsProvider.setCredentials(AuthScope.ANY,
                new UsernamePasswordCredentials(user, key));
    }


    this.client = new RestHighLevelClient(
            RestClient.builder(
                    new HttpHost(host, port, scheme)
            ).setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                @Override
                public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                    return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                }
            })
    );
}
 

public void open() {
    String esEndpoint =
            ConfigurationContext.getProperty(ConfigurationContext.ConfigurationProperties.ES_ENDPOINT_URL);
    try {
        String urlString =
                new URL(esEndpoint).getHost();
        RestClientBuilder builder = RestClient.builder(new HttpHost(urlString, 80, "http"));
        esClient = new RestHighLevelClient(builder);
        logger.info("Initialized Elastic Stack Helper");
    } catch (MalformedURLException e) {
        logger.error("Could not initialize ElasticSearch Helper cannot talk to Elastic Search");
    }
}
 

@Before
public void setup(){
    PowerMockito.mockStatic(RestClient.class);
    restClientMock = PowerMockito.mock(RestClient.class);
    RestClientBuilder restClientBuilderMock = PowerMockito.mock(RestClientBuilder.class);

    given(RestClient.builder(anyVararg())).willReturn(restClientBuilderMock);
    given(restClientBuilderMock.build()).willReturn(restClientMock);
}
 

public MetricStoreImpl(@Value("${elasticsearch.host}") String host,
                       @Value("${elasticsearch.port}") int port,
                       @Value("${elasticsearch.scheme:http}") String scheme,
                       @Value("${elasticsearch.user:}") String user,
                       @Value("${elasticsearch.password:}") String password) {
    HttpHost httpHost = new HttpHost(host, port, scheme);
    RestClientBuilder builder = RestClient.builder(httpHost);
    if (!user.isEmpty() && !password.isEmpty()) {
        String encodedAuth = buildBasicAuthString(user, password);
        Header[] requestHeaders = new Header[]{
            new BasicHeader(org.apache.http.HttpHeaders.AUTHORIZATION,
                encodedAuth)};
        builder.setDefaultHeaders(requestHeaders);
    }
    this.client = builder.build();
    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.setContentType(MediaType.APPLICATION_JSON);
    this.responseHeaders = responseHeaders;
    String urlBase = String.format("/%s/%s", INDEX, TYPE);
    this.urlGet = urlBase.concat("/_search?filter_path=hits.hits._source");
    this.urlPost = urlBase.concat("/_bulk");
    this.urlDelete = urlBase.concat("/_delete_by_query");
    this.indexMetaData = String.format(
        "{ \"index\" : { \"_index\" : " +
            "\"%s\",\"_type\" : \"%s\" } }%n",
        INDEX,
        TYPE);
    this.mapper = new ObjectMapper();
}
 

private RestHighLevelClient createElasticsearchClient(ElasticsearchConfig elasticsearchConfig) {
    final RestClientBuilder builder = RestClient.builder(
            elasticsearchConfig.getUrls().stream().map(e -> new HttpHost(e.getHost(), e.getPort(), e.getProtocol())).collect(Collectors.toSet()).toArray(new HttpHost[0])
    );
    builder.setDefaultHeaders(elasticsearchConfig.getHeaders().entries().stream().map(e -> new BasicHeader(e.getKey(), e.getValue())).collect(Collectors.toList()).toArray(new Header[0]));

    if (elasticsearchConfig.getMaxRetryTimeoutMillis() != null) {
        builder.setMaxRetryTimeoutMillis(elasticsearchConfig.getMaxRetryTimeoutMillis());
    }
    if (elasticsearchConfig.getPathPrefix() != null) {
        builder.setPathPrefix(elasticsearchConfig.getPathPrefix());
    }

    return new RestHighLevelClient(builder);
}
 

public PooledObject<RestHighLevelClient> makeObject() throws Exception {
    HttpHost[] nodes = new HttpHost[nodesReference.get().size()];
    List<HttpHost> nodeList = new ArrayList<HttpHost>();
    for(HostAndPort each: nodesReference.get()){
        nodeList.add(new HttpHost(each.getHost(),each.getPort(),each.getSchema()));
    }
    nodes = nodeList.toArray(nodes);
    RestClientBuilder clientBuilder = RestClient.builder(nodes);
    RestHighLevelClient client = new RestHighLevelClient(clientBuilder);
    return new DefaultPooledObject(client);
}
 

@Override
public RestHighLevelClient createClient(Map<String, String> clientConfig) {
	RestClientBuilder builder = RestClient.builder(httpHosts.toArray(new HttpHost[httpHosts.size()]));
	restClientFactory.configureRestClientBuilder(builder);

	RestHighLevelClient rhlClient = new RestHighLevelClient(builder);

	return rhlClient;
}
 

public RestClient createRestClient(ElasticSearchConfig config) {

        List<String> esHosts = config.getRestApiHosts();
        List<HttpHost> hosts = new ArrayList<>();
        for (String host : esHosts) {
            try {
                URL url = new URL(host);
                hosts.add(new HttpHost(url.getHost(), url.getPort()));
            } catch (MalformedURLException e) {
                throw new RuntimeException("Failed to initialize Elasticsearch REST client. "
                        + "Invalid host: " + host, e);
            }
        }

        HttpHost[] httpHostsArray = (HttpHost[]) hosts.toArray(new HttpHost[hosts.size()]);
        
        client = RestClient.builder(httpHostsArray)
            .setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
                @Override
                public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
                    return requestConfigBuilder
                            .setConnectTimeout(config.getRestConnectTimeout())
                            .setSocketTimeout(config.getRestSocketTimeout());
                }
            })
            .setMaxRetryTimeoutMillis(config.getRestMaxRetryTimeoutMillis())
            .build();
        
        logger.info("Initialized Elasticsearch REST client for hosts: "+Arrays.toString(httpHostsArray));
        return client;
    }