@Override public Map.Entry<String, Map<D, S>> findEntryContaining(S session) { SessionFilter<D, S> filter = new SessionFilter<>(session); // Erase type to handle compilation issues with generics // Our filter will handle type safety and casting @SuppressWarnings("rawtypes") Cache cache = this.cache; try (Stream<Map.Entry<?, ?>> stream = cache.entrySet().stream()) { Map.Entry<CoarseSessionsKey, Map<D, S>> entry = stream.filter(this.filter).map(this.filter).filter(filter).findAny().orElse(null); return (entry != null) ? new AbstractMap.SimpleImmutableEntry<>(entry.getKey().getValue(), entry.getValue()) : null; } }
try (CloseableIterator<Map.Entry<T, Set<Address>>> entries = this.cache.entrySet().iterator()) { while (entries.hasNext()) { Map.Entry<T, Set<Address>> entry = entries.next();
@Test(dependsOnMethods = "sequantialOvewritingInBatches") public void indexWasStored() { cache = cacheManager.getCache(); Assert.assertEquals(0, cache.getAdvancedCache().getDataContainer().size()); boolean failed = false; for (Object key : cacheCopy.keySet()) { Object expected = cacheCopy.get(key); Object actual = cache.get(key); if (!expected.equals(actual)) { log.errorf("Failure on key '%s' expected value: '%s' actual value: '%s'", key.toString(), expected, actual); failed = true; } } Assert.assertFalse(failed); Assert.assertEquals(cacheCopy.keySet().size(), cache.keySet().size(), "have a different number of keys"); }
private void assertCacheSize(int expectedSize) { assertEquals(expectedSize, cache.size()); assertEquals(expectedSize, cache.keySet().size()); assertEquals(expectedSize, cache.values().size()); assertEquals(expectedSize, cache.entrySet().size()); boolean isEmpty = expectedSize == 0; assertEquals(isEmpty, cache.isEmpty()); assertEquals(isEmpty, cache.keySet().isEmpty()); assertEquals(isEmpty, cache.values().isEmpty()); assertEquals(isEmpty, cache.entrySet().isEmpty()); }
public void testLoadEntrySet() { int numberOfEntries = 10; ConfigurationBuilder cb = TestCacheManagerFactory.getDefaultCacheConfiguration(false); createCacheStoreConfig(cb.persistence(), true); cacheManager.defineConfiguration("testLoadKeySet", cb.build()); Cache<String, Object> cache = cacheManager.getCache("testLoadKeySet"); Map<String, Object> entriesMap = IntStream.range(0, numberOfEntries).boxed() .collect(Collectors.toMap(Object::toString, i -> wrap(i.toString(), "Val"+i))); cache.putAll(entriesMap); cache.stop(); cache.start(); CacheSet<Map.Entry<String, Object>> set = cache.entrySet(); assertEquals(numberOfEntries, cache.size()); assertEquals(numberOfEntries, set.size()); set.forEach(e -> assertEquals(entriesMap.get(e.getKey()), e.getValue())); }
int size = 1; assertEquals(size, cache.size()); assertEquals(size, cache.keySet().size()); assertEquals(size, cache.values().size()); assertEquals(size, cache.entrySet().size()); assertTrue(cache.keySet().contains(key)); assertTrue(cache.values().contains(value)); assertEquals(tmSize, cache.keySet().size()); assertEquals(tmSize, cache.values().size()); assertEquals(tmSize, cache.entrySet().size()); assertFalse(cache.keySet().contains(key)); assertFalse(cache.values().contains(value)); tm.setRollbackOnly(); size = 1; assertEquals(size, cache.size()); assertEquals(size, cache.keySet().size()); assertEquals(size, cache.values().size()); assertEquals(size, cache.entrySet().size()); assertTrue(cache.keySet().contains(key)); assertTrue(cache.values().contains(value));
public static void main(String[] args) throws Exception { // Setup up a clustered cache manager GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder(); // Make the default cache a distributed synchronous one ConfigurationBuilder builder = new ConfigurationBuilder(); builder.clustering().cacheMode(CacheMode.DIST_SYNC); // Initialize the cache manager DefaultCacheManager cacheManager = new DefaultCacheManager(global.build(), builder.build()); // Obtain the default cache Cache<String, String> cache = cacheManager.getCache(); // Store the current node address in some random keys for(int i=0; i < 10; i++) { cache.put(UUID.randomUUID().toString(), cacheManager.getNodeAddress()); } // Display the current cache contents for the whole cluster cache.entrySet().forEach(entry -> System.out.printf("%s = %s\n", entry.getKey(), entry.getValue())); // Display the current cache contents for this node cache.getAdvancedCache().withFlags(Flag.SKIP_REMOTE_LOOKUP) .entrySet().forEach(entry -> System.out.printf("%s = %s\n", entry.getKey(), entry.getValue())); // Stop the cache manager and release all resources cacheManager.stop(); }
private Boolean containsEntryInternal(V value) { return cache.entrySet().parallelStream().anyMatch(entry -> entry.getValue().contains(value)); }
@Override public Object visitPutKeyValueCommand(InvocationContext ctx, PutKeyValueCommand command) throws Throwable { // First execute the operation itself Object ret = super.visitPutKeyValueCommand(ctx, command); assertKeySet = (cache.keySet().size() == 1); // After entry has been committed to the container log.info("Cache entry created, now check in different thread"); latch.countDown(); // Force a bit of delay in the listener TestingUtil.sleepThread(3000); return ret; }
private void assertCacheSize(int expectedSize) { assertEquals(expectedSize, cache.size()); assertEquals(expectedSize, cache.keySet().size()); assertEquals(expectedSize, cache.values().size()); assertEquals(expectedSize, cache.entrySet().size()); boolean isEmpty = expectedSize == 0; assertEquals(isEmpty, cache.isEmpty()); assertEquals(isEmpty, cache.keySet().isEmpty()); assertEquals(isEmpty, cache.values().isEmpty()); assertEquals(isEmpty, cache.entrySet().isEmpty()); }
assertEquals(value, cache.get(key)); assertEquals(size, cache.size()); assertEquals(size, cache.keySet().size()); assertEquals(size, cache.values().size()); assertEquals(size, cache.entrySet().size()); assertTrue(cache.keySet().contains(key)); assertTrue(cache.values().contains(value)); assertEquals(value2, cache.get(key)); assertEquals(size, cache.size()); assertEquals(size, cache.keySet().size()); assertEquals(size, cache.values().size()); assertEquals(size, cache.entrySet().size()); assertTrue(cache.keySet().contains(key)); assertTrue(cache.values().contains(value2)); assertFalse(cache.values().contains(value)); assertEquals(size, cache.keySet().size()); assertEquals(size, cache.values().size()); assertEquals(size, cache.entrySet().size()); assertTrue(cache.keySet().contains(key)); assertTrue(cache.values().contains(value));
public static void main(String[] args) throws Exception { // Setup up a clustered cache manager GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder(); // Make the default cache a replicated synchronous one ConfigurationBuilder builder = new ConfigurationBuilder(); builder.clustering().cacheMode(CacheMode.REPL_SYNC); // Initialize the cache manager DefaultCacheManager cacheManager = new DefaultCacheManager(global.build(), builder.build()); // Obtain the default cache Cache<String, String> cache = cacheManager.getCache(); // Store the current node address in some random keys for(int i=0; i < 10; i++) { cache.put(UUID.randomUUID().toString(), cacheManager.getNodeAddress()); } // Display the current cache contents for the whole cluster cache.entrySet().forEach(entry -> System.out.printf("%s = %s\n", entry.getKey(), entry.getValue())); // Display the current cache contents for this node cache.getAdvancedCache().withFlags(Flag.SKIP_REMOTE_LOOKUP) .entrySet().forEach(entry -> System.out.printf("%s = %s\n", entry.getKey(), entry.getValue())); // Stop the cache manager and release all resources cacheManager.stop(); }
public void forgetTransaction(XidImpl xid) { if (trace) { log.tracef("[%s] Forgetting transaction.", xid); } storage.keySet().parallelStream() .filter(new XidPredicate(xid)) .forEach(BasicCache::remove); }
@Override public int getActiveCount() { try (Stream<Map.Entry<BeanKey<I>, BeanEntry<I>>> entries = this.cache.getAdvancedCache().withFlags(Flag.CACHE_MODE_LOCAL, Flag.SKIP_CACHE_LOAD).entrySet().stream()) { return (int) entries.filter(this.filter).count(); } }
private void schedule(Locality oldLocality, Locality newLocality) { SessionMetaDataFactory<InfinispanSessionMetaData<L>, L> metaDataFactory = this.factory.getMetaDataFactory(); // Iterate over sessions in memory try (CloseableIterator<Key<String>> keys = this.cache.getAdvancedCache().withFlags(Flag.CACHE_MODE_LOCAL, Flag.SKIP_CACHE_LOAD).keySet().iterator()) { while (keys.hasNext()) { if (Thread.currentThread().isInterrupted()) break; Key<String> key = keys.next(); // If we are the new primary owner of this session then schedule expiration of this session locally if (this.filter.test(key) && !oldLocality.isLocal(key) && newLocality.isLocal(key)) { String id = key.getValue(); try (Batch batch = this.batcher.createBatch()) { try { // We need to lookup the session to obtain its meta data InfinispanSessionMetaData<L> value = metaDataFactory.tryValue(id); if (value != null) { this.scheduler.schedule(id, metaDataFactory.createImmutableSessionMetaData(id, value)); } return; } catch (CacheException e) { batch.discard(); } } } } } } }
private void checkResponse(String result, int entryCount) { assert isSuccess(result) : "Received: " + result; assertEquals(cache(0, "test").keySet().size(), entryCount); assertEquals(cache(1, "test").keySet().size(), entryCount); eventually(new Condition() { @Override public boolean isSatisfied() throws Exception { return showInDoubtTransactions(0).isEmpty() && showInDoubtTransactions(1).isEmpty(); } }); //just make sure everything is cleaned up properly now checkProperlyCleanup(0); checkProperlyCleanup(1); }
int size = 1; assertEquals(size, cache.size()); assertEquals(size, cache.keySet().size()); assertEquals(size, cache.values().size()); assertEquals(size, cache.entrySet().size()); assertTrue(cache.keySet().contains(key)); assertTrue(cache.values().contains(value)); cache.put(key2, value2); assertEquals(value2, cache.get(key2)); assertTrue(cache.keySet().contains(key2)); int tmSize = 2; assertEquals(tmSize, cache.size()); assertEquals(tmSize, cache.keySet().size()); assertEquals(tmSize, cache.values().size()); assertEquals(tmSize, cache.entrySet().size()); assertEquals(size, cache.keySet().size()); assertEquals(size, cache.values().size()); assertEquals(size, cache.entrySet().size()); assertTrue(cache.keySet().contains(key)); assertTrue(cache.values().contains(value));
public void testEntrySetForEachNonSerializable() { assertEquals(0, cache.size()); cache.put("k1", "v1"); List<Object> values = new ArrayList<>(); cache.entrySet().forEach(values::add); assertEquals(1, values.size()); Map.Entry<Object, Object> entry = (Map.Entry<Object, Object>) values.iterator().next(); assertEquals("k1", entry.getKey()); assertEquals("v1", entry.getValue()); }
private Set<String> getSessions(Flag... flags) { Locality locality = new CacheLocality(this.cache); try (Stream<Key<String>> keys = this.cache.getAdvancedCache().withFlags(flags).keySet().stream()) { return keys.filter(this.filter.and(key -> locality.isLocal(key))).map(key -> key.getValue()).collect(Collectors.toSet()); } }