HSEARCH-3759 Clarify that backends/indexes in SearchIntegrationPartia…

…lBuildStateImpl are not "partially built" but rather "not started"
hibernate · Mar 6, 2020 · 804fc04 · 804fc04
1 parent 4e5efeb
commit 804fc04
Show file tree

Hide file tree

Showing 5 changed files with 54 additions and 54 deletions.
diff --git a/...common/impl/BackendPartialBuildState.java → ...e/common/impl/BackendNonStartedState.java b/...common/impl/BackendPartialBuildState.java → ...e/common/impl/BackendNonStartedState.java
@@ -14,21 +14,21 @@
 import org.hibernate.search.engine.reporting.spi.ContextualFailureCollector;
 import org.hibernate.search.engine.reporting.spi.EventContexts;
 
-class BackendPartialBuildState {
+class BackendNonStartedState {
 
 	private final String backendName;
-	private final BackendImplementor partiallyBuiltBackend;
+	private final BackendImplementor backend;
 
-	BackendPartialBuildState(String backendName, BackendImplementor partiallyBuiltBackend) {
+	BackendNonStartedState(String backendName, BackendImplementor backend) {
 		this.backendName = backendName;
-		this.partiallyBuiltBackend = partiallyBuiltBackend;
+		this.backend = backend;
 	}
 
 	void closeOnFailure() {
-		partiallyBuiltBackend.stop();
+		backend.stop();
 	}
 
-	BackendImplementor finalizeBuild(RootFailureCollector rootFailureCollector,
+	BackendImplementor start(RootFailureCollector rootFailureCollector,
 			BeanResolver beanResolver,
 			ConfigurationPropertySource rootPropertySource) {
 		ContextualFailureCollector backendFailureCollector =
@@ -41,11 +41,11 @@ BackendImplementor finalizeBuild(RootFailureCollector rootFailureCollector,
 				backendPropertySource
 		);
 		try {
-			partiallyBuiltBackend.start( startContext );
+			backend.start( startContext );
 		}
 		catch (RuntimeException e) {
 			backendFailureCollector.add( e );
 		}
-		return partiallyBuiltBackend; // The backend is now fully built
+		return backend; // The backend is now started
 	}
 }
diff --git a/...rc/main/java/org/hibernate/search/engine/common/impl/IndexManagerBuildingStateHolder.java b/...rc/main/java/org/hibernate/search/engine/common/impl/IndexManagerBuildingStateHolder.java
@@ -113,20 +113,20 @@ private String getDefaultBackendName() {
 		}
 	}
 
-	Map<String, BackendPartialBuildState> getBackendPartialBuildStates() {
+	Map<String, BackendNonStartedState> getBackendNonStartedStates() {
 		// Use a LinkedHashMap for deterministic iteration
-		Map<String, BackendPartialBuildState> backendsByName = new LinkedHashMap<>();
+		Map<String, BackendNonStartedState> backendsByName = new LinkedHashMap<>();
 		for ( Map.Entry<String, BackendInitialBuildState> entry : backendBuildStateByName.entrySet() ) {
-			backendsByName.put( entry.getKey(), entry.getValue().getPartiallyBuilt() );
+			backendsByName.put( entry.getKey(), entry.getValue().getNonStartedState() );
 		}
 		return backendsByName;
 	}
 
-	Map<String, IndexManagerPartialBuildState> getIndexManagersByName() {
+	Map<String, IndexManagerNonStartedState> getIndexManagersNonStartedStates() {
 		// Use a LinkedHashMap for deterministic iteration
-		Map<String, IndexManagerPartialBuildState> indexManagersByName = new LinkedHashMap<>();
+		Map<String, IndexManagerNonStartedState> indexManagersByName = new LinkedHashMap<>();
 		for ( Map.Entry<String, IndexManagerInitialBuildState> entry : indexManagerBuildStateByName.entrySet() ) {
-			indexManagersByName.put( entry.getKey(), entry.getValue().getPartialBuildState() );
+			indexManagersByName.put( entry.getKey(), entry.getValue().getNonStartedState() );
 		}
 		return indexManagersByName;
 	}
@@ -196,12 +196,12 @@ void closeOnFailure() {
 			backend.stop();
 		}
 
-		BackendPartialBuildState getPartiallyBuilt() {
-			return new BackendPartialBuildState( backendName, backend );
+		BackendNonStartedState getNonStartedState() {
+			return new BackendNonStartedState( backendName, backend );
 		}
 	}
 
-	private class IndexManagerInitialBuildState implements IndexManagerBuildingState {
+	private static class IndexManagerInitialBuildState implements IndexManagerBuildingState {
 
 		private final String backendName;
 		private final String indexName;
@@ -250,14 +250,14 @@ public IndexManagerImplementor build() {
 			return indexManager;
 		}
 
-		IndexManagerPartialBuildState getPartialBuildState() {
+		IndexManagerNonStartedState getNonStartedState() {
 			if ( indexManager == null ) {
 				throw new AssertionFailure(
 						"Index manager " + indexName + " was not built by the mapper as expected."
 						+ " There is probably a bug in the mapper implementation."
 				);
 			}
-			return new IndexManagerPartialBuildState( backendName, indexName, indexManager );
+			return new IndexManagerNonStartedState( backendName, indexName, indexManager );
 		}
 	}
 

diff --git a/...n/impl/IndexManagerPartialBuildState.java → ...mon/impl/IndexManagerNonStartedState.java b/...n/impl/IndexManagerPartialBuildState.java → ...mon/impl/IndexManagerNonStartedState.java
@@ -18,24 +18,24 @@
 import org.hibernate.search.util.common.impl.Futures;
 import org.hibernate.search.util.common.impl.Throwables;
 
-class IndexManagerPartialBuildState {
+class IndexManagerNonStartedState {
 
 	private final String backendName;
 	private final String indexName;
-	private final IndexManagerImplementor partiallyBuiltIndexManager;
+	private final IndexManagerImplementor indexManager;
 
-	IndexManagerPartialBuildState(String backendName,
-			String indexName, IndexManagerImplementor partiallyBuiltIndexManager) {
+	IndexManagerNonStartedState(String backendName,
+			String indexName, IndexManagerImplementor indexManager) {
 		this.backendName = backendName;
 		this.indexName = indexName;
-		this.partiallyBuiltIndexManager = partiallyBuiltIndexManager;
+		this.indexManager = indexManager;
 	}
 
 	void closeOnFailure() {
-		partiallyBuiltIndexManager.stop();
+		indexManager.stop();
 	}
 
-	CompletableFuture<?> finalizeBuild(RootFailureCollector rootFailureCollector,
+	CompletableFuture<?> start(RootFailureCollector rootFailureCollector,
 			BeanResolver beanResolver,
 			ConfigurationPropertySource rootPropertySource) {
 		ContextualFailureCollector indexFailureCollector =
@@ -51,14 +51,14 @@ CompletableFuture<?> finalizeBuild(RootFailureCollector rootFailureCollector,
 		IndexManagerStartContextImpl startContext = new IndexManagerStartContextImpl(
 				indexFailureCollector, beanResolver, indexPropertySource
 		);
-		return partiallyBuiltIndexManager.start( startContext )
+		return indexManager.start( startContext )
 				.exceptionally( Futures.handler( e -> {
 					indexFailureCollector.add( Throwables.expectException( e ) );
 					return null;
 				} ) );
 	}
 
 	public IndexManagerImplementor getIndexManager() {
-		return partiallyBuiltIndexManager;
+		return indexManager;
 	}
 }
diff --git a/...e/src/main/java/org/hibernate/search/engine/common/impl/SearchIntegrationBuilderImpl.java b/...e/src/main/java/org/hibernate/search/engine/common/impl/SearchIntegrationBuilderImpl.java
@@ -264,8 +264,8 @@ public SearchIntegrationPartialBuildState prepareBuild() {
 					failureHandlerHolder,
 					threadPoolProvider,
 					partiallyBuiltMappings,
-					indexManagerBuildingStateHolder.getBackendPartialBuildStates(),
-					indexManagerBuildingStateHolder.getIndexManagersByName(),
+					indexManagerBuildingStateHolder.getBackendNonStartedStates(),
+					indexManagerBuildingStateHolder.getIndexManagersNonStartedStates(),
 					propertyChecker
 			);
 		}

diff --git a/.../java/org/hibernate/search/engine/common/impl/SearchIntegrationPartialBuildStateImpl.java b/.../java/org/hibernate/search/engine/common/impl/SearchIntegrationPartialBuildStateImpl.java
@@ -43,29 +43,30 @@ class SearchIntegrationPartialBuildStateImpl implements SearchIntegrationPartial
 	private final ThreadPoolProviderImpl threadPoolProvider;
 
 	private final Map<MappingKey<?, ?>, MappingPartialBuildState> partiallyBuiltMappings;
-	private final List<MappingImplementor<?>> fullyBuiltMappings = new ArrayList<>();
-	private final Map<String, BackendPartialBuildState> partiallyBuiltBackends;
+	private final Map<String, BackendNonStartedState> nonStartedBackends;
+	private final Map<String, IndexManagerNonStartedState> nonStartedIndexManagers;
+
 	private final ConfigurationPropertyChecker partialConfigurationPropertyChecker;
 
-	private final Map<String, BackendImplementor> fullyBuiltBackends = new LinkedHashMap<>();
-	private final Map<String, IndexManagerPartialBuildState> partiallyBuiltIndexManagers;
-	private final Map<String, IndexManagerImplementor> fullyBuiltIndexManagers = new LinkedHashMap<>();
+	private final List<MappingImplementor<?>> fullyBuiltMappings = new ArrayList<>();
+	private final Map<String, BackendImplementor> startedBackends = new LinkedHashMap<>();
+	private final Map<String, IndexManagerImplementor> startedIndexManagers = new LinkedHashMap<>();
 
 	SearchIntegrationPartialBuildStateImpl(
 			BeanProvider beanProvider, BeanResolver beanResolver,
 			BeanHolder<? extends FailureHandler> failureHandlerHolder,
 			ThreadPoolProviderImpl threadPoolProvider,
 			Map<MappingKey<?, ?>, MappingPartialBuildState> partiallyBuiltMappings,
-			Map<String, BackendPartialBuildState> partiallyBuiltBackends,
-			Map<String, IndexManagerPartialBuildState> partiallyBuiltIndexManagers,
+			Map<String, BackendNonStartedState> nonStartedBackends,
+			Map<String, IndexManagerNonStartedState> nonStartedIndexManagers,
 			ConfigurationPropertyChecker partialConfigurationPropertyChecker) {
 		this.beanProvider = beanProvider;
 		this.beanResolver = beanResolver;
 		this.failureHandlerHolder = failureHandlerHolder;
 		this.threadPoolProvider = threadPoolProvider;
 		this.partiallyBuiltMappings = partiallyBuiltMappings;
-		this.partiallyBuiltBackends = partiallyBuiltBackends;
-		this.partiallyBuiltIndexManagers = partiallyBuiltIndexManagers;
+		this.nonStartedBackends = nonStartedBackends;
+		this.nonStartedIndexManagers = nonStartedIndexManagers;
 		this.partialConfigurationPropertyChecker = partialConfigurationPropertyChecker;
 	}
 
@@ -74,10 +75,10 @@ public void closeOnFailure() {
 		try ( Closer<RuntimeException> closer = new Closer<>() ) {
 			closer.pushAll( MappingPartialBuildState::closeOnFailure, partiallyBuiltMappings.values() );
 			closer.pushAll( MappingImplementor::close, fullyBuiltMappings );
-			closer.pushAll( IndexManagerPartialBuildState::closeOnFailure, partiallyBuiltIndexManagers.values() );
-			closer.pushAll( IndexManagerImplementor::stop, fullyBuiltIndexManagers.values() );
-			closer.pushAll( BackendPartialBuildState::closeOnFailure, partiallyBuiltBackends.values() );
-			closer.pushAll( BackendImplementor::stop, fullyBuiltBackends.values() );
+			closer.pushAll( IndexManagerNonStartedState::closeOnFailure, nonStartedIndexManagers.values() );
+			closer.pushAll( IndexManagerImplementor::stop, startedIndexManagers.values() );
+			closer.pushAll( BackendNonStartedState::closeOnFailure, nonStartedBackends.values() );
+			closer.pushAll( BackendImplementor::stop, startedBackends.values() );
 			closer.pushAll( ThreadPoolProviderImpl::close, threadPoolProvider );
 			closer.pushAll( BeanHolder::close, failureHandlerHolder );
 			closer.pushAll( BeanProvider::close, beanProvider );
@@ -140,30 +141,29 @@ public SearchIntegration finalizeIntegration() {
 					new RootFailureCollector( EngineEventContextMessages.INSTANCE.bootstrap() );
 
 			// Start backends
-			for ( Map.Entry<String, BackendPartialBuildState> entry : partiallyBuiltBackends.entrySet() ) {
+			for ( Map.Entry<String, BackendNonStartedState> entry : nonStartedBackends.entrySet() ) {
 				// TODO HSEARCH-3084 perform backend initialization in parallel for all backends?
-				fullyBuiltBackends.put(
+				startedBackends.put(
 						entry.getKey(),
-						entry.getValue().finalizeBuild( failureCollector, beanResolver, propertySource )
+						entry.getValue().start( failureCollector, beanResolver, propertySource )
 				);
 			}
 			failureCollector.checkNoFailure();
 
 			// Start indexes
-			CompletableFuture<?>[] indexManagerFutures = new CompletableFuture<?>[partiallyBuiltIndexManagers.size()];
+			CompletableFuture<?>[] indexManagerFutures = new CompletableFuture<?>[nonStartedIndexManagers.size()];
 			int indexManagerIndex = 0;
 			// Start
-			for ( IndexManagerPartialBuildState state : partiallyBuiltIndexManagers.values() ) {
-				indexManagerFutures[indexManagerIndex] =
-						state.finalizeBuild( failureCollector, beanResolver, propertySource );
+			for ( IndexManagerNonStartedState state : nonStartedIndexManagers.values() ) {
+				indexManagerFutures[indexManagerIndex] = state.start( failureCollector, beanResolver, propertySource );
 				++indexManagerIndex;
 			}
 			// Wait for the starting operation to finish
 			Futures.unwrappedExceptionJoin( CompletableFuture.allOf( indexManagerFutures ) );
 			failureCollector.checkNoFailure();
 			// Everything went well: register the index managers
-			for ( Map.Entry<String, IndexManagerPartialBuildState> entry : partiallyBuiltIndexManagers.entrySet() ) {
-				fullyBuiltIndexManagers.put(
+			for ( Map.Entry<String, IndexManagerNonStartedState> entry : nonStartedIndexManagers.entrySet() ) {
+				startedIndexManagers.put(
 						entry.getKey(),
 						entry.getValue().getIndexManager()
 				);
@@ -176,8 +176,8 @@ public SearchIntegration finalizeIntegration() {
 					failureHandlerHolder,
 					threadPoolProvider,
 					fullyBuiltMappings,
-					fullyBuiltBackends,
-					fullyBuiltIndexManagers
+					startedBackends,
+					startedIndexManagers
 			);
 		}
 	}