DATAES-549 - URL Cleanup.

This commit updates URLs to prefer the https protocol. Redirects are not followed to avoid accidentally expanding intentionally shortened URLs (i.e. if using a URL shortener).

# Fixed URLs

## Fixed Success
These URLs were switched to an https URL with a 2xx status. While the status was successful, your review is still recommended.

* [ ] http://www.apache.org/licenses/ with 1 occurrences migrated to:
  https://www.apache.org/licenses/ ([https](https://www.apache.org/licenses/) result 200).
* [ ] http://www.apache.org/licenses/LICENSE-2.0 with 195 occurrences migrated to:
  https://www.apache.org/licenses/LICENSE-2.0 ([https](https://www.apache.org/licenses/LICENSE-2.0) result 200).

Original Pull Request: #261

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,12 +1,9 @@
-<!--
-
 Thank you for proposing a pull request. This template will guide you through the essential steps necessary for a pull request.
 Make sure that:
 
--->
-
 - [ ] You have read the [Spring Data contribution guidelines](https://github.com/spring-projects/spring-data-build/blob/master/CONTRIBUTING.adoc).
-- [ ] There is a ticket in the bug tracker for the project in our [issue tracker](https://github.com/spring-projects/spring-data-elasticsearch/issues).
+- [ ] There is a ticket in the bug tracker for the project in our [JIRA](https://jira.spring.io/browse/DATAES).
 - [ ] You use the code formatters provided [here](https://github.com/spring-projects/spring-data-build/tree/master/etc/ide) and have them applied to your changes. Don’t submit any formatting related changes.
 - [ ] You submit test cases (unit or integration tests) that back your changes.
 - [ ] You added yourself as author in the headers of the classes you touched. Amend the date range in the Apache license header if needed. For new types, add the license header (copy from another file and set the current year only).
+- [ ] You provide your full name and an email address registered with your GitHub account. If you’re a first-time submitter, make sure you have completed the [Contributor’s License Agreement form](https://support.springsource.com/spring_committer_signup).

.gitignore

@@ -1,22 +1,21 @@
-.DS_Store
-*.graphml
-.springBeans
-
-atlassian-ide-plugin.xml
-
-## Ignore svn files
-.svn
-
-## ignore any target dir
-target
-
-## Ignore project files created by Eclipse
-.settings
-.project
-.classpath
-
-## Ignore project files created by IntelliJ IDEA
-*.iml
-*.ipr
-*.iws
-.idea
+atlassian-ide-plugin.xml
+
+## Ignore svn files
+.svn
+
+## ignore any target dir
+target
+
+##ignore only top level data dir - local node data files for unit tests
+/data
+
+## Ignore project files created by Eclipse
+.settings
+.project
+.classpath
+
+## Ignore project files created by IntelliJ IDEA
+*.iml
+*.ipr
+*.iws
+.idea

.mvn/wrapper/MavenWrapperDownloader.java

@@ -1,117 +0,0 @@
-/*
- * Copyright 2007-present the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import java.net.*;
-import java.io.*;
-import java.nio.channels.*;
-import java.util.Properties;
-
-public class MavenWrapperDownloader {
-
-    private static final String WRAPPER_VERSION = "0.5.6";
-    /**
-     * Default URL to download the maven-wrapper.jar from, if no 'downloadUrl' is provided.
-     */
-    private static final String DEFAULT_DOWNLOAD_URL = "https://repo.maven.apache.org/maven2/io/takari/maven-wrapper/"
-        + WRAPPER_VERSION + "/maven-wrapper-" + WRAPPER_VERSION + ".jar";
-
-    /**
-     * Path to the maven-wrapper.properties file, which might contain a downloadUrl property to
-     * use instead of the default one.
-     */
-    private static final String MAVEN_WRAPPER_PROPERTIES_PATH =
-            ".mvn/wrapper/maven-wrapper.properties";
-
-    /**
-     * Path where the maven-wrapper.jar will be saved to.
-     */
-    private static final String MAVEN_WRAPPER_JAR_PATH =
-            ".mvn/wrapper/maven-wrapper.jar";
-
-    /**
-     * Name of the property which should be used to override the default download url for the wrapper.
-     */
-    private static final String PROPERTY_NAME_WRAPPER_URL = "wrapperUrl";
-
-    public static void main(String args[]) {
-        System.out.println("- Downloader started");
-        File baseDirectory = new File(args[0]);
-        System.out.println("- Using base directory: " + baseDirectory.getAbsolutePath());
-
-        // If the maven-wrapper.properties exists, read it and check if it contains a custom
-        // wrapperUrl parameter.
-        File mavenWrapperPropertyFile = new File(baseDirectory, MAVEN_WRAPPER_PROPERTIES_PATH);
-        String url = DEFAULT_DOWNLOAD_URL;
-        if(mavenWrapperPropertyFile.exists()) {
-            FileInputStream mavenWrapperPropertyFileInputStream = null;
-            try {
-                mavenWrapperPropertyFileInputStream = new FileInputStream(mavenWrapperPropertyFile);
-                Properties mavenWrapperProperties = new Properties();
-                mavenWrapperProperties.load(mavenWrapperPropertyFileInputStream);
-                url = mavenWrapperProperties.getProperty(PROPERTY_NAME_WRAPPER_URL, url);
-            } catch (IOException e) {
-                System.out.println("- ERROR loading '" + MAVEN_WRAPPER_PROPERTIES_PATH + "'");
-            } finally {
-                try {
-                    if(mavenWrapperPropertyFileInputStream != null) {
-                        mavenWrapperPropertyFileInputStream.close();
-                    }
-                } catch (IOException e) {
-                    // Ignore ...
-                }
-            }
-        }
-        System.out.println("- Downloading from: " + url);
-
-        File outputFile = new File(baseDirectory.getAbsolutePath(), MAVEN_WRAPPER_JAR_PATH);
-        if(!outputFile.getParentFile().exists()) {
-            if(!outputFile.getParentFile().mkdirs()) {
-                System.out.println(
-                        "- ERROR creating output directory '" + outputFile.getParentFile().getAbsolutePath() + "'");
-            }
-        }
-        System.out.println("- Downloading to: " + outputFile.getAbsolutePath());
-        try {
-            downloadFileFromURL(url, outputFile);
-            System.out.println("Done");
-            System.exit(0);
-        } catch (Throwable e) {
-            System.out.println("- Error downloading");
-            e.printStackTrace();
-            System.exit(1);
-        }
-    }
-
-    private static void downloadFileFromURL(String urlString, File destination) throws Exception {
-        if (System.getenv("MVNW_USERNAME") != null && System.getenv("MVNW_PASSWORD") != null) {
-            String username = System.getenv("MVNW_USERNAME");
-            char[] password = System.getenv("MVNW_PASSWORD").toCharArray();
-            Authenticator.setDefault(new Authenticator() {
-                @Override
-                protected PasswordAuthentication getPasswordAuthentication() {
-                    return new PasswordAuthentication(username, password);
-                }
-            });
-        }
-        URL website = new URL(urlString);
-        ReadableByteChannel rbc;
-        rbc = Channels.newChannel(website.openStream());
-        FileOutputStream fos = new FileOutputStream(destination);
-        fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
-        fos.close();
-        rbc.close();
-    }
-
-}

.mvn/wrapper/maven-wrapper.properties

@@ -1,3 +0,0 @@
-#Fri Sep 10 15:39:43 CEST 2021
-wrapperUrl=https\://repo.maven.apache.org/maven2/io/takari/maven-wrapper/0.5.6/maven-wrapper-0.5.6.jar
-distributionUrl=https\://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.2/apache-maven-3.8.2-bin.zip

CI.adoc

@@ -1,43 +0,0 @@
-= Continuous Integration
-
-image:https://jenkins.spring.io/buildStatus/icon?job=spring-data-elasticsearch%2Fmaster&subject=2020.0.0%20(master)[link=https://jenkins.spring.io/view/SpringData/job/spring-data-elasticsearch/]
-image:https://jenkins.spring.io/buildStatus/icon?job=spring-data-elasticsearch%2F4.0.x&subject=Neumann%20(4.0.x)[link=https://jenkins.spring.io/view/SpringData/job/spring-data-elasticsearch/]
-image:https://jenkins.spring.io/buildStatus/icon?job=spring-data-elasticsearch%2F3.2.x&subject=Moore%20(3.2.x)[link=https://jenkins.spring.io/view/SpringData/job/spring-data-elasticsearch/]
-
-== Running CI tasks locally
-
-Since this pipeline is purely Docker-based, it's easy to:
-
-* Debug what went wrong on your local machine.
-* Test out a a tweak to your `verify.sh` script before sending it out.
-* Experiment against a new image before submitting your pull request.
-
-All of these use cases are great reasons to essentially run what the CI server does on your local machine.
-
-IMPORTANT: To do this you must have Docker installed on your machine.
-
-1. `docker run -it --mount type=bind,source="$(pwd)",target=/spring-data-elasticsearch-github adoptopenjdk/openjdk8:latest /bin/bash`
-+
-This will launch the Docker image and mount your source code at `spring-data-elasticsearch-github`.
-+
-2. `cd spring-data-elasticsearch-github`
-+
-Next, run your tests from inside the container:
-+
-3. `./mvnw clean dependency:list test -Dsort` (or whatever profile you need to test out)
-
-Since the container is binding to your source, you can make edits from your IDE and continue to run build jobs.
-
-If you need to package things up, do this:
-
-1. `docker run -it -v /var/run/docker.sock:/var/run/docker.sock --mount type=bind,source="$(pwd)",target=/spring-data-elasticsearch-github adoptopenjdk/openjdk8:latest /bin/bash`
-+
-This will launch the Docker image and mount your source code at `spring-data-elasticsearch-github`.
-+
-2. `cd spring-data-elasticsearch-github`
-+
-Next, try to package everything up from inside the container:
-+
-3. `./mvnw -Pci,snapshot -Dmaven.test.skip=true clean package`
-
-NOTE: Docker containers can eat up disk space fast! From time to time, run `docker system prune` to clean out old images.

CODE_OF_CONDUCT.adoc

@@ -0,0 +1,27 @@
+= Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic addresses,
+  without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team.
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting a project maintainer at spring-code-of-conduct@pivotal.io.
+All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances.
+Maintainers are obligated to maintain confidentiality with regard to the reporter of an incident.
+
+This Code of Conduct is adapted from the http://contributor-covenant.org[Contributor Covenant], version 1.3.0, available at http://contributor-covenant.org/version/1/3/0/[contributor-covenant.org/version/1/3/0/].

CONTRIBUTING.adoc

@@ -1,7 +1,3 @@
 = Spring Data contribution guidelines
 
 You find the contribution guidelines for Spring Data projects https://github.com/spring-projects/spring-data-build/blob/master/CONTRIBUTING.adoc[here].
-
-== Running the test locally
-
-In order to run the tests locally with `./mvnw test` you need to have docker running because Spring Data Elasticsearch uses https://www.testcontainers.org/[Testcontainers] to start a local running Elasticsearch instance.

Jenkinsfile

@@ -1,181 +0,0 @@
-pipeline {
-	agent none
-
-	triggers {
-		pollSCM 'H/10 * * * *'
-		upstream(upstreamProjects: "spring-data-commons/2.5.x", threshold: hudson.model.Result.SUCCESS)
-	}
-
-	options {
-		disableConcurrentBuilds()
-		buildDiscarder(logRotator(numToKeepStr: '14'))
-	}
-
-	stages {
-		stage("test: baseline (jdk8)") {
-			when {
-				anyOf {
-					branch '4.2.x'
-					not { triggeredBy 'UpstreamCause' }
-				}
-			}
-			agent {
-				label 'data'
-			}
-			options { timeout(time: 30, unit: 'MINUTES') }
-
-			environment {
-				DOCKER_HUB = credentials('hub.docker.com-springbuildmaster')
-				ARTIFACTORY = credentials('02bd1690-b54f-4c9f-819d-a77cb7a9822c')
-			}
-
-			steps {
-				script {
-					docker.withRegistry('', 'hub.docker.com-springbuildmaster') {
-						docker.image('adoptopenjdk/openjdk8:latest').inside('-u root -v /var/run/docker.sock:/var/run/docker.sock -v /usr/bin/docker:/usr/bin/docker -v $HOME:/tmp/jenkins-home') {
-							sh "docker login --username ${DOCKER_HUB_USR} --password ${DOCKER_HUB_PSW}"
-							sh 'PROFILE=none ci/verify.sh'
-							sh "ci/clean.sh"
-						}
-					}
-				}
-			}
-		}
-
-		stage("Test other configurations") {
-			when {
-				allOf {
-					branch '4.2.x'
-					not { triggeredBy 'UpstreamCause' }
-				}
-			}
-			parallel {
-				stage("test: baseline (jdk11)") {
-					agent {
-						label 'data'
-					}
-					options { timeout(time: 30, unit: 'MINUTES') }
-
-					environment {
-						DOCKER_HUB = credentials('hub.docker.com-springbuildmaster')
-						ARTIFACTORY = credentials('02bd1690-b54f-4c9f-819d-a77cb7a9822c')
-					}
-
-					steps {
-						script {
-							docker.withRegistry('', 'hub.docker.com-springbuildmaster') {
-								docker.image('adoptopenjdk/openjdk11:latest').inside('-u root -v /var/run/docker.sock:/var/run/docker.sock -v /usr/bin/docker:/usr/bin/docker -v $HOME:/tmp/jenkins-home') {
-									sh "docker login --username ${DOCKER_HUB_USR} --password ${DOCKER_HUB_PSW}"
-									sh 'PROFILE=java11 ci/verify.sh'
-									sh "ci/clean.sh"
-								}
-							}
-						}
-					}
-				}
-
-				stage("test: baseline (jdk16)") {
-					agent {
-						label 'data'
-					}
-					options { timeout(time: 30, unit: 'MINUTES') }
-
-					environment {
-						DOCKER_HUB = credentials('hub.docker.com-springbuildmaster')
-						ARTIFACTORY = credentials('02bd1690-b54f-4c9f-819d-a77cb7a9822c')
-					}
-
-					steps {
-						script {
-							docker.withRegistry('', 'hub.docker.com-springbuildmaster') {
-								docker.image('adoptopenjdk/openjdk16:latest').inside('-u root -v /var/run/docker.sock:/var/run/docker.sock -v /usr/bin/docker:/usr/bin/docker -v $HOME:/tmp/jenkins-home') {
-									sh "docker login --username ${DOCKER_HUB_USR} --password ${DOCKER_HUB_PSW}"
-									sh 'PROFILE=java11 ci/verify.sh'
-									sh "ci/clean.sh"
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-
-		stage('Release to artifactory') {
-			when {
-				anyOf {
-					branch '4.2.x'
-					not { triggeredBy 'UpstreamCause' }
-				}
-			}
-			agent {
-				label 'data'
-			}
-			options { timeout(time: 20, unit: 'MINUTES') }
-
-			environment {
-				ARTIFACTORY = credentials('02bd1690-b54f-4c9f-819d-a77cb7a9822c')
-			}
-
-			steps {
-				script {
-					docker.withRegistry('', 'hub.docker.com-springbuildmaster') {
-						docker.image('adoptopenjdk/openjdk8:latest').inside('-v $HOME:/tmp/jenkins-home') {
-							sh 'MAVEN_OPTS="-Duser.name=jenkins -Duser.home=/tmp/jenkins-home" ./mvnw -s settings.xml -Pci,artifactory -Dmaven.repo.local=/tmp/jenkins-home/.m2/spring-data-elasticsearch-non-root ' +
-									'-Dartifactory.server=https://repo.spring.io ' +
-									"-Dartifactory.username=${ARTIFACTORY_USR} " +
-									"-Dartifactory.password=${ARTIFACTORY_PSW} " +
-									"-Dartifactory.staging-repository=libs-snapshot-local " +
-									"-Dartifactory.build-name=spring-data-elasticsearch " +
-									"-Dartifactory.build-number=${BUILD_NUMBER} " +
-									'-Dmaven.test.skip=true clean deploy -U -B'
-						}
-					}
-				}
-			}
-		}
-		stage('Publish documentation') {
-			when {
-				branch '4.2.x'
-			}
-			agent {
-				label 'data'
-			}
-			options { timeout(time: 20, unit: 'MINUTES') }
-
-			environment {
-				ARTIFACTORY = credentials('02bd1690-b54f-4c9f-819d-a77cb7a9822c')
-			}
-
-			steps {
-				script {
-					docker.withRegistry('', 'hub.docker.com-springbuildmaster') {
-						docker.image('adoptopenjdk/openjdk8:latest').inside('-v $HOME:/tmp/jenkins-home') {
-							sh 'MAVEN_OPTS="-Duser.name=jenkins -Duser.home=/tmp/jenkins-home" ./mvnw -s settings.xml -Pci,distribute -Dmaven.repo.local=/tmp/jenkins-home/.m2/spring-data-elasticsearch-non-root ' +
-									'-Dartifactory.server=https://repo.spring.io ' +
-									"-Dartifactory.username=${ARTIFACTORY_USR} " +
-									"-Dartifactory.password=${ARTIFACTORY_PSW} " +
-									"-Dartifactory.distribution-repository=temp-private-local " +
-									'-Dmaven.test.skip=true clean deploy -U -B'
-						}
-					}
-				}
-			}
-		}
-	}
-
-	post {
-		changed {
-			script {
-				slackSend(
-						color: (currentBuild.currentResult == 'SUCCESS') ? 'good' : 'danger',
-						channel: '#spring-data-dev',
-						message: "${currentBuild.fullDisplayName} - `${currentBuild.currentResult}`\n${env.BUILD_URL}")
-				emailext(
-						subject: "[${currentBuild.fullDisplayName}] ${currentBuild.currentResult}",
-						mimeType: 'text/html',
-						recipientProviders: [[$class: 'CulpritsRecipientProvider'], [$class: 'RequesterRecipientProvider']],
-						body: "<a href=\"${env.BUILD_URL}\">${currentBuild.fullDisplayName} is reported as ${currentBuild.currentResult}</a>")
-			}
-		}
-	}
-}

LICENSE.txt

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        https://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright {yyyy} {name of copyright owner}
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       https://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

README.adoc

@@ -1,224 +0,0 @@
-image:https://spring.io/badges/spring-data-elasticsearch/ga.svg[Spring Data Elasticsearch,link=https://projects.spring.io/spring-data-elasticsearch#quick-start] image:https://spring.io/badges/spring-data-elasticsearch/snapshot.svg[Spring Data Elasticsearch,link=https://projects.spring.io/spring-data-elasticsearch#quick-start]
-
-= Spring Data for Elasticsearch image:https://jenkins.spring.io/buildStatus/icon?job=spring-data-elasticsearch%2Fmaster&subject=Build[link=https://jenkins.spring.io/view/SpringData/job/spring-data-elasticsearch/] https://gitter.im/spring-projects/spring-data[image:https://badges.gitter.im/spring-projects/spring-data.svg[Gitter]]
-
-The primary goal of the https://projects.spring.io/spring-data[Spring Data] project is to make it easier to build Spring-powered applications that use new data access technologies such as non-relational databases, map-reduce frameworks, and cloud based data services.
-
-The Spring Data Elasticsearch project provides integration with the https://www.elastic.co/[Elasticsearch] search engine. Key functional areas of Spring Data Elasticsearch are a POJO centric model for interacting with a Elasticsearch Documents and easily writing a Repository style data access layer.
-
-This project is lead and maintained by the community.
-
-== Features
-
-* Spring configuration support using Java based `@Configuration` classes or an XML namespace for a ES clients instances.
-* `ElasticsearchRestTemplate` helper class that increases productivity performing common ES operations. Includes integrated object mapping between documents and POJOs.
-* Feature Rich Object Mapping integrated with Spring’s Conversion Service
-* Annotation based mapping metadata
-* Automatic implementation of `Repository` interfaces including support for custom search methods.
-* CDI support for repositories
-
-== Code of Conduct
-
-This project is governed by the https://github.com/spring-projects/.github/blob/e3cc2ff230d8f1dca06535aa6b5a4a23815861d4/CODE_OF_CONDUCT.md[Spring Code of Conduct]. By participating, you are expected to uphold this code of conduct. Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.
-
-== Getting Started
-
-Here is a quick teaser of an application using Spring Data Repositories in Java:
-
-[source,java]
-----
-public interface PersonRepository extends CrudRepository<Person, Long> {
-
-  List<Person> findByLastname(String lastname);
-
-  List<Person> findByFirstnameLike(String firstname);
-}
-
-@Service
-public class MyService {
-
-  private final PersonRepository repository;
-
-  public MyService(PersonRepository repository) {
-    this.repository = repository;
-  }
-
-  public void doWork() {
-
-    repository.deleteAll();
-
-    Person person = new Person();
-    person.setFirstname("Oliver");
-    person.setLastname("Gierke");
-    repository.save(person);
-
-    List<Person> lastNameResults = repository.findByLastname("Gierke");
-    List<Person> firstNameResults = repository.findByFirstnameLike("Oli");
- }
-}
-----
-
-=== Using Transport Client
-
-NOTE: Usage of the TransportClient is deprecated as of version 4.0, use RestClient instead.
-
-
-[source,java]
-----
-@Configuration
-public class TransportClientConfig extends ElasticsearchConfigurationSupport {
-
-	@Bean
-	public Client elasticsearchClient() throws UnknownHostException {
-		Settings settings = Settings.builder().put("cluster.name", "elasticsearch").build();
-		TransportClient client = new PreBuiltTransportClient(settings);
-		client.addTransportAddress(new TransportAddress(InetAddress.getByName("127.0.0.1"), 9300));
-		return client;
-	}
-
-	@Bean(name = { "elasticsearchOperations", "elasticsearchTemplate" })
-	public ElasticsearchTemplate elasticsearchTemplate() throws UnknownHostException {
-		return new ElasticsearchTemplate(elasticsearchClient());
-	}
-}
-----
-
-=== Using the RestClient
-
-Provide a configuration like this:
-
-[source,java]
-----
-@Configuration
-public class RestClientConfig extends AbstractElasticsearchConfiguration {
-
-    @Override
-    @Bean
-    public RestHighLevelClient elasticsearchClient() {
-
-        final ClientConfiguration clientConfiguration = ClientConfiguration.builder()
-            .connectedTo("localhost:9200")
-            .build();
-
-        return RestClients.create(clientConfiguration).rest();
-    }
-}
-----
-
-=== Maven configuration
-
-Add the Maven dependency:
-
-[source,xml]
-----
-<dependency>
-  <groupId>org.springframework.data</groupId>
-  <artifactId>spring-data-elasticsearch</artifactId>
-  <version>${version}</version>
-</dependency>
-----
-
-// NOTE: since Github does not support include directives, the content of
-// the src/main/asciidoc/reference/preface.adoc file is duplicated here
-// Always change both files!
-**Compatibility Matrix**
-
-The compatibility between Spring Data Elasticsearch, Elasticsearch client drivers and Spring Boot versions can be found in the https://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/#preface.versions[reference documentation].
-
-To use the Release candidate versions of the upcoming major version, use our Maven milestone repository and declare the appropriate dependency version:
-
-[source,xml]
-----
-<dependency>
-  <groupId>org.springframework.data</groupId>
-  <artifactId>spring-data-elasticsearch</artifactId>
-  <version>${version}.RCx</version> <!-- x being 1, 2, ... -->
-</dependency>
-
-<repository>
-  <id>spring-libs-snapshot</id>
-  <name>Spring Snapshot Repository</name>
-  <url>https://repo.spring.io/libs-milestone</url>
-</repository>
-----
-
-If you'd rather like the latest snapshots of the upcoming major version, use our Maven snapshot repository and declare the appropriate dependency version:
-
-[source,xml]
-----
-<dependency>
-  <groupId>org.springframework.data</groupId>
-  <artifactId>spring-data-elasticsearch</artifactId>
-  <version>${version}-SNAPSHOT</version>
-</dependency>
-
-<repository>
-  <id>spring-libs-snapshot</id>
-  <name>Spring Snapshot Repository</name>
-  <url>https://repo.spring.io/libs-snapshot</url>
-</repository>
-----
-
-== Getting Help
-
-Having trouble with Spring Data? We’d love to help!
-
-* Check the
-https://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/[reference documentation], and https://docs.spring.io/spring-data/elasticsearch/docs/current/api/[Javadocs].
-* Learn the Spring basics – Spring Data builds on Spring Framework, check the https://spring.io[spring.io] web-site for a wealth of reference documentation.
-If you are just starting out with Spring, try one of the https://spring.io/guides[guides].
-* If you are upgrading, check out the https://docs.spring.io/spring-data/elasticsearch/docs/current/changelog.txt[changelog] for "`new and noteworthy`" features.
-* Ask a question - we monitor https://stackoverflow.com[stackoverflow.com] for questions tagged with https://stackoverflow.com/tags/spring-data[`spring-data-elasticsearch`].
-You can also chat with the community on https://gitter.im/spring-projects/spring-data[Gitter].
-* Report bugs with Spring Data for Elasticsearch at https://github.com/spring-projects/spring-data-elasticsearch/issues[https://github.com/spring-projects/spring-data-elasticsearch/issues].
-
-== Reporting Issues
-
-Spring Data uses GitHub as issue tracking system to record bugs and feature requests. If you want to raise an issue, please follow the recommendations below:
-
-* Before you log a bug, please search the
-https://github.com/spring-projects/spring-data-elasticsearch/issues[issue tracker] to see if someone has already reported the problem.
-* If the issue doesn’t already exist, https://github.com/spring-projects/spring-data-elasticsearch/issues/new[create a new issue].
-* Please provide as much information as possible with the issue report, we like to know the version of Spring Data Elasticsearch that you are using and JVM version.
-* If you need to paste code, or include a stack trace use Markdown +++```+++ escapes before and after your text.
-* If possible try to create a test-case or project that replicates the issue. Attach a link to your code or a compressed file containing your code.
-
-== Building from Source
-
-You don’t need to build from source to use Spring Data (binaries in https://repo.spring.io[repo.spring.io]), but if you want to try out the latest and greatest, Spring Data can be easily built with the https://github.com/takari/maven-wrapper[maven wrapper].
-You also need JDK 1.8.
-
-[source,bash]
-----
- $ ./mvnw clean install
-----
-
-If you want to build with the regular `mvn` command, you will need https://maven.apache.org/run-maven/index.html[Maven v3.5.0 or above].
-
-_Also see link:CONTRIBUTING.adoc[CONTRIBUTING.adoc] if you wish to submit pull requests, and in particular please sign the https://cla.pivotal.io/sign/spring[Contributor’s Agreement] before submitting your first pull request._
-
-IMPORTANT: When contributing, please make sure an issue exists in https://github.com/spring-projects/spring-data-elasticsearch/issues[issue tracker] and comment on this issue with how you want to address it. By this we not only know that someone is working on an issue, we can also align architectural questions and possible solutions before work is invested
-. We
-so
-can prevent that much work is put into Pull Requests that have little
-or no chances of being merged.
-
-
-=== Building reference documentation
-
-Building the documentation builds also the project without running tests.
-
-[source,bash]
-----
- $ ./mvnw clean install -Pdistribute
-----
-
-The generated documentation is available from `target/site/reference/html/index.html`.
-
-== Examples
-
-For examples on using the Spring Data for Elasticsearch, see the https://github.com/spring-projects/spring-data-examples/tree/master/elasticsearch/example[spring-data-examples] project.
-
-== License
-
-Spring Data for Elasticsearch Open Source software released under the https://www.apache.org/licenses/LICENSE-2.0.html[Apache 2.0 license].

README.md

@@ -0,0 +1,258 @@
+Spring Data Elasticsearch
+=========================
+
+Spring Data implementation for ElasticSearch
+
+Spring Data makes it easier to build Spring-powered applications that use new data access technologies such as non-relational databases, map-reduce frameworks, and cloud based data services as well as provide improved support for relational database technologies.
+
+The Spring Data Elasticsearch project provides integration with the [elasticsearch](http://www.elasticsearch.org/) search engine.
+
+Guide
+------------
+
+* [Reference Documentation](http://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/)
+* [API Documentation](http://docs.spring.io/spring-data/elasticsearch/docs/current/api/)
+* [Spring Data Project](http://projects.spring.io/spring-data)
+* [Sample Test Application](https://github.com/BioMedCentralLtd/spring-data-elasticsearch-sample-application)
+* [Issues](https://jira.springsource.org/browse/DATAES)
+* [Spring Data Elasticsearch Google Group](https://groups.google.com/d/forum/spring-data-elasticsearch-devs)
+* [Questions](http://stackoverflow.com/questions/tagged/spring-data-elasticsearch)
+
+
+Quick Start
+-----------
+Wiki page for [Getting Started](https://github.com/spring-projects/spring-data-elasticsearch/wiki/How-to-start-with-spring-data-elasticsearch)
+
+### Maven configuration
+
+Add the Maven dependency:
+
+```xml
+<dependency>
+    <groupId>org.springframework.data</groupId>
+    <artifactId>spring-data-elasticsearch</artifactId>
+    <version>1.3.4.RELEASE</version>
+</dependency>
+```
+
+If you'd rather like the latest snapshots of the upcoming major version, use our Maven snapshot repository and declare
+the appropriate dependency version.
+
+```xml
+<dependency>
+  <groupId>org.springframework.data</groupId>
+  <artifactId>spring-data-elasticsearch</artifactId>
+  <version>2.0.0.BUILD-SNAPSHOT</version>
+</dependency>
+
+<repository>
+  <id>spring-libs-snapshot</id>
+  <name>Spring Snapshot Repository</name>
+  <url>http://repo.spring.io/libs-snapshot</url>
+</repository>
+```
+
+### Note:
+
+1) Spring data elaticsearch until 1.0.0.RELEASE version is on elasticsearch 1.1.x library, which uses java 1.6 or later version.
+
+2) From spring data elasticsearch 1.1.0.RELEASE the version of elasticsearch is 1.3.x  which is supporting java 1.7 or later.
+
+|   spring data elasticsearch         | elasticsearch |
+|:-----------------------------------:|:-------------:|
+|           2.0.0.RC1                 |      2.2.0    |
+|           1.4.0.M1                  |      1.7.3    |
+|           1.3.0.RELEASE             |      1.5.2    |
+|           1.2.0.RELEASE             |      1.4.4    |
+|           1.1.0.RELEASE             |      1.3.2    |
+|           1.0.0.RELEASE             |      1.1.1    |
+
+
+### ElasticsearchRepository
+A default implementation of ElasticsearchRepository, aligning to the generic Repository Interfaces, is provided. Spring can do the Repository implementation for you depending on method names in the interface definition.
+
+The ElasticsearchCrudRepository extends PagingAndSortingRepository
+
+```java
+    public interface ElasticsearchCrudRepository<T, ID extends Serializable> extends ElasticsearchRepository<T, ID>, PagingAndSortingRepository<T, ID> {
+    }
+```
+
+Extending ElasticsearchRepository for custom methods
+
+```java
+    public interface BookRepository extends Repository<Book, String> {
+
+        List<Book> findByNameAndPrice(String name, Integer price);
+
+        List<Book> findByNameOrPrice(String name, Integer price);
+        
+        Page<Book> findByName(String name,Pageable page);
+
+        Page<Book> findByNameNot(String name,Pageable page);
+
+        Page<Book> findByPriceBetween(int price,Pageable page);
+
+        Page<Book> findByNameLike(String name,Pageable page);
+
+        @Query("{\"bool\" : {\"must\" : {\"term\" : {\"message\" : \"?0\"}}}}")
+        Page<Book> findByMessage(String message, Pageable pageable);
+    }
+```
+Indexing a single document with Repository
+
+```java
+        @Autowired
+        private SampleElasticsearchRepository repository;
+
+        String documentId = "123456";
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+
+        repository.save(sampleEntity);
+```
+
+Indexing multiple Document(bulk index) using Repository
+
+```java
+        @Autowired
+        private SampleElasticsearchRepository repository;
+
+        String documentId = "123456";
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("some message");
+
+        String documentId2 = "123457"
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("test message");
+
+        List<SampleEntity> sampleEntities = Arrays.asList(sampleEntity1, sampleEntity2);
+
+        //bulk index
+        repository.save(sampleEntities);
+```
+
+
+### ElasticsearchTemplate
+
+ElasticsearchTemplate is the central support class for elasticsearch operations.
+
+Indexing a single document using Elasticsearch Template
+
+```java
+        String documentId = "123456";
+        SampleEntity sampleEntity = new SampleEntity();
+        sampleEntity.setId(documentId);
+        sampleEntity.setMessage("some message");
+        IndexQuery indexQuery = new IndexQueryBuilder().withId(sampleEntity.getId()).withObject(sampleEntity).build();
+        elasticsearchTemplate.index(indexQuery);
+```
+
+Indexing multiple Document(bulk index) using Elasticsearch Template
+
+```java
+        @Autowired
+        private ElasticsearchTemplate elasticsearchTemplate;
+
+        List<IndexQuery> indexQueries = new ArrayList<IndexQuery>();
+        //first document
+        String documentId = "123456";
+        SampleEntity sampleEntity1 = new SampleEntity();
+        sampleEntity1.setId(documentId);
+        sampleEntity1.setMessage("some message");
+
+        IndexQuery indexQuery1 = new IndexQueryBuilder().withId(sampleEntity1.getId()).withObject(sampleEntity1).build();
+        indexQueries.add(indexQuery1);
+
+        //second document
+        String documentId2 = "123457";
+        SampleEntity sampleEntity2 = new SampleEntity();
+        sampleEntity2.setId(documentId2);
+        sampleEntity2.setMessage("some message");
+
+        IndexQuery indexQuery2 = new IndexQueryBuilder().withId(sampleEntity2.getId()).withObject(sampleEntity2).build()
+        indexQueries.add(indexQuery2);
+
+        //bulk index
+        elasticsearchTemplate.bulkIndex(indexQueries);
+```
+
+Searching entities using Elasticsearch Template
+
+```java
+        @Autowired
+        private ElasticsearchTemplate elasticsearchTemplate;
+
+        SearchQuery searchQuery = new NativeSearchQueryBuilder()
+        .withQuery(queryString(documentId).field("id"))
+        .build();
+        Page<SampleEntity> sampleEntities = elasticsearchTemplate.queryForPage(searchQuery,SampleEntity.class);
+```
+
+### XML Namespace
+
+You can set up repository scanning via xml configuration, which will happily create your repositories.
+
+Using Node Client
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
+       xsi:schemaLocation="http://www.springframework.org/schema/data/elasticsearch http://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch.xsd
+		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
+
+    <elasticsearch:node-client id="client" local="true"/>
+
+    <bean name="elasticsearchTemplate" class="org.springframework.data.elasticsearch.core.ElasticsearchTemplate">
+        <constructor-arg name="client" ref="client"/>
+    </bean>
+
+</beans>
+```
+
+Using Transport Client
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
+       xsi:schemaLocation="http://www.springframework.org/schema/data/elasticsearch http://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch.xsd
+		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
+
+    <elasticsearch:repositories base-package="com.xyz.acme"/>
+
+    <elasticsearch:transport-client id="client" cluster-nodes="ip:9300,ip:9300" cluster-name="elasticsearch" />
+
+    <bean name="elasticsearchTemplate" class="org.springframework.data.elasticsearch.core.ElasticsearchTemplate">
+        <constructor-arg name="client" ref="client"/>
+    </bean>
+
+</beans>
+```
+
+## Help Pages
+
+* [Geo distance and location search](https://github.com/spring-projects/spring-data-elasticsearch/wiki/Geo-indexing-and-request)
+* [Custom object mapper](https://github.com/spring-projects/spring-data-elasticsearch/wiki/Custom-ObjectMapper)
+
+## Contributing to Spring Data
+
+Here are some ways for you to get involved in the community:
+
+* Get involved with the Spring community on the Spring Community Forums.  Please help out on the [forum](http://forum.springsource.org/forumdisplay.php?f=80) by responding to questions and joining the debate.
+* Create [JIRA](https://jira.springframework.org/browse/DATAES) tickets for bugs and new features and comment and vote on the ones that you are interested in.  
+* Github is for social coding: if you want to write code, we encourage contributions through pull requests from [forks of this repository](http://help.github.com/forking/). If you want to contribute code this way, please reference a JIRA ticket as well covering the specific issue you are addressing.
+* Watch for upcoming articles on Spring by [subscribing](http://www.springsource.org/node/feed) to springframework.org
+
+Before we accept a non-trivial patch or pull request we will need you to sign the [contributor's agreement](https://support.springsource.com/spring_committer_signup).  Signing the contributor's agreement does not grant anyone commit rights to the main repository, but it does mean that we can accept your contributions, and you will get an author credit if we do.  Active contributors might be asked to join the core team, and given the ability to merge pull requests.
+
+
+Code formatting for [Eclipse and Intellij](https://github.com/spring-projects/spring-data-build/tree/master/etc/ide)
+
+[More information about contributing to Spring Data](https://github.com/spring-projects/spring-data-build/blob/master/CONTRIBUTING.adoc)

SECURITY.adoc

@@ -1,9 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Please see the https://spring.io/projects/spring-data-elasticsearch[Spring Data Elasticsearch] project page for supported versions.
-
-## Reporting a Vulnerability
-
-Please don't raise security vulnerabilities here. Head over to https://pivotal.io/security to learn how to disclose them responsibly.

TESTING.adoc

@@ -1,41 +0,0 @@
-= Testing
-
-== Unit tests
-
-Unit tests in the project are run with
-
-----
-./mvnw test
-----
-
-== Integration tests
-
-Integration tests are executed when
-----
-./mvnw verify
-----
-is run. There must be _docker_ running, as the integration tests use docker to start an Elasticsearch server.
-
-Integration tests are tests that have the Junit5 Tag `@Tag("integration-test")` on the test class. Normally this should not be set explicitly, but the annotation `@SpringIntegrationTest` should be used. This not only marks the test as integration test, but integrates an automatic setup of an Elasticsearch Testcontainer and integrate this with Spring, so
-that the required Beans can be automatically injected. Check _src/test/java/org/springframework/data/elasticsearch/JUnit5SampleRestClientBasedTests.java_ as a reference setup
-
-== Mutation testing
-
-The pom includes a plugin dependency to run mutation tests using [pitest](https://pitest.org/). These tests must be explicitly configured and run, they are not included in the normal build steps. Before pitest can run, a normal `./mvnw test` must be executed. The configuration excludes integration tests, only unit tests are considered.
-
-
-pitest can be run directly from the commandline
-----
-./mvnw org.pitest:pitest-maven:mutationCoverage
-----
-This will output an html report to _target/pit-reports/YYYYMMDDHHMI_.
-
-To speed-up repeated analysis of the same codebase set the withHistory parameter to true.
-----
-./mvnw -DwithHistory org.pitest:pitest-maven:mutationCoverage
-----
-
-The classes to test are defined either in the pom.xml or can be set on the commandline:
-----
-./mvnw -DwithHistory org.pitest:pitest-maven:mutationCoverage -DtargetClasses="org.springframework.data.elasticsearch.support.*"
-----

ci/clean.sh

@@ -1,6 +0,0 @@
-#!/bin/bash -x
-
-set -euo pipefail
-
-MAVEN_OPTS="-Duser.name=jenkins -Duser.home=/tmp/jenkins-home" \
-  ./mvnw -s settings.xml clean -Dmaven.repo.local=/tmp/jenkins-home/.m2/spring-data-elasticsearch

ci/verify.sh

@@ -1,10 +0,0 @@
-#!/bin/bash -x
-
-set -euo pipefail
-
-mkdir -p /tmp/jenkins-home/.m2/spring-data-elasticsearch
-chown -R 1001:1001 .
-
-MAVEN_OPTS="-Duser.name=jenkins -Duser.home=/tmp/jenkins-home" \
-  ./mvnw -s settings.xml \
-  -P${PROFILE} clean dependency:list verify -Dsort -U -B -Dmaven.repo.local=/tmp/jenkins-home/.m2/spring-data-elasticsearch

mvnw

@@ -1,310 +0,0 @@
-#!/bin/sh
-# ----------------------------------------------------------------------------
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-# ----------------------------------------------------------------------------
-
-# ----------------------------------------------------------------------------
-# Maven Start Up Batch script
-#
-# Required ENV vars:
-# ------------------
-#   JAVA_HOME - location of a JDK home dir
-#
-# Optional ENV vars
-# -----------------
-#   M2_HOME - location of maven2's installed home dir
-#   MAVEN_OPTS - parameters passed to the Java VM when running Maven
-#     e.g. to debug Maven itself, use
-#       set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
-#   MAVEN_SKIP_RC - flag to disable loading of mavenrc files
-# ----------------------------------------------------------------------------
-
-if [ -z "$MAVEN_SKIP_RC" ] ; then
-
-  if [ -f /etc/mavenrc ] ; then
-    . /etc/mavenrc
-  fi
-
-  if [ -f "$HOME/.mavenrc" ] ; then
-    . "$HOME/.mavenrc"
-  fi
-
-fi
-
-# OS specific support.  $var _must_ be set to either true or false.
-cygwin=false;
-darwin=false;
-mingw=false
-case "`uname`" in
-  CYGWIN*) cygwin=true ;;
-  MINGW*) mingw=true;;
-  Darwin*) darwin=true
-    # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
-    # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
-    if [ -z "$JAVA_HOME" ]; then
-      if [ -x "/usr/libexec/java_home" ]; then
-        export JAVA_HOME="`/usr/libexec/java_home`"
-      else
-        export JAVA_HOME="/Library/Java/Home"
-      fi
-    fi
-    ;;
-esac
-
-if [ -z "$JAVA_HOME" ] ; then
-  if [ -r /etc/gentoo-release ] ; then
-    JAVA_HOME=`java-config --jre-home`
-  fi
-fi
-
-if [ -z "$M2_HOME" ] ; then
-  ## resolve links - $0 may be a link to maven's home
-  PRG="$0"
-
-  # need this for relative symlinks
-  while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-      PRG="$link"
-    else
-      PRG="`dirname "$PRG"`/$link"
-    fi
-  done
-
-  saveddir=`pwd`
-
-  M2_HOME=`dirname "$PRG"`/..
-
-  # make it fully qualified
-  M2_HOME=`cd "$M2_HOME" && pwd`
-
-  cd "$saveddir"
-  # echo Using m2 at $M2_HOME
-fi
-
-# For Cygwin, ensure paths are in UNIX format before anything is touched
-if $cygwin ; then
-  [ -n "$M2_HOME" ] &&
-    M2_HOME=`cygpath --unix "$M2_HOME"`
-  [ -n "$JAVA_HOME" ] &&
-    JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-  [ -n "$CLASSPATH" ] &&
-    CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
-fi
-
-# For Mingw, ensure paths are in UNIX format before anything is touched
-if $mingw ; then
-  [ -n "$M2_HOME" ] &&
-    M2_HOME="`(cd "$M2_HOME"; pwd)`"
-  [ -n "$JAVA_HOME" ] &&
-    JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
-fi
-
-if [ -z "$JAVA_HOME" ]; then
-  javaExecutable="`which javac`"
-  if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
-    # readlink(1) is not available as standard on Solaris 10.
-    readLink=`which readlink`
-    if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
-      if $darwin ; then
-        javaHome="`dirname \"$javaExecutable\"`"
-        javaExecutable="`cd \"$javaHome\" && pwd -P`/javac"
-      else
-        javaExecutable="`readlink -f \"$javaExecutable\"`"
-      fi
-      javaHome="`dirname \"$javaExecutable\"`"
-      javaHome=`expr "$javaHome" : '\(.*\)/bin'`
-      JAVA_HOME="$javaHome"
-      export JAVA_HOME
-    fi
-  fi
-fi
-
-if [ -z "$JAVACMD" ] ; then
-  if [ -n "$JAVA_HOME"  ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-      # IBM's JDK on AIX uses strange locations for the executables
-      JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-      JAVACMD="$JAVA_HOME/bin/java"
-    fi
-  else
-    JAVACMD="`which java`"
-  fi
-fi
-
-if [ ! -x "$JAVACMD" ] ; then
-  echo "Error: JAVA_HOME is not defined correctly." >&2
-  echo "  We cannot execute $JAVACMD" >&2
-  exit 1
-fi
-
-if [ -z "$JAVA_HOME" ] ; then
-  echo "Warning: JAVA_HOME environment variable is not set."
-fi
-
-CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher
-
-# traverses directory structure from process work directory to filesystem root
-# first directory with .mvn subdirectory is considered project base directory
-find_maven_basedir() {
-
-  if [ -z "$1" ]
-  then
-    echo "Path not specified to find_maven_basedir"
-    return 1
-  fi
-
-  basedir="$1"
-  wdir="$1"
-  while [ "$wdir" != '/' ] ; do
-    if [ -d "$wdir"/.mvn ] ; then
-      basedir=$wdir
-      break
-    fi
-    # workaround for JBEAP-8937 (on Solaris 10/Sparc)
-    if [ -d "${wdir}" ]; then
-      wdir=`cd "$wdir/.."; pwd`
-    fi
-    # end of workaround
-  done
-  echo "${basedir}"
-}
-
-# concatenates all lines of a file
-concat_lines() {
-  if [ -f "$1" ]; then
-    echo "$(tr -s '\n' ' ' < "$1")"
-  fi
-}
-
-BASE_DIR=`find_maven_basedir "$(pwd)"`
-if [ -z "$BASE_DIR" ]; then
-  exit 1;
-fi
-
-##########################################################################################
-# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
-# This allows using the maven wrapper in projects that prohibit checking in binary data.
-##########################################################################################
-if [ -r "$BASE_DIR/.mvn/wrapper/maven-wrapper.jar" ]; then
-    if [ "$MVNW_VERBOSE" = true ]; then
-      echo "Found .mvn/wrapper/maven-wrapper.jar"
-    fi
-else
-    if [ "$MVNW_VERBOSE" = true ]; then
-      echo "Couldn't find .mvn/wrapper/maven-wrapper.jar, downloading it ..."
-    fi
-    if [ -n "$MVNW_REPOURL" ]; then
-      jarUrl="$MVNW_REPOURL/io/takari/maven-wrapper/0.5.6/maven-wrapper-0.5.6.jar"
-    else
-      jarUrl="https://repo.maven.apache.org/maven2/io/takari/maven-wrapper/0.5.6/maven-wrapper-0.5.6.jar"
-    fi
-    while IFS="=" read key value; do
-      case "$key" in (wrapperUrl) jarUrl="$value"; break ;;
-      esac
-    done < "$BASE_DIR/.mvn/wrapper/maven-wrapper.properties"
-    if [ "$MVNW_VERBOSE" = true ]; then
-      echo "Downloading from: $jarUrl"
-    fi
-    wrapperJarPath="$BASE_DIR/.mvn/wrapper/maven-wrapper.jar"
-    if $cygwin; then
-      wrapperJarPath=`cygpath --path --windows "$wrapperJarPath"`
-    fi
-
-    if command -v wget > /dev/null; then
-        if [ "$MVNW_VERBOSE" = true ]; then
-          echo "Found wget ... using wget"
-        fi
-        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
-            wget "$jarUrl" -O "$wrapperJarPath"
-        else
-            wget --http-user=$MVNW_USERNAME --http-password=$MVNW_PASSWORD "$jarUrl" -O "$wrapperJarPath"
-        fi
-    elif command -v curl > /dev/null; then
-        if [ "$MVNW_VERBOSE" = true ]; then
-          echo "Found curl ... using curl"
-        fi
-        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
-            curl -o "$wrapperJarPath" "$jarUrl" -f
-        else
-            curl --user $MVNW_USERNAME:$MVNW_PASSWORD -o "$wrapperJarPath" "$jarUrl" -f
-        fi
-
-    else
-        if [ "$MVNW_VERBOSE" = true ]; then
-          echo "Falling back to using Java to download"
-        fi
-        javaClass="$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.java"
-        # For Cygwin, switch paths to Windows format before running javac
-        if $cygwin; then
-          javaClass=`cygpath --path --windows "$javaClass"`
-        fi
-        if [ -e "$javaClass" ]; then
-            if [ ! -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
-                if [ "$MVNW_VERBOSE" = true ]; then
-                  echo " - Compiling MavenWrapperDownloader.java ..."
-                fi
-                # Compiling the Java class
-                ("$JAVA_HOME/bin/javac" "$javaClass")
-            fi
-            if [ -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
-                # Running the downloader
-                if [ "$MVNW_VERBOSE" = true ]; then
-                  echo " - Running MavenWrapperDownloader.java ..."
-                fi
-                ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$MAVEN_PROJECTBASEDIR")
-            fi
-        fi
-    fi
-fi
-##########################################################################################
-# End of extension
-##########################################################################################
-
-export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
-if [ "$MVNW_VERBOSE" = true ]; then
-  echo $MAVEN_PROJECTBASEDIR
-fi
-MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin; then
-  [ -n "$M2_HOME" ] &&
-    M2_HOME=`cygpath --path --windows "$M2_HOME"`
-  [ -n "$JAVA_HOME" ] &&
-    JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
-  [ -n "$CLASSPATH" ] &&
-    CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
-  [ -n "$MAVEN_PROJECTBASEDIR" ] &&
-    MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"`
-fi
-
-# Provide a "standardized" way to retrieve the CLI args that will
-# work with both Windows and non-Windows executions.
-MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $@"
-export MAVEN_CMD_LINE_ARGS
-
-WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
-
-exec "$JAVACMD" \
-  $MAVEN_OPTS \
-  -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
-  "-Dmaven.home=${M2_HOME}" "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
-  ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"

mvnw.cmd

@@ -1,182 +0,0 @@
-@REM ----------------------------------------------------------------------------
-@REM Licensed to the Apache Software Foundation (ASF) under one
-@REM or more contributor license agreements.  See the NOTICE file
-@REM distributed with this work for additional information
-@REM regarding copyright ownership.  The ASF licenses this file
-@REM to you under the Apache License, Version 2.0 (the
-@REM "License"); you may not use this file except in compliance
-@REM with the License.  You may obtain a copy of the License at
-@REM
-@REM    http://www.apache.org/licenses/LICENSE-2.0
-@REM
-@REM Unless required by applicable law or agreed to in writing,
-@REM software distributed under the License is distributed on an
-@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-@REM KIND, either express or implied.  See the License for the
-@REM specific language governing permissions and limitations
-@REM under the License.
-@REM ----------------------------------------------------------------------------
-
-@REM ----------------------------------------------------------------------------
-@REM Maven Start Up Batch script
-@REM
-@REM Required ENV vars:
-@REM JAVA_HOME - location of a JDK home dir
-@REM
-@REM Optional ENV vars
-@REM M2_HOME - location of maven2's installed home dir
-@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
-@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
-@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
-@REM     e.g. to debug Maven itself, use
-@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
-@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
-@REM ----------------------------------------------------------------------------
-
-@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
-@echo off
-@REM set title of command window
-title %0
-@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
-@if "%MAVEN_BATCH_ECHO%" == "on"  echo %MAVEN_BATCH_ECHO%
-
-@REM set %HOME% to equivalent of $HOME
-if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
-
-@REM Execute a user defined script before this one
-if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
-@REM check for pre script, once with legacy .bat ending and once with .cmd ending
-if exist "%HOME%\mavenrc_pre.bat" call "%HOME%\mavenrc_pre.bat"
-if exist "%HOME%\mavenrc_pre.cmd" call "%HOME%\mavenrc_pre.cmd"
-:skipRcPre
-
-@setlocal
-
-set ERROR_CODE=0
-
-@REM To isolate internal variables from possible post scripts, we use another setlocal
-@setlocal
-
-@REM ==== START VALIDATION ====
-if not "%JAVA_HOME%" == "" goto OkJHome
-
-echo.
-echo Error: JAVA_HOME not found in your environment. >&2
-echo Please set the JAVA_HOME variable in your environment to match the >&2
-echo location of your Java installation. >&2
-echo.
-goto error
-
-:OkJHome
-if exist "%JAVA_HOME%\bin\java.exe" goto init
-
-echo.
-echo Error: JAVA_HOME is set to an invalid directory. >&2
-echo JAVA_HOME = "%JAVA_HOME%" >&2
-echo Please set the JAVA_HOME variable in your environment to match the >&2
-echo location of your Java installation. >&2
-echo.
-goto error
-
-@REM ==== END VALIDATION ====
-
-:init
-
-@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
-@REM Fallback to current working directory if not found.
-
-set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
-IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
-
-set EXEC_DIR=%CD%
-set WDIR=%EXEC_DIR%
-:findBaseDir
-IF EXIST "%WDIR%"\.mvn goto baseDirFound
-cd ..
-IF "%WDIR%"=="%CD%" goto baseDirNotFound
-set WDIR=%CD%
-goto findBaseDir
-
-:baseDirFound
-set MAVEN_PROJECTBASEDIR=%WDIR%
-cd "%EXEC_DIR%"
-goto endDetectBaseDir
-
-:baseDirNotFound
-set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
-cd "%EXEC_DIR%"
-
-:endDetectBaseDir
-
-IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
-
-@setlocal EnableExtensions EnableDelayedExpansion
-for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
-@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
-
-:endReadAdditionalConfig
-
-SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
-set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
-set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
-
-set DOWNLOAD_URL="https://repo.maven.apache.org/maven2/io/takari/maven-wrapper/0.5.6/maven-wrapper-0.5.6.jar"
-
-FOR /F "tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
-    IF "%%A"=="wrapperUrl" SET DOWNLOAD_URL=%%B
-)
-
-@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
-@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
-if exist %WRAPPER_JAR% (
-    if "%MVNW_VERBOSE%" == "true" (
-        echo Found %WRAPPER_JAR%
-    )
-) else (
-    if not "%MVNW_REPOURL%" == "" (
-        SET DOWNLOAD_URL="%MVNW_REPOURL%/io/takari/maven-wrapper/0.5.6/maven-wrapper-0.5.6.jar"
-    )
-    if "%MVNW_VERBOSE%" == "true" (
-        echo Couldn't find %WRAPPER_JAR%, downloading it ...
-        echo Downloading from: %DOWNLOAD_URL%
-    )
-
-    powershell -Command "&{"^
-		"$webclient = new-object System.Net.WebClient;"^
-		"if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
-		"$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
-		"}"^
-		"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%DOWNLOAD_URL%', '%WRAPPER_JAR%')"^
-		"}"
-    if "%MVNW_VERBOSE%" == "true" (
-        echo Finished downloading %WRAPPER_JAR%
-    )
-)
-@REM End of extension
-
-@REM Provide a "standardized" way to retrieve the CLI args that will
-@REM work with both Windows and non-Windows executions.
-set MAVEN_CMD_LINE_ARGS=%*
-
-%MAVEN_JAVA_EXE% %JVM_CONFIG_MAVEN_PROPS% %MAVEN_OPTS% %MAVEN_DEBUG_OPTS% -classpath %WRAPPER_JAR% "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
-if ERRORLEVEL 1 goto error
-goto end
-
-:error
-set ERROR_CODE=1
-
-:end
-@endlocal & set ERROR_CODE=%ERROR_CODE%
-
-if not "%MAVEN_SKIP_RC%" == "" goto skipRcPost
-@REM check for post script, once with legacy .bat ending and once with .cmd ending
-if exist "%HOME%\mavenrc_post.bat" call "%HOME%\mavenrc_post.bat"
-if exist "%HOME%\mavenrc_post.cmd" call "%HOME%\mavenrc_post.cmd"
-:skipRcPost
-
-@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
-if "%MAVEN_BATCH_PAUSE%" == "on" pause
-
-if "%MAVEN_TERMINATE_CMD%" == "on" exit %ERROR_CODE%
-
-exit /B %ERROR_CODE%

pom.xml

@@ -1,500 +1,230 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
 
-	<modelVersion>4.0.0</modelVersion>
+    <groupId>org.springframework.data</groupId>
+    <artifactId>spring-data-elasticsearch</artifactId>
+    <version>2.0.12.BUILD-SNAPSHOT</version>
 
-	<groupId>org.springframework.data</groupId>
-	<artifactId>spring-data-elasticsearch</artifactId>
-	<version>4.2.7</version>
+    <parent>
+        <groupId>org.springframework.data.build</groupId>
+        <artifactId>spring-data-parent</artifactId>
+        <version>1.8.12.BUILD-SNAPSHOT</version>
+        <relativePath>../spring-data-build/parent/pom.xml</relativePath>
+    </parent>
 
-	<parent>
-		<groupId>org.springframework.data.build</groupId>
-		<artifactId>spring-data-parent</artifactId>
-		<version>2.5.7</version>
-	</parent>
+    <name>Spring Data Elasticsearch</name>
+    <description>Spring Data Implementation for Elasticsearch</description>
+    <url>https://github.com/spring-projects/spring-data-elasticsearch</url>
 
-	<name>Spring Data Elasticsearch</name>
-	<description>Spring Data Implementation for Elasticsearch</description>
-	<url>https://github.com/spring-projects/spring-data-elasticsearch</url>
+    <properties>
 
-	<properties>
-		<commonslang>2.6</commonslang>
-		<elasticsearch>7.12.1</elasticsearch>
-		<log4j>2.13.3</log4j>
-		<netty>4.1.52.Final</netty>
-		<springdata.commons>2.5.7</springdata.commons>
-		<testcontainers>1.15.1</testcontainers>
-		<java-module-name>spring.data.elasticsearch</java-module-name>
-	</properties>
+        <dist.key>DATAES</dist.key>
 
-	<developers>
-		<developer>
-			<id>biomedcentral</id>
-			<name>BioMed Central Development Team</name>
-			<timezone>+0</timezone>
-		</developer>
-		<developer>
-			<id>cstrobl</id>
-			<name>Christoph Strobl</name>
-			<email>cstrobl at pivotal.io</email>
-			<organization>Pivotal</organization>
-			<organizationUrl>https://www.pivotal.io</organizationUrl>
-			<roles>
-				<role>Developer</role>
-			</roles>
-			<timezone>+1</timezone>
-		</developer>
-		<developer>
-			<id>mpaluch</id>
-			<name>Mark Paluch</name>
-			<email>mpaluch at pivotal.io</email>
-			<organization>Pivotal</organization>
-			<organizationUrl>https://www.pivotal.io</organizationUrl>
-			<roles>
-				<role>Developer</role>
-			</roles>
-			<timezone>+1</timezone>
-		</developer>
-	</developers>
+        <commonscollections>3.2.1</commonscollections>
+        <commonslang>2.6</commonslang>
+        <elasticsearch>2.2.0</elasticsearch>
+        <springdata.commons>1.12.12.BUILD-SNAPSHOT</springdata.commons>
 
-	<scm>
-		<url>https://github.com/spring-projects/spring-data-elasticsearch</url>
-		<connection>scm:git:git://github.com/spring-projects/spring-data-elasticsearch.git</connection>
-		<developerConnection>scm:git:ssh://git@github.com/spring-projects/spring-data-elasticsearch.git
-		</developerConnection>
-	</scm>
+    </properties>
 
-	<ciManagement>
-		<system>Bamboo</system>
-		<url>https://build.spring.io/browse/SPRINGDATAES</url>
-	</ciManagement>
+    <dependencies>
 
-	<issueManagement>
-		<system>GitHub</system>
-		<url>https://github.com/spring-projects/spring-data-elasticsearch/issues</url>
-	</issueManagement>
+        <!-- Spring -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+            <exclusions>
+                <exclusion>
+                    <groupId>commons-logging</groupId>
+                    <artifactId>commons-logging</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
 
-	<dependencyManagement>
-		<dependencies>
-			<dependency>
-				<groupId>io.netty</groupId>
-				<artifactId>netty-bom</artifactId>
-				<version>${netty}</version>
-				<type>pom</type>
-				<scope>import</scope>
-			</dependency>
-		</dependencies>
-	</dependencyManagement>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-tx</artifactId>
+        </dependency>
 
-	<dependencies>
+        <!-- SPRING DATA -->
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-commons</artifactId>
+            <version>${springdata.commons}</version>
+        </dependency>
 
-		<!-- Spring -->
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-context</artifactId>
-			<exclusions>
-				<exclusion>
-					<groupId>commons-logging</groupId>
-					<artifactId>commons-logging</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
+        <!-- APACHE -->
+        <dependency>
+            <groupId>commons-lang</groupId>
+            <artifactId>commons-lang</artifactId>
+            <version>${commonslang}</version>
+        </dependency>
 
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-tx</artifactId>
-		</dependency>
+        <!-- JODA Time -->
+        <dependency>
+            <groupId>joda-time</groupId>
+            <artifactId>joda-time</artifactId>
+            <version>${jodatime}</version>
+        </dependency>
 
-		<!-- SPRING DATA -->
-		<dependency>
-			<groupId>org.springframework.data</groupId>
-			<artifactId>spring-data-commons</artifactId>
-			<version>${springdata.commons}</version>
-		</dependency>
+        <!-- Elasticsearch -->
+        <dependency>
+            <groupId>org.elasticsearch</groupId>
+            <artifactId>elasticsearch</artifactId>
+            <version>${elasticsearch}</version>
+        </dependency>
 
-		<!-- Reactive Infrastructure -->
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-webflux</artifactId>
-			<optional>true</optional>
-		</dependency>
+        <!-- Jackson JSON Mapper -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-core</artifactId>
+            <version>${jackson}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>${jackson}</version>
+        </dependency>
 
-		<dependency>
-			<groupId>io.projectreactor.netty</groupId>
-			<artifactId>reactor-netty-http</artifactId>
-			<optional>true</optional>
-		</dependency>
+        <!-- CDI -->
+        <dependency>
+            <groupId>javax.enterprise</groupId>
+            <artifactId>cdi-api</artifactId>
+            <version>${cdi}</version>
+            <scope>provided</scope>
+            <optional>true</optional>
+        </dependency>
 
-		<dependency>
-			<groupId>io.projectreactor</groupId>
-			<artifactId>reactor-test</artifactId>
-			<scope>test</scope>
-		</dependency>
+        <!-- Test -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <version>${spring}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.openwebbeans.test</groupId>
+            <artifactId>cditest-owb</artifactId>
+            <version>${webbeans}</version>
+            <scope>test</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.apache.geronimo.specs</groupId>
+                    <artifactId>geronimo-jcdi_1.0_spec</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.apache.geronimo.specs</groupId>
+                    <artifactId>geronimo-atinject_1.0_spec</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>servlet-api</artifactId>
+            <version>3.0-alpha-1</version>
+            <scope>test</scope>
+        </dependency>
 
-		<!-- APACHE -->
-		<dependency>
-			<groupId>commons-lang</groupId>
-			<artifactId>commons-lang</artifactId>
-			<version>${commonslang}</version>
-			<scope>test</scope>
-		</dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok}</version>
+            <scope>test</scope>
+        </dependency>
 
-		<!-- JODA Time -->
-		<dependency>
-			<groupId>joda-time</groupId>
-			<artifactId>joda-time</artifactId>
-			<version>${jodatime}</version>
-			<optional>true</optional>
-		</dependency>
+    </dependencies>
 
-		<!-- Elasticsearch -->
-		<dependency>
-			<groupId>org.elasticsearch.client</groupId>
-			<artifactId>transport</artifactId>
-			<version>${elasticsearch}</version>
-		</dependency>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>wagon-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.asciidoctor</groupId>
+                <artifactId>asciidoctor-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
 
-		<dependency>
-			<!-- required by elasticsearch -->
-			<groupId>org.elasticsearch.plugin</groupId>
-			<artifactId>transport-netty4-client</artifactId>
-			<version>${elasticsearch}</version>
-		</dependency>
+        <testResources>
+            <testResource>
+                <directory>${basedir}/src/test/resources</directory>
+            </testResource>
+            <testResource>
+                <targetPath>${basedir}/target/test-home-dir</targetPath>
+                <directory>${basedir}/src/test/es-modules/${elasticsearch}</directory>
+                <includes>
+                    <include>**/*</include>
+                </includes>
+            </testResource>
+        </testResources>
+    </build>
 
-		<dependency>
-			<groupId>org.elasticsearch.client</groupId>
-			<artifactId>elasticsearch-rest-high-level-client</artifactId>
-			<version>${elasticsearch}</version>
-			<exclusions>
-				<exclusion>
-					<groupId>commons-logging</groupId>
-					<artifactId>commons-logging</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
+    <profiles>
 
-		<!-- Logging -->
-		<dependency>
-			<groupId>org.slf4j</groupId>
-			<artifactId>log4j-over-slf4j</artifactId>
-			<version>${slf4j}</version>
-			<scope>test</scope>
-		</dependency>
+        <profile>
+            <id>es2.3.3</id>
+            <properties>
+                <elasticsearch>2.3.3</elasticsearch>
+            </properties>
+        </profile>
 
-		<dependency>
-			<groupId>org.apache.logging.log4j</groupId>
-			<artifactId>log4j-core</artifactId>
-			<version>${log4j}</version>
-			<scope>test</scope>
-		</dependency>
+        <profile>
+            <id>release</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.jfrog.buildinfo</groupId>
+                        <artifactId>artifactory-maven-plugin</artifactId>
+                        <inherited>false</inherited>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
 
-		<!-- Jackson JSON Mapper -->
-		<dependency>
-			<groupId>com.fasterxml.jackson.core</groupId>
-			<artifactId>jackson-core</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>com.fasterxml.jackson.core</groupId>
-			<artifactId>jackson-databind</artifactId>
-		</dependency>
+    <developers>
+        <developer>
+            <id>biomedcentral</id>
+            <name>BioMed Central Development Team</name>
+            <timezone>+0</timezone>
+        </developer>
+    </developers>
 
-		<!-- CDI -->
-		<!-- Dependency order required to build against CDI 1.0 and test with CDI 2.0 -->
-		<dependency>
-			<groupId>org.apache.geronimo.specs</groupId>
-			<artifactId>geronimo-jcdi_2.0_spec</artifactId>
-			<version>1.0.1</version>
-			<scope>test</scope>
-		</dependency>
+    <repositories>
+        <repository>
+            <id>spring-libs-snapshot</id>
+            <url>https://repo.spring.io/libs-snapshot</url>
+        </repository>
+    </repositories>
 
-		<dependency>
-			<groupId>javax.interceptor</groupId>
-			<artifactId>javax.interceptor-api</artifactId>
-			<version>1.2.1</version>
-			<scope>test</scope>
-		</dependency>
+    <pluginRepositories>
+        <pluginRepository>
+            <id>spring-plugins-release</id>
+            <url>https://repo.spring.io/plugins-release</url>
+        </pluginRepository>
+    </pluginRepositories>
 
-		<dependency>
-			<groupId>javax.enterprise</groupId>
-			<artifactId>cdi-api</artifactId>
-			<version>${cdi}</version>
-			<scope>provided</scope>
-			<optional>true</optional>
-		</dependency>
+    <scm>
+        <url>https://github.com/spring-projects/spring-data-elasticsearch</url>
+        <connection>scm:git:git://github.com/spring-projects/spring-data-elasticsearch.git</connection>
+        <developerConnection>scm:git:ssh://git@github.com/spring-projects/spring-data-elasticsearch.git
+        </developerConnection>
+    </scm>
 
-		<dependency>
-			<groupId>javax.annotation</groupId>
-			<artifactId>javax.annotation-api</artifactId>
-			<version>${javax-annotation-api}</version>
-			<scope>test</scope>
-		</dependency>
+    <ciManagement>
+        <system>Bamboo</system>
+        <url>https://build.springsource.org/browse/SPRINGDATAES</url>
+    </ciManagement>
 
-		<dependency>
-			<groupId>org.apache.openwebbeans</groupId>
-			<artifactId>openwebbeans-se</artifactId>
-			<version>${webbeans}</version>
-			<scope>test</scope>
-		</dependency>
-
-		<!-- Test -->
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-test</artifactId>
-			<scope>test</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>ch.qos.logback</groupId>
-					<artifactId>logback-classic</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<dependency>
-			<groupId>org.apache.logging.log4j</groupId>
-			<artifactId>log4j-to-slf4j</artifactId>
-			<version>${log4j}</version>
-			<scope>test</scope>
-		</dependency>
-
-		<!--
-		  we don't use lombok in Spring Data Elasticsearch anymore. But the dependency is set in the parent project, and so the
-		  lombok compiler stuff is executed regardless of the fact that we don't need it.
-		  On AdoptOpenJdk 16.0.0 this leads to an error, so the project does not build.
-		  Therefore we replace lombok with a jar - that just contains an empty file - that lives in a local maven repository in
-		  src/test/resources/local-maven-repo/
-		  It was installed with
-		   mvn deploy:deploy-file -DgroupId=org.projectlombok -DartifactId=lombok -Dversion=999999 -Durl=file:./src/test/resources/local-maven-repo/ -DrepositoryId=local-maven-repo -DupdateReleaseInfo=true -Dfile=path/to/empty.jar
-		-->
-		<dependency>
-			<groupId>org.projectlombok</groupId>
-			<artifactId>lombok</artifactId>
-			<version>999999</version>
-			<scope>test</scope>
-		</dependency>
-
-<!--
-		<dependency>
-			<groupId>org.apache.openwebbeans.test</groupId>
-			<artifactId>cditest-owb</artifactId>
-			<version>1.2.8</version>
-			<scope>test</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>org.apache.geronimo.specs</groupId>
-					<artifactId>geronimo-jcdi_1.0_spec</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.apache.geronimo.specs</groupId>
-					<artifactId>geronimo-atinject_1.0_spec</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
--->
-
-		<dependency>
-			<groupId>org.skyscreamer</groupId>
-			<artifactId>jsonassert</artifactId>
-			<version>1.5.0</version>
-			<scope>test</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>com.github.tomakehurst</groupId>
-			<artifactId>wiremock-jre8</artifactId>
-			<version>2.26.3</version>
-			<scope>test</scope>
-			<exclusions>
-				<!-- these exclusions are needed because of Elasticsearch JarHell-->
-				<exclusion>
-					<groupId>commons-logging</groupId>
-					<artifactId>commons-logging</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.ow2.asm</groupId>
-					<artifactId>asm</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-
-		<dependency>
-			<groupId>io.specto</groupId>
-			<artifactId>hoverfly-java-junit5</artifactId>
-			<version>0.13.1</version>
-			<scope>test</scope>
-		</dependency>
-
-		<!-- Upgrade xbean to 4.5 to prevent incompatibilities due to ASM versions -->
-		<dependency>
-			<groupId>org.apache.xbean</groupId>
-			<artifactId>xbean-asm5-shaded</artifactId>
-			<version>4.5</version>
-			<scope>test</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>javax.servlet</groupId>
-			<artifactId>javax.servlet-api</artifactId>
-			<version>3.1.0</version>
-			<scope>test</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.mockito</groupId>
-			<artifactId>mockito-junit-jupiter</artifactId>
-			<version>${mockito}</version>
-			<scope>test</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.testcontainers</groupId>
-			<artifactId>elasticsearch</artifactId>
-			<version>${testcontainers}</version>
-			<scope>test</scope>
-		</dependency>
-
-	</dependencies>
-
-	<build>
-		<resources>
-			<resource>
-				<directory>src/main/resources</directory>
-				<filtering>true</filtering>
-				<includes>
-					<include>**/versions.properties</include>
-				</includes>
-			</resource>
-			<resource>
-				<directory>src/main/resources</directory>
-				<filtering>false</filtering>
-				<excludes>
-					<exclude>**/versions.properties</exclude>
-				</excludes>
-			</resource>
-		</resources>
-
-		<plugins>
-			<!--
-			please do not remove this configuration for surefire - we need that to avoid issue with jar hell
-			-->
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
-				<configuration>
-					<useSystemClassLoader>true</useSystemClassLoader>
-					<useFile>false</useFile>
-					<includes>
-						<include>**/*Tests.java</include>
-						<include>**/*Test.java</include>
-					</includes>
-					<systemPropertyVariables>
-						<es.set.netty.runtime.available.processors>false</es.set.netty.runtime.available.processors>
-					</systemPropertyVariables>
-				</configuration>
-				<executions>
-					<!-- the default-test execution runs only the unit tests -->
-					<execution>
-						<id>default-test</id>
-						<phase>test</phase>
-						<goals>
-							<goal>test</goal>
-						</goals>
-						<configuration>
-							<excludedGroups>integration-test</excludedGroups>
-						</configuration>
-					</execution>
-					<!-- execution to run the integration tests -->
-					<execution>
-						<id>integration-test</id>
-						<phase>integration-test</phase>
-						<goals>
-							<goal>test</goal>
-						</goals>
-						<configuration>
-							<groups>integration-test</groups>
-						</configuration>
-					</execution>
-				</executions>
-			</plugin>
-			<plugin>
-				<groupId>org.pitest</groupId>
-				<artifactId>pitest-maven</artifactId>
-				<version>1.5.2</version>
-				<dependencies>
-					<dependency>
-						<groupId>org.pitest</groupId>
-						<artifactId>pitest-junit5-plugin</artifactId>
-						<version>0.12</version>
-					</dependency>
-				</dependencies>
-				<configuration>
-					<excludedGroups>integration-test</excludedGroups>
-					<targetClasses>
-						<param>org.springframework.data.elasticsearch.core.geo.*</param>
-					</targetClasses>
-					<excludedMethods>toString</excludedMethods>
-				</configuration>
-			</plugin>
-
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-assembly-plugin</artifactId>
-			</plugin>
-			<plugin>
-				<groupId>org.asciidoctor</groupId>
-				<artifactId>asciidoctor-maven-plugin</artifactId>
-			</plugin>
-		</plugins>
-	</build>
-
-	<profiles>
-		<profile>
-
-			<id>ci</id>
-
-			<build>
-				<plugins>
-					<plugin>
-						<groupId>org.apache.maven.plugins</groupId>
-						<artifactId>maven-checkstyle-plugin</artifactId>
-						<configuration>
-							<checkstyleRules>
-								<module name="Checker">
-
-									<!-- Configure checker to use UTF-8 encoding -->
-									<property name="charset" value="UTF-8"/>
-
-									<module name="io.spring.nohttp.checkstyle.check.NoHttpCheck"/>
-								</module>
-							</checkstyleRules>
-							<includes>**/*</includes>
-							<excludes>.git/**/*,target/**/*,**/target/**/*,.idea/**/*,**/spring.schemas,**/*.svg,mvnw,mvnw.cmd,**/*.policy</excludes>
-							<sourceDirectories>./</sourceDirectories>
-						</configuration>
-					</plugin>
-				</plugins>
-			</build>
-
-		</profile>
-
-	</profiles>
-
-	<repositories>
-		<repository>
-			<id>spring-libs-release</id>
-			<url>https://repo.spring.io/libs-release</url>
-		</repository>
-
-		<repository>
-			<id>local-maven-repo</id>
-			<url>file:///${project.basedir}/src/test/resources/local-maven-repo</url>
-		</repository>
-	</repositories>
-
-	<pluginRepositories>
-		<pluginRepository>
-			<id>spring-plugins-release</id>
-			<url>https://repo.spring.io/plugins-release</url>
-		</pluginRepository>
-	</pluginRepositories>
+    <issueManagement>
+        <system>JIRA</system>
+        <url>https://jira.springsource.org/browse/DATAES</url>
+    </issueManagement>
 
 </project>

settings.xml

@@ -1,29 +0,0 @@
-<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
-          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
-                      https://maven.apache.org/xsd/settings-1.0.0.xsd">
-
-	<servers>
-		<server>
-			<id>spring-plugins-release</id>
-			<username>${env.ARTIFACTORY_USR}</username>
-			<password>${env.ARTIFACTORY_PSW}</password>
-		</server>
-		<server>
-			<id>spring-libs-snapshot</id>
-			<username>${env.ARTIFACTORY_USR}</username>
-			<password>${env.ARTIFACTORY_PSW}</password>
-		</server>
-		<server>
-			<id>spring-libs-milestone</id>
-			<username>${env.ARTIFACTORY_USR}</username>
-			<password>${env.ARTIFACTORY_PSW}</password>
-		</server>
-		<server>
-			<id>spring-libs-release</id>
-			<username>${env.ARTIFACTORY_USR}</username>
-			<password>${env.ARTIFACTORY_PSW}</password>
-		</server>
-	</servers>
-
-</settings>

src/main/asciidoc/index.adoc

@@ -1,18 +1,18 @@
-= Spring Data Elasticsearch - Reference Documentation
-BioMed Central Development Team; Oliver Drotbohm; Greg Turnquist; Christoph Strobl; Peter-Josef Meisch
+= Spring Data Elasticsearch
+BioMed Central Development Team
 :revnumber: {version}
 :revdate: {localdate}
-ifdef::backend-epub3[:front-cover-image: image:epub-cover.png[Front Cover,1050,1600]]
+:toc:
+:toc-placement!:
 :spring-data-commons-docs: ../../../../spring-data-commons/src/main/asciidoc
 
-(C) 2013-2021 The original author(s).
+(C) 2013-2015 The original author(s).
 
 NOTE: Copies of this document may be made for your own use and for distribution to others, provided that you do not charge any fee for such copies and further provided that each copy contains this Copyright Notice, whether distributed in print or electronically.
 
 toc::[]
 
 include::preface.adoc[]
-
 :leveloffset: +1
 include::{spring-data-commons-docs}/repositories.adoc[]
 :leveloffset: -1
@@ -21,20 +21,7 @@ include::{spring-data-commons-docs}/repositories.adoc[]
 = Reference Documentation
 
 :leveloffset: +1
-include::reference/elasticsearch-clients.adoc[]
-include::reference/elasticsearch-object-mapping.adoc[]
-include::reference/elasticsearch-operations.adoc[]
-
-include::reference/elasticsearch-repositories.adoc[]
-
-include::{spring-data-commons-docs}/auditing.adoc[]
-include::reference/elasticsearch-auditing.adoc[]
-
-include::{spring-data-commons-docs}/entity-callbacks.adoc[]
-include::reference/elasticsearch-entity-callbacks.adoc[leveloffset=+1]
-
-include::reference/elasticsearch-join-types.adoc[]
-include::reference/elasticsearch-routing.adoc[]
+include::reference/data-elasticsearch.adoc[]
 include::reference/elasticsearch-misc.adoc[]
 :leveloffset: -1
 
@@ -46,5 +33,4 @@ include::{spring-data-commons-docs}/repository-namespace-reference.adoc[]
 include::{spring-data-commons-docs}/repository-populator-namespace-reference.adoc[]
 include::{spring-data-commons-docs}/repository-query-keywords-reference.adoc[]
 include::{spring-data-commons-docs}/repository-query-return-types-reference.adoc[]
-include::reference/migration-guides.adoc[]
 :leveloffset: -1

src/main/asciidoc/preface.adoc

@@ -1,46 +1,20 @@
-[[preface]]
 = Preface
 
-The Spring Data Elasticsearch project applies core Spring concepts to the development of solutions using the Elasticsearch Search Engine.
-It provides:
+The Spring Data Elasticsearch project applies core Spring concepts to the development of solutions using the Elasticsearch Search Engine. We have povided a "template" as a high-level abstraction for storing,querying,sorting and faceting documents. You will notice similarities to the Spring data solr and mongodb support in the Spring Framework.
 
-* _Templates_ as a high-level abstraction for storing, searching, sorting documents and building aggregations.
-* _Repositories_ which for example enable the user to express queries by defining interfaces having customized method names (for basic information about repositories see <<repositories>>).
-
-You will notice similarities to the Spring data solr and mongodb support in the Spring Framework.
-
-include::reference/elasticsearch-new.adoc[leveloffset=+1]
-
-[[preface.metadata]]
+[[project]]
+[preface]
 == Project Metadata
 
 * Version Control - https://github.com/spring-projects/spring-data-elasticsearch
-* API Documentation - https://docs.spring.io/spring-data/elasticsearch/docs/current/api/
-* Bugtracker - https://github.com/spring-projects/spring-data-elasticsearch/issues
+* Bugtracker - https://jira.spring.io/browse/DATAES
 * Release repository - https://repo.spring.io/libs-release
 * Milestone repository - https://repo.spring.io/libs-milestone
 * Snapshot repository - https://repo.spring.io/libs-snapshot
 
-[[preface.requirements]]
+[[requirements]]
+[preface]
 == Requirements
 
-Requires an installation of https://www.elastic.co/products/elasticsearch[Elasticsearch].
+Requires http://www.elasticsearch.org/download/[Elasticsearch] 0.20.2 and above or optional dependency or not even that if you are using Embedded Node Client
 
-[[preface.versions]]
-=== Versions
-
-The following table shows the Elasticsearch versions that are used by Spring Data release trains and version of Spring Data Elasticsearch included in that, as well as the Spring Boot versions referring to that particular Spring Data release train:
-
-[cols="^,^,^,^,^",options="header"]
-|===
-| Spring Data Release Train | Spring Data Elasticsearch | Elasticsearch | Spring Framework | Spring Boot
-| 2021.0 (Pascal) | 4.2.1 | 7.12.1 | 5.3.7 | 2.5.x
-| 2020.0 (Ockham) | 4.1.x | 7.9.3 | 5.3.2 | 2.4.x
-| Neumann | 4.0.x | 7.6.2 | 5.2.12 |2.3.x
-| Moore | 3.2.x |6.8.12 | 5.2.12| 2.2.x
-| Lovelacefootnote:oom[Out of maintenance] | 3.1.xfootnote:oom[] | 6.2.2 | 5.1.19 |2.1.x
-| Kayfootnote:oom[] | 3.0.xfootnote:oom[] | 5.5.0 | 5.0.13 | 2.0.x
-| Ingallsfootnote:oom[] | 2.1.xfootnote:oom[] | 2.4.0 | 4.3.25 | 1.5.x
-|===
-
-Support for upcoming versions of Elasticsearch is being tracked and general compatibility should be given assuming the usage of the <<elasticsearch.clients.rest,high-level REST client>>.

src/main/asciidoc/reference/data-elasticsearch.adoc

@@ -0,0 +1,288 @@
+[[elasticsearch.repositories]]
+= Elasticsearch Repositories
+
+This chapter includes details of the Elasticsearch repository implementation.
+
+[[elasticsearch.introduction]]
+== Introduction
+
+[[elasticsearch.namespace]]
+=== Spring Namespace
+
+The Spring Data Elasticsearch module contains a custom namespace allowing definition of repository beans as well as elements for instantiating a `ElasticsearchServer` .
+
+Using the `repositories` element looks up Spring Data repositories as described in <<repositories.create-instances>> .
+
+.Setting up Elasticsearch repositories using Namespace
+====
+[source,xml]
+----
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
+xsi:schemaLocation="http://www.springframework.org/schema/beans
+http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
+http://www.springframework.org/schema/data/elasticsearch
+http://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch-1.0.xsd">
+
+    <elasticsearch:repositories base-package="com.acme.repositories" />
+    
+</beans>
+----
+====
+
+Using the `Transport Client` or `Node Client` element registers an instance of `Elasticsearch Server` in the context. 
+
+.Transport Client using Namespace
+====
+[source,xml]
+----
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
+xsi:schemaLocation="http://www.springframework.org/schema/beans
+http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
+http://www.springframework.org/schema/data/elasticsearch
+http://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch-1.0.xsd">
+
+    <elasticsearch:transport-client id="client" cluster-nodes="localhost:9300,someip:9300" />
+    
+</beans> 
+----
+====
+
+.Node Client using Namespace
+====
+[source,xml]
+----
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
+xsi:schemaLocation="http://www.springframework.org/schema/beans
+http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
+http://www.springframework.org/schema/data/elasticsearch
+http://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch-1.0.xsd">
+
+    <elasticsearch:node-client id="client" local="true"" />
+    
+</beans> 
+----
+====
+
+[[elasticsearch.annotation]]
+=== Annotation based configuration
+
+The Spring Data Elasticsearch repositories support cannot only be activated through an XML namespace but also using an annotation through JavaConfig.
+
+.Spring Data Elasticsearch repositories using JavaConfig
+====
+[source,java]
+----
+@Configuration
+@EnableElasticsearchRepositories(basePackages = "org/springframework/data/elasticsearch/repositories")
+static class Config {
+
+    @Bean
+    public ElasticsearchOperations elasticsearchTemplate() {
+        return new ElasticsearchTemplate(nodeBuilder().local(true).node().client());
+    }
+}                
+----
+====
+
+The configuration above sets up an `Embedded Elasticsearch Server` which is used by the `ElasticsearchTemplate` . Spring Data Elasticsearch Repositories are activated using the `@EnableElasticsearchRepositories` annotation, which essentially carries the same attributes as the XML namespace does. If no base package is configured, it will use the one the configuration class resides in.
+
+[[elasticsearch.cdi]]
+=== Elasticsearch Repositores using CDI
+
+The Spring Data Elasticsearch repositories can also be set up using CDI functionality.
+
+.Spring Data Elasticsearch repositories using JavaConfig
+====
+[source,java]
+----
+class ElasticsearchTemplateProducer {
+
+    @Produces
+    @ApplicationScoped
+    public ElasticsearchOperations createElasticsearchTemplate() {
+        return new ElasticsearchTemplate(nodeBuilder().local(true).node().client());
+    }
+}
+
+class ProductService {
+
+    private ProductRepository repository;
+
+    public Page<Product> findAvailableBookByName(String name, Pageable pageable) {
+        return repository.findByAvailableTrueAndNameStartingWith(name, pageable);
+    }
+
+    @Inject
+    public void setRepository(ProductRepository repository) {
+        this.repository = repository;
+    }
+}                
+----
+====
+
+[[elasticsearch.query-methods]]
+== Query methods
+
+[[elasticsearch.query-methods.finders]]
+=== Query lookup strategies
+
+The Elasticsearch module supports all basic query building  feature as String,Abstract,Criteria or have it being derived from the method name.
+
+==== Declared queries
+
+Deriving the query from the method name is not always sufficient and/or may result in unreadable method names. In this case one might make either use of `@Query` annotation (see <<elasticsearch.query-methods.at-query>> ).
+
+[[elasticsearch.query-methods.criterions]]
+=== Query creation
+
+Generally the query creation mechanism for Elasticsearch works as described in <<repositories.query-methods>> . Here's a short example of what a Elasticsearch query method translates into: 
+
+.Query creation from method names
+====
+[source,java]
+----
+public interface BookRepository extends Repository<Book, String>
+{
+    List<Book> findByNameAndPrice(String name, Integer price);
+}                
+----
+====
+
+The method name above will be translated into the following Elasticsearch json query
+
+[source]
+----
+{ "bool" :
+    { "must" :
+        [
+            { "field" : {"name" : "?"} },
+            { "field" : {"price" : "?"} }
+        ] 
+    }
+}                    
+----
+
+A list of supported keywords for Elasticsearch is shown below. 
+
+[cols="1,2,3", options="header"]
+.Supported keywords inside method names
+|===
+| Keyword
+| Sample
+| Elasticsearch Query String| `And`
+| `findByNameAndPrice`
+| `{"bool" : {"must" : [ {"field" : {"name" : "?"}},
+                                        {"field" : {"price" : "?"}} ]}}`
+
+| `Or`
+| `findByNameOrPrice`
+| `{"bool" : {"should" : [ {"field" : {"name" : "?"}},
+                                        {"field" : {"price" : "?"}} ]}}`
+
+| `Is`
+| `findByName`
+| `{"bool" : {"must" : {"field" : {"name" : "?"}}}}`
+
+| `Not`
+| `findByNameNot`
+| `{"bool" : {"must_not" : {"field" : {"name" : "?"}}}}`
+
+| `Between`
+| `findByPriceBetween`
+| `{"bool" : {"must" : {"range" : {"price" : {"from" :
+                                        ?,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}`
+
+| `LessThanEqual`
+| `findByPriceLessThan`
+| `{"bool" : {"must" : {"range" : {"price" : {"from" :
+                                        null,"to" : ?,"include_lower" : true,"include_upper" :
+                                        true}}}}}`
+
+| `GreaterThanEqual`
+| `findByPriceGreaterThan`
+| `{"bool" : {"must" : {"range" : {"price" : {"from" :
+                                        ?,"to" : null,"include_lower" : true,"include_upper" :
+                                        true}}}}}`
+
+| `Before`
+| `findByPriceBefore`
+| `{"bool" : {"must" : {"range" : {"price" : {"from" :
+                                        null,"to" : ?,"include_lower" : true,"include_upper" :
+                                        true}}}}}`
+
+| `After`
+| `findByPriceAfter`
+| `{"bool" : {"must" : {"range" : {"price" : {"from" :
+                                        ?,"to" : null,"include_lower" : true,"include_upper" :
+                                        true}}}}}`
+
+| `Like`
+| `findByNameLike`
+| `{"bool" : {"must" : {"field" : {"name" : {"query" :
+                                        "?*","analyze_wildcard" : true}}}}}`
+
+| `StartingWith`
+| `findByNameStartingWith`
+| `{"bool" : {"must" : {"field" : {"name" : {"query" :
+                                        "?*","analyze_wildcard" : true}}}}}`
+
+| `EndingWith`
+| `findByNameEndingWith`
+| `{"bool" : {"must" : {"field" : {"name" : {"query" :
+                                        "*?","analyze_wildcard" : true}}}}}`
+
+| `Contains/Containing`
+| `findByNameContaining`
+| `{"bool" : {"must" : {"field" : {"name" : {"query" :
+                                        "*?*","analyze_wildcard" : true}}}}}`
+
+| `In`
+| `findByNameIn(Collection<String>names)`
+| `{"bool" : {"must" : {"bool" : {"should" : [ {"field" :
+                                        {"name" : "?"}}, {"field" : {"name" : "?"}} ]}}}}`
+
+| `NotIn`
+| `findByNameNotIn(Collection<String>names)`
+| `{"bool" : {"must_not" : {"bool" : {"should" : {"field" :
+                                        {"name" : "?"}}}}}}`
+
+| `Near`
+| `findByStoreNear`
+| `Not Supported Yet !`
+
+| `True`
+| `findByAvailableTrue`
+| `{"bool" : {"must" : {"field" : {"available" : true}}}}`
+
+| `False`
+| `findByAvailableFalse`
+| `{"bool" : {"must" : {"field" : {"available" : false}}}}`
+
+| `OrderBy`
+| `findByAvailableTrueOrderByNameDesc`
+| `{"sort" : [{ "name" : {"order" : "desc"} }],"bool" :
+                                        {"must" : {"field" : {"available" : true}}}}`
+|===
+
+[[elasticsearch.query-methods.at-query]]
+=== Using @Query Annotation
+
+.Declare query at the method using the `@Query` annotation.
+====
+[source,java]
+----
+public interface BookRepository extends ElasticsearchRepository<Book, String> {
+    @Query("{"bool" : {"must" : {"field" : {"name" : "?0"}}}}")
+    Page<Book> findByName(String name,Pageable pageable);
+}                
+----
+====

src/main/asciidoc/reference/elasticsearch-auditing.adoc

@@ -1,83 +0,0 @@
-[[elasticsearch.auditing]]
-== Elasticsearch Auditing
-
-=== Preparing entities
-
-In order for the auditing code to be able to decide whether an entity instance is new, the entity must implement the `Persistable<ID>` interface which is defined as follows:
-
-[source,java]
-----
-package org.springframework.data.domain;
-
-import org.springframework.lang.Nullable;
-
-public interface Persistable<ID> {
-    @Nullable
-    ID getId();
-
-    boolean isNew();
-}
-----
-
-As the existence of an Id is not a sufficient criterion to determine if an enitity is new in Elasticsearch, additional information is necessary. One way is to use the creation-relevant auditing fields for this decision:
-
-A `Person` entity might look as follows - omitting getter and setter methods for brevity:
-
-[source,java]
-----
-@Document(indexName = "person")
-public class Person implements Persistable<Long> {
-    @Id private Long id;
-    private String lastName;
-    private String firstName;
-    @CreatedDate
-    @Field(type = FieldType.Date, format = DateFormat.basic_date_time)
-    private Instant createdDate;
-    @CreatedBy
-    private String createdBy
-    @Field(type = FieldType.Date, format = DateFormat.basic_date_time)
-    @LastModifiedDate
-    private Instant lastModifiedDate;
-    @LastModifiedBy
-    private String lastModifiedBy;
-
-    public Long getId() {                                                 // <.>
-        return id;
-    }
-
-    @Override
-    public boolean isNew() {
-        return id == null || (createdDate == null && createdBy == null);  // <.>
-    }
-}
-----
-<.> the getter is the required implementation from the interface
-<.> an object is new if it either has no `id` or none of fields containing creation attributes are set.
-
-=== Activating auditing
-
-After the entities have been set up and providing the `AuditorAware` - or `ReactiveAuditorAware` - the Auditing must be activated by setting the `@EnableElasticsearchAuditing` on a configuration class:
-
-[source,java]
-----
-@Configuration
-@EnableElasticsearchRepositories
-@EnableElasticsearchAuditing
-class MyConfiguration {
-   // configuration code
-}
-----
-
-When using the reactive stack this must be:
-[source,java]
-----
-@Configuration
-@EnableReactiveElasticsearchRepositories
-@EnableReactiveElasticsearchAuditing
-class MyConfiguration {
-   // configuration code
-}
-----
-
-If your code contains more than one `AuditorAware` bean for different types, you must provide the name of the bean to use as an argument to the `auditorAwareRef` parameter of the 
- `@EnableElasticsearchAuditing` annotation. 

src/main/asciidoc/reference/elasticsearch-clients.adoc

@@ -1,205 +0,0 @@
-[[elasticsearch.clients]]
-= Elasticsearch Clients
-
-This chapter illustrates configuration and usage of supported Elasticsearch client implementations.
-
-Spring Data Elasticsearch operates upon an Elasticsearch client that is connected to a single Elasticsearch node or a cluster. Although the Elasticsearch Client can be used to work with the cluster, applications using Spring Data Elasticsearch normally use the higher level abstractions of <<elasticsearch.operations>> and <<elasticsearch.repositories>>.
-
-[[elasticsearch.clients.transport]]
-== Transport Client
-
-WARNING: The `TransportClient` is deprecated as of Elasticsearch 7 and will be removed in Elasticsearch 8. (https://www.elastic.co/guide/en/elasticsearch/client/java-api/current/transport-client.html[see the Elasticsearch documentation]). Spring Data Elasticsearch will support the `TransportClient` as long as it is available in the used
-Elasticsearch <<elasticsearch.versions,version>> but has deprecated the classes using it since version 4.0.
-
-We strongly recommend to use the <<elasticsearch.clients.rest>> instead of the `TransportClient`.
-
-.Transport Client
-====
-[source,java]
-----
-@Configuration
-public class TransportClientConfig extends ElasticsearchConfigurationSupport {
-
-    @Bean
-    public Client elasticsearchClient() throws UnknownHostException {
-        Settings settings = Settings.builder().put("cluster.name", "elasticsearch").build();        <.>
-        TransportClient client = new PreBuiltTransportClient(settings);
-        client.addTransportAddress(new TransportAddress(InetAddress.getByName("127.0.0.1"), 9300)); <.>
-        return client;
-    }
-
-    @Bean(name = { "elasticsearchOperations", "elasticsearchTemplate" })
-    public ElasticsearchTemplate elasticsearchTemplate() throws UnknownHostException {
-
-		ElasticsearchTemplate template = new ElasticsearchTemplate(elasticsearchClient, elasticsearchConverter);
-		template.setRefreshPolicy(refreshPolicy());                                                 <.>
-
-		return template;
-    }
-}
-
-// ...
-
-IndexRequest request = new IndexRequest("spring-data")
- .id(randomID())
- .source(someObject);
-
-IndexResponse response = client.index(request);
-----
-<.> The `TransportClient` must be configured with the cluster name.
-<.> The host and port to connect the client to.
-<.> the RefreshPolicy must be set in the `ElasticsearchTemplate` (override `refreshPolicy()` to not use the default)
-====
-
-[[elasticsearch.clients.rest]]
-== High Level REST Client
-
-The Java High Level REST Client is the default client of Elasticsearch, it provides a straight forward replacement for the `TransportClient` as it accepts and returns
-the very same request/response objects and therefore depends on the Elasticsearch core project.
-Asynchronous calls are operated upon a client managed thread pool and require a callback to be notified when the request is done.
-
-.High Level REST Client
-====
-[source,java]
-----
-@Configuration
-public class RestClientConfig extends AbstractElasticsearchConfiguration {
-
-    @Override
-    @Bean
-    public RestHighLevelClient elasticsearchClient() {
-
-        final ClientConfiguration clientConfiguration = ClientConfiguration.builder()  <1>
-            .connectedTo("localhost:9200")
-            .build();
-
-        return RestClients.create(clientConfiguration).rest();                         <2>
-    }
-}
-
-// ...
-
-  @Autowired
-  RestHighLevelClient highLevelClient;
-
-  RestClient lowLevelClient = highLevelClient.lowLevelClient();                        <3>
-
-// ...
-
-IndexRequest request = new IndexRequest("spring-data")
-  .id(randomID())
-  .source(singletonMap("feature", "high-level-rest-client"))
-  .setRefreshPolicy(IMMEDIATE);
-
-IndexResponse response = highLevelClient.index(request,RequestOptions.DEFAULT);
-----
-<1> Use the builder to provide cluster addresses, set default `HttpHeaders` or enable SSL.
-<2> Create the RestHighLevelClient.
-<3> It is also possible to obtain the `lowLevelRest()` client.
-====
-
-[[elasticsearch.clients.reactive]]
-== Reactive Client
-
-The `ReactiveElasticsearchClient` is a non official driver based on `WebClient`.
-It uses the request/response objects provided by the Elasticsearch core project.
-Calls are directly operated on the reactive stack, **not** wrapping async (thread pool bound) responses into reactive types.
-
-.Reactive REST Client
-====
-[source,java]
-----
-@Configuration
-public class ReactiveRestClientConfig extends AbstractReactiveElasticsearchConfiguration {
-
-    @Override
-    @Bean
-    public ReactiveElasticsearchClient reactiveElasticsearchClient() {
-        final ClientConfiguration clientConfiguration = ClientConfiguration.builder() <.>
-            .connectedTo("localhost:9200") //
-            .build();
-        return ReactiveRestClients.create(clientConfiguration);
-
-    }
-}
-// ...
-
-Mono<IndexResponse> response = client.index(request ->
-
-  request.index("spring-data")
-    .id(randomID())
-    .source(singletonMap("feature", "reactive-client"));
-);
-----
-<.> Use the builder to provide cluster addresses, set default `HttpHeaders` or enable SSL.
-====
-
-NOTE: The ReactiveClient response, especially for search operations, is bound to the `from` (offset) & `size` (limit) options of the request.
-
-[[elasticsearch.clients.configuration]]
-== Client Configuration
-
-Client behaviour can be changed via the `ClientConfiguration` that allows to set options for SSL, connect and socket timeouts, headers and other parameters.
-
-.Client Configuration
-====
-[source,java]
-----
-HttpHeaders httpHeaders = new HttpHeaders();
-httpHeaders.add("some-header", "on every request")                      <.>
-
-ClientConfiguration clientConfiguration = ClientConfiguration.builder()
-  .connectedTo("localhost:9200", "localhost:9291")                      <.>
-  .usingSsl()                                                           <.>
-  .withProxy("localhost:8888")                                          <.>
-  .withPathPrefix("ela")                                                <.>
-  .withConnectTimeout(Duration.ofSeconds(5))                            <.>
-  .withSocketTimeout(Duration.ofSeconds(3))                             <.>
-  .withDefaultHeaders(defaultHeaders)                                   <.>
-  .withBasicAuth(username, password)                                    <.>
-  .withHeaders(() -> {                                                  <.>
-    HttpHeaders headers = new HttpHeaders();
-    headers.add("currentTime", LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
-    return headers;
-  })
-  .withWebClientConfigurer(webClient -> {                               <.>
-    //...
-    return webClient;
-  })
-  .withHttpClientConfigurer(clientBuilder -> {                          <.>
-      //...
-      return clientBuilder;
-  })
-  . // ... other options
-  .build();
-
-----
-<.> Define default headers, if they need to be customized
-<.> Use the builder to provide cluster addresses, set default `HttpHeaders` or enable SSL.
-<.> Optionally enable SSL.
-<.> Optionally set a proxy.
-<.> Optionally set a path prefix, mostly used when different clusters a behind some reverse proxy.
-<.> Set the connection timeout. Default is 10 sec.
-<.> Set the socket timeout. Default is 5 sec.
-<.> Optionally set headers.
-<.> Add basic authentication.
-<.> A `Supplier<Header>` function can be specified which is called every time before a request is sent to Elasticsearch - here, as an example, the current time is written in a header.
-<.> for reactive setup a function configuring the `WebClient`
-<.> for non-reactive setup a function configuring the REST client
-====
-
-IMPORTANT: Adding a Header supplier as shown in above example allows to inject headers that may change over the time, like authentication JWT tokens. If this is used in the reactive setup, the supplier function *must not* block!
-
-[[elasticsearch.clients.logging]]
-== Client Logging
-
-To see what is actually sent to and received from the server `Request` / `Response` logging on the transport level needs
-to be turned on as outlined in the snippet below.
-
-.Enable transport layer logging
-[source,xml]
-----
-<logger name="org.springframework.data.elasticsearch.client.WIRE" level="trace"/>
-----
-
-NOTE: The above applies to both the `RestHighLevelClient` and `ReactiveElasticsearchClient` when obtained via `RestClients` respectively `ReactiveRestClients`, is not available for the `TransportClient`.

src/main/asciidoc/reference/elasticsearch-entity-callbacks.adoc

@@ -1,35 +0,0 @@
-[[elasticsearch.entity-callbacks]]
-= Elasticsearch EntityCallbacks
-
-Spring Data Elasticsearch uses the `EntityCallback` API internally for its auditing support and reacts on the following callbacks:
-
-.Supported Entity Callbacks
-[%header,cols="4"]
-|===
-| Callback
-| Method
-| Description
-| Order
-
-| Reactive/BeforeConvertCallback
-| `onBeforeConvert(T entity, IndexCoordinates index)`
-| Invoked before a domain object is converted to `org.springframework.data.elasticsearch.core.document.Document`. Can return the `entity` or a modified entity which then will be converted.
-| `Ordered.LOWEST_PRECEDENCE`
-
-| Reactive/AfterConvertCallback
-| `onAfterConvert(T entity, Document document, IndexCoordinates indexCoordinates)`
-| Invoked after a domain object is converted from `org.springframework.data.elasticsearch.core.document.Document` on reading result data from Elasticsearch.
-| `Ordered.LOWEST_PRECEDENCE`
-
-| Reactive/AuditingEntityCallback
-| `onBeforeConvert(Object entity, IndexCoordinates index)`
-| Marks an auditable entity _created_ or _modified_
-| 100
-
-| Reactive/AfterSaveCallback
-| `T onAfterSave(T entity, IndexCoordinates index)`
-| Invoked after a domain object is saved.
-| `Ordered.LOWEST_PRECEDENCE`
-
-|===
-

src/main/asciidoc/reference/elasticsearch-join-types.adoc

@@ -1,229 +0,0 @@
-[[elasticsearch.jointype]]
-= Join-Type implementation
-
-Spring Data Elasticsearch supports the https://www.elastic.co/guide/en/elasticsearch/reference/current/parent-join.html[Join data type] for creating the corresponding index mappings and for storing the relevant information.
-
-== Setting up the data
-
-For an entity to be used in a parent child join relationship, it must have a property of type `JoinField` which must be annotated.
-Let's assume a `Statement` entity where a statement may be a _question_, an _answer_, a _comment_ or a _vote_ (a _Builder_ is also shown in this example, it's not necessary, but later used in the sample code):
-
-====
-[source,java]
-----
-@Document(indexName = "statements")
-@Routing("routing")                                                                       <.>
-public class Statement {
-    @Id
-    private String id;
-
-    @Field(type = FieldType.Text)
-    private String text;
-
-    @Field(type = FieldType.Keyword)
-    private String routing;
-
-    @JoinTypeRelations(
-        relations =
-            {
-                @JoinTypeRelation(parent = "question", children = {"answer", "comment"}), <.>
-                @JoinTypeRelation(parent = "answer", children = "vote")                   <.>
-            }
-    )
-    private JoinField<String> relation;                                                   <.>
-
-    private Statement() {
-    }
-
-    public static StatementBuilder builder() {
-        return new StatementBuilder();
-    }
-
-    public String getId() {
-        return id;
-    }
-
-    public void setId(String id) {
-        this.id = id;
-    }
-
-    public String getRouting() {
-        return routing;
-    }
-
-    public void setRouting(Routing routing) {
-        this.routing = routing;
-    }
-
-    public String getText() {
-        return text;
-    }
-
-    public void setText(String text) {
-        this.text = text;
-    }
-
-    public JoinField<String> getRelation() {
-        return relation;
-    }
-
-    public void setRelation(JoinField<String> relation) {
-        this.relation = relation;
-    }
-
-    public static final class StatementBuilder {
-        private String id;
-        private String text;
-        private String routing;
-        private JoinField<String> relation;
-
-        private StatementBuilder() {
-        }
-
-        public StatementBuilder withId(String id) {
-            this.id = id;
-            return this;
-        }
-
-        public StatementBuilder withRouting(String routing) {
-            this.routing = routing;
-            return this;
-        }
-
-        public StatementBuilder withText(String text) {
-            this.text = text;
-            return this;
-        }
-
-        public StatementBuilder withRelation(JoinField<String> relation) {
-            this.relation = relation;
-            return this;
-        }
-
-        public Statement build() {
-            Statement statement = new Statement();
-            statement.setId(id);
-            statement.setRouting(routing);
-            statement.setText(text);
-            statement.setRelation(relation);
-            return statement;
-        }
-    }
-}
-----
-<.> for routing related info see <<elasticsearch.routing>>
-<.> a question can have answers and comments
-<.> an answer can have votes
-<.> the `JoinField` property is used to combine the name (_question_, _answer_, _comment_ or _vote_) of the relation with the parent id.
-The generic type must be the same as the `@Id` annotated property.
-====
-
-Spring Data Elasticsearch will build the following mapping for this class:
-
-====
-[source,json]
-----
-{
-  "statements": {
-    "mappings": {
-      "properties": {
-        "_class": {
-          "type": "text",
-          "fields": {
-            "keyword": {
-              "type": "keyword",
-              "ignore_above": 256
-            }
-          }
-        },
-        "routing": {
-          "type": "keyword"
-        },
-        "relation": {
-          "type": "join",
-          "eager_global_ordinals": true,
-          "relations": {
-            "question": [
-              "answer",
-              "comment"
-            ],
-            "answer": "vote"
-          }
-        },
-        "text": {
-          "type": "text"
-        }
-      }
-    }
-  }
-}
-----
-====
-
-==  Storing data
-
-Given a repository for this class the following code inserts a question, two answers, a comment and a vote:
-
-====
-[source,java]
-----
-void init() {
-    repository.deleteAll();
-
-    Statement savedWeather = repository.save(
-        Statement.builder()
-            .withText("How is the weather?")
-            .withRelation(new JoinField<>("question"))                          <1>
-            .build());
-
-    Statement sunnyAnswer = repository.save(
-        Statement.builder()
-            .withText("sunny")
-            .withRelation(new JoinField<>("answer", savedWeather.getId()))      <2>
-            .build());
-
-    repository.save(
-        Statement.builder()
-            .withText("rainy")
-            .withRelation(new JoinField<>("answer", savedWeather.getId()))      <3>
-            .build());
-
-    repository.save(
-        Statement.builder()
-            .withText("I don't like the rain")
-            .withRelation(new JoinField<>("comment", savedWeather.getId()))     <4>
-            .build());
-
-    repository.save(
-        Statement.builder()
-            .withText("+1 for the sun")
-            ,withRouting(savedWeather.getId())
-            .withRelation(new JoinField<>("vote", sunnyAnswer.getId()))         <5>
-            .build());
-}
-----
-<1> create a question statement
-<2> the first answer to the question
-<3> the second answer
-<4> a comment to the question
-<5> a vote for the first answer, this needs to have the routing set to the weather document, see <<elasticsearch.routing>>.
-====
-
-==  Retrieving data
-
-Currently native search queries must be used to query the data, so there is no support from standard repository methods. <<repositories.custom-implementations>> can be used instead.
-
-The following code shows as an example how to retrieve all entries that have a _vote_ (which must be _answers_, because only answers can have a vote) using an `ElasticsearchOperations` instance:
-
-====
-[source,java]
-----
-SearchHits<Statement> hasVotes() {
-    NativeSearchQuery query = new NativeSearchQueryBuilder()
-        .withQuery(hasChildQuery("vote", matchAllQuery(), ScoreMode.None))
-        .build();
-
-    return operations.search(query, Statement.class);
-}
-----
-====

src/main/asciidoc/reference/elasticsearch-migration-guide-3.2-4.0.adoc

@@ -1,133 +0,0 @@
-[[elasticsearch-migration-guide-3.2-4.0]]
-= Upgrading from 3.2.x to 4.0.x
-
-This section describes breaking changes from version 3.2.x to 4.0.x and how removed features can be replaced by new introduced features.
-
-[[elasticsearch-migration-guide-3.2-4.0.jackson-removal]]
-== Removal of the used Jackson Mapper
-
-One of the changes in version 4.0.x is that Spring Data Elasticsearch does not use the Jackson Mapper anymore to map an entity to the JSON representation needed for Elasticsearch (see <<elasticsearch.mapping>>). In version 3.2.x the Jackson Mapper was the default that was used. It was possible to switch to the meta-model based converter (named `ElasticsearchEntityMapper`) by explicitly configuring it (<<elasticsearch.mapping.meta-model>>).
-
-In version 4.0.x the meta-model based converter is the only one that is available and does not need to be configured explicitly. If you had a custom configuration to enable the meta-model converter by providing a bean like this:
-
-[source,java]
-----
-@Bean
-@Override
-public EntityMapper entityMapper() {
-
-  ElasticsearchEntityMapper entityMapper = new ElasticsearchEntityMapper(
-    elasticsearchMappingContext(), new DefaultConversionService()
-  );
-  entityMapper.setConversions(elasticsearchCustomConversions());
-
-  return entityMapper;
-}
-----
-
-You now have to remove this bean, the `ElasticsearchEntityMapper` interface has been removed.
-
-.Entity configuration
-Some users had custom Jackson annotations on the entity class, for example in order to define a custom name for the mapped document in Elasticsearch or to configure date conversions. These are not taken into account anymore. The needed functionality is now provided with Spring Data Elasticsearch's `@Field` annotation. Please see <<elasticsearch.mapping.meta-model.annotations>> for detailed information.
-
-[[elasticsearch-migration-guide-3.2-4.0.implicit-index-name]]
-== Removal of implicit index name from query objects
-
-In 3.2.x the different query classes like `IndexQuery` or `SearchQuery` had properties that were taking the index name or index names that they were operating upon. If these were not set, the passed in entity was inspected to retrieve the index name that was set in the `@Document` annotation. +
-In 4.0.x the index name(s) must now be provided in an additional parameter of type `IndexCoordinates`. By separating this, it now is possible to use one query object against different indices.
-
-So for example the following code:
-
-[source,java]
-----
-IndexQuery indexQuery = new IndexQueryBuilder()
-  .withId(person.getId().toString())
-  .withObject(person)
-  .build();
-
-String documentId = elasticsearchOperations.index(indexQuery);
-----
-
-must be changed to:
-
-[source,java]
-----
-IndexCoordinates indexCoordinates = elasticsearchOperations.getIndexCoordinatesFor(person.getClass());
-
-IndexQuery indexQuery = new IndexQueryBuilder()
-  .withId(person.getId().toString())
-  .withObject(person)
-  .build();
-
-String documentId = elasticsearchOperations.index(indexQuery, indexCoordinates);
-----
-
-To make it easier to work with entities and use the index name that is contained in the entitie's `@Document` annotation, new methods have been added like `DocumentOperations.save(T entity)`;
-
-[[elasticsearch-migration-guide-3.2-4.0.new-operations]]
-== The new Operations interfaces
-
-In version 3.2 there was the `ElasticsearchOperations` interface that defined all the methods for the `ElasticsearchTemplate` class. In version 4 the functions have been split into different interfaces, aligning these interfaces with the Elasticsearch API:
-
-* `DocumentOperations` are the functions related documents like saving, or deleting
-* `SearchOperations` contains the functions to search in Elasticsearch
-* `IndexOperations` define the functions to operate on indexes, like index creation or mappings creation.
-
-`ElasticsearchOperations` now extends `DocumentOperations` and `SearchOperations` and has methods get access to an `IndexOperations` instance.
-
-NOTE: All the functions from the `ElasticsearchOperations` interface in version 3.2 that are now moved to the `IndexOperations` interface are still available, they are marked as deprecated and have default implementations that delegate to the new implementation:
-
-[source,java]
-----
-/**
- * Create an index for given indexName.
- *
- * @param indexName the name of the index
- * @return {@literal true} if the index was created
- * @deprecated since 4.0, use {@link IndexOperations#create()}
- */
-@Deprecated
-default boolean createIndex(String indexName) {
-	return indexOps(IndexCoordinates.of(indexName)).create();
-}
-----
-
-[[elasticsearch-migration-guide-3.2-4.0.deprecations]]
-== Deprecations
-
-=== Methods and classes
-
-Many functions and classes have been deprecated. These functions still work, but the Javadocs show with what they should be replaced.
-
-.Example from ElasticsearchOperations
-[source,java]
-----
-/*
- * Retrieves an object from an index.
- *
- * @param query the query defining the id of the object to get
- * @param clazz the type of the object to be returned
- * @return the found object
- * @deprecated since 4.0, use {@link #get(String, Class, IndexCoordinates)}
- */
-@Deprecated
-@Nullable
-<T> T queryForObject(GetQuery query, Class<T> clazz);
-----
-
-=== Elasticsearch deprecations
-
-Since version 7 the Elasticsearch `TransportClient` is deprecated, it will be removed with Elasticsearch version 8. Spring Data Elasticsearch deprecates the `ElasticsearchTemplate` class which uses the `TransportClient` in version 4.0.
-
-Mapping types were removed from Elasticsearch 7, they still exist as deprecated values in the Spring Data `@Document` annotation and the `IndexCoordinates` class but they are not used anymore internally.
-
-[[elasticsearch-migration-guide-3.2-4.0.removal]]
-== Removals
-
-* As already described, the `ElasticsearchEntityMapper` interface has been removed.
-
-* The `SearchQuery` interface has been merged into it's base interface `Query`, so it's occurrences can just be replaced with `Query`.
-
-* The method `org.springframework.data.elasticsearch.core.ElasticsearchOperations.query(SearchQuery query, ResultsExtractor<T> resultsExtractor);` and the `org.springframework.data.elasticsearch.core.ResultsExtractor` interface have been removed. These could be used to parse the result from Elasticsearch for cases in which the response mapping done with the Jackson based mapper was not enough. Since version 4.0, there are the new <<elasticsearch.operations.searchresulttypes>>  to return the information from an Elasticsearch response, so there is no need to expose this low level functionality.
-
-* The low level methods `startScroll`, `continueScroll` and `clearScroll` have been removed from the `ElasticsearchOperations` interface. For low level scroll API access, there now are `searchScrollStart`, `searchScrollContinue` and `searchScrollClear` methods on the `ElasticsearchRestTemplate` class.

src/main/asciidoc/reference/elasticsearch-migration-guide-4.0-4.1.adoc

@@ -1,46 +0,0 @@
-[[elasticsearch-migration-guide-4.0-4.1]]
-= Upgrading from 4.0.x to 4.1.x
-
-This section describes breaking changes from version 4.0.x to 4.1.x and how removed features can be replaced by new introduced features.
-
-[[elasticsearch-migration-guide-4.0-4.1.deprecations]]
-== Deprecations
-
-.Definition of the id property
-It is possible to define a property of en entity as the id property by naming it either `id` or  `document`.
-This behaviour is now deprecated and will produce a warning.
-PLease us the `@Id` annotation to mark a property as being the id property.
-
-.Index mappings
-In the `ReactiveElasticsearchClient.Indices` interface the `updateMapping` methods are deprecated in favour of the `putMapping` methods.
-They do the same, but `putMapping` is consistent with the naming in the Elasticsearch API:
-
-.Alias handling
-In the `IndexOperations` interface the methods `addAlias(AliasQuery)`, `removeAlias(AliasQuery)` and `queryForAlias()` have been deprecated.
-The new methods `alias(AliasAction)`, `getAliases(String...)` and `getAliasesForIndex(String...)` offer more functionality and a cleaner API.
-
-.Parent-ID
-Usage of a parent-id has been removed from Elasticsearch since version 6. We now deprecate the corresponding fields and methods.
-
-[[elasticsearch-migration-guide-4.0-4.1.removal]]
-== Removals
-
-.Type mappings
-The _type mappings_ parameters of the `@Document` annotation and the `IndexCoordinates` object were removed.
-They had been deprecated in Spring Data Elasticsearch 4.0 and their values weren't used anymore.
-
-[[elasticsearch-migration-guide-4.0-4.1.breaking-changes]]
-== Breaking Changes
-
-=== Return types of ReactiveElasticsearchClient.Indices methods
-
-The methods in the `ReactiveElasticsearchClient.Indices` were not used up to now.
-With the introduction of the `ReactiveIndexOperations` it became necessary to change some of the return types:
-
-* the `createIndex`  variants now return a `Mono<Boolean>` instead of a `Mono<Void>` to signal successful index creation.
-* the `updateMapping`  variants now return a `Mono<Boolean>` instead of a `Mono<Void>` to signal successful mappings storage.
-
-=== Return types of DocumentOperartions.bulkIndex methods
-
-These methods were returing a `List<String>` containing the ids of the new indexed records.
-Now they return a `List<IndexedObjectInformation>`; these objects contain the id and information about optimistic locking (seq_no and primary_term)

src/main/asciidoc/reference/elasticsearch-migration-guide-4.1-4.2.adoc

@@ -1,66 +0,0 @@
-[[elasticsearch-migration-guide-4.1-4.2]]
-= Upgrading from 4.1.x to 4.2.x
-
-This section describes breaking changes from version 4.1.x to 4.2.x and how removed features can be replaced by new introduced features.
-
-[[elasticsearch-migration-guide-4.1-4.2.deprecations]]
-== Deprecations
-
-=== @Document parameters
-
-The parameters of the `@Document` annotation that are relevant for  the index settings (`useServerConfiguration`, `shards`. `replicas`, `refreshIntervall` and `indexStoretype`) have been moved to the `@Setting` annotation. Use in `@Document` is still possible but deprecated.
-
-[[elasticsearch-migration-guide-4.1-4.2.removal]]
-== Removals
-
-The `@Score` annotation that was used to set the score return value in an entity was deprecated in version 4.0 and has been removed.
-Scroe values are returned in the `SearchHit` instances that encapsulate the returned entities.
-
-The `org.springframework.data.elasticsearch.ElasticsearchException` class has been removed.
-The remaining usages have been replaced with `org.springframework.data.mapping.MappingException` and `org.springframework.dao.InvalidDataAccessApiUsageException`.
-
-The deprecated `ScoredPage`, `ScrolledPage` `@AggregatedPage` and implementations has been removed.
-
-The deprecated `GetQuery` and `DeleteQuery` have been removed.
-
-The deprecated `find` methods from `ReactiveSearchOperations` and `ReactiveDocumentOperations` have been removed.
-
-[[elasticsearch-migration-guide-4.1-4.2.breaking-changes]]
-== Breaking Changes
-
-=== RefreshPolicy
-
-==== Enum package changed
-
-It was possible in 4.1 to configure the refresh policy for the `ReactiveElasticsearchTemplate` by overriding the method `AbstractReactiveElasticsearchConfiguration.refreshPolicy()` in a custom configuration class.
-The return value of this method was an instance of the class `org.elasticsearch.action.support.WriteRequest.RefreshPolicy`.
-
-Now the configuration must return `org.springframework.data.elasticsearch.core.RefreshPolicy`.
-This enum has the same values and triggers the same behaviour as before, so only the `import` statement has to be adjusted.
-
-==== Refresh behaviour
-
-`ElasticsearchOperations` and `ReactiveElasticsearchOperations` now explicitly use the `RefreshPolicy` set on the template for write requests if not null.
-If the refresh policy is null, then nothing special is done, so the cluster defaults are used. `ElasticsearchOperations` was always using the cluster default before this version.
-
-The provided implementations for `ElasticsearchRepository` and `ReactiveElasticsearchRepository` will do an explicit refresh when the refresh policy is null.
-This is the same behaviour as in previous versions.
-If a refresh policy is set, then it will be used by the repositories as well.
-
-==== Refresh configuration
-
-When configuring Spring Data Elasticsearch like described in <<elasticsearch.clients>> by using `ElasticsearchConfigurationSupport`, `AbstractElasticsearchConfiguration` or `AbstractReactiveElasticsearchConfiguration` the refresh policy will be initialized to `null`.
-Previously the reactive code initialized this to `IMMEDIATE`, now reactive and non-reactive code show the same behaviour.
-
-=== Method return types
-
-==== delete methods that take a Query
-
-The reactive methods previously returned a `Mono<Long>` with the number of deleted documents, the non reactive versions were void. They now return a `Mono<ByQueryResponse>` which contains much more detailed information about the deleted documents and errors that might have occurred.
-
-==== multiget methods
-
-The implementations of _multiget_ previousl only returned the found entities in a `List<T>` for non-reactive implementations and in a `Flux<T>` for reactive implementations. If the request contained ids that were not found, the information that these are missing was not available. The user needed to compare the returned ids to the requested ones to find
-which ones were missing.
-
-Now the `multiget` methods return a `MultiGetItem` for every requested id. This contains information about failures (like non existing indices) and the information if the item existed (then it is contained in the `MultiGetItem) or not.

src/main/asciidoc/reference/elasticsearch-misc.adoc

@@ -1,50 +1,7 @@
 [[elasticsearch.misc]]
 = Miscellaneous Elasticsearch Operation Support
 
-This chapter covers additional support for Elasticsearch operations that cannot be directly accessed via the repository interface.
-It is recommended to add those operations as custom implementation as described in <<repositories.custom-implementations>> .
-
-[[elasticsearc.misc.index.settings]]
-== Index settings
-
-When creating Elasticsearch indices with Spring Data Elasticsearch different index settings can be defined by using the `@Setting` annotation. The following arguments are available:
-
-* `useServerConfiguration` does not send any settings parameters, so the Elasticsearch server configuration determines them.
-* `settingPath` refers to a JSON file defining the settings that must be resolvable in the classpath
-* `shards` the number of shards to use, defaults to _1_
-* `replicas` the number of replicas, defaults to _1_
-* `refreshIntervall`, defaults to _"1s"_
-* `indexStoreType`, defaults to _"fs"_
-
-
-It is as well possible to define https://www.elastic.co/guide/en/elasticsearch/reference/7.11/index-modules-index-sorting.html[index sorting] (check the linked Elasticsearch documentation for the possible field types and values):
-
-====
-[source,java]
-----
-@Document(indexName = "entities")
-@Setting(
-  sortFields = { "secondField", "firstField" },                                  <.>
-  sortModes = { Setting.SortMode.max, Setting.SortMode.min },                    <.>
-  sortOrders = { Setting.SortOrder.desc, Setting.SortOrder.asc },
-  sortMissingValues = { Setting.SortMissing._last, Setting.SortMissing._first })
-class Entity {
-    @Nullable
-    @Id private String id;
-
-    @Nullable
-    @Field(name = "first_field", type = FieldType.Keyword)
-    private String firstField;
-
-    @Nullable @Field(name = "second_field", type = FieldType.Keyword)
-    private String secondField;
-
-    // getter and setter...
-}
-----
-<.> when defining sort fields, use the name of the Java property (_firstField_), not the name that might be defined for Elasticsearch (_first_field_)
-<.> `sortModes`, `sortOrders` and `sortMissingValues` are optional, but if they are set, the number of entries must match the number of `sortFields` elements
-====
+This chapter covers additional support for Elasticsearch operations that cannot be directly accessed via the repository interface. It is recommended to add those operations as custom implementation as described in <<repositories.custom-implementations>> .
 
 [[elasticsearch.misc.filter]]
 == Filter Builder
@@ -54,100 +11,62 @@ Filter Builder improves query speed.
 ====
 [source,java]
 ----
-private ElasticsearchOperations operations;
-
-IndexCoordinates index = IndexCoordinates.of("sample-index");
+private ElasticsearchTemplate elasticsearchTemplate;
 
 SearchQuery searchQuery = new NativeSearchQueryBuilder()
-  .withQuery(matchAllQuery())
-  .withFilter(boolFilter().must(termFilter("id", documentId)))
-  .build();
-
-Page<SampleEntity> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
+    .withQuery(matchAllQuery())
+    .withFilter(boolFilter().must(termFilter("id", documentId)))
+    .build();
+    
+Page<SampleEntity> sampleEntities =
+    elasticsearchTemplate.queryForPage(searchQuery,SampleEntity.class);            
 ----
 ====
 
-[[elasticsearch.scroll]]
-== Using Scroll For Big Result Set
+[[elasticsearch.scan.and.scroll]]
+== Using Scan And Scroll For Big Result Set
 
-Elasticsearch has a scroll API for getting big result set in chunks.
-This is internally used by Spring Data Elasticsearch to provide the implementations of the `<T> SearchHitsIterator<T> SearchOperations.searchForStream(Query query, Class<T> clazz, IndexCoordinates index)` method.
+Elasticsearch has scan and scroll feature for getting big result set in chunks. `ElasticsearchTemplate` has scan and scroll methods that can be used as below.
 
+.Using Scan and Scroll
 ====
 [source,java]
 ----
-IndexCoordinates index = IndexCoordinates.of("sample-index");
-
 SearchQuery searchQuery = new NativeSearchQueryBuilder()
-  .withQuery(matchAllQuery())
-  .withFields("message")
-  .withPageable(PageRequest.of(0, 10))
-  .build();
-
-SearchHitsIterator<SampleEntity> stream = elasticsearchTemplate.searchForStream(searchQuery, SampleEntity.class, index);
-
-List<SampleEntity> sampleEntities = new ArrayList<>();
-while (stream.hasNext()) {
-  sampleEntities.add(stream.next());
-}
-
-stream.close();
-----
-====
-
-There are no methods in the `SearchOperations` API to access the scroll id, if it should be necessary to access this, the following methods of the `ElasticsearchRestTemplate` can be used:
-
-====
-[source,java]
-----
-
-@Autowired ElasticsearchRestTemplate template;
-
-IndexCoordinates index = IndexCoordinates.of("sample-index");
-
-SearchQuery searchQuery = new NativeSearchQueryBuilder()
-  .withQuery(matchAllQuery())
-  .withFields("message")
-  .withPageable(PageRequest.of(0, 10))
-  .build();
-
-SearchScrollHits<SampleEntity> scroll = template.searchScrollStart(1000, searchQuery, SampleEntity.class, index);
-
-String scrollId = scroll.getScrollId();
-List<SampleEntity> sampleEntities = new ArrayList<>();
-while (scroll.hasSearchHits()) {
-  sampleEntities.addAll(scroll.getSearchHits());
-  scrollId = scroll.getScrollId();
-  scroll = template.searchScrollContinue(scrollId, 1000, SampleEntity.class);
-}
-template.searchScrollClear(scrollId);
-----
-====
-
-To use the Scroll API with repository methods, the return type must defined as `Stream` in the Elasticsearch Repository.
-The implementation of the method will then use the scroll methods from the ElasticsearchTemplate.
-
-====
-[source,java]
-----
-interface SampleEntityRepository extends Repository<SampleEntity, String> {
-
-    Stream<SampleEntity> findBy();
-
-}
-----
-====
-
-[[elasticsearch.misc.sorts]]
-== Sort options
-
-In addition to the default sort options described <<repositories.paging-and-sorting>> Spring Data Elasticsearch has a `GeoDistanceOrder` class which can be used to have the result of a search operation ordered by geographical distance.
-
-If the class to be retrieved has a `GeoPoint` property named _location_, the following `Sort` would sort the results by distance to the given point:
-
-====
-[source,java]
-----
-Sort.by(new GeoDistanceOrder("location", new GeoPoint(48.137154, 11.5761247)))
+    .withQuery(matchAllQuery())
+    .withIndices("test-index")
+    .withTypes("test-type")
+    .withPageable(new PageRequest(0,1))
+    .build();
+String scrollId = elasticsearchTemplate.scan(searchQuery,1000,false);
+List<SampleEntity> sampleEntities = new ArrayList<SampleEntity>();
+boolean hasRecords = true;
+while (hasRecords){
+    Page<SampleEntity> page = elasticsearchTemplate.scroll(scrollId, 5000L , new ResultsMapper<SampleEntity>()
+    {
+        @Override
+        public Page<SampleEntity> mapResults(SearchResponse response) {
+            List<SampleEntity> chunk = new ArrayList<SampleEntity>();
+            for(SearchHit searchHit : response.getHits()){
+                if(response.getHits().getHits().length <= 0) {
+                    return null;
+                }
+                SampleEntity user = new SampleEntity();
+                user.setId(searchHit.getId());
+                user.setMessage((String)searchHit.getSource().get("message"));
+                chunk.add(user);
+            }
+            return new PageImpl<SampleEntity>(chunk);
+        }
+    });
+    if(page != null) {
+        sampleEntities.addAll(page.getContent());
+        hasRecords = page.hasNextPage();
+    }
+    else{
+        hasRecords = false;
+    }
+    }
+}            
 ----
 ====

src/main/asciidoc/reference/elasticsearch-new.adoc

@@ -1,44 +0,0 @@
-[[new-features]]
-= What's new
-
-[[new-features.4-2-0]]
-== New in Spring Data Elasticsearch 4.2
-
-* Upgrade to Elasticsearch 7.10.0.
-* Support for custom routing values
-
-[[new-features.4-1-0]]
-== New in Spring Data Elasticsearch 4.1
-
-* Uses Spring 5.3.
-* Upgrade to Elasticsearch 7.9.3.
-* Improved API for alias management.
-* Introduction of `ReactiveIndexOperations` for index management.
-* Index templates support.
-* Support for Geo-shape data with GeoJson.
-
-[[new-features.4-0-0]]
-== New in Spring Data Elasticsearch 4.0
-
-* Uses Spring 5.2.
-* Upgrade to Elasticsearch 7.6.2.
-* Deprecation of `TransportClient` usage.
-* Implements most of the mapping-types available for the index mappings.
-* Removal of the Jackson `ObjectMapper`, now using the <<elasticsearch.mapping.meta-model,MappingElasticsearchConverter>>
-* Cleanup of the API in the `*Operations` interfaces, grouping and renaming methods so that they match the Elasticsearch API, deprecating the old methods, aligning with other Spring Data modules.
-* Introduction of `SearchHit<T>` class to represent a found document together with the relevant result metadata for this document (i.e. _sortValues_).
-* Introduction of the `SearchHits<T>` class to represent a whole search result together with the metadata for the complete search result (i.e. _max_score_).
-* Introduction of `SearchPage<T>` class to represent a paged result containing a `SearchHits<T>` instance.
-* Introduction of the `GeoDistanceOrder` class to be able to create sorting by geographical distance
-* Implementation of Auditing Support
-* Implementation of lifecycle entity callbacks
-
-[[new-features.3-2-0]]
-== New in Spring Data Elasticsearch 3.2
-
-* Secured Elasticsearch cluster support with Basic Authentication and SSL transport.
-* Upgrade to Elasticsearch 6.8.1.
-* Reactive programming support with <<elasticsearch.reactive.operations>> and <<elasticsearch.reactive.repositories>>.
-* Introduction of the <<elasticsearch.mapping.meta-model,ElasticsearchEntityMapper>> as an alternative to the Jackson `ObjectMapper`.
-* Field name customization in `@Field`.
-* Support for Delete by Query.

src/main/asciidoc/reference/elasticsearch-object-mapping.adoc

@@ -1,361 +0,0 @@
-[[elasticsearch.mapping]]
-= Elasticsearch Object Mapping
-
-Spring Data Elasticsearch Object Mapping is the process that maps a Java object - the domain entity - into the JSON representation that is stored in Elasticsearch and back.
-
-Earlier versions of Spring Data Elasticsearch used a Jackson based conversion, Spring Data Elasticsearch 3.2.x introduced the <<elasticsearch.mapping.meta-model>>.
-As of version 4.0 only the Meta Object Mapping is used, the Jackson based mapper is not available anymore and the `MappingElasticsearchConverter` is used.
-
-The main reasons for the removal of the Jackson based mapper are:
-
-* Custom mappings of fields needed to be done with annotations like `@JsonFormat` or `@JsonInclude`.
-This often caused problems when the same object was used in different JSON based datastores or sent over a JSON based API.
-* Custom field types and formats also need to be stored into the Elasticsearch index mappings.
-The Jackson based annotations did not fully provide all the information that is necessary to represent the types of Elasticsearch.
-* Fields must be mapped not only when converting from and to entities, but also in query argument, returned data and on other places.
-
-Using the `MappingElasticsearchConverter` now covers all these cases.
-
-[[elasticsearch.mapping.meta-model]]
-== Meta Model Object Mapping
-
-The Metamodel based approach uses domain type information for reading/writing from/to Elasticsearch.
-This allows to register `Converter` instances for specific domain type mapping.
-
-[[elasticsearch.mapping.meta-model.annotations]]
-=== Mapping Annotation Overview
-
-The `MappingElasticsearchConverter` uses metadata to drive the mapping of objects to documents.
-The metadata is taken from the entity's properties which can be annotated.
-
-The following annotations are available:
-
-* `@Document`: Applied at the class level to indicate this class is a candidate for mapping to the database.
-The most important attributes are:
-** `indexName`: the name of the index to store this entity in.
-This can contain a SpEL template expression like `"log-#{T(java.time.LocalDate).now().toString()}"`
-** `type`: [line-through]#the mapping type.
-If not set, the lowercased simple name of the class is used.# (deprecated since version 4.0)
-** `createIndex`: flag whether to create an index on repository bootstrapping.
-Default value is _true_.
-See <<elasticsearch.repositories.autocreation>>
-** `versionType`: Configuration of version management.
-Default value is _EXTERNAL_.
-
-* `@Id`: Applied at the field level to mark the field used for identity purpose.
-* `@Transient`: By default all fields are mapped to the document when it is stored or retrieved, this annotation excludes the field.
-* `@PersistenceConstructor`: Marks a given constructor - even a package protected one - to use when instantiating the object from the database.
-Constructor arguments are mapped by name to the key values in the retrieved Document.
-* `@Field`: Applied at the field level and defines properties of the field, most of the attributes map to the respective https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping.html[Elasticsearch Mapping] definitions (the following list is not complete, check the annotation Javadoc for a complete reference):
-** `name`: The name of the field as it will be represented in the Elasticsearch document, if not set, the Java field name is used.
-** `type`: The field type, can be one of _Text, Keyword, Long, Integer, Short, Byte, Double, Float, Half_Float, Scaled_Float, Date, Date_Nanos, Boolean, Binary, Integer_Range, Float_Range, Long_Range, Double_Range, Date_Range, Ip_Range, Object, Nested, Ip, TokenCount, Percolator, Flattened, Search_As_You_Type_.
-See https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-types.html[Elasticsearch Mapping Types]
-** `format`: One or more built-in date formats, see the next section <<elasticsearch.mapping.meta-model.date-formats>>.
-** `pattern`: One or more custom date formats, see the next section <<elasticsearch.mapping.meta-model.date-formats>>.
-** `store`: Flag whether the original field value should be store in Elasticsearch, default value is _false_.
-** `analyzer`, `searchAnalyzer`, `normalizer` for specifying custom analyzers and normalizer.
-* `@GeoPoint`: Marks a field as _geo_point_ datatype.
-Can be omitted if the field is an instance of the `GeoPoint` class.
-
-The mapping metadata infrastructure is defined in a separate spring-data-commons project that is technology agnostic.
-
-[[elasticsearch.mapping.meta-model.date-formats]]
-==== Date format mapping
-
-Properties that derive from `TemporalAccessor` or are of type `java.util.Date` must either have a `@Field` annotation
-of type `FieldType.Date` or a custom converter must be registered for this type. This paragraph describes the use of
-`FieldType.Date`.
-
-There are two attributes of the `@Field` annotation that define which date format information is written to the
-mapping (also see https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-date-format.html#built-in-date-formats[Elasticsearch Built In Formats] and https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-date-format.html#custom-date-formats[Elasticsearch Custom Date Formats])
-
-The `format` attributes is used to define at least one of the predefined formats. If it is not defined, then a
-default value of  __date_optional_time_ and _epoch_millis_ is used.
-
-The `pattern` attribute can be used to add additional custom format strings. If you want to use only custom date formats, you must set the `format` property to empty `{}`.
-
-The following table shows the different attributes and the mapping created from their values:
-
-
-[cols=2*,options=header]
-|===
-| annotation
-| format string in Elasticsearch mapping
-
-| @Field(type=FieldType.Date)
-| "date_optional_time\|\|epoch_millis",
-
-| @Field(type=FieldType.Date, format=DateFormat.basic_date)
-| "basic_date"
-
-| @Field(type=FieldType.Date, format={DateFormat.basic_date, DateFormat.basic_time})
-| "basic_date\|\|basic_time"
-
-| @Field(type=FieldType.Date, pattern="dd.MM.uuuu")
-| "date_optional_time\|\|epoch_millis\|\|dd.MM.uuuu",
-
-| @Field(type=FieldType.Date, format={}, pattern="dd.MM.uuuu")
-| "dd.MM.uuuu"
-
-|===
-
-NOTE: If you are using a custom date format, you need to use _uuuu_ for the year instead of _yyyy_.
-This is due to a https://www.elastic.co/guide/en/elasticsearch/reference/current/migrate-to-java-time.html#java-time-migration-incompatible-date-formats[change in Elasticsearch 7].
-
-==== Mapped field names
-
-Without further configuration, Spring Data Elasticsearch will use the property name of an object as field name in Elasticsearch. This can be changed for individual field by using the `@Field` annotation on that property.
-
-It is also possible to define a `FieldNamingStrategy` in the configuration of the client (<<elasticsearch.clients>>). If for example a `SnakeCaseFieldNamingStrategy` is configured, the property _sampleProperty_ of the object would be mapped to _sample_property_ in Elasticsearch. A `FieldNamingStrategy` applies to all entities; it can be overwritten by
-setting a specific name with `@Field` on a property.
-
-[[elasticsearch.mapping.meta-model.rules]]
-=== Mapping Rules
-
-==== Type Hints
-
-Mapping uses _type hints_ embedded in the document sent to the server to allow generic type mapping.
-Those type hints are represented as `_class` attributes within the document and are written for each aggregate root.
-
-.Type Hints
-====
-[source,java]
-----
-public class Person {              <1>
-
-  @Id String id;
-  String firstname;
-  String lastname;
-}
-----
-
-[source,json]
-----
-{
-  "_class" : "com.example.Person", <1>
-  "id" : "cb7bef",
-  "firstname" : "Sarah",
-  "lastname" : "Connor"
-}
-----
-<1> By default the domain types class name is used for the type hint.
-====
-
-Type hints can be configured to hold custom information.
-Use the `@TypeAlias` annotation to do so.
-
-NOTE: Make sure to add types with `@TypeAlias` to the initial entity set (`AbstractElasticsearchConfiguration#getInitialEntitySet`) to already have entity information available when first reading data from the store.
-
-.Type Hints with Alias
-====
-[source,java]
-----
-@TypeAlias("human")                <1>
-public class Person {
-
-  @Id String id;
-  // ...
-}
-----
-
-[source,json]
-----
-{
-  "_class" : "human",              <1>
-  "id" : ...
-}
-----
-<1> The configured alias is used when writing the entity.
-====
-
-NOTE: Type hints will not be written for nested Objects unless the properties type is `Object`, an interface or the actual value type does not match the properties declaration.
-
-==== Geospatial Types
-
-Geospatial types like `Point` & `GeoPoint` are converted into _lat/lon_ pairs.
-
-.Geospatial types
-====
-[source,java]
-----
-public class Address {
-
-  String city, street;
-  Point location;
-}
-----
-
-[source,json]
-----
-{
-  "city" : "Los Angeles",
-  "street" : "2800 East Observatory Road",
-  "location" : { "lat" : 34.118347, "lon" : -118.3026284 }
-}
-----
-====
-
-==== GeoJson Types
-
-Spring Data Elasticsearch supports the GeoJson types by providing an interface `GeoJson` and implementations for the different geometries.
-They are mapped to Elasticsearch documents according to the GeoJson specification.
-The corresponding properties of the entity are specified in the index mappings as `geo_shape` when the index mappings is written. (check the https://www.elastic.co/guide/en/elasticsearch/reference/current/geo-shape.html[Elasticsearch documentation] as well)
-
-.GeoJson types
-====
-[source,java]
-----
-public class Address {
-
-  String city, street;
-  GeoJsonPoint location;
-}
-----
-
-[source,json]
-----
-{
-  "city": "Los Angeles",
-  "street": "2800 East Observatory Road",
-  "location": {
-    "type": "Point",
-    "coordinates": [-118.3026284, 34.118347]
-  }
-}
-----
-====
-
-The following GeoJson types are implemented:
-
-* `GeoJsonPoint`
-* `GeoJsonMultiPoint`
-* `GeoJsonLineString`
-* `GeoJsonMultiLineString`
-* `GeoJsonPolygon`
-* `GeoJsonMultiPolygon`
-* `GeoJsonGeometryCollection`
-
-==== Collections
-
-For values inside Collections apply the same mapping rules as for aggregate roots when it comes to _type hints_ and <<elasticsearch.mapping.meta-model.conversions>>.
-
-.Collections
-====
-[source,java]
-----
-public class Person {
-
-  // ...
-
-  List<Person> friends;
-
-}
-----
-
-[source,json]
-----
-{
-  // ...
-
-  "friends" : [ { "firstname" : "Kyle", "lastname" : "Reese" } ]
-}
-----
-====
-
-==== Maps
-
-For values inside Maps apply the same mapping rules as for aggregate roots when it comes to _type hints_ and <<elasticsearch.mapping.meta-model.conversions>>.
-However the Map key needs to a String to be processed by Elasticsearch.
-
-.Collections
-====
-[source,java]
-----
-public class Person {
-
-  // ...
-
-  Map<String, Address> knownLocations;
-
-}
-----
-
-[source,json]
-----
-{
-  // ...
-
-  "knownLocations" : {
-    "arrivedAt" : {
-       "city" : "Los Angeles",
-       "street" : "2800 East Observatory Road",
-       "location" : { "lat" : 34.118347, "lon" : -118.3026284 }
-     }
-  }
-}
-----
-====
-
-[[elasticsearch.mapping.meta-model.conversions]]
-=== Custom Conversions
-
-Looking at the `Configuration` from the <<elasticsearch.mapping.meta-model, previous section>> `ElasticsearchCustomConversions` allows registering specific rules for mapping domain and simple types.
-
-.Meta Model Object Mapping Configuration
-====
-[source,java]
-----
-@Configuration
-public class Config extends AbstractElasticsearchConfiguration {
-
-  @Override
-  public RestHighLevelClient elasticsearchClient() {
-    return RestClients.create(ClientConfiguration.create("localhost:9200")).rest();
-  }
-
-  @Bean
-  @Override
-  public ElasticsearchCustomConversions elasticsearchCustomConversions() {
-    return new ElasticsearchCustomConversions(
-      Arrays.asList(new AddressToMap(), new MapToAddress()));       <1>
-  }
-
-  @WritingConverter                                                 <2>
-  static class AddressToMap implements Converter<Address, Map<String, Object>> {
-
-    @Override
-    public Map<String, Object> convert(Address source) {
-
-      LinkedHashMap<String, Object> target = new LinkedHashMap<>();
-      target.put("ciudad", source.getCity());
-      // ...
-
-      return target;
-    }
-  }
-
-  @ReadingConverter                                                 <3>
-  static class MapToAddress implements Converter<Map<String, Object>, Address> {
-
-    @Override
-    public Address convert(Map<String, Object> source) {
-
-      // ...
-      return address;
-    }
-  }
-}
-----
-
-[source,json]
-----
-{
-  "ciudad" : "Los Angeles",
-  "calle" : "2800 East Observatory Road",
-  "localidad" : { "lat" : 34.118347, "lon" : -118.3026284 }
-}
-----
-<1> Add `Converter` implementations.
-<2> Set up the `Converter` used for writing `DomainType` to Elasticsearch.
-<3> Set up the `Converter` used for reading `DomainType` from search result.
-====

src/main/asciidoc/reference/elasticsearch-operations.adoc

@@ -1,285 +0,0 @@
-[[elasticsearch.operations]]
-= Elasticsearch Operations
-
-Spring Data Elasticsearch uses several interfaces to define the operations that can be called against an Elasticsearch index (for a description of the reactive interfaces see <<elasticsearch.reactive.operations>>).
-
-* `IndexOperations` defines actions on index level like creating or deleting an index.
-* `DocumentOperations` defines actions to store, update and retrieve entities based on their id.
-* `SearchOperations` define the actions to search for multiple entities using queries
-* `ElasticsearchOperations` combines the `DocumentOperations` and `SearchOperations` interfaces.
-
-These interfaces correspond to the structuring of the https://www.elastic.co/guide/en/elasticsearch/reference/current/rest-apis.html[Elasticsearch API].
-
-The default implementations of the interfaces offer:
-
-* index management functionality.
-* Read/Write mapping support for domain types.
-* A rich query and criteria api.
-* Resource management and Exception translation.
-
-[NOTE]
-====
-.Index management and automatic creation of indices and mappings.
-
-The `IndexOperations` interface and the provided implementation which can be obtained from an `ElasticsearchOperations` instance - for example with a call to `operations.indexOps(clazz)`- give the user the ability to create indices, put mappings or store template and alias information in the Elasticsearch cluster. Details of the index that will be created
-can be set by using the `@Setting` annotation, refer to <<elasticsearc.misc.index.settings>> for further information.
-
-**None of these operations are done automatically** by the implementations of `IndexOperations` or `ElasticsearchOperations`. It is the user's responsibility to call the methods.
-
-There is support for automatic creation of indices and writing the mappings when using Spring Data Elasticsearch repositories, see <<elasticsearch.repositories.autocreation>>
-
-====
-
-[[elasticsearch.operations.template]]
-== ElasticsearchTemplate
-
-NOTE: Usage of the ElasticsearchTemplate is deprecated as of version 4.0, use ElasticsearchRestTemplate instead.
-
-The `ElasticsearchTemplate` is an implementation of the `ElasticsearchOperations` interface using the <<elasticsearch.clients.transport>>.
-
-.ElasticsearchTemplate configuration
-====
-[source,java]
-----
-@Configuration
-public class TransportClientConfig extends ElasticsearchConfigurationSupport {
-
-  @Bean
-  public Client elasticsearchClient() throws UnknownHostException {                 <1>
-    Settings settings = Settings.builder().put("cluster.name", "elasticsearch").build();
-    TransportClient client = new PreBuiltTransportClient(settings);
-    client.addTransportAddress(new TransportAddress(InetAddress.getByName("127.0.0.1"), 9300));
-    return client;
-  }
-
-  @Bean(name = {"elasticsearchOperations", "elasticsearchTemplate"})
-  public ElasticsearchTemplate elasticsearchTemplate() throws UnknownHostException { <2>
-  	return new ElasticsearchTemplate(elasticsearchClient());
-  }
-}
-----
-<1> Setting up the <<elasticsearch.clients.transport>>.
-Deprecated as of version 4.0.
-<2> Creating the `ElasticsearchTemplate` bean, offering both names, _elasticsearchOperations_ and _elasticsearchTemplate_.
-====
-
-[[elasticsearch.operations.resttemplate]]
-== ElasticsearchRestTemplate
-
-The `ElasticsearchRestTemplate` is an implementation of the `ElasticsearchOperations` interface using the <<elasticsearch.clients.rest>>.
-
-.ElasticsearchRestTemplate configuration
-====
-[source,java]
-----
-@Configuration
-public class RestClientConfig extends AbstractElasticsearchConfiguration {
-  @Override
-  public RestHighLevelClient elasticsearchClient() {       <1>
-    return RestClients.create(ClientConfiguration.localhost()).rest();
-  }
-
-  // no special bean creation needed                       <2>
-}
-----
-<1> Setting up the <<elasticsearch.clients.rest>>.
-<2> The base class `AbstractElasticsearchConfiguration` already provides the `elasticsearchTemplate` bean.
-====
-
-[[elasticsearch.operations.usage]]
-== Usage examples
-
-As both `ElasticsearchTemplate` and `ElasticsearchRestTemplate` implement the `ElasticsearchOperations` interface, the code to use them is not different.
-The example shows how to use an injected `ElasticsearchOperations` instance in a Spring REST controller.
-The decision, if this is using the `TransportClient` or the `RestClient` is made by providing the corresponding Bean with one of the configurations shown above.
-
-.ElasticsearchOperations usage
-====
-[source,java]
-----
-@RestController
-@RequestMapping("/")
-public class TestController {
-
-  private  ElasticsearchOperations elasticsearchOperations;
-
-  public TestController(ElasticsearchOperations elasticsearchOperations) { <1>
-    this.elasticsearchOperations = elasticsearchOperations;
-  }
-
-  @PostMapping("/person")
-  public String save(@RequestBody Person person) {                         <2>
-
-    IndexQuery indexQuery = new IndexQueryBuilder()
-      .withId(person.getId().toString())
-      .withObject(person)
-      .build();
-    String documentId = elasticsearchOperations.index(indexQuery);
-    return documentId;
-  }
-
-  @GetMapping("/person/{id}")
-  public Person findById(@PathVariable("id")  Long id) {                   <3>
-    Person person = elasticsearchOperations
-      .queryForObject(GetQuery.getById(id.toString()), Person.class);
-    return person;
-  }
-}
-
-----
-<1> Let Spring inject the provided `ElasticsearchOperations` bean in the constructor.
-<2> Store some entity in the Elasticsearch cluster.
-<3> Retrieve the entity with a query by id.
-====
-
-To see the full possibilities of `ElasticsearchOperations` please refer to the API documentation.
-
-include::reactive-elasticsearch-operations.adoc[leveloffset=+1]
-
-[[elasticsearch.operations.searchresulttypes]]
-== Search Result Types
-
-When a document is retrieved with the methods of the  `DocumentOperations` interface, just the found entity will be returned.
-When searching with the methods of the `SearchOperations` interface, additional information is available for each entity, for example the _score_ or the _sortValues_ of the found entity.
-
-In order to return this information, each entity is wrapped in a `SearchHit` object that contains this entity-specific additional information.
-These `SearchHit` objects themselves are returned within a `SearchHits` object which additionally contains informations about the whole search like the _maxScore_ or requested aggregations.
-The following classes and interfaces are now available:
-
-.SearchHit<T>
-Contains the following information:
-
-* Id
-* Score
-* Sort Values
-* Highlight fields
-* Inner hits (this is an embedded `SearchHits` object containing eventually returned inner hits)
-* The retrieved entity of type <T>
-
-.SearchHits<T>
-Contains the following information:
-
-* Number of total hits
-* Total hits relation
-* Maximum score
-* A list of `SearchHit<T>` objects
-* Returned aggregations
-
-.SearchPage<T>
-Defines a Spring Data `Page` that contains a `SearchHits<T>` element and can be used for paging access using repository methods.
-
-.SearchScrollHits<T>
-Returned by the low level scroll API functions in `ElasticsearchRestTemplate`, it enriches a `SearchHits<T>` with the Elasticsearch scroll id.
-
-.SearchHitsIterator<T>
-An Iterator returned by the streaming functions of the `SearchOperations` interface.
-
-[[elasticsearch.operations.queries]]
-== Queries
-
-Almost all of the methods defined in the `SearchOperations` and `ReactiveSearchOperations` interface take a `Query` parameter that defines the query to execute for searching. `Query` is an interface and Spring Data Elasticsearch provides three implementations: `CriteriaQuery`, `StringQuery` and `NativeSearchQuery`.
-
-[[elasticsearch.operations.criteriaquery]]
-=== CriteriaQuery
-
-`CriteriaQuery` based queries allow the creation of queries to search for data without knowing the syntax or basics of Elasticsearch queries. They allow the user to build queries by simply chaining and combining `Criteria` objects that specifiy the criteria the searched documents must fulfill.
-
-NOTE: when talking about AND or OR when combining criteria keep in mind, that in Elasticsearch AND are converted to a **must** condition and OR to a **should**
-
-`Criteria` and their usage are best explained by example
-(let's assume we have a `Book` entity with a `price` property):
-
-.Get books with a given price
-====
-[source,java]
-----
-Criteria criteria = new Criteria("price").is(42.0);
-Query query = new CriteriaQuery(criteria);
-----
-====
-
-Conditions for the same field can be chained, they will be combined with a logical AND:
-
-.Get books with a given price
-====
-[source,java]
-----
-Criteria criteria = new Criteria("price").greaterThan(42.0).lessThan(34.0L);
-Query query = new CriteriaQuery(criteria);
-----
-====
-
-When chaining `Criteria`, by default a AND logic is used:
-
-.Get all persons with first name _James_  and last name _Miller_:
-====
-[source,java]
-----
-Criteria criteria = new Criteria("lastname").is("Miller") <1>
-  .and("firstname").is("James")                           <2>
-Query query = new CriteriaQuery(criteria);
-----
-<1> the first `Criteria`
-<2> the and() creates a new `Criteria` and chaines it to the first one.
-====
-
-If you want to create nested queries, you need to use subqueries for this. Let's assume we want to find all persons with a last name of _Miller_ and a first name of either _Jack_ or _John_:
-
-.Nested subqueries
-====
-[source,java]
-----
-Criteria miller = new Criteria("lastName").is("Miller")  <.>
-  .subCriteria(                                          <.>
-    new Criteria().or("firstName").is("John")            <.>
-      .or("firstName").is("Jack")                        <.>
-  );
-Query query = new CriteriaQuery(criteria);
-----
-<.> create a first `Criteria` for the last name
-<.> this is combined with AND to a subCriteria
-<.> This sub Criteria is an OR combination for the first name _John_
-<.> and the first name Jack
-====
-
-Please refer to the API documentation of the `Criteria` class for a complete overview of the different available operations.
-
-[[elasticsearch.operations.stringquery]]
-=== StringQuery
-
-This class takes an Elasticsearch query as JSON String.
-The following code shows a query that searches for persons having the first name "Jack":
-
-====
-[source,java]
-----
-
-Query query = new SearchQuery("{ \"match\": { \"firstname\": { \"query\": \"Jack\" } } } ");
-SearchHits<Person> searchHits = operations.search(query, Person.class);
-
-----
-====
-
-Using `StringQuery` may be appropriate if you already have an Elasticsearch query to use.
-
-[[elasticsearch.operations.nativesearchquery]]
-=== NativeSearchQuery
-
-`NativeSearchQuery` is the class to use when you have a complex query, or a query that cannot be expressed by using the `Criteria` API, for example when building queries and using aggregates.
-It allows to use all the different `QueryBuilder` implementations from the Elasticsearch library therefore named "native".
-
-The following code shows how to search for persons with a given firstname and for the found documents have a terms aggregation that counts the number of occurences of the lastnames for these persons:
-
-====
-[source,java]
-----
-Query query = new NativeSearchQueryBuilder()
-    .addAggregation(terms("lastnames").field("lastname").size(10)) //
-    .withQuery(QueryBuilders.matchQuery("firstname", firstName))
-    .build();
-
-SearchHits<Person> searchHits = operations.search(query, Person.class);
-----
-====
-
-

src/main/asciidoc/reference/elasticsearch-repositories.adoc

@@ -1,205 +0,0 @@
-[[elasticsearch.repositories]]
-= Elasticsearch Repositories
-
-This chapter includes details of the Elasticsearch repository implementation.
-
-.The sample `Book` entity
-====
-[source,java]
-----
-@Document(indexName="books")
-class Book {
-    @Id
-    private String id;
-
-    @Field(type = FieldType.text)
-    private String name;
-
-    @Field(type = FieldType.text)
-    private String summary;
-
-    @Field(type = FieldType.Integer)
-    private Integer price;
-
-	// getter/setter ...
-}
-----
-====
-
-[[elasticsearch.repositories.autocreation]]
-== Automatic creation of indices with the corresponding mapping
-
-The `@Document` annotation has an argument `createIndex`. If this argument is set to true - which is the default value  - Spring Data Elasticsearch will during bootstrapping the repository support on application startup check if the index defined by the `@Document` annotation exists.
-
-If it does not exist, the index will be created and the mappings derived from the entity's annotations (see <<elasticsearch.mapping>>) will be written to the newly created index. Details of the index that will be created can be set by using the `@Setting` annotation, refer to <<elasticsearc.misc.index.settings>> for further information.
-
-include::elasticsearch-repository-queries.adoc[leveloffset=+1]
-
-include::reactive-elasticsearch-repositories.adoc[leveloffset=+1]
-
-[[elasticsearch.repositories.annotations]]
-== Annotations for repository methods
-
-=== @Highlight
-
-The `@Highlight` annotation on a repository method defines for which fields of the returned entity highlighting should be included. To search for some text in a `Book` 's name or summary and have the found data highlighted, the following repository method can be used:
-
-====
-[source,java]
-----
-interface BookRepository extends Repository<Book, String> {
-
-    @Highlight(fields = {
-        @HighlightField(name = "name"),
-        @HighlightField(name = "summary")
-    })
-    List<SearchHit<Book>> findByNameOrSummary(String text, String summary);
-}
-----
-====
-
-It is possible to define multiple fields to be highlighted like above, and both the `@Highlight` and the `@HighlightField` annotation can further be customized with a `@HighlightParameters` annotation. Check the Javadocs for the possible configuration options.
-
-In the search results the highlight data can be retrieved from the `SearchHit` class.
-
-[[elasticsearch.annotation]]
-== Annotation based configuration
-
-The Spring Data Elasticsearch repositories support can be activated using an annotation through JavaConfig.
-
-.Spring Data Elasticsearch repositories using JavaConfig
-====
-[source,java]
-----
-@Configuration
-@EnableElasticsearchRepositories(                             <1>
-  basePackages = "org.springframework.data.elasticsearch.repositories"
-  )
-static class Config {
-
-  @Bean
-  public ElasticsearchOperations elasticsearchTemplate() {    <2>
-      // ...
-  }
-}
-
-class ProductService {
-
-  private ProductRepository repository;                       <3>
-
-  public ProductService(ProductRepository repository) {
-    this.repository = repository;
-  }
-
-  public Page<Product> findAvailableBookByName(String name, Pageable pageable) {
-    return repository.findByAvailableTrueAndNameStartingWith(name, pageable);
-  }
-}
-----
-
-<1> The `EnableElasticsearchRepositories` annotation activates the Repository support.
-If no base package is configured, it will use the one of the configuration class it is put on.
-<2> Provide a Bean named `elasticsearchTemplate` of type `ElasticsearchOperations` by using one of the configurations shown in the <<elasticsearch.operations>> chapter.
-<3> Let Spring inject the Repository bean into your class.
-====
-
-[[elasticsearch.cdi]]
-== Elasticsearch Repositories using CDI
-
-The Spring Data Elasticsearch repositories can also be set up using CDI functionality.
-
-.Spring Data Elasticsearch repositories using CDI
-====
-[source,java]
-----
-class ElasticsearchTemplateProducer {
-
-  @Produces
-  @ApplicationScoped
-  public ElasticsearchOperations createElasticsearchTemplate() {
-    // ...                               <1>
-  }
-}
-
-class ProductService {
-
-  private ProductRepository repository;  <2>
-  public Page<Product> findAvailableBookByName(String name, Pageable pageable) {
-    return repository.findByAvailableTrueAndNameStartingWith(name, pageable);
-  }
-  @Inject
-  public void setRepository(ProductRepository repository) {
-    this.repository = repository;
-  }
-}
-----
-<1> Create a component by using the same calls as are used in the <<elasticsearch.operations>> chapter.
-<2> Let the CDI framework inject the Repository into your class.
-
-====
-
-[[elasticsearch.namespace]]
-== Spring Namespace
-
-The Spring Data Elasticsearch module contains a custom namespace allowing definition of repository beans as well as elements for instantiating a `ElasticsearchServer` .
-
-Using the `repositories` element looks up Spring Data repositories as described in <<repositories.create-instances>> .
-
-.Setting up Elasticsearch repositories using Namespace
-====
-[source,xml]
-----
-<?xml version="1.0" encoding="UTF-8"?>
-<beans xmlns="http://www.springframework.org/schema/beans"
-       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-       xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
-       xsi:schemaLocation="http://www.springframework.org/schema/beans
-       https://www.springframework.org/schema/beans/spring-beans-3.1.xsd
-       http://www.springframework.org/schema/data/elasticsearch
-       https://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch-1.0.xsd">
-
-  <elasticsearch:repositories base-package="com.acme.repositories" />
-
-</beans>
-----
-====
-
-Using the `Transport Client` or `Rest Client` element registers an instance of `Elasticsearch Server` in the context.
-
-.Transport Client using Namespace
-====
-[source,xml]
-----
-<?xml version="1.0" encoding="UTF-8"?>
-<beans xmlns="http://www.springframework.org/schema/beans"
-       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-       xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
-       xsi:schemaLocation="http://www.springframework.org/schema/beans
-       https://www.springframework.org/schema/beans/spring-beans-3.1.xsd
-       http://www.springframework.org/schema/data/elasticsearch
-       https://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch-1.0.xsd">
-
-  <elasticsearch:transport-client id="client" cluster-nodes="localhost:9300,someip:9300" />
-
-</beans>
-----
-====
-
-.Rest Client using Namespace
-====
-[source,xml]
-----
-<?xml version="1.0" encoding="UTF-8"?>
-<beans xmlns="http://www.springframework.org/schema/beans"
-       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-       xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
-       xsi:schemaLocation="http://www.springframework.org/schema/data/elasticsearch
-       https://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch.xsd
-       http://www.springframework.org/schema/beans
-       https://www.springframework.org/schema/beans/spring-beans.xsd">
-
-  <elasticsearch:rest-client id="restClient" hosts="http://localhost:9200">
-
-</beans>
-----
-====

src/main/asciidoc/reference/elasticsearch-repository-queries.adoc

@@ -1,324 +0,0 @@
-[[elasticsearch.query-methods]]
-= Query methods
-
-[[elasticsearch.query-methods.finders]]
-== Query lookup strategies
-
-The Elasticsearch module supports all basic query building feature as string queries, native search queries, criteria based queries or have it being derived from the method name.
-
-=== Declared queries
-
-Deriving the query from the method name is not always sufficient and/or may result in unreadable method names.
-In this case one might make use of the `@Query` annotation (see <<elasticsearch.query-methods.at-query>> ).
-
-[[elasticsearch.query-methods.criterions]]
-== Query creation
-
-Generally the query creation mechanism for Elasticsearch works as described in <<repositories.query-methods>>.
-Here's a short example of what a Elasticsearch query method translates into:
-
-.Query creation from method names
-====
-[source,java]
-----
-interface BookRepository extends Repository<Book, String> {
-  List<Book> findByNameAndPrice(String name, Integer price);
-}
-----
-====
-
-The method name above will be translated into the following Elasticsearch json query
-
-[source]
-----
-{
-    "query": {
-        "bool" : {
-            "must" : [
-                { "query_string" : { "query" : "?", "fields" : [ "name" ] } },
-                { "query_string" : { "query" : "?", "fields" : [ "price" ] } }
-            ]
-        }
-    }
-}
-----
-
-A list of supported keywords for Elasticsearch is shown below.
-
-[cols="1,2,3",options="header"]
-.Supported keywords inside method names
-|===
-| Keyword
-| Sample
-| Elasticsearch Query String
-
-| `And`
-| `findByNameAndPrice`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{ "query_string" : { "query" : "?", "fields" : [ "name" ] } },
-{ "query_string" : { "query" : "?", "fields" : [ "price" ] } }
-]
-}
-}}`
-
-| `Or`
-| `findByNameOrPrice`
-| `{ "query" : {
-"bool" : {
-"should" : [
-{ "query_string" : { "query" : "?", "fields" : [ "name" ] } },
-{ "query_string" : { "query" : "?", "fields" : [ "price" ] } }
-]
-}
-}}`
-
-| `Is`
-| `findByName`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{ "query_string" : { "query" : "?", "fields" : [ "name" ] } }
-]
-}
-}}`
-
-| `Not`
-| `findByNameNot`
-| `{ "query" : {
-"bool" : {
-"must_not" : [
-{ "query_string" : { "query" : "?", "fields" : [ "name" ] } }
-]
-}
-}}`
-
-| `Between`
-| `findByPriceBetween`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{"range" : {"price" : {"from" : ?, "to" : ?, "include_lower" : true, "include_upper" : true } } }
-]
-}
-}}`
-
-| `LessThan`
-| `findByPriceLessThan`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{"range" : {"price" : {"from" : null, "to" : ?, "include_lower" : true, "include_upper" : false } } }
-]
-}
-}}`
-
-| `LessThanEqual`
-| `findByPriceLessThanEqual`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{"range" : {"price" : {"from" : null, "to" : ?, "include_lower" : true, "include_upper" : true } } }
-]
-}
-}}`
-
-| `GreaterThan`
-| `findByPriceGreaterThan`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{"range" : {"price" : {"from" : ?, "to" : null, "include_lower" : false, "include_upper" : true } } }
-]
-}
-}}`
-
-
-| `GreaterThanEqual`
-| `findByPriceGreaterThan`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{"range" : {"price" : {"from" : ?, "to" : null, "include_lower" : true, "include_upper" : true } } }
-]
-}
-}}`
-
-| `Before`
-| `findByPriceBefore`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{"range" : {"price" : {"from" : null, "to" : ?, "include_lower" : true, "include_upper" : true } } }
-]
-}
-}}`
-
-| `After`
-| `findByPriceAfter`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{"range" : {"price" : {"from" : ?, "to" : null, "include_lower" : true, "include_upper" : true } } }
-]
-}
-}}`
-
-| `Like`
-| `findByNameLike`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{ "query_string" : { "query" : "?*", "fields" : [ "name" ] }, "analyze_wildcard": true }
-]
-}
-}}`
-
-| `StartingWith`
-| `findByNameStartingWith`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{ "query_string" : { "query" : "?*", "fields" : [ "name" ] }, "analyze_wildcard": true }
-]
-}
-}}`
-
-| `EndingWith`
-| `findByNameEndingWith`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{ "query_string" : { "query" : "*?", "fields" : [ "name" ] }, "analyze_wildcard": true }
-]
-}
-}}`
-
-| `Contains/Containing`
-| `findByNameContaining`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{ "query_string" : { "query" : "\*?*", "fields" : [ "name" ] }, "analyze_wildcard": true }
-]
-}
-}}`
-
-| `In` (when annotated as FieldType.Keyword)
-| `findByNameIn(Collection<String>names)`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{"bool" : {"must" : [
-{"terms" : {"name" : ["?","?"]}}
-]
-}
-}
-]
-}
-}}`
-
-
-| `In`
-| `findByNameIn(Collection<String>names)`
-| `{ "query": {"bool": {"must": [{"query_string":{"query": "\"?\" \"?\"", "fields": ["name"]}}]}}}`
-
-| `NotIn`  (when annotated as FieldType.Keyword)
-| `findByNameNotIn(Collection<String>names)`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{"bool" : {"must_not" : [
-{"terms" : {"name" : ["?","?"]}}
-]
-}
-}
-]
-}
-}}`
-
-| `NotIn`
-| `findByNameNotIn(Collection<String>names)`
-| `{"query": {"bool": {"must": [{"query_string": {"query": "NOT(\"?\" \"?\")", "fields": ["name"]}}]}}}`
-
-| `Near`
-| `findByStoreNear`
-| `Not Supported Yet !`
-
-| `True`
-| `findByAvailableTrue`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{ "query_string" : { "query" : "true", "fields" : [ "available" ] } }
-]
-}
-}}`
-
-| `False`
-| `findByAvailableFalse`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{ "query_string" : { "query" : "false", "fields" : [ "available" ] } }
-]
-}
-}}`
-
-| `OrderBy`
-| `findByAvailableTrueOrderByNameDesc`
-| `{ "query" : {
-"bool" : {
-"must" : [
-{ "query_string" : { "query" : "true", "fields" : [ "available" ] } }
-]
-}
-}, "sort":[{"name":{"order":"desc"}}]
-}`
-
-|===
-
-NOTE: Methods names to build Geo-shape queries taking `GeoJson` parameters are not supported.
-Use `ElasticsearchOperations` with `CriteriaQuery` in a custom repository implementation if you need to have such a function in a repository.
-
-== Method return types
-
-Repository methods can be defined to have the following return types for returning multiple Elements:
-
-* `List<T>`
-* `Stream<T>`
-* `SearchHits<T>`
-* `List<SearchHit<T>>`
-* `Stream<SearchHit<T>>`
-* `SearchPage<T>`
-
-[[elasticsearch.query-methods.at-query]]
-== Using @Query Annotation
-
-.Declare query at the method using the `@Query` annotation.
-====
-[source,java]
-----
-interface BookRepository extends ElasticsearchRepository<Book, String> {
-    @Query("{\"match\": {\"name\": {\"query\": \"?0\"}}}")
-    Page<Book> findByName(String name,Pageable pageable);
-}
-----
-
-The String that is set as the annotation argument must be a valid Elasticsearch JSON query.
-It will be sent to Easticsearch as value of the query element; if for example the function is called with the parameter _John_, it would produce the following query body:
-
-[source,json]
-----
-{
-  "query": {
-    "match": {
-      "name": {
-        "query": "John"
-      }
-    }
-  }
-}
-----
-====

src/main/asciidoc/reference/elasticsearch-routing.adoc

@@ -1,106 +0,0 @@
-
-[[elasticsearch.routing]]
-= Routing values
-
-When Elasticsearch stores a document in an index that has multiple shards, it determines the shard to you use based on the _id_ of the document.
-Sometimes it is necessary to predefine that multiple documents should be indexed on the same shard (join-types, faster search for related data).
-For this Elasticsearch offers the possibility to define a routing, which is the value that should be used to calculate the shard from instead of the _id_.
-
-Spring Data Elasticsearch supports routing definitions on storing and retrieving data in the following ways:
-
-== Routing on join-types
-
-When using join-types (see <<elasticsearch.jointype>>), Spring Data Elasticsearch will automatically use the `parent` property of the entity's `JoinField` property as the value for the routing.
-
-This is correct for all the use-cases where the parent-child relationship has just one level.
-If it is deeper, like a child-parent-grandparent relationship - like in the above example from _vote_ -> _answer_ -> _question_ - then the routing needs to explicitly specified by using the techniques described in the next section (the _vote_ needs the _question.id_ as routing value).
-
-== Custom routing values
-
-To define a custom routing for an entity, Spring Data Elasticsearch provides a `@Routing` annotation (reusing the `Statement` class from above):
-
-====
-[source,java]
-----
-@Document(indexName = "statements")
-@Routing("routing")                  <.>
-public class Statement {
-    @Id
-    private String id;
-
-    @Field(type = FieldType.Text)
-    private String text;
-
-    @JoinTypeRelations(
-        relations =
-            {
-                @JoinTypeRelation(parent = "question", children = {"answer", "comment"}),
-                @JoinTypeRelation(parent = "answer", children = "vote")
-            }
-    )
-    private JoinField<String> relation;
-
-    @Nullable
-    @Field(type = FieldType.Keyword)
-    private String routing;          <.>
-
-    // getter/setter...
-}
-----
-<.> This defines _"routing"_ as routing specification
-<.> a property with the name _routing_
-====
-
-If the `routing` specification of the annotation is a plain string and not a SpEL expression, it is interpreted as the name of a property of the entity, in the example it's the _routing_ property.
-The value of this property will then be used as the routing value for all requests that use the entity.
-
-It is also possible to us a SpEL expression in the `@Document` annotation like this:
-
-====
-[source,java]
-----
-@Document(indexName = "statements")
-@Routing("@myBean.getRouting(#entity)")
-public class Statement{
-    // all the needed stuff
-}
-----
-====
-
-In this case the user needs to provide a bean with the name _myBean_ that has a method `String getRouting(Object)`. To reference the entity _"#entity"_ must be used in the SpEL expression, and the return value must be `null` or the routing value as a String.
-
-If plain property's names and SpEL expressions are not enough to customize the routing definitions, it is possible to define provide an implementation of the `RoutingResolver` interface. This can then be set on the `ElasticOperations` instance:
-
-====
-[source,java]
-----
-RoutingResolver resolver = ...;
-
-ElasticsearchOperations customOperations= operations.withRouting(resolver);
-
-----
-====
-
-The `withRouting()` functions return a copy of the original `ElasticsearchOperations` instance with the customized routing set.
-
-
-When a routing has been defined on an entity when it is stored in Elasticsearch, the same value must be provided when doing a _get_ or _delete_ operation. For methods that do not use an entity - like `get(ID)` or `delete(ID)` - the `ElasticsearchOperations.withRouting(RoutingResolver)` method can be used like this:
-
-====
-[source,java]
-----
-String id = "someId";
-String routing = "theRoutingValue";
-
-// get an entity
-Statement s = operations
-                .withRouting(RoutingResolver.just(routing))       <.>
-                .get(id, Statement.class);
-
-// delete an entity
-operations.withRouting(RoutingResolver.just(routing)).delete(id);
-
-----
-<.> `RoutingResolver.just(s)` returns a resolver that will just return the given String.
-====
-

src/main/asciidoc/reference/migration-guides.adoc

@@ -1,11 +0,0 @@
-[[elasticsearch.migration]]
-= Appendix E: Migration Guides
-
-// line breaks required otherwise the TOC breaks due to joining of first/last lines.
-:leveloffset: +1
-include::elasticsearch-migration-guide-3.2-4.0.adoc[]
-
-include::elasticsearch-migration-guide-4.0-4.1.adoc[]
-
-include::elasticsearch-migration-guide-4.1-4.2.adoc[]
-:leveloffset: -1

src/main/asciidoc/reference/reactive-elasticsearch-operations.adoc

@@ -1,124 +0,0 @@
-[[elasticsearch.reactive.operations]]
-= Reactive Elasticsearch Operations
-
-`ReactiveElasticsearchOperations` is the gateway to executing high level commands against an Elasticsearch cluster using the `ReactiveElasticsearchClient`.
-
-The `ReactiveElasticsearchTemplate` is the default implementation of `ReactiveElasticsearchOperations`.
-
-[[elasticsearch.reactive.template]]
-== Reactive Elasticsearch Template
-
-To get started the `ReactiveElasticsearchTemplate` needs to know about the actual client to work with.
-Please see <<elasticsearch.clients.reactive>> for details on the client.
-
-[[elasticsearch.reactive.template.configuration]]
-=== Reactive Template Configuration
-
-The easiest way of setting up the `ReactiveElasticsearchTemplate` is via `AbstractReactiveElasticsearchConfiguration` providing
-dedicated configuration method hooks for `base package`, the `initial entity set` etc.
-
-.The AbstractReactiveElasticsearchConfiguration
-====
-[source,java]
-----
-@Configuration
-public class Config extends AbstractReactiveElasticsearchConfiguration {
-
-  @Bean <1>
-  @Override
-  public ReactiveElasticsearchClient reactiveElasticsearchClient() {
-      // ...
-  }
-}
-----
-<1> Configure the client to use. This can be done by `ReactiveRestClients` or directly via `DefaultReactiveElasticsearchClient`.
-====
-
-NOTE: If applicable set default `HttpHeaders` via the `ClientConfiguration` of the `ReactiveElasticsearchClient`. See <<elasticsearch.clients.configuration>>.
-
-TIP: If needed the `ReactiveElasticsearchTemplate` can be configured with default `RefreshPolicy` and `IndicesOptions` that get applied to the related requests by overriding the defaults of `refreshPolicy()` and `indicesOptions()`.
-
-However one might want to be more in control over the actual components and use a more verbose approach.
-
-.Configure the ReactiveElasticsearchTemplate
-====
-[source,java]
-----
-@Configuration
-public class Config {
-
-  @Bean <1>
-  public ReactiveElasticsearchClient reactiveElasticsearchClient() {
-    // ...
-  }
-  @Bean <2>
-  public ElasticsearchConverter elasticsearchConverter() {
-    return new MappingElasticsearchConverter(elasticsearchMappingContext());
-  }
-  @Bean <3>
-  public SimpleElasticsearchMappingContext elasticsearchMappingContext() {
-    return new SimpleElasticsearchMappingContext();
-  }
-  @Bean <4>
-  public ReactiveElasticsearchOperations reactiveElasticsearchOperations() {
-    return new ReactiveElasticsearchTemplate(reactiveElasticsearchClient(), elasticsearchConverter());
-  }
-}
-----
-<1> Configure the client to use. This can be done by `ReactiveRestClients` or directly via `DefaultReactiveElasticsearchClient`.
-<2> Set up the `ElasticsearchConverter` used for domain type mapping utilizing metadata provided by the mapping context.
-<3> The Elasticsearch specific mapping context for domain type metadata.
-<4> The actual template based on the client and conversion infrastructure.
-====
-
-[[elasticsearch.reactive.template.usage]]
-=== Reactive Template Usage
-
-`ReactiveElasticsearchTemplate` lets you save, find and delete your domain objects and map those objects to documents stored in Elasticsearch.
-
-Consider the following:
-
-.Use the ReactiveElasticsearchTemplate
-====
-[source,java]
-----
-@Document(indexName = "marvel")
-public class Person {
-
-  private @Id String id;
-  private String name;
-  private int age;
-  // Getter/Setter omitted...
-}
-----
-
-[source,java]
-----
-template.save(new Person("Bruce Banner", 42))                    <1>
-  .doOnNext(System.out::println)
-  .flatMap(person -> template.findById(person.id, Person.class)) <2>
-  .doOnNext(System.out::println)
-  .flatMap(person -> template.delete(person))                    <3>
-  .doOnNext(System.out::println)
-  .flatMap(id -> template.count(Person.class))                   <4>
-  .doOnNext(System.out::println)
-  .subscribe(); <5>
-----
-
-The above outputs the following sequence on the console.
-
-[source,text]
-----
-> Person(id=QjWCWWcBXiLAnp77ksfR, name=Bruce Banner, age=42)
-> Person(id=QjWCWWcBXiLAnp77ksfR, name=Bruce Banner, age=42)
-> QjWCWWcBXiLAnp77ksfR
-> 0
-----
-<1> Insert a new `Person` document into the _marvel_ index under type _characters_. The `id` is generated on server side and set into the instance returned.
-<2> Lookup the `Person` with matching `id` in the _marvel_ index under type _characters_.
-<3> Delete the `Person` with matching `id`, extracted from the given instance, in the _marvel_ index under type _characters_.
-<4> Count the total number of documents in the _marvel_ index under type _characters_.
-<5> Don't forget to _subscribe()_.
-====
-
-

src/main/asciidoc/reference/reactive-elasticsearch-repositories.adoc

@@ -1,130 +0,0 @@
-[[elasticsearch.reactive.repositories]]
-= Reactive Elasticsearch Repositories
-
-Reactive Elasticsearch repository support builds on the core repository support explained in <<repositories>> utilizing
-operations provided via <<elasticsearch.reactive.operations>> executed by a <<elasticsearch.clients.reactive>>.
-
-Spring Data Elasticsearch reactive repository support uses https://projectreactor.io/[Project Reactor] as its reactive
-composition library of choice.
-
-There are 3 main interfaces to be used:
-
-* `ReactiveRepository`
-* `ReactiveCrudRepository`
-* `ReactiveSortingRepository`
-
-[[elasticsearch.reactive.repositories.usage]]
-== Usage
-
-To access domain objects stored in a Elasticsearch using a `Repository`, just create an interface for it.
-Before you can actually go on and do that you will need an entity.
-
-.Sample `Person` entity
-====
-[source,java]
-----
-public class Person {
-
-  @Id
-  private String id;
-  private String firstname;
-  private String lastname;
-  private Address address;
-
-  // … getters and setters omitted
-}
-----
-====
-
-NOTE: Please note that the `id` property needs to be of type `String`.
-
-.Basic repository interface to persist Person entities
-====
-[source]
-----
-interface ReactivePersonRepository extends ReactiveSortingRepository<Person, String> {
-
-  Flux<Person> findByFirstname(String firstname);                                   <1>
-
-  Flux<Person> findByFirstname(Publisher<String> firstname);                        <2>
-
-  Flux<Person> findByFirstnameOrderByLastname(String firstname);                    <3>
-
-  Flux<Person> findByFirstname(String firstname, Sort sort);                        <4>
-
-  Flux<Person> findByFirstname(String firstname, Pageable page);                    <5>
-
-  Mono<Person> findByFirstnameAndLastname(String firstname, String lastname);       <6>
-
-  Mono<Person> findFirstByLastname(String lastname);                                <7>
-
-  @Query("{ \"bool\" : { \"must\" : { \"term\" : { \"lastname\" : \"?0\" } } } }")
-  Flux<Person> findByLastname(String lastname);                                     <8>
-
-  Mono<Long> countByFirstname(String firstname)                                     <9>
-
-  Mono<Boolean> existsByFirstname(String firstname)                                 <10>
-
-  Mono<Long> deleteByFirstname(String firstname)                                    <11>
-}
-----
-<1> The method shows a query for all people with the given `lastname`.
-<2> Finder method awaiting input from `Publisher` to bind parameter value for `firstname`.
-<3> Finder method ordering matching documents by `lastname`.
-<4> Finder method ordering matching documents by the expression defined via the `Sort` parameter.
-<5> Use `Pageable` to pass offset and sorting parameters to the database.
-<6> Finder method concating criteria using `And` / `Or` keywords.
-<7> Find the first matching entity.
-<8> The method shows a query for all people with the given `lastname` looked up by running the annotated `@Query` with given
-parameters.
-<9> Count all entities with matching `firstname`.
-<10> Check if at least one entity with matching `firstname` exists.
-<11> Delete all entites with matching `firstname`.
-====
-
-[[elasticsearch.reactive.repositories.configuration]]
-== Configuration
-
-For Java configuration, use the `@EnableReactiveElasticsearchRepositories` annotation. If no base package is configured,
-the infrastructure scans the package of the annotated configuration class.
-
-The following listing shows how to use Java configuration for a repository:
-
-.Java configuration for repositories
-====
-[source,java]
-----
-@Configuration
-@EnableReactiveElasticsearchRepositories
-public class Config extends AbstractReactiveElasticsearchConfiguration {
-
-  @Override
-  public ReactiveElasticsearchClient reactiveElasticsearchClient() {
-    return ReactiveRestClients.create(ClientConfiguration.localhost());
-  }
-}
-----
-====
-
-Because the repository from the previous example extends `ReactiveSortingRepository`, all CRUD operations are available
-as well as methods for sorted access to the entities. Working with the repository instance is a matter of dependency
-injecting it into a client, as the following example shows:
-
-.Sorted access to Person entities
-====
-[source,java]
-----
-public class PersonRepositoryTests {
-
-  @Autowired ReactivePersonRepository repository;
-
-  @Test
-  public void sortsElementsCorrectly() {
-
-    Flux<Person> persons = repository.findAll(Sort.by(new Order(ASC, "lastname")));
-
-    // ...
-  }
-}
-----
-====

src/main/java/org/springframework/data/elasticsearch/ElasticsearchException.java

@@ -1,37 +1,51 @@
-/*
- * Copyright 2020-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch;
-
-import org.springframework.dao.DataRetrievalFailureException;
-
-import java.util.Map;
-
-/**
- * @author Peter-Josef Meisch
- * @since 4.1
- */
-public class BulkFailureException extends DataRetrievalFailureException {
-	private final Map<String, String> failedDocuments;
-
-	public BulkFailureException(String msg, Map<String, String> failedDocuments) {
-		super(msg);
-		this.failedDocuments = failedDocuments;
-	}
-
-	public Map<String, String> getFailedDocuments() {
-		return failedDocuments;
-	}
-}
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch;
+
+import java.util.Map;
+
+/**
+ * ElasticsearchException
+ *
+ * @author Rizwan Idrees
+ * @author Mohsin Husen
+ */
+public class ElasticsearchException extends RuntimeException {
+
+	private Map<String, String> failedDocuments;
+
+	public ElasticsearchException(String message) {
+		super(message);
+	}
+
+	public ElasticsearchException(String message, Throwable cause) {
+		super(message, cause);
+	}
+
+	public ElasticsearchException(String message, Throwable cause, Map<String, String> failedDocuments) {
+		super(message, cause);
+		this.failedDocuments = failedDocuments;
+	}
+
+	public ElasticsearchException(String message, Map<String, String> failedDocuments) {
+		super(message);
+		this.failedDocuments = failedDocuments;
+	}
+
+	public Map<String, String> getFailedDocuments() {
+		return failedDocuments;
+	}
+}

src/main/java/org/springframework/data/elasticsearch/annotations/CompletionContext.java

@@ -1,30 +0,0 @@
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Inherited;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import org.elasticsearch.search.suggest.completion.context.ContextMapping;
-
-/**
- * Based on reference doc - https://www.elastic.co/guide/en/elasticsearch/reference/current/suggester-context.html
- *
- * @author Robert Gruendler
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-@Documented
-@Inherited
-public @interface CompletionContext {
-
-	String name();
-
-	ContextMapping.Type type();
-
-	String precision() default "";
-
-	String path() default "";
-}

src/main/java/org/springframework/data/elasticsearch/annotations/CompletionContextType.java

@@ -1,12 +0,0 @@
-package org.springframework.data.elasticsearch.annotations;
-
-/**
- * Based on reference doc - https://www.elastic.co/guide/en/elasticsearch/reference/current/suggester-context.html
- *
- * @author Robert Gruendler
- */
-public enum CompletionContextType {
-
-	CATEGORY, GEO
-
-}

src/main/java/org/springframework/data/elasticsearch/annotations/CompletionField.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 the original author or authors.
+ * Copyright 2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,18 +15,12 @@
  */
 package org.springframework.data.elasticsearch.annotations;
 
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Inherited;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import java.lang.annotation.*;
 
 /**
- * Based on the reference doc - https://www.elastic.co/guide/en/elasticsearch/reference/current/search-suggesters-completion.html
+ * Based on the reference doc - http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters-completion.html
  *
  * @author Mewes Kochheim
- * @author Robert Gruendler
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.FIELD)
@@ -38,11 +32,11 @@ public @interface CompletionField {
 
 	String analyzer() default "simple";
 
+	boolean payloads() default false;
+
 	boolean preserveSeparators() default true;
 
 	boolean preservePositionIncrements() default true;
 
 	int maxInputLength() default 50;
-
-	CompletionContext[] contexts() default {};
 }

src/main/java/org/springframework/data/elasticsearch/annotations/CountQuery.java

@@ -1,39 +0,0 @@
-/*
- * Copyright 2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import org.springframework.core.annotation.AliasFor;
-
-/**
- * Alias for a @Query annotation with the count parameter set to true.
- *
- * @author Peter-Josef Meisch
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ ElementType.METHOD, ElementType.ANNOTATION_TYPE })
-@Documented
-@Query(count = true)
-public @interface CountQuery {
-
-	@AliasFor(annotation = Query.class)
-	String value() default "";
-}

src/main/java/org/springframework/data/elasticsearch/annotations/DateFormat.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2021 the original author or authors.
+ * Copyright 2014 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,85 +16,16 @@
 package org.springframework.data.elasticsearch.annotations;
 
 /**
- * Values based on reference doc - https://www.elastic.co/guide/reference/mapping/date-format/. The patterns are taken
- * from this documentation and slightly adapted so that a Java {@link java.time.format.DateTimeFormatter} produces the
- * same values as the Elasticsearch formatter.
- *
  * @author Jakub Vavrik
- * @author Tim te Beek
- * @author Peter-Josef Meisch
- * @author Sascha Woo
+ *         Values based on reference doc - http://www.elasticsearch.org/guide/reference/mapping/date-format/
  */
 public enum DateFormat {
-	/**
-	 * @deprecated since 4.2, will be removed in a future version. Use <code>format = {}</code> to disable built-in date
-	 *             formats in the @Field annotation.
-	 */
-	@Deprecated
-	none(""), //
-	/**
-	 * @deprecated since 4.2, will be removed in a future version.It is no longer required for using a custom date format
-	 *             pattern. If you want to use only a custom date format pattern, you must set the <code>format</code>
-	 *             property to empty <code>{}</code>.
-	 */
-	@Deprecated
-	custom(""), //
-	basic_date("uuuuMMdd"), //
-	basic_date_time("uuuuMMdd'T'HHmmss.SSSXXX"), //
-	basic_date_time_no_millis("uuuuMMdd'T'HHmmssXXX"), //
-	basic_ordinal_date("uuuuDDD"), //
-	basic_ordinal_date_time("yyyyDDD'T'HHmmss.SSSXXX"), //
-	basic_ordinal_date_time_no_millis("yyyyDDD'T'HHmmssXXX"), //
-	basic_time("HHmmss.SSSXXX"), //
-	basic_time_no_millis("HHmmssXXX"), //
-	basic_t_time("'T'HHmmss.SSSXXX"), //
-	basic_t_time_no_millis("'T'HHmmssXXX"), //
-	basic_week_date("YYYY'W'wwe"), // week-based-year!
-	basic_week_date_time("YYYY'W'wwe'T'HHmmss.SSSX"), // here Elasticsearch uses a different zone format
-	basic_week_date_time_no_millis("YYYY'W'wwe'T'HHmmssX"), //
-	date("uuuu-MM-dd"), //
-	date_hour("uuuu-MM-dd'T'HH"), //
-	date_hour_minute("uuuu-MM-dd'T'HH:mm"), //
-	date_hour_minute_second("uuuu-MM-dd'T'HH:mm:ss"), //
-	date_hour_minute_second_fraction("uuuu-MM-dd'T'HH:mm:ss.SSS"), //
-	date_hour_minute_second_millis("uuuu-MM-dd'T'HH:mm:ss.SSS"), //
-	date_optional_time("uuuu-MM-dd['T'HH:mm:ss.SSSXXX]"), //
-	date_time("uuuu-MM-dd'T'HH:mm:ss.SSSXXX"), //
-	date_time_no_millis("uuuu-MM-dd'T'HH:mm:ssVV"), // here Elasticsearch uses the zone-id in it's implementation
-	epoch_millis("epoch_millis"), //
-	epoch_second("epoch_second"), //
-	hour("HH"), //
-	hour_minute("HH:mm"), //
-	hour_minute_second("HH:mm:ss"), //
-	hour_minute_second_fraction("HH:mm:ss.SSS"), //
-	hour_minute_second_millis("HH:mm:ss.SSS"), //
-	ordinal_date("uuuu-DDD"), //
-	ordinal_date_time("uuuu-DDD'T'HH:mm:ss.SSSXXX"), //
-	ordinal_date_time_no_millis("uuuu-DDD'T'HH:mm:ssXXX"), //
-	time("HH:mm:ss.SSSXXX"), //
-	time_no_millis("HH:mm:ssXXX"), //
-	t_time("'T'HH:mm:ss.SSSXXX"), //
-	t_time_no_millis("'T'HH:mm:ssXXX"), //
-	week_date("YYYY-'W'ww-e"), //
-	week_date_time("YYYY-'W'ww-e'T'HH:mm:ss.SSSXXX"), //
-	week_date_time_no_millis("YYYY-'W'ww-e'T'HH:mm:ssXXX"), //
-	weekyear(""), // no TemporalAccessor available for these 3
-	weekyear_week(""), //
-	weekyear_week_day(""), //
-	year("uuuu"), //
-	year_month("uuuu-MM"), //
-	year_month_day("uuuu-MM-dd"); //
-
-	private final String pattern;
-
-	DateFormat(String pattern) {
-		this.pattern = pattern;
-	}
-
-	/**
-	 * @since 4.2
-	 */
-	public String getPattern() {
-		return pattern;
-	}
+	none, custom, basic_date, basic_date_time, basic_date_time_no_millis, basic_ordinal_date, basic_ordinal_date_time,
+	basic_ordinal_date_time_no_millis, basic_time, basic_time_no_millis, basic_t_time, basic_t_time_no_millis,
+	basic_week_date, basic_week_date_time, basic_week_date_time_no_millis, date, date_hour, date_hour_minute,
+	date_hour_minute_second, date_hour_minute_second_fraction, date_hour_minute_second_millis, date_optional_time,
+	date_time, date_time_no_millis, hour, hour_minute, hour_minute_second, hour_minute_second_fraction,
+	hour_minute_second_millis, ordinal_date, ordinal_date_time, ordinal_date_time_no_millis, time, time_no_millis,
+	t_time, t_time_no_millis, week_date, week_date_time, weekDateTimeNoMillis, week_year, weekyearWeek,
+	weekyearWeekDay, year, year_month, year_month_day
 }

src/main/java/org/springframework/data/elasticsearch/annotations/Document.java

@@ -1,108 +1,51 @@
-/*
- * Copyright 2013-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Inherited;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import org.elasticsearch.index.VersionType;
-import org.springframework.data.annotation.Persistent;
-
-/**
- * Identifies a domain object to be persisted to Elasticsearch.
- *
- * @author Rizwan Idrees
- * @author Mohsin Husen
- * @author Mason Chan
- * @author Ivan Greene
- * @author Mark Paluch
- * @author Peter-Josef Meisch
- */
-@Persistent
-@Inherited
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ ElementType.TYPE })
-public @interface Document {
-
-	/**
-	 * Name of the Elasticsearch index.
-	 * <ul>
-	 * <li>Lowercase only</li>
-	 * <li><Cannot include \, /, *, ?, ", <, >, |, ` ` (space character), ,, #/li>
-	 * <li>Cannot start with -, _, +</li>
-	 * <li>Cannot be . or ..</li>
-	 * <li>Cannot be longer than 255 bytes (note it is bytes, so multi-byte characters will count towards the 255 limit
-	 * faster)</li>
-	 * </ul>
-	 */
-	String indexName();
-
-	/**
-	 * Use server-side settings when creating the index.
-	 *
-	 * @deprecated since 4.2, use the {@link Setting} annotation to configure settings
-	 */
-	@Deprecated
-	boolean useServerConfiguration() default false;
-
-	/**
-	 * Number of shards for the index {@link #indexName()}. Used for index creation. <br/>
-	 * With version 4.0, the default value is changed from 5 to 1 to reflect the change in the default settings of
-	 * Elasticsearch which changed to 1 as well in Elasticsearch 7.0.
-	 * ComposableAnnotationsUnitTest.documentAnnotationShouldBeComposable:60
-	 *
-	 * @deprecated since 4.2, use the {@link Setting} annotation to configure settings
-	 */
-	@Deprecated
-	short shards() default 1;
-
-	/**
-	 * Number of replicas for the index {@link #indexName()}. Used for index creation.
-	 *
-	 * @deprecated since 4.2, use the {@link Setting} annotation to configure settings
-	 */
-	@Deprecated
-	short replicas() default 1;
-
-	/**
-	 * Refresh interval for the index {@link #indexName()}. Used for index creation.
-	 *
-	 * @deprecated since 4.2, use the {@link Setting} annotation to configure settings
-	 */
-	@Deprecated
-	String refreshInterval() default "1s";
-
-	/**
-	 * Index storage type for the index {@link #indexName()}. Used for index creation.
-	 *
-	 * @deprecated since 4.2, use the {@link Setting} annotation to configure settings
-	 */
-	@Deprecated
-	String indexStoreType() default "fs";
-
-	/**
-	 * Configuration whether to create an index on repository bootstrapping.
-	 */
-	boolean createIndex() default true;
-
-	/**
-	 * Configuration of version management.
-	 */
-	VersionType versionType() default VersionType.EXTERNAL;
-}
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch.annotations;
+
+import java.lang.annotation.*;
+
+import org.springframework.data.annotation.Persistent;
+
+/**
+ * Document
+ *
+ * @author Rizwan Idrees
+ * @author Mohsin Husen
+ * @author Mason Chan
+ */
+
+@Persistent
+@Inherited
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface Document {
+
+	String indexName();
+
+	String type() default "";
+
+	boolean useServerConfiguration() default false;
+
+	short shards() default 5;
+
+	short replicas() default 1;
+
+	String refreshInterval() default "1s";
+
+	String indexStoreType() default "fs";
+
+	boolean createIndex() default true;
+}

src/main/java/org/springframework/data/elasticsearch/annotations/DynamicMapping.java

@@ -1,37 +0,0 @@
-/*
- * Copyright 2019-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation to set the dynamic mapping mode
- * {@see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/dynamic.html">elasticsearch doc</a>}
- * 
- * @author Peter-Josef Meisch
- * @since 4.0
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ ElementType.TYPE, ElementType.FIELD })
-@Documented
-public @interface DynamicMapping {
-
-	DynamicMappingValue value() default DynamicMappingValue.True;
-}

src/main/java/org/springframework/data/elasticsearch/annotations/DynamicTemplates.java

@@ -1,27 +0,0 @@
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Inherited;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import org.springframework.data.annotation.Persistent;
-
-/**
- * Elasticsearch dynamic templates mapping.
- * This annotation is handy if you prefer apply dynamic templates on fields with annotation e.g. {@link Field}
- * with type = FieldType.Object etc. instead of static mapping on Document via {@link Mapping} annotation.
- * DynamicTemplates annotation is omitted if {@link Mapping} annotation is used.
- *
- * @author Petr Kukral
- */
-@Persistent
-@Inherited
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.TYPE})
-public @interface DynamicTemplates {
-
-	String mappingPath() default "";
-
-}

src/main/java/org/springframework/data/elasticsearch/annotations/Field.java

@@ -1,198 +1,56 @@
-/*
- * Copyright 2013-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Inherited;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import org.springframework.core.annotation.AliasFor;
-
-/**
- * @author Rizwan Idrees
- * @author Mohsin Husen
- * @author Artur Konczak
- * @author Jonathan Yan
- * @author Jakub Vavrik
- * @author Kevin Leturc
- * @author Peter-Josef Meisch
- * @author Xiao Yu
- * @author Aleksei Arsenev
- * @author Brian Kimmig
- * @author Morgan Lutz
- * @author Sascha Woo
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ ElementType.FIELD, ElementType.ANNOTATION_TYPE })
-@Documented
-@Inherited
-public @interface Field {
-
-	/**
-	 * Alias for {@link #name}.
-	 *
-	 * @since 3.2
-	 */
-	@AliasFor("name")
-	String value() default "";
-
-	/**
-	 * The <em>name</em> to be used to store the field inside the document.
-	 * <p>
-	 * √5 If not set, the name of the annotated property is used.
-	 *
-	 * @since 3.2
-	 */
-	@AliasFor("value")
-	String name() default "";
-
-	FieldType type() default FieldType.Auto;
-
-	boolean index() default true;
-
-	DateFormat[] format() default { DateFormat.date_optional_time, DateFormat.epoch_millis };
-
-	String[] pattern() default {};
-
-	boolean store() default false;
-
-	boolean fielddata() default false;
-
-	String searchAnalyzer() default "";
-
-	String analyzer() default "";
-
-	String normalizer() default "";
-
-	String[] ignoreFields() default {};
-
-	boolean includeInParent() default false;
-
-	String[] copyTo() default {};
-
-	/**
-	 * @since 4.0
-	 */
-	int ignoreAbove() default -1;
-
-	/**
-	 * @since 4.0
-	 */
-	boolean coerce() default true;
-
-	/**
-	 * @since 4.0
-	 */
-	boolean docValues() default true;
-
-	/**
-	 * @since 4.0
-	 */
-	boolean ignoreMalformed() default false;
-
-	/**
-	 * @since 4.0
-	 */
-	IndexOptions indexOptions() default IndexOptions.none;
-
-	/**
-	 * @since 4.0
-	 */
-	boolean indexPhrases() default false;
-
-	/**
-	 * implemented as array to enable the empty default value
-	 *
-	 * @since 4.0
-	 */
-	IndexPrefixes[] indexPrefixes() default {};
-
-	/**
-	 * @since 4.0
-	 */
-	boolean norms() default true;
-
-	/**
-	 * @since 4.0
-	 */
-	String nullValue() default "";
-
-	/**
-	 * @since 4.0
-	 */
-	int positionIncrementGap() default -1;
-
-	/**
-	 * @since 4.0
-	 */
-	Similarity similarity() default Similarity.Default;
-
-	/**
-	 * @since 4.0
-	 */
-	TermVector termVector() default TermVector.none;
-
-	/**
-	 * @since 4.0
-	 */
-	double scalingFactor() default 1;
-
-	/**
-	 * @since 4.0
-	 */
-	int maxShingleSize() default -1;
-
-	/**
-	 * if true, the field will be stored in Elasticsearch even if it has a null value
-	 *
-	 * @since 4.1
-	 */
-	boolean storeNullValue() default false;
-
-	/**
-	 * to be used in combination with {@link FieldType#Rank_Feature}
-	 *
-	 * @since 4.1
-	 */
-	boolean positiveScoreImpact() default true;
-
-	/**
-	 * to be used in combination with {@link FieldType#Object}
-	 *
-	 * @since 4.1
-	 */
-	boolean enabled() default true;
-
-	/**
-	 * @since 4.1
-	 */
-	boolean eagerGlobalOrdinals() default false;
-
-	/**
-	 * @since 4.1
-	 */
-	NullValueType nullValueType() default NullValueType.String;
-
-	/**
-	 * to be used in combination with {@link FieldType#Dense_Vector}
-	 *
-	 * @since 4.2
-	 */
-	int dims() default -1;
-}
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author Rizwan Idrees
+ * @author Mohsin Husen
+ * @author Artur Konczak
+ * @author Jonathan Yan
+ * @author Jakub Vavrik
+ * @author Kevin Leturc
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@Documented
+@Inherited
+public @interface Field {
+
+	FieldType type() default FieldType.Auto;
+
+	FieldIndex index() default FieldIndex.analyzed;
+
+	DateFormat format() default DateFormat.none;
+
+	String pattern() default "";
+
+	boolean store() default false;
+
+	String searchAnalyzer() default "";
+
+	String analyzer() default "";
+
+	String[] ignoreFields() default {};
+
+	boolean includeInParent() default false;
+}

src/main/java/org/springframework/data/elasticsearch/annotations/FieldIndex.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019-2021 the original author or authors.
+ * Copyright 2014 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,9 +16,11 @@
 package org.springframework.data.elasticsearch.annotations;
 
 /**
- * @author Peter-Josef Meisch
- * @since 4.0
+ * @author Artur Konczak
+ * @author Mohsin Husen
+ * @author Alexander Volz
+ * @author Dennis Maaß
  */
-public enum IndexOptions {
-	none, docs, freqs, positions, offsets
+public enum FieldIndex {
+	not_analyzed, analyzed, no
 }

src/main/java/org/springframework/data/elasticsearch/annotations/FieldType.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 the original author or authors.
+ * Copyright 2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,47 +19,7 @@ package org.springframework.data.elasticsearch.annotations;
  * @author Rizwan Idrees
  * @author Mohsin Husen
  * @author Artur Konczak
- * @author Zeng Zetang
- * @author Peter-Josef Meisch
- * @author Aleksei Arsenev
- * @author Brian Kimmig
- * @author Morgan Lutz
  */
 public enum FieldType {
-	Auto, //
-	Text, //
-	Keyword, //
-	Long, //
-	Integer, //
-	Short, //
-	Byte, //
-	Double, //
-	Float, //
-	Half_Float, //
-	Scaled_Float, //
-	Date, //
-	Date_Nanos, //
-	Boolean, //
-	Binary, //
-	Integer_Range, //
-	Float_Range, //
-	Long_Range, //
-	Double_Range, //
-	Date_Range, //
-	Ip_Range, //
-	Object, //
-	Nested, //
-	Ip, //
-	TokenCount, //
-	Percolator, //
-	Flattened, //
-	Search_As_You_Type, //
-	/** @since 4.1 */
-	Rank_Feature, //
-	/** @since 4.1 */
-	Rank_Features, //
-	/** since 4.2 */
-	Wildcard, //
-	/** @since 4.2 */
-	Dense_Vector //
+	String, Integer, Long, Date, Float, Double, Boolean, Object, Auto, Nested, Ip, Attachment
 }

src/main/java/org/springframework/data/elasticsearch/annotations/GeoPointField.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 the original author or authors.
+ * Copyright 2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,4 +25,8 @@ import java.lang.annotation.*;
 @Documented
 public @interface GeoPointField {
 
+        boolean geoHashPrefix() default false;
+
+        String geoHashPrecision() default "0";
+
 }

src/main/java/org/springframework/data/elasticsearch/annotations/GeoShapeField.java

@@ -1,44 +0,0 @@
-/*
- * Copyright 2017-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * @author Lukas Vorisek
- * @author Peter-Josef Meisch
- * @since 4.1
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-@Documented
-public @interface GeoShapeField {
-	Orientation orientation() default Orientation.ccw;
-
-	boolean ignoreMalformed() default false;
-
-	boolean ignoreZValue() default true;
-
-	boolean coerce() default false;
-
-	enum Orientation {
-		right, ccw, counterclockwise, left, cw, clockwise
-	}
-}

src/main/java/org/springframework/data/elasticsearch/annotations/Highlight.java

@@ -1,36 +0,0 @@
-/*
- * Copyright 2020-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * @author Peter-Josef Meisch
- * @since 4.0
- */
-@Documented
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.METHOD)
-public @interface Highlight {
-
-	HighlightParameters parameters() default @HighlightParameters;
-
-	HighlightField[] fields();
-}

src/main/java/org/springframework/data/elasticsearch/annotations/HighlightField.java

@@ -1,37 +0,0 @@
-/*
- * Copyright 2020-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-
-/**
- * @author Peter-Josef Meisch
- * @since 4.0
- */
-@Documented
-@Retention(RetentionPolicy.RUNTIME)
-public @interface HighlightField {
-
-	/**
-	 * The name of the field to apply highlighting to. This must be the field name of the entity's property, not the name
-	 * of the field in the index mappings.
-	 */
-	String name() default "";
-
-	HighlightParameters parameters() default @HighlightParameters;
-}

src/main/java/org/springframework/data/elasticsearch/annotations/HighlightParameters.java

@@ -1,78 +0,0 @@
-/*
- * Copyright 2020-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-
-/**
- * @author Peter-Josef Meisch
- * @since 4.0
- */
-@Documented
-@Retention(RetentionPolicy.RUNTIME)
-public @interface HighlightParameters {
-	String boundaryChars() default "";
-
-	int boundaryMaxScan() default -1;
-
-	String boundaryScanner() default "";
-
-	String boundaryScannerLocale() default "";
-
-	/**
-	 * only used for {@link Highlight}s.
-	 */
-	String encoder() default "";
-
-	boolean forceSource() default false;
-
-	String fragmenter() default "";
-
-	/**
-	 * only used for {@link HighlightField}s.
-	 */
-	int fragmentOffset() default -1;
-
-	int fragmentSize() default -1;
-
-	/**
-	 * only used for {@link HighlightField}s.
-	 */
-	String[] matchedFields() default {};
-
-	int noMatchSize() default -1;
-
-	int numberOfFragments() default -1;
-
-	String order() default "";
-
-	int phraseLimit() default -1;
-
-	String[] preTags() default {};
-
-	String[] postTags() default {};
-
-	boolean requireFieldMatch() default true;
-
-	/**
-	 * only used for {@link Highlight}s.
-	 */
-	String tagsSchema() default "";
-
-	String type() default "";
-}

src/main/java/org/springframework/data/elasticsearch/annotations/InnerField.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2021 the original author or authors.
+ * Copyright 2014 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,132 +21,21 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * @author Artur Konczak
- * @author Mohsin Husen
- * @author Sascha Woo
- * @author Xiao Yu
- * @author Peter-Josef Meisch
- * @author Aleksei Arsenev
- * @author Brian Kimmig
- * @author Morgan Lutz
+ *
  */
 @Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.ANNOTATION_TYPE)
+@Target(ElementType.FIELD)
 public @interface InnerField {
 
 	String suffix();
 
 	FieldType type();
 
-	boolean index() default true;
-
-	DateFormat[] format() default { DateFormat.date_optional_time, DateFormat.epoch_millis };
-
-	String[] pattern() default {};
+	FieldIndex index() default FieldIndex.analyzed;
 
 	boolean store() default false;
 
-	boolean fielddata() default false;
-
 	String searchAnalyzer() default "";
 
-	String analyzer() default "";
-
-	String normalizer() default "";
-
-	/**
-	 * @since 4.0
-	 */
-	int ignoreAbove() default -1;
-
-	/**
-	 * @since 4.0
-	 */
-	boolean coerce() default true;
-
-	/**
-	 * @since 4.0
-	 */
-	boolean docValues() default true;
-
-	/**
-	 * @since 4.0
-	 */
-	boolean ignoreMalformed() default false;
-
-	/**
-	 * @since 4.0
-	 */
-	IndexOptions indexOptions() default IndexOptions.none;
-
-	/**
-	 * @since 4.0
-	 */
-	boolean indexPhrases() default false;
-
-	/**
-	 * implemented as array to enable the empty default value
-	 *
-	 * @since 4.0
-	 */
-	IndexPrefixes[] indexPrefixes() default {};
-
-	/**
-	 * @since 4.0
-	 */
-	boolean norms() default true;
-
-	/**
-	 * @since 4.0
-	 */
-	String nullValue() default "";
-
-	/**
-	 * @since 4.0
-	 */
-	int positionIncrementGap() default -1;
-
-	/**
-	 * @since 4.0
-	 */
-	Similarity similarity() default Similarity.Default;
-
-	/**
-	 * @since 4.0
-	 */
-	TermVector termVector() default TermVector.none;
-
-	/**
-	 * @since 4.0
-	 */
-	double scalingFactor() default 1;
-
-	/**
-	 * @since 4.0
-	 */
-	int maxShingleSize() default -1;
-
-	/**
-	 * to be used in combination with {@link FieldType#Rank_Feature}
-	 * 
-	 * @since 4.1
-	 */
-	boolean positiveScoreImpact() default true;
-
-	/**
-	 * @since 4.1
-	 */
-	boolean eagerGlobalOrdinals() default false;
-
-	/**
-	 * @since 4.1
-	 */
-	NullValueType nullValueType() default NullValueType.String;
-
-	/**
-	 * to be used in combination with {@link FieldType#Dense_Vector}
-	 *
-	 * @since 4.2
-	 */
-	int dims() default -1;
+	String indexAnalyzer() default "";
 }

src/main/java/org/springframework/data/elasticsearch/annotations/JoinTypeRelation.java

@@ -1,36 +0,0 @@
-/*
- * Copyright 2020-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * @author Subhobrata Dey
- * @since 4.1
- */
-@Documented
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.ANNOTATION_TYPE)
-public @interface JoinTypeRelation {
-
-	String parent();
-
-	String[] children();
-}

src/main/java/org/springframework/data/elasticsearch/annotations/JoinTypeRelations.java

@@ -1,36 +0,0 @@
-/*
- * Copyright 2020-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Inherited;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * @author Subhobrata Dey
- * @since 4.1
- */
-@Documented
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-@Inherited
-public @interface JoinTypeRelations {
-
-	JoinTypeRelation[] relations();
-}

src/main/java/org/springframework/data/elasticsearch/annotations/Mapping.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2021 the original author or authors.
+ * Copyright 2014 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,12 +15,7 @@
  */
 package org.springframework.data.elasticsearch.annotations;
 
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Inherited;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
+import java.lang.annotation.*;
 import org.springframework.data.annotation.Persistent;
 
 /**
@@ -31,15 +26,9 @@ import org.springframework.data.annotation.Persistent;
 @Persistent
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
-@Target({ ElementType.TYPE, ElementType.FIELD })
+@Target({ElementType.TYPE, ElementType.FIELD})
 public @interface Mapping {
 
 	String mappingPath() default "";
 
-	/**
-	 * whether mappings are enabled
-	 * 
-	 * @since 4.2
-	 */
-	boolean enabled() default true;
 }

src/main/java/org/springframework/data/elasticsearch/annotations/MultiField.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2021 the original author or authors.
+ * Copyright 2014 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,26 +15,20 @@
  */
 package org.springframework.data.elasticsearch.annotations;
 
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import java.lang.annotation.*;
 
 /**
  * @author Rizwan Idrees
  * @author Mohsin Husen
  * @author Artur Konczak
  * @author Jonathan Yan
- * @author Xiao Yu
- * @author Peter-Josef Meisch
  */
 @Retention(RetentionPolicy.RUNTIME)
-@Target({ ElementType.FIELD, ElementType.ANNOTATION_TYPE })
+@Target(ElementType.FIELD)
 @Documented
 public @interface MultiField {
 
-	Field mainField();
+	public Field mainField();
 
-	InnerField[] otherFields() default {};
+	public InnerField[] otherFields() default {};
 }

src/main/java/org/springframework/data/elasticsearch/annotations/NullValueType.java

@@ -1,24 +0,0 @@
-/*
- * Copyright 2020-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-/**
- * @author Peter-Josef Meisch
- * @since 4.1
- */
-public enum NullValueType {
-	String, Integer, Long, Double
-}

src/main/java/org/springframework/data/elasticsearch/annotations/Parent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2021 the original author or authors.
+ * Copyright 2014 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,9 +23,8 @@ import org.springframework.data.annotation.Persistent;
  * Parent
  *
  * @author Philipp Jardas
- * @deprecated since 4.1, not supported anymore by Elasticsearch
  */
-@Deprecated
+
 @Persistent
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)

src/main/java/org/springframework/data/elasticsearch/annotations/Query.java

@@ -1,53 +1,45 @@
-/*
- * Copyright 2013-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.*;
-
-/**
- * Query
- *
- * @author Rizwan Idrees
- * @author Mohsin Husen
- * @author Peter-Josef Meisch
- */
-
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
-@Documented
-public @interface Query {
-
-	/**
-	 * @return Elasticsearch query to be used when executing query. May contain placeholders eg. ?0
-	 */
-	String value() default "";
-
-	/**
-	 * Named Query Named looked up by repository.
-	 *
-	 * @deprecated since 4.2, not implemented and used anywhere
-	 */
-	String name() default "";
-
-	/**
-	 * Returns whether the query defined should be executed as count projection.
-	 *
-	 * @return {@literal false} by default.
-	 * @since 4.2
-	 */
-	boolean count() default false;
-}
-
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch.annotations;
+
+import java.lang.annotation.*;
+
+/**
+ * Query
+ *
+ * @author Rizwan Idrees
+ * @author Mohsin Husen
+ */
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@Documented
+public @interface Query {
+
+	/**
+	 * Elasticsearch query to be used when executing query. May contain placeholders eg. ?0
+	 *
+	 * @return
+	 */
+	String value() default "";
+
+	/**
+	 * Named Query Named looked up by repository.
+	 *
+	 * @return
+	 */
+	String name() default "";
+}

src/main/java/org/springframework/data/elasticsearch/annotations/Routing.java

@@ -1,43 +0,0 @@
-/*
- * Copyright2020-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Inherited;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import org.springframework.data.annotation.Persistent;
-
-/**
- * Annotation to enable custom routing values for an entity.
- *
- * @author Peter-Josef Meisch
- * @since 4.2
- */
-@Persistent
-@Inherited
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ ElementType.TYPE })
-public @interface Routing {
-
-	/**
-	 * defines how the routing is determined. Can be either the name of a property or a SpEL expression. See the reference
-	 * documentation for examples how to use this annotation.
-	 */
-	String value();
-}

src/main/java/org/springframework/data/elasticsearch/annotations/Setting.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2021 the original author or authors.
+ * Copyright 2014 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,11 +15,7 @@
  */
 package org.springframework.data.elasticsearch.annotations;
 
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Inherited;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import java.lang.annotation.*;
 
 import org.springframework.data.annotation.Persistent;
 
@@ -27,84 +23,14 @@ import org.springframework.data.annotation.Persistent;
  * Elasticsearch Setting
  *
  * @author Mohsin Husen
- * @author Peter-Josef Meisch
  */
 
 @Persistent
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
-@Target({ ElementType.TYPE })
+@Target({ElementType.TYPE})
 public @interface Setting {
 
-	/**
-	 * Resource path for a settings configuration
-	 */
 	String settingPath() default "";
 
-	/**
-	 * Use server-side settings when creating the index.
-	 */
-	boolean useServerConfiguration() default false;
-
-	/**
-	 * Number of shards for the index. Used for index creation. <br/>
-	 * With version 4.0, the default value is changed from 5 to 1 to reflect the change in the default settings of
-	 * Elasticsearch which changed to 1 as well in Elasticsearch 7.0.
-	 */
-	short shards() default 1;
-
-	/**
-	 * Number of replicas for the index. Used for index creation.
-	 */
-	short replicas() default 1;
-
-	/**
-	 * Refresh interval for the index. Used for index creation.
-	 */
-	String refreshInterval() default "1s";
-
-	/**
-	 * Index storage type for the index. Used for index creation.
-	 */
-	String indexStoreType() default "fs";
-
-	/**
-	 * fields to define an index sorting
-	 *
-	 * @since 4.2
-	 */
-	String[] sortFields() default {};
-
-	/**
-	 * defines the order for {@link #sortFields()}. If present, it must have the same number of elements
-	 *
-	 * @since 4.2
-	 */
-	SortOrder[] sortOrders() default {};
-
-	/**
-	 * defines the mode for {@link #sortFields()}. If present, it must have the same number of elements
-	 *
-	 * @since 4.2
-	 */
-	SortMode[] sortModes() default {};
-
-	/**
-	 * defines the missing value for {@link #sortFields()}. If present, it must have the same number of elements
-	 *
-	 * @since 4.2
-	 */
-	SortMissing[] sortMissingValues() default {};
-
-	enum SortOrder {
-		asc, desc
-	}
-
-	enum SortMode {
-		min, max
-	}
-
-	enum SortMissing {
-		_last, _first
-	}
 }

src/main/java/org/springframework/data/elasticsearch/annotations/Similarity.java

@@ -1,36 +0,0 @@
-/*
- * Copyright 2019-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-/**
- * @author Peter-Josef Meisch
- * @since 4.0
- */
-public enum Similarity {
-	Default("default"), BM25("BM25"), classic("classic"), Boolean("boolean");
-
-	// need to use a custom name because 'boolean' can't be used as enum name
-	private final String toStringName;
-
-	Similarity(String name) {
-		this.toStringName = name;
-	}
-
-	@Override
-	public String toString() {
-		return toStringName;
-	}
-}

src/main/java/org/springframework/data/elasticsearch/annotations/TermVector.java

@@ -1,24 +0,0 @@
-/*
- * Copyright 2019-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.annotations;
-
-/**
- * @author Peter-Josef Meisch
- * @since 4.0
- */
-public enum TermVector {
-	none, no, yes, with_positions, with_offsets, with_positions_offsets, with_positions_payloads, with_positions_offsets_payloads
-}

src/main/java/org/springframework/data/elasticsearch/annotations/package-info.java

@@ -1,3 +0,0 @@
-@org.springframework.lang.NonNullApi
-@org.springframework.lang.NonNullFields
-package org.springframework.data.elasticsearch.annotations;

src/main/java/org/springframework/data/elasticsearch/client/ClientConfiguration.java

@@ -1,380 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client;
-
-import java.net.InetSocketAddress;
-import java.net.SocketAddress;
-import java.time.Duration;
-import java.util.List;
-import java.util.Optional;
-import java.util.function.Function;
-import java.util.function.Supplier;
-
-import javax.net.ssl.HostnameVerifier;
-import javax.net.ssl.SSLContext;
-
-import org.elasticsearch.client.RestClientBuilder.HttpClientConfigCallback;
-import org.springframework.http.HttpHeaders;
-import org.springframework.lang.Nullable;
-import org.springframework.web.reactive.function.client.WebClient;
-
-/**
- * Configuration interface exposing common client configuration properties for Elasticsearch clients.
- *
- * @author Mark Paluch
- * @author Peter-Josef Meisch
- * @author Huw Ayling-Miller
- * @author Henrique Amaral
- * @since 3.2
- */
-public interface ClientConfiguration {
-
-	/**
-	 * Creates a new {@link ClientConfigurationBuilder} instance.
-	 *
-	 * @return a new {@link ClientConfigurationBuilder} instance.
-	 */
-	static ClientConfigurationBuilderWithRequiredEndpoint builder() {
-		return new ClientConfigurationBuilder();
-	}
-
-	/**
-	 * Creates a new {@link ClientConfiguration} instance configured to localhost.
-	 * <p/>
-	 *
-	 * <pre class="code">
-	 * // "localhost:9200"
-	 * ClientConfiguration configuration = ClientConfiguration.localhost();
-	 * </pre>
-	 *
-	 * @return a new {@link ClientConfiguration} instance
-	 * @see ClientConfigurationBuilder#connectedToLocalhost()
-	 */
-	static ClientConfiguration localhost() {
-		return new ClientConfigurationBuilder().connectedToLocalhost().build();
-	}
-
-	/**
-	 * Creates a new {@link ClientConfiguration} instance configured to a single host given {@code hostAndPort}.
-	 * <p/>
-	 * For example given the endpoint http://localhost:9200
-	 *
-	 * <pre class="code">
-	 * ClientConfiguration configuration = ClientConfiguration.create("localhost:9200");
-	 * </pre>
-	 *
-	 * @return a new {@link ClientConfigurationBuilder} instance.
-	 */
-	static ClientConfiguration create(String hostAndPort) {
-		return new ClientConfigurationBuilder().connectedTo(hostAndPort).build();
-	}
-
-	/**
-	 * Creates a new {@link ClientConfiguration} instance configured to a single host given {@link InetSocketAddress}.
-	 * <p/>
-	 * For example given the endpoint http://localhost:9200
-	 *
-	 * <pre class="code">
-	 * ClientConfiguration configuration = ClientConfiguration
-	 * 		.create(InetSocketAddress.createUnresolved("localhost", 9200));
-	 * </pre>
-	 *
-	 * @return a new {@link ClientConfigurationBuilder} instance.
-	 */
-	static ClientConfiguration create(InetSocketAddress socketAddress) {
-		return new ClientConfigurationBuilder().connectedTo(socketAddress).build();
-	}
-
-	/**
-	 * Returns the configured endpoints.
-	 *
-	 * @return the configured endpoints.
-	 */
-	List<InetSocketAddress> getEndpoints();
-
-	/**
-	 * Obtain the {@link HttpHeaders} to be used by default.
-	 *
-	 * @return the {@link HttpHeaders} to be used by default.
-	 */
-	HttpHeaders getDefaultHeaders();
-
-	/**
-	 * Returns {@literal true} when the client should use SSL.
-	 *
-	 * @return {@literal true} when the client should use SSL.
-	 */
-	boolean useSsl();
-
-	/**
-	 * Returns the {@link SSLContext} to use. Can be {@link Optional#empty()} if unconfigured.
-	 *
-	 * @return the {@link SSLContext} to use. Can be {@link Optional#empty()} if unconfigured.
-	 */
-	Optional<SSLContext> getSslContext();
-
-	/**
-	 * Returns the {@link HostnameVerifier} to use. Can be {@link Optional#empty()} if unconfigured.
-	 *
-	 * @return the {@link HostnameVerifier} to use. Can be {@link Optional#empty()} if unconfigured.
-	 */
-	Optional<HostnameVerifier> getHostNameVerifier();
-
-	/**
-	 * Returns the {@link java.time.Duration connect timeout}.
-	 *
-	 * @see java.net.Socket#connect(SocketAddress, int)
-	 * @see io.netty.channel.ChannelOption#CONNECT_TIMEOUT_MILLIS
-	 */
-	Duration getConnectTimeout();
-
-	/**
-	 * Returns the {@link java.time.Duration socket timeout} which is typically applied as SO-timeout/read timeout.
-	 *
-	 * @see java.net.Socket#setSoTimeout(int)
-	 * @see io.netty.handler.timeout.ReadTimeoutHandler
-	 * @see io.netty.handler.timeout.WriteTimeoutHandler
-	 */
-	Duration getSocketTimeout();
-
-	/**
-	 * Returns the path prefix that should be prepended to HTTP(s) requests for Elasticsearch behind a proxy.
-	 * 
-	 * @return the path prefix.
-	 * @since 4.0
-	 */
-	@Nullable
-	String getPathPrefix();
-
-	/**
-	 * returns an optionally set proxy in the form host:port
-	 * 
-	 * @return the optional proxy
-	 * @since 4.0
-	 */
-	Optional<String> getProxy();
-
-	/**
-	 * @return the function for configuring a WebClient.
-	 */
-	Function<WebClient, WebClient> getWebClientConfigurer();
-
-	/**
-	 * @return the client configuration callback.
-	 * @since 4.2
-	 */
-	HttpClientConfigCallback getHttpClientConfigurer();
-
-	/**
-	 * @return the supplier for custom headers.
-	 */
-	Supplier<HttpHeaders> getHeadersSupplier();
-
-	/**
-	 * @author Christoph Strobl
-	 */
-	interface ClientConfigurationBuilderWithRequiredEndpoint {
-
-		/**
-		 * @param hostAndPort the {@literal host} and {@literal port} formatted as String {@literal host:port}.
-		 * @return the {@link MaybeSecureClientConfigurationBuilder}.
-		 */
-		default MaybeSecureClientConfigurationBuilder connectedTo(String hostAndPort) {
-			return connectedTo(new String[] { hostAndPort });
-		}
-
-		/**
-		 * @param hostAndPorts the list of {@literal host} and {@literal port} combinations formatted as String
-		 *          {@literal host:port}.
-		 * @return the {@link MaybeSecureClientConfigurationBuilder}.
-		 */
-		MaybeSecureClientConfigurationBuilder connectedTo(String... hostAndPorts);
-
-		/**
-		 * @param endpoint the {@literal host} and {@literal port}.
-		 * @return the {@link MaybeSecureClientConfigurationBuilder}.
-		 */
-		default MaybeSecureClientConfigurationBuilder connectedTo(InetSocketAddress endpoint) {
-			return connectedTo(new InetSocketAddress[] { endpoint });
-		}
-
-		/**
-		 * @param endpoints the list of {@literal host} and {@literal port} combinations.
-		 * @return the {@link MaybeSecureClientConfigurationBuilder}.
-		 */
-		MaybeSecureClientConfigurationBuilder connectedTo(InetSocketAddress... endpoints);
-
-		/**
-		 * Obviously for testing.
-		 *
-		 * @return the {@link MaybeSecureClientConfigurationBuilder}.
-		 */
-		default MaybeSecureClientConfigurationBuilder connectedToLocalhost() {
-			return connectedTo("localhost:9200");
-		}
-	}
-
-	/**
-	 * @author Christoph Strobl
-	 */
-	interface MaybeSecureClientConfigurationBuilder extends TerminalClientConfigurationBuilder {
-
-		/**
-		 * Connect via {@literal https} <br />
-		 * <strong>NOTE</strong> You need to leave out the protocol in
-		 * {@link ClientConfigurationBuilderWithRequiredEndpoint#connectedTo(String)}.
-		 *
-		 * @return the {@link TerminalClientConfigurationBuilder}.
-		 */
-		TerminalClientConfigurationBuilder usingSsl();
-
-		/**
-		 * Connect via {@literal https} using the given {@link SSLContext}.<br />
-		 * <strong>NOTE</strong> You need to leave out the protocol in
-		 * {@link ClientConfigurationBuilderWithRequiredEndpoint#connectedTo(String)}.
-		 *
-		 * @return the {@link TerminalClientConfigurationBuilder}.
-		 */
-		TerminalClientConfigurationBuilder usingSsl(SSLContext sslContext);
-
-		/**
-		 * Connect via {@literal https} using the givens {@link SSLContext} and HostnameVerifier {@link HostnameVerifier}
-		 * .<br />
-		 * <strong>NOTE</strong> You need to leave out the protocol in
-		 * {@link ClientConfigurationBuilderWithRequiredEndpoint#connectedTo(String)}.
-		 *
-		 * @return the {@link TerminalClientConfigurationBuilder}.
-		 */
-		TerminalClientConfigurationBuilder usingSsl(SSLContext sslContext, HostnameVerifier hostnameVerifier);
-	}
-
-	/**
-	 * @author Christoph Strobl
-	 * @author Mark Paluch
-	 */
-	interface TerminalClientConfigurationBuilder {
-
-		/**
-		 * @param defaultHeaders must not be {@literal null}.
-		 * @return the {@link TerminalClientConfigurationBuilder}
-		 */
-		TerminalClientConfigurationBuilder withDefaultHeaders(HttpHeaders defaultHeaders);
-
-		/**
-		 * Configure the {@literal milliseconds} for the connect timeout.
-		 *
-		 * @param millis the timeout to use.
-		 * @return the {@link TerminalClientConfigurationBuilder}
-		 * @see #withConnectTimeout(Duration)
-		 */
-		default TerminalClientConfigurationBuilder withConnectTimeout(long millis) {
-			return withConnectTimeout(Duration.ofMillis(millis));
-		}
-
-		/**
-		 * Configure a {@link java.time.Duration} connect timeout.
-		 *
-		 * @param timeout the timeout to use. Must not be {@literal null}.
-		 * @return the {@link TerminalClientConfigurationBuilder}
-		 * @see java.net.Socket#connect(SocketAddress, int)
-		 * @see io.netty.channel.ChannelOption#CONNECT_TIMEOUT_MILLIS
-		 */
-		TerminalClientConfigurationBuilder withConnectTimeout(Duration timeout);
-
-		/**
-		 * Configure the {@literal milliseconds} for the socket timeout.
-		 *
-		 * @param millis the timeout to use.
-		 * @return the {@link TerminalClientConfigurationBuilder}
-		 * @see #withSocketTimeout(Duration)
-		 */
-		default TerminalClientConfigurationBuilder withSocketTimeout(long millis) {
-			return withSocketTimeout(Duration.ofMillis(millis));
-		}
-
-		/**
-		 * Configure a {@link java.time.Duration socket timeout} which is typically applied as SO-timeout/read timeout.
-		 *
-		 * @param timeout the timeout to use. Must not be {@literal null}.
-		 * @return the {@link TerminalClientConfigurationBuilder}
-		 * @see java.net.Socket#setSoTimeout(int)
-		 * @see io.netty.handler.timeout.ReadTimeoutHandler
-		 * @see io.netty.handler.timeout.WriteTimeoutHandler
-		 */
-		TerminalClientConfigurationBuilder withSocketTimeout(Duration timeout);
-
-		/**
-		 * Configure the username and password to be sent as a Basic Authentication header
-		 *
-		 * @param username the username. Must not be {@literal null}.
-		 * @param password the password. Must not be {@literal null}.
-		 * @return the {@link TerminalClientConfigurationBuilder}
-		 */
-		TerminalClientConfigurationBuilder withBasicAuth(String username, String password);
-
-		/**
-		 * Configure the path prefix that will be prepended to any HTTP(s) requests
-		 * 
-		 * @param pathPrefix the pathPrefix.
-		 * @return the {@link TerminalClientConfigurationBuilder}
-		 * @since 4.0
-		 */
-		TerminalClientConfigurationBuilder withPathPrefix(String pathPrefix);
-
-		/**
-		 * @param proxy a proxy formatted as String {@literal host:port}.
-		 * @return the {@link TerminalClientConfigurationBuilder}.
-		 */
-		TerminalClientConfigurationBuilder withProxy(String proxy);
-
-		/**
-		 * set customization hook in case of a reactive configuration
-		 * 
-		 * @param webClientConfigurer function to configure the WebClient
-		 * @return the {@link TerminalClientConfigurationBuilder}.
-		 */
-		TerminalClientConfigurationBuilder withWebClientConfigurer(Function<WebClient, WebClient> webClientConfigurer);
-
-		/**
-		 * Register a {HttpClientConfigCallback} to configure the non-reactive REST client.
-		 * 
-		 * @param httpClientConfigurer configuration callback, must not be null.
-		 * @return the {@link TerminalClientConfigurationBuilder}.
-		 * @since 4.2
-		 */
-		TerminalClientConfigurationBuilder withHttpClientConfigurer(HttpClientConfigCallback httpClientConfigurer);
-
-		/**
-		 * set a supplier for custom headers. This is invoked for every HTTP request to Elasticsearch to retrieve headers
-		 * that should be sent with the request. A common use case is passing in authentication headers that may change.
-		 * <br/>
-		 * Note: When used in a reactive environment, the calling of {@link Supplier#get()} function must not do any
-		 * blocking operations. It may return {@literal null}.
-		 *
-		 * @param headers supplier function for headers, must not be {@literal null}
-		 * @return the {@link TerminalClientConfigurationBuilder}.
-		 * @since 4.0
-		 */
-		TerminalClientConfigurationBuilder withHeaders(Supplier<HttpHeaders> headers);
-
-		/**
-		 * Build the {@link ClientConfiguration} object.
-		 *
-		 * @return the {@link ClientConfiguration} object.
-		 */
-		ClientConfiguration build();
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/ClientConfigurationBuilder.java

@@ -1,252 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client;
-
-import java.net.InetSocketAddress;
-import java.time.Duration;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.function.Function;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-
-import javax.net.ssl.HostnameVerifier;
-import javax.net.ssl.SSLContext;
-
-import org.elasticsearch.client.RestClientBuilder.HttpClientConfigCallback;
-import org.springframework.data.elasticsearch.client.ClientConfiguration.ClientConfigurationBuilderWithRequiredEndpoint;
-import org.springframework.data.elasticsearch.client.ClientConfiguration.MaybeSecureClientConfigurationBuilder;
-import org.springframework.data.elasticsearch.client.ClientConfiguration.TerminalClientConfigurationBuilder;
-import org.springframework.http.HttpHeaders;
-import org.springframework.lang.Nullable;
-import org.springframework.util.Assert;
-import org.springframework.web.reactive.function.client.WebClient;
-
-/**
- * Default builder implementation for {@link ClientConfiguration}.
- *
- * @author Christoph Strobl
- * @author Mark Paluch
- * @author Peter-Josef Meisch
- * @author Huw Ayling-Miller
- * @author Henrique Amaral
- * @since 3.2
- */
-class ClientConfigurationBuilder
-		implements ClientConfigurationBuilderWithRequiredEndpoint, MaybeSecureClientConfigurationBuilder {
-
-	private List<InetSocketAddress> hosts = new ArrayList<>();
-	private HttpHeaders headers = HttpHeaders.EMPTY;
-	private boolean useSsl;
-	private @Nullable SSLContext sslContext;
-	private @Nullable HostnameVerifier hostnameVerifier;
-	private Duration connectTimeout = Duration.ofSeconds(10);
-	private Duration soTimeout = Duration.ofSeconds(5);
-	private @Nullable String username;
-	private @Nullable String password;
-	private @Nullable String pathPrefix;
-	private @Nullable String proxy;
-	private Function<WebClient, WebClient> webClientConfigurer = Function.identity();
-	private Supplier<HttpHeaders> headersSupplier = () -> HttpHeaders.EMPTY;
-	private HttpClientConfigCallback httpClientConfigurer = httpClientBuilder -> httpClientBuilder;
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.ClientConfiguration.ClientConfigurationBuilderWithRequiredEndpoint#connectedTo(java.lang.String[])
-	 */
-	@Override
-	public MaybeSecureClientConfigurationBuilder connectedTo(String... hostAndPorts) {
-
-		Assert.notEmpty(hostAndPorts, "At least one host is required");
-
-		this.hosts.addAll(Arrays.stream(hostAndPorts).map(ClientConfigurationBuilder::parse).collect(Collectors.toList()));
-		return this;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.ClientConfiguration.ClientConfigurationBuilderWithRequiredEndpoint#connectedTo(java.net.InetSocketAddress[])
-	 */
-	@Override
-	public MaybeSecureClientConfigurationBuilder connectedTo(InetSocketAddress... endpoints) {
-
-		Assert.notEmpty(endpoints, "At least one endpoint is required");
-
-		this.hosts.addAll(Arrays.asList(endpoints));
-
-		return this;
-	}
-
-	@Override
-	public MaybeSecureClientConfigurationBuilder withProxy(String proxy) {
-		Assert.hasLength(proxy, "proxy must not be null or empty");
-		this.proxy = proxy;
-		return this;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.ClientConfiguration.MaybeSecureClientConfigurationBuilder#usingSsl()
-	 */
-	@Override
-	public TerminalClientConfigurationBuilder usingSsl() {
-
-		this.useSsl = true;
-		return this;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.ClientConfiguration.MaybeSecureClientConfigurationBuilder#usingSsl(javax.net.ssl.SSLContext)
-	 */
-	@Override
-	public TerminalClientConfigurationBuilder usingSsl(SSLContext sslContext) {
-
-		Assert.notNull(sslContext, "SSL Context must not be null");
-
-		this.useSsl = true;
-		this.sslContext = sslContext;
-		return this;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.ClientConfiguration.MaybeSecureClientConfigurationBuilder#usingSsl(javax.net.ssl.SSLContext, javax.net.ssl.HostnameVerifier)
-	 */
-	@Override
-	public TerminalClientConfigurationBuilder usingSsl(SSLContext sslContext, HostnameVerifier hostnameVerifier) {
-
-		Assert.notNull(sslContext, "SSL Context must not be null");
-		Assert.notNull(hostnameVerifier, "Host Name Verifier must not be null");
-
-		this.useSsl = true;
-		this.sslContext = sslContext;
-		this.hostnameVerifier = hostnameVerifier;
-		return this;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.ClientConfiguration.TerminalClientConfigurationBuilder#withDefaultHeaders(org.springframework.http.HttpHeaders)
-	 */
-	@Override
-	public TerminalClientConfigurationBuilder withDefaultHeaders(HttpHeaders defaultHeaders) {
-
-		Assert.notNull(defaultHeaders, "Default HTTP headers must not be null");
-
-		this.headers = new HttpHeaders();
-		this.headers.addAll(defaultHeaders);
-
-		return this;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.ClientConfiguration.TerminalClientConfigurationBuilder#withConnectTimeout(java.time.Duration)
-	 */
-	@Override
-	public TerminalClientConfigurationBuilder withConnectTimeout(Duration timeout) {
-
-		Assert.notNull(timeout, "I/O timeout must not be null!");
-
-		this.connectTimeout = timeout;
-		return this;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.ClientConfiguration.TerminalClientConfigurationBuilder#withTimeout(java.time.Duration)
-	 */
-	@Override
-	public TerminalClientConfigurationBuilder withSocketTimeout(Duration timeout) {
-
-		Assert.notNull(timeout, "Socket timeout must not be null!");
-
-		this.soTimeout = timeout;
-		return this;
-	}
-
-	@Override
-	public TerminalClientConfigurationBuilder withBasicAuth(String username, String password) {
-
-		Assert.notNull(username, "username must not be null");
-		Assert.notNull(password, "password must not be null");
-
-		this.username = username;
-		this.password = password;
-
-		return this;
-	}
-
-	@Override
-	public TerminalClientConfigurationBuilder withPathPrefix(String pathPrefix) {
-		this.pathPrefix = pathPrefix;
-
-		return this;
-	}
-
-	@Override
-	public TerminalClientConfigurationBuilder withWebClientConfigurer(
-			Function<WebClient, WebClient> webClientConfigurer) {
-
-		Assert.notNull(webClientConfigurer, "webClientConfigurer must not be null");
-
-		this.webClientConfigurer = webClientConfigurer;
-		return this;
-	}
-
-	@Override
-	public TerminalClientConfigurationBuilder withHttpClientConfigurer(HttpClientConfigCallback httpClientConfigurer) {
-
-		Assert.notNull(httpClientConfigurer, "httpClientConfigurer must not be null");
-
-		this.httpClientConfigurer = httpClientConfigurer;
-		return this;
-	}
-
-	@Override
-	public TerminalClientConfigurationBuilder withHeaders(Supplier<HttpHeaders> headers) {
-
-		Assert.notNull(headers, "headersSupplier must not be null");
-
-		this.headersSupplier = headers;
-		return this;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.ClientConfiguration.ClientConfigurationBuilderWithOptionalDefaultHeaders#build()
-	 */
-	@Override
-	public ClientConfiguration build() {
-
-		if (username != null && password != null) {
-			if (HttpHeaders.EMPTY.equals(headers)) {
-				headers = new HttpHeaders();
-			}
-			headers.setBasicAuth(username, password);
-		}
-
-		return new DefaultClientConfiguration(hosts, headers, useSsl, sslContext, soTimeout, connectTimeout, pathPrefix,
-				hostnameVerifier, proxy, webClientConfigurer, httpClientConfigurer, headersSupplier);
-	}
-
-	private static InetSocketAddress parse(String hostAndPort) {
-		return InetSocketAddressParser.parse(hostAndPort, ElasticsearchHost.DEFAULT_PORT);
-	}
-
-}

src/main/java/org/springframework/data/elasticsearch/client/ClientLogger.java

@@ -1,128 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client;
-
-import java.util.function.Supplier;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.http.HttpStatus;
-import org.springframework.lang.Nullable;
-import org.springframework.util.ObjectUtils;
-
-/**
- * Logging Utility to log client requests and responses. Logs client requests and responses to Elasticsearch to a
- * dedicated logger: {@code org.springframework.data.elasticsearch.client.WIRE} on {@link org.slf4j.event.Level#TRACE}
- * level.
- *
- * @author Mark Paluch
- * @author Christoph Strobl
- * @since 3.2
- */
-public abstract class ClientLogger {
-
-	private static final String lineSeparator = System.getProperty("line.separator");
-	private static final Logger WIRE_LOGGER = LoggerFactory
-			.getLogger("org.springframework.data.elasticsearch.client.WIRE");
-
-	private ClientLogger() {}
-
-	/**
-	 * Returns {@literal true} if the logger is enabled.
-	 *
-	 * @return {@literal true} if the logger is enabled.
-	 */
-	public static boolean isEnabled() {
-		return WIRE_LOGGER.isTraceEnabled();
-	}
-
-	/**
-	 * Log an outgoing HTTP request.
-	 *
-	 * @param logId the correlation Id, see {@link #newLogId()}.
-	 * @param method HTTP method
-	 * @param endpoint URI
-	 * @param parameters optional parameters.
-	 */
-	public static void logRequest(String logId, String method, String endpoint, Object parameters) {
-
-		if (isEnabled()) {
-
-			WIRE_LOGGER.trace("[{}] Sending request {} {} with parameters: {}", logId, method.toUpperCase(), endpoint,
-					parameters);
-		}
-	}
-
-	/**
-	 * Log an outgoing HTTP request with a request body.
-	 *
-	 * @param logId the correlation Id, see {@link #newLogId()}.
-	 * @param method HTTP method
-	 * @param endpoint URI
-	 * @param parameters optional parameters.
-	 * @param body body content supplier.
-	 */
-	public static void logRequest(String logId, String method, String endpoint, Object parameters,
-			Supplier<Object> body) {
-
-		if (isEnabled()) {
-
-			WIRE_LOGGER.trace("[{}] Sending request {} {} with parameters: {}{}Request body: {}", logId, method.toUpperCase(),
-					endpoint, parameters, lineSeparator, body.get());
-		}
-	}
-
-	/**
-	 * Log a raw HTTP response without logging the body.
-	 *
-	 * @param logId the correlation Id, see {@link #newLogId()}.
-	 * @param statusCode the HTTP status code.
-	 */
-	public static void logRawResponse(String logId, @Nullable HttpStatus statusCode) {
-
-		if (isEnabled()) {
-			WIRE_LOGGER.trace("[{}] Received raw response: {}", logId, statusCode);
-		}
-	}
-
-	/**
-	 * Log a raw HTTP response along with the body.
-	 *
-	 * @param logId the correlation Id, see {@link #newLogId()}.
-	 * @param statusCode the HTTP status code.
-	 * @param body body content.
-	 */
-	public static void logResponse(String logId, HttpStatus statusCode, String body) {
-
-		if (isEnabled()) {
-			WIRE_LOGGER.trace("[{}] Received response: {}{}Response body: {}", logId, statusCode, lineSeparator, body);
-		}
-	}
-
-	/**
-	 * Creates a new, unique correlation Id to improve tracing across log events.
-	 *
-	 * @return a new, unique correlation Id.
-	 */
-	public static String newLogId() {
-
-		if (!isEnabled()) {
-			return "-";
-		}
-
-		return ObjectUtils.getIdentityHexString(new Object());
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/ClusterNodes.java

@@ -1,102 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client;
-
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import org.elasticsearch.common.transport.TransportAddress;
-import org.springframework.data.util.Streamable;
-import org.springframework.util.Assert;
-import org.springframework.util.StringUtils;
-
-/**
- * Value object to represent a list of cluster nodes.
- *
- * @author Oliver Gierke
- * @since 3.1
- */
-class ClusterNodes implements Streamable<TransportAddress> {
-
-	public static ClusterNodes DEFAULT = ClusterNodes.of("127.0.0.1:9300");
-
-	private static final String COLON = ":";
-	private static final String COMMA = ",";
-
-	private final List<TransportAddress> clusterNodes;
-
-	/**
-	 * Creates a new {@link ClusterNodes} by parsing the given source.
-	 * 
-	 * @param source must not be {@literal null} or empty.
-	 */
-	private ClusterNodes(String source) {
-
-		Assert.hasText(source, "Cluster nodes source must not be null or empty!");
-
-		String[] nodes = StringUtils.delimitedListToStringArray(source, COMMA);
-
-		this.clusterNodes = Arrays.stream(nodes).map(node -> {
-
-			String[] segments = StringUtils.delimitedListToStringArray(node, COLON);
-
-			Assert.isTrue(segments.length == 2,
-					() -> String.format("Invalid cluster node %s in %s! Must be in the format host:port!", node, source));
-
-			String host = segments[0].trim();
-			String port = segments[1].trim();
-
-			Assert.hasText(host, () -> String.format("No host name given cluster node %s!", node));
-			Assert.hasText(port, () -> String.format("No port given in cluster node %s!", node));
-
-			return new TransportAddress(toInetAddress(host), Integer.parseInt(port));
-
-		}).collect(Collectors.toList());
-	}
-
-	/**
-	 * Creates a new {@link ClusterNodes} by parsing the given source. The expected format is a comma separated list of
-	 * host-port-combinations separated by a colon: {@code host:port,host:port,…}.
-	 * 
-	 * @param source must not be {@literal null} or empty.
-	 * @return
-	 */
-	public static ClusterNodes of(String source) {
-		return new ClusterNodes(source);
-	}
-
-	/* 
-	 * (non-Javadoc)
-	 * @see java.lang.Iterable#iterator()
-	 */
-	@Override
-	public Iterator<TransportAddress> iterator() {
-		return clusterNodes.iterator();
-	}
-
-	private static InetAddress toInetAddress(String host) {
-
-		try {
-			return InetAddress.getByName(host);
-		} catch (UnknownHostException o_O) {
-			throw new IllegalArgumentException(o_O);
-		}
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/DefaultClientConfiguration.java

@@ -1,139 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client;
-
-import java.net.InetSocketAddress;
-import java.time.Duration;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Optional;
-import java.util.function.Function;
-import java.util.function.Supplier;
-
-import javax.net.ssl.HostnameVerifier;
-import javax.net.ssl.SSLContext;
-
-import org.elasticsearch.client.RestClientBuilder.HttpClientConfigCallback;
-import org.springframework.http.HttpHeaders;
-import org.springframework.lang.Nullable;
-import org.springframework.web.reactive.function.client.WebClient;
-
-/**
- * Default {@link ClientConfiguration} implementation.
- *
- * @author Mark Paluch
- * @author Christoph Strobl
- * @author Huw Ayling-Miller
- * @author Peter-Josef Meisch
- * @since 3.2
- */
-class DefaultClientConfiguration implements ClientConfiguration {
-
-	private final List<InetSocketAddress> hosts;
-	private final HttpHeaders headers;
-	private final boolean useSsl;
-	private final @Nullable SSLContext sslContext;
-	private final Duration soTimeout;
-	private final Duration connectTimeout;
-	private final @Nullable String pathPrefix;
-	private final @Nullable HostnameVerifier hostnameVerifier;
-	private final @Nullable String proxy;
-	private final Function<WebClient, WebClient> webClientConfigurer;
-	private final HttpClientConfigCallback httpClientConfigurer;
-	private final Supplier<HttpHeaders> headersSupplier;
-
-	DefaultClientConfiguration(List<InetSocketAddress> hosts, HttpHeaders headers, boolean useSsl,
-			@Nullable SSLContext sslContext, Duration soTimeout, Duration connectTimeout, @Nullable String pathPrefix,
-			@Nullable HostnameVerifier hostnameVerifier, @Nullable String proxy,
-			Function<WebClient, WebClient> webClientConfigurer, HttpClientConfigCallback httpClientConfigurer,
-			Supplier<HttpHeaders> headersSupplier) {
-
-		this.hosts = Collections.unmodifiableList(new ArrayList<>(hosts));
-		this.headers = new HttpHeaders(headers);
-		this.useSsl = useSsl;
-		this.sslContext = sslContext;
-		this.soTimeout = soTimeout;
-		this.connectTimeout = connectTimeout;
-		this.pathPrefix = pathPrefix;
-		this.hostnameVerifier = hostnameVerifier;
-		this.proxy = proxy;
-		this.webClientConfigurer = webClientConfigurer;
-		this.httpClientConfigurer = httpClientConfigurer;
-		this.headersSupplier = headersSupplier;
-	}
-
-	@Override
-	public List<InetSocketAddress> getEndpoints() {
-		return this.hosts;
-	}
-
-	@Override
-	public HttpHeaders getDefaultHeaders() {
-		return this.headers;
-	}
-
-	@Override
-	public boolean useSsl() {
-		return this.useSsl;
-	}
-
-	@Override
-	public Optional<SSLContext> getSslContext() {
-		return Optional.ofNullable(this.sslContext);
-	}
-
-	@Override
-	public Optional<HostnameVerifier> getHostNameVerifier() {
-		return Optional.ofNullable(this.hostnameVerifier);
-	}
-
-	@Override
-	public Duration getConnectTimeout() {
-		return this.connectTimeout;
-	}
-
-	@Override
-	public Duration getSocketTimeout() {
-		return this.soTimeout;
-	}
-
-	@Nullable
-	@Override
-	public String getPathPrefix() {
-		return this.pathPrefix;
-	}
-
-	@Override
-	public Optional<String> getProxy() {
-		return Optional.ofNullable(proxy);
-	}
-
-	@Override
-	public Function<WebClient, WebClient> getWebClientConfigurer() {
-		return webClientConfigurer;
-	}
-
-	@Override
-	public HttpClientConfigCallback getHttpClientConfigurer() {
-		return httpClientConfigurer;
-	}
-
-	@Override
-	public Supplier<HttpHeaders> getHeadersSupplier() {
-		return headersSupplier;
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/ElasticsearchHost.java

@@ -1,113 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.data.elasticsearch.client;
-
-import java.net.InetSocketAddress;
-import java.time.Instant;
-
-import org.springframework.util.Assert;
-
-/**
- * Value Object containing information about Elasticsearch cluster nodes.
- *
- * @author Christoph Strobl
- * @since 3.2
- */
-public class ElasticsearchHost {
-
-	/**
-	 * Default HTTP port for Elasticsearch servers.
-	 */
-	public static final int DEFAULT_PORT = 9200;
-
-	private final InetSocketAddress endpoint;
-	private final State state;
-	private final Instant timestamp;
-
-	public ElasticsearchHost(InetSocketAddress endpoint, State state) {
-
-		Assert.notNull(endpoint, "Host must not be null");
-		Assert.notNull(state, "State must not be null");
-
-		this.endpoint = endpoint;
-		this.state = state;
-		this.timestamp = Instant.now();
-	}
-
-	/**
-	 * @param host must not be {@literal null}.
-	 * @return new instance of {@link ElasticsearchHost}.
-	 */
-	public static ElasticsearchHost online(InetSocketAddress host) {
-		return new ElasticsearchHost(host, State.ONLINE);
-	}
-
-	/**
-	 * @param host must not be {@literal null}.
-	 * @return new instance of {@link ElasticsearchHost}.
-	 */
-	public static ElasticsearchHost offline(InetSocketAddress host) {
-		return new ElasticsearchHost(host, State.OFFLINE);
-	}
-
-	/**
-	 * Parse a {@literal hostAndPort} string into a {@link InetSocketAddress}.
-	 *
-	 * @param hostAndPort the string containing host and port or IP address and port in the format {@code host:port}.
-	 * @return the parsed {@link InetSocketAddress}.
-	 */
-	public static InetSocketAddress parse(String hostAndPort) {
-		return InetSocketAddressParser.parse(hostAndPort, DEFAULT_PORT);
-	}
-
-	/**
-	 * @return {@literal true} if the last known {@link State} was {@link State#ONLINE}
-	 */
-	public boolean isOnline() {
-		return State.ONLINE.equals(state);
-	}
-
-	/**
-	 * @return never {@literal null}.
-	 */
-	public InetSocketAddress getEndpoint() {
-		return endpoint;
-	}
-
-	/**
-	 * @return the last known {@link State}.
-	 */
-	public State getState() {
-		return state;
-	}
-
-	/**
-	 * @return the {@link Instant} the information was captured.
-	 */
-	public Instant getTimestamp() {
-		return timestamp;
-	}
-
-	@Override
-	public String toString() {
-		return "ElasticsearchHost(" + endpoint + ", " + state.name() + ')';
-	}
-
-	public enum State {
-		ONLINE, OFFLINE, UNKNOWN
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/InetSocketAddressParser.java

@@ -1,117 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client;
-
-import java.net.InetSocketAddress;
-
-import org.springframework.util.Assert;
-import org.springframework.util.StringUtils;
-
-/**
- * Utility to parse endpoints in {@code host:port} format into {@link java.net.InetSocketAddress}.
- *
- * @author Mark Paluch
- * @since 3.2
- */
-class InetSocketAddressParser {
-
-	/**
-	 * Parse a host and port string into a {@link InetSocketAddress}.
-	 *
-	 * @param hostPortString Hostname/IP address and port formatted as {@code host:port} or {@code host}.
-	 * @param defaultPort default port to apply if {@code hostPostString} does not contain a port.
-	 * @return a {@link InetSocketAddress} that is unresolved to avoid DNS lookups.
-	 * @see InetSocketAddress#createUnresolved(String, int)
-	 */
-	static InetSocketAddress parse(String hostPortString, int defaultPort) {
-
-		Assert.notNull(hostPortString, "HostPortString must not be null");
-		String host;
-		String portString = null;
-
-		if (hostPortString.startsWith("[")) {
-			String[] hostAndPort = getHostAndPortFromBracketedHost(hostPortString);
-			host = hostAndPort[0];
-			portString = hostAndPort[1];
-		} else {
-			int colonPos = hostPortString.indexOf(':');
-			if (colonPos >= 0 && hostPortString.indexOf(':', colonPos + 1) == -1) {
-				// Exactly 1 colon. Split into host:port.
-				host = hostPortString.substring(0, colonPos);
-				portString = hostPortString.substring(colonPos + 1);
-			} else {
-				// 0 or 2+ colons. Bare hostname or IPv6 literal.
-				host = hostPortString;
-			}
-		}
-
-		int port = defaultPort;
-		if (StringUtils.hasText(portString)) {
-			// Try to parse the whole port string as a number.
-			Assert.isTrue(!portString.startsWith("+"), String.format("Cannot parse port number: %s", hostPortString));
-			try {
-				port = Integer.parseInt(portString);
-			} catch (NumberFormatException e) {
-				throw new IllegalArgumentException(String.format("Cannot parse port number: %s", hostPortString));
-			}
-
-			Assert.isTrue(isValidPort(port), String.format("Port number out of range: %s", hostPortString));
-		}
-
-		return InetSocketAddress.createUnresolved(host, port);
-	}
-
-	/**
-	 * Parses a bracketed host-port string, throwing IllegalArgumentException if parsing fails.
-	 *
-	 * @param hostPortString the full bracketed host-port specification. Post might not be specified.
-	 * @return an array with 2 strings: host and port, in that order.
-	 * @throws IllegalArgumentException if parsing the bracketed host-port string fails.
-	 */
-	private static String[] getHostAndPortFromBracketedHost(String hostPortString) {
-
-		Assert.isTrue(hostPortString.charAt(0) == '[',
-				String.format("Bracketed host-port string must start with a bracket: %s", hostPortString));
-
-		int colonIndex = hostPortString.indexOf(':');
-		int closeBracketIndex = hostPortString.lastIndexOf(']');
-
-		Assert.isTrue(colonIndex > -1 && closeBracketIndex > colonIndex,
-				String.format("Invalid bracketed host/port: %s", hostPortString));
-
-		String host = hostPortString.substring(1, closeBracketIndex);
-		if (closeBracketIndex + 1 == hostPortString.length()) {
-			return new String[] { host, "" };
-		} else {
-
-			Assert.isTrue(hostPortString.charAt(closeBracketIndex + 1) == ':',
-					"Only a colon may follow a close bracket: " + hostPortString);
-			for (int i = closeBracketIndex + 2; i < hostPortString.length(); ++i) {
-				Assert.isTrue(Character.isDigit(hostPortString.charAt(i)),
-						String.format("Port must be numeric: %s", hostPortString));
-			}
-			return new String[] { host, hostPortString.substring(closeBracketIndex + 2) };
-		}
-	}
-
-	/**
-	 * @param port the port number
-	 * @return {@literal true} for valid port numbers.
-	 */
-	private static boolean isValidPort(int port) {
-		return port >= 0 && port <= 65535;
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/NoReachableHostException.java

@@ -1,45 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.data.elasticsearch.client;
-
-import java.util.Set;
-
-/**
- * {@link RuntimeException} to be emitted / thrown when the cluster is down (aka none of the known nodes is reachable).
- *
- * @author Christoph Strobl
- * @since 3.2
- */
-public class NoReachableHostException extends RuntimeException {
-
-	public NoReachableHostException(Set<ElasticsearchHost> hosts) {
-		super(createMessage(hosts));
-	}
-
-	public NoReachableHostException(Set<ElasticsearchHost> hosts, Throwable cause) {
-		super(createMessage(hosts), cause);
-	}
-
-	private static String createMessage(Set<ElasticsearchHost> hosts) {
-
-		if (hosts.size() == 1) {
-			return String.format("Host '%s' not reachable. Cluster state is offline.", hosts.iterator().next().getEndpoint());
-		}
-
-		return String.format("No active host found in cluster. (%s) of (%s) nodes offline.", hosts.size(), hosts.size());
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/NodeClientFactoryBean.java

@@ -1,173 +1,127 @@
-/*
- * Copyright 2015-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Collection;
-import java.util.Collections;
-
-import org.elasticsearch.client.Client;
-import org.elasticsearch.client.node.NodeClient;
-import org.elasticsearch.common.logging.LogConfigurator;
-import org.elasticsearch.common.settings.Settings;
-import org.elasticsearch.node.InternalSettingsPreparer;
-import org.elasticsearch.node.Node;
-import org.elasticsearch.plugins.Plugin;
-import org.elasticsearch.transport.Netty4Plugin;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.DisposableBean;
-import org.springframework.beans.factory.FactoryBean;
-import org.springframework.beans.factory.FactoryBeanNotInitializedException;
-import org.springframework.beans.factory.InitializingBean;
-import org.springframework.lang.Nullable;
-import org.springframework.util.StringUtils;
-
-/**
- * NodeClientFactoryBean
- *
- * @author Rizwan Idrees
- * @author Mohsin Husen
- * @author Ilkang Na
- * @author Peter-Josef Meisch
- * @deprecated since 4.1, we're not supporting embedded Node clients anymore, use the REST client
- */
-@Deprecated
-public class NodeClientFactoryBean implements FactoryBean<Client>, InitializingBean, DisposableBean {
-
-	private static final Logger logger = LoggerFactory.getLogger(NodeClientFactoryBean.class);
-	private boolean local;
-	private boolean enableHttp;
-	private @Nullable String clusterName;
-	private @Nullable Node node;
-	private @Nullable NodeClient nodeClient;
-	private @Nullable String pathData;
-	private @Nullable String pathHome;
-	private @Nullable String pathConfiguration;
-
-	public static class TestNode extends Node {
-
-		private static final String DEFAULT_NODE_NAME = "spring-data-elasticsearch-nodeclientfactorybean-test";
-
-		public TestNode(Settings preparedSettings, Collection<Class<? extends Plugin>> classpathPlugins) {
-
-			super(InternalSettingsPreparer.prepareEnvironment(preparedSettings, Collections.emptyMap(), null,
-					() -> DEFAULT_NODE_NAME), classpathPlugins, false);
-		}
-
-		protected void registerDerivedNodeNameWithLogger(String nodeName) {
-			try {
-				LogConfigurator.setNodeName(nodeName);
-			} catch (Exception e) {
-				// nagh - just forget about it
-			}
-		}
-	}
-
-	NodeClientFactoryBean() {}
-
-	public NodeClientFactoryBean(boolean local) {
-		this.local = local;
-	}
-
-	@Override
-	public NodeClient getObject() {
-
-		if (nodeClient == null) {
-			throw new FactoryBeanNotInitializedException();
-		}
-
-		return nodeClient;
-	}
-
-	@Override
-	public Class<? extends Client> getObjectType() {
-		return NodeClient.class;
-	}
-
-	@Override
-	public boolean isSingleton() {
-		return true;
-	}
-
-	@Override
-	public void afterPropertiesSet() throws Exception {
-
-		Settings settings = Settings.builder() //
-				.put(loadConfig()) //
-				.put("transport.type", "netty4") //
-				.put("http.type", "netty4") //
-				.put("path.home", this.pathHome) //
-				.put("path.data", this.pathData) //
-				.put("cluster.name", this.clusterName) //
-				.put("node.max_local_storage_nodes", 100) //
-				.build();
-		node = new TestNode(settings, Collections.singletonList(Netty4Plugin.class));
-		nodeClient = (NodeClient) node.start().client();
-	}
-
-	private Settings loadConfig() throws IOException {
-		if (!StringUtils.isEmpty(pathConfiguration)) {
-			InputStream stream = getClass().getClassLoader().getResourceAsStream(pathConfiguration);
-			if (stream != null) {
-				return Settings.builder().loadFromStream(pathConfiguration,
-						getClass().getClassLoader().getResourceAsStream(pathConfiguration), false).build();
-			}
-			logger.error(String.format("Unable to read node configuration from file [%s]", pathConfiguration));
-		}
-		return Settings.builder().build();
-	}
-
-	public void setLocal(boolean local) {
-		this.local = local;
-	}
-
-	public void setEnableHttp(boolean enableHttp) {
-		this.enableHttp = enableHttp;
-	}
-
-	public void setClusterName(String clusterName) {
-		this.clusterName = clusterName;
-	}
-
-	public void setPathData(String pathData) {
-		this.pathData = pathData;
-	}
-
-	public void setPathHome(String pathHome) {
-		this.pathHome = pathHome;
-	}
-
-	public void setPathConfiguration(String configuration) {
-		this.pathConfiguration = configuration;
-	}
-
-	@Override
-	public void destroy() {
-		try {
-			// NodeClient.close() is a noop, no need to call it here
-			nodeClient = null;
-			logger.info("Closing elasticSearch node");
-			if (node != null) {
-				node.close();
-				node = null;
-			}
-		} catch (final Exception e) {
-			logger.error("Error closing ElasticSearch client: ", e);
-		}
-	}
-}
+/*
+ * Copyright 2015 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch.client;
+
+import static org.elasticsearch.node.NodeBuilder.*;
+
+import java.io.InputStream;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.client.Client;
+import org.elasticsearch.client.node.NodeClient;
+import org.elasticsearch.common.settings.Settings;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.InitializingBean;
+
+/**
+ * NodeClientFactoryBean
+ *
+ * @author Rizwan Idrees
+ * @author Mohsin Husen
+ */
+
+public class NodeClientFactoryBean implements FactoryBean<NodeClient>, InitializingBean, DisposableBean {
+
+	private static final Logger logger = LoggerFactory.getLogger(NodeClientFactoryBean.class);
+	private boolean local;
+	private boolean enableHttp;
+	private String clusterName;
+	private NodeClient nodeClient;
+	private String pathData;
+	private String pathHome;
+	private String pathConfiguration;
+
+	NodeClientFactoryBean() {
+	}
+
+	public NodeClientFactoryBean(boolean local) {
+		this.local = local;
+	}
+
+	@Override
+	public NodeClient getObject() throws Exception {
+		return nodeClient;
+	}
+
+	@Override
+	public Class<? extends Client> getObjectType() {
+		return NodeClient.class;
+	}
+
+	@Override
+	public boolean isSingleton() {
+		return true;
+	}
+
+	@Override
+	public void afterPropertiesSet() throws Exception {
+		nodeClient = (NodeClient) nodeBuilder().settings(Settings.builder().put(loadConfig())
+				.put("http.enabled", String.valueOf(this.enableHttp))
+				.put("path.home", this.pathHome)
+				.put("path.data", this.pathData))
+				.clusterName(this.clusterName).local(this.local).node()
+				.client();
+	}
+
+	private Settings loadConfig() {
+		if (StringUtils.isNotBlank(pathConfiguration)) {
+			InputStream stream = getClass().getClassLoader().getResourceAsStream(pathConfiguration);
+			if (stream != null) {
+				return Settings.builder().loadFromStream(pathConfiguration, getClass().getClassLoader().getResourceAsStream(pathConfiguration)).build();
+			}
+			logger.error(String.format("Unable to read node configuration from file [%s]", pathConfiguration));
+		}
+		return Settings.builder().build();
+	}
+
+	public void setLocal(boolean local) {
+		this.local = local;
+	}
+
+	public void setEnableHttp(boolean enableHttp) {
+		this.enableHttp = enableHttp;
+	}
+
+	public void setClusterName(String clusterName) {
+		this.clusterName = clusterName;
+	}
+
+	public void setPathData(String pathData) {
+		this.pathData = pathData;
+	}
+
+	public void setPathHome(String pathHome) {
+		this.pathHome = pathHome;
+	}
+
+	public void setPathConfiguration(String configuration) {
+		this.pathConfiguration = configuration;
+	}
+
+	@Override
+	public void destroy() throws Exception {
+		try {
+			logger.info("Closing elasticSearch  client");
+			if (nodeClient != null) {
+				nodeClient.close();
+			}
+		} catch (final Exception e) {
+			logger.error("Error closing ElasticSearch client: ", e);
+		}
+	}
+}

src/main/java/org/springframework/data/elasticsearch/client/RestClientFactoryBean.java

@@ -1,103 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client;
-
-import java.net.URL;
-import java.util.ArrayList;
-
-import org.apache.http.HttpHost;
-import org.elasticsearch.client.RestClient;
-import org.elasticsearch.client.RestHighLevelClient;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.DisposableBean;
-import org.springframework.beans.factory.FactoryBean;
-import org.springframework.beans.factory.FactoryBeanNotInitializedException;
-import org.springframework.beans.factory.InitializingBean;
-import org.springframework.lang.Nullable;
-import org.springframework.util.Assert;
-
-/**
- * RestClientFactoryBean
- *
- * @author Don Wellington
- * @author Peter-Josef Meisch
- */
-public class RestClientFactoryBean implements FactoryBean<RestHighLevelClient>, InitializingBean, DisposableBean {
-
-	private static final Logger LOGGER = LoggerFactory.getLogger(RestClientFactoryBean.class);
-
-	private @Nullable RestHighLevelClient client;
-	private String hosts = "http://localhost:9200";
-	static final String COMMA = ",";
-
-	@Override
-	public void destroy() {
-		try {
-			LOGGER.info("Closing elasticSearch  client");
-			if (client != null) {
-				client.close();
-			}
-		} catch (final Exception e) {
-			LOGGER.error("Error closing ElasticSearch client: ", e);
-		}
-	}
-
-	@Override
-	public void afterPropertiesSet() throws Exception {
-		buildClient();
-	}
-
-	@Override
-	public RestHighLevelClient getObject() {
-
-		if (client == null) {
-			throw new FactoryBeanNotInitializedException();
-		}
-
-		return client;
-	}
-
-	@Override
-	public Class<?> getObjectType() {
-		return RestHighLevelClient.class;
-	}
-
-	@Override
-	public boolean isSingleton() {
-		return false;
-	}
-
-	protected void buildClient() throws Exception {
-
-		Assert.hasText(hosts, "[Assertion Failed] At least one host must be set.");
-
-		ArrayList<HttpHost> httpHosts = new ArrayList<>();
-		for (String host : hosts.split(COMMA)) {
-			URL hostUrl = new URL(host);
-			httpHosts.add(new HttpHost(hostUrl.getHost(), hostUrl.getPort(), hostUrl.getProtocol()));
-		}
-		client = new RestHighLevelClient(RestClient.builder(httpHosts.toArray(new HttpHost[httpHosts.size()])));
-	}
-
-	public void setHosts(String hosts) {
-		this.hosts = hosts;
-	}
-
-	public String getHosts() {
-		return this.hosts;
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/RestClients.java

@@ -1,236 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client;
-
-import java.io.ByteArrayOutputStream;
-import java.io.Closeable;
-import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.time.Duration;
-import java.util.Arrays;
-import java.util.List;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-
-import org.apache.http.Header;
-import org.apache.http.HttpEntity;
-import org.apache.http.HttpEntityEnclosingRequest;
-import org.apache.http.HttpHost;
-import org.apache.http.HttpRequest;
-import org.apache.http.HttpRequestInterceptor;
-import org.apache.http.HttpResponse;
-import org.apache.http.HttpResponseInterceptor;
-import org.apache.http.client.config.RequestConfig;
-import org.apache.http.client.config.RequestConfig.Builder;
-import org.apache.http.entity.ByteArrayEntity;
-import org.apache.http.message.BasicHeader;
-import org.apache.http.protocol.HttpContext;
-import org.elasticsearch.client.RestClient;
-import org.elasticsearch.client.RestClientBuilder;
-import org.elasticsearch.client.RestHighLevelClient;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpStatus;
-import org.springframework.util.Assert;
-
-/**
- * Utility class for common access to Elasticsearch clients. {@link RestClients} consolidates set up routines for the
- * various drivers into a single place.
- *
- * @author Christoph Strobl
- * @author Mark Paluch
- * @author Huw Ayling-Miller
- * @author Henrique Amaral
- * @author Peter-Josef Meisch
- * @author Nic Hines
- * @since 3.2
- */
-public final class RestClients {
-
-	/**
-	 * Name of whose value can be used to correlate log messages for this request.
-	 */
-	private static final String LOG_ID_ATTRIBUTE = RestClients.class.getName() + ".LOG_ID";
-
-	private RestClients() {}
-
-	/**
-	 * Start here to create a new client tailored to your needs.
-	 *
-	 * @return new instance of {@link ElasticsearchRestClient}.
-	 */
-	public static ElasticsearchRestClient create(ClientConfiguration clientConfiguration) {
-
-		Assert.notNull(clientConfiguration, "ClientConfiguration must not be null!");
-
-		HttpHost[] httpHosts = formattedHosts(clientConfiguration.getEndpoints(), clientConfiguration.useSsl()).stream()
-				.map(HttpHost::create).toArray(HttpHost[]::new);
-		RestClientBuilder builder = RestClient.builder(httpHosts);
-
-		if (clientConfiguration.getPathPrefix() != null) {
-			builder.setPathPrefix(clientConfiguration.getPathPrefix());
-		}
-
-		HttpHeaders headers = clientConfiguration.getDefaultHeaders();
-
-		if (!headers.isEmpty()) {
-			builder.setDefaultHeaders(toHeaderArray(headers));
-		}
-
-		builder.setHttpClientConfigCallback(clientBuilder -> {
-			clientConfiguration.getSslContext().ifPresent(clientBuilder::setSSLContext);
-			clientConfiguration.getHostNameVerifier().ifPresent(clientBuilder::setSSLHostnameVerifier);
-			clientBuilder.addInterceptorLast(new CustomHeaderInjector(clientConfiguration.getHeadersSupplier()));
-
-			if (ClientLogger.isEnabled()) {
-				HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
-
-				clientBuilder.addInterceptorLast((HttpRequestInterceptor) interceptor);
-				clientBuilder.addInterceptorLast((HttpResponseInterceptor) interceptor);
-			}
-
-			Builder requestConfigBuilder = RequestConfig.custom();
-			Duration connectTimeout = clientConfiguration.getConnectTimeout();
-
-			if (!connectTimeout.isNegative()) {
-				requestConfigBuilder.setConnectTimeout(Math.toIntExact(connectTimeout.toMillis()));
-			}
-
-			Duration socketTimeout = clientConfiguration.getSocketTimeout();
-
-			if (!socketTimeout.isNegative()) {
-				requestConfigBuilder.setSocketTimeout(Math.toIntExact(socketTimeout.toMillis()));
-				requestConfigBuilder.setConnectionRequestTimeout(Math.toIntExact(socketTimeout.toMillis()));
-			}
-
-			clientBuilder.setDefaultRequestConfig(requestConfigBuilder.build());
-
-			clientConfiguration.getProxy().map(HttpHost::create).ifPresent(clientBuilder::setProxy);
-
-			clientBuilder = clientConfiguration.getHttpClientConfigurer().customizeHttpClient(clientBuilder);
-
-			return clientBuilder;
-		});
-
-		RestHighLevelClient client = new RestHighLevelClient(builder);
-		return () -> client;
-	}
-
-	private static Header[] toHeaderArray(HttpHeaders headers) {
-		return headers.entrySet().stream() //
-				.flatMap(entry -> entry.getValue().stream() //
-						.map(value -> new BasicHeader(entry.getKey(), value))) //
-				.toArray(Header[]::new);
-	}
-
-	private static List<String> formattedHosts(List<InetSocketAddress> hosts, boolean useSsl) {
-		return hosts.stream().map(it -> (useSsl ? "https" : "http") + "://" + it.getHostString() + ":" + it.getPort())
-				.collect(Collectors.toList());
-	}
-
-	/**
-	 * @author Christoph Strobl
-	 */
-	@FunctionalInterface
-	public interface ElasticsearchRestClient extends Closeable {
-
-		/**
-		 * Apply the configuration to create a {@link RestHighLevelClient}.
-		 *
-		 * @return new instance of {@link RestHighLevelClient}.
-		 */
-		RestHighLevelClient rest();
-
-		/**
-		 * Apply the configuration to create a {@link RestClient}.
-		 *
-		 * @return new instance of {@link RestClient}.
-		 */
-		default RestClient lowLevelRest() {
-			return rest().getLowLevelClient();
-		}
-
-		@Override
-		default void close() throws IOException {
-			rest().close();
-		}
-	}
-
-	/**
-	 * Logging interceptors for Elasticsearch client logging.
-	 *
-	 * @see ClientLogger
-	 * @since 3.2
-	 */
-	private static class HttpLoggingInterceptor implements HttpResponseInterceptor, HttpRequestInterceptor {
-
-		@Override
-		public void process(HttpRequest request, HttpContext context) throws IOException {
-
-			String logId = (String) context.getAttribute(RestClients.LOG_ID_ATTRIBUTE);
-
-			if (logId == null) {
-				logId = ClientLogger.newLogId();
-				context.setAttribute(RestClients.LOG_ID_ATTRIBUTE, logId);
-			}
-
-			if (request instanceof HttpEntityEnclosingRequest && ((HttpEntityEnclosingRequest) request).getEntity() != null) {
-
-				HttpEntityEnclosingRequest entityRequest = (HttpEntityEnclosingRequest) request;
-				HttpEntity entity = ((HttpEntityEnclosingRequest) request).getEntity();
-				ByteArrayOutputStream buffer = new ByteArrayOutputStream();
-				entity.writeTo(buffer);
-
-				if (!entity.isRepeatable()) {
-					entityRequest.setEntity(new ByteArrayEntity(buffer.toByteArray()));
-				}
-
-				ClientLogger.logRequest(logId, request.getRequestLine().getMethod(), request.getRequestLine().getUri(), "",
-						() -> new String(buffer.toByteArray()));
-			} else {
-				ClientLogger.logRequest(logId, request.getRequestLine().getMethod(), request.getRequestLine().getUri(), "");
-			}
-		}
-
-		@Override
-		public void process(HttpResponse response, HttpContext context) {
-			String logId = (String) context.getAttribute(RestClients.LOG_ID_ATTRIBUTE);
-			ClientLogger.logRawResponse(logId, HttpStatus.resolve(response.getStatusLine().getStatusCode()));
-		}
-	}
-
-	/**
-	 * Interceptor to inject custom supplied headers.
-	 * 
-	 * @since 4.0
-	 */
-	private static class CustomHeaderInjector implements HttpRequestInterceptor {
-
-		public CustomHeaderInjector(Supplier<HttpHeaders> headersSupplier) {
-			this.headersSupplier = headersSupplier;
-		}
-
-		private final Supplier<HttpHeaders> headersSupplier;
-
-		@Override
-		public void process(HttpRequest request, HttpContext context) {
-			HttpHeaders httpHeaders = headersSupplier.get();
-
-			if (httpHeaders != null && httpHeaders != HttpHeaders.EMPTY) {
-				Arrays.stream(toHeaderArray(httpHeaders)).forEach(request::addHeader);
-			}
-		}
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/TransportClientFactoryBean.java

@@ -1,158 +1,154 @@
-/*
- * Copyright 2013-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client;
-
-import java.util.Properties;
-
-import org.elasticsearch.client.transport.TransportClient;
-import org.elasticsearch.common.settings.Settings;
-import org.elasticsearch.transport.client.PreBuiltTransportClient;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.DisposableBean;
-import org.springframework.beans.factory.FactoryBean;
-import org.springframework.beans.factory.FactoryBeanNotInitializedException;
-import org.springframework.beans.factory.InitializingBean;
-import org.springframework.lang.Nullable;
-
-/**
- * TransportClientFactoryBean
- *
- * @author Rizwan Idrees
- * @author Mohsin Husen
- * @author Jakub Vavrik
- * @author Piotr Betkier
- * @author Ilkang Na
- * @author Oliver Gierke
- * @author Peter-Josef Meisch
- * @deprecated as of 4.0
- */
-@Deprecated
-public class TransportClientFactoryBean implements FactoryBean<TransportClient>, InitializingBean, DisposableBean {
-
-	private static final Logger logger = LoggerFactory.getLogger(TransportClientFactoryBean.class);
-	private ClusterNodes clusterNodes = ClusterNodes.of("127.0.0.1:9300");
-	private String clusterName = "elasticsearch";
-	private Boolean clientTransportSniff = true;
-	private Boolean clientIgnoreClusterName = Boolean.FALSE;
-	private String clientPingTimeout = "5s";
-	private String clientNodesSamplerInterval = "5s";
-	private @Nullable TransportClient client;
-	private @Nullable Properties properties;
-
-	@Override
-	public void destroy() {
-		try {
-			logger.info("Closing elasticSearch  client");
-			if (client != null) {
-				client.close();
-			}
-		} catch (final Exception e) {
-			logger.error("Error closing ElasticSearch client: ", e);
-		}
-	}
-
-	@Override
-	public TransportClient getObject() {
-
-		if (clientTransportSniff == null) {
-			throw new FactoryBeanNotInitializedException();
-		}
-		return client;
-	}
-
-	@Override
-	public Class<TransportClient> getObjectType() {
-		return TransportClient.class;
-	}
-
-	@Override
-	public boolean isSingleton() {
-		return true;
-	}
-
-	@Override
-	public void afterPropertiesSet() throws Exception {
-		buildClient();
-	}
-
-	protected void buildClient() {
-
-		client = new PreBuiltTransportClient(settings());
-
-		clusterNodes.stream() //
-				.peek(it -> logger.info("Adding transport node : " + it.toString())) //
-				.forEach(client::addTransportAddress);
-
-		client.connectedNodes();
-	}
-
-	private Settings settings() {
-		if (properties != null) {
-			Settings.Builder builder = Settings.builder();
-
-			properties.forEach((key, value) -> {
-				builder.put(key.toString(), value.toString());
-			});
-
-			return builder.build();
-		}
-		return Settings.builder().put("cluster.name", clusterName).put("client.transport.sniff", clientTransportSniff)
-				.put("client.transport.ignore_cluster_name", clientIgnoreClusterName)
-				.put("client.transport.ping_timeout", clientPingTimeout)
-				.put("client.transport.nodes_sampler_interval", clientNodesSamplerInterval).build();
-	}
-
-	public void setClusterNodes(String clusterNodes) {
-		this.clusterNodes = ClusterNodes.of(clusterNodes);
-	}
-
-	public void setClusterName(String clusterName) {
-		this.clusterName = clusterName;
-	}
-
-	public void setClientTransportSniff(Boolean clientTransportSniff) {
-		this.clientTransportSniff = clientTransportSniff;
-	}
-
-	public String getClientNodesSamplerInterval() {
-		return clientNodesSamplerInterval;
-	}
-
-	public void setClientNodesSamplerInterval(String clientNodesSamplerInterval) {
-		this.clientNodesSamplerInterval = clientNodesSamplerInterval;
-	}
-
-	public String getClientPingTimeout() {
-		return clientPingTimeout;
-	}
-
-	public void setClientPingTimeout(String clientPingTimeout) {
-		this.clientPingTimeout = clientPingTimeout;
-	}
-
-	public Boolean getClientIgnoreClusterName() {
-		return clientIgnoreClusterName;
-	}
-
-	public void setClientIgnoreClusterName(Boolean clientIgnoreClusterName) {
-		this.clientIgnoreClusterName = clientIgnoreClusterName;
-	}
-
-	public void setProperties(Properties properties) {
-		this.properties = properties;
-	}
-}
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch.client;
+
+import static org.apache.commons.lang.StringUtils.*;
+
+import java.net.InetAddress;
+import java.util.Properties;
+
+import org.elasticsearch.client.transport.TransportClient;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.transport.InetSocketTransportAddress;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.util.Assert;
+
+/**
+ * TransportClientFactoryBean
+ *
+ * @author Rizwan Idrees
+ * @author Mohsin Husen
+ * @author Jakub Vavrik
+ * @author Piotr Betkier
+ */
+
+public class TransportClientFactoryBean implements FactoryBean<TransportClient>, InitializingBean, DisposableBean {
+
+	private static final Logger logger = LoggerFactory.getLogger(TransportClientFactoryBean.class);
+	private String clusterNodes = "127.0.0.1:9300";
+	private String clusterName = "elasticsearch";
+	private Boolean clientTransportSniff = true;
+	private Boolean clientIgnoreClusterName = Boolean.FALSE;
+	private String clientPingTimeout = "5s";
+	private String clientNodesSamplerInterval = "5s";
+	private TransportClient client;
+	private Properties properties;
+	static final String COLON = ":";
+	static final String COMMA = ",";
+
+	@Override
+	public void destroy() throws Exception {
+		try {
+			logger.info("Closing elasticSearch  client");
+			if (client != null) {
+				client.close();
+			}
+		} catch (final Exception e) {
+			logger.error("Error closing ElasticSearch client: ", e);
+		}
+	}
+
+	@Override
+	public TransportClient getObject() throws Exception {
+		return client;
+	}
+
+	@Override
+	public Class<TransportClient> getObjectType() {
+		return TransportClient.class;
+	}
+
+	@Override
+	public boolean isSingleton() {
+		return false;
+	}
+
+	@Override
+	public void afterPropertiesSet() throws Exception {
+		buildClient();
+	}
+
+	protected void buildClient() throws Exception {
+		client = TransportClient.builder().settings(settings()).build();
+		Assert.hasText(clusterNodes, "[Assertion failed] clusterNodes settings missing.");
+		for (String clusterNode : split(clusterNodes, COMMA)) {
+			String hostName = substringBeforeLast(clusterNode, COLON);
+			String port = substringAfterLast(clusterNode, COLON);
+			Assert.hasText(hostName, "[Assertion failed] missing host name in 'clusterNodes'");
+			Assert.hasText(port, "[Assertion failed] missing port in 'clusterNodes'");
+			logger.info("adding transport node : " + clusterNode);
+			client.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(hostName), Integer.valueOf(port)));
+		}
+		client.connectedNodes();
+	}
+
+	private Settings settings() {
+		if (properties != null) {
+			return Settings.builder().put(properties).build();
+		}
+		return Settings.builder()
+				.put("cluster.name", clusterName)
+				.put("client.transport.sniff", clientTransportSniff)
+				.put("client.transport.ignore_cluster_name", clientIgnoreClusterName)
+				.put("client.transport.ping_timeout", clientPingTimeout)
+				.put("client.transport.nodes_sampler_interval", clientNodesSamplerInterval)
+				.build();
+	}
+
+	public void setClusterNodes(String clusterNodes) {
+		this.clusterNodes = clusterNodes;
+	}
+
+	public void setClusterName(String clusterName) {
+		this.clusterName = clusterName;
+	}
+
+	public void setClientTransportSniff(Boolean clientTransportSniff) {
+		this.clientTransportSniff = clientTransportSniff;
+	}
+
+	public String getClientNodesSamplerInterval() {
+		return clientNodesSamplerInterval;
+	}
+
+	public void setClientNodesSamplerInterval(String clientNodesSamplerInterval) {
+		this.clientNodesSamplerInterval = clientNodesSamplerInterval;
+	}
+
+	public String getClientPingTimeout() {
+		return clientPingTimeout;
+	}
+
+	public void setClientPingTimeout(String clientPingTimeout) {
+		this.clientPingTimeout = clientPingTimeout;
+	}
+
+	public Boolean getClientIgnoreClusterName() {
+		return clientIgnoreClusterName;
+	}
+
+	public void setClientIgnoreClusterName(Boolean clientIgnoreClusterName) {
+		this.clientIgnoreClusterName = clientIgnoreClusterName;
+	}
+
+	public void setProperties(Properties properties) {
+		this.properties = properties;
+	}
+}

src/main/java/org/springframework/data/elasticsearch/client/package-info.java

@@ -1,3 +0,0 @@
-@org.springframework.lang.NonNullApi
-@org.springframework.lang.NonNullFields
-package org.springframework.data.elasticsearch.client;

src/main/java/org/springframework/data/elasticsearch/client/reactive/DefaultReactiveElasticsearchClient.java

@@ -1,970 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client.reactive;
-
-import io.netty.channel.ChannelOption;
-import io.netty.handler.ssl.ApplicationProtocolConfig;
-import io.netty.handler.ssl.ClientAuth;
-import io.netty.handler.ssl.IdentityCipherSuiteFilter;
-import io.netty.handler.ssl.JdkSslContext;
-import io.netty.handler.timeout.ReadTimeoutHandler;
-import io.netty.handler.timeout.WriteTimeoutHandler;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-import reactor.netty.http.client.HttpClient;
-import reactor.netty.transport.ProxyProvider;
-
-import java.io.IOException;
-import java.lang.reflect.Method;
-import java.net.ConnectException;
-import java.net.InetSocketAddress;
-import java.nio.charset.StandardCharsets;
-import java.time.Duration;
-import java.util.Collection;
-import java.util.Map.Entry;
-import java.util.Optional;
-import java.util.concurrent.TimeUnit;
-import java.util.function.Function;
-import java.util.function.Supplier;
-
-import javax.net.ssl.SSLContext;
-
-import org.apache.http.util.EntityUtils;
-import org.elasticsearch.ElasticsearchException;
-import org.elasticsearch.ElasticsearchStatusException;
-import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequest;
-import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse;
-import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest;
-import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest;
-import org.elasticsearch.action.admin.indices.close.CloseIndexRequest;
-import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
-import org.elasticsearch.action.admin.indices.flush.FlushRequest;
-import org.elasticsearch.action.admin.indices.flush.FlushResponse;
-import org.elasticsearch.action.admin.indices.open.OpenIndexRequest;
-import org.elasticsearch.action.admin.indices.refresh.RefreshRequest;
-import org.elasticsearch.action.admin.indices.refresh.RefreshResponse;
-import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest;
-import org.elasticsearch.action.admin.indices.settings.get.GetSettingsResponse;
-import org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest;
-import org.elasticsearch.action.bulk.BulkRequest;
-import org.elasticsearch.action.bulk.BulkResponse;
-import org.elasticsearch.action.delete.DeleteRequest;
-import org.elasticsearch.action.delete.DeleteResponse;
-import org.elasticsearch.action.get.GetRequest;
-import org.elasticsearch.action.get.GetResponse;
-import org.elasticsearch.action.get.MultiGetItemResponse;
-import org.elasticsearch.action.get.MultiGetRequest;
-import org.elasticsearch.action.get.MultiGetResponse;
-import org.elasticsearch.action.index.IndexRequest;
-import org.elasticsearch.action.index.IndexResponse;
-import org.elasticsearch.action.main.MainRequest;
-import org.elasticsearch.action.main.MainResponse;
-import org.elasticsearch.action.search.ClearScrollRequest;
-import org.elasticsearch.action.search.ClearScrollResponse;
-import org.elasticsearch.action.search.SearchRequest;
-import org.elasticsearch.action.search.SearchResponse;
-import org.elasticsearch.action.search.SearchScrollRequest;
-import org.elasticsearch.action.support.master.AcknowledgedResponse;
-import org.elasticsearch.action.update.UpdateRequest;
-import org.elasticsearch.action.update.UpdateResponse;
-import org.elasticsearch.client.GetAliasesResponse;
-import org.elasticsearch.client.Request;
-import org.elasticsearch.client.indices.*;
-import org.elasticsearch.common.unit.TimeValue;
-import org.elasticsearch.common.xcontent.DeprecationHandler;
-import org.elasticsearch.common.xcontent.NamedXContentRegistry;
-import org.elasticsearch.common.xcontent.XContentParser;
-import org.elasticsearch.common.xcontent.XContentType;
-import org.elasticsearch.index.get.GetResult;
-import org.elasticsearch.index.reindex.BulkByScrollResponse;
-import org.elasticsearch.index.reindex.DeleteByQueryRequest;
-import org.elasticsearch.index.reindex.UpdateByQueryRequest;
-import org.elasticsearch.rest.BytesRestResponse;
-import org.elasticsearch.rest.RestStatus;
-import org.elasticsearch.script.mustache.SearchTemplateRequest;
-import org.elasticsearch.script.mustache.SearchTemplateResponse;
-import org.elasticsearch.search.SearchHit;
-import org.elasticsearch.search.SearchHits;
-import org.elasticsearch.search.aggregations.Aggregation;
-import org.elasticsearch.search.suggest.Suggest;
-import org.reactivestreams.Publisher;
-import org.springframework.data.elasticsearch.UncategorizedElasticsearchException;
-import org.springframework.data.elasticsearch.client.ClientConfiguration;
-import org.springframework.data.elasticsearch.client.ClientLogger;
-import org.springframework.data.elasticsearch.client.ElasticsearchHost;
-import org.springframework.data.elasticsearch.client.NoReachableHostException;
-import org.springframework.data.elasticsearch.client.reactive.HostProvider.Verification;
-import org.springframework.data.elasticsearch.client.reactive.ReactiveElasticsearchClient.Cluster;
-import org.springframework.data.elasticsearch.client.reactive.ReactiveElasticsearchClient.Indices;
-import org.springframework.data.elasticsearch.client.util.NamedXContents;
-import org.springframework.data.elasticsearch.client.util.ScrollState;
-import org.springframework.data.elasticsearch.core.query.ByQueryResponse;
-import org.springframework.data.util.Lazy;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpMethod;
-import org.springframework.http.MediaType;
-import org.springframework.http.client.reactive.ReactorClientHttpConnector;
-import org.springframework.lang.Nullable;
-import org.springframework.util.Assert;
-import org.springframework.util.ObjectUtils;
-import org.springframework.util.ReflectionUtils;
-import org.springframework.web.reactive.function.BodyExtractors;
-import org.springframework.web.reactive.function.client.ClientRequest;
-import org.springframework.web.reactive.function.client.ClientResponse;
-import org.springframework.web.reactive.function.client.WebClient;
-import org.springframework.web.reactive.function.client.WebClient.RequestBodySpec;
-
-/**
- * A {@link WebClient} based {@link ReactiveElasticsearchClient} that connects to an Elasticsearch cluster using HTTP.
- *
- * @author Christoph Strobl
- * @author Mark Paluch
- * @author Peter-Josef Meisch
- * @author Huw Ayling-Miller
- * @author Henrique Amaral
- * @author Roman Puchkovskiy
- * @author Russell Parry
- * @author Thomas Geese
- * @author Brian Clozel
- * @author Farid Faoudi
- * @author George Popides
- * @since 3.2
- * @see ClientConfiguration
- * @see ReactiveRestClients
- */
-public class DefaultReactiveElasticsearchClient implements ReactiveElasticsearchClient, Indices, Cluster {
-
-	private final HostProvider<?> hostProvider;
-	private final RequestCreator requestCreator;
-	private Supplier<HttpHeaders> headersSupplier = () -> HttpHeaders.EMPTY;
-
-	/**
-	 * Create a new {@link DefaultReactiveElasticsearchClient} using the given {@link HostProvider} to obtain server
-	 * connections.
-	 *
-	 * @param hostProvider must not be {@literal null}.
-	 */
-	public DefaultReactiveElasticsearchClient(HostProvider<?> hostProvider) {
-		this(hostProvider, new DefaultRequestCreator());
-	}
-
-	/**
-	 * Create a new {@link DefaultReactiveElasticsearchClient} using the given {@link HostProvider} to obtain server
-	 * connections and the given {@link RequestCreator}.
-	 *
-	 * @param hostProvider must not be {@literal null}.
-	 * @param requestCreator must not be {@literal null}.
-	 */
-	public DefaultReactiveElasticsearchClient(HostProvider<?> hostProvider, RequestCreator requestCreator) {
-
-		Assert.notNull(hostProvider, "HostProvider must not be null");
-		Assert.notNull(requestCreator, "RequestCreator must not be null");
-
-		this.hostProvider = hostProvider;
-		this.requestCreator = requestCreator;
-	}
-
-	/**
-	 * Create a new {@link DefaultReactiveElasticsearchClient} aware of the given nodes in the cluster. <br />
-	 * <strong>NOTE</strong> If the cluster requires authentication be sure to provide the according {@link HttpHeaders}
-	 * correctly.
-	 *
-	 * @param headers Use {@link HttpHeaders} to provide eg. authentication data. Must not be {@literal null}.
-	 * @param hosts must not be {@literal null} nor empty!
-	 * @return new instance of {@link DefaultReactiveElasticsearchClient}.
-	 */
-	public static ReactiveElasticsearchClient create(HttpHeaders headers, String... hosts) {
-
-		Assert.notNull(headers, "HttpHeaders must not be null");
-		Assert.notEmpty(hosts, "Elasticsearch Cluster needs to consist of at least one host");
-
-		ClientConfiguration clientConfiguration = ClientConfiguration.builder().connectedTo(hosts)
-				.withDefaultHeaders(headers).build();
-		return create(clientConfiguration);
-	}
-
-	/**
-	 * Create a new {@link DefaultReactiveElasticsearchClient} given {@link ClientConfiguration}. <br />
-	 * <strong>NOTE</strong> If the cluster requires authentication be sure to provide the according {@link HttpHeaders}
-	 * correctly.
-	 *
-	 * @param clientConfiguration Client configuration. Must not be {@literal null}.
-	 * @return new instance of {@link DefaultReactiveElasticsearchClient}.
-	 */
-	public static ReactiveElasticsearchClient create(ClientConfiguration clientConfiguration) {
-		return create(clientConfiguration, new DefaultRequestCreator());
-	}
-
-	/**
-	 * Create a new {@link DefaultReactiveElasticsearchClient} given {@link ClientConfiguration} and
-	 * {@link RequestCreator}. <br />
-	 * <strong>NOTE</strong> If the cluster requires authentication be sure to provide the according {@link HttpHeaders}
-	 * correctly.
-	 *
-	 * @param clientConfiguration Client configuration. Must not be {@literal null}.
-	 * @param requestCreator Request creator. Must not be {@literal null}.
-	 * @return new instance of {@link DefaultReactiveElasticsearchClient}.
-	 */
-	public static ReactiveElasticsearchClient create(ClientConfiguration clientConfiguration,
-			RequestCreator requestCreator) {
-
-		Assert.notNull(clientConfiguration, "ClientConfiguration must not be null");
-		Assert.notNull(requestCreator, "RequestCreator must not be null");
-
-		WebClientProvider provider = getWebClientProvider(clientConfiguration);
-
-		HostProvider<?> hostProvider = HostProvider.provider(provider, clientConfiguration.getHeadersSupplier(),
-				clientConfiguration.getEndpoints().toArray(new InetSocketAddress[0]));
-
-		DefaultReactiveElasticsearchClient client = new DefaultReactiveElasticsearchClient(hostProvider, requestCreator);
-
-		client.setHeadersSupplier(clientConfiguration.getHeadersSupplier());
-
-		return client;
-	}
-
-	private static WebClientProvider getWebClientProvider(ClientConfiguration clientConfiguration) {
-
-		Duration connectTimeout = clientConfiguration.getConnectTimeout();
-		Duration soTimeout = clientConfiguration.getSocketTimeout();
-
-		HttpClient httpClient = HttpClient.create().compress(true);
-
-		if (!connectTimeout.isNegative()) {
-			httpClient = httpClient.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, Math.toIntExact(connectTimeout.toMillis()));
-		}
-
-		if (!soTimeout.isNegative()) {
-			httpClient = httpClient.doOnConnected(connection -> connection //
-					.addHandlerLast(new ReadTimeoutHandler(soTimeout.toMillis(), TimeUnit.MILLISECONDS))
-					.addHandlerLast(new WriteTimeoutHandler(soTimeout.toMillis(), TimeUnit.MILLISECONDS)));
-		}
-
-		if (clientConfiguration.getProxy().isPresent()) {
-			String proxy = clientConfiguration.getProxy().get();
-			String[] hostPort = proxy.split(":");
-
-			if (hostPort.length != 2) {
-				throw new IllegalArgumentException("invalid proxy configuration " + proxy + ", should be \"host:port\"");
-			}
-			httpClient = httpClient.proxy(proxyOptions -> proxyOptions.type(ProxyProvider.Proxy.HTTP).host(hostPort[0])
-					.port(Integer.parseInt(hostPort[1])));
-		}
-
-		String scheme = "http";
-
-		if (clientConfiguration.useSsl()) {
-
-			Optional<SSLContext> sslContext = clientConfiguration.getSslContext();
-
-			if (sslContext.isPresent()) {
-				httpClient = httpClient
-						.secure(sslContextSpec -> sslContextSpec.sslContext(new JdkSslContext(sslContext.get(), true, null,
-								IdentityCipherSuiteFilter.INSTANCE, ApplicationProtocolConfig.DISABLED, ClientAuth.NONE, null, false)));
-			} else {
-				httpClient = httpClient.secure();
-			}
-
-			scheme = "https";
-		}
-
-		WebClientProvider provider = WebClientProvider.create(scheme, new ReactorClientHttpConnector(httpClient));
-
-		if (clientConfiguration.getPathPrefix() != null) {
-			provider = provider.withPathPrefix(clientConfiguration.getPathPrefix());
-		}
-
-		provider = provider //
-				.withDefaultHeaders(clientConfiguration.getDefaultHeaders()) //
-				.withWebClientConfigurer(clientConfiguration.getWebClientConfigurer()) //
-				.withRequestConfigurer(requestHeadersSpec -> requestHeadersSpec.headers(httpHeaders -> {
-					HttpHeaders suppliedHeaders = clientConfiguration.getHeadersSupplier().get();
-
-					if (suppliedHeaders != null && suppliedHeaders != HttpHeaders.EMPTY) {
-						httpHeaders.addAll(suppliedHeaders);
-					}
-				}));
-
-		return provider;
-	}
-
-	public void setHeadersSupplier(Supplier<HttpHeaders> headersSupplier) {
-
-		Assert.notNull(headersSupplier, "headersSupplier must not be null");
-
-		this.headersSupplier = headersSupplier;
-	}
-
-	@Override
-	public Mono<Boolean> ping(HttpHeaders headers) {
-
-		return sendRequest(new MainRequest(), requestCreator.ping(), RawActionResponse.class, headers) //
-				.flatMap(response -> response.releaseBody().thenReturn(response.statusCode().is2xxSuccessful())) //
-				.onErrorResume(NoReachableHostException.class, error -> Mono.just(false)).next();
-	}
-
-	@Override
-	public Mono<MainResponse> info(HttpHeaders headers) {
-
-		return sendRequest(new MainRequest(), requestCreator.info(), MainResponse.class, headers) //
-				.next();
-	}
-
-	@Override
-	public Mono<GetResult> get(HttpHeaders headers, GetRequest getRequest) {
-
-		return sendRequest(getRequest, requestCreator.get(), GetResponse.class, headers) //
-				.filter(GetResponse::isExists) //
-				.map(DefaultReactiveElasticsearchClient::getResponseToGetResult) //
-				.next();
-	}
-
-	@Override
-	public Flux<MultiGetItemResponse> multiGet(HttpHeaders headers, MultiGetRequest multiGetRequest) {
-
-		return sendRequest(multiGetRequest, requestCreator.multiGet(), MultiGetResponse.class, headers)
-				.map(MultiGetResponse::getResponses) //
-				.flatMap(Flux::fromArray); //
-	}
-
-	@Override
-	public Mono<Boolean> exists(HttpHeaders headers, GetRequest getRequest) {
-
-		return sendRequest(getRequest, requestCreator.exists(), RawActionResponse.class, headers) //
-				.flatMap(response -> response.releaseBody().thenReturn(response.statusCode().is2xxSuccessful())) //
-				.next();
-	}
-
-	@Override
-	public Mono<IndexResponse> index(HttpHeaders headers, IndexRequest indexRequest) {
-		return sendRequest(indexRequest, requestCreator.index(), IndexResponse.class, headers).next();
-	}
-
-	@Override
-	public Indices indices() {
-		return this;
-	}
-
-	@Override
-	public Cluster cluster() {
-		return this;
-	}
-
-	@Override
-	public Mono<UpdateResponse> update(HttpHeaders headers, UpdateRequest updateRequest) {
-		return sendRequest(updateRequest, requestCreator.update(), UpdateResponse.class, headers).next();
-	}
-
-	@Override
-	public Mono<DeleteResponse> delete(HttpHeaders headers, DeleteRequest deleteRequest) {
-
-		return sendRequest(deleteRequest, requestCreator.delete(), DeleteResponse.class, headers) //
-				.next();
-	}
-
-	@Override
-	public Mono<Long> count(HttpHeaders headers, SearchRequest searchRequest) {
-		searchRequest.source().trackTotalHits(true);
-		searchRequest.source().size(0);
-		searchRequest.source().fetchSource(false);
-		return sendRequest(searchRequest, requestCreator.search(), SearchResponse.class, headers) //
-				.map(SearchResponse::getHits) //
-				.map(searchHits -> searchHits.getTotalHits().value) //
-				.next();
-	}
-
-	@Override
-	public Flux<SearchHit> searchTemplate(HttpHeaders headers, SearchTemplateRequest searchTemplateRequest) {
-		return sendRequest(searchTemplateRequest, requestCreator.searchTemplate(), SearchTemplateResponse.class, headers)
-				.map(response -> response.getResponse().getHits()).flatMap(Flux::fromIterable);
-	}
-
-	@Override
-	public Flux<SearchHit> search(HttpHeaders headers, SearchRequest searchRequest) {
-
-		return sendRequest(searchRequest, requestCreator.search(), SearchResponse.class, headers) //
-				.map(SearchResponse::getHits) //
-				.flatMap(Flux::fromIterable);
-	}
-
-	@Override
-	public Mono<SearchResponse> searchForResponse(HttpHeaders headers, SearchRequest searchRequest) {
-		return sendRequest(searchRequest, requestCreator.search(), SearchResponse.class, headers).next();
-	}
-
-	@Override
-	public Flux<Suggest> suggest(HttpHeaders headers, SearchRequest searchRequest) {
-		return sendRequest(searchRequest, requestCreator.search(), SearchResponse.class, headers) //
-				.map(SearchResponse::getSuggest);
-	}
-
-	@Override
-	public Flux<Aggregation> aggregate(HttpHeaders headers, SearchRequest searchRequest) {
-
-		Assert.notNull(headers, "headers must not be null");
-		Assert.notNull(searchRequest, "searchRequest must not be null");
-
-		searchRequest.source().size(0);
-		searchRequest.source().trackTotalHits(false);
-
-		return sendRequest(searchRequest, requestCreator.search(), SearchResponse.class, headers) //
-				.map(SearchResponse::getAggregations) //
-				.flatMap(Flux::fromIterable);
-	}
-
-	@Override
-	public Flux<SearchHit> scroll(HttpHeaders headers, SearchRequest searchRequest) {
-
-		TimeValue scrollTimeout = searchRequest.scroll() != null ? searchRequest.scroll().keepAlive()
-				: TimeValue.timeValueMinutes(1);
-
-		if (searchRequest.scroll() == null) {
-			searchRequest.scroll(scrollTimeout);
-		}
-
-		return Flux.usingWhen(Mono.fromSupplier(ScrollState::new),
-
-				state -> sendRequest(searchRequest, requestCreator.search(), SearchResponse.class, headers)
-						.expand(searchResponse -> {
-
-							state.updateScrollId(searchResponse.getScrollId());
-							if (isEmpty(searchResponse.getHits())) {
-								return Mono.empty();
-							}
-
-							return sendRequest(new SearchScrollRequest(searchResponse.getScrollId()).scroll(scrollTimeout),
-									requestCreator.scroll(), SearchResponse.class, headers);
-
-						}),
-				state -> cleanupScroll(headers, state), //
-				(state, ex) -> cleanupScroll(headers, state), //
-				state -> cleanupScroll(headers, state)) //
-				.filter(it -> !isEmpty(it.getHits())) //
-				.map(SearchResponse::getHits) //
-				.flatMapIterable(Function.identity()); //
-	}
-
-	private static boolean isEmpty(@Nullable SearchHits hits) {
-		return hits != null && hits.getHits() != null && hits.getHits().length == 0;
-	}
-
-	private Publisher<?> cleanupScroll(HttpHeaders headers, ScrollState state) {
-
-		if (state.getScrollIds().isEmpty()) {
-			return Mono.empty();
-		}
-
-		ClearScrollRequest clearScrollRequest = new ClearScrollRequest();
-		clearScrollRequest.scrollIds(state.getScrollIds());
-
-		// just send the request, resources get cleaned up anyways after scrollTimeout has been reached.
-		return sendRequest(clearScrollRequest, requestCreator.clearScroll(), ClearScrollResponse.class, headers);
-	}
-
-	@Override
-	public Mono<BulkByScrollResponse> deleteBy(HttpHeaders headers, DeleteByQueryRequest deleteRequest) {
-
-		return sendRequest(deleteRequest, requestCreator.deleteByQuery(), BulkByScrollResponse.class, headers) //
-				.next();
-	}
-
-	@Override
-	public Mono<ByQueryResponse> updateBy(HttpHeaders headers, UpdateByQueryRequest updateRequest) {
-		return sendRequest(updateRequest, requestCreator.updateByQuery(), BulkByScrollResponse.class, headers) //
-				.next() //
-				.map(ByQueryResponse::of);
-	}
-
-	@Override
-	public Mono<BulkResponse> bulk(HttpHeaders headers, BulkRequest bulkRequest) {
-		return sendRequest(bulkRequest, requestCreator.bulk(), BulkResponse.class, headers) //
-				.next();
-	}
-
-	@Override
-	public <T> Mono<T> execute(ReactiveElasticsearchClientCallback<T> callback) {
-
-		return this.hostProvider.getActive(Verification.LAZY) //
-				.flatMap(callback::doWithClient) //
-				.onErrorResume(throwable -> {
-
-					if (isCausedByConnectionException(throwable)) {
-						return hostProvider.getActive(Verification.ACTIVE) //
-								.flatMap(callback::doWithClient);
-					}
-
-					return Mono.error(throwable);
-				});
-	}
-
-	/**
-	 * checks if the given throwable is a {@link ConnectException} or has one in it's cause chain
-	 *
-	 * @param throwable the throwable to check
-	 * @return true if throwable is caused by a {@link ConnectException}
-	 */
-	private boolean isCausedByConnectionException(Throwable throwable) {
-
-		Throwable t = throwable;
-		do {
-
-			if (t instanceof ConnectException) {
-				return true;
-			}
-
-			t = t.getCause();
-		} while (t != null);
-
-		return false;
-	}
-
-	@Override
-	public Mono<Status> status() {
-
-		return hostProvider.clusterInfo() //
-				.map(it -> new ClientStatus(it.getNodes()));
-	}
-
-	// --> Private Response helpers
-
-	private static GetResult getResponseToGetResult(GetResponse response) {
-
-		return new GetResult(response.getIndex(), response.getType(), response.getId(), response.getSeqNo(),
-				response.getPrimaryTerm(), response.getVersion(), response.isExists(), response.getSourceAsBytesRef(),
-				response.getFields(), null);
-	}
-
-	// -->
-
-	private <REQ, RESP> Flux<RESP> sendRequest(REQ request, Function<REQ, Request> converter, Class<RESP> responseType,
-			HttpHeaders headers) {
-		return sendRequest(converter.apply(request), responseType, headers);
-	}
-
-	private <Resp> Flux<Resp> sendRequest(Request request, Class<Resp> responseType, HttpHeaders headers) {
-
-		String logId = ClientLogger.newLogId();
-
-		return Flux
-				.from(execute(webClient -> sendRequest(webClient, logId, request, headers).exchangeToMono(clientResponse -> {
-					Publisher<? extends Resp> publisher = readResponseBody(logId, request, clientResponse, responseType);
-					return Mono.from(publisher);
-				})));
-	}
-
-	private RequestBodySpec sendRequest(WebClient webClient, String logId, Request request, HttpHeaders headers) {
-
-		RequestBodySpec requestBodySpec = webClient.method(HttpMethod.valueOf(request.getMethod().toUpperCase())) //
-				.uri(builder -> {
-
-					builder = builder.path(request.getEndpoint());
-
-					if (!ObjectUtils.isEmpty(request.getParameters())) {
-						for (Entry<String, String> entry : request.getParameters().entrySet()) {
-							builder = builder.queryParam(entry.getKey(), entry.getValue());
-						}
-					}
-					return builder.build();
-				}) //
-				.attribute(ClientRequest.LOG_ID_ATTRIBUTE, logId) //
-				.headers(theHeaders -> {
-
-					// add all the headers explicitly set
-					theHeaders.addAll(headers);
-
-					// and now those that might be set on the request.
-					if (request.getOptions() != null) {
-
-						if (!ObjectUtils.isEmpty(request.getOptions().getHeaders())) {
-							request.getOptions().getHeaders().forEach(it -> theHeaders.add(it.getName(), it.getValue()));
-						}
-					}
-				});
-
-		if (request.getEntity() != null) {
-
-			Lazy<String> body = bodyExtractor(request);
-
-			ClientLogger.logRequest(logId, request.getMethod().toUpperCase(), request.getEndpoint(), request.getParameters(),
-					body::get);
-
-			requestBodySpec.contentType(MediaType.valueOf(request.getEntity().getContentType().getValue()))
-					.body(Mono.fromSupplier(body), String.class);
-		} else {
-			ClientLogger.logRequest(logId, request.getMethod().toUpperCase(), request.getEndpoint(), request.getParameters());
-		}
-
-		return requestBodySpec;
-	}
-
-	// region indices operations
-	@Override
-	public Mono<Boolean> createIndex(HttpHeaders headers,
-			org.elasticsearch.action.admin.indices.create.CreateIndexRequest createIndexRequest) {
-
-		return sendRequest(createIndexRequest, requestCreator.indexCreate(), AcknowledgedResponse.class, headers) //
-				.map(AcknowledgedResponse::isAcknowledged) //
-				.next();
-	}
-
-	@Override
-	public Mono<Boolean> createIndex(HttpHeaders headers, CreateIndexRequest createIndexRequest) {
-
-		return sendRequest(createIndexRequest, requestCreator.createIndexRequest(), AcknowledgedResponse.class, headers) //
-				.map(AcknowledgedResponse::isAcknowledged) //
-				.next();
-	}
-
-	@Override
-	public Mono<Void> closeIndex(HttpHeaders headers, CloseIndexRequest closeIndexRequest) {
-
-		return sendRequest(closeIndexRequest, requestCreator.indexClose(), AcknowledgedResponse.class, headers) //
-				.then();
-	}
-
-	@Override
-	public Mono<Boolean> existsIndex(HttpHeaders headers,
-			org.elasticsearch.action.admin.indices.get.GetIndexRequest request) {
-
-		return sendRequest(request, requestCreator.indexExists(), RawActionResponse.class, headers) //
-				.flatMap(response -> response.releaseBody().thenReturn(response.statusCode().is2xxSuccessful())) //
-				.next();
-	}
-
-	@Override
-	public Mono<Boolean> existsIndex(HttpHeaders headers, GetIndexRequest request) {
-		return sendRequest(request, requestCreator.indexExistsRequest(), RawActionResponse.class, headers) //
-				.flatMap(response -> response.releaseBody().thenReturn(response.statusCode().is2xxSuccessful())) //
-				.next();
-	}
-
-	@Override
-	public Mono<Boolean> deleteIndex(HttpHeaders headers, DeleteIndexRequest request) {
-
-		return sendRequest(request, requestCreator.indexDelete(), AcknowledgedResponse.class, headers) //
-				.map(AcknowledgedResponse::isAcknowledged) //
-				.next();
-	}
-
-	@Override
-	public Mono<Void> flushIndex(HttpHeaders headers, FlushRequest flushRequest) {
-
-		return sendRequest(flushRequest, requestCreator.flushIndex(), FlushResponse.class, headers) //
-				.then();
-	}
-
-	@Override
-	@Deprecated
-	public Mono<org.elasticsearch.action.admin.indices.mapping.get.GetMappingsResponse> getMapping(HttpHeaders headers,
-			org.elasticsearch.action.admin.indices.mapping.get.GetMappingsRequest getMappingsRequest) {
-		return sendRequest(getMappingsRequest, requestCreator.getMapping(),
-				org.elasticsearch.action.admin.indices.mapping.get.GetMappingsResponse.class, headers).next();
-	}
-
-	@Override
-	public Mono<GetMappingsResponse> getMapping(HttpHeaders headers, GetMappingsRequest getMappingsRequest) {
-		return sendRequest(getMappingsRequest, requestCreator.getMappingRequest(), GetMappingsResponse.class, headers) //
-				.next();
-	}
-
-	@Override
-	public Mono<GetFieldMappingsResponse> getFieldMapping(HttpHeaders headers,
-			GetFieldMappingsRequest getFieldMappingsRequest) {
-		return sendRequest(getFieldMappingsRequest, requestCreator.getFieldMapping(), GetFieldMappingsResponse.class,
-				headers).next();
-	}
-
-	@Override
-	public Mono<GetSettingsResponse> getSettings(HttpHeaders headers, GetSettingsRequest getSettingsRequest) {
-		return sendRequest(getSettingsRequest, requestCreator.getSettings(), GetSettingsResponse.class, headers).next();
-	}
-
-	@Override
-	public Mono<Boolean> putMapping(HttpHeaders headers,
-			org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest putMappingRequest) {
-
-		return sendRequest(putMappingRequest, requestCreator.putMapping(), AcknowledgedResponse.class, headers) //
-				.map(AcknowledgedResponse::isAcknowledged) //
-				.next();
-	}
-
-	@Override
-	public Mono<Boolean> putMapping(HttpHeaders headers, PutMappingRequest putMappingRequest) {
-		return sendRequest(putMappingRequest, requestCreator.putMappingRequest(), AcknowledgedResponse.class, headers) //
-				.map(AcknowledgedResponse::isAcknowledged) //
-				.next();
-	}
-
-	@Override
-	public Mono<Void> openIndex(HttpHeaders headers, OpenIndexRequest request) {
-
-		return sendRequest(request, requestCreator.indexOpen(), AcknowledgedResponse.class, headers) //
-				.then();
-	}
-
-	@Override
-	public Mono<Void> refreshIndex(HttpHeaders headers, RefreshRequest refreshRequest) {
-
-		return sendRequest(refreshRequest, requestCreator.indexRefresh(), RefreshResponse.class, headers) //
-				.then();
-	}
-
-	@Override
-	public Mono<Boolean> updateAliases(HttpHeaders headers, IndicesAliasesRequest indicesAliasesRequest) {
-		return sendRequest(indicesAliasesRequest, requestCreator.updateAlias(), AcknowledgedResponse.class, headers)
-				.map(AcknowledgedResponse::isAcknowledged).next();
-	}
-
-	@Override
-	public Mono<GetAliasesResponse> getAliases(HttpHeaders headers, GetAliasesRequest getAliasesRequest) {
-		return sendRequest(getAliasesRequest, requestCreator.getAlias(), GetAliasesResponse.class, headers).next();
-	}
-
-	@Override
-	public Mono<Boolean> putTemplate(HttpHeaders headers, PutIndexTemplateRequest putIndexTemplateRequest) {
-		return sendRequest(putIndexTemplateRequest, requestCreator.putTemplate(), AcknowledgedResponse.class, headers)
-				.map(AcknowledgedResponse::isAcknowledged).next();
-	}
-
-	@Override
-	public Mono<GetIndexTemplatesResponse> getTemplate(HttpHeaders headers,
-			GetIndexTemplatesRequest getIndexTemplatesRequest) {
-		return (sendRequest(getIndexTemplatesRequest, requestCreator.getTemplates(), GetIndexTemplatesResponse.class,
-				headers)).next();
-	}
-
-	@Override
-	public Mono<Boolean> existsTemplate(HttpHeaders headers, IndexTemplatesExistRequest indexTemplatesExistRequest) {
-		return sendRequest(indexTemplatesExistRequest, requestCreator.templatesExist(), RawActionResponse.class, headers) //
-				.flatMap(response -> response.releaseBody().thenReturn(response.statusCode().is2xxSuccessful())) //
-				.next();
-	}
-
-	@Override
-	public Mono<Boolean> deleteTemplate(HttpHeaders headers, DeleteIndexTemplateRequest deleteIndexTemplateRequest) {
-		return sendRequest(deleteIndexTemplateRequest, requestCreator.deleteTemplate(), AcknowledgedResponse.class, headers)
-				.map(AcknowledgedResponse::isAcknowledged).next();
-	}
-
-	@Override
-	public Mono<GetIndexResponse> getIndex(HttpHeaders headers, GetIndexRequest getIndexRequest) {
-		return sendRequest(getIndexRequest, requestCreator.getIndex(), GetIndexResponse.class, headers).next();
-	}
-
-	// endregion
-
-	// region cluster operations
-	@Override
-	public Mono<ClusterHealthResponse> health(HttpHeaders headers, ClusterHealthRequest clusterHealthRequest) {
-		return sendRequest(clusterHealthRequest, requestCreator.clusterHealth(), ClusterHealthResponse.class, headers)
-				.next();
-	}
-	// endregion
-
-	// region helper functions
-	private <T> Publisher<? extends T> readResponseBody(String logId, Request request, ClientResponse response,
-			Class<T> responseType) {
-
-		if (RawActionResponse.class.equals(responseType)) {
-
-			ClientLogger.logRawResponse(logId, response.statusCode());
-			return Mono.just(responseType.cast(RawActionResponse.create(response)));
-		}
-
-		if (response.statusCode().is5xxServerError()) {
-
-			ClientLogger.logRawResponse(logId, response.statusCode());
-			return handleServerError(request, response);
-		}
-
-		if (response.statusCode().is4xxClientError()) {
-
-			ClientLogger.logRawResponse(logId, response.statusCode());
-			return handleClientError(logId, response, responseType);
-		}
-
-		return response.body(BodyExtractors.toMono(byte[].class)) //
-				.map(it -> new String(it, StandardCharsets.UTF_8)) //
-				.doOnNext(it -> ClientLogger.logResponse(logId, response.statusCode(), it)) //
-				.flatMap(content -> doDecode(response, responseType, content));
-	}
-
-	private static <T> Mono<T> doDecode(ClientResponse response, Class<T> responseType, String content) {
-
-		String mediaType = response.headers().contentType().map(MediaType::toString).orElse(XContentType.JSON.mediaType());
-
-		try {
-
-			Method fromXContent = ReflectionUtils.findMethod(responseType, "fromXContent", XContentParser.class);
-
-			if (fromXContent == null) {
-				return Mono.error(new UncategorizedElasticsearchException(
-						"No method named fromXContent found in " + responseType.getCanonicalName()));
-			}
-			return Mono.justOrEmpty(responseType
-					.cast(ReflectionUtils.invokeMethod(fromXContent, responseType, createParser(mediaType, content))));
-
-		} catch (Throwable errorParseFailure) { // cause elasticsearch also uses AssertionError
-
-			try {
-				return Mono.error(BytesRestResponse.errorFromXContent(createParser(mediaType, content)));
-			} catch (Exception e) {
-
-				return Mono
-						.error(new ElasticsearchStatusException(content, RestStatus.fromCode(response.statusCode().value())));
-			}
-		}
-	}
-
-	private static XContentParser createParser(String mediaType, String content) throws IOException {
-		return XContentType.fromMediaTypeOrFormat(mediaType) //
-				.xContent() //
-				.createParser(new NamedXContentRegistry(NamedXContents.getDefaultNamedXContents()),
-						DeprecationHandler.THROW_UNSUPPORTED_OPERATION, content);
-	}
-
-	private Lazy<String> bodyExtractor(Request request) {
-
-		return Lazy.of(() -> {
-
-			try {
-				return EntityUtils.toString(request.getEntity());
-			} catch (IOException e) {
-				throw new RequestBodyEncodingException("Error encoding request", e);
-			}
-		});
-	}
-	// endregion
-
-	// region error and exception handling
-	private <T> Publisher<? extends T> handleServerError(Request request, ClientResponse response) {
-
-		int statusCode = response.statusCode().value();
-		RestStatus status = RestStatus.fromCode(statusCode);
-		String mediaType = response.headers().contentType().map(MediaType::toString).orElse(XContentType.JSON.mediaType());
-
-		return response.body(BodyExtractors.toMono(byte[].class)) //
-				.switchIfEmpty(Mono.error(
-						new ElasticsearchStatusException(String.format("%s request to %s returned error code %s and no body.",
-								request.getMethod(), request.getEndpoint(), statusCode), status)))
-				.map(bytes -> new String(bytes, StandardCharsets.UTF_8)) //
-				.flatMap(content -> contentOrError(content, mediaType, status))
-				.flatMap(unused -> Mono
-						.error(new ElasticsearchStatusException(String.format("%s request to %s returned error code %s.",
-								request.getMethod(), request.getEndpoint(), statusCode), status)));
-	}
-
-	private <T> Publisher<? extends T> handleClientError(String logId, ClientResponse response, Class<T> responseType) {
-
-		int statusCode = response.statusCode().value();
-		RestStatus status = RestStatus.fromCode(statusCode);
-		String mediaType = response.headers().contentType().map(MediaType::toString).orElse(XContentType.JSON.mediaType());
-
-		return response.body(BodyExtractors.toMono(byte[].class)) //
-				.map(bytes -> new String(bytes, StandardCharsets.UTF_8)) //
-				.flatMap(content -> contentOrError(content, mediaType, status)) //
-				.doOnNext(content -> ClientLogger.logResponse(logId, response.statusCode(), content)) //
-				.flatMap(content -> doDecode(response, responseType, content));
-	}
-
-	/**
-	 * checks if the given content body contains an {@link ElasticsearchException}, if yes it is returned in a Mono.error.
-	 * Otherwise the content is returned in the Mono
-	 *
-	 * @param content the content to analyze
-	 * @param mediaType the returned media type
-	 * @param status the response status
-	 * @return a Mono with the content or an Mono.error
-	 */
-	private static Mono<String> contentOrError(String content, String mediaType, RestStatus status) {
-
-		ElasticsearchException exception = getElasticsearchException(content, mediaType, status);
-
-		if (exception != null) {
-			StringBuilder sb = new StringBuilder();
-			buildExceptionMessages(sb, exception);
-			return Mono.error(new ElasticsearchStatusException(sb.toString(), status, exception));
-		}
-
-		return Mono.just(content);
-	}
-
-	/**
-	 * tries to parse an {@link ElasticsearchException} from the given body content
-	 *
-	 * @param content the content to analyse
-	 * @param mediaType the type of the body content
-	 * @return an {@link ElasticsearchException} or {@literal null}.
-	 */
-	@Nullable
-	private static ElasticsearchException getElasticsearchException(String content, String mediaType, RestStatus status) {
-
-		try {
-			XContentParser parser = createParser(mediaType, content);
-			// we have a JSON object with an error and a status field
-			parser.nextToken(); // Skip START_OBJECT
-
-			XContentParser.Token token;
-			do {
-				token = parser.nextToken();
-
-				if ("error".equals(parser.currentName())) {
-					return ElasticsearchException.failureFromXContent(parser);
-				}
-			} while (token == XContentParser.Token.FIELD_NAME);
-
-			return null;
-		} catch (Exception e) {
-			return new ElasticsearchStatusException(content, status);
-		}
-	}
-
-	private static void buildExceptionMessages(StringBuilder sb, Throwable t) {
-
-		sb.append(t.getMessage());
-		for (Throwable throwable : t.getSuppressed()) {
-			sb.append(", ");
-			buildExceptionMessages(sb, throwable);
-		}
-	}
-	// endregion
-
-	// region internal classes
-	/**
-	 * Reactive client {@link ReactiveElasticsearchClient.Status} implementation.
-	 *
-	 * @author Christoph Strobl
-	 */
-	static class ClientStatus implements Status {
-
-		private final Collection<ElasticsearchHost> connectedHosts;
-
-		ClientStatus(Collection<ElasticsearchHost> connectedHosts) {
-			this.connectedHosts = connectedHosts;
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * @see org.springframework.data.elasticsearch.client.reactive.ReactiveElasticsearchClient.Status#hosts()
-		 */
-		@Override
-		public Collection<ElasticsearchHost> hosts() {
-			return connectedHosts;
-		}
-	}
-
-	// endregion
-}

src/main/java/org/springframework/data/elasticsearch/client/reactive/DefaultRequestCreator.java

@@ -1,7 +0,0 @@
-package org.springframework.data.elasticsearch.client.reactive;
-
-/**
- * @author Roman Puchkovskiy
- * @since 4.0
- */
-class DefaultRequestCreator implements RequestCreator {}

src/main/java/org/springframework/data/elasticsearch/client/reactive/DefaultWebClientProvider.java

@@ -1,191 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client.reactive;
-
-import java.net.InetSocketAddress;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.client.reactive.ClientHttpConnector;
-import org.springframework.lang.Nullable;
-import org.springframework.util.Assert;
-import org.springframework.web.reactive.function.client.WebClient;
-import org.springframework.web.reactive.function.client.WebClient.Builder;
-import org.springframework.web.util.DefaultUriBuilderFactory;
-
-/**
- * Default {@link WebClientProvider} that uses cached {@link WebClient} instances per {@code hostAndPort}.
- *
- * @author Mark Paluch
- * @author Christoph Strobl
- * @author Huw Ayling-Miller
- * @author Peter-Josef Meisch
- * @since 3.2
- */
-class DefaultWebClientProvider implements WebClientProvider {
-
-	private final Map<InetSocketAddress, WebClient> cachedClients;
-
-	private final String scheme;
-	private final @Nullable ClientHttpConnector connector;
-	private final Consumer<Throwable> errorListener;
-	private final HttpHeaders headers;
-	private final @Nullable String pathPrefix;
-	private final Function<WebClient, WebClient> webClientConfigurer;
-	private final Consumer<WebClient.RequestHeadersSpec<?>> requestConfigurer;
-
-	/**
-	 * Create new {@link DefaultWebClientProvider} with empty {@link HttpHeaders} and no-op {@literal error listener}.
-	 *
-	 * @param scheme must not be {@literal null}.
-	 * @param connector can be {@literal null}.
-	 */
-	DefaultWebClientProvider(String scheme, @Nullable ClientHttpConnector connector) {
-		this(scheme, connector, e -> {}, HttpHeaders.EMPTY, null, Function.identity(), requestHeadersSpec -> {});
-	}
-
-	/**
-	 * Create new {@link DefaultWebClientProvider} with empty {@link HttpHeaders} and no-op {@literal error listener}.
-	 *
-	 * @param scheme must not be {@literal null}.
-	 * @param connector can be {@literal null}.
-	 * @param errorListener must not be {@literal null}.
-	 * @param headers must not be {@literal null}.
-	 * @param pathPrefix can be {@literal null}.
-	 * @param webClientConfigurer must not be {@literal null}.
-	 * @param requestConfigurer must not be {@literal null}.
-	 */
-	private DefaultWebClientProvider(String scheme, @Nullable ClientHttpConnector connector,
-			Consumer<Throwable> errorListener, HttpHeaders headers, @Nullable String pathPrefix,
-			Function<WebClient, WebClient> webClientConfigurer, Consumer<WebClient.RequestHeadersSpec<?>> requestConfigurer) {
-
-		Assert.notNull(scheme, "Scheme must not be null! A common scheme would be 'http'.");
-		Assert.notNull(errorListener, "errorListener must not be null! You may want use a no-op one 'e -> {}' instead.");
-		Assert.notNull(headers, "headers must not be null! Think about using 'HttpHeaders.EMPTY' as an alternative.");
-		Assert.notNull(webClientConfigurer,
-				"webClientConfigurer must not be null! You may want use a no-op one 'Function.identity()' instead.");
-		Assert.notNull(requestConfigurer,
-				"requestConfigurer must not be null! You may want use a no-op one 'r -> {}' instead.\"");
-
-		this.cachedClients = new ConcurrentHashMap<>();
-		this.scheme = scheme;
-		this.connector = connector;
-		this.errorListener = errorListener;
-		this.headers = headers;
-		this.pathPrefix = pathPrefix;
-		this.webClientConfigurer = webClientConfigurer;
-		this.requestConfigurer = requestConfigurer;
-	}
-
-	@Override
-	public WebClient get(InetSocketAddress endpoint) {
-
-		Assert.notNull(endpoint, "Endpoint must not be empty!");
-
-		return this.cachedClients.computeIfAbsent(endpoint, this::createWebClientForSocketAddress);
-	}
-
-	@Override
-	public HttpHeaders getDefaultHeaders() {
-		return headers;
-	}
-
-	@Override
-	public Consumer<Throwable> getErrorListener() {
-		return this.errorListener;
-	}
-
-	@Nullable
-	@Override
-	public String getPathPrefix() {
-		return pathPrefix;
-	}
-
-	@Override
-	public WebClientProvider withDefaultHeaders(HttpHeaders headers) {
-
-		Assert.notNull(headers, "HttpHeaders must not be null.");
-
-		HttpHeaders merged = new HttpHeaders();
-		merged.addAll(this.headers);
-		merged.addAll(headers);
-
-		return new DefaultWebClientProvider(scheme, connector, errorListener, merged, pathPrefix, webClientConfigurer,
-				requestConfigurer);
-	}
-
-	@Override
-	public WebClientProvider withRequestConfigurer(Consumer<WebClient.RequestHeadersSpec<?>> requestConfigurer) {
-
-		Assert.notNull(requestConfigurer, "requestConfigurer must not be null.");
-
-		return new DefaultWebClientProvider(scheme, connector, errorListener, headers, pathPrefix, webClientConfigurer,
-				requestConfigurer);
-	}
-
-	@Override
-	public WebClientProvider withErrorListener(Consumer<Throwable> errorListener) {
-
-		Assert.notNull(errorListener, "Error listener must not be null.");
-
-		Consumer<Throwable> listener = this.errorListener.andThen(errorListener);
-		return new DefaultWebClientProvider(scheme, this.connector, listener, headers, pathPrefix, webClientConfigurer,
-				requestConfigurer);
-	}
-
-	@Override
-	public WebClientProvider withPathPrefix(String pathPrefix) {
-		Assert.notNull(pathPrefix, "pathPrefix must not be null.");
-
-		return new DefaultWebClientProvider(this.scheme, this.connector, this.errorListener, this.headers, pathPrefix,
-				webClientConfigurer, requestConfigurer);
-	}
-
-	@Override
-	public WebClientProvider withWebClientConfigurer(Function<WebClient, WebClient> webClientConfigurer) {
-		return new DefaultWebClientProvider(scheme, connector, errorListener, headers, pathPrefix, webClientConfigurer,
-				requestConfigurer);
-
-	}
-
-	protected WebClient createWebClientForSocketAddress(InetSocketAddress socketAddress) {
-
-		Builder builder = WebClient.builder() //
-				.defaultHeaders(it -> it.addAll(getDefaultHeaders())) //
-				.defaultRequest(requestConfigurer);
-
-		if (connector != null) {
-			builder = builder.clientConnector(connector);
-		}
-
-		String baseUrl = String.format("%s://%s:%d%s", this.scheme, socketAddress.getHostString(), socketAddress.getPort(),
-				pathPrefix == null ? "" : '/' + pathPrefix);
-
-		DefaultUriBuilderFactory uriBuilderFactory = new DefaultUriBuilderFactory(baseUrl);
-		// the template will already be encoded by the RequestConverters methods
-		uriBuilderFactory.setEncodingMode(DefaultUriBuilderFactory.EncodingMode.VALUES_ONLY);
-		builder.uriBuilderFactory(uriBuilderFactory); //
-
-		WebClient webClient = builder //
-				.filter((request, next) -> next.exchange(request) //
-						.doOnError(errorListener)) //
-				.build(); //
-		return webClientConfigurer.apply(webClient);
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/reactive/HostProvider.java

@@ -1,154 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client.reactive;
-
-import reactor.core.publisher.Mono;
-
-import java.net.InetSocketAddress;
-import java.util.Collections;
-import java.util.Set;
-import java.util.function.Supplier;
-
-import org.springframework.data.elasticsearch.client.ElasticsearchHost;
-import org.springframework.data.elasticsearch.client.NoReachableHostException;
-import org.springframework.http.HttpHeaders;
-import org.springframework.util.Assert;
-import org.springframework.web.reactive.function.client.WebClient;
-
-/**
- * Infrastructure helper class aware of hosts within the cluster and the health of those allowing easy selection of
- * active ones.
- *
- * @author Christoph Strobl
- * @author Mark Paluch
- * @author Peter-Josef Meisch
- * @since 3.2
- */
-public interface HostProvider<T extends HostProvider<T>> {
-
-	/**
-	 * Create a new {@link HostProvider} best suited for the given {@link WebClientProvider} and number of hosts.
-	 *
-	 * @param clientProvider must not be {@literal null} .
-	 * @param headersSupplier to supply custom headers, must not be {@literal null}
-	 * @param endpoints must not be {@literal null} nor empty.
-	 * @return new instance of {@link HostProvider}.
-	 */
-	static HostProvider<?> provider(WebClientProvider clientProvider, Supplier<HttpHeaders> headersSupplier,
-			InetSocketAddress... endpoints) {
-
-		Assert.notNull(clientProvider, "WebClientProvider must not be null");
-		Assert.notEmpty(endpoints, "Please provide at least one endpoint to connect to.");
-
-		if (endpoints.length == 1) {
-			return new SingleNodeHostProvider(clientProvider, endpoints[0]);
-		} else {
-			return new MultiNodeHostProvider(clientProvider, endpoints);
-		}
-	}
-
-	/**
-	 * Lookup an active host in {@link Verification#LAZY lazy} mode utilizing cached {@link ElasticsearchHost}.
-	 *
-	 * @return the {@link Mono} emitting the active host or {@link Mono#error(Throwable) an error} if none found.
-	 */
-	default Mono<InetSocketAddress> lookupActiveHost() {
-		return lookupActiveHost(Verification.LAZY);
-	}
-
-	/**
-	 * Lookup an active host in using the given {@link Verification}.
-	 *
-	 * @param verification
-	 * @return the {@link Mono} emitting the active host or {@link Mono#error(Throwable) an error}
-	 *         ({@link NoReachableHostException}) if none found.
-	 */
-	Mono<InetSocketAddress> lookupActiveHost(Verification verification);
-
-	/**
-	 * Get the {@link WebClient} connecting to an active host utilizing cached {@link ElasticsearchHost}.
-	 *
-	 * @return the {@link Mono} emitting the client for an active host or {@link Mono#error(Throwable) an error} if none
-	 *         found.
-	 */
-	default Mono<WebClient> getActive() {
-		return getActive(Verification.LAZY);
-	}
-
-	/**
-	 * Get the {@link WebClient} connecting to an active host.
-	 *
-	 * @param verification must not be {@literal null}.
-	 * @return the {@link Mono} emitting the client for an active host or {@link Mono#error(Throwable) an error} if none
-	 *         found.
-	 */
-	default Mono<WebClient> getActive(Verification verification) {
-		return lookupActiveHost(verification).map(this::createWebClient);
-	}
-
-	/**
-	 * Creates a {@link WebClient} for {@link InetSocketAddress endpoint}.
-	 *
-	 * @param endpoint must not be {@literal null}.
-	 * @return a {@link WebClient} using the the given endpoint as {@literal base url}.
-	 */
-	WebClient createWebClient(InetSocketAddress endpoint);
-
-	/**
-	 * Obtain information about known cluster nodes.
-	 *
-	 * @return the {@link Mono} emitting {@link ClusterInformation} when available.
-	 */
-	Mono<ClusterInformation> clusterInfo();
-
-	/**
-	 * {@link Verification} allows to influence the lookup strategy for active hosts.
-	 *
-	 * @author Christoph Strobl
-	 * @since 3.2
-	 */
-	enum Verification {
-
-		/**
-		 * Actively check for cluster node health.
-		 */
-		ACTIVE,
-
-		/**
-		 * Use cached data for cluster node health.
-		 */
-		LAZY
-	}
-
-	/**
-	 * Value object accumulating information about an Elasticsearch cluster.
-	 *
-	 * @author Christoph Strobl
-	 * @since 3.2
-	 */
-	class ClusterInformation {
-
-		private final Set<ElasticsearchHost> nodes;
-
-		public ClusterInformation(Set<ElasticsearchHost> nodes) {
-			this.nodes = nodes;
-		}
-
-		public Set<ElasticsearchHost> getNodes() {
-			return Collections.unmodifiableSet(nodes);
-		}
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/reactive/MultiNodeHostProvider.java

@@ -1,189 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client.reactive;
-
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-import reactor.util.function.Tuple2;
-
-import java.net.InetSocketAddress;
-import java.time.Duration;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.data.elasticsearch.client.ElasticsearchHost;
-import org.springframework.data.elasticsearch.client.ElasticsearchHost.State;
-import org.springframework.data.elasticsearch.client.NoReachableHostException;
-import org.springframework.lang.Nullable;
-import org.springframework.web.reactive.function.client.ClientResponse;
-import org.springframework.web.reactive.function.client.WebClient;
-
-/**
- * {@link HostProvider} for a cluster of nodes.
- *
- * @author Christoph Strobl
- * @author Mark Paluch
- * @author Peter-Josef Meisch
- * @since 3.2
- */
-class MultiNodeHostProvider implements HostProvider<MultiNodeHostProvider> {
-
-	private final static Logger LOG = LoggerFactory.getLogger(MultiNodeHostProvider.class);
-
-	private final WebClientProvider clientProvider;
-	private final Map<InetSocketAddress, ElasticsearchHost> hosts;
-
-	MultiNodeHostProvider(WebClientProvider clientProvider, InetSocketAddress... endpoints) {
-
-		this.clientProvider = clientProvider;
-		this.hosts = new ConcurrentHashMap<>();
-		for (InetSocketAddress endpoint : endpoints) {
-			this.hosts.put(endpoint, new ElasticsearchHost(endpoint, State.UNKNOWN));
-		}
-
-		LOG.debug("initialized with " + hosts);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.reactive.HostProvider#clusterInfo()
-	 */
-	@Override
-	public Mono<ClusterInformation> clusterInfo() {
-		return checkNodes(null).map(this::updateNodeState).buffer(hosts.size())
-				.then(Mono.just(new ClusterInformation(new LinkedHashSet<>(this.hosts.values()))));
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.reactive.HostProvider#createWebClient(java.net.InetSocketAddress)
-	 */
-	@Override
-	public WebClient createWebClient(InetSocketAddress endpoint) {
-		return this.clientProvider.get(endpoint);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.reactive.HostProvider#lookupActiveHost(org.springframework.data.elasticsearch.client.reactive.HostProvider.Verification)
-	 */
-	@Override
-	public Mono<InetSocketAddress> lookupActiveHost(Verification verification) {
-
-		LOG.trace("lookupActiveHost " + verification + " from " + hosts());
-
-		if (Verification.LAZY.equals(verification)) {
-			for (ElasticsearchHost entry : hosts()) {
-				if (entry.isOnline()) {
-					LOG.trace("lookupActiveHost returning " + entry);
-					return Mono.just(entry.getEndpoint());
-				}
-			}
-			LOG.trace("no online host found with LAZY");
-		}
-
-		LOG.trace("searching for active host");
-		return findActiveHostInKnownActives() //
-				.switchIfEmpty(findActiveHostInUnresolved()) //
-				.switchIfEmpty(findActiveHostInDead()) //
-				.switchIfEmpty(Mono.error(() -> new NoReachableHostException(new LinkedHashSet<>(getCachedHostState()))));
-	}
-
-	Collection<ElasticsearchHost> getCachedHostState() {
-		return hosts.values();
-	}
-
-	private Mono<InetSocketAddress> findActiveHostInKnownActives() {
-		return findActiveForState(State.ONLINE);
-	}
-
-	private Mono<InetSocketAddress> findActiveHostInUnresolved() {
-		return findActiveForState(State.UNKNOWN);
-	}
-
-	private Mono<InetSocketAddress> findActiveHostInDead() {
-		return findActiveForState(State.OFFLINE);
-	}
-
-	private Mono<InetSocketAddress> findActiveForState(State state) {
-
-		LOG.trace("findActiveForState state " + state + ", current hosts: " + hosts);
-
-		return checkNodes(state) //
-				.map(this::updateNodeState) //
-				.filter(ElasticsearchHost::isOnline) //
-				.map(elasticsearchHost -> {
-					LOG.trace("findActiveForState returning host " + elasticsearchHost);
-					return elasticsearchHost;
-				}).map(ElasticsearchHost::getEndpoint) //
-				.takeLast(1) //
-				.next();
-	}
-
-	private ElasticsearchHost updateNodeState(Tuple2<InetSocketAddress, State> tuple2) {
-
-		State state = tuple2.getT2();
-		ElasticsearchHost elasticsearchHost = new ElasticsearchHost(tuple2.getT1(), state);
-		hosts.put(tuple2.getT1(), elasticsearchHost);
-		return elasticsearchHost;
-	}
-
-	private Flux<Tuple2<InetSocketAddress, State>> checkNodes(@Nullable State state) {
-
-		LOG.trace("checkNodes() with state " + state);
-
-		return Flux.fromIterable(hosts()) //
-				.filter(entry -> state == null || entry.getState().equals(state)) //
-				.map(ElasticsearchHost::getEndpoint) //
-				.concatMap(host -> {
-
-					LOG.trace("checking host " + host);
-
-					Mono<ClientResponse> clientResponseMono = createWebClient(host) //
-							.head().uri("/") //
-							.exchangeToMono(Mono::just) //
-							.timeout(Duration.ofSeconds(1)) //
-							.doOnError(throwable -> {
-								LOG.trace("error checking host " + host + ", " + throwable.getMessage());
-								hosts.put(host, new ElasticsearchHost(host, State.OFFLINE));
-								clientProvider.getErrorListener().accept(throwable);
-							});
-
-					return Mono.just(host) //
-							.zipWith(clientResponseMono.flatMap(it -> it.releaseBody() //
-									.thenReturn(it.statusCode().isError() ? State.OFFLINE : State.ONLINE)));
-				}) //
-				.map(tuple -> {
-					LOG.trace("check result " + tuple);
-					return tuple;
-				}).onErrorContinue((throwable, o) -> clientProvider.getErrorListener().accept(throwable));
-	}
-
-	private List<ElasticsearchHost> hosts() {
-
-		List<ElasticsearchHost> hosts = new ArrayList<>(this.hosts.values());
-		Collections.shuffle(hosts);
-
-		return hosts;
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/reactive/RawActionResponse.java

@@ -1,86 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client.reactive;
-
-import reactor.core.publisher.Mono;
-
-import java.io.IOException;
-
-import org.elasticsearch.action.ActionResponse;
-import org.elasticsearch.common.io.stream.StreamOutput;
-
-import org.springframework.http.HttpStatus;
-import org.springframework.http.client.reactive.ClientHttpResponse;
-import org.springframework.web.reactive.function.BodyExtractor;
-import org.springframework.web.reactive.function.client.ClientResponse;
-
-/**
- * Extension to {@link ActionResponse} that also delegates to {@link ClientResponse}.
- *
- * @author Christoph Strobl
- * @author Peter-Josef Meisch
- * @author Mark Paluch
- * @since 3.2
- */
-class RawActionResponse extends ActionResponse {
-
-	private final ClientResponse delegate;
-
-	private RawActionResponse(ClientResponse delegate) {
-		this.delegate = delegate;
-	}
-
-	static RawActionResponse create(ClientResponse response) {
-		return new RawActionResponse(response);
-	}
-
-	public HttpStatus statusCode() {
-		return delegate.statusCode();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.web.reactive.function.client.ClientResponse#headers()
-	 */
-	public ClientResponse.Headers headers() {
-		return delegate.headers();
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.web.reactive.function.client.ClientResponse#body(org.springframework.web.reactive.function.BodyExtractor)
-	 */
-	public <T> T body(BodyExtractor<T, ? super ClientHttpResponse> extractor) {
-		return delegate.body(extractor);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * until Elasticsearch 7.4 this empty implementation was available in the abstract base class
-	 */
-	@Override
-	public void writeTo(StreamOutput out) throws IOException {
-	}
-
-	/**
-	 * Ensure the response body is released to properly release the underlying connection.
-	 *
-	 * @return
-	 */
-	public Mono<Void> releaseBody() {
-		return delegate.releaseBody();
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/reactive/ReactiveRestClients.java

@@ -1,64 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client.reactive;
-
-import org.springframework.data.elasticsearch.client.ClientConfiguration;
-import org.springframework.util.Assert;
-
-/**
- * Utility class for common access to reactive Elasticsearch clients. {@link ReactiveRestClients} consolidates set up
- * routines for the various drivers into a single place.
- *
- * @author Christoph Strobl
- * @author Mark Paluch
- * @author Roman Puchkovskiy
- * @since 3.2
- */
-public final class ReactiveRestClients {
-
-	private ReactiveRestClients() {}
-
-	/**
-	 * Start here to create a new client tailored to your needs.
-	 *
-	 * @param clientConfiguration client configuration to use for building {@link ReactiveElasticsearchClient}; must not
-	 *          be {@literal null}.
-	 * @return new instance of {@link ReactiveElasticsearchClient}.
-	 */
-	public static ReactiveElasticsearchClient create(ClientConfiguration clientConfiguration) {
-
-		Assert.notNull(clientConfiguration, "ClientConfiguration must not be null!");
-
-		return DefaultReactiveElasticsearchClient.create(clientConfiguration);
-	}
-
-	/**
-	 * Start here to create a new client tailored to your needs.
-	 *
-	 * @param clientConfiguration client configuration to use for building {@link ReactiveElasticsearchClient}; must not
-	 *          be {@literal null}.
-	 * @param requestCreator request creator to use in the client; must not be {@literal null}.
-	 * @return new instance of {@link ReactiveElasticsearchClient}.
-	 */
-	public static ReactiveElasticsearchClient create(ClientConfiguration clientConfiguration,
-			RequestCreator requestCreator) {
-
-		Assert.notNull(clientConfiguration, "ClientConfiguration must not be null!");
-		Assert.notNull(requestCreator, "RequestCreator must not be null!");
-
-		return DefaultReactiveElasticsearchClient.create(clientConfiguration, requestCreator);
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/reactive/RequestBodyEncodingException.java

@@ -1,40 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client.reactive;
-
-import org.springframework.web.reactive.function.client.WebClientException;
-
-/**
- * Exception thrown if the request body cannot be properly encoded.
- *
- * @author Christoph Strobl
- * @author Mark Paluch
- * @since 3.2
- */
-public class RequestBodyEncodingException extends WebClientException {
-
-	private static final long serialVersionUID = 472776714118912855L;
-
-	/**
-	 * Construct a new instance of {@link RequestBodyEncodingException} with the given message and exception.
-	 *
-	 * @param msg the message
-	 * @param ex the exception
-	 */
-	public RequestBodyEncodingException(String msg, Throwable ex) {
-		super(msg, ex);
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/reactive/RequestCreator.java

@@ -1,277 +0,0 @@
-package org.springframework.data.elasticsearch.client.reactive;
-
-import java.io.IOException;
-import java.util.function.Function;
-
-import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequest;
-import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest;
-import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest;
-import org.elasticsearch.action.admin.indices.close.CloseIndexRequest;
-import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
-import org.elasticsearch.action.admin.indices.flush.FlushRequest;
-import org.elasticsearch.action.admin.indices.open.OpenIndexRequest;
-import org.elasticsearch.action.admin.indices.refresh.RefreshRequest;
-import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest;
-import org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest;
-import org.elasticsearch.action.bulk.BulkRequest;
-import org.elasticsearch.action.delete.DeleteRequest;
-import org.elasticsearch.action.get.GetRequest;
-import org.elasticsearch.action.get.MultiGetRequest;
-import org.elasticsearch.action.index.IndexRequest;
-import org.elasticsearch.action.main.MainRequest;
-import org.elasticsearch.action.search.ClearScrollRequest;
-import org.elasticsearch.action.search.SearchRequest;
-import org.elasticsearch.action.search.SearchScrollRequest;
-import org.elasticsearch.action.update.UpdateRequest;
-import org.elasticsearch.client.Request;
-import org.elasticsearch.client.core.CountRequest;
-import org.elasticsearch.client.indices.CreateIndexRequest;
-import org.elasticsearch.client.indices.GetFieldMappingsRequest;
-import org.elasticsearch.client.indices.GetIndexRequest;
-import org.elasticsearch.client.indices.GetIndexTemplatesRequest;
-import org.elasticsearch.client.indices.GetMappingsRequest;
-import org.elasticsearch.client.indices.IndexTemplatesExistRequest;
-import org.elasticsearch.client.indices.PutIndexTemplateRequest;
-import org.elasticsearch.client.indices.PutMappingRequest;
-import org.elasticsearch.index.reindex.DeleteByQueryRequest;
-import org.elasticsearch.index.reindex.UpdateByQueryRequest;
-import org.elasticsearch.script.mustache.SearchTemplateRequest;
-import org.springframework.data.elasticsearch.UncategorizedElasticsearchException;
-import org.springframework.data.elasticsearch.client.util.RequestConverters;
-
-/**
- * @author Roman Puchkovskiy
- * @author Farid Faoudi
- * @author George Popides
- * @since 4.0
- */
-public interface RequestCreator {
-
-	default Function<SearchRequest, Request> search() {
-		return RequestConverters::search;
-	}
-
-	default Function<SearchTemplateRequest, Request> searchTemplate() {
-		return RequestConverters::searchTemplate;
-	}
-
-	default Function<SearchScrollRequest, Request> scroll() {
-		return RequestConverters::searchScroll;
-	}
-
-	default Function<ClearScrollRequest, Request> clearScroll() {
-		return RequestConverters::clearScroll;
-	}
-
-	default Function<IndexRequest, Request> index() {
-		return RequestConverters::index;
-	}
-
-	default Function<GetRequest, Request> get() {
-		return RequestConverters::get;
-	}
-
-	default Function<MainRequest, Request> ping() {
-		return (request) -> RequestConverters.ping();
-	}
-
-	default Function<MainRequest, Request> info() {
-		return (request) -> RequestConverters.info();
-	}
-
-	default Function<MultiGetRequest, Request> multiGet() {
-		return RequestConverters::multiGet;
-	}
-
-	default Function<GetRequest, Request> exists() {
-		return RequestConverters::exists;
-	}
-
-	default Function<UpdateRequest, Request> update() {
-		return RequestConverters::update;
-	}
-
-	default Function<DeleteRequest, Request> delete() {
-		return RequestConverters::delete;
-	}
-
-	default Function<DeleteByQueryRequest, Request> deleteByQuery() {
-		return RequestConverters::deleteByQuery;
-	}
-
-	/**
-	 * @since 4.2
-	 */
-	default Function<UpdateByQueryRequest, Request> updateByQuery() {
-		return RequestConverters::updateByQuery;
-	}
-
-	default Function<BulkRequest, Request> bulk() {
-
-		return request -> {
-
-			try {
-				return RequestConverters.bulk(request);
-			} catch (IOException e) {
-				throw new UncategorizedElasticsearchException("Could not parse request", e);
-			}
-		};
-	}
-
-	// --> INDICES
-
-	/**
-	 * @deprecated since 4.2
-	 */
-	@Deprecated
-	default Function<org.elasticsearch.action.admin.indices.get.GetIndexRequest, Request> indexExists() {
-		return RequestConverters::indexExists;
-	}
-
-	/**
-	 * @since 4.2
-	 */
-	default Function<GetIndexRequest, Request> indexExistsRequest() {
-		return RequestConverters::indexExists;
-	}
-
-	default Function<DeleteIndexRequest, Request> indexDelete() {
-		return RequestConverters::indexDelete;
-	}
-
-	/**
-	 * @deprecated since 4.2
-	 */
-	@Deprecated
-	default Function<org.elasticsearch.action.admin.indices.create.CreateIndexRequest, Request> indexCreate() {
-		return RequestConverters::indexCreate;
-	}
-
-	/**
-	 * @since 4.2
-	 */
-	default Function<CreateIndexRequest, Request> createIndexRequest() {
-		return RequestConverters::indexCreate;
-	}
-
-	default Function<OpenIndexRequest, Request> indexOpen() {
-		return RequestConverters::indexOpen;
-	}
-
-	default Function<CloseIndexRequest, Request> indexClose() {
-		return RequestConverters::indexClose;
-	}
-
-	default Function<RefreshRequest, Request> indexRefresh() {
-		return RequestConverters::indexRefresh;
-	}
-
-	/**
-	 * @deprecated since 4.2
-	 */
-	@Deprecated
-	default Function<org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest, Request> putMapping() {
-		return RequestConverters::putMapping;
-	}
-
-	/**
-	 * @since 4.2
-	 */
-	default Function<PutMappingRequest, Request> putMappingRequest() {
-		return RequestConverters::putMapping;
-	}
-
-	default Function<FlushRequest, Request> flushIndex() {
-		return RequestConverters::flushIndex;
-	}
-
-	default Function<CountRequest, Request> count() {
-		return RequestConverters::count;
-	}
-
-	/**
-	 * @since 4.1
-	 */
-	default Function<GetSettingsRequest, Request> getSettings() {
-		return RequestConverters::getSettings;
-	}
-
-	/**
-	 * @since 4.1
-	 * @deprecated since 4.2
-	 */
-	@Deprecated
-	default Function<org.elasticsearch.action.admin.indices.mapping.get.GetMappingsRequest, Request> getMapping() {
-		return RequestConverters::getMapping;
-	}
-
-	/**
-	 * @since 4.2
-	 */
-	default Function<GetMappingsRequest, Request> getMappingRequest() {
-		return RequestConverters::getMapping;
-	}
-
-	/**
-	 * @since 4.1
-	 */
-	default Function<IndicesAliasesRequest, Request> updateAlias() {
-		return RequestConverters::updateAliases;
-	}
-
-	/**
-	 * @since 4.1
-	 */
-	default Function<GetAliasesRequest, Request> getAlias() {
-		return RequestConverters::getAlias;
-	}
-
-	/**
-	 * @since 4.1
-	 */
-	default Function<PutIndexTemplateRequest, Request> putTemplate() {
-		return RequestConverters::putTemplate;
-	}
-
-	/**
-	 * @since 4.1
-	 */
-	default Function<GetIndexTemplatesRequest, Request> getTemplates() {
-		return RequestConverters::getTemplates;
-	}
-
-	/**
-	 * @since 4.1
-	 */
-	default Function<IndexTemplatesExistRequest, Request> templatesExist() {
-		return RequestConverters::templatesExist;
-	}
-
-	/**
-	 * @since 4.1
-	 */
-	default Function<DeleteIndexTemplateRequest, Request> deleteTemplate() {
-		return RequestConverters::deleteTemplate;
-	}
-
-	/**
-	 * @since 4.2
-	 */
-	default Function<GetFieldMappingsRequest, Request> getFieldMapping() {
-		return RequestConverters::getFieldMapping;
-	}
-
-	/**
-	 * @since 4.2
-	 */
-	default Function<GetIndexRequest, Request> getIndex() {
-		return RequestConverters::getIndex;
-	}
-
-	/**
-	 * @since 4.2
-	 */
-	default Function<ClusterHealthRequest, Request> clusterHealth() {
-		return RequestConverters::clusterHealth;
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/reactive/SingleNodeHostProvider.java

@@ -1,108 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client.reactive;
-
-import reactor.core.publisher.Mono;
-
-import java.net.InetSocketAddress;
-import java.util.Collections;
-
-import org.springframework.data.elasticsearch.client.ElasticsearchHost;
-import org.springframework.data.elasticsearch.client.ElasticsearchHost.State;
-import org.springframework.data.elasticsearch.client.NoReachableHostException;
-import org.springframework.web.reactive.function.client.WebClient;
-
-/**
- * {@link HostProvider} for a single host.
- *
- * @author Christoph Strobl
- * @author Mark Paluch
- * @author Peter-Josef Meisch
- * @since 3.2
- */
-class SingleNodeHostProvider implements HostProvider<SingleNodeHostProvider> {
-
-	private final WebClientProvider clientProvider;
-	private final InetSocketAddress endpoint;
-	private volatile ElasticsearchHost state;
-
-	SingleNodeHostProvider(WebClientProvider clientProvider, InetSocketAddress endpoint) {
-
-		this.clientProvider = clientProvider;
-		this.endpoint = endpoint;
-		this.state = new ElasticsearchHost(this.endpoint, State.UNKNOWN);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.reactive.HostProvider#clusterInfo()
-	 */
-	@Override
-	public Mono<ClusterInformation> clusterInfo() {
-
-		return createWebClient(endpoint) //
-				.head().uri("/") //
-				.exchangeToMono(it -> {
-					if (it.statusCode().isError()) {
-						state = ElasticsearchHost.offline(endpoint);
-					} else {
-						state = ElasticsearchHost.online(endpoint);
-					}
-					return Mono.just(state);
-				}).onErrorResume(throwable -> {
-					state = ElasticsearchHost.offline(endpoint);
-					clientProvider.getErrorListener().accept(throwable);
-					return Mono.just(state);
-				}).map(elasticsearchHost -> new ClusterInformation(Collections.singleton(elasticsearchHost)));
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.reactive.HostProvider#createWebClient(java.net.InetSocketAddress)
-	 */
-	@Override
-	public WebClient createWebClient(InetSocketAddress endpoint) {
-		return this.clientProvider.get(endpoint);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.elasticsearch.client.reactive.HostProvider#lookupActiveHost(org.springframework.data.elasticsearch.client.reactive.HostProvider.Verification)
-	 */
-	@Override
-	public Mono<InetSocketAddress> lookupActiveHost(Verification verification) {
-
-		if (Verification.LAZY.equals(verification) && state.isOnline()) {
-			return Mono.just(endpoint);
-		}
-
-		return clusterInfo().handle((information, sink) -> {
-
-			ElasticsearchHost host = information.getNodes().iterator().next();
-			if (host.isOnline()) {
-
-				sink.next(host.getEndpoint());
-				return;
-			}
-
-			sink.error(new NoReachableHostException(Collections.singleton(host)));
-		});
-	}
-
-	ElasticsearchHost getCachedHostState() {
-		return state;
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/reactive/WebClientProvider.java

@@ -1,155 +0,0 @@
-/*
- * Copyright 2018-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client.reactive;
-
-import java.net.InetSocketAddress;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.client.reactive.ClientHttpConnector;
-import org.springframework.lang.Nullable;
-import org.springframework.util.Assert;
-import org.springframework.web.reactive.function.client.WebClient;
-
-/**
- * Provider for {@link WebClient}s using a pre-configured {@code scheme}. This class returns {@link WebClient} for a
- * specific {@link InetSocketAddress endpoint} and encapsulates common configuration aspects of {@link WebClient} so
- * that code using {@link WebClient} is not required to apply further configuration to the actual client.
- * <p/>
- * Client instances are typically cached allowing reuse of pooled connections if configured on the
- * {@link ClientHttpConnector}.
- *
- * @author Christoph Strobl
- * @author Mark Paluch
- * @author Huw Ayling-Miller
- * @author Peter-Josef Meisch
- * @since 3.2
- */
-public interface WebClientProvider {
-
-	/**
-	 * Creates a new {@link WebClientProvider} using the {@code http} scheme and a default {@link ClientHttpConnector}.
-	 *
-	 * @return the resulting {@link WebClientProvider}.
-	 */
-	static WebClientProvider http() {
-		return create("http");
-	}
-
-	/**
-	 * Creates a new {@link WebClientProvider} using the given {@code scheme} and a default {@link ClientHttpConnector}.
-	 *
-	 * @param scheme protocol scheme such as {@literal http} or {@literal https}.
-	 * @return the resulting {@link WebClientProvider}.
-	 */
-	static WebClientProvider create(String scheme) {
-
-		Assert.hasText(scheme, "Protocol scheme must not be empty");
-
-		return new DefaultWebClientProvider(scheme, null);
-	}
-
-	/**
-	 * Creates a new {@link WebClientProvider} given {@code scheme} and {@link ClientHttpConnector}.
-	 *
-	 * @param scheme protocol scheme such as {@literal http} or {@literal https}.
-	 * @param connector the HTTP connector to use. Can be {@literal null}.
-	 * @return the resulting {@link WebClientProvider}.
-	 */
-	static WebClientProvider create(String scheme, @Nullable ClientHttpConnector connector) {
-
-		Assert.hasText(scheme, "Protocol scheme must not be empty");
-
-		return new DefaultWebClientProvider(scheme, connector);
-	}
-
-	/**
-	 * Obtain the {@link WebClient} configured with {@link #withDefaultHeaders(HttpHeaders) default HTTP headers} and
-	 * {@link Consumer} error callback for a given {@link InetSocketAddress endpoint}.
-	 *
-	 * @return the {@link WebClient} for the given {@link InetSocketAddress endpoint}.
-	 */
-	WebClient get(InetSocketAddress endpoint);
-
-	/**
-	 * Obtain the {@link HttpHeaders} to be used by default.
-	 *
-	 * @return never {@literal null}. {@link HttpHeaders#EMPTY} by default.
-	 */
-	HttpHeaders getDefaultHeaders();
-
-	/**
-	 * Obtain the {@link Consumer error listener} to be used;
-	 *
-	 * @return never {@literal null}.
-	 */
-	Consumer<Throwable> getErrorListener();
-
-	/**
-	 * Obtain the {@link String pathPrefix} to be used.
-	 *
-	 * @return the pathPrefix if set.
-	 * @since 4.0
-	 */
-	@Nullable
-	String getPathPrefix();
-
-	/**
-	 * Create a new instance of {@link WebClientProvider} applying the given headers by default.
-	 *
-	 * @param headers must not be {@literal null}.
-	 * @return new instance of {@link WebClientProvider}.
-	 */
-	WebClientProvider withDefaultHeaders(HttpHeaders headers);
-
-	/**
-	 * Create a new instance of {@link WebClientProvider} calling the given {@link Consumer} on error.
-	 *
-	 * @param errorListener must not be {@literal null}.
-	 * @return new instance of {@link WebClientProvider}.
-	 */
-	WebClientProvider withErrorListener(Consumer<Throwable> errorListener);
-
-	/**
-	 * Create a new instance of {@link WebClientProvider} where HTTP requests are called with the given path prefix.
-	 *
-	 * @param pathPrefix Path prefix to add to requests
-	 * @return new instance of {@link WebClientProvider}
-	 * @since 4.0
-	 */
-	WebClientProvider withPathPrefix(String pathPrefix);
-
-	/**
-	 * Create a new instance of {@link WebClientProvider} calling the given {@link Function} to configure the
-	 * {@link WebClient}.
-	 *
-	 * @param webClientConfigurer configuration function
-	 * @return new instance of {@link WebClientProvider}
-	 * @since 4.0
-	 */
-	WebClientProvider withWebClientConfigurer(Function<WebClient, WebClient> webClientConfigurer);
-
-	/**
-	 * Create a new instance of {@link WebClientProvider} calling the given {@link Consumer} to configure the requests of
-	 * this {@link WebClient}.
-	 *
-	 * @param requestConfigurer request configuration callback
-	 * @return new instance of {@link WebClientProvider}
-	 * @since 4.3
-	 */
-	WebClientProvider withRequestConfigurer(Consumer<WebClient.RequestHeadersSpec<?>> requestConfigurer);
-}

src/main/java/org/springframework/data/elasticsearch/client/reactive/package-info.java

@@ -1,3 +0,0 @@
-@org.springframework.lang.NonNullApi
-@org.springframework.lang.NonNullFields
-package org.springframework.data.elasticsearch.client.reactive;

src/main/java/org/springframework/data/elasticsearch/client/util/NamedXContents.java

@@ -1,175 +0,0 @@
-/*
- * Copyright 2020-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client.util;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-import org.elasticsearch.client.analytics.InferencePipelineAggregationBuilder;
-import org.elasticsearch.client.analytics.ParsedInference;
-import org.elasticsearch.client.analytics.ParsedStringStats;
-import org.elasticsearch.client.analytics.ParsedTopMetrics;
-import org.elasticsearch.client.analytics.StringStatsAggregationBuilder;
-import org.elasticsearch.client.analytics.TopMetricsAggregationBuilder;
-import org.elasticsearch.common.ParseField;
-import org.elasticsearch.common.xcontent.ContextParser;
-import org.elasticsearch.common.xcontent.NamedXContentRegistry;
-import org.elasticsearch.search.aggregations.Aggregation;
-import org.elasticsearch.search.aggregations.bucket.adjacency.AdjacencyMatrixAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.adjacency.ParsedAdjacencyMatrix;
-import org.elasticsearch.search.aggregations.bucket.composite.CompositeAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.composite.ParsedComposite;
-import org.elasticsearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.filter.FiltersAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.filter.ParsedFilter;
-import org.elasticsearch.search.aggregations.bucket.filter.ParsedFilters;
-import org.elasticsearch.search.aggregations.bucket.geogrid.GeoHashGridAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.geogrid.GeoTileGridAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.geogrid.ParsedGeoHashGrid;
-import org.elasticsearch.search.aggregations.bucket.geogrid.ParsedGeoTileGrid;
-import org.elasticsearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.global.ParsedGlobal;
-import org.elasticsearch.search.aggregations.bucket.histogram.AutoDateHistogramAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.histogram.HistogramAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.histogram.ParsedAutoDateHistogram;
-import org.elasticsearch.search.aggregations.bucket.histogram.ParsedDateHistogram;
-import org.elasticsearch.search.aggregations.bucket.histogram.ParsedHistogram;
-import org.elasticsearch.search.aggregations.bucket.histogram.ParsedVariableWidthHistogram;
-import org.elasticsearch.search.aggregations.bucket.histogram.VariableWidthHistogramAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.missing.MissingAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.missing.ParsedMissing;
-import org.elasticsearch.search.aggregations.bucket.nested.NestedAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.nested.ParsedNested;
-import org.elasticsearch.search.aggregations.bucket.nested.ParsedReverseNested;
-import org.elasticsearch.search.aggregations.bucket.nested.ReverseNestedAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.range.DateRangeAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.range.GeoDistanceAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.range.IpRangeAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.range.ParsedBinaryRange;
-import org.elasticsearch.search.aggregations.bucket.range.ParsedDateRange;
-import org.elasticsearch.search.aggregations.bucket.range.ParsedGeoDistance;
-import org.elasticsearch.search.aggregations.bucket.range.ParsedRange;
-import org.elasticsearch.search.aggregations.bucket.range.RangeAggregationBuilder;
-import org.elasticsearch.search.aggregations.bucket.sampler.InternalSampler;
-import org.elasticsearch.search.aggregations.bucket.sampler.ParsedSampler;
-import org.elasticsearch.search.aggregations.bucket.terms.*;
-import org.elasticsearch.search.aggregations.metrics.*;
-import org.elasticsearch.search.aggregations.pipeline.*;
-import org.elasticsearch.search.suggest.Suggest;
-import org.elasticsearch.search.suggest.completion.CompletionSuggestion;
-import org.elasticsearch.search.suggest.completion.CompletionSuggestionBuilder;
-import org.elasticsearch.search.suggest.phrase.PhraseSuggestion;
-import org.elasticsearch.search.suggest.phrase.PhraseSuggestionBuilder;
-import org.elasticsearch.search.suggest.term.TermSuggestion;
-import org.elasticsearch.search.suggest.term.TermSuggestionBuilder;
-import org.springframework.data.elasticsearch.client.reactive.ReactiveElasticsearchClient;
-
-/**
- * <p>
- * Original implementation source {@link org.elasticsearch.client.RestHighLevelClient#getDefaultNamedXContents()} by
- * {@literal Elasticsearch} (<a href="https://www.elastic.co">https://www.elastic.co</a>) licensed under the Apache
- * License, Version 2.0. The latest version used from Elasticsearch is 7.10.2.
- * </p>
- * Modified for usage with {@link ReactiveElasticsearchClient}.
- * <p>
- * Only intended for internal use.
- *
- * @author Russell Parry
- * @since 4.0
- */
-public class NamedXContents {
-
-	private NamedXContents() {
-		// contains only utility methods
-	}
-
-	public static List<NamedXContentRegistry.Entry> getDefaultNamedXContents() {
-		Map<String, ContextParser<Object, ? extends Aggregation>> map = new HashMap<>();
-		map.put(CardinalityAggregationBuilder.NAME, (p, c) -> ParsedCardinality.fromXContent(p, (String) c));
-		map.put(InternalHDRPercentiles.NAME, (p, c) -> ParsedHDRPercentiles.fromXContent(p, (String) c));
-		map.put(InternalHDRPercentileRanks.NAME, (p, c) -> ParsedHDRPercentileRanks.fromXContent(p, (String) c));
-		map.put(InternalTDigestPercentiles.NAME, (p, c) -> ParsedTDigestPercentiles.fromXContent(p, (String) c));
-		map.put(InternalTDigestPercentileRanks.NAME, (p, c) -> ParsedTDigestPercentileRanks.fromXContent(p, (String) c));
-		map.put(PercentilesBucketPipelineAggregationBuilder.NAME,
-				(p, c) -> ParsedPercentilesBucket.fromXContent(p, (String) c));
-		map.put(MedianAbsoluteDeviationAggregationBuilder.NAME,
-				(p, c) -> ParsedMedianAbsoluteDeviation.fromXContent(p, (String) c));
-		map.put(MinAggregationBuilder.NAME, (p, c) -> ParsedMin.fromXContent(p, (String) c));
-		map.put(MaxAggregationBuilder.NAME, (p, c) -> ParsedMax.fromXContent(p, (String) c));
-		map.put(SumAggregationBuilder.NAME, (p, c) -> ParsedSum.fromXContent(p, (String) c));
-		map.put(AvgAggregationBuilder.NAME, (p, c) -> ParsedAvg.fromXContent(p, (String) c));
-		map.put(WeightedAvgAggregationBuilder.NAME, (p, c) -> ParsedWeightedAvg.fromXContent(p, (String) c));
-		map.put(ValueCountAggregationBuilder.NAME, (p, c) -> ParsedValueCount.fromXContent(p, (String) c));
-		map.put(InternalSimpleValue.NAME, (p, c) -> ParsedSimpleValue.fromXContent(p, (String) c));
-		map.put(DerivativePipelineAggregationBuilder.NAME, (p, c) -> ParsedDerivative.fromXContent(p, (String) c));
-		map.put(InternalBucketMetricValue.NAME, (p, c) -> ParsedBucketMetricValue.fromXContent(p, (String) c));
-		map.put(StatsAggregationBuilder.NAME, (p, c) -> ParsedStats.fromXContent(p, (String) c));
-		map.put(StatsBucketPipelineAggregationBuilder.NAME, (p, c) -> ParsedStatsBucket.fromXContent(p, (String) c));
-		map.put(ExtendedStatsAggregationBuilder.NAME, (p, c) -> ParsedExtendedStats.fromXContent(p, (String) c));
-		map.put(ExtendedStatsBucketPipelineAggregationBuilder.NAME,
-				(p, c) -> ParsedExtendedStatsBucket.fromXContent(p, (String) c));
-		map.put(GeoBoundsAggregationBuilder.NAME, (p, c) -> ParsedGeoBounds.fromXContent(p, (String) c));
-		map.put(GeoCentroidAggregationBuilder.NAME, (p, c) -> ParsedGeoCentroid.fromXContent(p, (String) c));
-		map.put(HistogramAggregationBuilder.NAME, (p, c) -> ParsedHistogram.fromXContent(p, (String) c));
-		map.put(DateHistogramAggregationBuilder.NAME, (p, c) -> ParsedDateHistogram.fromXContent(p, (String) c));
-		map.put(AutoDateHistogramAggregationBuilder.NAME, (p, c) -> ParsedAutoDateHistogram.fromXContent(p, (String) c));
-		map.put(VariableWidthHistogramAggregationBuilder.NAME,
-				(p, c) -> ParsedVariableWidthHistogram.fromXContent(p, (String) c));
-		map.put(StringTerms.NAME, (p, c) -> ParsedStringTerms.fromXContent(p, (String) c));
-		map.put(LongTerms.NAME, (p, c) -> ParsedLongTerms.fromXContent(p, (String) c));
-		map.put(DoubleTerms.NAME, (p, c) -> ParsedDoubleTerms.fromXContent(p, (String) c));
-		map.put(LongRareTerms.NAME, (p, c) -> ParsedLongRareTerms.fromXContent(p, (String) c));
-		map.put(StringRareTerms.NAME, (p, c) -> ParsedStringRareTerms.fromXContent(p, (String) c));
-		map.put(MissingAggregationBuilder.NAME, (p, c) -> ParsedMissing.fromXContent(p, (String) c));
-		map.put(NestedAggregationBuilder.NAME, (p, c) -> ParsedNested.fromXContent(p, (String) c));
-		map.put(ReverseNestedAggregationBuilder.NAME, (p, c) -> ParsedReverseNested.fromXContent(p, (String) c));
-		map.put(GlobalAggregationBuilder.NAME, (p, c) -> ParsedGlobal.fromXContent(p, (String) c));
-		map.put(FilterAggregationBuilder.NAME, (p, c) -> ParsedFilter.fromXContent(p, (String) c));
-		map.put(InternalSampler.PARSER_NAME, (p, c) -> ParsedSampler.fromXContent(p, (String) c));
-		map.put(GeoHashGridAggregationBuilder.NAME, (p, c) -> ParsedGeoHashGrid.fromXContent(p, (String) c));
-		map.put(GeoTileGridAggregationBuilder.NAME, (p, c) -> ParsedGeoTileGrid.fromXContent(p, (String) c));
-		map.put(RangeAggregationBuilder.NAME, (p, c) -> ParsedRange.fromXContent(p, (String) c));
-		map.put(DateRangeAggregationBuilder.NAME, (p, c) -> ParsedDateRange.fromXContent(p, (String) c));
-		map.put(GeoDistanceAggregationBuilder.NAME, (p, c) -> ParsedGeoDistance.fromXContent(p, (String) c));
-		map.put(FiltersAggregationBuilder.NAME, (p, c) -> ParsedFilters.fromXContent(p, (String) c));
-		map.put(AdjacencyMatrixAggregationBuilder.NAME, (p, c) -> ParsedAdjacencyMatrix.fromXContent(p, (String) c));
-		map.put(SignificantLongTerms.NAME, (p, c) -> ParsedSignificantLongTerms.fromXContent(p, (String) c));
-		map.put(SignificantStringTerms.NAME, (p, c) -> ParsedSignificantStringTerms.fromXContent(p, (String) c));
-		map.put(ScriptedMetricAggregationBuilder.NAME, (p, c) -> ParsedScriptedMetric.fromXContent(p, (String) c));
-		map.put(IpRangeAggregationBuilder.NAME, (p, c) -> ParsedBinaryRange.fromXContent(p, (String) c));
-		map.put(TopHitsAggregationBuilder.NAME, (p, c) -> ParsedTopHits.fromXContent(p, (String) c));
-		map.put(CompositeAggregationBuilder.NAME, (p, c) -> ParsedComposite.fromXContent(p, (String) c));
-		map.put(StringStatsAggregationBuilder.NAME, (p, c) -> ParsedStringStats.PARSER.parse(p, (String) c));
-		map.put(TopMetricsAggregationBuilder.NAME, (p, c) -> ParsedTopMetrics.PARSER.parse(p, (String) c));
-		map.put(InferencePipelineAggregationBuilder.NAME, (p, c) -> ParsedInference.fromXContent(p, (String) (c)));
-		List<NamedXContentRegistry.Entry> entries = map.entrySet().stream().map(
-				entry -> new NamedXContentRegistry.Entry(Aggregation.class, new ParseField(entry.getKey()), entry.getValue()))
-				.collect(Collectors.toList());
-		entries.add(
-				new NamedXContentRegistry.Entry(Suggest.Suggestion.class, new ParseField(TermSuggestionBuilder.SUGGESTION_NAME),
-						(parser, context) -> TermSuggestion.fromXContent(parser, (String) context)));
-		entries.add(new NamedXContentRegistry.Entry(Suggest.Suggestion.class,
-				new ParseField(PhraseSuggestionBuilder.SUGGESTION_NAME),
-				(parser, context) -> PhraseSuggestion.fromXContent(parser, (String) context)));
-		entries.add(new NamedXContentRegistry.Entry(Suggest.Suggestion.class,
-				new ParseField(CompletionSuggestionBuilder.SUGGESTION_NAME),
-				(parser, context) -> CompletionSuggestion.fromXContent(parser, (String) context)));
-		return entries;
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/util/ScrollState.java

@@ -1,72 +0,0 @@
-/*
- * Copyright 2020-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.elasticsearch.client.util;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-
-import org.elasticsearch.action.search.SearchScrollRequest;
-import org.elasticsearch.search.Scroll;
-import org.springframework.lang.Nullable;
-import org.springframework.util.StringUtils;
-
-/**
- * Mutable state object holding scrollId to be used for {@link SearchScrollRequest#scroll(Scroll)}
- *
- * @author Christoph Strobl
- * @author Peter-Josef Meisch
- * @since 3.2
- */
-public class ScrollState {
-
-	private final Object lock = new Object();
-
-	private final Set<String> pastIds = new LinkedHashSet<>();
-	@Nullable private String scrollId;
-
-	public ScrollState() {}
-
-	public ScrollState(String scrollId) {
-		updateScrollId(scrollId);
-	}
-
-	@Nullable
-	public String getScrollId() {
-		return scrollId;
-	}
-
-	public List<String> getScrollIds() {
-
-		synchronized (lock) {
-			return Collections.unmodifiableList(new ArrayList<>(pastIds));
-		}
-	}
-
-	public void updateScrollId(@Nullable String scrollId) {
-
-		if (StringUtils.hasText(scrollId)) {
-
-			synchronized (lock) {
-
-				this.scrollId = scrollId;
-				pastIds.add(scrollId);
-			}
-		}
-	}
-}

src/main/java/org/springframework/data/elasticsearch/client/util/package-info.java

@@ -1,3 +0,0 @@
-@org.springframework.lang.NonNullApi
-@org.springframework.lang.NonNullFields
-package org.springframework.data.elasticsearch.client.util;