public void testChangesOnAtomicMapNoLocksExistingData() { AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache, "key"); assert map.isEmpty(); map.put("x", "y"); assert map.get("x").equals("y"); // TestingUtil.extractComponent(cache, InvocationContextContainer.class).createInvocationContext(false, -1).setFlags(SKIP_LOCKING); log.debug("Doing a put"); map.put("a", "b"); log.debug("Put complete"); assert map.get("a").equals("b"); assert map.get("x").equals("y"); // now re-retrieve the map and make sure we see the diffs assert AtomicMapLookup.getAtomicMap(cache, "key").get("x").equals("y"); assert AtomicMapLookup.getAtomicMap(cache, "key").get("a").equals("b"); }
public void testChangesOnAtomicMap() { AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache, "key"); assert map.isEmpty(); map.put("a", "b"); assert map.get("a").equals("b"); // now re-retrieve the map and make sure we see the diffs assert AtomicMapLookup.getAtomicMap(cache, "key").get("a").equals("b"); }
private V putIfAbsent(AdvancedCache<?, ?> cache, K key, V value) { startAtomic(); try { AtomicMap<K, V> data = getDataInternal(cache); if (!data.containsKey(key)) return data.put(key, value); return data.get(key); } finally { endAtomic(); } }
public void testChangesOnAtomicMapNoLocks() { AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache, "key"); assert map.isEmpty(); // InvocationContextContainer icc = TestingUtil.extractComponent(cache, InvocationContextContainer.class); // InvocationContext ic = icc.createInvocationContext(false, -1); // ic.setFlags(SKIP_LOCKING); log.debug("Doing a put"); // assert icc.getInvocationContext(true).hasFlag(SKIP_LOCKING); map.put("a", "b"); log.debug("Put complete"); assert map.get("a").equals("b"); // now re-retrieve the map and make sure we see the diffs assert AtomicMapLookup.getAtomicMap(cache, "key").get("a").equals("b"); }
private boolean replace(AdvancedCache<?, ?> cache, K key, V oldValue, V newValue) { startAtomic(); try { AtomicMap<K, V> data = getDataInternal(cache); V old = data.get(key); if (Util.safeEquals(oldValue, old)) { data.put(key, newValue); return true; } return false; } finally { endAtomic(); } }
public void testTxChangesOnAtomicMap() throws Exception { AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache, "key"); tm().begin(); assert map.isEmpty(); map.put("a", "b"); assert map.get("a").equals("b"); Transaction t = tm().suspend(); assert AtomicMapLookup.getAtomicMap(cache, "key").get("a") == null; tm().resume(t); tm().commit(); // now re-retrieve the map and make sure we see the diffs assert AtomicMapLookup.getAtomicMap(cache, "key").get("a").equals("b"); }
public void testTxChangesOnAtomicMapNoLocks() throws Exception { AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache, "key"); tm().begin(); assert map.isEmpty(); // TestingUtil.extractComponent(cache, InvocationContextContainer.class).createInvocationContext(true, -1).setFlags(SKIP_LOCKING); map.put("a", "b"); assert map.get("a").equals("b"); Transaction t = tm().suspend(); assert AtomicMapLookup.getAtomicMap(cache, "key").get("a") == null; tm().resume(t); tm().commit(); // now re-retrieve the map and make sure we see the diffs assert AtomicMapLookup.getAtomicMap(cache, "key").get("a").equals("b"); }
public void testRestoreAtomicMap(Method m) { cacheManager.defineConfiguration(m.getName(), configureCacheLoader(null, false).build()); Cache<String, Object> cache = cacheManager.getCache(m.getName()); AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache, m.getName()); map.put("a", "b"); //evict from memory cache.evict(m.getName()); // now re-retrieve the map assertEquals("b", AtomicMapLookup.getAtomicMap(cache, m.getName()).get("a")); }
public void testReplicationCommitCreateMapInTransaction(Method m) throws Exception { Cache<String, Object> cache1 = cache(0, "atomic"); Cache<String, Object> cache2 = cache(1, "atomic"); TestingUtil.getTransactionManager(cache1).begin(); AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache1, m.getName()); map.put("a", "b"); TestingUtil.getTransactionManager(cache1).commit(); assert map.size() == 1; assert map.get("a").equals("b"); assert map.containsKey("a"); assert AtomicMapLookup.getAtomicMap(cache2, m.getName()).size() == 1; assert AtomicMapLookup.getAtomicMap(cache2, m.getName()).get("a").equals("b"); assert AtomicMapLookup.getAtomicMap(cache2, m.getName()).containsKey("a"); }
@Test public void testRestoreTransactionalAtomicMap(final Method m) throws Exception { cacheManager.defineConfiguration(m.getName(), configureCacheLoader(null, false).build()); Cache<String, Object> cache = cacheManager.getCache(m.getName()); TransactionManager tm = cache.getAdvancedCache().getTransactionManager(); tm.begin(); final AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache, m.getName()); map.put("a", "b"); tm.commit(); //evict from memory cache.evict(m.getName()); // now re-retrieve the map and make sure we see the diffs assertEquals("b", AtomicMapLookup.getAtomicMap(cache, m.getName()).get("a")); }
public void testAtomicMapWithoutBatchSet() { ConfigurationBuilder builder = buildConfiguration(); builder.invocationBatching().disable(); cacheManager.defineConfiguration("ahm_without_batch", builder.build()); Cache<String, String> ahmCache = cacheManager.getCache("ahm_without_batch"); AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(ahmCache, "key"); assert map.isEmpty(); map.put("a", "b"); assert map.get("a").equals("b"); // now re-retrieve the map and make sure we see the diffs assert AtomicMapLookup.getAtomicMap(ahmCache, "key").get("a").equals("b"); }
public void testAtomicMapWithoutTransactionManagerLookupSet() { ConfigurationBuilder builder = buildConfiguration(); builder.transaction().transactionMode(TransactionMode.TRANSACTIONAL).transactionManagerLookup(null); cacheManager.defineConfiguration("ahm_without_tmlookup", builder.build()); Cache<String, String> ahmCache = cacheManager.getCache("ahm_without_tmlookup"); AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(ahmCache, "key"); assert map.isEmpty(); map.put("a", "b"); assert map.get("a").equals("b"); // now re-retrieve the map and make sure we see the diffs assert AtomicMapLookup.getAtomicMap(ahmCache, "key").get("a").equals("b"); }
public void testReplicationCommit() throws Exception { Cache<String, Object> cache1 = cache(0, "atomic"); Cache<String, Object> cache2 = cache(1, "atomic"); AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache1, "map"); TestingUtil.getTransactionManager(cache1).begin(); map.put("existing", "existing"); map.put("blah", "blah"); TestingUtil.getTransactionManager(cache1).commit(); assert map.size() == 2; assert map.get("blah").equals("blah"); assert map.containsKey("blah"); assert AtomicMapLookup.getAtomicMap(cache2, "map").size() == 2; assert AtomicMapLookup.getAtomicMap(cache2, "map").get("blah").equals("blah"); assert AtomicMapLookup.getAtomicMap(cache2, "map").containsKey("blah"); }
public void testReadSafetyNotEmptyCache() throws Exception { AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache, "map"); tm.begin(); map.put("blah", "blah"); assert map.get("blah").equals("blah"); Transaction t = tm.suspend(); assert map.isEmpty(); assertIsEmpty(map); assertIsEmptyMap(cache, "map"); tm.resume(t); tm.commit(); assert map.size() == 1; assert map.get("blah").equals("blah"); assert map.containsKey("blah"); map.clear(); assertIsEmpty(map); assertIsEmptyMap(cache, "map"); }
public void testPassivateAndUpdate(Method m) throws Exception { String key = "k-" + m.getName(); TransactionManager tm = TestingUtil.getTransactionManager(cache); tm.begin(); AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache, key); assert map.isEmpty(); map.put("a", "b"); assert map.get("a").equals("b"); tm.commit(); assertInCacheNotInStore(key); log.trace("About to evict..."); cache.evict(key); assertInStoreNotInCache(key); tm.begin(); map = AtomicMapLookup.getAtomicMap(cache, key); map.put("a", "c"); map.put("d", "e"); tm.commit(); }
public void testAtomicMapNonTransactionWithoutBatchSet() { ConfigurationBuilder builder = buildConfiguration(); builder.invocationBatching().disable(); builder.transaction().transactionMode(TransactionMode.NON_TRANSACTIONAL); cacheManager.defineConfiguration("ahm_no_tx_without_batch", builder.build()); Cache<String, String> ahmCache = cacheManager.getCache("ahm_no_tx_without_batch"); AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(ahmCache, "key"); assert map.isEmpty(); map.put("a", "b"); assert map.get("a").equals("b"); // now re-retrieve the map and make sure we see the diffs assert AtomicMapLookup.getAtomicMap(ahmCache, "key").get("a").equals("b"); }
public void testAtomicMapBackup() { AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache("LON", 0), "amKey"); assert map.isEmpty(); log.trace("Update is here"); map.put("a", "fancyValue"); assertEquals("fancyValue", map.get("a")); assertEquals("fancyValue", AtomicMapLookup.getAtomicMap(backup("LON"), "amKey").get("a")); }
@Override public Void call() throws Exception { // Modify atomic map from first node AtomicMap<String, String> map = AtomicMapLookup .getAtomicMap(cache1, "map"); map.put("key1", "new_value1"); assertTrue(map.containsKey("key2")); assertEquals("value2", map.get("key2")); return null; } });
public void testReadSafetyRollback() throws Exception { AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache, "map"); tm.begin(); map.put("blah", "blah"); assert map.size() == 1; assert map.get("blah").equals("blah"); assert map.containsKey("blah"); Transaction t = tm.suspend(); assertIsEmpty(map); assertIsEmptyMap(cache, "map"); tm.resume(t); tm.rollback(); assertIsEmpty(map); assertIsEmptyMap(cache, "map"); }
public void testAtomicMap() { AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache, "map"); assertIsEmpty(map); assertIsEmptyMap(cache, "map"); assert cache.containsKey("map"); map.put("blah", "blah"); assert map.size() == 1; assert map.get("blah").equals("blah"); assert map.containsKey("blah"); map.clear(); assertIsEmpty(map); assertIsEmptyMap(cache, "map"); assert cache.containsKey("map"); AtomicMapLookup.removeAtomicMap(cache, "map"); assert !cache.containsKey("map"); }