Beispiel #1
0
  @Test
  public void testCacheLocalEntries() {
    int n = 2;
    String mapName = "test";

    Config config = new Config();
    final NearCacheConfig nearCacheConfig = new NearCacheConfig();
    nearCacheConfig.setCacheLocalEntries(true);
    nearCacheConfig.setInvalidateOnChange(false);
    final MapConfig mapConfig = config.getMapConfig(mapName);
    mapConfig.setNearCacheConfig(nearCacheConfig);
    HazelcastInstance instance = createHazelcastInstanceFactory(n).newInstances(config)[0];

    IMap<String, String> map = instance.getMap(mapName);

    int noOfEntries = 100;

    for (int i = 0; i < noOfEntries; i++) {
      map.put("key" + i, "value" + i);
    }

    // warm-up cache
    for (int i = 0; i < noOfEntries; i++) {
      map.get("key" + i);
    }

    NearCache nearCache = getNearCache(mapName, instance);
    assertEquals(noOfEntries, nearCache.size());
  }
Beispiel #2
0
 @Test
 public void testNearCacheEvictionByUsingMapClear() throws InterruptedException {
   final Config cfg = new Config();
   final String mapName = "testNearCacheEviction";
   final NearCacheConfig nearCacheConfig = new NearCacheConfig();
   nearCacheConfig.setInvalidateOnChange(true);
   cfg.getMapConfig(mapName).setNearCacheConfig(nearCacheConfig);
   final TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(2);
   final HazelcastInstance hazelcastInstance1 = factory.newHazelcastInstance(cfg);
   final HazelcastInstance hazelcastInstance2 = factory.newHazelcastInstance(cfg);
   final IMap map1 = hazelcastInstance1.getMap(mapName);
   final IMap map2 = hazelcastInstance2.getMap(mapName);
   final int size = 10;
   // populate map.
   for (int i = 0; i < size; i++) {
     map1.put(i, i);
   }
   // populate near cache
   for (int i = 0; i < size; i++) {
     map1.get(i);
     map2.get(i);
   }
   // clear map should trigger near cache eviction.
   map1.clear();
   for (int i = 0; i < size; i++) {
     assertNull(map1.get(i));
   }
 }
  protected ClientConfig newClientConfig(String mapName) {
    NearCacheConfig nearCacheConfig = new NearCacheConfig();
    nearCacheConfig.setInMemoryFormat(getNearCacheInMemoryFormat());
    nearCacheConfig.setName(mapName);
    nearCacheConfig.setInvalidateOnChange(true);
    nearCacheConfig.setCacheLocalEntries(true);

    ClientConfig clientConfig = new ClientConfig();
    clientConfig.addNearCacheConfig(nearCacheConfig);

    return clientConfig;
  }
Beispiel #4
0
 @Test
 public void testNearCacheEvictionByUsingMapTTLEviction() throws InterruptedException {
   final int instanceCount = 3;
   final int ttl = 1;
   final int size = 1000;
   final Config cfg = new Config();
   final String mapName = "_testNearCacheEvictionByUsingMapTTLEviction_";
   final NearCacheConfig nearCacheConfig = new NearCacheConfig();
   nearCacheConfig.setInvalidateOnChange(true);
   nearCacheConfig.setInMemoryFormat(InMemoryFormat.OBJECT);
   cfg.getMapConfig(mapName).setNearCacheConfig(nearCacheConfig);
   final MapConfig mapConfig = cfg.getMapConfig(mapName);
   mapConfig.setTimeToLiveSeconds(ttl);
   final TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(instanceCount);
   final HazelcastInstance instance1 = factory.newHazelcastInstance(cfg);
   final HazelcastInstance instance2 = factory.newHazelcastInstance(cfg);
   final HazelcastInstance instance3 = factory.newHazelcastInstance(cfg);
   final IMap map1 = instance1.getMap(mapName);
   final IMap map2 = instance2.getMap(mapName);
   final IMap map3 = instance3.getMap(mapName);
   // observe eviction
   final CountDownLatch latch = new CountDownLatch(size);
   map1.addEntryListener(
       new EntryAdapter() {
         public void entryEvicted(EntryEvent event) {
           latch.countDown();
         }
       },
       false);
   // populate map
   for (int i = 0; i < size; i++) {
     // populate.
     map1.put(i, i);
     // bring near caches. -- here is a time window
     // that "i" already evicted. so a "get" brings
     // a NULL object to the near cache.
     map1.get(i);
     map2.get(i);
     map3.get(i);
   }
   // wait operations to complete
   assertOpenEventually(latch);
   // check map size after eviction.
   assertEquals(0, map1.size());
   assertEquals(0, map2.size());
   assertEquals(0, map3.size());
   // near cache sizes should be zero after eviction.
   assertEquals(0, countNotNullValuesInNearCache(mapName, instance1));
   assertEquals(0, countNotNullValuesInNearCache(mapName, instance2));
   assertEquals(0, countNotNullValuesInNearCache(mapName, instance3));
 }