Skip to content

Commit 0b33d7f

Browse files
sothawosothawo
authored
Introduce IndexOperationsAdapter.
Original Pull Request #2724 Closes #2723
1 parent ccb7d23 commit 0b33d7f

14 files changed

+372
-151
lines changed

‎src/main/java/org/springframework/data/elasticsearch/core/IndexOperationsAdapter.java

+214
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,214 @@
1+
/*
2+
* Copyright 2023 the original author or authors.
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* https://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
package org.springframework.data.elasticsearch.core;
17+
18+
import reactor.core.publisher.Mono;
19+
20+
import java.util.List;
21+
import java.util.Map;
22+
import java.util.Objects;
23+
import java.util.Set;
24+
25+
import org.springframework.data.elasticsearch.core.document.Document;
26+
import org.springframework.data.elasticsearch.core.index.*;
27+
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
28+
import org.springframework.lang.Nullable;
29+
import org.springframework.util.Assert;
30+
31+
/**
32+
* Adapter for creating synchronous calls for a reactive {@link ReactiveIndexOperations}.
33+
*
34+
* @author Peter-Josef Meisch
35+
* @since 5.2
36+
*/
37+
public interface IndexOperationsAdapter extends IndexOperations {
38+
static IndexOperationsAdapter blocking(ReactiveIndexOperations reactiveIndexOperations) {
39+
40+
Assert.notNull(reactiveIndexOperations, "reactiveIndexOperations must not be null");
41+
42+
return new IndexOperationsAdapter() {
43+
@Override
44+
public boolean create() {
45+
return Boolean.TRUE.equals(reactiveIndexOperations.create().block());
46+
}
47+
48+
@Override
49+
public boolean create(Map<String, Object> settings) {
50+
return Boolean.TRUE.equals(reactiveIndexOperations.create(settings).block());
51+
}
52+
53+
@Override
54+
public boolean create(Map<String, Object> settings, Document mapping) {
55+
return Boolean.TRUE.equals(reactiveIndexOperations.create(settings, mapping).block());
56+
}
57+
58+
@Override
59+
public boolean createWithMapping() {
60+
return Boolean.TRUE.equals(reactiveIndexOperations.createWithMapping().block());
61+
}
62+
63+
@Override
64+
public boolean delete() {
65+
return Boolean.TRUE.equals(reactiveIndexOperations.delete().block());
66+
}
67+
68+
@Override
69+
public boolean exists() {
70+
return Boolean.TRUE.equals(reactiveIndexOperations.exists().block());
71+
}
72+
73+
@Override
74+
public void refresh() {
75+
reactiveIndexOperations.refresh().block();
76+
}
77+
78+
@Override
79+
public Document createMapping() {
80+
return Objects.requireNonNull(reactiveIndexOperations.createMapping().block());
81+
}
82+
83+
@Override
84+
public Document createMapping(Class<?> clazz) {
85+
return Objects.requireNonNull(reactiveIndexOperations.createMapping(clazz).block());
86+
87+
}
88+
89+
@Override
90+
public boolean putMapping(Document mapping) {
91+
return Boolean.TRUE.equals(reactiveIndexOperations.putMapping(Mono.just(mapping)).block());
92+
}
93+
94+
@Override
95+
public Map<String, Object> getMapping() {
96+
return Objects.requireNonNull(reactiveIndexOperations.getMapping().block());
97+
}
98+
99+
@Override
100+
public Settings createSettings() {
101+
return Objects.requireNonNull(reactiveIndexOperations.createSettings().block());
102+
}
103+
104+
@Override
105+
public Settings createSettings(Class<?> clazz) {
106+
return Objects.requireNonNull(reactiveIndexOperations.createSettings(clazz).block());
107+
}
108+
109+
@Override
110+
public Settings getSettings() {
111+
return Objects.requireNonNull(reactiveIndexOperations.getSettings().block());
112+
}
113+
114+
@Override
115+
public Settings getSettings(boolean includeDefaults) {
116+
return Objects.requireNonNull(reactiveIndexOperations.getSettings(includeDefaults).block());
117+
}
118+
119+
@Override
120+
public boolean alias(AliasActions aliasActions) {
121+
return Boolean.TRUE.equals(reactiveIndexOperations.alias(aliasActions).block());
122+
}
123+
124+
@Override
125+
public Map<String, Set<AliasData>> getAliases(String... aliasNames) {
126+
return Objects.requireNonNull(reactiveIndexOperations.getAliases(aliasNames).block());
127+
}
128+
129+
@Override
130+
public Map<String, Set<AliasData>> getAliasesForIndex(String... indexNames) {
131+
return Objects.requireNonNull(reactiveIndexOperations.getAliasesForIndex(indexNames).block());
132+
}
133+
134+
@Deprecated
135+
@Override
136+
public boolean putTemplate(PutTemplateRequest putTemplateRequest) {
137+
return Boolean.TRUE.equals(reactiveIndexOperations.putTemplate(putTemplateRequest).block());
138+
}
139+
140+
@Override
141+
public boolean putIndexTemplate(PutIndexTemplateRequest putIndexTemplateRequest) {
142+
return Boolean.TRUE.equals(reactiveIndexOperations.putIndexTemplate(putIndexTemplateRequest).block());
143+
}
144+
145+
@Override
146+
public boolean putComponentTemplate(PutComponentTemplateRequest putComponentTemplateRequest) {
147+
return Boolean.TRUE.equals(reactiveIndexOperations.putComponentTemplate(putComponentTemplateRequest).block());
148+
}
149+
150+
@Override
151+
public boolean existsComponentTemplate(ExistsComponentTemplateRequest existsComponentTemplateRequest) {
152+
return Boolean.TRUE
153+
.equals(reactiveIndexOperations.existsComponentTemplate(existsComponentTemplateRequest).block());
154+
}
155+
156+
@Override
157+
public List<TemplateResponse> getComponentTemplate(GetComponentTemplateRequest getComponentTemplateRequest) {
158+
return Objects.requireNonNull(
159+
reactiveIndexOperations.getComponentTemplate(getComponentTemplateRequest).collectList().block());
160+
}
161+
162+
@Override
163+
public boolean deleteComponentTemplate(DeleteComponentTemplateRequest deleteComponentTemplateRequest) {
164+
return Boolean.TRUE
165+
.equals(reactiveIndexOperations.deleteComponentTemplate(deleteComponentTemplateRequest).block());
166+
}
167+
168+
@Deprecated
169+
@Nullable
170+
@Override
171+
public TemplateData getTemplate(GetTemplateRequest getTemplateRequest) {
172+
return Objects.requireNonNull(reactiveIndexOperations).getTemplate(getTemplateRequest).block();
173+
}
174+
175+
@Deprecated
176+
@Override
177+
public boolean existsTemplate(ExistsTemplateRequest existsTemplateRequest) {
178+
return Boolean.TRUE.equals(reactiveIndexOperations.existsTemplate(existsTemplateRequest).block());
179+
}
180+
181+
@Override
182+
public boolean existsIndexTemplate(ExistsIndexTemplateRequest existsTemplateRequest) {
183+
return Boolean.TRUE.equals(reactiveIndexOperations.existsIndexTemplate(existsTemplateRequest).block());
184+
}
185+
186+
@Override
187+
public List<TemplateResponse> getIndexTemplate(GetIndexTemplateRequest getIndexTemplateRequest) {
188+
return Objects
189+
.requireNonNull(reactiveIndexOperations.getIndexTemplate(getIndexTemplateRequest).collectList().block());
190+
}
191+
192+
@Override
193+
public boolean deleteIndexTemplate(DeleteIndexTemplateRequest deleteIndexTemplateRequest) {
194+
return Boolean.TRUE.equals(reactiveIndexOperations.deleteIndexTemplate(deleteIndexTemplateRequest).block());
195+
}
196+
197+
@Deprecated
198+
@Override
199+
public boolean deleteTemplate(DeleteTemplateRequest deleteTemplateRequest) {
200+
return Boolean.TRUE.equals(reactiveIndexOperations.deleteTemplate(deleteTemplateRequest).block());
201+
}
202+
203+
@Override
204+
public List<IndexInformation> getInformation(IndexCoordinates index) {
205+
return Objects.requireNonNull(reactiveIndexOperations.getInformation(index).collectList().block());
206+
}
207+
208+
@Override
209+
public IndexCoordinates getIndexCoordinates() {
210+
return reactiveIndexOperations.getIndexCoordinates();
211+
}
212+
};
213+
}
214+
}

‎src/main/java/org/springframework/data/elasticsearch/repository/support/SimpleReactiveElasticsearchRepository.java

+9-5
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,8 @@
1515
*/
1616
package org.springframework.data.elasticsearch.repository.support;
1717

18+
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
19+
1820
import reactor.core.publisher.Flux;
1921
import reactor.core.publisher.Mono;
2022

@@ -62,12 +64,14 @@ public SimpleReactiveElasticsearchRepository(ElasticsearchEntityInformation<T, I
6264

6365
private void createIndexAndMappingIfNeeded() {
6466

67+
var blockingIndexOperations = blocking(indexOperations);
68+
6569
if (shouldCreateIndexAndMapping()) {
66-
indexOperations.exists() //
67-
.flatMap(exists -> exists ? Mono.empty() : indexOperations.createWithMapping()) //
68-
.block();
69-
} else if(shouldAlwaysWriteMapping()) {
70-
indexOperations.putMapping().block();
70+
if (!blockingIndexOperations.exists()) {
71+
blockingIndexOperations.createWithMapping();
72+
}
73+
} else if (shouldAlwaysWriteMapping()) {
74+
blockingIndexOperations.putMapping();
7175
}
7276
}
7377

‎src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchIntegrationTests.java

+13-8
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@
1818
import static java.util.Collections.*;
1919
import static org.assertj.core.api.Assertions.*;
2020
import static org.springframework.data.elasticsearch.annotations.FieldType.*;
21+
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
2122
import static org.springframework.data.elasticsearch.core.query.StringQuery.*;
2223

2324
import reactor.core.publisher.Flux;
@@ -105,14 +106,14 @@ public abstract class ReactiveElasticsearchIntegrationTests {
105106
public void beforeEach() {
106107

107108
indexNameProvider.increment();
108-
operations.indexOps(SampleEntity.class).createWithMapping().block();
109-
operations.indexOps(IndexedIndexNameEntity.class).createWithMapping().block();
109+
blocking(operations.indexOps(SampleEntity.class)).createWithMapping();
110+
blocking(operations.indexOps(IndexedIndexNameEntity.class)).createWithMapping();
110111
}
111112

112113
@Test
113114
@Order(java.lang.Integer.MAX_VALUE)
114115
void cleanup() {
115-
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + "*")).delete().block();
116+
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
116117
}
117118
// endregion
118119

@@ -625,7 +626,8 @@ public void shouldDeleteAcrossIndex() {
625626
.as(StepVerifier::create)//
626627
.verifyComplete();
627628

628-
operations.indexOps(thisIndex).refresh().then(operations.indexOps(thatIndex).refresh()).block();
629+
blocking(operations.indexOps(thisIndex)).refresh();
630+
blocking(operations.indexOps(thatIndex)).refresh();
629631

630632
Query query = getBuilderWithTermQuery("message", "test").build();
631633

@@ -651,7 +653,8 @@ public void shouldDeleteAcrossIndexWhenNoMatchingDataPresent() {
651653
.as(StepVerifier::create)//
652654
.verifyComplete();
653655

654-
operations.indexOps(thisIndex).refresh().then(operations.indexOps(thatIndex).refresh()).block();
656+
blocking(operations.indexOps(thisIndex)).refresh();
657+
blocking(operations.indexOps(thatIndex)).refresh();
655658

656659
Query query = getBuilderWithTermQuery("message", "negative").build();
657660

@@ -876,7 +879,7 @@ void searchShouldReturnSeqNoPrimaryTerm() {
876879
original.setMessage("It's fine");
877880
OptimisticEntity saved = operations.save(original).block();
878881

879-
operations.indexOps(OptimisticEntity.class).refresh().block();
882+
blocking(operations.indexOps(OptimisticEntity.class)).refresh();
880883

881884
operations
882885
.search(searchQueryForOne(saved.getId()), OptimisticEntity.class,
@@ -1081,14 +1084,16 @@ void shouldReturnInformationListOfAllIndices() {
10811084
String indexName = indexNameProvider.indexName();
10821085
String aliasName = indexName + "-alias";
10831086
ReactiveIndexOperations indexOps = operations.indexOps(EntityWithSettingsAndMappingsReactive.class);
1087+
var blockingIndexOps = blocking(indexOps);
10841088

10851089
// beforeEach uses SampleEntity, so recreate the index here
1086-
indexOps.delete().then(indexOps.createWithMapping()).block();
1090+
blockingIndexOps.delete();
1091+
blockingIndexOps.createWithMapping();
10871092

10881093
AliasActionParameters parameters = AliasActionParameters.builder().withAliases(aliasName).withIndices(indexName)
10891094
.withIsHidden(false).withIsWriteIndex(false).withRouting("indexrouting").withSearchRouting("searchrouting")
10901095
.build();
1091-
indexOps.alias(new AliasActions(new AliasAction.Add(parameters))).block();
1096+
blockingIndexOps.alias(new AliasActions(new AliasAction.Add(parameters)));
10921097

10931098
indexOps.getInformation().as(StepVerifier::create).consumeNextWith(indexInformation -> {
10941099
assertThat(indexInformation.getName()).isEqualTo(indexName);

‎src/test/java/org/springframework/data/elasticsearch/core/ReactivePointInTimeIntegrationTests.java

+3-4
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@
1616
package org.springframework.data.elasticsearch.core;
1717

1818
import static org.assertj.core.api.Assertions.*;
19+
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
1920

2021
import java.time.Duration;
2122
import java.util.List;
@@ -49,19 +50,17 @@ public abstract class ReactivePointInTimeIntegrationTests {
4950

5051
@Autowired ReactiveElasticsearchOperations operations;
5152
@Autowired IndexNameProvider indexNameProvider;
52-
@Nullable ReactiveIndexOperations indexOperations;
5353

5454
@BeforeEach
5555
void setUp() {
5656
indexNameProvider.increment();
57-
indexOperations = operations.indexOps(SampleEntity.class);
58-
indexOperations.createWithMapping().block();
57+
blocking(operations.indexOps(SampleEntity.class)).createWithMapping();
5958
}
6059

6160
@Test
6261
@Order(Integer.MAX_VALUE)
6362
void cleanup() {
64-
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*')).delete().block();
63+
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
6564
}
6665

6766
@Test // #1684

‎src/test/java/org/springframework/data/elasticsearch/core/ReactiveReindexIntegrationTests.java

+3-2
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@
1616
package org.springframework.data.elasticsearch.core;
1717

1818
import static org.assertj.core.api.Assertions.*;
19+
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
1920
import static org.springframework.data.elasticsearch.utils.IdGenerator.*;
2021

2122
import reactor.test.StepVerifier;
@@ -54,13 +55,13 @@ public abstract class ReactiveReindexIntegrationTests {
5455
public void beforeEach() {
5556

5657
indexNameProvider.increment();
57-
operations.indexOps(Entity.class).createWithMapping().block();
58+
blocking(operations.indexOps(Entity.class)).createWithMapping();
5859
}
5960

6061
@Test
6162
@Order(java.lang.Integer.MAX_VALUE)
6263
void cleanup() {
63-
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + "*")).delete().block();
64+
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
6465
}
6566

6667
@Test

0 commit comments

Comments
 (0)