/** * @throws Exception In case of error. */ @Test public void testAddRemoveDiscoListener() throws Exception { IgnitePredicate<Event> lsnr = new IgnitePredicate<Event>() { @Override public boolean apply(Event evt) { info("Received local event: " + evt); return true; } }; ignite1.events().localListen(lsnr, EVT_NODE_LEFT, EVT_NODE_FAILED); assert ignite1.events().stopLocalListen(lsnr); assert !ignite1.events().stopLocalListen(lsnr); }
IgniteEvents evtAsync = grid(0).events().withAsync(); evtAsync.stopRemoteListen(null); evtAsync.future().get(); evtAsync.stopRemoteListen(UUID.randomUUID()); evtAsync.future().get(); evtAsync.remoteListen( new P2<UUID, DiscoveryEvent>() { @Override public boolean apply(UUID uuid, DiscoveryEvent evt) { consumeId = (UUID)evtAsync.future().get(); evtAsync.stopRemoteListen(consumeId); evtAsync.future().get(); evtAsync.remoteListen( new P2<UUID, DiscoveryEvent>() { @Override public boolean apply(UUID uuid, DiscoveryEvent evt) { consumeId = (UUID)evtAsync.future().get(); evtAsync.stopRemoteListen(consumeId); evtAsync.future().get(); evtAsync.remoteListen( new P2<UUID, Event>() { @Override public boolean apply(UUID uuid, Event evt) {
/** {@inheritDoc} */ @Override public long processInStreamOutLong(int type, BinaryRawReaderEx reader) throws IgniteCheckedException { switch (type) { case OP_RECORD_LOCAL: // TODO: IGNITE-1410. return TRUE; case OP_ENABLE_LOCAL: events.enableLocal(readEventTypes(reader)); return TRUE; case OP_DISABLE_LOCAL: events.disableLocal(readEventTypes(reader)); return TRUE; case OP_STOP_REMOTE_LISTEN: events.stopRemoteListen(reader.readUuid()); return TRUE; case OP_LOCAL_LISTEN: events.localListen(localFilter(reader.readLong()), reader.readInt()); return TRUE; case OP_REMOTE_QUERY_ASYNC: readAndListenFuture(reader, startRemoteQueryAsync(reader, events), eventColResWriter); return TRUE; case OP_WAIT_FOR_LOCAL_ASYNC: { readAndListenFuture(reader, startWaitForLocalAsync(reader, events), eventResWriter); return TRUE; } default: return super.processInStreamOutLong(type, reader); } }
/** {@inheritDoc} */ @Override public long processInLongOutLong(int type, long val) throws IgniteCheckedException { switch (type) { case OP_IS_ENABLED: return events.isEnabled((int)val) ? TRUE : FALSE; case OP_STOP_LOCAL_LISTEN: return events.stopLocalListen(localFilter(val)) ? TRUE : FALSE; } return super.processInLongOutLong(type, val); }
/** * @param ignite Node. * @param cache Cache. * @param async Use async API. * @param oldAsync Use old async API. * @throws Exception If failed. */ private void doTransformResourceInjection(Ignite ignite, IgniteCache<String, Integer> cache, boolean async, boolean oldAsync) throws Exception { final Collection<ResourceType> required = Arrays.asList(ResourceType.IGNITE_INSTANCE, ResourceType.CACHE_NAME, ResourceType.LOGGER); final CacheEventListener lsnr = new CacheEventListener(); IgniteEvents evts = ignite.events(ignite.cluster()); UUID opId = evts.remoteListen(lsnr, null, EventType.EVT_CACHE_OBJECT_READ); try { checkResourceInjectionOnInvoke(cache, required, async, oldAsync); checkResourceInjectionOnInvokeAll(cache, required, async, oldAsync); checkResourceInjectionOnInvokeAllMap(cache, required, async, oldAsync); } finally { evts.stopRemoteListen(opId); } }
/** */ private EventCounter(int cnt) { this.cnt = new AtomicInteger(cnt); this.execLatch = new CountDownLatch(NODE_COUNT); for (int i = 0; i < NODE_COUNT; i++) grid(i).events().localListen(pred, EVT_CACHE_QUERY_EXECUTED); }
/** * @throws Exception If test failed. */ private void testExternalClassesAtEvent0(boolean p2p) throws Exception { try { useExtClassLoader = true; cutromEvt = true; if (p2p) disableP2p = true; final Class cls = (Class)getExternalClassLoader(). loadClass("org.apache.ignite.tests.p2p.CacheDeploymentExternalizableTestValue"); final Class cls2 = (Class)getExternalClassLoader(). loadClass("org.apache.ignite.tests.p2p.GridEventConsumeFilter"); Ignite g1 = startGrid(1); startGrid(2); latch = new CountDownLatch(3); g1.events().localListen((IgnitePredicate)cls2.newInstance(), EVT_CACHE_OBJECT_PUT); g1.events().localListen(new EventListener(), EVT_CACHE_OBJECT_PUT); g1.events().remoteListen(null, (IgnitePredicate)cls2.newInstance(), EVT_CACHE_OBJECT_PUT); g1.events().remoteListen(null, new EventListener(), EVT_CACHE_OBJECT_PUT); g1.cache(DEFAULT_CACHE_NAME).put("1", cls.newInstance()); latch.await(); } finally { useExtClassLoader = false; cutromEvt = false; if (p2p) disableP2p = false; } }
ignite1.events().localListen(lsnr, EVT_TASK_STARTED); ignite1.events().localListen(lsnr, EVT_TASK_STARTED); Collection<Event> evts = ignite1.events().localQuery(filter); assert ignite1.events().stopLocalListen(lsnr); assert !ignite1.events().stopLocalListen(lsnr); evts = ignite1.events().localQuery(filter); events(ignite1.cluster().forPredicate(F.<ClusterNode>alwaysFalse())).remoteQuery(filter, 0);
/** * @throws Exception In case of error. */ @Test public void testGridInternalEvents() throws Exception { IgnitePredicate<Event> lsnr = new IgnitePredicate<Event>() { @Override public boolean apply(Event evt) { checkGridInternalEvent(evt); return true; } }; ignite1.events().localListen(lsnr, EVTS_TASK_EXECUTION); ignite1.events().localListen(lsnr, EVTS_JOB_EXECUTION); ignite2.events().localListen(lsnr, EVTS_TASK_EXECUTION); ignite2.events().localListen(lsnr, EVTS_JOB_EXECUTION); executeGridInternalTask(ignite1); Collection<Event> evts1 = ignite1.events().localQuery(F.<Event>alwaysTrue()); Collection<Event> evts2 = ignite2.events().localQuery(F.<Event>alwaysTrue()); assert evts1 != null; assert evts2 != null; for (Event evt : evts1) checkGridInternalEvent(evt); for (Event evt : evts2) checkGridInternalEvent(evt); assert ignite1.events().stopLocalListen(lsnr, EVTS_TASK_EXECUTION); assert ignite1.events().stopLocalListen(lsnr, EVTS_JOB_EXECUTION); assert ignite2.events().stopLocalListen(lsnr, EVTS_TASK_EXECUTION); assert ignite2.events().stopLocalListen(lsnr, EVTS_JOB_EXECUTION); }
/** {@inheritDoc} */ @Override public void close() throws Exception { for (int i = 0; i < NODE_COUNT; i++) grid(i).events().stopLocalListen(pred); } }
UUID opId = client.events().remoteListen(lsnr, null, EventType.EVT_JOB_STARTED); client.events().localListen(new IgnitePredicate<Event>() { @Override public boolean apply(Event evt) { if (evt.type() == EVT_CLIENT_NODE_RECONNECTED) { client.events().stopRemoteListen(opId);
/** * Add event listener to passed Ignite instances for cache event types. * * @param igns Ignite instances. */ private void registerEventListeners(Ignite... igns) { if (igns != null) { for (Ignite ign : igns) { ign.events().enableLocal(CACHE_EVENT_TYPES); ign.events().localListen((IgnitePredicate<Event>)event -> { CacheEvent cacheEvt = (CacheEvent)event; if (!TX_LABEL.equals(cacheEvt.txLabel())) { log.error("Has been received event with incorrect label " + cacheEvt.txLabel() + " ," + " expected " + TX_LABEL + " label"); wrongEvts.add(cacheEvt); } return true; }, CACHE_EVENT_TYPES); } } }
/** * Node fail itself. * * @throws Exception If failed. */ @Test public void testMassiveFailSelfKill() throws Exception { startGrids(5); grid(0).events().enabledEvents(); CountDownLatch latch = new CountDownLatch(1); grid(0).events().localListen((e) -> { DiscoveryEvent evt = (DiscoveryEvent)e; if (evt.eventNode().equals(compromisedNode)) latch.countDown(); return true; }, EventType.EVT_NODE_FAILED); compromisedNode = (TcpDiscoveryNode)grid(2).localNode(); for (int i = 3; i < 5; i++) failedAddrs.addAll(((TcpDiscoveryNode)grid(i).localNode()).socketAddresses()); System.out.println(">> Start failing nodes"); forceFailConnectivity = true; assert latch.await(waitTime(), TimeUnit.MILLISECONDS); assertEquals(4, grid(0).cluster().forServers().nodes().size()); }
/** * @throws Exception If failed. */ @Test public void testDisableWithIncludes() throws Exception { inclEvtTypes = null; try { Ignite g = startGrid(); g.events().enableLocal(EVT_TASK_STARTED, EVT_TASK_FINISHED, EVT_JOB_STARTED); final AtomicInteger cnt = new AtomicInteger(); g.events().localListen(new IgnitePredicate<Event>() { @Override public boolean apply(Event evt) { cnt.incrementAndGet(); return true; } }, EVT_TASK_STARTED, EVT_TASK_FINISHED, EVT_JOB_STARTED); g.compute().run(F.noop()); assertEquals(3, cnt.get()); g.events().disableLocal(EVT_TASK_STARTED, EVT_TASK_FINISHED, EVT_JOB_FAILED); g.compute().run(F.noop()); assertEquals(4, cnt.get()); } finally { stopAllGrids(); } }
/** * @param ignite Node. * @param joinEvtCnt Expected events number. * @return Events latch. */ private CountDownLatch expectJoinEvents(Ignite ignite, int joinEvtCnt) { final CountDownLatch latch = new CountDownLatch(joinEvtCnt); ignite.events().remoteListen(new IgniteBiPredicate<UUID, Event>() { @Override public boolean apply(UUID uuid, Event evt) { latch.countDown(); return true; } }, null, EventType.EVT_NODE_JOINED); return latch; } }
if (!evts.isEnabled(EVT_WAL_SEGMENT_ARCHIVED)) fail("nothing to test"); evts.localListen(e -> { WalSegmentArchivedEvent archComplEvt = (WalSegmentArchivedEvent)e;
/** * @throws Exception If failed. */ @Test public void testEnableDisable() throws Exception { inclEvtTypes = null; try { Ignite g = startGrid(); IgniteEvents evts = g.events(); evts.enableLocal(EVT_CACHE_OBJECT_PUT); evts.disableLocal(EVT_CACHE_OBJECT_PUT); for (int evtType : evts.enabledEvents()) assertFalse(evtType == EVT_CACHE_OBJECT_PUT); } finally { stopAllGrids(); } }
@Override public Boolean apply(Object o) { UUID remoteId = (UUID)o; assertNotNull(remoteId); client.events().stopRemoteListen(remoteId); return true; } }
assertEqualsWithoutOrder(inclEvtTypes, getEnabledEvents(1013, g, 30000)); g.events().enableLocal(20000, EVT_TASK_STARTED, EVT_CACHE_ENTRY_CREATED); getEnabledEvents(1013, g, 20000, 30000)); g.events().disableLocal(20000, 20001, 30000, EVT_TASK_STARTED, EVT_CACHE_ENTRY_CREATED); g.events().enableLocal(Arrays.copyOf(a, 1002)); assertEqualsWithoutOrder(Arrays.copyOf(a0, 1004), getEnabledEvents(2013, g, 30000)); g.events().disableLocal(Arrays.copyOf(a, 1002));
/** {@inheritDoc} */ @Override public void processOutStream(int type, BinaryRawWriterEx writer) throws IgniteCheckedException { switch (type) { case OP_GET_ENABLED_EVENTS: writeEventTypes(events.enabledEvents(), writer); break; default: super.processOutStream(type, writer); } }