Java ExceptionsHelper.convertToRuntime方法代码示例

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public DfsSearchResult executeDfsPhase(ShardSearchRequest request, SearchTask task) throws IOException {
    final SearchContext context = createAndPutContext(request);
    context.incRef();
    try {
        context.setTask(task);
        contextProcessing(context);
        dfsPhase.execute(context);
        contextProcessedSuccessfully(context);
        return context.dfsResult();
    } catch (Exception e) {
        logger.trace("Dfs phase failed", e);
        processFailure(context, e);
        throw ExceptionsHelper.convertToRuntime(e);
    } finally {
        cleanContext(context);
    }
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
private QueryFetchSearchResult executeFetchPhase(SearchContext context, SearchOperationListener operationListener,
                                                    long afterQueryTime) {
    operationListener.onPreFetchPhase(context);
    try {
        shortcutDocIdsToLoad(context);
        fetchPhase.execute(context);
        if (fetchPhaseShouldFreeContext(context)) {
            freeContext(context.id());
        } else {
            contextProcessedSuccessfully(context);
        }
    } catch (Exception e) {
        operationListener.onFailedFetchPhase(context);
        throw ExceptionsHelper.convertToRuntime(e);
    }
    operationListener.onFetchPhase(context, System.nanoTime() - afterQueryTime);
    return new QueryFetchSearchResult(context.queryResult(), context.fetchResult());
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public ScrollQuerySearchResult executeQueryPhase(InternalScrollSearchRequest request, SearchTask task) {
    final SearchContext context = findContext(request.id());
    SearchOperationListener operationListener = context.indexShard().getSearchOperationListener();
    context.incRef();
    try {
        context.setTask(task);
        operationListener.onPreQueryPhase(context);
        long time = System.nanoTime();
        contextProcessing(context);
        processScroll(request, context);
        queryPhase.execute(context);
        contextProcessedSuccessfully(context);
        operationListener.onQueryPhase(context, System.nanoTime() - time);
        return new ScrollQuerySearchResult(context.queryResult(), context.shardTarget());
    } catch (Exception e) {
        operationListener.onFailedQueryPhase(context);
        logger.trace("Query phase failed", e);
        processFailure(context, e);
        throw ExceptionsHelper.convertToRuntime(e);
    } finally {
        cleanContext(context);
    }
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
private Query queryFromInnerFunction(Function function, Context context) {
    for (Symbol symbol : function.arguments()) {
        if (symbol.symbolType() == SymbolType.FUNCTION) {
            String functionName = ((Function) symbol).info().ident().name();
            InnerFunctionToQuery functionToQuery = innerFunctions.get(functionName);
            if (functionToQuery != null) {
                try {
                    Query query = functionToQuery.apply(function, (Function)symbol, context);
                    if (query != null) {
                        return query;
                    }
                } catch (IOException e) {
                    throw ExceptionsHelper.convertToRuntime(e);
                }
            }
        }
    }
    return null;
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public ScrollQuerySearchResult executeQueryPhase(InternalScrollSearchRequest request) {
    final SearchContext context = findContext(request.id());
    ShardSearchStats shardSearchStats = context.indexShard().searchService();
    try {
        shardSearchStats.onPreQueryPhase(context);
        long time = System.nanoTime();
        contextProcessing(context);
        processScroll(request, context);
        queryPhase.execute(context);
        contextProcessedSuccessfully(context);
        shardSearchStats.onQueryPhase(context, System.nanoTime() - time);
        return new ScrollQuerySearchResult(context.queryResult(), context.shardTarget());
    } catch (Throwable e) {
        shardSearchStats.onFailedQueryPhase(context);
        logger.trace("Query phase failed", e);
        processFailure(context, e);
        throw ExceptionsHelper.convertToRuntime(e);
    } finally {
        cleanContext(context);
    }
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
final SearchContext createContext(ShardSearchRequest request, @Nullable Engine.Searcher searcher) throws IOException {
    final DefaultSearchContext context = createSearchContext(request, defaultSearchTimeout, searcher);
    try {
        if (request.scroll() != null) {
            context.scrollContext(new ScrollContext());
            context.scrollContext().scroll = request.scroll();
        }
        parseSource(context, request.source());

        // if the from and size are still not set, default them
        if (context.from() == -1) {
            context.from(0);
        }
        if (context.size() == -1) {
            context.size(10);
        }

        // pre process
        dfsPhase.preProcess(context);
        queryPhase.preProcess(context);
        fetchPhase.preProcess(context);

        // compute the context keep alive
        long keepAlive = defaultKeepAlive;
        if (request.scroll() != null && request.scroll().keepAlive() != null) {
            keepAlive = request.scroll().keepAlive().millis();
        }
        context.keepAlive(keepAlive);
        context.lowLevelCancellation(lowLevelCancellation);
    } catch (Exception e) {
        context.close();
        throw ExceptionsHelper.convertToRuntime(e);
    }

    return context;
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public ClusterState applyFailedShards(ClusterState clusterState, List<FailedShard> failedShards) {
    List<ShardStateAction.ShardEntry> entries = failedShards.stream().map(failedShard ->
        new ShardStateAction.ShardEntry(failedShard.getRoutingEntry().shardId(), failedShard.getRoutingEntry().allocationId().getId(),
            0L, failedShard.getMessage(), failedShard.getFailure()))
        .collect(Collectors.toList());
    try {
        return shardFailedClusterStateTaskExecutor.execute(clusterState, entries).resultingState;
    } catch (Exception e) {
        throw ExceptionsHelper.convertToRuntime(e);
    }
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public ClusterState applyStartedShards(ClusterState clusterState, List<ShardRouting> startedShards) {
    List<ShardStateAction.ShardEntry> entries = startedShards.stream().map(startedShard ->
        new ShardStateAction.ShardEntry(startedShard.shardId(), startedShard.allocationId().getId(), 0L, "shard started", null))
        .collect(Collectors.toList());
    try {
        return shardStartedClusterStateTaskExecutor.execute(clusterState, entries).resultingState;
    } catch (Exception e) {
        throw ExceptionsHelper.convertToRuntime(e);
    }
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public DfsSearchResult executeDfsPhase(ShardSearchRequest request) {
    final SearchContext context = createAndPutContext(request);
    try {
        contextProcessing(context);
        dfsPhase.execute(context);
        contextProcessedSuccessfully(context);
        return context.dfsResult();
    } catch (Throwable e) {
        logger.trace("Dfs phase failed", e);
        processFailure(context, e);
        throw ExceptionsHelper.convertToRuntime(e);
    } finally {
        cleanContext(context);
    }
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
public FetchSearchResult executeFetchPhase(ShardFetchRequest request) {
    final SearchContext context = findContext(request.id());
    contextProcessing(context);
    final ShardSearchStats shardSearchStats = context.indexShard().searchService();
    try {
        if (request.lastEmittedDoc() != null) {
            context.scrollContext().lastEmittedDoc = request.lastEmittedDoc();
        }
        context.docIdsToLoad(request.docIds(), 0, request.docIdsSize());
        shardSearchStats.onPreFetchPhase(context);
        long time = System.nanoTime();
        fetchPhase.execute(context);
        if (fetchPhaseShouldFreeContext(context)) {
            freeContext(request.id());
        } else {
            contextProcessedSuccessfully(context);
        }
        shardSearchStats.onFetchPhase(context, System.nanoTime() - time);
        return context.fetchResult();
    } catch (Throwable e) {
        shardSearchStats.onFailedFetchPhase(context);
        logger.trace("Fetch phase failed", e);
        processFailure(context, e);
        throw ExceptionsHelper.convertToRuntime(e);
    } finally {
        cleanContext(context);
    }
}
 

import org.elasticsearch.ExceptionsHelper; //导入方法依赖的package包/类
final SearchContext createContext(ShardSearchRequest request, @Nullable Engine.Searcher searcher) {
    IndexService indexService = indicesService.indexServiceSafe(request.index());
    IndexShard indexShard = indexService.shardSafe(request.shardId());

    SearchShardTarget shardTarget = new SearchShardTarget(clusterService.localNode().id(), request.index(), request.shardId());
    String searchSource = "search";
    if (request.hasHeader("search_source")) {
        searchSource = request.getHeader("search_source");
    }
    Engine.Searcher engineSearcher = searcher == null ? indexShard.acquireSearcher(searchSource) : searcher;

    DefaultSearchContext context = new DefaultSearchContext(idGenerator.incrementAndGet(), request, shardTarget, engineSearcher, indexService, indexShard, scriptService, pageCacheRecycler, bigArrays, threadPool.estimatedTimeInMillisCounter(), parseFieldMatcher, defaultSearchTimeout);
    SearchContext.setCurrent(context);
    try {
        if (request.scroll() != null) {
            context.scrollContext(new ScrollContext());
            context.scrollContext().scroll = request.scroll();
        }

        parseTemplate(request, context);
        parseSource(context, request.source());
        parseSource(context, request.extraSource());

        // if the from and size are still not set, default them
        if (context.from() == -1) {
            context.from(0);
        }
        if (context.searchType() == SearchType.COUNT) {
            // so that the optimizations we apply to size=0 also apply to search_type=COUNT
            // and that we close contexts when done with the query phase
            context.searchType(SearchType.QUERY_THEN_FETCH);
            context.size(0);
        } else if (context.size() == -1) {
            context.size(10);
        }

        if (context.request().isProfile()) {
            context.setProfilers(new Profilers(context.searcher()));
        }

        // pre process
        dfsPhase.preProcess(context);
        queryPhase.preProcess(context);
        fetchPhase.preProcess(context);

        // compute the context keep alive
        long keepAlive = defaultKeepAlive;
        if (request.scroll() != null && request.scroll().keepAlive() != null) {
            keepAlive = request.scroll().keepAlive().millis();
        }
        context.keepAlive(keepAlive);
    } catch (Throwable e) {
        context.close();
        throw ExceptionsHelper.convertToRuntime(e);
    }

    return context;
}