Introduce a one-and-only dependency resolver strategy

For least element of surprise coding.
Used for defensive coding in RecoverConsensusLogIndex.

community/graphdb-api/src/main/java/org/neo4j/graphdb/DependencyResolver.java

@@ -22,6 +22,8 @@
 import java.util.Iterator;
 import java.util.function.Supplier;
 
+import static org.neo4j.graphdb.DependencyResolver.SelectionStrategy.FIRST;
+
 /**
  * Find a dependency given a type. This can be the exact type or a super type of
  * the actual dependency.
@@ -73,15 +75,8 @@ interface SelectionStrategy
          * @throws IllegalArgumentException if no suitable candidate was found.
          */
         <T> T select( Class<T> type, Iterable<? extends T> candidates ) throws IllegalArgumentException;
-    }
 
-    /**
-     * Adapter for {@link DependencyResolver} which will select the first available candidate by default
-     * for {@link #resolveDependency(Class)}.
-     */
-    abstract class Adapter implements DependencyResolver
-    {
-        private static final SelectionStrategy FIRST = new SelectionStrategy()
+        SelectionStrategy FIRST = new SelectionStrategy()
         {
             @Override
             public <T> T select( Class<T> type, Iterable<? extends T> candidates ) throws IllegalArgumentException
@@ -95,6 +90,40 @@ public <T> T select( Class<T> type, Iterable<? extends T> candidates ) throws Il
             }
         };
 
+        /**
+         * Returns the one and only dependency, or throws.
+         */
+        SelectionStrategy ONLY = new SelectionStrategy()
+        {
+            @Override
+            public <T> T select( Class<T> type, Iterable<? extends T> candidates ) throws IllegalArgumentException
+            {
+                Iterator<? extends T> iterator = candidates.iterator();
+                if ( !iterator.hasNext() )
+                {
+                    throw new IllegalArgumentException( "Could not resolve dependency of type:" + type.getName() );
+                }
+
+                T only = iterator.next();
+
+                if ( iterator.hasNext() )
+                {
+                    throw new IllegalArgumentException( "Multiple dependencies of type:" + type.getName() );
+                }
+                else
+                {
+                    return only;
+                }
+            }
+        };
+    }
+
+    /**
+     * Adapter for {@link DependencyResolver} which will select the first available candidate by default
+     * for {@link #resolveDependency(Class)}.
+     */
+    abstract class Adapter implements DependencyResolver
+    {
         @Override
         public <T> T resolveDependency( Class<T> type ) throws IllegalArgumentException
         {

enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/tx/RecoverConsensusLogIndex.java

@@ -24,6 +24,8 @@
 import org.neo4j.kernel.impl.util.Dependencies;
 import org.neo4j.logging.LogProvider;
 
+import static org.neo4j.graphdb.DependencyResolver.SelectionStrategy.ONLY;
+
 /**
  * Retrieves last raft log index that was appended to the transaction log, so that raft log replay can recover while
  * preserving idempotency (avoid appending the same transaction twice).
@@ -41,8 +43,8 @@ public RecoverConsensusLogIndex( Dependencies dependencies, LogProvider logProvi
 
     public long findLastAppliedIndex()
     {
-        TransactionIdStore transactionIdStore = dependencies.resolveDependency( TransactionIdStore.class );
-        LogicalTransactionStore transactionStore = dependencies.resolveDependency( LogicalTransactionStore.class );
+        TransactionIdStore transactionIdStore = dependencies.resolveDependency( TransactionIdStore.class, ONLY );
+        LogicalTransactionStore transactionStore = dependencies.resolveDependency( LogicalTransactionStore.class, ONLY );
 
         return new LastCommittedIndexFinder( transactionIdStore, transactionStore, logProvider )
                 .getLastCommittedIndex();