Java EngineFactory类代码示例

import org.elasticsearch.index.engine.EngineFactory; //导入依赖的package包/类
@Inject
public ShadowIndexShard(ShardId shardId, IndexSettingsService indexSettingsService,
                        IndicesLifecycle indicesLifecycle, Store store, StoreRecoveryService storeRecoveryService,
                        ThreadPool threadPool, MapperService mapperService,
                        IndexQueryParserService queryParserService, IndexCache indexCache,
                        IndexAliasesService indexAliasesService, IndicesQueryCache indicesQueryCache,
                        ShardPercolateService shardPercolateService, CodecService codecService,
                        ShardTermVectorsService termVectorsService, IndexFieldDataService indexFieldDataService,
                        IndexService indexService, @Nullable IndicesWarmer warmer,
                        SnapshotDeletionPolicy deletionPolicy, SimilarityService similarityService,
                        EngineFactory factory, ClusterService clusterService,
                        ShardPath path, BigArrays bigArrays, IndexSearcherWrappingService wrappingService,
                        IndexingMemoryController indexingMemoryController, SearchService shardSearchService) throws IOException {
    super(shardId, indexSettingsService, indicesLifecycle, store, storeRecoveryService,
          threadPool, mapperService, queryParserService, indexCache, indexAliasesService,
          indicesQueryCache, shardPercolateService, codecService,
          termVectorsService, indexFieldDataService, indexService,
          warmer, deletionPolicy, similarityService,
          factory, clusterService, path, bigArrays, wrappingService, indexingMemoryController, shardSearchService);
}
 

import org.elasticsearch.index.engine.EngineFactory; //导入依赖的package包/类
@Override
protected void configure() {
    bind(ShardId.class).toInstance(shardId);
    if (IndexMetaData.isIndexUsingDLEngine(settings)) {
        bind(IndexShard.class).to(DLBasedIndexShard.class).asEagerSingleton();
        bind(TranslogService.class).asEagerSingleton();
    }else if (useShadowEngine()) {
        bind(IndexShard.class).to(ShadowIndexShard.class).asEagerSingleton();
    } else {
        bind(IndexShard.class).asEagerSingleton();
        bind(TranslogService.class).asEagerSingleton();
    }

    bind(EngineFactory.class).to(engineFactoryImpl);
    bind(StoreRecoveryService.class).asEagerSingleton();
    bind(ShardPercolateService.class).asEagerSingleton();
    bind(ShardTermVectorsService.class).asEagerSingleton();
    bind(IndexSearcherWrappingService.class).asEagerSingleton();
    // this injects an empty set in IndexSearcherWrappingService, otherwise guice can't construct IndexSearcherWrappingService
    Multibinder<IndexSearcherWrapper> multibinder
            = Multibinder.newSetBinder(binder(), IndexSearcherWrapper.class);
}
 

import org.elasticsearch.index.engine.EngineFactory; //导入依赖的package包/类
/**
 * creates a new initializing shard. The shard will will be put in its proper path under the
 * current node id the shard is assigned to.
 *
 * @param routing                shard routing to use
 * @param indexMetaData          indexMetaData for the shard, including any mapping
 * @param indexSearcherWrapper   an optional wrapper to be used during searchers
 * @param globalCheckpointSyncer an runnable to run when the global check point needs syncing
 * @param listeners              an optional set of listeners to add to the shard
 */
protected IndexShard newShard(ShardRouting routing, IndexMetaData indexMetaData,
                              @Nullable IndexSearcherWrapper indexSearcherWrapper, Runnable globalCheckpointSyncer,
                              @Nullable EngineFactory engineFactory,
                              IndexingOperationListener... listeners)
    throws IOException {
    // add node id as name to settings for popper logging
    final ShardId shardId = routing.shardId();
    final NodeEnvironment.NodePath nodePath = new NodeEnvironment.NodePath(createTempDir());
    ShardPath shardPath = new ShardPath(false, nodePath.resolve(shardId), nodePath.resolve(shardId), shardId);
    return newShard(routing, shardPath, indexMetaData, indexSearcherWrapper, globalCheckpointSyncer, engineFactory, listeners);
}
 

import org.elasticsearch.index.engine.EngineFactory; //导入依赖的package包/类
public ShadowIndexShard(ShardRouting shardRouting, IndexSettings indexSettings, ShardPath path, Store store, IndexCache indexCache,
                        MapperService mapperService, SimilarityService similarityService, IndexFieldDataService indexFieldDataService,
                        @Nullable EngineFactory engineFactory, IndexEventListener indexEventListener, IndexSearcherWrapper wrapper,
                        ThreadPool threadPool, BigArrays bigArrays, Engine.Warmer engineWarmer,
                        List<SearchOperationListener> searchOperationListeners) throws IOException {
    super(shardRouting, indexSettings, path, store, indexCache, mapperService, similarityService, indexFieldDataService, engineFactory,
        indexEventListener, wrapper, threadPool, bigArrays, engineWarmer, () -> {
        }, searchOperationListeners, Collections.emptyList());
}
 

import org.elasticsearch.index.engine.EngineFactory; //导入依赖的package包/类
@Inject
public DLBasedIndexShard(ShardId shardId,
        IndexSettingsService indexSettingsService,
        IndicesLifecycle indicesLifecycle, Store store,
        StoreRecoveryService storeRecoveryService, ThreadPool threadPool,
        MapperService mapperService,
        IndexQueryParserService queryParserService, IndexCache indexCache,
        IndexAliasesService indexAliasesService,
        IndicesQueryCache indicesQueryCache,
        ShardPercolateService shardPercolateService,
        CodecService codecService,
        ShardTermVectorsService termVectorsService,
        IndexFieldDataService indexFieldDataService,
        IndexService indexService, IndicesWarmer warmer,
        SnapshotDeletionPolicy deletionPolicy,
        SimilarityService similarityService, EngineFactory factory,
        ClusterService clusterService, ShardPath path, BigArrays bigArrays,
        IndexSearcherWrappingService wrappingService,
        IndexingMemoryController indexingMemoryController,
        TransportGetOrChangePrimaryShardLeaseAction checkLeaseAction,
        TransportIndexShardStatsAction indexShardStatsAction,
        SearchService shardSearchService) {
    super(shardId, indexSettingsService, indicesLifecycle, store,
            storeRecoveryService, threadPool, mapperService, queryParserService,
            indexCache, indexAliasesService, indicesQueryCache,
            shardPercolateService, codecService, termVectorsService,
            indexFieldDataService, indexService, warmer, deletionPolicy,
            similarityService, factory, clusterService, path, bigArrays,
            wrappingService, indexingMemoryController, shardSearchService);
    this.localNodeId = clusterService.state().nodes().localNodeId();
    this.checkLeaseAction = checkLeaseAction;
    this.indexShardStatsAction = indexShardStatsAction;
}
 

import org.elasticsearch.index.engine.EngineFactory; //导入依赖的package包/类
public IndexService(IndexSettings indexSettings, NodeEnvironment nodeEnv,
                    NamedXContentRegistry xContentRegistry,
                    SimilarityService similarityService,
                    ShardStoreDeleter shardStoreDeleter,
                    AnalysisRegistry registry,
                    @Nullable EngineFactory engineFactory,
                    CircuitBreakerService circuitBreakerService,
                    BigArrays bigArrays,
                    ThreadPool threadPool,
                    ScriptService scriptService,
                    ClusterService clusterService,
                    Client client,
                    QueryCache queryCache,
                    IndexStore indexStore,
                    IndexEventListener eventListener,
                    IndexModule.IndexSearcherWrapperFactory wrapperFactory,
                    MapperRegistry mapperRegistry,
                    IndicesFieldDataCache indicesFieldDataCache,
                    Consumer<ShardId> globalCheckpointSyncer,
                    List<SearchOperationListener> searchOperationListeners,
                    List<IndexingOperationListener> indexingOperationListeners) throws IOException {
    super(indexSettings);
    this.indexSettings = indexSettings;
    this.globalCheckpointSyncer = globalCheckpointSyncer;
    this.xContentRegistry = xContentRegistry;
    this.similarityService = similarityService;
    this.mapperService = new MapperService(indexSettings, registry.build(indexSettings), xContentRegistry, similarityService,
        mapperRegistry,
        // we parse all percolator queries as they would be parsed on shard 0
        () -> newQueryShardContext(0, null, () -> {
            throw new IllegalArgumentException("Percolator queries are not allowed to use the current timestamp");
        }));
    this.indexFieldData = new IndexFieldDataService(indexSettings, indicesFieldDataCache, circuitBreakerService, mapperService);
    this.shardStoreDeleter = shardStoreDeleter;
    this.bigArrays = bigArrays;
    this.threadPool = threadPool;
    this.scriptService = scriptService;
    this.clusterService = clusterService;
    this.client = client;
    this.eventListener = eventListener;
    this.nodeEnv = nodeEnv;
    this.indexStore = indexStore;
    indexFieldData.setListener(new FieldDataCacheListener(this));
    this.bitsetFilterCache = new BitsetFilterCache(indexSettings, new BitsetCacheListener(this));
    this.warmer = new IndexWarmer(indexSettings.getSettings(), threadPool,
        bitsetFilterCache.createListener(threadPool));
    this.indexCache = new IndexCache(indexSettings, queryCache, bitsetFilterCache);
    this.engineFactory = engineFactory;
    // initialize this last -- otherwise if the wrapper requires any other member to be non-null we fail with an NPE
    this.searcherWrapper = wrapperFactory.newWrapper(this);
    this.globalCheckpointTask = new AsyncGlobalCheckpointTask(this);
    this.indexingOperationListeners = Collections.unmodifiableList(indexingOperationListeners);
    this.searchOperationListeners = Collections.unmodifiableList(searchOperationListeners);
    // kick off async ops for the first shard in this index
    this.refreshTask = new AsyncRefreshTask(this);
    rescheduleFsyncTask(indexSettings.getTranslogDurability());
}
 

import org.elasticsearch.index.engine.EngineFactory; //导入依赖的package包/类
final EngineFactory getEngineFactory() {
    return engineFactory;
}
 

import org.elasticsearch.index.engine.EngineFactory; //导入依赖的package包/类
public IndexShard(ShardRouting shardRouting, IndexSettings indexSettings, ShardPath path, Store store, IndexCache indexCache,
                  MapperService mapperService, SimilarityService similarityService, IndexFieldDataService indexFieldDataService,
                  @Nullable EngineFactory engineFactory,
                  IndexEventListener indexEventListener, IndexSearcherWrapper indexSearcherWrapper, ThreadPool threadPool, BigArrays bigArrays,
                  Engine.Warmer warmer, Runnable globalCheckpointSyncer, List<SearchOperationListener> searchOperationListener, List<IndexingOperationListener> listeners) throws IOException {
    super(shardRouting.shardId(), indexSettings);
    assert shardRouting.initializing();
    this.shardRouting = shardRouting;
    final Settings settings = indexSettings.getSettings();
    this.codecService = new CodecService(mapperService, logger);
    this.warmer = warmer;
    this.deletionPolicy = new SnapshotDeletionPolicy(new KeepOnlyLastCommitDeletionPolicy());
    this.similarityService = similarityService;
    Objects.requireNonNull(store, "Store must be provided to the index shard");
    this.engineFactory = engineFactory == null ? new InternalEngineFactory() : engineFactory;
    this.store = store;
    this.indexEventListener = indexEventListener;
    this.threadPool = threadPool;
    this.mapperService = mapperService;
    this.indexCache = indexCache;
    this.internalIndexingStats = new InternalIndexingStats();
    final List<IndexingOperationListener> listenersList = new ArrayList<>(listeners);
    listenersList.add(internalIndexingStats);
    this.indexingOperationListeners = new IndexingOperationListener.CompositeListener(listenersList, logger);
    final List<SearchOperationListener> searchListenersList = new ArrayList<>(searchOperationListener);
    searchListenersList.add(searchStats);
    this.searchOperationListener = new SearchOperationListener.CompositeListener(searchListenersList, logger);
    this.globalCheckpointSyncer = globalCheckpointSyncer;
    this.getService = new ShardGetService(indexSettings, this, mapperService);
    this.shardWarmerService = new ShardIndexWarmerService(shardId, indexSettings);
    this.requestCacheStats = new ShardRequestCache();
    this.shardFieldData = new ShardFieldData();
    this.indexFieldDataService = indexFieldDataService;
    this.shardBitsetFilterCache = new ShardBitsetFilterCache(shardId, indexSettings);
    state = IndexShardState.CREATED;
    this.path = path;
    /* create engine config */
    logger.debug("state: [CREATED]");

    this.checkIndexOnStartup = indexSettings.getValue(IndexSettings.INDEX_CHECK_ON_STARTUP);
    this.translogConfig = new TranslogConfig(shardId, shardPath().resolveTranslog(), indexSettings,
        bigArrays);
    // the query cache is a node-level thing, however we want the most popular filters
    // to be computed on a per-shard basis
    if (IndexModule.INDEX_QUERY_CACHE_EVERYTHING_SETTING.get(settings)) {
        cachingPolicy = QueryCachingPolicy.ALWAYS_CACHE;
    } else {
        QueryCachingPolicy cachingPolicy = new UsageTrackingQueryCachingPolicy();
        if (IndexModule.INDEX_QUERY_CACHE_TERM_QUERIES_SETTING.get(settings) == false) {
            cachingPolicy = new ElasticsearchQueryCachingPolicy(cachingPolicy);
        }
        this.cachingPolicy = cachingPolicy;
    }
    indexShardOperationsLock = new IndexShardOperationsLock(shardId, logger, threadPool);
    searcherWrapper = indexSearcherWrapper;
    primaryTerm = indexSettings.getIndexMetaData().primaryTerm(shardId.id());
    refreshListeners = buildRefreshListeners();
    persistMetadata(shardRouting, null);
}
 

import org.elasticsearch.index.engine.EngineFactory; //导入依赖的package包/类
EngineFactory getEngineFactory() {
    return engineFactory;
}
 

import org.elasticsearch.index.engine.EngineFactory; //导入依赖的package包/类
protected EngineFactory getEngineFactory(ShardRouting routing) {
    return null;
}
 

import org.elasticsearch.index.engine.EngineFactory; //导入依赖的package包/类
@Inject
public IndexShard(ShardId shardId, IndexSettingsService indexSettingsService, IndicesLifecycle indicesLifecycle, Store store,
                  StoreRecoveryService storeRecoveryService,
                  ThreadPool threadPool, MapperService mapperService, IndexQueryParserService queryParserService, IndexCache
                          indexCache, IndexAliasesService indexAliasesService,
                  IndicesQueryCache indicesQueryCache, ShardPercolateService shardPercolateService, CodecService codecService,
                  ShardTermVectorsService termVectorsService, IndexFieldDataService indexFieldDataService, IndexService indexService,
                  @Nullable IndicesWarmer warmer, SnapshotDeletionPolicy deletionPolicy, SimilarityService similarityService,
                  EngineFactory factory,
                  ClusterService clusterService, ShardPath path, BigArrays bigArrays, IndexSearcherWrappingService wrappingService,
                  IndexingMemoryController indexingMemoryController, SearchService shardSearchService) {
    super(shardId, indexSettingsService.getSettings());
    this.codecService = codecService;
    this.warmer = warmer;
    this.deletionPolicy = deletionPolicy;
    this.similarityService = similarityService;
    this.wrappingService = wrappingService;
    Preconditions.checkNotNull(store, "Store must be provided to the index shard");
    Preconditions.checkNotNull(deletionPolicy, "Snapshot deletion policy must be provided to the index shard");
    this.engineFactory = factory;
    this.indicesLifecycle = (InternalIndicesLifecycle) indicesLifecycle;
    this.indexSettingsService = indexSettingsService;
    this.store = store;
    this.storeRecoveryService = storeRecoveryService;
    this.mergeSchedulerConfig = new MergeSchedulerConfig(indexSettings);
    this.threadPool = threadPool;
    this.mapperService = mapperService;
    this.queryParserService = queryParserService;
    this.indexCache = indexCache;
    this.indexAliasesService = indexAliasesService;
    this.indexingService = new ShardIndexingService(shardId, indexSettings);
    this.getService = new ShardGetService(this, mapperService);
    this.termVectorsService = termVectorsService.setIndexShard(this);
    this.searchService = new ShardSearchStats(indexSettings);
    this.shardWarmerService = new ShardIndexWarmerService(shardId, indexSettings);
    this.indicesQueryCache = indicesQueryCache;
    this.shardQueryCache = new ShardRequestCache(shardId, indexSettings);
    this.shardFieldData = new ShardFieldData();
    this.percolatorQueriesRegistry = new PercolatorQueriesRegistry(shardId, indexSettings, queryParserService, indexingService,
            indicesLifecycle, mapperService, indexFieldDataService, shardPercolateService);
    this.shardPercolateService = shardPercolateService;
    this.indexFieldDataService = indexFieldDataService;
    this.indexService = indexService;
    this.shardBitsetFilterCache = new ShardBitsetFilterCache(shardId, indexSettings);
    assert clusterService.localNode() != null : "Local node is null lifecycle state is: " + clusterService.lifecycleState();
    this.clusterService = clusterService;
    this.localNode = clusterService.localNode();
    state = IndexShardState.CREATED;
    this.refreshInterval = indexSettings.getAsTime(INDEX_REFRESH_INTERVAL, EngineConfig.DEFAULT_REFRESH_INTERVAL);
    this.flushOnClose = indexSettings.getAsBoolean(INDEX_FLUSH_ON_CLOSE, true);
    // set it to 0 means reindex is disabled
    this.reindexBatchSize = indexSettings.getAsInt(INDEX_REINDEX_BATCH_SIZE, 0);
    this.reindexInterval = indexSettings.getAsTime(INDEX_REINDEX_INTERVAL, TimeValue.timeValueSeconds(10));
    indexSettingsService.addListener(applyRefreshSettings);
    this.path = path;
    this.mergePolicyConfig = new MergePolicyConfig(logger, indexSettings);
    /* create engine config */

    logger.debug("state: [CREATED]");

    this.checkIndexOnStartup = indexSettings.get("index.shard.check_on_startup", "false");
    this.translogConfig = new TranslogConfig(shardId, shardPath().resolveTranslog(), indexSettings, getFromSettings(logger,
            indexSettings, Translog.Durabilty.REQUEST),
            bigArrays, threadPool);
    final QueryCachingPolicy cachingPolicy;
    // the query cache is a node-level thing, however we want the most popular filters
    // to be computed on a per-shard basis
    if (indexSettings.getAsBoolean(IndexCacheModule.QUERY_CACHE_EVERYTHING, false)) {
        cachingPolicy = QueryCachingPolicy.ALWAYS_CACHE;
    } else {
        cachingPolicy = new XUsageTrackingQueryCachingPolicy();
    }
    this.engineConfig = newEngineConfig(translogConfig, cachingPolicy);
    this.indexShardOperationCounter = new IndexShardOperationCounter(logger, shardId);

    this.indexingMemoryController = indexingMemoryController;

    // We start up inactive
    active.set(false);
    this.shardSearchService = shardSearchService;
}