/** * 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); }
protected abstract void doExecute(Request request, ActionListener<Response> 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); }
@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); } }
public final ActionFuture<Response> execute(Request request) { PlainActionFuture<Response> future = newFuture(); execute(request, future); return future; }
protected abstract void doExecute(Request request, ActionListener<Response> listener);
protected abstract void doExecute(Request request, ActionListener<Response> listener);
/** * 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; }
protected abstract void doExecute(Request request, ActionListener<Response> listener);
searchAction.execute(request.request, new ActionListener<SearchResponse>() { @Override public void onResponse(final SearchResponse searchResponse) {
protected abstract void doExecute(Request request, ActionListener<Response> 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); }
@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); } }
public final ActionFuture<Response> execute(Request request) { PlainActionFuture<Response> future = newFuture(); execute(request, future); return future; }
@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); } }
/** * 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); }
@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); } }
/** * 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); }
@Override @SuppressWarnings("unchecked") public void proceed(Task task, String actionName, ActionRequest request, ActionListener 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) request, new FilteredActionListener<Response>(actionName, listener, new ResponseFilterChain(this.action.filters, logger))); } else { listener.onFailure(new IllegalStateException("proceed was called too many times")); } } catch(Throwable t) { logger.trace("Error during transport action execution.", t); listener.onFailure(t); } }