Java PercolatorService类代码示例

import org.elasticsearch.percolator.PercolatorService; //导入依赖的package包/类
private int loadQueries(IndexShard shard) {
    shard.refresh("percolator_load_queries");
    // NOTE: we acquire the searcher via the engine directly here since this is executed right
    // before the shard is marked as POST_RECOVERY
    try (Engine.Searcher searcher = shard.engine().acquireSearcher("percolator_load_queries")) {
        Query query = new TermQuery(new Term(TypeFieldMapper.NAME, PercolatorService.TYPE_NAME));
        QueriesLoaderCollector queryCollector = new QueriesLoaderCollector(PercolatorQueriesRegistry.this, logger, mapperService, indexFieldDataService);
        IndexSearcher indexSearcher = new IndexSearcher(searcher.reader());
        indexSearcher.setQueryCache(null);
        indexSearcher.search(query, queryCollector);
        Map<BytesRef, Query> queries = queryCollector.queries();
        for (Map.Entry<BytesRef, Query> entry : queries.entrySet()) {
            Query previousQuery = percolateQueries.put(entry.getKey(), entry.getValue());
            shardPercolateService.addedQuery(entry.getKey(), previousQuery, entry.getValue());
        }
        return queries.size();
    } catch (Exception e) {
        throw new PercolatorException(shardId.index(), "failed to load queries from percolator index", e);
    }
}
 

import org.elasticsearch.percolator.PercolatorService; //导入依赖的package包/类
@Override
public Engine.Create preCreate(Engine.Create create) {
    // validate the query here, before we index
    if (PercolatorService.TYPE_NAME.equals(create.type())) {
        parsePercolatorDocument(create.id(), create.source());
    }
    return create;
}
 

import org.elasticsearch.percolator.PercolatorService; //导入依赖的package包/类
@Override
public void postCreateUnderLock(Engine.Create create) {
    // add the query under a doc lock
    if (PercolatorService.TYPE_NAME.equals(create.type())) {
        addPercolateQuery(create.id(), create.source());
    }
}
 

import org.elasticsearch.percolator.PercolatorService; //导入依赖的package包/类
@Override
public Engine.Index preIndex(Engine.Index index) {
    // validate the query here, before we index
    if (PercolatorService.TYPE_NAME.equals(index.type())) {
        parsePercolatorDocument(index.id(), index.source());
    }
    return index;
}
 

import org.elasticsearch.percolator.PercolatorService; //导入依赖的package包/类
@Override
public void postIndexUnderLock(Engine.Index index) {
    // add the query under a doc lock
    if (PercolatorService.TYPE_NAME.equals(index.type())) {
        addPercolateQuery(index.id(), index.source());
    }
}
 

import org.elasticsearch.percolator.PercolatorService; //导入依赖的package包/类
@Override
public void postDeleteUnderLock(Engine.Delete delete) {
    // remove the query under a lock
    if (PercolatorService.TYPE_NAME.equals(delete.type())) {
        removePercolateQuery(delete.id());
    }
}
 

import org.elasticsearch.percolator.PercolatorService; //导入依赖的package包/类
public DocumentMapper parse(String mappingType, CompressedXContent mappingSource, boolean applyDefault) throws MapperParsingException {
    String defaultMappingSource;
    if (PercolatorService.TYPE_NAME.equals(mappingType)) {
        defaultMappingSource = this.defaultPercolatorMappingSource;
    }  else {
        defaultMappingSource = this.defaultMappingSource;
    }
    return documentParser.parse(mappingType, mappingSource, applyDefault ? defaultMappingSource : null);
}
 

import org.elasticsearch.percolator.PercolatorService; //导入依赖的package包/类
@Inject
public TransportPercolateAction(Settings settings, ThreadPool threadPool, ClusterService clusterService,
                                TransportService transportService, PercolatorService percolatorService,
                                TransportGetAction getAction, ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, PercolateAction.NAME, threadPool, clusterService, transportService, actionFilters,
            indexNameExpressionResolver, PercolateRequest.class, PercolateShardRequest.class, ThreadPool.Names.PERCOLATE);
    this.percolatorService = percolatorService;
    this.getAction = getAction;
}
 

import org.elasticsearch.percolator.PercolatorService; //导入依赖的package包/类
@Inject
public TransportMultiPercolateAction(Settings settings, ThreadPool threadPool, TransportShardMultiPercolateAction shardMultiPercolateAction,
                                     ClusterService clusterService, TransportService transportService, PercolatorService percolatorService,
                                     TransportMultiGetAction multiGetAction, ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, MultiPercolateAction.NAME, threadPool, transportService, actionFilters, indexNameExpressionResolver, MultiPercolateRequest.class);
    this.shardMultiPercolateAction = shardMultiPercolateAction;
    this.clusterService = clusterService;
    this.percolatorService = percolatorService;
    this.multiGetAction = multiGetAction;
}
 

import org.elasticsearch.percolator.PercolatorService; //导入依赖的package包/类
@Inject
public TransportShardMultiPercolateAction(Settings settings, ThreadPool threadPool, ClusterService clusterService,
                                          TransportService transportService, PercolatorService percolatorService,
                                          ActionFilters actionFilters, IndexNameExpressionResolver indexNameExpressionResolver) {
    super(settings, ACTION_NAME, threadPool, clusterService, transportService, actionFilters, indexNameExpressionResolver,
            Request.class, ThreadPool.Names.PERCOLATE);
    this.percolatorService = percolatorService;
}
 

import org.elasticsearch.percolator.PercolatorService; //导入依赖的package包/类
@Override
public void beforeCreate(DocumentMapper mapper) {
    if (PercolatorService.TYPE_NAME.equals(mapper.type())) {
        enableRealTimePercolator();
    }
}
 

import org.elasticsearch.percolator.PercolatorService; //导入依赖的package包/类
private boolean hasPercolatorType(IndexShard indexShard) {
    ShardId otherShardId = indexShard.shardId();
    return shardId.equals(otherShardId) && mapperService.hasMapping(PercolatorService.TYPE_NAME);
}
 

import org.elasticsearch.percolator.PercolatorService; //导入依赖的package包/类
private boolean typeNameStartsWithIllegalDot(DocumentMapper mapper) {
    return mapper.type().startsWith(".") && !PercolatorService.TYPE_NAME.equals(mapper.type());
}