import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
public ExtendedEngine(final EngineConfig engineConfig,
        final EngineFilters engineFilters) throws EngineException {
    super(engineConfig);
    engine = new InternalEngine(engineConfig);
    filters = engineFilters.filters();

    Class<? extends Engine> clazz = engine.getClass();
    try {
        getSearcherManagerMethod = clazz
                .getDeclaredMethod("getSearcherManager");
        getSearcherManagerMethod.setAccessible(true);
        closeNoLockMethod = clazz.getDeclaredMethod("closeNoLock",
                new Class<?>[] { String.class });
        closeNoLockMethod.setAccessible(true);
        getLastCommittedSegmentInfosMethod = clazz
                .getDeclaredMethod("getLastCommittedSegmentInfos");
        getLastCommittedSegmentInfosMethod.setAccessible(true);
    } catch (NoSuchMethodException | SecurityException e) {
        throw new EngineException(shardId,
                "Cannot load methods from " + clazz.getName(), e);
    }
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
public AssertingIndexSearcher newSearcher(String source, IndexSearcher searcher, SearcherManager manager) throws EngineException {
    IndexReader reader = searcher.getIndexReader();
    IndexReader wrappedReader = reader;
    assert reader != null;
    if (reader instanceof DirectoryReader && mockContext.wrapReader) {
        wrappedReader = wrapReader((DirectoryReader) reader);
    }
    // this executes basic query checks and asserts that weights are normalized only once etc.
    final AssertingIndexSearcher assertingIndexSearcher = new AssertingIndexSearcher(mockContext.random, wrappedReader);
    assertingIndexSearcher.setSimilarity(searcher.getSimilarity(true));
    assertingIndexSearcher.setQueryCache(filterCache);
    assertingIndexSearcher.setQueryCachingPolicy(filterCachingPolicy);
    return assertingIndexSearcher;
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
/**
 * Creates a new {@link IndexCommit} snapshot form the currently running engine. All resources referenced by this
 * commit won't be freed until the commit / snapshot is released via {@link #releaseIndexCommit(IndexCommit)}.
 *
 * @param flushFirst <code>true</code> if the index should first be flushed to disk / a low level lucene commit should be executed
 */
public IndexCommit acquireIndexCommit(boolean flushFirst) throws EngineException {
    IndexShardState state = this.state; // one time volatile read
    // we allow snapshot on closed index shard, since we want to do one after we close the shard and before we close the engine
    if (state == IndexShardState.STARTED || state == IndexShardState.RELOCATED || state == IndexShardState.CLOSED) {
        return getEngine().acquireIndexCommit(flushFirst);
    } else {
        throw new IllegalIndexShardStateException(shardId, state, "snapshot is not allowed");
    }
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
public void testSearchIsReleaseIfWrapperFails() throws IOException {
    IndexShard shard = newStartedShard(true);
    indexDoc(shard, "test", "0", "{\"foo\" : \"bar\"}");
    shard.refresh("test");
    IndexSearcherWrapper wrapper = new IndexSearcherWrapper() {
        @Override
        public DirectoryReader wrap(DirectoryReader reader) throws IOException {
            throw new RuntimeException("boom");
        }

        @Override
        public IndexSearcher wrap(IndexSearcher searcher) throws EngineException {
            return searcher;
        }
    };

    closeShards(shard);
    IndexShard newShard = newShard(ShardRoutingHelper.reinitPrimary(shard.routingEntry()),
        shard.shardPath(), shard.indexSettings().getIndexMetaData(), wrapper, () -> {}, null);

    recoveryShardFromStore(newShard);

    try {
        newShard.acquireSearcher("test");
        fail("exception expected");
    } catch (RuntimeException ex) {
        //
    }
    closeShards(newShard);
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
public SnapshotIndexCommit snapshotIndex(boolean flushFirst) throws EngineException {
    IndexShardState state = this.state; // one time volatile read
    // we allow snapshot on closed index shard, since we want to do one after we close the shard and before we close the engine
    if (state == IndexShardState.STARTED || state == IndexShardState.RELOCATED || state == IndexShardState.CLOSED) {
        return engine().snapshotIndex(flushFirst);
    } else {
        throw new IllegalIndexShardStateException(shardId, state, "snapshot is not allowed");
    }
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
@Override
public final IndexSearcher wrap(final IndexSearcher searcher) throws EngineException {

    if (!isAdminAuthenticatedOrInternalRequest()) {
        return dlsFlsWrap(searcher);
    }

    return searcher;
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
@Override
public void forceMerge(boolean flush, int maxNumSegments,
        boolean onlyExpungeDeletes, boolean upgrade,
        boolean upgradeOnlyAncientSegments) throws EngineException {
    new EngineChain(engine, engineConfig, filters).doForceMerge(flush,
            maxNumSegments, onlyExpungeDeletes, upgrade,
            upgradeOnlyAncientSegments);
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
public void doCreate(final Create create) throws EngineException {
    if (position < filters.length) {
        final EngineFilter filter = filters[position];
        position++;
        filter.doCreate(create, this);
    } else {
        engine.create(create);
    }
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
public void doIndex(final Index index) throws EngineException {
    if (position < filters.length) {
        final EngineFilter filter = filters[position];
        position++;
        filter.doIndex(index, this);
    } else {
        engine.index(index);
    }
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
public void doDelete(final Delete delete) throws EngineException {
    if (position < filters.length) {
        final EngineFilter filter = filters[position];
        position++;
        filter.doDelete(delete, this);
    } else {
        engine.delete(delete);
    }
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
public GetResult doGet(final Get get) throws EngineException {
    if (position < filters.length) {
        final EngineFilter filter = filters[position];
        position++;
        return filter.doGet(get, this);
    } else {
        return engine.get(get);
    }
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
public void doMaybeMerge() throws EngineException {
    if (position < filters.length) {
        final EngineFilter filter = filters[position];
        position++;
        filter.doMaybeMerge(this);
    } else {
        engine.maybeMerge();
    }
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
public void doRefresh(final String source) throws EngineException {
    if (position < filters.length) {
        final EngineFilter filter = filters[position];
        position++;
        filter.doRefresh(source, this);
    } else {
        engine.refresh(source);
    }
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
public CommitId doFlush(final boolean force, final boolean waitIfOngoing)
        throws EngineException, FlushNotAllowedEngineException {
    if (position < filters.length) {
        final EngineFilter filter = filters[position];
        position++;
        return filter.doFlush(force, waitIfOngoing, this);
    } else {
        return engine.flush(force, waitIfOngoing);
    }
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
public SnapshotIndexCommit doSnapshotIndex() throws EngineException {
    if (position < filters.length) {
        final EngineFilter filter = filters[position];
        position++;
        return filter.doSnapshotIndex(this);
    } else {
        return engine.snapshotIndex();
    }
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
public void doRecover(final RecoveryHandler recoveryHandler)
        throws EngineException {
    if (position < filters.length) {
        final EngineFilter filter = filters[position];
        position++;
        filter.doRecover(recoveryHandler, this);
    } else {
        engine.recover(recoveryHandler);
    }
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
@Override
public CommitId doFlush(final boolean force, final boolean waitIfOngoing,
        final EngineChain chain)
                throws EngineException, FlushNotAllowedEngineException {
    doFlush = true;
    return chain.doFlush(force, waitIfOngoing);
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
@Override
public CommitId doFlush(final boolean force, final boolean waitIfOngoing,
        final EngineChain chain) throws EngineException,
        FlushNotAllowedEngineException {
    logger.info("doFlush({}, {})", force, waitIfOngoing);
    return chain.doFlush(force, waitIfOngoing);
}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
MockInternalEngine(EngineConfig config,  Class<? extends FilterDirectoryReader> wrapper) throws EngineException {
    super(config);
    randomizeFlushOnClose = config.getIndexSettings().isOnSharedFilesystem() == false;
    wrapperClass = wrapper;

}
 

import org.elasticsearch.index.engine.EngineException; //导入依赖的package包/类
@Override
protected Searcher newSearcher(String source, IndexSearcher searcher, SearcherManager manager) throws EngineException {
    final Searcher engineSearcher = super.newSearcher(source, searcher, manager);
    return support().wrapSearcher(source, engineSearcher, searcher, manager);
}