Java Action类代码示例

import org.elasticsearch.action.Action; //导入依赖的package包/类
@Override
public ActionRequestValidationException validate() {
    ActionRequestValidationException arve = null;
    if (store == null) {
        arve = addValidationError("store must be set", null);
    }
    if (!store.equals(IndexFeatureStore.DEFAULT_STORE) && !store.startsWith(IndexFeatureStore.STORE_PREFIX)) {
        arve = addValidationError("Store name [" + store + "] is invalid.", arve);
    }
    if (storableElement == null) {
        arve = addValidationError("storable element must be set", arve);
    }
    if (action == Action.UPDATE && !storableElement.updatable()) {
        arve = addValidationError("Elements of type [" + storableElement.type() + "] are not updatable.", arve);
    }
    if (updatedVersion != null && action != Action.UPDATE) {
        arve = addValidationError("Only UPDATE supports a version.", arve);
    }
    return arve;
}
 

import org.elasticsearch.action.Action; //导入依赖的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.Action; //导入依赖的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) {
    request.setParentTask(parentTask);
    super.doExecute(action, request, listener);
}
 

import org.elasticsearch.action.Action; //导入依赖的package包/类
@Override
public final <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> ActionFuture<Response> execute(
        Action<Request, Response, RequestBuilder> action, Request request) {
    PlainActionFuture<Response> actionFuture = PlainActionFuture.newFuture();
    execute(action, request, actionFuture);
    return actionFuture;
}
 

import org.elasticsearch.action.Action; //导入依赖的package包/类
@Override
public Client filterWithHeader(Map<String, String> headers) {
    return new FilterClient(this) {
        @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) {
            ThreadContext threadContext = threadPool().getThreadContext();
            try (ThreadContext.StoredContext ctx = threadContext.stashAndMergeHeaders(headers)) {
                super.doExecute(action, request, listener);
            }
        }
    };
}
 

import org.elasticsearch.action.Action; //导入依赖的package包/类
TransportProxyClient(Settings settings, TransportService transportService,
                            TransportClientNodesService nodesService, List<GenericAction> actions) {
    this.nodesService = nodesService;
    Map<Action, TransportActionNodeProxy> proxies = new HashMap<>();
    for (GenericAction action : actions) {
        if (action instanceof Action) {
            proxies.put((Action) action, new TransportActionNodeProxy(settings, action, transportService));
        }
    }
    this.proxies = unmodifiableMap(proxies);
}
 

import org.elasticsearch.action.Action; //导入依赖的package包/类
@Override
public <    Request extends ActionRequest,
            Response extends ActionResponse,
            RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>
        > void doExecute(Action<Request, Response, RequestBuilder> action, Request request, ActionListener<Response> listener) {
    // Discard the task because the Client interface doesn't use it.
    executeLocally(action, request, listener);
}
 

import org.elasticsearch.action.Action; //导入依赖的package包/类
public static <
            Request extends AbstractBulkByScrollRequest<Request>
        > void startSlices(Client client, TaskManager taskManager, Action<Request, BulkByScrollResponse, ?> action,
                String localNodeId, ParentBulkByScrollTask task, Request request, ActionListener<BulkByScrollResponse> listener) {
    TaskId parentTaskId = new TaskId(localNodeId, task.getId());
    for (final SearchRequest slice : sliceIntoSubRequests(request.getSearchRequest(), UidFieldMapper.NAME, request.getSlices())) {
        // TODO move the request to the correct node. maybe here or somehow do it as part of startup for reindex in general....
        Request requestForSlice = request.forSlice(parentTaskId, slice);
        ActionListener<BulkByScrollResponse> sliceListener = ActionListener.wrap(
                r -> task.onSliceResponse(listener, slice.source().slice().getId(), r),
                e -> task.onSliceFailure(listener, slice.source().slice().getId(), e));
        client.execute(action, requestForSlice, sliceListener);
    }
}
 

import org.elasticsearch.action.Action; //导入依赖的package包/类
public void testSetsParentId() {
    TaskId[] parentTaskId = new TaskId[] {new TaskId(randomAsciiOfLength(3), randomLong())};

    // This mock will do nothing but verify that parentTaskId is set on all requests sent to it.
    NoOpClient mock = new NoOpClient(getTestName()) {
        @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) {
            assertEquals(parentTaskId[0], request.getParentTask());
            super.doExecute(action, request, listener);
        }
    };
    try (ParentTaskAssigningClient client = new ParentTaskAssigningClient(mock, parentTaskId[0])) {
        // All of these should have the parentTaskId set
        client.bulk(new BulkRequest());
        client.search(new SearchRequest());
        client.clearScroll(new ClearScrollRequest());

        // Now lets verify that unwrapped calls don't have the parentTaskId set
        parentTaskId[0] = TaskId.EMPTY_TASK_ID;
        client.unwrap().bulk(new BulkRequest());
        client.unwrap().search(new SearchRequest());
        client.unwrap().clearScroll(new ClearScrollRequest());
    }
}
 

import org.elasticsearch.action.Action; //导入依赖的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) {
  Tracer.SpanBuilder spanBuilder = tracer.buildSpan(request.getClass().getSimpleName())
      .withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT);

  Span span = spanBuilder.start();
  SpanDecorator.onRequest(span);

  ActionListener<Response> actionFuture = new TracingResponseListener<>(listener, span);
  super.doExecute(action, request, actionFuture);
}
 

import org.elasticsearch.action.Action; //导入依赖的package包/类
@Override
public void readFrom(StreamInput in) throws IOException {
    super.readFrom(in);
    store = in.readString();
    routing = in.readOptionalString();
    action = Action.values()[in.readVInt()];
    storableElement = in.readNamedWriteable(StorableElement.class);
    validation = in.readOptionalWriteable(FeatureValidation::new);
}
 

import org.elasticsearch.action.Action; //导入依赖的package包/类
@Override
public <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> void execute(
		Action<Request, Response, RequestBuilder> action, Request request,
		ActionListener<Response> listener) {
	// TODO Auto-generated method stub

}
 

import org.elasticsearch.action.Action; //导入依赖的package包/类
@SuppressWarnings({"unchecked", "rawtypes"})
@Override
public <R extends ActionRequest, T extends ActionResponse, B extends ActionRequestBuilder<R, T, B>>
void doExecute(Action<R, T, B> action, R request, ActionListener<T> listener) {
    HttpAction httpAction = actionMap.get(action);
    if (httpAction == null) {
        throw new IllegalStateException("failed to find http action [" + action + "] to execute");
    }
    try {
        HttpContext httpContext = new HttpContext(httpAction, listener, request);
        httpContext.httpRequest = httpAction.createHttpRequest(url, request);
        ChannelFuture future = bootstrap.connect(new InetSocketAddress(url.getHost(), url.getPort()));
        future.awaitUninterruptibly();
        if (!future.isSuccess()) {
            bootstrap.releaseExternalResources();
            logger.error("can't connect to {}", url);
        } else {
            Channel channel = future.getChannel();
            httpContext.setChannel(channel);
            httpContextMap.put(channel, httpContext);
            channel.getConfig().setConnectTimeoutMillis(settings.getAsInt("http.client.timeout", 5000));
            httpAction.execute(httpContext, listener);
        }
    } catch (IOException e) {
        logger.error(e.getMessage(), e);
    }
}
 

import org.elasticsearch.action.Action; //导入依赖的package包/类
@Override
public <RequestT extends ActionRequest, ResponseT extends ActionResponse,
    RequestBuilderT extends ActionRequestBuilder<RequestT, ResponseT, RequestBuilderT>> ActionFuture<ResponseT> execute(
    Action<RequestT, ResponseT, RequestBuilderT> action, RequestT request)
{
    return null;
}
 

import org.elasticsearch.action.Action; //导入依赖的package包/类
@Override
public <RequestT extends ActionRequest, ResponseT extends ActionResponse,
    RequestBuilderT extends ActionRequestBuilder<RequestT, ResponseT, RequestBuilderT>> RequestBuilderT prepareExecute(
    Action<RequestT, ResponseT, RequestBuilderT> action)
{
    return null;
}