DATAES-519 - Add reactive repository support.

Reactive Elasticsearch repository support builds on the core repository support utilizing
operations provided via ReactiveElasticsearchOperations executed by a ReactiveElasticsearchClient.

Spring Data Elasticsearchs reactive repository support uses Project Reactor as its reactive
composition library of choice.

There are 3 main interfaces to be used:

* ReactiveRepository
* ReactiveCrudRepository
* ReactiveSortingRepository

For Java configuration, use the @EnableReactiveElasticsearchRepositories annotation.
The following listing shows how to use Java configuration for a repository:

@configuration
@EnableReactiveElasticsearchRepositories
public class Config extends AbstractReactiveElasticsearchConfiguration {

  @OverRide
  public ReactiveElasticsearchClient reactiveElasticsearchClient() {
    return ReactiveRestClients.create(ClientConfiguration.localhost());
  }
}

Using a repository that extends ReactiveSortingRepository makes all CRUD operations 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.

The repository itself allows defining additional methods backed by the inferred proxy.

public interface ReactivePersonRepository extends ReactiveSortingRepository<Person, String> {

  Flux<Person> findByFirstname(String firstname);

  Flux<Person> findByFirstname(Publisher<String> firstname);

  Flux<Person> findByFirstnameOrderByLastname(String firstname);

  Flux<Person> findByFirstname(String firstname, Sort sort);

  Flux<Person> findByFirstname(String firstname, Pageable page);

  Mono<Person> findByFirstnameAndLastname(String firstname, String lastname);

  Mono<Person> findFirstByLastname(String lastname);

  @query("{ \"bool\" : { \"must\" : { \"term\" : { \"lastname\" : \"?0\" } } } }")
  Flux<Person> findByLastname(String lastname);

  Mono<Long> countByFirstname(String firstname)

  Mono<Boolean> existsByFirstname(String firstname)

  Mono<Long> deleteByFirstname(String firstname)
}

Original Pull Request: spring-projects#235

Author: christophstrobl

pom.xml

@@ -270,6 +270,9 @@
 					<includes>
 						<include>**/*Tests.java</include>
 					</includes>
+					<systemPropertyVariables>
+						<es.set.netty.runtime.available.processors>false</es.set.netty.runtime.available.processors>
+					</systemPropertyVariables>
 				</configuration>
 			</plugin>
 		</plugins>

src/main/asciidoc/index.adoc

@@ -31,6 +31,7 @@ include::{spring-data-commons-docs}/repositories.adoc[]
 include::reference/elasticsearch-clients.adoc[]
 include::reference/data-elasticsearch.adoc[]
 include::reference/reactive-elasticsearch-operations.adoc[]
+include::reference/reactive-elasticsearch-repositories.adoc[]
 include::reference/elasticsearch-misc.adoc[]
 :leveloffset: -1
 

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

@@ -0,0 +1,130 @@
+[[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 Elasticsearchs 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]
+----
+public 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/NoSuchIndexException.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2019 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
+ *
+ *      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.
+ */
+package org.springframework.data.elasticsearch;
+
+import org.springframework.dao.NonTransientDataAccessResourceException;
+
+/**
+ * @author Christoph Strobl
+ * @since 3.2
+ */
+public class NoSuchIndexException extends NonTransientDataAccessResourceException {
+
+	private final String index;
+
+	public NoSuchIndexException(String index, Throwable cause) {
+		super(String.format("Index %s not found.", index), cause);
+		this.index = index;
+	}
+
+	public String getIndex() {
+		return index;
+	}
+}

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

@@ -42,6 +42,22 @@ 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/>

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

@@ -545,7 +545,7 @@ private static <T> Mono<T> doDecode(ClientResponse response, Class<T> responseTy
 			return Mono.justOrEmpty(responseType
 					.cast(ReflectionUtils.invokeMethod(fromXContent, responseType, createParser(mediaType, content))));
 
-		} catch (Exception errorParseFailure) {
+		} catch (Throwable errorParseFailure) { // cause elasticsearch also uses AssertionError
 
 			try {
 				return Mono.error(BytesRestResponse.errorFromXContent(createParser(mediaType, content)));

src/main/java/org/springframework/data/elasticsearch/config/AbstractReactiveElasticsearchConfiguration.java

@@ -47,7 +47,7 @@ public abstract class AbstractReactiveElasticsearchConfiguration extends Elastic
 	 * @return never {@literal null}.
 	 */
 	@Bean
-	public ReactiveElasticsearchOperations reactiveElasticsearchOperations() {
+	public ReactiveElasticsearchOperations reactiveElasticsearchTemplate() {
 
 		ReactiveElasticsearchTemplate template = new ReactiveElasticsearchTemplate(reactiveElasticsearchClient(),
 				elasticsearchConverter());

src/main/java/org/springframework/data/elasticsearch/core/ElasticsearchExceptionTranslator.java

@@ -22,6 +22,8 @@
 import org.springframework.dao.DataAccessException;
 import org.springframework.dao.DataAccessResourceFailureException;
 import org.springframework.dao.support.PersistenceExceptionTranslator;
+import org.springframework.data.elasticsearch.NoSuchIndexException;
+import org.springframework.util.CollectionUtils;
 
 /**
  * @author Christoph Strobl
@@ -33,15 +35,22 @@ public class ElasticsearchExceptionTranslator implements PersistenceExceptionTra
 	public DataAccessException translateExceptionIfPossible(RuntimeException ex) {
 
 		if (ex instanceof ElasticsearchException) {
-			// TODO: exception translation
-			ElasticsearchException elasticsearchExption = (ElasticsearchException) ex;
-//			elasticsearchExption.get
+
+			ElasticsearchException elasticsearchException = (ElasticsearchException) ex;
+
+			if (!indexAvailable(elasticsearchException)) {
+				return new NoSuchIndexException(elasticsearchException.getMetadata("es.index").toString(), ex);
+			}
 		}
 
-		if(ex.getCause() instanceof ConnectException) {
+		if (ex.getCause() instanceof ConnectException) {
 			return new DataAccessResourceFailureException(ex.getMessage(), ex);
 		}
 
 		return null;
 	}
+
+	private boolean indexAvailable(ElasticsearchException ex) {
+		return !CollectionUtils.contains(ex.getMetadata("es.index_uuid").iterator(), "_na_");
+	}
 }

src/main/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchOperations.java

@@ -22,6 +22,7 @@
 import org.reactivestreams.Publisher;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.elasticsearch.client.reactive.ReactiveElasticsearchClient;
+import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter;
 import org.springframework.data.elasticsearch.core.query.Query;
 import org.springframework.data.elasticsearch.core.query.StringQuery;
 import org.springframework.lang.Nullable;
@@ -451,6 +452,13 @@ default Mono<Long> deleteBy(Query query, Class<?> entityType, @Nullable String i
 	 */
 	Mono<Long> deleteBy(Query query, Class<?> entityType, @Nullable String index, @Nullable String type);
 
+	/**
+	 * Get the {@link ElasticsearchConverter} used.
+	 *
+	 * @return never {@literal null}
+	 */
+	ElasticsearchConverter getElasticsearchConverter();
+
 	/**
 	 * Callback interface to be used with {@link #execute(ClientCallback)} for operating directly on
 	 * {@link ReactiveElasticsearchClient}.