@Test public void testQueryDuringAndAfterMigrationWithIndex() throws Exception { Config cfg = new Config(); final HazelcastInstance h1 = nodeFactory.newHazelcastInstance(cfg); IMap imap = h1.getMap("employees"); imap.addIndex("name", false); imap.addIndex("active", false); int size = 500; for (int i = 0; i < size; i++) { imap.put(String.valueOf(i), new Employee("joe" + i, i % 60, ((i & 1) == 1), (double) i)); } nodeFactory.newInstances(cfg, 3); final IMap employees = h1.getMap("employees"); assertTrueAllTheTime( new AssertTask() { @Override public void run() throws Exception { Collection<Employee> values = employees.values(new SqlPredicate("active and name LIKE 'joe15%'")); for (Employee employee : values) { assertTrue(employee.isActive() && employee.getName().startsWith("joe15")); } assertEquals(6, values.size()); } }, 3); }
@Test(timeout = 300000) public void testTwoMemberWriteThrough2() throws Exception { int items = 1000; TestMapStore testMapStore = new TestMapStore(items, 0, 0); Config config = newConfig(testMapStore, 0); TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(3); HazelcastInstance h1 = nodeFactory.newHazelcastInstance(config); HazelcastInstance h2 = nodeFactory.newHazelcastInstance(config); IMap map1 = h1.getMap("default"); IMap map2 = h2.getMap("default"); for (int i = 0; i < items; i++) { map1.put(i, "value" + i); } assertTrue( "store operations could not be done wisely ", testMapStore.latchStore.await(30, TimeUnit.SECONDS)); assertEquals(items, testMapStore.getStore().size()); assertEquals(items, map1.size()); assertEquals(items, map2.size()); testMapStore.assertAwait(10); // N put-load N put-store call and 1 loadAllKeys assertEquals(items * 2 + 1, testMapStore.callCount.get()); }
@Test public void testRemovedEntry_shouldNotBeReached_afterMigration() throws Exception { String mapName = randomMapName(); TestHazelcastInstanceFactory factory = new TestHazelcastInstanceFactory(2); MapStoreTest.SimpleMapStore<Integer, Integer> store = new MapStoreTest.SimpleMapStore<Integer, Integer>(); store.store.put(1, 0); Config config = createConfig(mapName, store); HazelcastInstance node1 = factory.newHazelcastInstance(config); IMap<Integer, Integer> map = node1.getMap(mapName); map.put(1, 1); map.delete(1); HazelcastInstance node2 = factory.newHazelcastInstance(config); map = node2.getMap(mapName); Integer value = map.get(1); factory.shutdownAll(); assertNull(value); }
@Test public void testWANClusteringActivePassive() throws Exception { Config c1 = new Config(); Config c2 = new Config(); c1.getGroupConfig().setName("newyork"); c1.addWanReplicationConfig( new WanReplicationConfig() .setName("my-wan") .addTargetClusterConfig( new WanTargetClusterConfig().addEndpoint("127.0.0.1:5702").setGroupName("london"))); c1.getMapConfig("default") .setWanReplicationRef( new WanReplicationRef().setName("my-wan").setMergePolicy(PassThroughMergePolicy.NAME)); c2.getGroupConfig().setName("london"); c2.getMapConfig("default") .setWanReplicationRef( new WanReplicationRef().setName("my-wan").setMergePolicy(PassThroughMergePolicy.NAME)); HazelcastInstance h10 = Hazelcast.newHazelcastInstance(c1); HazelcastInstance h20 = Hazelcast.newHazelcastInstance(c2); int size = 1000; MergeLatch mergeLatch2 = new MergeLatch(size); getConcurrentMapManager(h20).addWanMergeListener(mergeLatch2); for (int i = 0; i < size; i++) { h10.getMap("default").put(i, "value" + i); } assertTrue("Latch state: " + mergeLatch2, mergeLatch2.await(60, TimeUnit.SECONDS)); Thread.sleep(1000); assertEquals(size, mergeLatch2.totalOperations()); assertEquals(size, h10.getMap("default").size()); assertEquals(size, h20.getMap("default").size()); for (int i = 0; i < size; i++) { assertEquals("value" + i, h20.getMap("default").get(i)); } }
@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)); } }
// ignored due to: https://github.com/hazelcast/hazelcast/issues/5035 @Ignore @Test public void testMapLoaderLoadUpdatingIndex() throws Exception { final int nodeCount = 3; String mapName = randomString(); SampleIndexableObjectMapLoader loader = new SampleIndexableObjectMapLoader(); Config config = createMapConfig(mapName, loader); NodeBuilder nodeBuilder = new NodeBuilder(nodeCount, config).build(); HazelcastInstance node = nodeBuilder.getRandomNode(); IMap<Integer, SampleIndexableObject> map = node.getMap(mapName); for (int i = 0; i < 10; i++) { map.put(i, new SampleIndexableObject("My-" + i, i)); } final SqlPredicate predicate = new SqlPredicate("name='My-5'"); assertPredicateResultCorrect(map, predicate); map.destroy(); loader.preloadValues = true; node = nodeBuilder.getRandomNode(); map = node.getMap(mapName); assertLoadAllKeysCount(loader, 1); assertPredicateResultCorrect(map, predicate); }
@Test public void testHigherBatchSize_shouldNotCauseAnyInvalidation_onClient() throws Exception { Config config = getConfig(); configureBatching(config, true, Integer.MAX_VALUE, Integer.MAX_VALUE); HazelcastInstance server = factory.newHazelcastInstance(config); factory.newHazelcastInstance(config); ClientConfig clientConfig = newClientConfig(mapName); HazelcastInstance client = factory.newHazelcastClient(clientConfig); IMap<Integer, Integer> serverMap = server.getMap(mapName); IMap<Integer, Integer> clientMap = client.getMap(mapName); int size = 1000; // fill serverMap for (int i = 0; i < size; i++) { serverMap.put(i, i); } // fill near-cache on client for (int i = 0; i < size; i++) { clientMap.get(i); } // generate invalidation data. for (int i = 0; i < size; i++) { serverMap.put(i, i); } assertNearCacheSizeEventually(clientMap, size); }
@Test public void testBatchInvalidationRemovesEntries() throws Exception { Config config = getConfig(); configureBatching(config, true, 10, 1); HazelcastInstance server = factory.newHazelcastInstance(config); factory.newHazelcastInstance(config); ClientConfig clientConfig = newClientConfig(mapName); HazelcastInstance client = factory.newHazelcastClient(clientConfig); IMap<Integer, Integer> serverMap = server.getMap(mapName); IMap<Integer, Integer> clientMap = client.getMap(mapName); int size = 1000; // fill serverMap for (int i = 0; i < size; i++) { serverMap.put(i, i); } // fill near-cache on client for (int i = 0; i < size; i++) { clientMap.get(i); } // generate invalidation data. for (int i = 0; i < size; i++) { serverMap.put(i, i); } assertNearCacheSizeEventually(clientMap, 0); }
@Test public void testMapEvictAll_shouldClearNearCaches_onOwnerAndBackupNodes() throws Exception { Config config = getConfig(); configureBatching(config, true, 10, 1); HazelcastInstance server = factory.newHazelcastInstance(config); factory.newHazelcastInstance(config); ClientConfig clientConfig = newClientConfig(mapName); HazelcastInstance client = factory.newHazelcastClient(clientConfig); IMap<Integer, Integer> serverMap = server.getMap(mapName); IMap<Integer, Integer> clientMap = client.getMap(mapName); int size = 1000; // fill serverMap for (int i = 0; i < size; i++) { serverMap.put(i, i); } // fill near-cache on client for (int i = 0; i < size; i++) { clientMap.get(i); } serverMap.evictAll(); assertNearCacheSizeEventually(clientMap, 0); }
@Test(timeout = MINUTE) public void testQueryDuringAndAfterMigration() throws Exception { HazelcastInstance h1 = nodeFactory.newHazelcastInstance(); int count = 500; IMap imap = h1.getMap("employees"); for (int i = 0; i < count; i++) { imap.put(String.valueOf(i), new Employee("joe" + i, i % 60, ((i & 1) == 1), (double) i)); } nodeFactory.newInstances(new Config(), 3); final IMap employees = h1.getMap("employees"); assertTrueAllTheTime( new AssertTask() { @Override public void run() throws Exception { Collection<Employee> values = employees.values(new SqlPredicate("active and name LIKE 'joe15%'")); for (Employee employee : values) { assertTrue(employee.isActive()); } assertEquals(6, values.size()); } }, 3); }
@Test public void equalsReadLocalBackup() { TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(2); Config config = new Config(); config.addMapConfig( new MapConfig("objectMap") .setInMemoryFormat(InMemoryFormat.OBJECT) .setReadBackupData(true)); HazelcastInstance hz1 = factory.newHazelcastInstance(config); HazelcastInstance hz2 = factory.newHazelcastInstance(config); Pair pair = new Pair("a", "1"); IMap<String, Pair> objectMap1 = hz1.getMap("objectMap"); IMap<String, Pair> objectMap2 = hz2.getMap("objectMap"); objectMap1.put("1", pair); Pair v1 = objectMap1.get("1"); Pair v2 = objectMap1.get("1"); Pair rv1 = objectMap2.get("1"); Pair rv2 = objectMap2.get("1"); assertNotSame(pair, v1); assertNotSame(pair, v2); assertNotSame(v1, v2); assertNotSame(pair, rv1); assertNotSame(pair, rv2); assertNotSame(rv1, rv2); assertTrue(objectMap2.containsValue(v1)); }
@Test public void testIndexDoesNotReturnStaleResultsAfterSplit() { String mapName = randomMapName(); Config config = newConfig(LatestUpdateMapMergePolicy.class.getName(), mapName); HazelcastInstance h1 = Hazelcast.newHazelcastInstance(config); HazelcastInstance h2 = Hazelcast.newHazelcastInstance(config); TestMembershipListener membershipListener = new TestMembershipListener(1); h2.getCluster().addMembershipListener(membershipListener); TestLifecycleListener lifecycleListener = new TestLifecycleListener(1); h2.getLifecycleService().addLifecycleListener(lifecycleListener); RealtimeCall call = new RealtimeCall(); String key = generateKeyOwnedBy(h1); call.setId(key); call.setClusterUUID(key); IMap<PartitionAwareKey<String, String>, RealtimeCall> map1 = h1.getMap(mapName); IMap<PartitionAwareKey<String, String>, RealtimeCall> map2 = h2.getMap(mapName); map1.put(call.getAffinityKey(), call); sleepMillis(1); assertNotNull("entry should be in map2 before split", map2.get(call.getAffinityKey())); closeConnectionBetween(h1, h2); assertOpenEventually(membershipListener.latch); assertClusterSizeEventually(1, h1); assertClusterSizeEventually(1, h2); map1 = h1.getMap(mapName); map1.remove(call.getAffinityKey()); sleepMillis(1); map2 = h2.getMap(mapName); assertNotNull("entry should be in map2 in split", map2.get(call.getAffinityKey())); assertOpenEventually(lifecycleListener.latch); assertClusterSizeEventually(2, h1); assertClusterSizeEventually(2, h2); map1 = h1.getMap(mapName); assertNotNull("entry should be in map1", map1.get(call.getAffinityKey())); map1.remove(call.getAffinityKey()); assertNull("map1 should be null", map1.get(call.getAffinityKey())); assertNull("map2 should be null", map2.get(call.getAffinityKey())); for (int i = 0; i < 100; i++) { Collection<RealtimeCall> calls = map1.values(Predicates.equal("id", call.getId())); System.out.println("Map 1 query by uuid: " + calls.size()); assert calls.size() == 0; calls = map2.values(Predicates.equal("id", call.getId())); System.out.println("Map 2 query by uuid: " + calls.size()); assert calls.size() == 0; sleepMillis(5); } }
/* github issue #183 */ @Test public void testKeyBasedListeners() throws InterruptedException { try { Config config = new Config(); HazelcastInstance instance = Hazelcast.newHazelcastInstance(config); IMap<String, String> map = instance.getMap("map"); map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); ClientConfig clientConfig = new ClientConfig(); HazelcastInstance client = HazelcastClient.newHazelcastClient(clientConfig); final AtomicInteger count = new AtomicInteger(0); IMap<String, String> clientMap = client.getMap("map"); clientMap.addEntryListener( new EntryListener<String, String>() { public void entryAdded(EntryEvent<String, String> entryEvent) { count.incrementAndGet(); } public void entryRemoved(EntryEvent<String, String> entryEvent) {} public void entryUpdated(EntryEvent<String, String> entryEvent) { count.incrementAndGet(); } public void entryEvicted(EntryEvent<String, String> entryEvent) {} }, "key1", true); clientMap.addEntryListener( new EntryListener<String, String>() { public void entryAdded(EntryEvent<String, String> entryEvent) { count.incrementAndGet(); } public void entryRemoved(EntryEvent<String, String> entryEvent) {} public void entryUpdated(EntryEvent<String, String> entryEvent) { System.out.println("event map"); count.incrementAndGet(); } public void entryEvicted(EntryEvent<String, String> entryEvent) {} }, "key2", true); map.put("key1", "new-value1"); Thread.sleep(100); Assert.assertEquals(count.get(), 1); } catch (InterruptedException e) { e.printStackTrace(); } }
private void start() throws IOException { if (logPath != null) { PropertyConfigurator.configure(logPath.getAbsolutePath()); } if (!hazelcastFile.isFile()) { throw new RuntimeException("Could not find hazelcast configuration file : " + hazelcastFile); } /* * Start a lightweight http server, make sure it can only be accessed * from the machine it's running on (don't want to allow remote * shutdown). */ server = HttpServer.create(new InetSocketAddress(host, port), port); server.createContext(baseContext + HazelcastServiceCommand.stop, new ShutdownHandler()); server.createContext(baseContext + HazelcastServiceCommand.status, new StatusHandler()); server.setExecutor(null); server.start(); // Config config = new Config(); // config.setConfigurationFile(hazelcastFile); // config.setConfigurationUrl(hazelcastFile.toURI().toURL()); // hz = Hazelcast.newHazelcastInstance(config); /* * Creating a Config object (as commented out above) and setting the * file using setConfigurationFile doesn't seem to work at all. The * system property approach does. */ String path = hazelcastFile.getAbsolutePath(); logger.info("Setting configuration file " + path); System.setProperty("hazelcast.config", path); hz = Hazelcast.getDefaultInstance(); logger.info(hz.getConfig().getConfigurationFile()); logger.info(hz.getConfig().getGroupConfig().getName()); monitor = new HazelcastMonitor(); hz.addInstanceListener(monitor); if (testValues) { hz.getMap("tst").put("1", "1"); hz.getMap("tst").put("2", "2"); hz.getMap("tst").put("3", "3"); logger.info(hz.getMap("tst").getId()); logger.info(hz.getMap("tst").size()); } System.out.println("-- HAZELCAST SERVICE WRAPPER READY --"); System.out.println( String.format("To check status, request: '%s'.", url(HazelcastServiceCommand.status))); System.out.println( String.format("To shut it down, request: '%s'.", url(HazelcastServiceCommand.stop))); }
public static void main(String[] args) throws Exception { HazelcastInstance hz = Hazelcast.newHazelcastInstance(); Person person = new Person("Joe"); IMap<String, String> hzSimpleMap = hz.getMap("simple"); hzSimpleMap.set("key1", "value1"); IMap<String, Person> hzObjectMap = hz.getMap("object"); hzObjectMap.set("key1", person); }
@Test public void testEntity() { final HazelcastInstance hz = getHazelcastInstance(sf); assertNotNull(hz); final int count = 100; final int childCount = 3; insertDummyEntities(count, childCount); List<DummyEntity> list = new ArrayList<DummyEntity>(count); Session session = sf.openSession(); try { for (int i = 0; i < count; i++) { DummyEntity e = (DummyEntity) session.get(DummyEntity.class, (long) i); session.evict(e); list.add(e); } } finally { session.close(); } session = sf.openSession(); Transaction tx = session.beginTransaction(); try { for (DummyEntity dummy : list) { dummy.setDate(new Date()); session.update(dummy); } tx.commit(); } catch (Exception e) { tx.rollback(); e.printStackTrace(); } finally { session.close(); } Statistics stats = sf.getStatistics(); Map<?, ?> cache = hz.getMap(DummyEntity.class.getName()); Map<?, ?> propCache = hz.getMap(DummyProperty.class.getName()); Map<?, ?> propCollCache = hz.getMap(DummyEntity.class.getName() + ".properties"); assertEquals((childCount + 1) * count, stats.getEntityInsertCount()); // twice put of entity and properties (on load and update) and once put of collection // TODO: fix next assertion -> // assertEquals((childCount + 1) * count * 2, stats.getSecondLevelCachePutCount()); assertEquals(childCount * count, stats.getEntityLoadCount()); assertEquals(count, stats.getSecondLevelCacheHitCount()); // collection cache miss assertEquals(count, stats.getSecondLevelCacheMissCount()); assertEquals(count, cache.size()); assertEquals(count * childCount, propCache.size()); assertEquals(count, propCollCache.size()); sf.getCache().evictEntityRegion(DummyEntity.class); sf.getCache().evictEntityRegion(DummyProperty.class); assertEquals(0, cache.size()); assertEquals(0, propCache.size()); stats.logSummary(); }
@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)); }
@Test public void testBasicUsage() throws Exception { int n = 3; String mapName = "test"; Config config = new Config(); config .getMapConfig(mapName) .setNearCacheConfig(new NearCacheConfig().setInvalidateOnChange(true)); TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(n); HazelcastInstance[] instances = factory.newInstances(config); IMap<Object, Object> map = instances[0].getMap(mapName); int count = 5000; for (int i = 0; i < count; i++) { map.put(i, i); } for (HazelcastInstance instance : instances) { IMap<Object, Object> m = instance.getMap(mapName); for (int i = 0; i < count; i++) { Assert.assertNotNull(m.get(i)); } } for (int i = 0; i < count; i++) { map.put(i, i * 2); } for (HazelcastInstance instance : instances) { IMap<Object, Object> m = instance.getMap(mapName); for (int i = 0; i < count; i++) { Assert.assertNotNull(m.get(i)); } } for (HazelcastInstance instance : instances) { NearCache nearCache = getNearCache(mapName, instance); int size = nearCache.size(); assertTrue("NearCache Size: " + size, size > 0); } map.clear(); for (HazelcastInstance instance : instances) { NearCache nearCache = getNearCache(mapName, instance); int size = nearCache.size(); assertEquals(0, size); } }
@Test(timeout = 120000) public void testGetAllKeys() throws Exception { TestEventBasedMapStore testMapStore = new TestEventBasedMapStore(); Map store = testMapStore.getStore(); Set keys = new HashSet(); int size = 1000; for (int i = 0; i < size; i++) { store.put(i, "value" + i); keys.add(i); } Config config = newConfig(testMapStore, 2); TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(3); HazelcastInstance h1 = nodeFactory.newHazelcastInstance(config); HazelcastInstance h2 = nodeFactory.newHazelcastInstance(config); IMap map1 = h1.getMap("default"); IMap map2 = h2.getMap("default"); // checkIfMapLoaded("default", h1); // checkIfMapLoaded("default", h2); assertEquals("value1", map1.get(1)); assertEquals("value1", map2.get(1)); assertEquals(1000, map1.size()); assertEquals(1000, map2.size()); HazelcastInstance h3 = nodeFactory.newHazelcastInstance(config); IMap map3 = h3.getMap("default"); // checkIfMapLoaded("default", h3); assertEquals("value1", map1.get(1)); assertEquals("value1", map2.get(1)); assertEquals("value1", map3.get(1)); assertEquals(1000, map1.size()); assertEquals(1000, map2.size()); assertEquals(1000, map3.size()); h3.shutdown(); assertEquals("value1", map1.get(1)); assertEquals("value1", map2.get(1)); assertEquals(1000, map1.size()); assertEquals(1000, map2.size()); }
@Test public void testOneQuorumsFailsOneQuorumSuccessForDifferentMaps() throws Exception { TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(3); String fourNodeQuorum = randomString(); QuorumConfig fourNodeQuorumConfig = new QuorumConfig(fourNodeQuorum, true); fourNodeQuorumConfig.setQuorumFunctionImplementation( new QuorumFunction() { @Override public boolean apply(Collection<Member> members) { return members.size() == 4; } }); String threeNodeQuorum = randomString(); QuorumConfig threeNodeQuorumConfig = new QuorumConfig(threeNodeQuorum, true); threeNodeQuorumConfig.setQuorumFunctionImplementation( new QuorumFunction() { @Override public boolean apply(Collection<Member> members) { return members.size() == 3; } }); MapConfig fourNodeMapConfig = new MapConfig("fourNode"); fourNodeMapConfig.setQuorumName(fourNodeQuorum); MapConfig threeNodeMapConfig = new MapConfig("threeNode"); threeNodeMapConfig.setQuorumName(threeNodeQuorum); Config config = new Config(); config.addQuorumConfig(threeNodeQuorumConfig); config.addQuorumConfig(fourNodeQuorumConfig); config.addMapConfig(fourNodeMapConfig); config.addMapConfig(threeNodeMapConfig); HazelcastInstance h1 = factory.newHazelcastInstance(config); HazelcastInstance h2 = factory.newHazelcastInstance(config); HazelcastInstance h3 = factory.newHazelcastInstance(config); IMap<Object, Object> fourNode = h1.getMap("fourNode"); IMap<Object, Object> threeNode = h1.getMap("threeNode"); threeNode.put(generateKeyOwnedBy(h1), "bar"); try { fourNode.put(generateKeyOwnedBy(h1), "bar"); fail(); } catch (Exception e) { } }
@Test(timeout = 120000) public void testInitialLoadModeEagerMultipleThread() { final String mapName = "default"; final int instanceCount = 2; final int size = 10000; final TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(instanceCount); final CountDownLatch countDownLatch = new CountDownLatch(instanceCount - 1); final Config config = getConfig(); GroupConfig groupConfig = new GroupConfig("testEager"); config.setGroupConfig(groupConfig); MapStoreConfig mapStoreConfig = new MapStoreConfig(); mapStoreConfig.setEnabled(true); mapStoreConfig.setImplementation(new SimpleMapLoader(size, true)); mapStoreConfig.setInitialLoadMode(MapStoreConfig.InitialLoadMode.EAGER); config.getMapConfig(mapName).setMapStoreConfig(mapStoreConfig); HazelcastInstance instance1 = nodeFactory.newHazelcastInstance(config); Runnable runnable = new Runnable() { public void run() { HazelcastInstance instance2 = nodeFactory.newHazelcastInstance(config); final IMap<Object, Object> map = instance2.getMap(mapName); assertEquals(size, map.size()); countDownLatch.countDown(); } }; new Thread(runnable).start(); assertOpenEventually(countDownLatch, 120); IMap map = instance1.getMap(mapName); assertEquals(size, map.size()); }
@Test(timeout = 120000) public void testMapStoreWriteRemoveOrder() { final String mapName = randomMapName("testMapStoreWriteDeleteOrder"); final int numIterations = 10; final int writeDelaySeconds = 3; // create map store implementation final RecordingMapStore store = new RecordingMapStore(0, 1); // create hazelcast config final Config config = newConfig(mapName, store, writeDelaySeconds); // start hazelcast instance final HazelcastInstance hzInstance = createHazelcastInstance(config); // loop over num iterations final IMap<String, String> map = hzInstance.getMap(mapName); for (int k = 0; k < numIterations; k++) { String key = String.valueOf(k + 10); // 2 digits for sorting in output String value = "v:" + key; // add entry map.put(key, value); // sleep 300ms sleepMillis(1); // remove entry map.remove(key); } // wait for store to finish store.awaitStores(); // wait for remove to finish store.awaitRemoves(); assertEquals(0, store.getStore().size()); }
@Test(timeout = 120000) public void testMapStoreNotCalledFromEntryProcessorBackup() throws Exception { final String mapName = "testMapStoreNotCalledFromEntryProcessorBackup_" + randomString(); final int instanceCount = 2; Config config = getConfig(); // Configure map with one backup and dummy map store MapConfig mapConfig = config.getMapConfig(mapName); mapConfig.setBackupCount(1); MapStoreConfig mapStoreConfig = new MapStoreConfig(); MapStoreWithStoreCount mapStore = new MapStoreWithStoreCount(1, 120); mapStoreConfig.setImplementation(mapStore); mapConfig.setMapStoreConfig(mapStoreConfig); TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(instanceCount); HazelcastInstance instance1 = nodeFactory.newHazelcastInstance(config); HazelcastInstance instance2 = nodeFactory.newHazelcastInstance(config); final IMap<String, String> map = instance1.getMap(mapName); final String key = "key"; final String value = "value"; // executeOnKey map.executeOnKey(key, new ValueSetterEntryProcessor(value)); mapStore.awaitStores(); assertEquals(value, map.get(key)); assertEquals(1, mapStore.getCount()); }
@Test(timeout = 120000) public void testIssue1142ExceptionWhenLoadAllReturnsNull() { Config config = getConfig(); String mapname = "testIssue1142ExceptionWhenLoadAllReturnsNull"; MapStoreConfig mapStoreConfig = new MapStoreConfig(); mapStoreConfig.setImplementation( new MapStoreAdapter<String, String>() { @Override public Set<String> loadAllKeys() { Set keys = new HashSet(); keys.add("key"); return keys; } public Map loadAll(Collection keys) { return null; } }); config.getMapConfig(mapname).setMapStoreConfig(mapStoreConfig); TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(2); HazelcastInstance instance = nodeFactory.newHazelcastInstance(config); HazelcastInstance instance2 = nodeFactory.newHazelcastInstance(config); final IMap map = instance.getMap(mapname); for (int i = 0; i < 300; i++) { map.put(i, i); } assertEquals(300, map.size()); }
@Test(timeout = 120000) public void testIssue991EvictedNullIssue() throws InterruptedException { MapStoreConfig mapStoreConfig = new MapStoreConfig(); mapStoreConfig.setEnabled(true); mapStoreConfig.setImplementation( new MapLoader<String, String>() { @Override public String load(String key) { return null; } @Override public Map<String, String> loadAll(Collection<String> keys) { return null; } @Override public Set<String> loadAllKeys() { return null; } }); Config config = getConfig(); config.getMapConfig("testIssue991EvictedNullIssue").setMapStoreConfig(mapStoreConfig); HazelcastInstance hc = createHazelcastInstance(config); IMap<Object, Object> map = hc.getMap("testIssue991EvictedNullIssue"); map.get("key"); assertNull(map.get("key")); map.put("key", "value"); Thread.sleep(2000); assertEquals("value", map.get("key")); }
@Test(timeout = 120000) public void testOneMemberFlush() throws Exception { TestMapStore testMapStore = new TestMapStore(1, 1, 1); testMapStore.setLoadAllKeys(false); int size = 100; Config config = newConfig(testMapStore, 200); TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(3); HazelcastInstance h1 = nodeFactory.newHazelcastInstance(config); IMap map = h1.getMap("default"); assertEquals(0, map.size()); for (int i = 0; i < size; i++) { map.put(i, i); } assertEquals(size, map.size()); assertEquals(0, testMapStore.getStore().size()); assertEquals(size, map.getLocalMapStats().getDirtyEntryCount()); map.flush(); assertEquals(size, testMapStore.getStore().size()); assertEquals(0, map.getLocalMapStats().getDirtyEntryCount()); assertEquals(size, map.size()); for (int i = 0; i < size / 2; i++) { map.remove(i); } assertEquals(size / 2, map.size()); assertEquals(size, testMapStore.getStore().size()); map.flush(); assertEquals(size / 2, testMapStore.getStore().size()); assertEquals(size / 2, map.size()); }
@Test(timeout = 120000) public void testIssue583MapReplaceShouldTriggerMapStore() { final ConcurrentMap<String, Long> store = new ConcurrentHashMap<String, Long>(); final MapStore<String, Long> myMapStore = new SimpleMapStore<String, Long>(store); Config config = getConfig(); config .getMapConfig("myMap") .setMapStoreConfig(new MapStoreConfig().setImplementation(myMapStore)); TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(3); HazelcastInstance hc = nodeFactory.newHazelcastInstance(config); IMap<String, Long> myMap = hc.getMap("myMap"); myMap.put("one", 1L); assertEquals(1L, myMap.get("one").longValue()); assertEquals(1L, store.get("one").longValue()); myMap.putIfAbsent("two", 2L); assertEquals(2L, myMap.get("two").longValue()); assertEquals(2L, store.get("two").longValue()); myMap.putIfAbsent("one", 5L); assertEquals(1L, myMap.get("one").longValue()); assertEquals(1L, store.get("one").longValue()); myMap.replace("one", 1L, 111L); assertEquals(111L, myMap.get("one").longValue()); assertEquals(111L, store.get("one").longValue()); myMap.replace("one", 1L); assertEquals(1L, myMap.get("one").longValue()); assertEquals(1L, store.get("one").longValue()); }
@Test(timeout = 120000) public void testSlowStore() throws Exception { final TestMapStore store = new WaitingOnFirstTestMapStore(); Config config = getConfig(); MapStoreConfig mapStoreConfig = new MapStoreConfig(); mapStoreConfig.setEnabled(true); mapStoreConfig.setWriteDelaySeconds(1); mapStoreConfig.setImplementation(store); config.getMapConfig("default").setMapStoreConfig(mapStoreConfig); HazelcastInstance h1 = createHazelcastInstance(config); final IMap<Integer, Integer> map = h1.getMap("testSlowStore"); int count = 1000; for (int i = 0; i < count; i++) { map.put(i, 1); } Thread.sleep(2000); // sleep for scheduling following puts to a different second for (int i = 0; i < count; i++) { map.put(i, 2); } for (int i = 0; i < count; i++) { final int index = i; assertTrueEventually( new AssertTask() { @Override public void run() throws Exception { final Integer valueInMap = map.get(index); final Integer valueInStore = (Integer) store.getStore().get(index); assertEquals(valueInMap, valueInStore); } }); } }
@Test public void setMapStoreConfigImplementationTest() { String mapName = "mapStoreImpObjTest"; String xml = "<hazelcast xmlns=\"http://www.hazelcast.com/schema/config\">\n" + "<map name=\"" + mapName + "\">\n" + "<map-store enabled=\"true\">\n" + "<class-name>com.hazelcast.config.helpers.DummyMapStore</class-name>\n" + "<write-delay-seconds>5</write-delay-seconds>\n" + "</map-store>\n" + "</map>\n" + "</hazelcast>\n"; Config config = buildConfig(xml); HazelcastInstance hz = createHazelcastInstance(config); hz.getMap(mapName); MapConfig mapConfig = hz.getConfig().getMapConfig(mapName); MapStoreConfig mapStoreConfig = mapConfig.getMapStoreConfig(); Object o = mapStoreConfig.getImplementation(); assertNotNull(o); assertTrue(o instanceof DummyMapStore); }
@Test public void testHeartbeatResumedEvent() throws InterruptedException { hazelcastFactory.newHazelcastInstance(); HazelcastInstance client = hazelcastFactory.newHazelcastClient(getClientConfig()); final HazelcastInstance instance2 = hazelcastFactory.newHazelcastInstance(); // make sure client is connected to instance2 String keyOwnedByInstance2 = generateKeyOwnedBy(instance2); IMap<String, String> map = client.getMap(randomString()); map.put(keyOwnedByInstance2, randomString()); HazelcastClientInstanceImpl clientImpl = getHazelcastClientInstanceImpl(client); ClientConnectionManager connectionManager = clientImpl.getConnectionManager(); final CountDownLatch countDownLatch = new CountDownLatch(1); connectionManager.addConnectionHeartbeatListener( new ConnectionHeartbeatListener() { @Override public void heartbeatResumed(Connection connection) { assertEquals( instance2.getCluster().getLocalMember().getAddress(), connection.getEndPoint()); countDownLatch.countDown(); } @Override public void heartbeatStopped(Connection connection) {} }); blockMessagesFromInstance(instance2, client); sleepMillis(HEARTBEAT_TIMEOUT_MILLIS * 2); unblockMessagesFromInstance(instance2, client); assertOpenEventually(countDownLatch); }