Java Task类代码示例

import org.elasticsearch.tasks.Task; //导入依赖的package包/类
@Override
public Task register(String type, String action, TransportRequest request) {
    Task task = super.register(type, action, request);
    if (task != null) {
        for (MockTaskManagerListener listener : listeners) {
            try {
                listener.onTaskRegistered(task);
            } catch (Exception e) {
                logger.warn(
                    (Supplier<?>) () -> new ParameterizedMessage(
                        "failed to notify task manager listener about unregistering the task with id {}",
                        task.getId()),
                    e);
            }
        }
    }
    return task;
}
 

import org.elasticsearch.tasks.Task; //导入依赖的package包/类
@Override
public Task unregister(Task task) {
    Task removedTask = super.unregister(task);
    if (removedTask != null) {
        for (MockTaskManagerListener listener : listeners) {
            try {
                listener.onTaskUnregistered(task);
            } catch (Exception e) {
                logger.warn(
                    (Supplier<?>) () -> new ParameterizedMessage(
                        "failed to notify task manager listener about unregistering the task with id {}", task.getId()), e);
            }
        }
    } else {
        logger.warn("trying to remove the same with id {} twice", task.getId());
    }
    return removedTask;
}
 

import org.elasticsearch.tasks.Task; //导入依赖的package包/类
@Override
protected void doExecute(Task task, SearchScrollRequest request, ActionListener<SearchResponse> listener) {
    try {
        ParsedScrollId scrollId = parseScrollId(request.scrollId());
        AbstractAsyncAction action;
        switch (scrollId.getType()) {
            case QUERY_THEN_FETCH_TYPE:
                action = new SearchScrollQueryThenFetchAsyncAction(logger, clusterService, searchTransportService,
                    searchPhaseController, request, (SearchTask)task, scrollId, listener);
                break;
            case QUERY_AND_FETCH_TYPE: // TODO can we get rid of this?
                action = new SearchScrollQueryAndFetchAsyncAction(logger, clusterService, searchTransportService,
                    searchPhaseController, request, (SearchTask)task, scrollId, listener);
                break;
            default:
                throw new IllegalArgumentException("Scroll id type [" + scrollId.getType() + "] unrecognized");
        }
        action.start();
    } catch (Exception e) {
        listener.onFailure(e);
    }
}
 

import org.elasticsearch.tasks.Task; //导入依赖的package包/类
protected AsyncBroadcastAction(Task task, Request request, ActionListener<Response> listener) {
    this.task = task;
    this.request = request;
    this.listener = listener;

    clusterState = clusterService.state();

    ClusterBlockException blockException = checkGlobalBlock(clusterState, request);
    if (blockException != null) {
        throw blockException;
    }
    // update to concrete indices
    String[] concreteIndices = indexNameExpressionResolver.concreteIndices(clusterState, request);
    blockException = checkRequestBlock(clusterState, request, concreteIndices);
    if (blockException != null) {
        throw blockException;
    }

    nodes = clusterState.nodes();
    logger.trace("resolving shards based on cluster state version [{}]", clusterState.version());
    shardsIts = shards(clusterState, request, concreteIndices);
    expectedOps = shardsIts.size();

    shardsResponses = new AtomicReferenceArray<>(expectedOps);
}
 

import org.elasticsearch.tasks.Task; //导入依赖的package包/类
public boolean match(Task task) {
    if (getActions() != null && getActions().length > 0 && Regex.simpleMatch(getActions(), task.getAction()) == false) {
        return false;
    }
    if (getTaskId().isSet()) {
        if(getTaskId().getId() != task.getId()) {
            return false;
        }
    }
    if (parentTaskId.isSet()) {
        if (parentTaskId.equals(task.getParentTaskId()) == false) {
            return false;
        }
    }
    return true;
}
 

import org.elasticsearch.tasks.Task; //导入依赖的package包/类
protected AsyncBroadcastAction(Task task, Request request, ActionListener<Response> listener) {
    this.task = task;
    this.request = request;
    this.listener = listener;

    clusterState = clusterService.state();

    ClusterBlockException blockException = checkGlobalBlock(clusterState, request);
    if (blockException != null) {
        throw blockException;
    }
    // update to concrete indices
    String[] concreteIndices = indexNameExpressionResolver.concreteIndexNames(clusterState, request);
    blockException = checkRequestBlock(clusterState, request, concreteIndices);
    if (blockException != null) {
        throw blockException;
    }

    nodes = clusterState.nodes();
    logger.trace("resolving shards based on cluster state version [{}]", clusterState.version());
    shardsIts = shards(clusterState, request, concreteIndices);
    expectedOps = shardsIts.size();

    shardsResponses = new AtomicReferenceArray<>(expectedOps);
}
 

import org.elasticsearch.tasks.Task; //导入依赖的package包/类
@Override
protected void doExecute(final Task task, final DeleteRequest request, final ActionListener<DeleteResponse> listener) {
    ClusterState state = clusterService.state();
    if (autoCreateIndex.shouldAutoCreate(request.index(), state)) {
        createIndexAction.execute(task, new CreateIndexRequest(request).index(request.index()).cause("auto(delete api)")
            .masterNodeTimeout(request.timeout()), new ActionListener<CreateIndexResponse>() {
            @Override
            public void onResponse(CreateIndexResponse result) {
                innerExecute(task, request, listener);
            }

            @Override
            public void onFailure(Throwable e) {
                if (ExceptionsHelper.unwrapCause(e) instanceof IndexAlreadyExistsException) {
                    // we have the index, do it
                    innerExecute(task, request, listener);
                } else {
                    listener.onFailure(e);
                }
            }
        });
    } else {
        innerExecute(task, request, listener);
    }
}
 

import org.elasticsearch.tasks.Task; //导入依赖的package包/类
/**
 * Execute the transport action on the local node, returning the {@link Task} used to track its execution and accepting a
 * {@link TaskListener} which listens for the completion of the action.
 */
public final Task execute(Request request, TaskListener<Response> listener) {
    Task task = taskManager.register("transport", actionName, request);
    execute(task, request, new ActionListener<Response>() {
        @Override
        public void onResponse(Response response) {
            if (task != null) {
                taskManager.unregister(task);
            }
            listener.onResponse(task, response);
        }

        @Override
        public void onFailure(Exception e) {
            if (task != null) {
                taskManager.unregister(task);
            }
            listener.onFailure(task, e);
        }
    });
    return task;
}
 

import org.elasticsearch.tasks.Task; //导入依赖的package包/类
@Override
public void proceed(Task task, String actionName, Request request, ActionListener<Response> listener) {
    int i = index.getAndIncrement();
    try {
        if (i < this.action.filters.length) {
            this.action.filters[i].apply(task, actionName, request, listener, this);
        } else if (i == this.action.filters.length) {
            this.action.doExecute(task, request, listener);
        } else {
            listener.onFailure(new IllegalStateException("proceed was called too many times"));
        }
    } catch(Exception e) {
        logger.trace("Error during transport action execution.", e);
        listener.onFailure(e);
    }
}
 

import org.elasticsearch.tasks.Task; //导入依赖的package包/类
/**
 * Use this method when the transport action should continue to run in the context of the current task
 */
public final void execute(Task task, Request request, ActionListener<Response> listener) {

    ActionRequestValidationException validationException = request.validate();
    if (validationException != null) {
        listener.onFailure(validationException);
        return;
    }

    if (filters.length == 0) {
        try {
            doExecute(task, request, listener);
        } catch(Throwable t) {
            logger.trace("Error during transport action execution.", t);
            listener.onFailure(t);
        }
    } else {
        RequestFilterChain requestFilterChain = new RequestFilterChain<>(this, logger);
        requestFilterChain.proceed(task, actionName, request, listener);
    }
}
 

import org.elasticsearch.tasks.Task; //导入依赖的package包/类
void processBulkIndexIngestRequest(Task task, BulkRequest original, ActionListener<BulkResponse> listener) {
    long ingestStartTimeInNanos = System.nanoTime();
    BulkRequestModifier bulkRequestModifier = new BulkRequestModifier(original);
    ingestService.getPipelineExecutionService().executeBulkRequest(() -> bulkRequestModifier, (indexRequest, exception) -> {
        logger.debug((Supplier<?>) () -> new ParameterizedMessage("failed to execute pipeline [{}] for document [{}/{}/{}]",
            indexRequest.getPipeline(), indexRequest.index(), indexRequest.type(), indexRequest.id()), exception);
        bulkRequestModifier.markCurrentItemAsFailed(exception);
    }, (exception) -> {
        if (exception != null) {
            logger.error("failed to execute pipeline for a bulk request", exception);
            listener.onFailure(exception);
        } else {
            long ingestTookInMillis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - ingestStartTimeInNanos);
            BulkRequest bulkRequest = bulkRequestModifier.getBulkRequest();
            ActionListener<BulkResponse> actionListener = bulkRequestModifier.wrapActionListenerIfNeeded(ingestTookInMillis, listener);
            if (bulkRequest.requests().isEmpty()) {
                // at this stage, the transport bulk action can't deal with a bulk request with no requests,
                // so we stop and send an empty response back to the client.
                // (this will happen if pre-processing all items in the bulk failed)
                actionListener.onResponse(new BulkResponse(new BulkItemResponse[0], 0));
            } else {
                doExecute(task, bulkRequest, actionListener);
            }
        }
    });
}
 

import org.elasticsearch.tasks.Task; //导入依赖的package包/类
@Override
protected NodeResponse nodeOperation(NodeRequest request, Task task) {
    logger.info("Test task started on the node {}", clusterService.localNode());
    if (request.shouldBlock) {
        try {
            awaitBusy(() -> {
                if (((CancellableTask) task).isCancelled()) {
                    throw new RuntimeException("Cancelled!");
                }
                return ((TestTask) task).isBlocked() == false;
            });
        } catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
        }
    }
    logger.info("Test task finished on the node {}", clusterService.localNode());
    return new NodeResponse(clusterService.localNode());
}
 

import org.elasticsearch.tasks.Task; //导入依赖的package包/类
private Task startCancellableTestNodesAction(boolean waitForActionToStart, Collection<TestNode> blockOnNodes, CancellableNodesRequest
    request, ActionListener<NodesResponse> listener) throws InterruptedException {
    CountDownLatch actionLatch = waitForActionToStart ? new CountDownLatch(nodesCount) : null;
    CancellableTestNodesAction[] actions = new CancellableTestNodesAction[nodesCount];
    for (int i = 0; i < testNodes.length; i++) {
        boolean shouldBlock = blockOnNodes.contains(testNodes[i]);
        logger.info("The action in the node [{}] should block: [{}]", testNodes[i].getNodeId(), shouldBlock);
        actions[i] = new CancellableTestNodesAction(CLUSTER_SETTINGS, "testAction", threadPool, testNodes[i]
            .clusterService, testNodes[i].transportService, shouldBlock, actionLatch);
    }
    Task task = actions[0].execute(request, listener);
    if (waitForActionToStart) {
        logger.info("Awaiting for all actions to start");
        actionLatch.await();
        logger.info("Done waiting for all actions to start");
    }
    return task;
}
 

import org.elasticsearch.tasks.Task; //导入依赖的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.tasks.Task; //导入依赖的package包/类
private RestChannelConsumer sendTask(String localNodeId, Task task) throws IOException {
    return channel -> {
        try (XContentBuilder builder = channel.newBuilder()) {
            builder.startObject();
            builder.field("task", localNodeId + ":" + task.getId());
            builder.endObject();
            channel.sendResponse(new BytesRestResponse(RestStatus.OK, builder));
        }
    };
}