/** * 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; }
Task task = taskManager.register("transport", actionName, request); if (task == null) { execute(null, request, listener);
public void processMessageReceived(Request request, TransportChannel channel) throws Exception { final Task task = taskManager.register(channel.getChannelType(), action, request); if (task == null) { handler.messageReceived(request, channel); } else { boolean success = false; try { handler.messageReceived(request, new TaskTransportChannel(taskManager, task, channel), task); success = true; } finally { if (success == false) { taskManager.unregister(task); } } } }
private void resync(final ShardId shardId, final String primaryAllocationId, final long primaryTerm, final Translog.Snapshot snapshot, long startingSeqNo, long maxSeqNo, long maxSeenAutoIdTimestamp, ActionListener<ResyncTask> listener) { ResyncRequest request = new ResyncRequest(shardId, primaryAllocationId); ResyncTask resyncTask = (ResyncTask) taskManager.register("transport", "resync", request); // it's not transport :-) ActionListener<Void> wrappedListener = new ActionListener<Void>() { @Override public void onResponse(Void ignore) { resyncTask.setPhase("finished"); taskManager.unregister(resyncTask); listener.onResponse(resyncTask); } @Override public void onFailure(Exception e) { resyncTask.setPhase("finished"); taskManager.unregister(resyncTask); listener.onFailure(e); } }; try { new SnapshotSender(logger, syncAction, resyncTask, shardId, primaryAllocationId, primaryTerm, snapshot, chunkSize.bytesAsInt(), startingSeqNo, maxSeqNo, maxSeenAutoIdTimestamp, wrappedListener).run(); } catch (Exception e) { wrappedListener.onFailure(e); } }
AllocatedPersistentTask task = (AllocatedPersistentTask) taskManager.register("persistent", taskInProgress.getTaskName() + "[c]", request); boolean processed = false;
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; }
@Override public Task register(String type, String action, TaskAwareRequest 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; }
Task task = taskManager.register("transport", actionName, request); if (task == null) { execute(null, request, listener);
/** * Use this method when the transport action call should result in creation of a new task associated with the call. * * This is a typical behavior. */ public final Task execute(Request request, final ActionListener<Response> listener) { /* * While this version of execute could delegate to the TaskListener version of execute that'd add yet another layer of wrapping on * the listener and prevent us from using the listener bare if there isn't a task. That just seems like too many objects. Thus the * two versions of this method. */ final Task task = taskManager.register("transport", actionName, request); if (task == null) { execute(null, request, listener); } else { execute(task, request, new ActionListener<Response>() { @Override public void onResponse(Response response) { taskManager.unregister(task); listener.onResponse(response); } @Override public void onFailure(Throwable e) { taskManager.unregister(task); listener.onFailure(e); } }); } return task; }
Task task = taskManager.register("transport", actionName, request); if (task == null) { execute(null, request, listener);
Task task = taskManager.register("transport", actionName, request); if (task == null) { execute(null, request, listener);
public void processMessageReceived(Request request, TransportChannel channel) throws Exception { final Task task = taskManager.register(channel.getChannelType(), action, request); if (task == null) { handler.messageReceived(request, channel); } else { boolean success = false; try { handler.messageReceived(request, new TaskTransportChannel(taskManager, task, channel), task); success = true; } finally { if (success == false) { taskManager.unregister(task); } } } }
public void processMessageReceived(Request request, TransportChannel channel) throws Exception { final Task task = taskManager.register(channel.getChannelType(), action, request); if (task == null) { handler.messageReceived(request, channel); } else { boolean success = false; try { handler.messageReceived(request, new TransportChannelWrapper(taskManager, task, channel), task); success = true; } finally { if (success == false) { taskManager.unregister(task); } } } }
public void processMessageReceived(Request request, TransportChannel channel) throws Exception { final Task task = taskManager.register(channel.getChannelType(), action, request); if (task == null) { handler.messageReceived(request, channel); } else { boolean success = false; try { handler.messageReceived(request, new TransportChannelWrapper(taskManager, task, channel), task); success = true; } finally { if (success == false) { taskManager.unregister(task); } } } }
public void processMessageReceived(Request request, TransportChannel channel) throws Exception { final Task task = taskManager.register(channel.getChannelType(), action, request); if (task == null) { handler.messageReceived(request, channel); } else { boolean success = false; try { handler.messageReceived(request, new TaskTransportChannel(taskManager, task, channel), task); success = true; } finally { if (success == false) { taskManager.unregister(task); } } } }
private void resync(final ShardId shardId, final String primaryAllocationId, final long primaryTerm, final Translog.Snapshot snapshot, long startingSeqNo, long maxSeqNo, long maxSeenAutoIdTimestamp, ActionListener<ResyncTask> listener) { ResyncRequest request = new ResyncRequest(shardId, primaryAllocationId); ResyncTask resyncTask = (ResyncTask) taskManager.register("transport", "resync", request); // it's not transport :-) ActionListener<Void> wrappedListener = new ActionListener<Void>() { @Override public void onResponse(Void ignore) { resyncTask.setPhase("finished"); taskManager.unregister(resyncTask); listener.onResponse(resyncTask); } @Override public void onFailure(Exception e) { resyncTask.setPhase("finished"); taskManager.unregister(resyncTask); listener.onFailure(e); } }; try { new SnapshotSender(logger, syncAction, resyncTask, shardId, primaryAllocationId, primaryTerm, snapshot, chunkSize.bytesAsInt(), startingSeqNo, maxSeqNo, maxSeenAutoIdTimestamp, wrappedListener).run(); } catch (Exception e) { wrappedListener.onFailure(e); } }
private void resync(final ShardId shardId, final String primaryAllocationId, final long primaryTerm, final Translog.Snapshot snapshot, long startingSeqNo, long maxSeqNo, ActionListener<ResyncTask> listener) { ResyncRequest request = new ResyncRequest(shardId, primaryAllocationId); ResyncTask resyncTask = (ResyncTask) taskManager.register("transport", "resync", request); // it's not transport :-) ActionListener<Void> wrappedListener = new ActionListener<Void>() { @Override public void onResponse(Void ignore) { resyncTask.setPhase("finished"); taskManager.unregister(resyncTask); listener.onResponse(resyncTask); } @Override public void onFailure(Exception e) { resyncTask.setPhase("finished"); taskManager.unregister(resyncTask); listener.onFailure(e); } }; try { new SnapshotSender(logger, syncAction, resyncTask, shardId, primaryAllocationId, primaryTerm, snapshot, chunkSize.bytesAsInt(), startingSeqNo, maxSeqNo, wrappedListener).run(); } catch (Exception e) { wrappedListener.onFailure(e); } }