/** * @param <K> Key type. * @param <V> Value type. * @return New instance of continuous query. */ protected <K, V> AbstractContinuousQuery<K, V> createQuery() { return new ContinuousQuery<>(); }
/** * @param node Node. * @param cacheName Cache name. * @return Received events counter. */ private AtomicInteger registerListener(Ignite node, String cacheName) { ContinuousQuery qry = new ContinuousQuery(); final AtomicInteger cntr = new AtomicInteger(); qry.setLocalListener(new CacheEntryUpdatedListener() { @Override public void onUpdated(Iterable iterable) { for (Object evt : iterable) cntr.incrementAndGet(); } }); node.cache(cacheName).query(qry); return cntr; }
/** * @param cache Cache. * @return Event counter. */ private T2<AtomicInteger, QueryCursor> startListener(IgniteCache<Object, Object> cache) { final AtomicInteger evtCnt = new AtomicInteger(); ContinuousQuery<Object, Object> qry = new ContinuousQuery<>(); qry.setLocalListener(new CacheEntryUpdatedListener<Object, Object>() { @Override public void onUpdated(Iterable<CacheEntryEvent<?, ?>> evts) { for (CacheEntryEvent evt : evts) { assertNotNull(evt.getKey()); assertNotNull(evt.getValue()); if ((Integer)evt.getValue() >= 0) evtCnt.incrementAndGet(); } } }); QueryCursor cur = cache.query(qry); return new T2<>(evtCnt, cur); }
@Override public Object call() throws Exception { int idx = startIdx.getAndIncrement(); Thread.currentThread().setName("start-thread-" + idx); barrier.await(); Ignite ignite = startGrid(idx); assertTrue(ignite.configuration().isClientMode()); log.info("Started node: " + ignite.name()); IgniteCache<Object, Object> cache = ignite.getOrCreateCache(DEFAULT_CACHE_NAME); for (int i = 0; i < 10; i++) { ContinuousQuery<Object, Object> qry = new ContinuousQuery<>(); qry.setLocalListener(new CacheEntryUpdatedListener<Object, Object>() { @Override public void onUpdated(Iterable<CacheEntryEvent<?, ?>> evts) { // No-op. } }); cache.query(qry); } return null; } }, JOIN_NODES, "start-thread");
/** * @throws Exception If failed. */ @Test public void testLoadCache() throws Exception { IgniteCache<Integer, Integer> cache = grid(0).cache(DEFAULT_CACHE_NAME); ContinuousQuery<Integer, Integer> qry = new ContinuousQuery<>(); final Map<Integer, Integer> map = new ConcurrentHashMap<>(); final CountDownLatch latch = new CountDownLatch(10); qry.setLocalListener(new CacheEntryUpdatedListener<Integer, Integer>() { @Override public void onUpdated(Iterable<CacheEntryEvent<? extends Integer, ? extends Integer>> evts) { for (CacheEntryEvent<? extends Integer, ? extends Integer> e : evts) { map.put(e.getKey(), e.getValue()); latch.countDown(); } } }); try (QueryCursor<Cache.Entry<Integer, Integer>> ignored = cache.query(qry)) { cache.loadCache(null, 0); assert latch.await(LATCH_TIMEOUT, MILLISECONDS) : "Count: " + latch.getCount(); assertEquals(10, map.size()); for (int i = 0; i < 10; i++) assertEquals(i, (int)map.get(i)); } }
/** * Register a continuous query, that counts updates on the provided cache. * * @param cache Cache. * @param loc If {@code true}, then local continuous query will be registered. * @param updCntr Update counter. * @param rmtFilter Remote filter. */ private void listenToUpdates(IgniteCache<Integer, String> cache, boolean loc, AtomicInteger updCntr, CacheEntryEventSerializableFilter<Integer, String> rmtFilter) { ContinuousQuery<Integer, String> cq = new ContinuousQuery<>(); cq.setLocal(loc); cq.setLocalListener((evts) -> { for (CacheEntryEvent e : evts) updCntr.incrementAndGet(); }); if (rmtFilter != null) cq.setRemoteFilterFactory(FactoryBuilder.factoryOf(rmtFilter)); cache.query(cq); } }
/** * @throws Exception If failed. */ @Test public void testRemoteNodeCallback() throws Exception { IgniteCache<Integer, Integer> cache1 = grid(0).cache(DEFAULT_CACHE_NAME); IgniteCache<Integer, Integer> cache2 = grid(1).cache(DEFAULT_CACHE_NAME); ContinuousQuery<Integer, Integer> qry = new ContinuousQuery<>(); final AtomicReference<Integer> val = new AtomicReference<>(); final CountDownLatch latch = new CountDownLatch(1); qry.setLocalListener(new CacheEntryUpdatedListener<Integer, Integer>() { @Override public void onUpdated(Iterable<CacheEntryEvent<? extends Integer, ? extends Integer>> evts) { Iterator<CacheEntryEvent<? extends Integer, ? extends Integer>> it = evts.iterator(); CacheEntryEvent<? extends Integer, ? extends Integer> e = it.next(); assert !it.hasNext(); log.info("Event: " + e); val.set(e.getValue()); latch.countDown(); } }); try (QueryCursor<Cache.Entry<Integer, Integer>> ignored = cache2.query(qry)) { cache1.put(1, 10); latch.await(LATCH_TIMEOUT, MILLISECONDS); assertEquals(10, val.get().intValue()); } }
/** * @throws Exception If failed. */ @Test public void testLoadCache() throws Exception { IgniteCache<Integer, Integer> cache = grid(0).cache(CACHE_NAME); ContinuousQuery<Integer, Integer> qry = new ContinuousQuery<>(); final Map<Integer, T2<Integer, Long>> map = new ConcurrentHashMap<>(); final CountDownLatch latch = new CountDownLatch(10); qry.setLocalListener(new CacheEntryUpdatedListener<Integer, Integer>() { @Override public void onUpdated(Iterable<CacheEntryEvent<? extends Integer, ? extends Integer>> evts) { for (CacheEntryEvent<? extends Integer, ? extends Integer> e : evts) { map.put(e.getKey(), new T2<>(e.getValue(), e.unwrap(CacheQueryEntryEvent.class).getPartitionUpdateCounter())); latch.countDown(); } } }); try (QueryCursor<Cache.Entry<Integer, Integer>> ignored = cache.query(qry)) { cache.loadCache(null, 0); assert latch.await(LATCH_TIMEOUT, MILLISECONDS) : "Count: " + latch.getCount(); assertEquals(10, map.size()); for (int i = 0; i < 10; i++) { assertEquals(i, (int)map.get(i).get1()); assertEquals((long)1, (long)map.get(i).get2()); } } }
/** * @param cache Ignite cache. * @throws Exception If fail. */ private void executeContinuousQuery(IgniteCache cache) throws Exception { ContinuousQuery<Integer, String> qry = new ContinuousQuery<>(); qry.setLocalListener( new CacheEntryUpdatedListener<Integer, String>() { @Override public void onUpdated(Iterable<CacheEntryEvent<? extends Integer, ? extends String>> events) throws CacheEntryListenerException { for (CacheEntryEvent<? extends Integer, ? extends String> event : events) System.out.println("Key = " + event.getKey() + ", Value = " + event.getValue()); } } ); final Class<CacheEntryEventSerializableFilter> remoteFilterClass = (Class<CacheEntryEventSerializableFilter>) ldr.loadClass("org.apache.ignite.tests.p2p.CacheDeploymentCacheEntryEventSerializableFilter"); qry.setRemoteFilterFactory(new ClassFilterFactory(remoteFilterClass)); cache.query(qry); for (int i = 0; i < 100; i++) cache.put(i, "Message " + i); }
/** * @throws Exception If failed. */ private void doTest(boolean loc) throws Exception { try { IgniteCache<String, Integer> cache = startGrid(0).cache(DEFAULT_CACHE_NAME); ContinuousQuery<String, Integer> qry = new ContinuousQuery<>(); final AtomicInteger cnt = new AtomicInteger(); final CountDownLatch latch = new CountDownLatch(10); qry.setLocalListener(new CacheEntryUpdatedListener<String, Integer>() { @Override public void onUpdated(Iterable<CacheEntryEvent<? extends String, ? extends Integer>> evts) throws CacheEntryListenerException { for (CacheEntryEvent<? extends String, ? extends Integer> evt : evts) { cnt.incrementAndGet(); latch.countDown(); } } }); cache.query(qry.setLocal(loc)); startGrid(1); awaitPartitionMapExchange(); for (int i = 0; i < 10; i++) cache.put("key" + i, i); assert latch.await(5000, TimeUnit.MILLISECONDS); assertEquals(10, cnt.get()); } finally { stopAllGrids(); } }
/** * @throws Exception If failed. */ @Test public void testInternalKey() throws Exception { if (atomicityMode() == ATOMIC) return; IgniteCache<Object, Object> cache = grid(0).cache(DEFAULT_CACHE_NAME); ContinuousQuery<Object, Object> qry = new ContinuousQuery<>(); final Map<Object, Object> map = new ConcurrentHashMap<>(); final CountDownLatch latch = new CountDownLatch(2); qry.setLocalListener(new CacheEntryUpdatedListener<Object, Object>() { @Override public void onUpdated(Iterable<CacheEntryEvent<?, ?>> evts) { for (CacheEntryEvent<?, ?> e : evts) { map.put(e.getKey(), e.getValue()); latch.countDown(); } } }); try (QueryCursor<Cache.Entry<Object, Object>> ignored = cache.query(qry)) { cache.put(new GridCacheInternalKeyImpl("test", "test"), 1); cachePut(cache, 1, 1); cachePut(cache, 2, 2); assert latch.await(LATCH_TIMEOUT, MILLISECONDS); assertEquals(2, map.size()); assertEquals(1, (int)map.get(1)); assertEquals(2, (int)map.get(2)); } }
/** * @throws Exception If failed. */ @SuppressWarnings("TryFinallyCanBeTryWithResources") @Test public void testNodeJoinWithoutCache() throws Exception { IgniteCache<Integer, Integer> cache = grid(0).cache(DEFAULT_CACHE_NAME); ContinuousQuery<Integer, Integer> qry = new ContinuousQuery<>(); final CountDownLatch latch = new CountDownLatch(1); qry.setLocalListener(new CacheEntryUpdatedListener<Integer, Integer>() { @Override public void onUpdated(Iterable<CacheEntryEvent<? extends Integer, ? extends Integer>> evts) { latch.countDown(); } }); QueryCursor<Cache.Entry<Integer, Integer>> cur = cache.query(qry); try { try (Ignite ignite = startGrid(NO_CACHE_IGNITE_INSTANCE_NAME)) { log.info("Started node without cache: " + ignite); } cachePut(cache, 1, 1); assertTrue(latch.await(5000, MILLISECONDS)); } finally { cur.close(); } }
/** * @throws Exception If failed. */ @Test public void testManyQueryBackupQueue() throws Exception { List<QueryCursor> qryCursors = new ArrayList<>(); for (int i = 0; i < QUERY_COUNT; i++) { ContinuousQuery<Object, Object> qry = new ContinuousQuery<>(); qry.setLocalListener(new CacheEventListener()); qry.setRemoteFilterFactory(new AlwaysFalseFilterFactory()); qryCursors.add(grid(0).cache(CACHE_NAME).query(qry)); } for (int i = 0; i < KEYS_COUNT; i++) { log.info("Put key: " + i); for (int j = 0; j < 150; j++) grid(ThreadLocalRandom.current().nextInt(GRID_COUNT)).cache(CACHE_NAME).put(i, new byte[1024 * 50]); } int size = backupQueueSize(); assertTrue(size > 0); assertTrue(size <= BACKUP_ACK_THRESHOLD * QUERY_COUNT * /* partition count */1024); for (QueryCursor qry : qryCursors) qry.close(); }
/** * @throws Exception If failed. */ @Test public void testFilterException() throws Exception { IgniteCache<Integer, Integer> cache = grid(0).cache(DEFAULT_CACHE_NAME); ContinuousQuery<Integer, Integer> qry = new ContinuousQuery<>(); qry.setLocalListener(new CacheEntryUpdatedListener<Integer, Integer>() { @Override public void onUpdated(Iterable<CacheEntryEvent<? extends Integer, ? extends Integer>> evts) { // No-op. } }); qry.setRemoteFilter(new CacheEntryEventSerializableFilter<Integer, Integer>() { @Override public boolean evaluate(CacheEntryEvent<? extends Integer, ? extends Integer> evt) { throw new RuntimeException("Test error."); } }); try (QueryCursor<Cache.Entry<Integer, Integer>> ignored = cache.query(qry)) { for (int i = 0; i < 100; i++) cachePut(cache, i, i); } }
/** * @throws Exception If failed. */ @Test public void testReconnectClient() throws Exception { Ignite client = grid(serverCount()); Ignite srv = clientRouter(client); assertTrue(client.cluster().localNode().isClient()); final CacheEventListener lsnr = new CacheEventListener(); ContinuousQuery<Object, Object> qry = new ContinuousQuery<>(); qry.setLocalListener(lsnr); IgniteCache<Object, Object> clnCache = client.cache(DEFAULT_CACHE_NAME); QueryCursor<?> cur = clnCache.query(qry); int keyCnt = 100; for (int i = 0; i < 10; i++) { lsnr.latch = new CountDownLatch(keyCnt); for (int key = 0; key < keyCnt; key++) clnCache.put(key, key); assertTrue("Failed to wait for event.", lsnr.latch.await(5, SECONDS)); reconnectClientNode(client, srv, null); lsnr.latch = new CountDownLatch(keyCnt); for (int key = 0; key < keyCnt; key++) clnCache.put(key, key); assertTrue("Failed to wait for event.", lsnr.latch.await(5, SECONDS)); } cur.close(); }
ContinuousQuery<Object, Object> qry = new ContinuousQuery<>();
/** * @throws Exception If failed. */ @Test public void testFirstFilteredEvent() throws Exception { this.backups = 2; final int SRV_NODES = 4; startGridsMultiThreaded(SRV_NODES); client = true; Ignite qryClient = startGrid(SRV_NODES); client = false; IgniteCache<Object, Object> qryClnCache = qryClient.cache(DEFAULT_CACHE_NAME); final CacheEventListener3 lsnr = new CacheEventListener3(); ContinuousQuery<Object, Object> qry = new ContinuousQuery<>(); qry.setLocalListener(lsnr); qry.setRemoteFilter(new CacheEventFilter()); try (QueryCursor<?> cur = qryClnCache.query(qry)) { List<Integer> keys = testKeys(grid(0).cache(DEFAULT_CACHE_NAME), 1); for (Integer key : keys) qryClnCache.put(key, -1); qryClnCache.put(keys.get(0), 100); GridTestUtils.waitForCondition(new GridAbsPredicate() { @Override public boolean apply() { return lsnr.evts.size() == 1; } }, 5000); assertEquals(lsnr.evts.size(), 1); } }
/** * @throws Exception If failed. */ @Test public void testCachingMaxSize() throws Exception { Ignite node = startGrids(1); final IgniteCache cache = node.createCache( cacheConfiguration(cacheMode(), FULL_SYNC, 1, 2) .setCacheMode(CacheMode.PARTITIONED) .setIndexedTypes(Integer.class, Integer.class)); ContinuousQuery<Integer, Integer> qry = new ContinuousQuery<>(); qry.setLocalListener(new CacheEntryUpdatedListener<Integer, Integer>() { @Override public void onUpdated(Iterable<CacheEntryEvent<? extends Integer, ? extends Integer>> evts) { // No-op. } }); GridTestUtils.assertThrows(log, new Callable<Object>() { @Override public Object call() throws Exception { try (QueryCursor<Cache.Entry<Integer, Integer>> ignored = cache.query(qry)) { try (Transaction tx = node.transactions().txStart(PESSIMISTIC, REPEATABLE_READ)) { for (int i = 0; i < TX_SIZE_THRESHOLD + 1; i++) cache.query(new SqlFieldsQuery("INSERT INTO Integer (_key, _val) values (" + i + ", 1)")).getAll(); tx.commit(); } } return null; } }, CacheException.class, "Failed to run update. Transaction is too large. Consider reducing transaction size"); }
/** * @throws Exception If failed. */ @Test public void testCacheContinuousQueryReconnect() throws Exception { Ignite client = grid(serverCount()); assertTrue(client.cluster().localNode().isClient()); IgniteCache<Object, Object> clientCache = client.getOrCreateCache(new CacheConfiguration<>(DEFAULT_CACHE_NAME)); CacheEventListener lsnr = new CacheEventListener(); ContinuousQuery<Object, Object> qry = new ContinuousQuery<>(); qry.setAutoUnsubscribe(true); qry.setLocalListener(lsnr); QueryCursor<?> cur = clientCache.query(qry); for (int i = 0; i < 5; i++) { log.info("Iteration: " + i); continuousQueryReconnect(client, clientCache, lsnr); } log.info("Close cursor, should not get cache events anymore."); cur.close(); lsnr.latch = new CountDownLatch(1); clientCache.put(3, 3); assertFalse(lsnr.latch.await(3000, MILLISECONDS)); }
/** * @throws Exception If failed. */ @Test public void testBackupQueue() throws Exception { final CacheEventListener lsnr = new CacheEventListener(); ContinuousQuery<Object, Object> qry = new ContinuousQuery<>(); qry.setLocalListener(lsnr); qry.setRemoteFilterFactory(new AlwaysFalseFilterFactory()); try (QueryCursor<?> ignore = grid(0).cache(CACHE_NAME).query(qry)) { for (int i = 0; i < KEYS_COUNT; i++) { log.info("Put key: " + i); for (int j = 0; j < 100; j++) grid(j % GRID_COUNT).cache(CACHE_NAME).put(i, new byte[1024 * 50]); } log.info("Finish."); } }