@Test public void testClientListenerDisconnected() throws InterruptedException { Config config = new Config(); config.setProperty(GroupProperties.PROP_IO_THREAD_COUNT, "1"); final HazelcastInstance hz = Hazelcast.newHazelcastInstance(config); final HazelcastInstance hz2 = Hazelcast.newHazelcastInstance(config); int clientCount = 10; ClientDisconnectedListenerLatch listenerLatch = new ClientDisconnectedListenerLatch(2 * clientCount); hz.getClientService().addClientListener(listenerLatch); hz2.getClientService().addClientListener(listenerLatch); Collection<HazelcastInstance> clients = new LinkedList<HazelcastInstance>(); for (int i = 0; i < clientCount; i++) { HazelcastInstance client = HazelcastClient.newHazelcastClient(); IMap<Object, Object> map = client.getMap(randomMapName()); map.addEntryListener(new EntryAdapter<Object, Object>(), true); map.put(generateKeyOwnedBy(hz), "value"); map.put(generateKeyOwnedBy(hz2), "value"); clients.add(client); } ExecutorService ex = Executors.newFixedThreadPool(4); try { for (final HazelcastInstance client : clients) { ex.execute( new Runnable() { @Override public void run() { client.shutdown(); } }); } assertOpenEventually(listenerLatch, 30); assertTrueEventually( new AssertTask() { @Override public void run() throws Exception { assertEquals(0, hz.getClientService().getConnectedClients().size()); } }, 10); assertTrueEventually( new AssertTask() { @Override public void run() throws Exception { assertEquals(0, hz2.getClientService().getConnectedClients().size()); } }, 10); } finally { ex.shutdown(); } }
@Repeat(25) @Test public void testEachConnectionUseDifferentSelectorEventually() { Config config = new Config(); config.setProperty(GroupProperties.PROP_IO_BALANCER_INTERVAL_SECONDS, "1"); config.setProperty(GroupProperties.PROP_IO_THREAD_COUNT, "2"); HazelcastInstance instance1 = Hazelcast.newHazelcastInstance(config); HazelcastInstance instance2 = Hazelcast.newHazelcastInstance(config); HazelcastInstance instance3 = Hazelcast.newHazelcastInstance(config); instance2.shutdown(); instance2 = Hazelcast.newHazelcastInstance(config); IMap<Integer, Integer> map = instance1.getMap(randomMapName()); long deadLine = System.currentTimeMillis() + TEST_DURATION_SECONDS * 1000; for (int i = 0; System.currentTimeMillis() < deadLine; i++) { map.put(i % 1000, i); } assertBalanced(instance1); assertBalanced(instance2); assertBalanced(instance3); }
@Test public void testOperationNotBlockingAfterClusterShutdown() throws InterruptedException { final HazelcastInstance instance1 = Hazelcast.newHazelcastInstance(); final HazelcastInstance instance2 = Hazelcast.newHazelcastInstance(); final ClientConfig clientConfig = new ClientConfig(); clientConfig.getNetworkConfig().setConnectionAttemptLimit(Integer.MAX_VALUE); final HazelcastInstance client = HazelcastClient.newHazelcastClient(clientConfig); final IMap<String, String> m = client.getMap("m"); m.put("elif", "Elif"); m.put("ali", "Ali"); m.put("alev", "Alev"); instance1.getLifecycleService().terminate(); instance2.getLifecycleService().terminate(); final CountDownLatch latch = new CountDownLatch(1); new Thread() { public void run() { try { m.get("ali"); } catch (Exception ignored) { latch.countDown(); } } }.start(); assertOpenEventually(latch); }
@BeforeClass public static void init() { instance1 = Hazelcast.newHazelcastInstance(); instance2 = Hazelcast.newHazelcastInstance(); instance3 = Hazelcast.newHazelcastInstance(); client = HazelcastClient.newHazelcastClient(); }
@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 testLatestAccessCacheMergePolicy() { String cacheName = randomMapName(); Config config = newConfig(); 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); closeConnectionBetween(h1, h2); assertOpenEventually(memberShipListener.latch); assertClusterSizeEventually(1, h1); assertClusterSizeEventually(1, h2); CachingProvider cachingProvider1 = HazelcastServerCachingProvider.createCachingProvider(h1); CachingProvider cachingProvider2 = HazelcastServerCachingProvider.createCachingProvider(h2); CacheManager cacheManager1 = cachingProvider1.getCacheManager(); CacheManager cacheManager2 = cachingProvider2.getCacheManager(); CacheConfig cacheConfig = newCacheConfig(cacheName, LatestAccessCacheMergePolicy.class.getName()); Cache cache1 = cacheManager1.createCache(cacheName, cacheConfig); Cache cache2 = cacheManager2.createCache(cacheName, cacheConfig); // TODO We assume that until here and also while doing get/put, cluster is still splitted. // This assumptions seems fragile due to time sensitivity. cache1.put("key1", "value"); assertEquals("value", cache1.get("key1")); // Access to record // Prevent updating at the same time sleepAtLeastMillis(1); cache2.put("key1", "LatestUpdatedValue"); assertEquals("LatestUpdatedValue", cache2.get("key1")); // Access to record cache2.put("key2", "value2"); assertEquals("value2", cache2.get("key2")); // Access to record // Prevent updating at the same time sleepAtLeastMillis(1); cache1.put("key2", "LatestUpdatedValue2"); assertEquals("LatestUpdatedValue2", cache1.get("key2")); // Access to record assertOpenEventually(lifeCycleListener.latch); assertClusterSizeEventually(2, h1); assertClusterSizeEventually(2, h2); Cache cacheTest = cacheManager1.getCache(cacheName); assertEquals("LatestUpdatedValue", cacheTest.get("key1")); assertEquals("LatestUpdatedValue2", cacheTest.get("key2")); }
@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); } }
@Test public void testSwitchingMasters() throws Exception { Config c1 = buildConfig(false); Config c2 = buildConfig(false); Config c3 = buildConfig(false); Config c4 = buildConfig(false); Config c5 = buildConfig(false); c1.getNetworkConfig().setPort(55701); c2.getNetworkConfig().setPort(55702); c3.getNetworkConfig().setPort(55703); c4.getNetworkConfig().setPort(55704); c5.getNetworkConfig().setPort(55705); List<String> allMembers = Arrays.asList( "127.0.0.1:55701", "127.0.0.1:55702", "127.0.0.1:55703", "127.0.0.1:55704", "127.0.0.1:55705"); c1.getNetworkConfig().getJoin().getTcpIpConfig().setMembers(allMembers); c2.getNetworkConfig().getJoin().getTcpIpConfig().setMembers(allMembers); c3.getNetworkConfig().getJoin().getTcpIpConfig().setMembers(allMembers); c4.getNetworkConfig().getJoin().getTcpIpConfig().setMembers(allMembers); c5.getNetworkConfig().getJoin().getTcpIpConfig().setMembers(allMembers); final HazelcastInstance h1 = Hazelcast.newHazelcastInstance(c1); final HazelcastInstance h2 = Hazelcast.newHazelcastInstance(c2); final HazelcastInstance h3 = Hazelcast.newHazelcastInstance(c3); final HazelcastInstance h4 = Hazelcast.newHazelcastInstance(c4); final HazelcastInstance h5 = Hazelcast.newHazelcastInstance(c5); assertEquals(5, h1.getCluster().getMembers().size()); assertEquals(5, h2.getCluster().getMembers().size()); assertEquals(5, h3.getCluster().getMembers().size()); assertEquals(5, h4.getCluster().getMembers().size()); assertEquals(5, h5.getCluster().getMembers().size()); // Need to wait for at least as long as PROP_MAX_NO_MASTER_CONFIRMATION_SECONDS Thread.sleep(15 * 1000); h1.getLifecycleService().shutdown(); Thread.sleep(3 * 1000); assertEquals(4, h2.getCluster().getMembers().size()); assertEquals(4, h3.getCluster().getMembers().size()); assertEquals(4, h4.getCluster().getMembers().size()); assertEquals(4, h5.getCluster().getMembers().size()); Thread.sleep(10 * 1000); assertEquals(4, h2.getCluster().getMembers().size()); assertEquals(4, h3.getCluster().getMembers().size()); assertEquals(4, h4.getCluster().getMembers().size()); assertEquals(4, h5.getCluster().getMembers().size()); }
@Test(expected = RuntimeException.class, timeout = 120000) public void testFailingSocketInterceptor() { Config config = new Config(); config.setProperty(GroupProperties.PROP_MAX_JOIN_SECONDS, "3"); SocketInterceptorConfig sic = new SocketInterceptorConfig(); MySocketInterceptor mySocketInterceptor = new MySocketInterceptor(false); sic.setImplementation(mySocketInterceptor); config.getNetworkConfig().setSocketInterceptorConfig(sic); HazelcastInstance h1 = Hazelcast.newHazelcastInstance(config); HazelcastInstance h2 = Hazelcast.newHazelcastInstance(config); }
@Test public void testSemaphoreSplitBrain() throws InterruptedException { Config config = newConfig(); HazelcastInstance h1 = Hazelcast.newHazelcastInstance(config); HazelcastInstance h2 = Hazelcast.newHazelcastInstance(config); final HazelcastInstance h3 = Hazelcast.newHazelcastInstance(config); final String key = generateKeyOwnedBy(h3); ISemaphore semaphore = h3.getSemaphore(key); semaphore.init(5); semaphore.acquire(3); assertEquals(2, semaphore.availablePermits()); assertTrueEventually( new AssertTask() { @Override public void run() throws Exception { assertTrue(h3.getPartitionService().isLocalMemberSafe()); } }); TestMemberShipListener memberShipListener = new TestMemberShipListener(2); h3.getCluster().addMembershipListener(memberShipListener); TestLifeCycleListener lifeCycleListener = new TestLifeCycleListener(1); h3.getLifecycleService().addLifecycleListener(lifeCycleListener); closeConnectionBetween(h1, h3); closeConnectionBetween(h2, h3); assertOpenEventually(memberShipListener.latch); assertClusterSizeEventually(2, h1); assertClusterSizeEventually(2, h2); assertClusterSizeEventually(1, h3); final ISemaphore semaphore1 = h1.getSemaphore(key); // when member is down, permits are released. // since releasing the permits is async, we use assert eventually assertTrueEventually( new AssertTask() { @Override public void run() throws Exception { assertEquals(5, semaphore1.availablePermits()); } }); semaphore1.acquire(4); assertOpenEventually(lifeCycleListener.latch); assertClusterSizeEventually(3, h1); assertClusterSizeEventually(3, h2); assertClusterSizeEventually(3, h3); ISemaphore testSemaphore = h3.getSemaphore(key); assertEquals(1, testSemaphore.availablePermits()); }
/* * Sets up a situation where the member list is out of order on node2. Both * node2 and node1 think they are masters and both think each other are in * their clusters. */ @Test public void testOutOfSyncMemberListTwoMasters() throws Exception { Config c1 = buildConfig(false); Config c2 = buildConfig(false); Config c3 = buildConfig(false); c1.getNetworkConfig().setPort(45701); c2.getNetworkConfig().setPort(45702); c3.getNetworkConfig().setPort(45703); List<String> allMembers = Arrays.asList("127.0.0.1:45701, 127.0.0.1:45702, 127.0.0.1:45703"); c1.getNetworkConfig().getJoin().getTcpIpConfig().setMembers(allMembers); c2.getNetworkConfig().getJoin().getTcpIpConfig().setMembers(allMembers); c3.getNetworkConfig().getJoin().getTcpIpConfig().setMembers(allMembers); final HazelcastInstance h1 = Hazelcast.newHazelcastInstance(c1); final HazelcastInstance h2 = Hazelcast.newHazelcastInstance(c2); final HazelcastInstance h3 = Hazelcast.newHazelcastInstance(c3); final MemberImpl m1 = (MemberImpl) h1.getCluster().getLocalMember(); final MemberImpl m2 = (MemberImpl) h2.getCluster().getLocalMember(); final MemberImpl m3 = (MemberImpl) h3.getCluster().getLocalMember(); // All three nodes join into one cluster assertEquals(3, h1.getCluster().getMembers().size()); assertEquals(3, h2.getCluster().getMembers().size()); assertEquals(3, h3.getCluster().getMembers().size()); final Node n2 = TestUtil.getNode(h2); // Simulates node2 getting an out of order member list. That causes node2 to think it's the // master. List<MemberInfo> members = new ArrayList<MemberInfo>(); members.add(new MemberInfo(m2.getAddress(), m2.getUuid())); members.add(new MemberInfo(m3.getAddress(), m3.getUuid())); members.add(new MemberInfo(m1.getAddress(), m1.getUuid())); n2.clusterService.updateMembers(members); n2.setMasterAddress(m2.getAddress()); // Give the cluster some time to figure things out. The merge and heartbeat code should have // kicked in by this point Thread.sleep(30 * 1000); assertEquals(m1, h1.getCluster().getMembers().iterator().next()); assertEquals(m1, h2.getCluster().getMembers().iterator().next()); assertEquals(m1, h3.getCluster().getMembers().iterator().next()); assertEquals(3, h1.getCluster().getMembers().size()); assertEquals(3, h2.getCluster().getMembers().size()); assertEquals(3, h3.getCluster().getMembers().size()); }
@Test public void testQueueSplitBrain() throws InterruptedException { Config config = newConfig(); HazelcastInstance h1 = Hazelcast.newHazelcastInstance(config); HazelcastInstance h2 = Hazelcast.newHazelcastInstance(config); HazelcastInstance h3 = Hazelcast.newHazelcastInstance(config); final String name = generateKeyOwnedBy(h1); IQueue<Object> queue = h1.getQueue(name); TestMemberShipListener memberShipListener = new TestMemberShipListener(2); h3.getCluster().addMembershipListener(memberShipListener); TestLifeCycleListener lifeCycleListener = new TestLifeCycleListener(1); h3.getLifecycleService().addLifecycleListener(lifeCycleListener); for (int i = 0; i < 100; i++) { queue.add("item" + i); } waitAllForSafeState(); closeConnectionBetween(h1, h3); closeConnectionBetween(h2, h3); assertOpenEventually(memberShipListener.latch); assertClusterSizeEventually(2, h1); assertClusterSizeEventually(2, h2); assertClusterSizeEventually(1, h3); for (int i = 100; i < 200; i++) { queue.add("item" + i); } IQueue<Object> queue3 = h3.getQueue(name); for (int i = 0; i < 50; i++) { queue3.add("lostQueueItem" + i); } assertOpenEventually(lifeCycleListener.latch); assertClusterSizeEventually(3, h1); assertClusterSizeEventually(3, h2); assertClusterSizeEventually(3, h3); IQueue<Object> testQueue = h1.getQueue(name); assertFalse(testQueue.contains("lostQueueItem0")); assertFalse(testQueue.contains("lostQueueItem49")); assertTrue(testQueue.contains("item0")); assertTrue(testQueue.contains("item199")); assertTrue(testQueue.contains("item121")); assertTrue(testQueue.contains("item45")); }
@Test(timeout = 300000) public void testJoinWhenMemberClosedInBetween() throws InterruptedException { // Test is expecting to all can join safely. // On the failed case the last opened instance throws java.lang.IllegalStateException: Node // failed to start! Config config = new Config(); HazelcastInstance i1 = Hazelcast.newHazelcastInstance(config); HazelcastInstance i2 = Hazelcast.newHazelcastInstance(config); HazelcastInstance i3 = Hazelcast.newHazelcastInstance(config); HazelcastInstance i4 = Hazelcast.newHazelcastInstance(config); final IMap<Integer, Integer> map = i4.getMap("a"); int numThreads = 40; final int loop = 5000; Thread[] threads = new Thread[numThreads]; for (int i = 0; i < numThreads; i++) { threads[i] = new Thread( new Runnable() { public void run() { Random random = new Random(); for (int j = 0; j < loop; j++) { int op = random.nextInt(3); if (op == 0) { map.put(j, j); } else if (op == 1) { Integer val = map.remove(j); assert val == null || val.equals(j); } else { Integer val = map.get(j); assert val == null || val.equals(j); } } } }); threads[i].start(); } i1.shutdown(); i2.shutdown(); i3.shutdown(); // Should not throw java.lang.IllegalStateException: Node failed to start! Hazelcast.newHazelcastInstance(config); for (int i = 0; i < numThreads; i++) { threads[i].join(); } }
@BeforeClass public static void setUp() { Config config = new Config(); config.setProperty("hazelcast.partition.count", "" + PARTITION_COUNT); instance = Hazelcast.newHazelcastInstance(config); HazelcastInstance remoteInstance = Hazelcast.newHazelcastInstance(config); warmUpPartitions(instance, remoteInstance); ClientConfig clientconfig = new ClientConfig(); clientconfig.setProperty("hazelcast.partition.count", "" + PARTITION_COUNT); client = HazelcastClient.newHazelcastClient(clientconfig); }
@Test @Ignore public void testCallState() throws Exception { Config config = new Config(); final HazelcastInstance h1 = Hazelcast.newHazelcastInstance(config); final HazelcastInstance h2 = Hazelcast.newHazelcastInstance(config); final Node node1 = getNode(h1); final Node node2 = getNode(h2); Thread.sleep(100); final CountDownLatch latch = new CountDownLatch(1); final IMap imap1 = h1.getMap("default"); new Thread( new Runnable() { public void run() { imap1.lock("1"); latch.countDown(); } }) .start(); latch.await(); // final IMap imap2 = h2.getMap("default"); final AtomicInteger threadId = new AtomicInteger(); new Thread( new Runnable() { public void run() { ThreadContext.get().setCurrentFactory(node1.factory); threadId.set(ThreadContext.get().getThreadId()); imap1.put("1", "value1"); } }) .start(); Thread.sleep(1000); System.out.println(node1.getThisAddress() + " thread " + threadId.get()); CallState callState1 = node1.getSystemLogService().getCallState(node1.getThisAddress(), threadId.get()); if (callState1 != null) { for (Object callStateLog : callState1.getLogs()) { System.out.println(callStateLog); } } CallState callState2 = node2.getSystemLogService().getCallState(node1.getThisAddress(), threadId.get()); System.out.println("========================"); if (callState2 != null) { for (Object callStateLog : callState2.getLogs()) { System.out.println(callStateLog); } } }
@Test public void testNumberOfClients_afterUnAuthenticatedClient_withTwoNode() { final HazelcastInstance instance1 = Hazelcast.newHazelcastInstance(); final HazelcastInstance instance2 = Hazelcast.newHazelcastInstance(); final ClientConfig clientConfig = new ClientConfig(); clientConfig.getGroupConfig().setPassword("wrongPassword"); try { HazelcastClient.newHazelcastClient(clientConfig); } catch (IllegalStateException ignored) { } assertEquals(0, instance1.getClientService().getConnectedClients().size()); assertEquals(0, instance2.getClientService().getConnectedClients().size()); }
@Test public void testTransactionAtomicity_whenMultiMapGetIsUsed_withTransaction() throws InterruptedException { final HazelcastInstance hz = Hazelcast.newHazelcastInstance(createConfigWithDummyTxService()); final String name = HazelcastTestSupport.generateRandomString(5); Thread producerThread = startProducerThread(hz, name); try { IQueue<String> q = hz.getQueue(name); for (int i = 0; i < 1000; i++) { String id = q.poll(); if (id != null) { TransactionContext tx = hz.newTransactionContext(); try { tx.beginTransaction(); TransactionalMultiMap<Object, Object> multiMap = tx.getMultiMap(name); Collection<Object> values = multiMap.get(id); assertFalse(values.isEmpty()); multiMap.remove(id); tx.commitTransaction(); } catch (TransactionException e) { tx.rollbackTransaction(); e.printStackTrace(); } } else { LockSupport.parkNanos(100); } } } finally { stopProducerThread(producerThread); } }
@Test public void testInitDNodeList() throws Throwable { SploutConfiguration config = SploutConfiguration.getTestConfig(); QNodeHandler handler = new QNodeHandler(); try { HazelcastInstance hz = Hazelcast.newHazelcastInstance(HazelcastConfigBuilder.build(config)); CoordinationStructures coord = new CoordinationStructures(hz); SploutConfiguration dNodeConfig = SploutConfiguration.getTestConfig(); dNodeConfig.setProperty(DNodeProperties.PORT, 1000); coord.getDNodes().put("/localhost:1000", new DNodeInfo(dNodeConfig)); dNodeConfig = SploutConfiguration.getTestConfig(); dNodeConfig.setProperty(DNodeProperties.PORT, 1001); coord.getDNodes().put("/localhost:1001", new DNodeInfo(dNodeConfig)); try { handler.init(config); } catch (Exception e) { // since the handler will try to connect to "localhost:1000" we skip the Exception and // continue // the things we want to assert should be present anyway. } Assert.assertEquals( handler.getContext().getCoordinationStructures().getDNodes().values().size(), 2); } finally { handler.close(); Hazelcast.shutdownAll(); } }
@Test(expected = NullPointerException.class) public void testRemoveClientListener_whenIdIsNull() { HazelcastInstance instance = Hazelcast.newHazelcastInstance(); ClientService clientService = instance.getClientService(); clientService.removeClientListener(null); }
@Test public void putFromMultipleThreads() throws InterruptedException { final HazelcastInstance h = Hazelcast.newHazelcastInstance(null); final AtomicInteger counter = new AtomicInteger(0); class Putter implements Runnable { volatile Boolean run = true; public void run() { HazelcastClient hClient = TestUtility.newHazelcastClient(h); while (run) { Map<String, String> clientMap = hClient.getMap("putFromMultipleThreads"); clientMap.put(String.valueOf(counter.incrementAndGet()), String.valueOf(counter.get())); } } }; List<Putter> list = new ArrayList<Putter>(); for (int i = 0; i < 10; i++) { Putter p = new Putter(); list.add(p); new Thread(p).start(); } Thread.sleep(5000); for (Iterator<Putter> it = list.iterator(); it.hasNext(); ) { Putter p = it.next(); p.run = false; } Thread.sleep(100); assertEquals(counter.get(), h.getMap("putFromMultipleThreads").size()); }
public static void main(String[] args) throws Exception { HazelcastInstance hz = Hazelcast.newHazelcastInstance(); Cluster cluster = hz.getCluster(); cluster.addMembershipListener(new MembershipListener() { @Override public void memberAdded(MembershipEvent membershipEvent) { System.out.println( "********** MemberAdded " + membershipEvent ); } @Override public void memberRemoved(MembershipEvent membershipEvent) { System.out.println( "********** MemberRemoved " + membershipEvent ); } @Override public void memberAttributeChanged(MemberAttributeEvent memberAttributeEvent) { System.out.println( "********** MemberAttributeChanged " + memberAttributeEvent ); } }); Member localMember = cluster.getLocalMember(); System.out.println ( "********** my inetAddress= " + localMember.getInetSocketAddress() ); }
protected HazelcastInstance hazelcastInstance() { Config config = new Config(); config.addCacheConfig( new CacheSimpleConfig() .setName("result-cache") .setInMemoryFormat(InMemoryFormat.BINARY) .setEvictionConfig(new EvictionConfig().setEvictionPolicy(EvictionPolicy.LRU)) .setExpiryPolicyFactoryConfig( new CacheSimpleConfig.ExpiryPolicyFactoryConfig( new CacheSimpleConfig.ExpiryPolicyFactoryConfig.TimedExpiryPolicyFactoryConfig( CacheSimpleConfig.ExpiryPolicyFactoryConfig.TimedExpiryPolicyFactoryConfig .ExpiryPolicyType.ACCESSED, new CacheSimpleConfig.ExpiryPolicyFactoryConfig.DurationConfig( 20, TimeUnit.MINUTES))))); NetworkConfig networkConfig = new NetworkConfig(); networkConfig.setPort(5712).setPortAutoIncrement(true); config.setNetworkConfig(networkConfig); config.setGroupConfig(new GroupConfig("ach-validation", "ach-validation")); TcpClusterConfigurator.configureNetwork(config.getNetworkConfig()); TcpClusterConfigurator.configureGroup(config.getGroupConfig()); return Hazelcast.newHazelcastInstance(config); }
private HazelcastInstance defaultConfig(final ClusteringConfig clusteringConfig) { final Config hazelcastConfig = new Config(); hazelcastConfig.setGroupConfig( new GroupConfig(clusteringConfig.getClusterName(), clusteringConfig.getClusterPassword())); final NetworkConfig networkConfig = new NetworkConfig(); networkConfig.setPort(clusteringConfig.getMulticastPort()); final JoinConfig joinConfig = new JoinConfig(); final MulticastConfig multicastConfig = new MulticastConfig(); multicastConfig.setMulticastPort(clusteringConfig.getMulticastPort()); multicastConfig.setMulticastGroup(clusteringConfig.getMulticastGroup()); joinConfig.setMulticastConfig(multicastConfig); networkConfig.setJoin(joinConfig); hazelcastConfig.setNetworkConfig(networkConfig); return Hazelcast.newHazelcastInstance(hazelcastConfig); }
public static void main(String[] args) { HazelcastInstance hz = Hazelcast.newHazelcastInstance(); IAtomicLong atomicLong = hz.getAtomicLong("counter"); atomicLong.set(1); long result = atomicLong.apply(new Add2Function()); System.out.println("apply.result:" + result); System.out.println("apply.value:" + atomicLong.get()); atomicLong.set(1); atomicLong.alter(new Add2Function()); System.out.println("alter.value:" + atomicLong.get()); atomicLong.set(1); result = atomicLong.alterAndGet(new Add2Function()); System.out.println("alterAndGet.result:" + result); System.out.println("alterAndGet.value:" + atomicLong.get()); atomicLong.set(1); result = atomicLong.getAndAlter(new Add2Function()); System.out.println("getAndAlter.result:" + result); System.out.println("getAndAlter.value:" + atomicLong.get()); System.exit(0); for (; ; ) { long oldValue = atomicLong.get(); long newValue = oldValue + 2; if (atomicLong.compareAndSet(oldValue, newValue)) { break; } } }
// public API public MyHazelcastInstance(final MapStore store, final String storeType) { this.store = store; this.storeType = storeType; log.info("Creating Hazelcast CEP instance.."); instanceName = UUID.randomUUID().toString(); Hazelcast.newHazelcastInstance(getConfig()); log.info("Created CEP instance."); }
@Test public void testRemoveClientListener_whenNonExistingId() { HazelcastInstance instance = Hazelcast.newHazelcastInstance(); ClientService clientService = instance.getClientService(); clientService.removeClientListener("foobar"); }
/* 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(); } }
@Test public void testCustomCacheMergePolicy() { String cacheName = randomMapName(); Config config = newConfig(); 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); closeConnectionBetween(h1, h2); assertOpenEventually(memberShipListener.latch); assertClusterSizeEventually(1, h1); assertClusterSizeEventually(1, h2); CachingProvider cachingProvider1 = HazelcastServerCachingProvider.createCachingProvider(h1); CachingProvider cachingProvider2 = HazelcastServerCachingProvider.createCachingProvider(h2); CacheManager cacheManager1 = cachingProvider1.getCacheManager(); CacheManager cacheManager2 = cachingProvider2.getCacheManager(); CacheConfig cacheConfig = newCacheConfig(cacheName, CustomCacheMergePolicy.class.getName()); Cache cache1 = cacheManager1.createCache(cacheName, cacheConfig); Cache cache2 = cacheManager2.createCache(cacheName, cacheConfig); // TODO We assume that until here and also while doing get/put, cluster is still splitted. // This assumptions seems fragile due to time sensitivity. String key = generateKeyOwnedBy(h1); cache1.put(key, "value"); cache2.put(key, Integer.valueOf(1)); assertOpenEventually(lifeCycleListener.latch); assertClusterSizeEventually(2, h1); assertClusterSizeEventually(2, h2); Cache cacheTest = cacheManager2.getCache(cacheName); assertNotNull(cacheTest.get(key)); assertTrue(cacheTest.get(key) instanceof Integer); }
@Before public void init() { Config config = new Config(); config.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(false); config.getNetworkConfig().setPort(5701); config.getGroupConfig().setName("cluster1"); config.getGroupConfig().setPassword("cluster1pass"); final HazelcastInstance hz1 = Hazelcast.newHazelcastInstance(config); Config config2 = new Config(); config2.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(false); config2.getNetworkConfig().setPort(5702); config2.getGroupConfig().setName("cluster2"); config2.getGroupConfig().setPassword("cluster2pass"); final HazelcastInstance hz2 = Hazelcast.newHazelcastInstance(config2); }
/** * Create HazelcastInstance bean. * * @param hazelcastConfigLocation String representation of hazelcast xml config. * @param resourceLoader resource loader for loading hazelcast xml configuration resource. * @return HazelcastInstance bean. * @throws IOException if parsing of hazelcast xml configuration fails */ @Bean public HazelcastInstance hazelcast( @Value("${hz.config.location:NO_CONFIG_PROVIDED}") final String hazelcastConfigLocation, final ResourceLoader resourceLoader) throws IOException { final Config hzConfig = getConfig(resourceLoader.getResource(hazelcastConfigLocation)); return Hazelcast.newHazelcastInstance(hzConfig); }