switch (type) { case OP_SEND: messaging.send(reader.readObjectDetached(), reader.readObjectDetached()); messaging.send(reader.readObjectDetached(), PlatformUtils.readCollection(reader)); messaging.sendOrdered(reader.readObjectDetached(), reader.readObjectDetached(), reader.readLong()); messaging.localListen(topic, filter); messaging.stopLocalListen(topic, filter); messaging.stopRemoteListen(reader.readUuid()); readAndListenFuture(reader, messaging.stopRemoteListenAsync(reader.readUuid()));
rmtMsg.remoteListen("MyOrderedTopic", new MessageListener()); rmtMsg.send("MyOrderedTopic", o); rmtMsg.sendOrdered("MyOrderedTopic", o, 0); rmtMsg.remoteListen(topic, new MessageListener()); rmtMsg.send(topic, topic); rmtMsg.sendOrdered(topic, topic, 0);
/** * Starts TensorFlow cluster. */ private void startCluster() { TensorFlowCluster cluster = clusterMgr.createCluster( clusterId, jobArchive, str -> ignite.message().sendOrdered("us_out_" + clusterId, str, 60 * 1000), str -> ignite.message().sendOrdered("us_err_" + clusterId, str, 60 * 1000) ); ignite.message().send(topicName, Optional.of(cluster)); }
/** * @param nodeSnd Sender Ignite node. * @param grp Cluster group. * @param msg Message. * @param async Async message send flag. */ private void sendMessage(Ignite nodeSnd, ClusterGroup grp, Object msg, boolean async) { if (async) nodeSnd.message(grp).withAsync().send(MESSAGE_TOPIC, msg); else nodeSnd.message(grp).send(MESSAGE_TOPIC, msg); }
grid().message().localListen(null, new MessagingListenActor<String>() { @Override protected void receive(UUID nodeId, String rcvMsg) { System.out.println(Thread.currentThread().getName() + "# Received message: '" + rcvMsg + "'"); String msg = "MESSAGE " + i; grid().message().send(null, msg);
/** * Stops TensorFlow cluster. * * @param terminate Terminate TensorFlow cluster and notify all listeners that cluster won't be started again. */ private void stopCluster(boolean terminate) { clusterMgr.stopClusterIfExists(clusterId); if (terminate) ignite.message().send(topicName, Optional.empty()); }
/** * Single server test with local listener. * @throws Exception If failed. */ private void localListenerInternal() throws Exception { int messages = MSGS; Ignite ignite = grid(SERVER_NODE_IDX); LATCH = new CountDownLatch(messages); ClusterGroup grp = grid(SERVER_NODE_IDX).cluster().forLocal(); MessageListener c = new MessageListener(); try { ignite.message(grp).localListen("localListenerTopic", c); for (int i = 0; i < messages; i++) ignite.message(grp).send("localListenerTopic", value(i)); assertTrue(LATCH.await(10, TimeUnit.SECONDS)); } finally { ignite.message().stopLocalListen("localListenerTopic", c); } }
/** * @param masterName Node name * @throws Exception If failed. */ private void testDataExchange(String masterName) throws Exception { startServerNodes(2); startClientNodes(2); checkNodes(2, 2); IgniteMessaging msg = grid(masterName).message(); UUID id = msg.remoteListen(null, new MessageListener()); try { msgLatch = new CountDownLatch(2); msg.send(null, "Message 1"); await(msgLatch); startServerNodes(1); startClientNodes(1); checkNodes(3, 3); msgLatch = new CountDownLatch(3); msg.send(null, "Message 2"); await(msgLatch); } finally { msg.stopRemoteListen(id); } }
ignite2.message().remoteListen(S_TOPIC_1, new P2<UUID, Object>() { @Override public boolean apply(UUID nodeId, Object msg) { try { message(ignite1.cluster().forRemotes()).send(S_TOPIC_1, Collections.singleton(rcCls.newInstance()));
assertFalse(ignite2.message().isAsync()); final IgniteMessaging msg = ignite2.message().withAsync(); assertTrue(msg.isAsync()); assertFalse(ignite2.message().isAsync()); UUID id = msg.remoteListen(topic, new P2<UUID, Object>() { @Override public boolean apply(UUID nodeId, Object msg) { System.out.println(Thread.currentThread().getName() + IgniteFuture<UUID> starFut = msg.future(); message(ignite1.cluster().forRemotes()).send(topic, "msg1"); msg.stopRemoteListen(id); IgniteFuture<?> stopFut = msg.future(); message(ignite1.cluster().forRemotes()).send(topic, "msg2");
UUID opId = client.message().remoteListen(topic, new RemoteMessageListener()); client.message().localListen(topic, locLsnr); latch = new CountDownLatch(2); client.message().send(topic, "msg1"); latch = new CountDownLatch(2); srv.message().send(topic, "msg2"); stopFrom.message().stopRemoteListen(opId); srv.message().send(topic, "msg3"); srv.message().send(topic, "msg4");
final AtomicReference<String> val = new AtomicReference<>(); igniteMsg.localListen(TOPIC, new IgniteBiPredicate<UUID, String>() { @Override public boolean apply(UUID uuid, String msgStr) { thread.set(Thread.currentThread()); igniteMsg.withAsync().send(TOPIC, msgStr); else igniteMsg.send(TOPIC, msgStr);
TensorFlowClusterGateway gateway = getCluster(clusterId); ignite.message().localListen("us_out_" + clusterId, (node, msg) -> { out.accept(msg.toString()); return true; }); ignite.message().localListen("us_err_" + clusterId, (node, msg) -> { err.accept(msg.toString()); return true;
g.message().remoteListen(null, new MessagingListenActor<String>() { @Override protected void receive(UUID nodeId, String rcvMsg) throws Throwable { if (hello.equals(rcvMsg)) { g.message().localListen(null, new P2<UUID, String>() { @Override public boolean apply(UUID nodeId, String msg) { if (msg.equals(bye)) g.message().send(null, hello);
/** * Creates TensorFlow cluster gateway. * * @param topicName Topic name. * @return TensorFlow cluster gateway. */ private TensorFlowClusterGateway createTensorFlowClusterGateway(String topicName) { TensorFlowClusterGateway gateway = new TensorFlowClusterGateway(subscriber -> { ignite.message().stopLocalListen(topicName, subscriber); log.info("Stop listen to cluster gateway [topicName=" + topicName + "]"); }); ignite.message().localListen(topicName, gateway); log.info("Start listen to cluster gateway [topicName=" + topicName + "]"); return gateway; } }
/** * @param igniteMsg Ignite message. * @param msgs messages for send. * @param cls Callback for compare result. * @throws Exception If failed. */ private<T> void sendOrdered( final IgniteMessaging igniteMsg, final List<T> msgs, final IgniteBiInClosure<List<T>,List<Thread>> cls ) throws Exception { final CountDownLatch latch = new CountDownLatch(msgs.size()); final List<T> received = Lists.newArrayList(); final List<Thread> threads = Lists.newArrayList(); for (T msg : msgs) igniteMsg.sendOrdered(TOPIC, msg, 1000); igniteMsg.localListen(TOPIC, new IgniteBiPredicate<UUID, T>() { @Override public boolean apply(UUID uuid, T s) { received.add(s); threads.add(Thread.currentThread()); latch.countDown(); return true; } }); latch.await(); cls.apply(received, threads); }
/** * @param ignite Ignite. * @param grp Cluster group. * @throws Exception If fail. */ private void registerListenerAndSendOrderedMessages(Ignite ignite, ClusterGroup grp) throws Exception { int messages = MSGS; LATCH = new CountDownLatch(grp.nodes().size() * messages); UUID opId = ignite.message(grp).remoteListen(MESSAGE_TOPIC, new OrderedMessageListener()); try { for (int i=0; i < messages; i++) ignite.message(grp).sendOrdered(MESSAGE_TOPIC, value(i), 2000); assertTrue(LATCH.await(10, TimeUnit.SECONDS)); } finally { ignite.message().stopRemoteListen(opId); } }
IgniteFuture<UUID> starFut = ignite2.message().remoteListenAsync(topic, new P2<UUID, Object>() { @Override public boolean apply(UUID nodeId, Object msg) { System.out.println(Thread.currentThread().getName() + message(ignite1.cluster().forRemotes()).send(topic, "msg1"); IgniteFuture<?> stopFut = ignite2.message().stopRemoteListenAsync(id); message(ignite1.cluster().forRemotes()).send(topic, "msg2");
ignite2.message().remoteListen(S_TOPIC_1, new P2<UUID, Object>() { @Override public boolean apply(UUID nodeId, Object msg) { try { message(prj2).sendOrdered(S_TOPIC_1, msg, 15000);