elasticsearch源码关于TransportSearchAction【阶段二】4.executeQueryPhase【重点】

1.回顾SearchTransportService

public class SearchTransportService extends AbstractComponent
searchService.executeQueryPhase(request, (SearchTask) task, new ActionListener()
request$ShardSearchTransportRequest

transportService.registerRequestHandler(QUERY_ACTION_NAME, ShardSearchTransportRequest::new, ThreadPool.Names.SAME,
            new TaskAwareTransportRequestHandler<ShardSearchTransportRequest>() {
                @Override
                public void messageReceived(ShardSearchTransportRequest request, TransportChannel channel, Task task) throws Exception {
                    searchService.executeQueryPhase(request, (SearchTask) task, new ActionListener<SearchPhaseResult>() {
                        @Override
                        public void onResponse(SearchPhaseResult searchPhaseResult) {
                            try {
                                channel.sendResponse(searchPhaseResult);
                            } catch (IOException e) {
                                throw new UncheckedIOException(e);
                            }
                        }
                    });
                }
           });

2.SearchService

public class SearchService extends AbstractLifecycleComponent implements IndexEventListener
executeQueryPhase(request, task)
SearchService：方法1

   public void executeQueryPhase(ShardSearchRequest request, SearchTask task, ActionListener<SearchPhaseResult> listener) {
        rewriteShardRequest(request, new ActionListener<ShardSearchRequest>() {
            @Override
            public void onResponse(ShardSearchRequest request) {
                try {
                    if (!Objects.equals(request.shardId().getIndex().getName(), ".kibana")) {
                        System.out.println("监听search之后的结果SearchService#SearchService");
                    }
                    listener.onResponse(executeQueryPhase(request, task));
                } catch (Exception e) {
                    onFailure(e);
                }
            }
        });
    }

SearchService：方法2

 SearchPhaseResult executeQueryPhase(ShardSearchRequest request, SearchTask task) throws IOException {
        final SearchContext context = createAndPutContext(request);
        final SearchOperationListener operationListener = context.indexShard().getSearchOperationListener();
        context.incRef();
        boolean queryPhaseSuccess = false;
        try {
            context.setTask(task);
            operationListener.onPreQueryPhase(context);
            long time = System.nanoTime();
            contextProcessing(context);
            // 节点查询缓存
            loadOrExecuteQueryPhase(request, context);

            if (context.queryResult().hasSearchContext() == false && context.scrollContext() == null) {
                freeContext(context.id());
            } else {
                contextProcessedSuccessfully(context);
            }
            final long afterQueryTime = System.nanoTime();
            queryPhaseSuccess = true;
            operationListener.onQueryPhase(context, afterQueryTime - time);
            if (request.numberOfShards() == 1) {
                return executeFetchPhase(context, operationListener, afterQueryTime);
            }
            return context.queryResult();
        } catch (Exception e) {
        } finally {
            cleanContext(context);
        }
    }

3.SearchExecutionStatsCollector

public final class SearchExecutionStatsCollector implements ActionListener
response接收
listener$InitalSearchphase

 @Override
    public void onResponse(SearchPhaseResult response) {
        QuerySearchResult queryResult = response.queryResult();
        if (nodeId != null && queryResult != null) {
            final long serviceTimeEWMA = queryResult.serviceTimeEWMA();
            final int queueSize = queryResult.nodeQueueSize();
            final long responseDuration = System.nanoTime() - startNanos;
            // EWMA/queue size may be -1 if the query node doesn't support capturing it
            if (serviceTimeEWMA > 0 && queueSize > 0) {
                collector.addNodeStatistics(nodeId, queueSize, responseDuration, serviceTimeEWMA);
            }
        }
        listener.onResponse(response);
    }

4.SearchActionListener

abstract class SearchActionListener implements ActionListener

  @Override
    public final void onResponse(T response) {
        if (response instanceof FetchSearchResult && !Objects.equals(".kibana", response.getSearchShardTarget().getIndex())) {
            System.out.println("SearchActionListener#onResponse->innerOnResponse >>>" + response.getSearchShardTarget().getIndex());
        }
        response.setShardIndex(requestIndex);
        setSearchShardTarget(response);
        innerOnResponse(response);
    }

5.InitialSearchPhase

abstract class InitialSearchPhase extends SearchPhase
onShardResult(result, shardIt)

 private void performPhaseOnShard(final int shardIndex, final SearchShardIterator shardIt, final ShardRouting shard) {
        final Thread thread = Thread.currentThread();
            try {
                executePhaseOnShard(shardIt, shard, new SearchActionListener<FirstResult>(new SearchShardTarget(shard.currentNodeId(),
                    shardIt.shardId(), shardIt.getClusterAlias(), shardIt.getOriginalIndices()), shardIndex) {
                    @Override
                    public void innerOnResponse(FirstResult result) {
                        maybeFork(thread, () -> onShardResult(result, shardIt));
                    }
                });
            } catch (final Exception e) {
         }
    }

 private void maybeFork(final Thread thread, final Runnable runnable) {
        if (thread == Thread.currentThread()) {
            fork(runnable);
        } else {
            runnable.run();
        }
    }

successfulShardExecution

  private void onShardResult(FirstResult result, SearchShardIterator shardIt) {
        assert result.getShardIndex() != -1 : "shard index is not set";
        assert result.getSearchShardTarget() != null : "search shard target must not be null";

        onShardSuccess(result);
        successfulShardExecution(shardIt);
    }

maybeExecuteNext

  private void successfulShardExecution(SearchShardIterator shardsIt) {
        final int remainingOpsOnIterator;
        if (shardsIt.skip()) {
            remainingOpsOnIterator = shardsIt.remaining();
        } else {
            remainingOpsOnIterator = shardsIt.remaining() + 1;
        }
        final int xTotalOps = totalOps.addAndGet(remainingOpsOnIterator);
        if (xTotalOps == expectedTotalOps) {
            onPhaseDone();
        } else if (xTotalOps > expectedTotalOps) {
            throw new AssertionError("unexpected higher total ops [" + xTotalOps + "] compared to expected ["
                + expectedTotalOps + "]");
        } else if (shardsIt.skip() == false) {
            maybeExecuteNext();
        }
    }

maybeExecuteNext，执行下一个分片

 private void maybeExecuteNext() {
        final int index = shardExecutionIndex.getAndIncrement();
        if (index < shardsIts.size()) {
            final SearchShardIterator shardRoutings = shardsIts.get(index);
            performPhaseOnShard(index, shardRoutings, shardRoutings.nextOrNull());
        }
    }

6.TransportService

public class TransportService extends AbstractLifecycleComponent
processResponse(handler, response)

        @Override
        public void sendResponse(final TransportResponse response, TransportResponseOptions options) throws IOException {
            adapter.onResponseSent(requestId, action, response, options);
            final TransportResponseHandler handler = adapter.onResponseReceived(requestId);
            // ignore if its null, the adapter logs it
            if (handler != null) {
                final String executor = handler.executor();
                if (ThreadPool.Names.SAME.equals(executor)) {
                    if (response instanceof QuerySearchResult) {
                        QuerySearchResult querySearchResult = (QuerySearchResult) response;
                        SearchShardTarget searchShardTarget = querySearchResult.getSearchShardTarget();
                        if (!Objects.equals(searchShardTarget.getShardId().getIndexName(),".kibana")){
                            System.out.println("发送响应结果,TransportService#sendResponse ->(QuerySearchResult) response");
                        }
                    }
                    if (response instanceof GetResponse) {
                        GetResponse getResponse = (GetResponse) response;
                        if (!Objects.equals(getResponse.getIndex(),".kibana")){
                            System.out.println("发送响应结果,TransportService#sendResponse ->(GetResponse) response");
                        }
                    }
                    processResponse(handler, response);
                } else {
                    threadPool.executor(executor).execute(() -> processResponse(handler, response));
                }
            }
        }