Java ActionListener.onResponse方法代码示例

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
static void rethrottle(String localNodeId, Client client, BulkByScrollTask task, float newRequestsPerSecond,
        ActionListener<TaskInfo> listener) {
    int runningSubTasks = task.runningSliceSubTasks();
    if (runningSubTasks == 0) {
        // Nothing to do, all sub tasks are done
        task.rethrottle(newRequestsPerSecond);
        listener.onResponse(task.taskInfo(localNodeId, true));
        return;
    }
    RethrottleRequest subRequest = new RethrottleRequest();
    subRequest.setRequestsPerSecond(newRequestsPerSecond / runningSubTasks);
    subRequest.setParentTaskId(new TaskId(localNodeId, task.getId()));
    client.execute(RethrottleAction.INSTANCE, subRequest, ActionListener.wrap(r -> {
        r.rethrowFailures("Rethrottle");
        listener.onResponse(task.getInfoGivenSliceInfo(localNodeId, r.getTasks()));
    }, listener::onFailure));
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
@Override
public void bulk(BulkRequest request, ActionListener<BulkResponse> listener) {
    if (false == expectedHeaders.equals(threadPool().getThreadContext().getHeaders())) {
        listener.onFailure(
                new RuntimeException("Expected " + expectedHeaders + " but got " + threadPool().getThreadContext().getHeaders()));
        return;
    }

    // do everything synchronously, that's fine for a test
    boolean shouldFail = numberOfCallsToFail > 0;
    numberOfCallsToFail--;

    BulkItemResponse[] itemResponses = new BulkItemResponse[request.requests().size()];
    // if we have to fail, we need to fail at least once "reliably", the rest can be random
    int itemToFail = randomInt(request.requests().size() - 1);
    for (int idx = 0; idx < request.requests().size(); idx++) {
        if (shouldFail && (randomBoolean() || idx == itemToFail)) {
            itemResponses[idx] = failedResponse();
        } else {
            itemResponses[idx] = successfulResponse();
        }
    }
    listener.onResponse(new BulkResponse(itemResponses, 1000L));
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
private void finishAndNotifyListener(ActionListener listener, CopyOnWriteArrayList<ShardResponse> shardsResponses) {
    logger.trace("{}: got all shard responses", actionName);
    int successfulShards = 0;
    int failedShards = 0;
    int totalNumCopies = 0;
    List<ShardOperationFailedException> shardFailures = null;
    for (int i = 0; i < shardsResponses.size(); i++) {
        ReplicationResponse shardResponse = shardsResponses.get(i);
        if (shardResponse == null) {
            // non active shard, ignore
        } else {
            failedShards += shardResponse.getShardInfo().getFailed();
            successfulShards += shardResponse.getShardInfo().getSuccessful();
            totalNumCopies += shardResponse.getShardInfo().getTotal();
            if (shardFailures == null) {
                shardFailures = new ArrayList<>();
            }
            for (ReplicationResponse.ShardInfo.Failure failure : shardResponse.getShardInfo().getFailures()) {
                shardFailures.add(new DefaultShardOperationFailedException(new BroadcastShardOperationFailedException(failure.fullShardId(), failure.getCause())));
            }
        }
    }
    listener.onResponse(newResponse(successfulShards, failedShards, totalNumCopies, shardFailures));
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
@Override
protected void masterOperation(final DeleteIndexRequest request, final ClusterState state, final ActionListener<DeleteIndexResponse> listener) {
    final String[] concreteIndices = indexNameExpressionResolver.concreteIndices(state, request);
    if (concreteIndices.length == 0) {
        listener.onResponse(new DeleteIndexResponse(true));
        return;
    }
    // add tenantid to index metadata
    LoginUserContext userInfo = (LoginUserContext)request.getHeader(LoginUserContext.USER_INFO_KEY);
    deleteIndexService.deleteIndices(new MetaDataDeleteIndexService.Request(concreteIndices, userInfo).timeout(request.timeout()).masterTimeout(request.masterNodeTimeout()), new MetaDataDeleteIndexService.Listener() {

        @Override
        public void onResponse(MetaDataDeleteIndexService.Response response) {
            listener.onResponse(new DeleteIndexResponse(response.acknowledged()));
        }

        @Override
        public void onFailure(Throwable t) {
            listener.onFailure(t);
        }
    });
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
@Override
protected void masterOperation(final BulkCreateIndicesRequest request,
                               final ClusterState state,
                               final ActionListener<BulkCreateIndicesResponse> listener) throws ElasticsearchException {

    if (request.indices().isEmpty()) {
        listener.onResponse(new BulkCreateIndicesResponse(true));
        return;
    }

    final ActionListener<ClusterStateUpdateResponse> stateUpdateListener = new ActionListener<ClusterStateUpdateResponse>() {
        @Override
        public void onResponse(ClusterStateUpdateResponse clusterStateUpdateResponse) {
                listener.onResponse(new BulkCreateIndicesResponse(true));
        }

        @Override
        public void onFailure(Throwable e) {
            listener.onFailure(e);
        }
    };
    createIndices(request, stateUpdateListener);
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
@Override
protected void doExecute(SearchRequest request, ActionListener<SearchResponse> listener) {
    listener.onResponse(new SearchResponse(new InternalSearchResponse(
        new SearchHits(
            new SearchHit[0], 0L, 0.0f),
        new InternalAggregations(Collections.emptyList()),
        new Suggest(Collections.emptyList()),
        new SearchProfileShardResults(Collections.emptyMap()), false, false, 1), "", 1, 1, 0, new ShardSearchFailure[0]));
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
@Override
protected <Request extends ActionRequest,
                Response extends ActionResponse,
                RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>>
        void doExecute(Action<Request, Response, RequestBuilder> action, Request request, ActionListener<Response> listener) {
    listener.onResponse(null);
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
public void testFailPhaseOnException() throws IOException {
    AtomicArray<DfsSearchResult> results = new AtomicArray<>(2);
    AtomicReference<AtomicArray<QuerySearchResultProvider>> responseRef = new AtomicReference<>();
    results.set(0, new DfsSearchResult(1, new SearchShardTarget("node1", new Index("test", "na"), 0)));
    results.set(1, new DfsSearchResult(2, new SearchShardTarget("node2", new Index("test", "na"), 0)));
    results.get(0).termsStatistics(new Term[0], new TermStatistics[0]);
    results.get(1).termsStatistics(new Term[0], new TermStatistics[0]);

    SearchPhaseController controller = new SearchPhaseController(Settings.EMPTY, BigArrays.NON_RECYCLING_INSTANCE, null);
    SearchTransportService searchTransportService = new SearchTransportService(
        Settings.builder().put("search.remote.connect", false).build(), null,  null) {

        @Override
        public void sendExecuteQuery(Transport.Connection connection, QuerySearchRequest request, SearchTask task,
                                     ActionListener<QuerySearchResult> listener) {
            if (request.id() == 1) {
                QuerySearchResult queryResult = new QuerySearchResult(123, new SearchShardTarget("node1", new Index("test", "na"), 0));
                queryResult.topDocs(new TopDocs(1, new ScoreDoc[] {new ScoreDoc(42, 1.0F)}, 2.0F), new DocValueFormat[0]);
                queryResult.size(2); // the size of the result set
                listener.onResponse(queryResult);
            } else if (request.id() == 2) {
               throw new UncheckedIOException(new MockDirectoryWrapper.FakeIOException());
            } else {
                fail("no such request ID: " + request.id());
            }
        }
    };
    MockSearchPhaseContext mockSearchPhaseContext = new MockSearchPhaseContext(2);
    mockSearchPhaseContext.searchTransport = searchTransportService;
    DfsQueryPhase phase = new DfsQueryPhase(results, controller,
        (response) -> new SearchPhase("test") {
            @Override
            public void run() throws IOException {
                responseRef.set(response.results);
            }
        }, mockSearchPhaseContext);
    assertEquals("dfs_query", phase.getName());
    expectThrows(UncheckedIOException.class, () -> phase.run());
    assertTrue(mockSearchPhaseContext.releasedSearchContexts.isEmpty()); // phase execution will clean up on the contexts
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
AsyncSingleAction(Task task, final Request request, ActionListener<Response> listener) {
    this.task = task;
    this.request = request;
    if (task != null) {
        request.setParentTask(clusterService.localNode().getId(), task.getId());
    }
    // TODO do we really need to wrap it in a listener? the handlers should be cheap
    if ((listener instanceof ThreadedActionListener) == false) {
        listener = new ThreadedActionListener<>(logger, threadPool, ThreadPool.Names.LISTENER, listener);
    }
    final ActionListener listenerAfterFilter = listener;
    this.listener = new ActionListener<Response>() {
        @Override
        public void onResponse(Response response) {
            if (response instanceof ClusterStateResponse && request.getHeader(LoginUserContext.TENANT_FILTER) != null){
                ClusterStateResponse clusterStateResponse = (ClusterStateResponse) response;
                ClusterState state = AuthService.filterState(clusterStateResponse.getState(), clusterService.state().metaData(),
                        (Long) request.getHeader(LoginUserContext.TENANT_FILTER));
                listenerAfterFilter.onResponse(new ClusterStateResponse(clusterStateResponse.getClusterName(), state));
            } else {
                listenerAfterFilter.onResponse(response);
            }
        }

        @Override
        public void onFailure(Throwable e) {
            listenerAfterFilter.onFailure(e);
        }
    };
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
@Override
protected void masterOperation(final IndicesExistsRequest request, final ClusterState state, final ActionListener<IndicesExistsResponse> listener) {
    boolean exists;
    try {
        // Similar as the previous behaviour, but now also aliases and wildcards are supported.
        indexNameExpressionResolver.concreteIndexNames(state, request);
        exists = true;
    } catch (IndexNotFoundException e) {
        exists = false;
    }
    listener.onResponse(new IndicesExistsResponse(exists));
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
@Override
protected void doMasterOperation(final GetWarmersRequest request, String[] concreteIndices, final ClusterState state, final ActionListener<GetWarmersResponse> listener) {
    ImmutableOpenMap<String, List<IndexWarmersMetaData.Entry>> result = state.metaData().findWarmers(
            concreteIndices, request.types(), request.warmers()
    );
    listener.onResponse(new GetWarmersResponse(result));
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
public void respond(ActionListener<Response> listener) {
    if (finalResponseIfSuccessful != null) {
        listener.onResponse(finalResponseIfSuccessful);
    } else {
        listener.onFailure(finalFailure);
    }
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
@Override
protected void masterOperation(GetAliasesRequest request, ClusterState state, ActionListener<GetAliasesResponse> listener) {
    String[] concreteIndices = indexNameExpressionResolver.concreteIndexNames(state, request);
    @SuppressWarnings("unchecked")
            ImmutableOpenMap<String, List<AliasMetaData>> result = (ImmutableOpenMap) state.metaData().findAliases(request.aliases(), concreteIndices);
    listener.onResponse(new GetAliasesResponse(result));
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
@Override
protected void doMasterOperation(final GetMappingsRequest request, String[] concreteIndices, final ClusterState state, final ActionListener<GetMappingsResponse> listener) {
    logger.trace("serving getMapping request based on version {}", state.version());
    ImmutableOpenMap<String, ImmutableOpenMap<String, MappingMetaData>> result = state.metaData().findMappings(
            concreteIndices, request.types()
    );
    listener.onResponse(new GetMappingsResponse(result));
}
 

import org.elasticsearch.action.ActionListener; //导入方法依赖的package包/类
@Override
protected void masterOperation(PendingClusterTasksRequest request, ClusterState state, ActionListener<PendingClusterTasksResponse> listener) {
    logger.trace("fetching pending tasks from cluster service");
    final List<PendingClusterTask> pendingTasks = clusterService.pendingTasks();
    logger.trace("done fetching pending tasks from cluster service");
    listener.onResponse(new PendingClusterTasksResponse(pendingTasks));
}