9595import java .util .concurrent .locks .ReentrantLock ;
9696import java .util .concurrent .locks .ReentrantReadWriteLock ;
9797import java .util .function .BiFunction ;
98+ import java .util .function .Function ;
9899import java .util .stream .Stream ;
99100
100101import static org .elasticsearch .index .seqno .SequenceNumbers .UNASSIGNED_PRIMARY_TERM ;
@@ -588,31 +589,17 @@ protected final GetResult getFromSearcher(Get get, BiFunction<String, SearcherSc
588589
589590 public abstract GetResult get (Get get , BiFunction <String , SearcherScope , Searcher > searcherFactory ) throws EngineException ;
590591
591-
592592 /**
593- * Returns a new searcher instance. The consumer of this
594- * API is responsible for releasing the returned searcher in a
595- * safe manner, preferably in a try/finally block.
596- *
597- * @param source the source API or routing that triggers this searcher acquire
598- *
599- * @see Searcher#close()
593+ * Acquires a point-in-time reader that can be used to create {@link Engine.Searcher}s on demand.
600594 */
601- public final Searcher acquireSearcher ( String source ) throws EngineException {
602- return acquireSearcher ( source , SearcherScope .EXTERNAL );
595+ public final SearcherSupplier acquireSearcherSupplier ( Function < Searcher , Searcher > wrapper ) throws EngineException {
596+ return acquireSearcherSupplier ( wrapper , SearcherScope .EXTERNAL );
603597 }
604598
605599 /**
606- * Returns a new searcher instance. The consumer of this
607- * API is responsible for releasing the returned searcher in a
608- * safe manner, preferably in a try/finally block.
609- *
610- * @param source the source API or routing that triggers this searcher acquire
611- * @param scope the scope of this searcher ie. if the searcher will be used for get or search purposes
612- *
613- * @see Searcher#close()
600+ * Acquires a point-in-time reader that can be used to create {@link Engine.Searcher}s on demand.
614601 */
615- public Searcher acquireSearcher ( String source , SearcherScope scope ) throws EngineException {
602+ public SearcherSupplier acquireSearcherSupplier ( Function < Searcher , Searcher > wrapper , SearcherScope scope ) throws EngineException {
616603 /* Acquire order here is store -> manager since we need
617604 * to make sure that the store is not closed before
618605 * the searcher is acquired. */
@@ -621,35 +608,64 @@ public Searcher acquireSearcher(String source, SearcherScope scope) throws Engin
621608 }
622609 Releasable releasable = store ::decRef ;
623610 try {
624- assert assertSearcherIsWarmedUp (source , scope );
625611 ReferenceManager <ElasticsearchDirectoryReader > referenceManager = getReferenceManager (scope );
626- final ElasticsearchDirectoryReader acquire = referenceManager .acquire ();
612+ ElasticsearchDirectoryReader acquire = referenceManager .acquire ();
627613 AtomicBoolean released = new AtomicBoolean (false );
628- Searcher engineSearcher = new Searcher (source , acquire ,
629- engineConfig .getSimilarity (), engineConfig .getQueryCache (), engineConfig .getQueryCachingPolicy (),
630- () -> {
631- if (released .compareAndSet (false , true )) {
632- try {
633- referenceManager .release (acquire );
634- } finally {
635- store .decRef ();
614+ SearcherSupplier reader = new SearcherSupplier (wrapper ) {
615+ @ Override
616+ public Searcher acquireSearcherInternal (String source ) {
617+ assert assertSearcherIsWarmedUp (source , scope );
618+ return new Searcher (source , acquire , engineConfig .getSimilarity (), engineConfig .getQueryCache (),
619+ engineConfig .getQueryCachingPolicy (), () -> {});
620+ }
621+
622+ @ Override
623+ public void close () {
624+ if (released .compareAndSet (false , true )) {
625+ try {
626+ referenceManager .release (acquire );
627+ } catch (IOException e ) {
628+ throw new UncheckedIOException ("failed to close" , e );
629+ } catch (AlreadyClosedException e ) {
630+ // This means there's a bug somewhere: don't suppress it
631+ throw new AssertionError (e );
632+ } finally {
633+ store .decRef ();
634+ }
635+ } else {
636+ /* In general, readers should never be released twice or this would break reference counting. There is one rare case
637+ * when it might happen though: when the request and the Reaper thread would both try to release it in a very short
638+ * amount of time, this is why we only log a warning instead of throwing an exception. */
639+ logger .warn ("Reader was released twice" , new IllegalStateException ("Double release" ));
636640 }
637- } else {
638- /* In general, readers should never be released twice or this would break reference counting. There is one rare case
639- * when it might happen though: when the request and the Reaper thread would both try to release it in a very short
640- * amount of time, this is why we only log a warning instead of throwing an exception. */
641- logger .warn ("Searcher was released twice" , new IllegalStateException ("Double release" ));
642641 }
643- }) ;
642+ } ;
644643 releasable = null ; // success - hand over the reference to the engine reader
645- return engineSearcher ;
644+ return reader ;
646645 } catch (AlreadyClosedException ex ) {
647646 throw ex ;
648647 } catch (Exception ex ) {
649- maybeFailEngine ("acquire_searcher " , ex );
648+ maybeFailEngine ("acquire_reader " , ex );
650649 ensureOpen (ex ); // throw EngineCloseException here if we are already closed
651- logger .error (() -> new ParameterizedMessage ("failed to acquire searcher, source {}" , source ), ex );
652- throw new EngineException (shardId , "failed to acquire searcher, source " + source , ex );
650+ logger .error (() -> new ParameterizedMessage ("failed to acquire reader" ), ex );
651+ throw new EngineException (shardId , "failed to acquire reader" , ex );
652+ } finally {
653+ Releasables .close (releasable );
654+ }
655+ }
656+
657+ public final Searcher acquireSearcher (String source ) throws EngineException {
658+ return acquireSearcher (source , SearcherScope .EXTERNAL );
659+ }
660+
661+ public Searcher acquireSearcher (String source , SearcherScope scope ) throws EngineException {
662+ SearcherSupplier releasable = null ;
663+ try {
664+ SearcherSupplier reader = releasable = acquireSearcherSupplier (Function .identity (), scope );
665+ Searcher searcher = reader .acquireSearcher (source );
666+ releasable = null ;
667+ return new Searcher (source , searcher .getDirectoryReader (), searcher .getSimilarity (),
668+ searcher .getQueryCache (), searcher .getQueryCachingPolicy (), () -> Releasables .close (searcher , reader ));
653669 } finally {
654670 Releasables .close (releasable );
655671 }
@@ -1158,6 +1174,21 @@ default void onFailedEngine(String reason, @Nullable Exception e) {
11581174 }
11591175 }
11601176
1177+ public abstract static class SearcherSupplier implements Releasable {
1178+ private final Function <Searcher , Searcher > wrapper ;
1179+
1180+ public SearcherSupplier (Function <Searcher , Searcher > wrapper ) {
1181+ this .wrapper = wrapper ;
1182+ }
1183+
1184+ public final Searcher acquireSearcher (String source ) {
1185+ final Searcher searcher = acquireSearcherInternal (source );
1186+ return "can_match" .equals (source ) ? searcher : wrapper .apply (searcher );
1187+ }
1188+
1189+ protected abstract Searcher acquireSearcherInternal (String source );
1190+ }
1191+
11611192 public static final class Searcher extends IndexSearcher implements Releasable {
11621193 private final String source ;
11631194 private final Closeable onClose ;
0 commit comments