/** * @return Closures processor. */ public GridClosureProcessor closures() { return ctx.closure(); }
/** * Executes query runnable. */ void execute() { fut = ctx.closure().runLocalSafe(run, true); }
/** {@inheritDoc} */ @Override public void listenAsync(final GridInClosure<? super GridFuture<T>> lsnr) { if (ctx == null) throw new IllegalStateException("Cannot attach listener to deserialized future (context is null): " + this); if (lsnr != null) { if (syncNotify) lsnr.apply(this); else ctx.closure().runLocalSafe(new GPR() { @Override public void run() { lsnr.apply(GridFinishedFuture.this); } }, true); } }
/** {@inheritDoc} */ @Override public <R> GridFuture<Collection<R>> broadcast(Callable<R> job) { A.notNull(job, "job"); guard(); try { return ctx.closure().callAsync(BROADCAST, Arrays.asList(job), prj.nodes()); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <R, T> GridFuture<Collection<R>> broadcast(GridClosure<T, R> job, @Nullable T arg) { A.notNull(job, "job"); guard(); try { return ctx.closure().broadcast(job, arg, prj.nodes()); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <R, T> GridFuture<R> apply(GridClosure<T, R> job, @Nullable T arg) { A.notNull(job, "job"); guard(); try { return ctx.closure().callAsync(job, arg, prj.nodes()); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <R> GridFuture<R> callLocal(Callable<R> c) { A.notNull(c, "c"); guard(); try { return ctx.closure().callLocalSafe(c, false); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public GridFuture<?> runLocal(Runnable r) { A.notNull(r, "r"); guard(); try { return ctx.closure().runLocalSafe(r, false); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <T, R> GridFuture<Collection<R>> apply(final GridClosure<T, R> job, @Nullable Collection<? extends T> args) { A.notNull(job, "job"); A.notNull(args, "args"); guard(); try { return ctx.closure().callAsync(job, args, prj.nodes()); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public GridFuture<?> affinityRun(@Nullable String cacheName, Object affKey, Runnable job) { A.notNull(affKey, "affKey"); A.notNull(job, "job"); guard(); try { return ctx.closure().affinityRun(cacheName, affKey, job, prj.nodes()); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <R> GridFuture<R> affinityCall(@Nullable String cacheName, Object affKey, Callable<R> job) { A.notNull(affKey, "affKey"); A.notNull(job, "job"); guard(); try { return ctx.closure().affinityCall(cacheName, affKey, job, prj.nodes()); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public GridFuture<?> broadcast(Runnable job) { A.notNull(job, "job"); guard(); try { return ctx.closure().runAsync(BROADCAST, job, prj.nodes()); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public GridFuture<?> run(Runnable job) { A.notNull(job, "job"); guard(); try { return ctx.closure().runAsync(BALANCE, job, prj.nodes()); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public GridFuture<?> run(Collection<? extends Runnable> jobs) { A.notEmpty(jobs, "jobs"); guard(); try { return ctx.closure().runAsync(BALANCE, jobs, prj.nodes()); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <R> GridFuture<R> call(Callable<R> job) { A.notNull(job, "job"); guard(); try { return ctx.closure().callAsync(BALANCE, job, prj.nodes()); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <R> GridFuture<Collection<R>> call(Collection<? extends Callable<R>> jobs) { A.notEmpty(jobs, "jobs"); guard(); try { return ctx.closure().callAsync(BALANCE, jobs, prj.nodes()); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <R1, R2> GridFuture<R2> call(Collection<? extends Callable<R1>> jobs, GridReducer<R1, R2> rdc) { A.notEmpty(jobs, "jobs"); A.notNull(rdc, "rdc"); guard(); try { return ctx.closure().forkjoinAsync(BALANCE, jobs, rdc, prj.nodes()); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public void onEvent(GridEvent evt) { assert evt.type() == EVT_NODE_FAILED || evt.type() == EVT_NODE_LEFT; final UUID nodeId = ((GridDiscoveryEvent)evt).eventNode().id(); ctx.closure().runLocalSafe(new Runnable() { @Override public void run() { if (!lock.tryReadLock()) return; try { for (GridTaskWorker<?, ?> task : tasks.values()) task.onNodeLeft(nodeId); } finally { lock.readUnlock(); } } }, false); } }
/** {@inheritDoc} */ @Override public <R1, R2, T> GridFuture<R2> apply(GridClosure<T, R1> job, Collection<? extends T> args, GridReducer<R1, R2> rdc) { A.notNull(job, "job"); A.notNull(rdc, "rdc"); A.notNull(args, "args"); guard(); try { return ctx.closure().callAsync(job, args, rdc, prj.nodes()); } finally { unguard(); } }
/** * Executes given closure either locally or on specified node. * * @param destId Destination node ID. * @param cacheName Cache name. * @param c Closure to execute. * @return Execution future. */ private GridFuture<GridRestResponse> execute(UUID destId, String cacheName, Callable<GridRestResponse> c) { boolean locExec = destId == null || destId.equals(ctx.localNodeId()) || replicatedCacheAvailable(cacheName); if (locExec) return ctx.closure().callLocalSafe(c, false); else { if (ctx.discovery().node(destId) == null) return new GridFinishedFutureEx<>(new GridException("Destination node ID has left the grid (retry " + "the query): " + destId)); return ctx.grid().forNodeId(destId).compute().withNoFailover().call(c); } }