@Override public Flowable<K> publishKeys(IntSet segments, Predicate<? super K> filter) { Flowable<K> keys = Flowable.using(Functions.justCallable(this.remoteCache.keySet(segments).iterator()), this, CloseableIterator::close); return (filter != null) ? keys.filter(filter::test) : keys; }
@Override public CloseableIteratorSet<K> keySet() { return delegate.keySet(); }
@Override public CloseableIteratorSet<K> keySet(IntSet segments) { return delegate.keySet(segments); }
/** * Retrieve the sessions using protobuf format and print them out to * confirm they're ok. */ public void checkConverted () { List<String> keys = null; try { keys = _protoCache.keySet().stream().collect(Collectors.toList()); } catch (Exception e) { System.err.println("Unable to read converted sessions, assuming still in legacy format. Run again without 'check' option to convert."); e.printStackTrace(); System.exit(1); } for (String s:keys) { InfinispanSessionData converted = (InfinispanSessionData)_protoCache.get(s); if (converted != null) { System.err.println("OK: "+converted); converted.getKeys().stream().forEach((ss)->{System.err.println(ss+":"+converted.getAttribute(ss));}); } else System.err.println("Failed: "+s); } System.err.println("Total converted sessions: "+keys.size()); }
@Override public Flowable<K> publishKeys(IntSet segments, Predicate<? super K> filter) { Flowable<K> keys = Flowable.using(Functions.justCallable(this.remoteCache.keySet(segments).iterator()), this, CloseableIterator::close); return (filter != null) ? keys.filter(filter::test) : keys; }
@Override public void removeAll() { checkNotClosed(); try (CloseableIterator<K> it = cacheWithoutStats.keySet().iterator()) { while (it.hasNext()) { remove(it.next()); } } //FIXME locks }
@Test public void testKeySet() { remoteCache.put("k1", "v1"); remoteCache.put("k2", "v2"); remoteCache.put("k3", "v3"); Set<String> expectedKeySet = new HashSet<String>(); expectedKeySet.add("k1"); expectedKeySet.add("k2"); expectedKeySet.add("k3"); assertEquals(expectedKeySet, remoteCache.keySet()); }
public void testEmbeddedPutHotRodKeySet() { Cache<String, Integer> embedded = cacheFactory1.getEmbeddedCache(); RemoteCache<String, Integer> remote = cacheFactory2.getHotRodCache(); populateCacheManager(embedded); Set<String> keySet = remote.keySet(); assertEquals(100, keySet.size()); for(int i = 0; i < 100; i++) { assertTrue(keySet.contains("key" + i)); } } }
public void testEmbeddedPutHotRodKeySet() { Cache<Integer, Integer> embedded = cacheFactory.getEmbeddedCache(); RemoteCache<Integer, Integer> remote = cacheFactory.getHotRodCache(); populateCacheManager(embedded); Set<Integer> keySet = remote.keySet(); assertEquals(100, keySet.size()); for(int i = 0; i < 100; i++) { assertTrue(keySet.contains(i)); } }
keys = _legacyCache.keySet().stream().collect(Collectors.toList());
@Test public void testPutAndGetBulk() { RemoteCache<String, Integer> rc = remoteCacheManager.getCache("off-heap-default"); rc.clear(); Map<String, Integer> values = new HashMap<>(); IntStream.range(0, 100).forEach(i -> values.put("key" + i, i)); rc.putAll(values); assertEquals(100, rc.size()); Set<String> keys = rc.keySet(); assertEquals(100, keys.size()); assertTrue(keys.contains("key0")); assertTrue(keys.contains("key50")); assertTrue(keys.contains("key99")); CloseableIterator<Map.Entry<Object, Object>> iter = rc.retrieveEntries(null, 100); //we cannot assert keys/values direcly as iterator returns items in random order Map<String, Integer> keyVal = new HashMap<>(100); while (iter.hasNext()) { Map.Entry<Object, Object> entry = iter.next(); keyVal.put((String) entry.getKey(), (Integer) entry.getValue()); } IntStream.range(0, 100).forEach(i -> { assertTrue(keyVal.containsKey("key" + i)); assertEquals(new Integer(i), keyVal.get("key" + i)); }); }
@Test public void testDistributedKeySet() { remoteCache.put(1, createUser(1)); remoteCache.put(2, createUser(2)); Set<Integer> keys = remoteCache.keySet(); assertNotNull(keys); assertEquals(2, keys.size()); assertTrue(keys.contains(1)); assertTrue(keys.contains(2)); }
public static void testKeySet(RemoteCache<String, String> remoteCache) { remoteCache.clear(); remoteCache.put(KEY1, VALUE1); remoteCache.put(KEY2, VALUE2); assertEquals(2, remoteCache.keySet().size()); }
/** * Test for read-only attribute of store - if true, no entries will be written into store */ @Test @WithRunningServer({@RunningServer(name = CONTAINER_LOCAL)}) public void testReadOnly() throws Exception { Configuration conf = new ConfigurationBuilder().addServer().host(server1.getHotrodEndpoint().getInetAddress().getHostName()).port(server1 .getHotrodEndpoint().getPort()).build(); rcm1 = new RemoteCacheManager(conf); RemoteCache<String, String> rc1 = rcm1.getCache(READONLY_CACHE_NAME); // put 3 keys, one entry is evicted, but not stored Set<String> allKeys = new HashSet<>(); for (int i = 1; i < 4; i++) { String key = "k"+i; rc1.put(key, "v"+i); allKeys.add(key); } assertEquals(0, server2.getCacheManager(LOCAL_CACHE_MANAGER).getDefaultCache().getNumberOfEntriesInMemory()); assertEquals(2, server1.getCacheManager(LOCAL_CACHE_MANAGER).getCache(READONLY_CACHE_NAME).getNumberOfEntries()); assertEquals(2, server1.getCacheManager(LOCAL_CACHE_MANAGER).getCache(READONLY_CACHE_NAME).getNumberOfEntriesInMemory()); Set<String> storedKeys = rc1.keySet(); allKeys.removeAll(storedKeys); for (String key : allKeys) assertNull(rc1.get(key)); for (String key : storedKeys) { int i = Integer.parseInt(key.substring(1)); assertEquals("v"+i, rc1.get(key)); } }