Remove engine factory provider

This commit removes a level of indirection by removing the engine
factory provider abstraction.

core/src/main/java/org/elasticsearch/indices/IndicesService.java

@@ -177,7 +177,7 @@ public class IndicesService extends AbstractLifecycleComponent
     private final IndicesRequestCache indicesRequestCache;
     private final IndicesQueryCache indicesQueryCache;
     private final MetaStateService metaStateService;
-    private final Collection<Tuple<EnginePlugin, EnginePlugin.EngineFactoryProvider>> engineFactoryProviders;
+    private final Collection<EnginePlugin> enginePlugins;
 
     @Override
     protected void doStart() {
@@ -190,7 +190,7 @@ public IndicesService(Settings settings, PluginsService pluginsService, NodeEnvi
                           MapperRegistry mapperRegistry, NamedWriteableRegistry namedWriteableRegistry, ThreadPool threadPool,
                           IndexScopedSettings indexScopedSettings, CircuitBreakerService circuitBreakerService, BigArrays bigArrays,
                           ScriptService scriptService, Client client, MetaStateService metaStateService,
-                          Collection<Tuple<EnginePlugin, EnginePlugin.EngineFactoryProvider>> engineFactoryProviders) {
+                          Collection<EnginePlugin> enginePlugins) {
         super(settings);
         this.threadPool = threadPool;
         this.pluginsService = pluginsService;
@@ -221,7 +221,7 @@ public void onRemoval(ShardId shardId, String fieldName, boolean wasEvicted, lon
         this.cleanInterval = INDICES_CACHE_CLEAN_INTERVAL_SETTING.get(settings);
         this.cacheCleaner = new CacheCleaner(indicesFieldDataCache, indicesRequestCache,  logger, threadPool, this.cleanInterval);
         this.metaStateService = metaStateService;
-        this.engineFactoryProviders = engineFactoryProviders;
+        this.enginePlugins = enginePlugins;
     }
 
     @Override
@@ -474,9 +474,9 @@ private synchronized IndexService createIndexService(final String reason,
 
     private EngineFactory getEngineFactory(final IndexSettings idxSettings) {
         final List<Tuple<EnginePlugin, Optional<EngineFactory>>> engineFactories =
-                engineFactoryProviders
+                enginePlugins
                         .stream()
-                        .map(p -> Tuple.tuple(p.v1(), p.v2().apply(idxSettings)))
+                        .map(p -> Tuple.tuple(p, p.getMaybeEngineFactory(idxSettings)))
                         .filter(t -> Objects.requireNonNull(t.v2()).isPresent())
                         .collect(Collectors.toList());
         if (engineFactories.isEmpty()) {

core/src/main/java/org/elasticsearch/node/Node.java

@@ -56,7 +56,6 @@
 import org.elasticsearch.cluster.routing.allocation.DiskThresholdMonitor;
 import org.elasticsearch.cluster.service.ClusterService;
 import org.elasticsearch.common.StopWatch;
-import org.elasticsearch.common.collect.Tuple;
 import org.elasticsearch.common.component.Lifecycle;
 import org.elasticsearch.common.component.LifecycleComponent;
 import org.elasticsearch.common.inject.Binder;
@@ -389,18 +388,13 @@ protected Node(final Environment environment, Collection<Class<? extends Plugin>
             final MetaStateService metaStateService = new MetaStateService(settings, nodeEnvironment, xContentRegistry);
 
             // collect engine factory providers per plugin
-            final Collection<Tuple<EnginePlugin, EnginePlugin.EngineFactoryProvider>> engineFactoryProviders =
-                    pluginsService
-                            .filterPlugins(EnginePlugin.class)
-                            .stream()
-                            .map(p -> Tuple.tuple(p, p.getEngineFactoryProvider()))
-                            .collect(Collectors.toList());
+            final Collection<EnginePlugin> enginePlugins = pluginsService.filterPlugins(EnginePlugin.class);
 
             final IndicesService indicesService =
                     new IndicesService(settings, pluginsService, nodeEnvironment, xContentRegistry, analysisModule.getAnalysisRegistry(),
                             clusterModule.getIndexNameExpressionResolver(), indicesModule.getMapperRegistry(), namedWriteableRegistry,
                             threadPool, settingsModule.getIndexScopedSettings(), circuitBreakerService, bigArrays,
-                            scriptModule.getScriptService(), client, metaStateService, engineFactoryProviders);
+                            scriptModule.getScriptService(), client, metaStateService, enginePlugins);
 
             Collection<Object> pluginComponents = pluginsService.filterPlugins(Plugin.class).stream()
                 .flatMap(p -> p.createComponents(client, clusterService, threadPool, resourceWatcherService,

core/src/main/java/org/elasticsearch/plugins/EnginePlugin.java

@@ -23,29 +23,20 @@
 import org.elasticsearch.index.engine.EngineFactory;
 
 import java.util.Optional;
-import java.util.function.Function;
 
 /**
  * A plugin that provides alternative engine implementations.
  */
 public interface EnginePlugin {
 
-   /**
-    * An engine factory provider. When an index is created this method is invoked for each engine plugin. Engine plugins can inspect the
-    * index settings to determine whether or not to provide an engine factory for the given index. A plugin that is not overriding the
-    * default engine should return {@link Optional#empty()}. If multiple plugins return an engine factory for a given index the index will
-    * not be created and an {@link IllegalStateException} will be thrown during index creation.
-    */
-   @FunctionalInterface
-   interface EngineFactoryProvider extends Function<IndexSettings, Optional<EngineFactory>> {
-
-   }
-
-   /**
-    * The engine factory provider for this engine plugin.
-    *
-    * @return the engine factory provider
-    */
-   EngineFactoryProvider getEngineFactoryProvider();
+    /**
+     * When an index is created this method is invoked for each engine plugin. Engine plugins can inspect the index settings to determine
+     * whether or not to provide an engine factory for the given index. A plugin that is not overriding the default engine should return
+     * {@link Optional#empty()}. If multiple plugins return an engine factory for a given index the index will not be created and an
+     * {@link IllegalStateException} will be thrown during index creation.
+     *
+     * @return an optional engine factory
+     */
+    Optional<EngineFactory> getMaybeEngineFactory(final IndexSettings indexSettings);
 
 }

core/src/test/java/org/elasticsearch/indices/IndicesServiceTests.java

@@ -126,14 +126,12 @@ public List<Setting<?>> getSettings() {
         }
 
         @Override
-        public EngineFactoryProvider getEngineFactoryProvider() {
-            return indexSettings -> {
-                if (FOO_INDEX_SETTING.get(indexSettings.getSettings())) {
-                    return Optional.of(new FooEngineFactory());
-                } else {
-                    return Optional.empty();
-                }
-            };
+        public Optional<EngineFactory> getMaybeEngineFactory(final IndexSettings indexSettings) {
+            if (FOO_INDEX_SETTING.get(indexSettings.getSettings())) {
+                return Optional.of(new FooEngineFactory());
+            } else {
+                return Optional.empty();
+            }
         }
 
     }
@@ -158,14 +156,12 @@ public List<Setting<?>> getSettings() {
         }
 
         @Override
-        public EngineFactoryProvider getEngineFactoryProvider() {
-            return indexSettings -> {
-                if (BAR_INDEX_SETTING.get(indexSettings.getSettings())) {
-                    return Optional.of(new BarEngineFactory());
-                } else {
-                    return Optional.empty();
-                }
-            };
+        public Optional<EngineFactory> getMaybeEngineFactory(final IndexSettings indexSettings) {
+            if (BAR_INDEX_SETTING.get(indexSettings.getSettings())) {
+                return Optional.of(new BarEngineFactory());
+            } else {
+                return Optional.empty();
+            }
         }
 
     }
@@ -508,7 +504,7 @@ public void testStatsByShardDoesNotDieFromExpectedExceptions() {
         assertThat("unexpected shard stats", indexStats.get(index), equalTo(shardStats));
     }
 
-    public void testEngineFactoryProvider() throws IOException {
+    public void testGetEngineFactory() throws IOException {
         final IndicesService indicesService = getIndicesService();
 
         final Boolean[] values = new Boolean[] { true, false, null };
@@ -536,7 +532,7 @@ public void testEngineFactoryProvider() throws IOException {
         }
     }
 
-    public void testConflictingEngineFactoryProviders() throws IOException {
+    public void testConflictingEngineFactories() throws IOException {
         final String indexName = "foobar";
         final Index index = new Index(indexName, UUIDs.randomBase64UUID());
         final Settings settings = Settings.builder()

test/framework/src/main/java/org/elasticsearch/index/MockEngineFactoryPlugin.java

@@ -21,6 +21,7 @@
 import org.apache.lucene.index.AssertingDirectoryReader;
 import org.apache.lucene.index.FilterDirectoryReader;
 import org.elasticsearch.common.settings.Setting;
+import org.elasticsearch.index.engine.EngineFactory;
 import org.elasticsearch.plugins.EnginePlugin;
 import org.elasticsearch.plugins.Plugin;
 import org.elasticsearch.test.engine.MockEngineFactory;
@@ -43,8 +44,8 @@ public List<Setting<?>> getSettings() {
     }
 
     @Override
-    public EngineFactoryProvider getEngineFactoryProvider() {
-        return indexSettings -> Optional.of(new MockEngineFactory(getReaderWrapperClass()));
+    public Optional<EngineFactory> getMaybeEngineFactory(final IndexSettings indexSettings) {
+        return Optional.of(new MockEngineFactory(getReaderWrapperClass()));
     }
 
     protected Class<? extends FilterDirectoryReader> getReaderWrapperClass() {