/** {@inheritDoc} */ @Override public Collection<String> hostNames() { Set<String> res = new HashSet<>(); for (ClusterNode node : nodes()) res.addAll(node.hostNames()); return Collections.unmodifiableSet(res); }
/** {@inheritDoc} */ @Override public ClusterNode node() { return F.first(nodes()); }
/** {@inheritDoc} */ @Override public final ClusterGroup forRandom() { if (!F.isEmpty(ids)) return forNodeId(F.rand(ids)); Collection<ClusterNode> nodes = nodes(); if (nodes.isEmpty()) return new ClusterGroupAdapter(ctx, null, Collections.<UUID>emptySet()); return forNode(F.rand(nodes)); }
/** {@inheritDoc} */ @Override public final ClusterMetrics metrics() { guard(); try { if (nodes().isEmpty()) throw U.convertException(U.emptyTopologyException()); return new ClusterMetricsSnapshot(this); } finally { unguard(); } }
/** * Broadcast implementation. * * @param job Job. * @return Internal future. */ private <R> IgniteInternalFuture<Collection<R>> broadcastAsync0(IgniteCallable<R> job) { A.notNull(job, "job"); guard(); try { return ctx.closure().callAsync(BROADCAST, Collections.singletonList(job), prj.nodes(), execName); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <T extends Event> IgniteFuture<List<T>> remoteQueryAsync(IgnitePredicate<T> p, long timeout, @Nullable int... types) throws IgniteException { guard(); try { return new IgniteFutureImpl<>(ctx.event().remoteEventsAsync(compoundPredicate(p, types), prj.nodes(), timeout)); } finally { unguard(); } }
/** * Apply implementation. * * @param job Job. * @param arg Argument. * @return Internal future. */ private <R, T> IgniteInternalFuture<R> applyAsync0(IgniteClosure<T, R> job, @Nullable T arg) { A.notNull(job, "job"); guard(); try { return ctx.closure().callAsync(job, arg, prj.nodes(), execName); } finally { unguard(); } }
/** * Resets node. */ private synchronized void reset() { guard(); try { long lastTopVer = ctx.discovery().topologyVersion(); ClusterNode node = isOldest ? U.oldest(super.nodes(), null) : U.youngest(super.nodes(), null); IgnitePredicate<ClusterNode> p = F.nodeForNodes(node); state = new AgeClusterGroupState(node, p, lastTopVer); } finally { unguard(); } }
/** * Broadcast implementation. * * @param job Job. * @param arg Argument. * @return Internal future. */ private <R, T> IgniteInternalFuture<Collection<R>> broadcastAsync0(IgniteClosure<T, R> job, @Nullable T arg) { A.notNull(job, "job"); guard(); try { return ctx.closure().broadcast(job, arg, prj.nodes(), execName); } finally { unguard(); } }
/** * Apply implementation. * * @param job Job. * @param args Arguments/ * @return Internal future. */ private <T, R> IgniteInternalFuture<Collection<R>> applyAsync0(final IgniteClosure<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(), execName); } finally { unguard(); } }
/** * Broadcast implementation. * * @param job Job. * @return Internal future. */ private IgniteInternalFuture<?> broadcastAsync0(IgniteRunnable job) { A.notNull(job, "job"); guard(); try { return ctx.closure().runAsync(BROADCAST, job, prj.nodes(), execName); } finally { unguard(); } }
/** * Run implementation. * * @param jobs Jobs. * @return Internal future. */ private IgniteInternalFuture<?> runAsync0(Collection<? extends IgniteRunnable> jobs) { A.notEmpty(jobs, "jobs"); guard(); try { return ctx.closure().runAsync(BALANCE, jobs, prj.nodes(), execName); } finally { unguard(); } }
/** * Call implementation. * * @param job Job. * @return Internal future. */ private <R> IgniteInternalFuture<R> callAsync0(IgniteCallable<R> job) { A.notNull(job, "job"); guard(); try { return ctx.closure().callAsync(BALANCE, job, prj.nodes(), execName); } finally { unguard(); } }
/** * Call implementation. * * @param jobs Jobs. * @return Internal future. */ private <R> IgniteInternalFuture<Collection<R>> callAsync0(Collection<? extends IgniteCallable<R>> jobs) { A.notEmpty(jobs, "jobs"); guard(); try { return ctx.closure().callAsync(BALANCE, (Collection<? extends Callable<R>>)jobs, prj.nodes(), execName); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <T extends Event> List<T> remoteQuery(IgnitePredicate<T> p, long timeout, @Nullable int... types) { A.notNull(p, "p"); guard(); try { return saveOrGet(ctx.event().remoteEventsAsync(compoundPredicate(p, types), prj.nodes(), timeout)); } catch (IgniteCheckedException e) { throw U.convertException(e); } finally { unguard(); } }
/** * Run implementation. * * @param job Job. * @return Internal future. */ private IgniteInternalFuture<?> runAsync0(IgniteRunnable job) { A.notNull(job, "job"); guard(); try { return ctx.closure().runAsync(BALANCE, job, prj.nodes(), execName); } finally { unguard(); } }
/** * Call with reducer implementation. * * @param jobs Jobs. * @param rdc Reducer. * @return Internal future. */ private <R1, R2> IgniteInternalFuture<R2> callAsync0(Collection<? extends IgniteCallable<R1>> jobs, IgniteReducer<R1, R2> rdc) { A.notEmpty(jobs, "jobs"); A.notNull(rdc, "rdc"); guard(); try { return ctx.closure().forkjoinAsync(BALANCE, jobs, rdc, prj.nodes(), execName); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public <T> Future<T> submit(Callable<T> task) { A.notNull(task, "task != null"); checkShutdown(); ctx.gateway().readLock(); try { return addFuture(ctx.closure().callAsync(BALANCE, task, prj.nodes())); } finally { ctx.gateway().readUnlock(); } }
/** {@inheritDoc} */ @Override public Future<?> submit(Runnable task) { A.notNull(task, "task != null"); checkShutdown(); ctx.gateway().readLock(); try { return addFuture(ctx.closure().runAsync(BALANCE, task, prj.nodes())); } finally { ctx.gateway().readUnlock(); } }
/** {@inheritDoc} */ @Override public void execute(Runnable cmd) { A.notNull(cmd, "cmd != null"); checkShutdown(); ctx.gateway().readLock(); try { addFuture(ctx.closure().runAsync(BALANCE, cmd, prj.nodes())); } finally { ctx.gateway().readUnlock(); } }