private Config newConfig() { Config config = new Config(); config.setProperty(GroupProperty.MERGE_FIRST_RUN_DELAY_SECONDS, "5"); config.setProperty(GroupProperty.MERGE_NEXT_RUN_DELAY_SECONDS, "3"); config.getGroupConfig().setName(generateRandomString(10)); return config; }
@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); }
private BasicBackPressureService newEnabledBackPressureService() { Config config = new Config(); config.setProperty(GroupProperties.PROP_BACKPRESSURE_ENABLED, "true"); config.setProperty(GroupProperties.PROP_BACKPRESSURE_SYNCWINDOW, "" + SYNC_WINDOW); GroupProperties groupProperties = new GroupProperties(config); return new BasicBackPressureService(groupProperties, logger); }
@Test(expected = IllegalArgumentException.class) public void testConstruction_invalidSyncWindow() { Config config = new Config(); config.setProperty(GroupProperties.PROP_BACKPRESSURE_ENABLED, "true"); config.setProperty(GroupProperties.PROP_BACKPRESSURE_SYNCWINDOW, "" + 0); GroupProperties groupProperties = new GroupProperties(config); new BasicBackPressureService(groupProperties, logger); }
@Before public void setup() { Config config = new Config(); config.setProperty(BACKPRESSURE_ENABLED, "false"); config.setProperty(OPERATION_CALL_TIMEOUT_MILLIS, "20000"); local = createHazelcastInstance(config); warmUpPartitions(local); nodeEngine = getNodeEngineImpl(local); operationService = getOperationServiceImpl(local); invocationRegistry = operationService.invocationRegistry; }
private Config createChunkedMapLoaderConfig( String mapName, int chunkSize, ChunkedLoader chunkedLoader) { Config cfg = getConfig(); cfg.setProperty(GroupProperty.PARTITION_COUNT, "1"); cfg.setProperty(GroupProperty.MAP_LOAD_CHUNK_SIZE, String.valueOf(chunkSize)); MapStoreConfig mapStoreConfig = new MapStoreConfig(); mapStoreConfig.setEnabled(true); mapStoreConfig.setImplementation(chunkedLoader); MapConfig mapConfig = cfg.getMapConfig(mapName); mapConfig.setMapStoreConfig(mapStoreConfig); return cfg; }
@Test public void testWaitingIndefinitely() throws InterruptedException { TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(5); final Config config = new Config(); config.setProperty(GroupProperties.PROP_OPERATION_CALL_TIMEOUT_MILLIS, "2000"); final HazelcastInstance[] instances = factory.newInstances(config); instances[0].getLock("testWaitingIndefinitely").lock(); final CountDownLatch latch = new CountDownLatch(1); new Thread() { public void run() { try { // because max timeout=2000 we get timeout exception which we should not instances[1].getLock("testWaitingIndefinitely").lock(); latch.countDown(); } catch (Exception ignored) { } } }.start(); // wait for enough time which is greater than max-timeout (2000) Thread.sleep(10000); instances[0].getLock("testWaitingIndefinitely").unlock(); assertTrue(latch.await(5, TimeUnit.SECONDS)); }
@Test public void testWaitingIndefinitely() throws InterruptedException { final Config config = new Config(); config.setProperty(GroupProperties.PROP_OPERATION_CALL_TIMEOUT_MILLIS, "3000"); TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(2); final HazelcastInstance[] instances = factory.newInstances(config); // need to warm-up partitions, // since waiting for lock backup can take up to 5 seconds // and that may cause OperationTimeoutException with "No response for 4000 ms" error. warmUpPartitions(instances); final String name = "testWaitingIndefinitely"; ILock lock = instances[0].getLock(name); lock.lock(); final CountDownLatch latch = new CountDownLatch(1); new Thread() { public void run() { try { // because max timeout=3000 we get timeout exception which we should not instances[1].getLock(name).lock(); latch.countDown(); } catch (Exception ignored) { } } }.start(); // wait for enough time which is greater than max-timeout (3000) sleepSeconds(10); lock.unlock(); assertTrue(latch.await(20, TimeUnit.SECONDS)); }
@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(); } }
@Test public void testPutInterruption() throws InterruptedException { Config config = new Config(); config.setProperty(GroupProperties.PROP_OPERATION_CALL_TIMEOUT_MILLIS, "1000"); config.getQueueConfig("default").setMaxSize(1); HazelcastInstance instance = createHazelcastInstance(config); final IQueue<Object> queue = instance.getQueue(randomName()); final AtomicBoolean interrupted = new AtomicBoolean(); assertTrue(queue.offer("item")); Thread t = new Thread() { public void run() { try { queue.put("item"); } catch (InterruptedException e) { interrupted.set(true); } } }; t.start(); sleepSeconds(1); t.interrupt(); t.join(5000); assertTrue(interrupted.get()); }
@Test @Category(ProblematicTest.class) // TODO public void testLockInterruption() throws InterruptedException { Config config = new Config(); config.setProperty(GroupProperties.PROP_OPERATION_CALL_TIMEOUT_MILLIS, "5000"); final TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(1); final HazelcastInstance hz = nodeFactory.newHazelcastInstance(config); final Lock lock = hz.getLock("testLockInterruption2"); final CountDownLatch latch = new CountDownLatch(1); Thread t = new Thread( new Runnable() { public void run() { try { lock.tryLock(60, TimeUnit.SECONDS); } catch (InterruptedException ignored) { latch.countDown(); } } }); lock.lock(); t.start(); Thread.sleep(2000); t.interrupt(); assertTrue("tryLock() is not interrupted!", latch.await(30, TimeUnit.SECONDS)); lock.unlock(); assertTrue("Could not acquire lock!", lock.tryLock()); }
private void multicastJoin(int count, final boolean sleep) throws InterruptedException { final TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(count); final Config config = new Config(); config.setProperty("hazelcast.wait.seconds.before.join", "5"); config.getNetworkConfig().getJoin().getMulticastConfig().setMulticastTimeoutSeconds(25); final ConcurrentMap<Integer, HazelcastInstance> map = new ConcurrentHashMap<Integer, HazelcastInstance>(); final CountDownLatch latch = new CountDownLatch(count); final ExecutorService ex = Executors.newCachedThreadPool(); for (int i = 0; i < count; i++) { final int index = i; ex.execute( new Runnable() { public void run() { if (sleep) { try { Thread.sleep((int) (1000 * Math.random())); } catch (InterruptedException ignored) { } } HazelcastInstance h = nodeFactory.newHazelcastInstance(config); map.put(index, h); latch.countDown(); } }); } assertOpenEventually(latch); for (HazelcastInstance h : map.values()) { assertEquals(count, h.getCluster().getMembers().size()); } ex.shutdown(); }
@Test public void testSerialization() { Config config = new Config(); config.setProperty(GroupProperties.PROP_MC_MAX_VISIBLE_SLOW_OPERATION_COUNT, "127"); SlowOperationInvocationDTO slowOperationInvocationDTO = new SlowOperationInvocationDTO(); slowOperationInvocationDTO.id = 12345; slowOperationInvocationDTO.durationMs = 15000; slowOperationInvocationDTO.startedAt = 12381912; slowOperationInvocationDTO.operationDetails = "TestOperationDetails"; List<SlowOperationInvocationDTO> invocationList = new ArrayList<SlowOperationInvocationDTO>(); invocationList.add(slowOperationInvocationDTO); SlowOperationDTO slowOperationDTO = new SlowOperationDTO(); slowOperationDTO.operation = "TestOperation"; slowOperationDTO.stackTrace = "stackTrace"; slowOperationDTO.totalInvocations = 4; slowOperationDTO.invocations = invocationList; HazelcastInstance hazelcastInstance = createHazelcastInstance(config); Node node = getNode(hazelcastInstance); LocalOperationStatsImpl localOperationStats = new LocalOperationStatsImpl(node); localOperationStats.getSlowOperations().add(slowOperationDTO); LocalOperationStatsImpl deserialized = new LocalOperationStatsImpl(); deserialized.fromJson(localOperationStats.toJson()); assertEquals(localOperationStats.getCreationTime(), deserialized.getCreationTime()); assertEquals( localOperationStats.getMaxVisibleSlowOperationCount(), deserialized.getMaxVisibleSlowOperationCount()); assertEqualsSlowOperationDTOs( localOperationStats.getSlowOperations(), deserialized.getSlowOperations()); }
HazelcastInstance getSingleNodeCluster(int slowOperationThresholdMillis) { Config config = new Config(); config.setProperty( GroupProperty.SLOW_OPERATION_DETECTOR_THRESHOLD_MILLIS.getName(), valueOf(slowOperationThresholdMillis)); return createHazelcastInstance(config); }
@Test public void testDisablingSystemLogs() throws Exception { Config config = new Config(); config.setProperty(GroupProperties.PROP_SYSTEM_LOG_ENABLED, "true"); config.getGroupConfig().setName("testDisablingSystemLogs"); HazelcastInstance instance = Hazelcast.newHazelcastInstance(config); HazelcastInstance instance2 = Hazelcast.newHazelcastInstance(config); instance.getMap("map").put("key", "value"); Node node = TestUtil.getNode(instance); assertTrue(node.getSystemLogService().getLogBundle().size() > 0); Hazelcast.shutdownAll(); config.setProperty(GroupProperties.PROP_SYSTEM_LOG_ENABLED, "false"); instance = Hazelcast.newHazelcastInstance(config); instance2 = Hazelcast.newHazelcastInstance(config); instance.getMap("map").put("key2", "value2"); assertTrue(node.getSystemLogService().getLogBundle().size() == 0); }
private Config newConfig(String mergePolicy, String mapName) { Config config = new Config(); setCommonProperties(config); config.setProperty(GroupProperty.MERGE_FIRST_RUN_DELAY_SECONDS.getName(), "5"); config.setProperty(GroupProperty.MERGE_NEXT_RUN_DELAY_SECONDS.getName(), "3"); MapConfig mapConfig = config.getMapConfig(mapName); mapConfig.setMergePolicy(mergePolicy); mapConfig.setBackupCount(1); mapConfig.setReadBackupData(true); mapConfig.setStatisticsEnabled(true); mapConfig.setMaxIdleSeconds(0); mapConfig.setTimeToLiveSeconds(0); mapConfig.addMapIndexConfig(new MapIndexConfig("id", false)); config.setNetworkConfig(this.getLocalhostTcpIpNetworkConfig(6701)); config.getGroupConfig().setName(mapName); config.getGroupConfig().setPassword(mapName); return config; }
private Config hazelcast() { Config conf = new Config(); conf.getNetworkConfig().setPort(hazelCastPort); conf.getNetworkConfig().setPortAutoIncrement(false); conf.setProperty("hazelcast.initial.min.cluster.size", "1"); conf.setProperty("hazelcast.shutdownhook.enabled", "false"); JoinConfig join = conf.getNetworkConfig().getJoin(); boolean isAws = System.getProperty("hazelcast.aws", "false").equals("true"); log.info("Setting up Joiner with this being " + (isAws ? "AWS" : "Multicast")); join.getAwsConfig().setEnabled(isAws); if (isAws) { join.getAwsConfig().setAccessKey(System.getProperty("hazelcast.access-key")); join.getAwsConfig().setSecretKey(System.getProperty("hazelcast.access-secret")); } join.getMulticastConfig().setEnabled(!isAws); ListConfig jobConfig = new ListConfig(); jobConfig.setName(JOBS); conf.addListConfig(jobConfig); ListConfig replicateConfig = new ListConfig(); replicateConfig.setName(REPLICATE_WEIGHTS); conf.addListConfig(replicateConfig); ListConfig topicsConfig = new ListConfig(); topicsConfig.setName(TOPICS); conf.addListConfig(topicsConfig); ListConfig updatesConfig = new ListConfig(); updatesConfig.setName(UPDATES); conf.addListConfig(updatesConfig); ListConfig availableWorkersConfig = new ListConfig(); availableWorkersConfig.setName(AVAILABLE_WORKERS); conf.addListConfig(availableWorkersConfig); MapConfig heartbeatConfig = new MapConfig(); heartbeatConfig.setName(HEART_BEAT); conf.addMapConfig(heartbeatConfig); MapConfig workerEnabledConifg = new MapConfig(); workerEnabledConifg.setName(WORKER_ENABLED); conf.addMapConfig(workerEnabledConifg); return conf; }
@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(expected = IllegalArgumentException.class) public void testLockFail_whenGreaterThanMaxLeaseTimeUsed() { Config config = new Config(); config.setProperty(GroupProperties.PROP_LOCK_MAX_LEASE_TIME_SECONDS, "1"); factory.newHazelcastInstance(config); HazelcastInstance hz = factory.newHazelcastClient(); ILock lock = hz.getLock(randomName()); lock.lock(10, TimeUnit.SECONDS); }
@Before public void setup() throws Exception { loggingService = new LoggingServiceImpl("foo", "jdk", new BuildInfo("1", "1", "1", 1, false, (byte) 1)); serializationService = new DefaultSerializationServiceBuilder().build(); config = new Config(); config.setProperty(GroupProperty.PARTITION_COUNT, "10"); config.setProperty(GroupProperty.PARTITION_OPERATION_THREAD_COUNT, "10"); config.setProperty(GroupProperty.GENERIC_OPERATION_THREAD_COUNT, "10"); thisAddress = new Address("localhost", 5701); threadGroup = new HazelcastThreadGroup( "foo", loggingService.getLogger(HazelcastThreadGroup.class), Thread.currentThread().getContextClassLoader()); nodeExtension = new DefaultNodeExtension(); handlerFactory = new DummyOperationRunnerFactory(); metricsRegistry = new MetricsRegistryImpl(Logger.getLogger(MetricsRegistry.class), INFO); responsePacketHandler = new DummyResponsePacketHandler(); }
@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 public void testNodeConstructor() { Config config = new Config(); config.setProperty(GroupProperties.PROP_MC_MAX_VISIBLE_SLOW_OPERATION_COUNT, "139"); HazelcastInstance hazelcastInstance = createHazelcastInstance(config); Node node = getNode(hazelcastInstance); LocalOperationStatsImpl localOperationStats = new LocalOperationStatsImpl(node); assertEquals(139, localOperationStats.getMaxVisibleSlowOperationCount()); assertEquals(0, localOperationStats.getSlowOperations().size()); assertTrue(localOperationStats.getCreationTime() > 0); assertNotNull(localOperationStats.toString()); }
private static Config createConfig(String licenceKey) { Config config = new Config(); config.setLicenseKey(licenceKey); config.setProperty("hazelcast.wait.seconds.before.join", "0"); SecurityInterceptorConfig securityInterceptorConfig = new SecurityInterceptorConfig(); securityInterceptorConfig.setClassName(MySecurityInterceptor.class.getName()); SecurityConfig securityConfig = config.getSecurityConfig(); securityConfig.setEnabled(true).addSecurityInterceptorConfig(securityInterceptorConfig); // when you enable security all client requests are denied, so we need to give permission first // security-interceptor will be run after checking this permission PermissionConfig permissionConfig = new PermissionConfig(PermissionConfig.PermissionType.ALL, "", null); securityConfig.addClientPermissionConfig(permissionConfig); return config; }
private static Config buildConfig(boolean multicastEnabled) { Config c = new Config(); c.getGroupConfig().setName("group").setPassword("pass"); c.setProperty(GroupProperties.PROP_MERGE_FIRST_RUN_DELAY_SECONDS, "10"); c.setProperty(GroupProperties.PROP_MERGE_NEXT_RUN_DELAY_SECONDS, "5"); c.setProperty(GroupProperties.PROP_MAX_NO_HEARTBEAT_SECONDS, "10"); c.setProperty(GroupProperties.PROP_MASTER_CONFIRMATION_INTERVAL_SECONDS, "2"); c.setProperty(GroupProperties.PROP_MAX_NO_MASTER_CONFIRMATION_SECONDS, "10"); c.setProperty(GroupProperties.PROP_MEMBER_LIST_PUBLISH_INTERVAL_SECONDS, "10"); final NetworkConfig networkConfig = c.getNetworkConfig(); networkConfig.getJoin().getMulticastConfig().setEnabled(multicastEnabled); networkConfig.getJoin().getTcpIpConfig().setEnabled(!multicastEnabled); networkConfig.setPortAutoIncrement(false); return c; }
@Test(timeout = 120000) public void testOneMemberWriteThroughWithLRU() throws Exception { final int size = 10000; TestMapStore testMapStore = new TestMapStore(size * 2, 1, 1); testMapStore.setLoadAllKeys(false); Config config = newConfig(testMapStore, 0); config.setProperty(GroupProperty.PARTITION_COUNT, "1"); MaxSizeConfig maxSizeConfig = new MaxSizeConfig(); maxSizeConfig.setSize(size); MapConfig mapConfig = config.getMapConfig("default"); mapConfig.setEvictionPolicy(EvictionPolicy.LRU); mapConfig.setMaxSizeConfig(maxSizeConfig); mapConfig.setMinEvictionCheckMillis(0); TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(3); HazelcastInstance h1 = nodeFactory.newHazelcastInstance(config); IMap map = h1.getMap("default"); final CountDownLatch countDownLatch = new CountDownLatch(size); map.addEntryListener( new EntryAdapter() { @Override public void entryEvicted(EntryEvent event) { countDownLatch.countDown(); } }, false); for (int i = 0; i < size * 2; i++) { // trigger eviction. if (i == (size * 2) - 1 || i == size) { sleepMillis(1001); } map.put(i, new Employee("joe", i, true, 100.00)); } assertEquals(testMapStore.getStore().size(), size * 2); assertOpenEventually(countDownLatch); final String msgFailure = String.format("map size: %d put count: %d", map.size(), size); assertTrue(msgFailure, map.size() > size / 2); assertTrue(msgFailure, map.size() <= size); assertEquals(testMapStore.getStore().size(), size * 2); }
@Test public void testWaitingInfinitelyForTryLock() throws InterruptedException { final Config config = new Config(); config.setProperty(GroupProperties.PROP_OPERATION_CALL_TIMEOUT_MILLIS, "2000"); final HazelcastInstance hz = createHazelcastInstance(config); final CountDownLatch latch = new CountDownLatch(1); hz.getLock("testWaitingInfinitelyForTryLock").lock(); new Thread() { public void run() { try { hz.getLock("testWaitingInfinitelyForTryLock").tryLock(5, TimeUnit.SECONDS); latch.countDown(); } catch (Exception ignored) { } } }.start(); assertTrue(latch.await(15, TimeUnit.SECONDS)); }
@Test public void testMapConfigUpdate_reflectedToRecordStore() throws ExecutionException, InterruptedException { String mapName = randomMapName(); Config config = getConfig(); config.setProperty(GroupProperty.PARTITION_COUNT.getName(), "1"); HazelcastInstance node = createHazelcastInstance(config); IMap<Integer, Integer> map = node.getMap(mapName); map.put(1, 1); // trigger recordStore creation. boolean beforeUpdate = isRecordStoreExpirable(map) && isEvictionEnabled(map); updateMapConfig(mapName, node); boolean afterUpdate = isRecordStoreExpirable(map) && isEvictionEnabled(map); assertFalse( "Before MapConfig update, RecordStore should not be expirable and evictable", beforeUpdate); assertTrue("RecordStore should be expirable and evictable after MapConfig update", afterUpdate); }
@Test public void testMaxLockLeaseTime() { Config config = new Config(); config.setProperty(GroupProperties.PROP_LOCK_MAX_LEASE_TIME_SECONDS, "1"); factory.newHazelcastInstance(config); HazelcastInstance hz = factory.newHazelcastClient(); final ILock lock = hz.getLock(randomName()); lock.lock(); assertTrueEventually( new AssertTask() { @Override public void run() throws Exception { assertFalse("Lock should be released after lease expires!", lock.isLocked()); } }, 30); }
private BasicBackPressureService newDisabledBackPressureService() { Config config = new Config(); config.setProperty(GroupProperties.PROP_BACKPRESSURE_ENABLED, "false"); GroupProperties groupProperties = new GroupProperties(config); return new BasicBackPressureService(groupProperties, logger); }
private Config newConfig() { Config config = new Config(); config.setProperty(GroupProperties.PROP_MERGE_FIRST_RUN_DELAY_SECONDS, "30"); config.setProperty(GroupProperties.PROP_MERGE_NEXT_RUN_DELAY_SECONDS, "3"); return config; }