/** * Execute an {@link Action} locally, returning that {@link Task} used to track it, and linking an {@link TaskListener}. Prefer this * method if you need access to the task when listening for the response. */ public < Request extends ActionRequest, Response extends ActionResponse > Task executeLocally(GenericAction<Request, Response> action, Request request, TaskListener<Response> listener) { return transportAction(action).execute(request, listener); }
/** * Execute an {@link Action} locally, returning that {@link Task} used to track it, and linking an {@link ActionListener}. Prefer this * method if you don't need access to the task when listening for the response. This is the method used to implement the {@link Client} * interface. */ public < Request extends ActionRequest, Response extends ActionResponse > Task executeLocally(GenericAction<Request, Response> action, Request request, ActionListener<Response> listener) { return transportAction(action).execute(request, listener); }
public final ActionFuture<Response> execute(Request request) { PlainActionFuture<Response> future = newFuture(); execute(request, future); return future; }
/** * 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; }
searchAction.execute(request.request, new ActionListener<SearchResponse>() { @Override public void onResponse(final SearchResponse searchResponse) {
/** * Execute an {@link Action} locally, returning that {@link Task} used to track it, and linking an {@link ActionListener}. Prefer this * method if you don't need access to the task when listening for the response. This is the method used to implement the {@link Client} * interface. */ public < Request extends ActionRequest, Response extends ActionResponse > Task executeLocally(GenericAction<Request, Response> action, Request request, ActionListener<Response> listener) { return transportAction(action).execute(request, listener); }
public final ActionFuture<Response> execute(Request request) { PlainActionFuture<Response> future = newFuture(); execute(request, future); return future; }
/** * Execute an {@link Action} locally, returning that {@link Task} used to track it, and linking an {@link ActionListener}. Prefer this * method if you don't need access to the task when listening for the response. This is the method used to implement the {@link Client} * interface. */ public < Request extends ActionRequest, Response extends ActionResponse > Task executeLocally(GenericAction<Request, Response> action, Request request, ActionListener<Response> listener) { return transportAction(action).execute(request, listener); }
public final ActionFuture<Response> execute(Request request) { PlainActionFuture<Response> future = newFuture(); execute(request, future); return future; }
/** * Execute an {@link Action} locally, returning that {@link Task} used to track it, and linking an {@link TaskListener}. Prefer this * method if you need access to the task when listening for the response. */ public < Request extends ActionRequest, Response extends ActionResponse > Task executeLocally(GenericAction<Request, Response> action, Request request, TaskListener<Response> listener) { return transportAction(action).execute(request, listener); }
/** * Execute an {@link Action} locally, returning that {@link Task} used to track it, and linking an {@link TaskListener}. Prefer this * method if you need access to the task when listening for the response. */ public < Request extends ActionRequest, Response extends ActionResponse > Task executeLocally(GenericAction<Request, Response> action, Request request, TaskListener<Response> listener) { return transportAction(action).execute(request, listener); }
public final ActionFuture<Response> execute(Request request) { PlainActionFuture<Response> future = newFuture(); execute(request, future); return future; }
public final ActionFuture<Response> execute(Request request) { PlainActionFuture<Response> future = newFuture(); execute(request, future); return future; }
@SuppressWarnings("unchecked") @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) { TransportAction<Request, Response> transportAction = actions.get(action); if (transportAction == null) { throw new IllegalStateException("failed to find action [" + action + "] to execute"); } transportAction.execute(request, listener); } }
public final Task execute(Request request, final TaskListener<Response> listener) { final 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(Throwable e) { if (task != null) { taskManager.unregister(task); } listener.onFailure(task, e); } }); return task; }
/** * 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; }
/** * 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; }
/** * 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; }