You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by kl...@apache.org on 2017/09/21 21:57:21 UTC
[geode] 04/04: GEODE-3552: cleanup more MXBean tests
This is an automated email from the ASF dual-hosted git repository.
klund pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode.git
commit 1d51aa3542af85b3833881265dd991d531b228b3
Author: Kirk Lund <kl...@apache.org>
AuthorDate: Thu Sep 14 08:56:20 2017 -0700
GEODE-3552: cleanup more MXBean tests
* start refactoring MXBean await methods to MXBeanAwaitility
* organize imports
* remove unused code
* convert from WaitCriterion to Awaitility
* reduce scope from protected/public to private where possible
* fix minor race conditions
---
.../cache/query/TypedJsonQueryIntegrationTest.java | 28 +-
.../geode/management/CacheManagementDUnitTest.java | 48 +-
.../apache/geode/management/CompositeStats.java | 37 +-
.../geode/management/CompositeTestMBean.java | 12 +-
.../geode/management/CompositeTestMXBean.java | 13 +-
.../management/CompositeTypeTestDUnitTest.java | 10 +-
.../geode/management/DLockManagementDUnitTest.java | 11 +-
.../geode/management/DiskManagementDUnitTest.java | 4 +-
.../management/DistributedSystemDUnitTest.java | 69 +-
.../apache/geode/management/JMXMBeanDUnitTest.java | 35 +-
.../management/LocatorManagementDUnitTest.java | 384 ++--
.../org/apache/geode/management/MBeanUtil.java | 2 +-
.../apache/geode/management/MXBeanAwaitility.java | 80 +
.../geode/management/ManagementTestBase.java | 206 +-
.../geode/management/ManagementTestRule.java | 13 +-
.../management/MemberMBeanAttributesDUnitTest.java | 293 ++-
.../management/OffHeapManagementDUnitTest.java | 609 +++---
.../geode/management/QueryDataDUnitTest.java | 169 +-
.../QueryDataFunctionIntegrationTest.java | 8 +-
.../management/RegionCreateDestroyDUnitTest.java | 6 +-
.../management/RegionManagementDUnitTest.java | 170 +-
...niversalMembershipListenerAdapterDUnitTest.java | 2172 ++++++++------------
.../cli/json/TypedJsonPdxIntegrationTest.java | 25 +-
.../internal/cli/json/TypedJsonTest.java | 3 +-
24 files changed, 1845 insertions(+), 2562 deletions(-)
diff --git a/geode-core/src/test/java/org/apache/geode/cache/query/TypedJsonQueryIntegrationTest.java b/geode-core/src/test/java/org/apache/geode/cache/query/TypedJsonQueryIntegrationTest.java
index bb54859..0d42554 100644
--- a/geode-core/src/test/java/org/apache/geode/cache/query/TypedJsonQueryIntegrationTest.java
+++ b/geode-core/src/test/java/org/apache/geode/cache/query/TypedJsonQueryIntegrationTest.java
@@ -1,18 +1,16 @@
/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
+ * agreements. See the NOTICE file distributed with this work for additional information regarding
+ * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License. You may obtain a
+ * copy of the License at
*
- * http://www.apache.org/licenses/LICENSE-2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
*
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
*/
package org.apache.geode.cache.query;
@@ -31,9 +29,11 @@ import org.apache.geode.management.internal.cli.json.TypedJson;
import org.apache.geode.test.junit.categories.IntegrationTest;
/**
- * Integration tests for {@link TypedJson} querying {@link Portfolio}.<p>
+ * Integration tests for {@link TypedJson} querying {@link Portfolio}.
+ * <p>
*
- * Extracted from {@link TypedJsonPdxIntegrationTest}.<p>
+ * Extracted from {@link TypedJsonPdxIntegrationTest}.
+ * <p>
*
* TODO: add real assertions
*/
diff --git a/geode-core/src/test/java/org/apache/geode/management/CacheManagementDUnitTest.java b/geode-core/src/test/java/org/apache/geode/management/CacheManagementDUnitTest.java
index 9d5c873..003dd9b 100644
--- a/geode-core/src/test/java/org/apache/geode/management/CacheManagementDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/CacheManagementDUnitTest.java
@@ -14,9 +14,10 @@
*/
package org.apache.geode.management;
-import static java.util.concurrent.TimeUnit.*;
-import static org.apache.geode.distributed.ConfigurationProperties.*;
-import static org.assertj.core.api.Assertions.*;
+import static org.apache.geode.distributed.ConfigurationProperties.LOG_FILE;
+import static org.apache.geode.distributed.ConfigurationProperties.REDUNDANCY_ZONE;
+import static org.apache.geode.management.MXBeanAwaitility.await;
+import static org.assertj.core.api.Assertions.assertThat;
import java.io.Serializable;
import java.lang.management.ManagementFactory;
@@ -33,8 +34,6 @@ import javax.management.Notification;
import javax.management.NotificationListener;
import javax.management.ObjectName;
-import org.awaitility.Awaitility;
-import org.awaitility.core.ConditionFactory;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
@@ -58,9 +57,13 @@ import org.apache.geode.test.junit.rules.serializable.SerializableTemporaryFolde
import org.apache.geode.test.junit.rules.serializable.SerializableTestName;
/**
+ * Distributed tests for {@link MemberMXBean}.
+ * <p>
+ *
* This class checks and verifies various data and operations exposed through MemberMXBean
* interface.
- * </p>
+ * <p>
+ *
* Goal of the Test : MemberMBean gets created once cache is created. Data like config data and
* stats are of proper value To check proper federation of MemberMBean including remote ops and
* remote data access
@@ -302,14 +305,14 @@ public class CacheManagementDUnitTest implements Serializable {
private void verifyQueryMBeans(final VM managerVM) {
managerVM.invoke("validateQueryMBeans", () -> {
- ManagementService service = this.managementTestRule.getManagementService();
+ SystemManagementService service = this.managementTestRule.getSystemManagementService();
Set<DistributedMember> otherMembers = this.managementTestRule.getOtherNormalMembers();
Set<ObjectName> superSet = new HashSet<>();
for (DistributedMember member : otherMembers) {
ObjectName memberMBeanName = service.getMemberMBeanName(member);
- awaitMemberMXBeanProxy(member);
+ MXBeanAwaitility.awaitMemberMXBeanProxy(member, service);
Set<ObjectName> objectNames = service.queryMBeanNames(member);
superSet.addAll(objectNames);
@@ -327,13 +330,13 @@ public class CacheManagementDUnitTest implements Serializable {
private void verifyGetMBeanInstance(final VM managerVM) {
managerVM.invoke("verifyGetMBeanInstance", () -> {
- ManagementService service = this.managementTestRule.getManagementService();
+ SystemManagementService service = this.managementTestRule.getSystemManagementService();
Set<DistributedMember> otherMembers = this.managementTestRule.getOtherNormalMembers();
for (DistributedMember member : otherMembers) {
ObjectName memberMBeanName = service.getMemberMBeanName(member);
- awaitMemberMXBeanProxy(member);
+ MXBeanAwaitility.awaitMemberMXBeanProxy(member, service);
MemberMXBean memberMXBean = service.getMBeanInstance(memberMBeanName, MemberMXBean.class);
assertThat(memberMXBean).isNotNull();
@@ -413,10 +416,11 @@ public class CacheManagementDUnitTest implements Serializable {
* not.
*/
private void verifyConfigDataRemote(final Map<DistributedMember, DistributionConfig> configMap) {
+ SystemManagementService service = this.managementTestRule.getSystemManagementService();
Set<DistributedMember> otherMembers = this.managementTestRule.getOtherNormalMembers();
for (DistributedMember member : otherMembers) {
- MemberMXBean memberMXBean = awaitMemberMXBeanProxy(member);
+ MemberMXBean memberMXBean = MXBeanAwaitility.awaitMemberMXBeanProxy(member, service);
GemFireProperties data = memberMXBean.listGemFireProperties();
DistributionConfig config = configMap.get(member);
@@ -577,10 +581,11 @@ public class CacheManagementDUnitTest implements Serializable {
}
private void invokeRemoteMemberMXBeanOps() {
+ SystemManagementService service = this.managementTestRule.getSystemManagementService();
Set<DistributedMember> otherMembers = this.managementTestRule.getOtherNormalMembers();
for (DistributedMember member : otherMembers) {
- MemberMXBean memberMXBean = awaitMemberMXBeanProxy(member);
+ MemberMXBean memberMXBean = MXBeanAwaitility.awaitMemberMXBeanProxy(member, service);
JVMMetrics metrics = memberMXBean.showJVMMetrics();
@@ -661,25 +666,6 @@ public class CacheManagementDUnitTest implements Serializable {
assertThat(region).isEmpty();
}
- private MemberMXBean awaitMemberMXBeanProxy(final DistributedMember member) {
- SystemManagementService service = this.managementTestRule.getSystemManagementService();
- ObjectName objectName = service.getMemberMBeanName(member);
-
- String alias = "Awaiting MemberMXBean proxy for " + member;
- await(alias)
- .until(() -> assertThat(service.getMBeanProxy(objectName, MemberMXBean.class)).isNotNull());
-
- return service.getMBeanProxy(objectName, MemberMXBean.class);
- }
-
- private ConditionFactory await() {
- return Awaitility.await().atMost(2, MINUTES);
- }
-
- private ConditionFactory await(final String alias) {
- return Awaitility.await(alias).atMost(2, MINUTES);
- }
-
private static String removeVMDir(String string) {
return string.replaceAll("vm.", "");
}
diff --git a/geode-core/src/test/java/org/apache/geode/management/CompositeStats.java b/geode-core/src/test/java/org/apache/geode/management/CompositeStats.java
index 33f7ea6..4abbe1d 100644
--- a/geode-core/src/test/java/org/apache/geode/management/CompositeStats.java
+++ b/geode-core/src/test/java/org/apache/geode/management/CompositeStats.java
@@ -17,16 +17,13 @@ package org.apache.geode.management;
import java.beans.ConstructorProperties;
public class CompositeStats {
- /**
- *
- */
- private static final long serialVersionUID = 1L;
- private final String connectionStatsType; // shouldn't change
- private long connectionsOpened;
- private long connectionsClosed;
- private long connectionsAttempted;
- private long connectionsFailed;
- private long connectionLifeTime; // is this total TTL??
+
+ private final String connectionStatsType;
+ private final long connectionsOpened;
+ private final long connectionsClosed;
+ private final long connectionsAttempted;
+ private final long connectionsFailed;
+ private final long connectionLifeTime;
@ConstructorProperties(value = {"connectionStatsType", "connectionsOpened", "connectionsClosed",
"connectionsAttempted", "connectionsFailed", "connectionLifeTime"})
@@ -40,44 +37,26 @@ public class CompositeStats {
this.connectionLifeTime = connectionLifeTime;
}
- /**
- * @return the connectionStatsType
- */
public String getConnectionStatsType() {
return connectionStatsType;
}
- /**
- * @return the connectionsOpened
- */
public long getConnectionsOpened() {
return connectionsOpened;
}
- /**
- * @return the connectionsClosed
- */
public long getConnectionsClosed() {
return connectionsClosed;
}
- /**
- * @return the connectionsAttempted
- */
public long getConnectionsAttempted() {
return connectionsAttempted;
}
- /**
- * @return the connectionsFailed
- */
public long getConnectionsFailed() {
return connectionsFailed;
}
- /**
- * @return the connectionLifeTime
- */
public long getConnectionLifeTime() {
return connectionLifeTime;
}
@@ -95,6 +74,4 @@ public class CompositeStats {
builder.append("]");
return builder.toString();
}
-
-
}
diff --git a/geode-core/src/test/java/org/apache/geode/management/CompositeTestMBean.java b/geode-core/src/test/java/org/apache/geode/management/CompositeTestMBean.java
index 3c9ba8c..f515d97 100644
--- a/geode-core/src/test/java/org/apache/geode/management/CompositeTestMBean.java
+++ b/geode-core/src/test/java/org/apache/geode/management/CompositeTestMBean.java
@@ -18,12 +18,13 @@ import java.util.HashMap;
import java.util.Map;
public class CompositeTestMBean implements CompositeTestMXBean {
+
private final String connectionStatsType = "AX";
- private long connectionsOpened = 100;
- private long connectionsClosed = 50;
- private long connectionsAttempted = 120;
- private long connectionsFailed = 20;
- private long connectionLifeTime = 100;
+ private final long connectionsOpened = 100;
+ private final long connectionsClosed = 50;
+ private final long connectionsAttempted = 120;
+ private final long connectionsFailed = 20;
+ private final long connectionLifeTime = 100;
@Override
public CompositeStats getCompositeStats() {
@@ -46,7 +47,6 @@ public class CompositeTestMBean implements CompositeTestMXBean {
@Override
public CompositeStats[] getCompositeArray() {
-
CompositeStats[] arr = new CompositeStats[2];
for (int i = 0; i < arr.length; i++) {
arr[i] = new CompositeStats("AX" + i, connectionsOpened, connectionsClosed,
diff --git a/geode-core/src/test/java/org/apache/geode/management/CompositeTestMXBean.java b/geode-core/src/test/java/org/apache/geode/management/CompositeTestMXBean.java
index bcbc441..011ea2f 100644
--- a/geode-core/src/test/java/org/apache/geode/management/CompositeTestMXBean.java
+++ b/geode-core/src/test/java/org/apache/geode/management/CompositeTestMXBean.java
@@ -17,15 +17,14 @@ package org.apache.geode.management;
import java.util.Map;
public interface CompositeTestMXBean {
- // [A] MBean Attributes
- // 0. Basic
- public CompositeStats getCompositeStats();
- public CompositeStats listCompositeStats();
+ CompositeStats getCompositeStats();
- public Map<String, Integer> getMap();
+ CompositeStats listCompositeStats();
- public Integer[] getIntegerArray();
+ Map<String, Integer> getMap();
- public CompositeStats[] getCompositeArray();
+ Integer[] getIntegerArray();
+
+ CompositeStats[] getCompositeArray();
}
diff --git a/geode-core/src/test/java/org/apache/geode/management/CompositeTypeTestDUnitTest.java b/geode-core/src/test/java/org/apache/geode/management/CompositeTypeTestDUnitTest.java
index 33bbc08..b60c462 100644
--- a/geode-core/src/test/java/org/apache/geode/management/CompositeTypeTestDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/CompositeTypeTestDUnitTest.java
@@ -14,8 +14,8 @@
*/
package org.apache.geode.management;
-import static java.util.concurrent.TimeUnit.*;
-import static org.assertj.core.api.Assertions.*;
+import static java.util.concurrent.TimeUnit.MINUTES;
+import static org.assertj.core.api.Assertions.assertThat;
import java.io.Serializable;
@@ -32,6 +32,12 @@ import org.apache.geode.management.internal.SystemManagementService;
import org.apache.geode.test.dunit.VM;
import org.apache.geode.test.junit.categories.DistributedTest;
+/**
+ * Distributed tests for registering of custom mbean using composite types.
+ * <p>
+ *
+ * See User API {@link ManagementService#registerMBean(Object, ObjectName)}.
+ */
@Category(DistributedTest.class)
@SuppressWarnings({"serial", "unused"})
public class CompositeTypeTestDUnitTest implements Serializable {
diff --git a/geode-core/src/test/java/org/apache/geode/management/DLockManagementDUnitTest.java b/geode-core/src/test/java/org/apache/geode/management/DLockManagementDUnitTest.java
index 1193f6b..ef5ace1 100644
--- a/geode-core/src/test/java/org/apache/geode/management/DLockManagementDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/DLockManagementDUnitTest.java
@@ -14,10 +14,11 @@
*/
package org.apache.geode.management;
-import static java.util.concurrent.TimeUnit.*;
-import static org.apache.geode.internal.process.ProcessUtils.*;
-import static org.apache.geode.management.internal.MBeanJMXAdapter.*;
-import static org.assertj.core.api.Assertions.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.apache.geode.internal.process.ProcessUtils.identifyPid;
+import static org.apache.geode.management.internal.MBeanJMXAdapter.getDistributedLockServiceName;
+import static org.apache.geode.management.internal.MBeanJMXAdapter.getLockServiceMBeanName;
+import static org.assertj.core.api.Assertions.assertThat;
import java.io.Serializable;
import java.util.Map;
@@ -42,7 +43,7 @@ import org.apache.geode.test.junit.categories.DistributedTest;
@SuppressWarnings({"serial", "unused"})
public class DLockManagementDUnitTest implements Serializable {
- private static final int MAX_WAIT_MILLIS = 120 * 1000; // 2 MINUTES
+ private static final int MAX_WAIT_MILLIS = 2 * 60 * 1000; // 2 MINUTES
private static final String LOCK_SERVICE_NAME =
DLockManagementDUnitTest.class.getSimpleName() + "_testLockService";
diff --git a/geode-core/src/test/java/org/apache/geode/management/DiskManagementDUnitTest.java b/geode-core/src/test/java/org/apache/geode/management/DiskManagementDUnitTest.java
index 2807f34..724fad7 100644
--- a/geode-core/src/test/java/org/apache/geode/management/DiskManagementDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/DiskManagementDUnitTest.java
@@ -14,8 +14,8 @@
*/
package org.apache.geode.management;
-import static java.util.concurrent.TimeUnit.*;
-import static org.assertj.core.api.Assertions.*;
+import static java.util.concurrent.TimeUnit.MINUTES;
+import static org.assertj.core.api.Assertions.assertThat;
import java.io.File;
import java.io.Serializable;
diff --git a/geode-core/src/test/java/org/apache/geode/management/DistributedSystemDUnitTest.java b/geode-core/src/test/java/org/apache/geode/management/DistributedSystemDUnitTest.java
index 9bfb525..3e2c36f 100644
--- a/geode-core/src/test/java/org/apache/geode/management/DistributedSystemDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/DistributedSystemDUnitTest.java
@@ -14,16 +14,20 @@
*/
package org.apache.geode.management;
-import static java.lang.management.ManagementFactory.*;
-import static java.util.concurrent.TimeUnit.*;
-import static org.apache.geode.management.internal.MBeanJMXAdapter.*;
-import static org.apache.geode.test.dunit.Host.*;
-import static org.apache.geode.test.dunit.IgnoredException.*;
-import static org.apache.geode.test.dunit.Invoke.*;
-import static org.assertj.core.api.Assertions.*;
+import static java.lang.management.ManagementFactory.getPlatformMBeanServer;
+import static java.util.concurrent.TimeUnit.MINUTES;
+import static org.apache.geode.management.internal.MBeanJMXAdapter.getDistributedSystemName;
+import static org.apache.geode.management.internal.MBeanJMXAdapter.getMemberMBeanName;
+import static org.apache.geode.management.internal.MBeanJMXAdapter.getMemberNameOrId;
+import static org.apache.geode.test.dunit.Host.getHost;
+import static org.apache.geode.test.dunit.IgnoredException.addIgnoredException;
+import static org.apache.geode.test.dunit.Invoke.invokeInEveryVM;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.Serializable;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -36,9 +40,9 @@ import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.management.ObjectName;
+import org.apache.logging.log4j.Logger;
import org.awaitility.Awaitility;
import org.awaitility.core.ConditionFactory;
-import org.apache.logging.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
@@ -61,20 +65,31 @@ import org.apache.geode.test.dunit.VM;
import org.apache.geode.test.junit.categories.DistributedTest;
/**
- * Distributed System management tests
- * </p>
- * a) For all the notifications i) gemfire.distributedsystem.member.joined ii)
- * gemfire.distributedsystem.member.left iii) gemfire.distributedsystem.member.suspect iv ) All
- * notifications emitted by member mbeans vi) Alerts
- * </p>
+ * DistributedSystemMXBean tests:
+ *
+ * <p>
+ * a) For all the notifications
+ * <ul>
+ * <li>i) gemfire.distributedsystem.member.joined
+ * <li>ii) gemfire.distributedsystem.member.left
+ * <li>iii) gemfire.distributedsystem.member.suspect
+ * <li>iv) All notifications emitted by member mbeans
+ * <li>v) Alerts
+ * </ul>
+ *
+ * <p>
* b) Concurrently modify proxy list by removing member and accessing the distributed system MBean
- * </p>
+ *
+ * <p>
* c) Aggregate Operations like shutDownAll
- * </p>
+ *
+ * <p>
* d) Member level operations like fetchJVMMetrics()
- * </p>
+ *
+ * <p>
* e ) Statistics
- * </p>
+ *
+ * <p>
* TODO: break up the large tests into smaller tests
*/
@Category(DistributedTest.class)
@@ -86,8 +101,8 @@ public class DistributedSystemDUnitTest implements Serializable {
private static final String WARNING_LEVEL_MESSAGE = "Warning Level Alert Message";
private static final String SEVERE_LEVEL_MESSAGE = "Severe Level Alert Message";
- private static List<Notification> notifications;
- private static Map<ObjectName, NotificationListener> notificationListenerMap;
+ private static volatile List<Notification> notifications;
+ private static volatile Map<ObjectName, NotificationListener> notificationListenerMap;
@Manager
private VM managerVM;
@@ -100,16 +115,20 @@ public class DistributedSystemDUnitTest implements Serializable {
@Before
public void before() throws Exception {
- notifications = new ArrayList<>();
- notificationListenerMap = new HashMap<>();
-
- invokeInEveryVM(() -> notifications = new ArrayList<>());
- invokeInEveryVM(() -> notificationListenerMap = new HashMap<>());
+ notifications = Collections.synchronizedList(new ArrayList<>());
+ notificationListenerMap = Collections.synchronizedMap(new HashMap<>());
+ invokeInEveryVM(() -> notifications = Collections.synchronizedList(new ArrayList<>()));
+ invokeInEveryVM(() -> notificationListenerMap = Collections.synchronizedMap(new HashMap<>()));
}
@After
public void after() throws Exception {
resetAlertCounts(this.managerVM);
+
+ notifications = null;
+ notificationListenerMap = null;
+ invokeInEveryVM(() -> notifications = null);
+ invokeInEveryVM(() -> notificationListenerMap = null);
}
/**
diff --git a/geode-core/src/test/java/org/apache/geode/management/JMXMBeanDUnitTest.java b/geode-core/src/test/java/org/apache/geode/management/JMXMBeanDUnitTest.java
index d2123f4..6a32cb8 100644
--- a/geode-core/src/test/java/org/apache/geode/management/JMXMBeanDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/JMXMBeanDUnitTest.java
@@ -38,32 +38,29 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.junit.Assert.assertEquals;
-import com.google.common.collect.Maps;
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
-import org.apache.geode.internal.AvailablePortHelper;
-import org.apache.geode.internal.security.SecurableCommunicationChannel;
-import org.apache.geode.test.dunit.rules.CleanupDUnitVMsRule;
-import org.apache.geode.test.dunit.rules.Locator;
-import org.apache.geode.test.dunit.rules.LocatorServerStartupRule;
-import org.apache.geode.test.dunit.rules.MBeanServerConnectionRule;
-import org.apache.geode.test.dunit.rules.MemberVM;
-import org.apache.geode.test.junit.categories.DistributedTest;
-import org.apache.geode.util.test.TestUtil;
+import javax.rmi.ssl.SslRMIClientSocketFactory;
+
+import com.google.common.collect.Maps;
import org.junit.Before;
import org.junit.BeforeClass;
-import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.junit.contrib.java.lang.system.RestoreSystemProperties;
import org.junit.experimental.categories.Category;
import org.junit.rules.RuleChain;
-import java.io.Serializable;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Properties;
-import javax.management.MBeanServerConnection;
-import javax.rmi.ssl.SslRMIClientSocketFactory;
+import org.apache.geode.internal.AvailablePortHelper;
+import org.apache.geode.internal.security.SecurableCommunicationChannel;
+import org.apache.geode.test.dunit.rules.CleanupDUnitVMsRule;
+import org.apache.geode.test.dunit.rules.LocatorServerStartupRule;
+import org.apache.geode.test.dunit.rules.MBeanServerConnectionRule;
+import org.apache.geode.test.junit.categories.DistributedTest;
+import org.apache.geode.util.test.TestUtil;
/**
* All the non-ssl enabled locators need to be in a different VM than the ssl enabled locators in
@@ -71,7 +68,9 @@ import javax.rmi.ssl.SslRMIClientSocketFactory;
* ssl settings cleanly.
*/
@Category(DistributedTest.class)
+@SuppressWarnings({"serial", "unused"})
public class JMXMBeanDUnitTest implements Serializable {
+
private LocatorServerStartupRule lsRule = new LocatorServerStartupRule();
private transient MBeanServerConnectionRule jmxConnector = new MBeanServerConnectionRule();
private transient RestoreSystemProperties restoreSystemProperties = new RestoreSystemProperties();
@@ -182,7 +181,6 @@ public class JMXMBeanDUnitTest implements Serializable {
});
}
-
private Map<String, Object> getClientEnvironment(boolean withAlias) {
System.setProperty("javax.net.ssl.keyStore", withAlias ? multiKeystore : singleKeystore);
System.setProperty("javax.net.ssl.keyStoreType", "JKS");
@@ -195,7 +193,6 @@ public class JMXMBeanDUnitTest implements Serializable {
return environment;
}
-
private void validateJmxConnection(MBeanServerConnectionRule mBeanServerConnectionRule)
throws Exception {
// Get MBean proxy instance that will be used to make calls to registered MBean
diff --git a/geode-core/src/test/java/org/apache/geode/management/LocatorManagementDUnitTest.java b/geode-core/src/test/java/org/apache/geode/management/LocatorManagementDUnitTest.java
index 205ada5..93b081c 100644
--- a/geode-core/src/test/java/org/apache/geode/management/LocatorManagementDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/LocatorManagementDUnitTest.java
@@ -14,62 +14,58 @@
*/
package org.apache.geode.management;
+import static java.util.concurrent.TimeUnit.MINUTES;
import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER;
import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_HTTP_PORT;
import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_PORT;
import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_START;
import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS;
-import static org.apache.geode.distributed.ConfigurationProperties.LOG_LEVEL;
-import static org.apache.geode.distributed.ConfigurationProperties.MCAST_PORT;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.apache.geode.internal.AvailablePortHelper.getRandomAvailableTCPPort;
+import static org.apache.geode.management.MXBeanAwaitility.awaitLocalLocatorMXBean;
+import static org.apache.geode.management.MXBeanAwaitility.awaitLocatorMXBeanProxy;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
+
+import java.io.File;
+import java.net.InetAddress;
+import java.util.Properties;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
import org.apache.geode.distributed.DistributedMember;
import org.apache.geode.distributed.Locator;
-import org.apache.geode.distributed.internal.DistributionConfig;
import org.apache.geode.distributed.internal.InternalLocator;
-import org.apache.geode.internal.AvailablePortHelper;
-import org.apache.geode.internal.cache.GemFireCacheImpl;
-import org.apache.geode.management.internal.ManagementConstants;
-import org.apache.geode.test.dunit.Assert;
import org.apache.geode.test.dunit.Host;
-import org.apache.geode.test.dunit.LogWriterUtils;
-import org.apache.geode.test.dunit.SerializableCallable;
import org.apache.geode.test.dunit.VM;
-import org.apache.geode.test.dunit.Wait;
-import org.apache.geode.test.dunit.WaitCriterion;
import org.apache.geode.test.junit.categories.DistributedTest;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-
-import java.io.File;
-import java.io.IOException;
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-import java.util.Properties;
/**
- * Test cases
- *
- * DistributedSystem Cache Locator no no yes yes no yes yes yes yes
+ * Distributed tests for {@link LocatorMXBean}.
*/
@Category(DistributedTest.class)
public class LocatorManagementDUnitTest extends ManagementTestBase {
- private static final int MAX_WAIT = 8 * ManagementConstants.REFRESH_TIME;
+ private VM managerVM;
+ private VM locatorVM;
+
+ private String hostName;
+ private int locatorPort;
- private VM locator;
+ @Before
+ public void setUp() throws Exception {
+ managerVM = managingNode;
+ locatorVM = managedNode1;
- @Override
- protected final void postSetUpManagementTestBase() throws Exception {
- locator = managedNode1;
+ hostName = Host.getHost(0).getHostName();
+ locatorPort = getRandomAvailableTCPPort();
}
- @Override
- protected final void preTearDownManagementTestBase() throws Exception {
- stopLocator(locator);
+ @After
+ public void tearDown() throws Exception {
+ stopLocator(locatorVM);
}
/**
@@ -77,46 +73,41 @@ public class LocatorManagementDUnitTest extends ManagementTestBase {
*/
@Test
public void testPeerLocation() throws Exception {
- int locPort = AvailablePortHelper.getRandomAvailableTCPPort();
- startLocator(locator, locPort);
- locatorMBeanExist(locator, locPort);
-
- Host host = Host.getHost(0);
- String host0 = getServerHostName(host);
- Properties props = new Properties();
- props.setProperty(MCAST_PORT, "0");
- props.setProperty(LOCATORS, host0 + "[" + locPort + "]");
- props.setProperty(JMX_MANAGER, "true");
- props.setProperty(JMX_MANAGER_START, "false");
- props.setProperty(JMX_MANAGER_PORT, "0");
- props.setProperty(JMX_MANAGER_HTTP_PORT, "0");
- createCache(managingNode, props);
- startManagingNode(managingNode);
- DistributedMember locatorMember = getMember(locator);
- remoteLocatorMBeanExist(managingNode, locatorMember);
+ startLocator(locatorVM, locatorPort);
+ validateLocatorMXBean(locatorVM, locatorPort);
+ Properties config = new Properties();
+ config.setProperty(LOCATORS, hostName + "[" + locatorPort + "]");
+ config.setProperty(JMX_MANAGER, "true");
+ config.setProperty(JMX_MANAGER_START, "false");
+ config.setProperty(JMX_MANAGER_PORT, "0");
+ config.setProperty(JMX_MANAGER_HTTP_PORT, "0");
+
+ createCache(managerVM, config);
+ startManagingNode(managerVM);
+ DistributedMember locatorMember = getMember(locatorVM);
+
+ validateLocatorMXBean(managerVM, locatorMember);
}
@Test
public void testPeerLocationWithPortZero() throws Exception {
- // Start the locator with port=0
- int locPort = startLocator(locator, 0);
- locatorMBeanExist(locator, locPort);
-
- Host host = Host.getHost(0);
- String host0 = getServerHostName(host);
- Properties props = new Properties();
- props.setProperty(MCAST_PORT, "0");
- props.setProperty(LOCATORS, host0 + "[" + locPort + "]");
- props.setProperty(JMX_MANAGER, "true");
- props.setProperty(JMX_MANAGER_START, "false");
- props.setProperty(JMX_MANAGER_PORT, "0");
- props.setProperty(JMX_MANAGER_HTTP_PORT, "0");
- createCache(managingNode, props);
- startManagingNode(managingNode);
- DistributedMember locatorMember = getMember(locator);
- remoteLocatorMBeanExist(managingNode, locatorMember);
+ locatorPort = startLocator(locatorVM, 0);
+
+ validateLocatorMXBean(locatorVM, locatorPort);
+
+ Properties config = new Properties();
+ config.setProperty(LOCATORS, hostName + "[" + locatorPort + "]");
+ config.setProperty(JMX_MANAGER, "true");
+ config.setProperty(JMX_MANAGER_START, "false");
+ config.setProperty(JMX_MANAGER_PORT, "0");
+ config.setProperty(JMX_MANAGER_HTTP_PORT, "0");
+ createCache(managerVM, config);
+ startManagingNode(managerVM);
+ DistributedMember locatorMember = getMember(locatorVM);
+
+ validateLocatorMXBean(managerVM, locatorMember);
}
/**
@@ -125,260 +116,125 @@ public class LocatorManagementDUnitTest extends ManagementTestBase {
@Test
public void testColocatedLocator() throws Exception {
initManagement(false);
- int locPort = AvailablePortHelper.getRandomAvailableTCPPort();
- startLocator(locator, locPort);
- locatorMBeanExist(locator, locPort);
+ startLocator(locatorVM, locatorPort);
+
+ validateLocatorMXBean(locatorVM, locatorPort);
}
@Test
public void testColocatedLocatorWithPortZero() throws Exception {
initManagement(false);
- int locPort = startLocator(locator, 0);
- locatorMBeanExist(locator, locPort);
+ locatorPort = startLocator(locatorVM, 0);
+
+ validateLocatorMXBean(locatorVM, locatorPort);
}
@Test
public void testListManagers() throws Exception {
initManagement(false);
- int locPort = AvailablePortHelper.getRandomAvailableTCPPort();
- startLocator(locator, locPort);
- listManagers(locator, locPort);
+
+ startLocator(locatorVM, locatorPort);
+
+ validateManagers(locatorVM);
}
@Test
public void testListManagersWithPortZero() throws Exception {
initManagement(false);
- int locPort = startLocator(locator, 0);
- listManagers(locator, locPort);
+
+ startLocator(locatorVM, 0);
+
+ validateManagers(locatorVM);
}
@Test
public void testWillingManagers() throws Exception {
- int locPort = AvailablePortHelper.getRandomAvailableTCPPort();
- startLocator(locator, locPort);
+ startLocator(locatorVM, locatorPort);
- Host host = Host.getHost(0);
- String host0 = getServerHostName(host);
+ Properties config = new Properties();
+ config.setProperty(LOCATORS, hostName + "[" + locatorPort + "]");
+ config.setProperty(JMX_MANAGER, "true");
- Properties props = new Properties();
- props.setProperty(MCAST_PORT, "0");
- props.setProperty(LOCATORS, host0 + "[" + locPort + "]");
- props.setProperty(JMX_MANAGER, "true");
+ createCache(managedNode2, config);
+ createCache(managedNode3, config);
- createCache(managedNode2, props);
- createCache(managedNode3, props);
-
- listWillingManagers(locator);
+ validatePotentialManagers(locatorVM, 3);
}
@Test
public void testWillingManagersWithPortZero() throws Exception {
- int locPort = startLocator(locator, 0);
-
- Host host = Host.getHost(0);
- String host0 = getServerHostName(host);
+ locatorPort = startLocator(locatorVM, 0);
- Properties props = new Properties();
- props.setProperty(MCAST_PORT, "0");
- props.setProperty(LOCATORS, host0 + "[" + locPort + "]");
- props.setProperty(JMX_MANAGER, "true");
+ Properties config = new Properties();
+ config.setProperty(LOCATORS, hostName + "[" + locatorPort + "]");
+ config.setProperty(JMX_MANAGER, "true");
- createCache(managedNode2, props);
- createCache(managedNode3, props);
+ createCache(managedNode2, config);
+ createCache(managedNode3, config);
- listWillingManagers(locator);
+ validatePotentialManagers(locatorVM, 3);
}
/**
* Starts a locator with given configuration. If DS is already started it will use the same DS
- *
- * @param vm reference to VM
*/
- protected Integer startLocator(final VM vm, final int port) {
+ private int startLocator(final VM locatorVM, final int port) {
+ return locatorVM.invoke("Start Locator In VM", () -> {
+ assertThat(InternalLocator.hasLocator()).isFalse();
- return (Integer) vm.invoke(new SerializableCallable("Start Locator In VM") {
+ Properties config = new Properties();
+ config.setProperty(LOCATORS, "");
- public Object call() throws Exception {
+ InetAddress bindAddress = InetAddress.getByName(hostName);
- assertFalse(InternalLocator.hasLocator());
+ File logFile = new File(getTestMethodName() + "-locator" + port + ".log");
+ Locator locator = Locator.startLocatorAndDS(port, logFile, bindAddress, config);
- Properties props = new Properties();
- props.setProperty(MCAST_PORT, "0");
-
- props.setProperty(LOCATORS, "");
- props.setProperty(LOG_LEVEL, LogWriterUtils.getDUnitLogLevel());
-
- InetAddress bindAddr = null;
- try {
- bindAddr = InetAddress.getByName(getServerHostName(vm.getHost()));
- } catch (UnknownHostException uhe) {
- Assert.fail("While resolving bind address ", uhe);
- }
-
- Locator locator = null;
- try {
- File logFile = new File(getTestMethodName() + "-locator" + port + ".log");
- locator = Locator.startLocatorAndDS(port, logFile, bindAddr, props);
- } catch (IOException ex) {
- Assert.fail("While starting locator on port " + port, ex);
- }
-
- assertTrue(InternalLocator.hasLocator());
- return locator.getPort();
- }
+ assertThat(InternalLocator.hasLocator()).isTrue();
+ return locator.getPort();
});
}
- /**
- * Creates a persistent region
- *
- * @param vm reference to VM
- */
- protected String stopLocator(VM vm) {
-
- return (String) vm.invoke(new SerializableCallable("Stop Locator In VM") {
-
- public Object call() throws Exception {
+ private void stopLocator(final VM vm) {
+ vm.invoke("Stop Locator In VM", () -> {
+ assertThat(InternalLocator.hasLocator()).isTrue();
- assertTrue(InternalLocator.hasLocator());
- InternalLocator.getLocator().stop();
- return null;
- }
+ InternalLocator.getLocator().stop();
});
}
- /**
- * Creates a persistent region
- *
- * @param vm reference to VM
- */
- protected void locatorMBeanExist(VM vm, final int locPort) {
-
- vm.invoke(new SerializableCallable("Locator MBean created") {
-
- public Object call() throws Exception {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
-
- ManagementService service = ManagementService.getExistingManagementService(cache);
- assertNotNull(service);
- LocatorMXBean bean = service.getLocalLocatorMXBean();
- assertNotNull(bean);
- assertEquals(locPort, bean.getPort());
- LogWriterUtils.getLogWriter().info("Log of Locator" + bean.viewLog());
- LogWriterUtils.getLogWriter().info("BindAddress" + bean.getBindAddress());
- return null;
- }
+ private void validateLocatorMXBean(final VM locatorVM, final int port) {
+ locatorVM.invoke("validateLocatorMXBean", () -> {
+ LocatorMXBean locatorMXBean = awaitLocalLocatorMXBean();
+
+ assertThat(locatorMXBean.getPort()).isEqualTo(port);
});
}
- /**
- * Creates a persistent region
- *
- * @param vm reference to VM
- */
- protected void remoteLocatorMBeanExist(VM vm, final DistributedMember member) {
-
- vm.invoke(new SerializableCallable("Locator MBean created") {
-
- public Object call() throws Exception {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
- ManagementService service = ManagementService.getExistingManagementService(cache);
- assertNotNull(service);
- LocatorMXBean bean = MBeanUtil.getLocatorMbeanProxy(member);
- assertNotNull(bean);
-
- LogWriterUtils.getLogWriter().info("Log of Locator" + bean.viewLog());
- LogWriterUtils.getLogWriter().info("BindAddress" + bean.getBindAddress());
-
- return null;
- }
+ private void validateLocatorMXBean(final VM vm, final DistributedMember member) {
+ vm.invoke("validateLocatorMXBean", () -> {
+ LocatorMXBean locatorMXBean = awaitLocatorMXBeanProxy(member);
+ assertThat(locatorMXBean).isNotNull();
});
}
- /**
- * Creates a persistent region
- *
- * @param vm reference to VM
- */
- protected void listManagers(VM vm, final int locPort) {
-
- vm.invoke(new SerializableCallable("List Managers") {
-
- public Object call() throws Exception {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
-
- ManagementService service = ManagementService.getExistingManagementService(cache);
- assertNotNull(service);
- final LocatorMXBean bean = service.getLocalLocatorMXBean();
- assertNotNull(bean);
-
- Wait.waitForCriterion(new WaitCriterion() {
-
- public String description() {
- return "Waiting for the managers List";
- }
-
- public boolean done() {
+ private void validateManagers(final VM locatorVM) {
+ locatorVM.invoke("validateManagers", () -> {
+ LocatorMXBean locatorMXBean = awaitLocalLocatorMXBean();
- boolean done = bean.listManagers().length == 1;
- return done;
- }
-
- }, MAX_WAIT, 500, true);
-
- return null;
- }
+ await().atMost(2, MINUTES).until(() -> assertThat(locatorMXBean.listManagers()).hasSize(1));
});
}
- /**
- * Creates a persistent region
- *
- * @param vm reference to VM
- */
- protected void listWillingManagers(VM vm) {
-
- vm.invoke(new SerializableCallable("List Willing Managers") {
-
- public Object call() throws Exception {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
-
- ManagementService service = ManagementService.getExistingManagementService(cache);
- assertNotNull(service);
- final LocatorMXBean bean = service.getLocalLocatorMXBean();
- assertNotNull(bean);
-
- Wait.waitForCriterion(new WaitCriterion() {
-
- public String description() {
- return "Waiting for the Willing managers List";
- }
+ private void validatePotentialManagers(final VM locatorVM,
+ final int expectedNumberPotentialManagers) {
+ locatorVM.invoke("List Willing Managers", () -> {
+ LocatorMXBean locatorMXBean = awaitLocalLocatorMXBean();
- public boolean done() {
-
- boolean done = bean.listPotentialManagers().length == 3;
- return done;
- }
-
- }, MAX_WAIT, 500, true);
-
- return null;
- }
+ await().atMost(2, MINUTES).until(() -> assertThat(locatorMXBean.listPotentialManagers())
+ .hasSize(expectedNumberPotentialManagers));
});
}
-
- /**
- * get the host name to use for a server cache in client/server dunit testing
- *
- * @param host
- * @return the host name
- */
- public static String getServerHostName(Host host) {
- return System.getProperty(DistributionConfig.GEMFIRE_PREFIX + "server-bind-address") != null
- ? System.getProperty(DistributionConfig.GEMFIRE_PREFIX + "server-bind-address")
- : host.getHostName();
- }
-
}
diff --git a/geode-core/src/test/java/org/apache/geode/management/MBeanUtil.java b/geode-core/src/test/java/org/apache/geode/management/MBeanUtil.java
index 13b2536..ae9f0c1 100644
--- a/geode-core/src/test/java/org/apache/geode/management/MBeanUtil.java
+++ b/geode-core/src/test/java/org/apache/geode/management/MBeanUtil.java
@@ -14,7 +14,7 @@
*/
package org.apache.geode.management;
-import static org.junit.Assert.*;
+import static org.junit.Assert.fail;
import javax.management.InstanceNotFoundException;
import javax.management.IntrospectionException;
diff --git a/geode-core/src/test/java/org/apache/geode/management/MXBeanAwaitility.java b/geode-core/src/test/java/org/apache/geode/management/MXBeanAwaitility.java
new file mode 100644
index 0000000..80add3f
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/management/MXBeanAwaitility.java
@@ -0,0 +1,80 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
+ * agreements. See the NOTICE file distributed with this work for additional information regarding
+ * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License. You may obtain a
+ * copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.geode.management;
+
+import static java.util.concurrent.TimeUnit.MINUTES;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import javax.management.ObjectName;
+
+import org.awaitility.Awaitility;
+import org.awaitility.core.ConditionFactory;
+
+import org.apache.geode.cache.Cache;
+import org.apache.geode.distributed.DistributedMember;
+import org.apache.geode.internal.cache.GemFireCacheImpl;
+import org.apache.geode.management.internal.SystemManagementService;
+
+class MXBeanAwaitility {
+
+ static LocatorMXBean awaitLocalLocatorMXBean() {
+ SystemManagementService service = getSystemManagementService();
+
+ await().atMost(2, MINUTES).until(() -> assertThat(service.getLocalLocatorMXBean()).isNotNull());
+
+ return service.getLocalLocatorMXBean();
+ }
+
+ static LocatorMXBean awaitLocatorMXBeanProxy(final DistributedMember member) {
+ SystemManagementService service = getSystemManagementService();
+ ObjectName objectName = service.getLocatorMBeanName(member);
+
+ String alias = "Awaiting LocatorMXBean proxy for " + member;
+ await(alias).until(
+ () -> assertThat(service.getMBeanProxy(objectName, LocatorMXBean.class)).isNotNull());
+
+ return service.getMBeanProxy(objectName, LocatorMXBean.class);
+ }
+
+ static SystemManagementService getSystemManagementService() {
+ Cache cache = GemFireCacheImpl.getInstance();
+ return (SystemManagementService) ManagementService.getExistingManagementService(cache);
+ }
+
+ static ConditionFactory await() {
+ return Awaitility.await().atMost(2, MINUTES);
+ }
+
+ static ConditionFactory await(final String alias) {
+ return Awaitility.await(alias).atMost(2, MINUTES);
+ }
+
+ static MemberMXBean awaitMemberMXBeanProxy(final DistributedMember member) {
+ return awaitMemberMXBeanProxy(member, getSystemManagementService());
+ }
+
+ static MemberMXBean awaitMemberMXBeanProxy(final DistributedMember member,
+ final SystemManagementService managementService) {
+ ObjectName objectName = managementService.getMemberMBeanName(member);
+
+ String alias = "Awaiting MemberMXBean proxy for " + member;
+ await(alias)
+ .until(() -> assertThat(managementService.getMBeanProxy(objectName, MemberMXBean.class))
+ .isNotNull());
+
+ return managementService.getMBeanProxy(objectName, MemberMXBean.class);
+ }
+}
diff --git a/geode-core/src/test/java/org/apache/geode/management/ManagementTestBase.java b/geode-core/src/test/java/org/apache/geode/management/ManagementTestBase.java
index ef1c4fa..36b3787 100644
--- a/geode-core/src/test/java/org/apache/geode/management/ManagementTestBase.java
+++ b/geode-core/src/test/java/org/apache/geode/management/ManagementTestBase.java
@@ -14,55 +14,44 @@
*/
package org.apache.geode.management;
-import static org.apache.geode.distributed.ConfigurationProperties.*;
-import static org.junit.Assert.*;
+import static org.apache.geode.distributed.ConfigurationProperties.ENABLE_TIME_STATISTICS;
+import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER;
+import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_HTTP_PORT;
+import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_PORT;
+import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_START;
+import static org.apache.geode.distributed.ConfigurationProperties.LOG_FILE;
+import static org.apache.geode.distributed.ConfigurationProperties.STATISTIC_SAMPLING_ENABLED;
-import java.lang.management.ManagementFactory;
import java.util.ArrayList;
-import java.util.Iterator;
import java.util.List;
import java.util.Properties;
-import java.util.Set;
import javax.management.ObjectName;
import org.junit.Rule;
import org.apache.geode.cache.Cache;
-import org.apache.geode.cache.CacheFactory;
-import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionFactory;
import org.apache.geode.cache.RegionShortcut;
+import org.apache.geode.cache30.CacheTestCase;
import org.apache.geode.distributed.DistributedMember;
-import org.apache.geode.distributed.DistributedSystem;
import org.apache.geode.distributed.internal.InternalDistributedSystem;
import org.apache.geode.internal.cache.GemFireCacheImpl;
-import org.apache.geode.management.internal.FederatingManager;
-import org.apache.geode.management.internal.LocalManager;
-import org.apache.geode.management.internal.ManagementStrings;
+import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.management.internal.SystemManagementService;
-import org.apache.geode.test.dunit.Assert;
-import org.apache.geode.test.dunit.AsyncInvocation;
import org.apache.geode.test.dunit.Host;
-import org.apache.geode.test.dunit.Invoke;
-import org.apache.geode.test.dunit.LogWriterUtils;
import org.apache.geode.test.dunit.SerializableCallable;
-import org.apache.geode.test.dunit.SerializableRunnable;
import org.apache.geode.test.dunit.VM;
import org.apache.geode.test.dunit.Wait;
import org.apache.geode.test.dunit.WaitCriterion;
-import org.apache.geode.test.dunit.cache.internal.JUnit4CacheTestCase;
-import org.apache.geode.test.dunit.internal.JUnit4DistributedTestCase;
import org.apache.geode.test.dunit.rules.DistributedRestoreSystemProperties;
@SuppressWarnings("serial")
-public abstract class ManagementTestBase extends JUnit4CacheTestCase {
+public abstract class ManagementTestBase extends CacheTestCase {
private static final int MAX_WAIT = 70 * 1000;
- // protected static DistributedSystem ds;
protected static ManagementService managementService;
- // protected static Cache cache;
/**
* List containing all the Managed Node VM
@@ -77,7 +66,6 @@ public abstract class ManagementTestBase extends JUnit4CacheTestCase {
protected static VM managedNode1;
protected static VM managedNode2;
protected static VM managedNode3;
- protected static VM locatorVM;
@Rule
public DistributedRestoreSystemProperties restoreSystemProperties =
@@ -93,16 +81,17 @@ public abstract class ManagementTestBase extends JUnit4CacheTestCase {
managedNode2 = host.getVM(2);
managedNode3 = host.getVM(3);
- managedNodeList = new ArrayList<VM>();
-
+ managedNodeList = new ArrayList<>();
managedNodeList.add(managedNode1);
managedNodeList.add(managedNode2);
managedNodeList.add(managedNode3);
- locatorVM = host.getLocator();
+
postSetUpManagementTestBase();
}
- protected void postSetUpManagementTestBase() throws Exception {}
+ protected void postSetUpManagementTestBase() throws Exception {
+ // override if needed
+ }
@Override
public final void preTearDownCacheTestCase() throws Exception {
@@ -116,15 +105,19 @@ public abstract class ManagementTestBase extends JUnit4CacheTestCase {
postTearDownManagementTestBase();
}
- protected void preTearDownManagementTestBase() throws Exception {}
+ protected void preTearDownManagementTestBase() throws Exception {
+ // override if needed
+ }
- protected void postTearDownManagementTestBase() throws Exception {}
+ protected void postTearDownManagementTestBase() throws Exception {
+ // override if needed
+ }
/**
* managingNodeFirst variable tests for two different test cases where Managing & Managed Node
* creation time lines are reversed.
*/
- protected void initManagement(final boolean managingNodeFirst) throws Exception {
+ protected void initManagement(final boolean managingNodeFirst) {
if (managingNodeFirst) {
createManagementCache(managingNode);
startManagingNode(managingNode);
@@ -141,34 +134,34 @@ public abstract class ManagementTestBase extends JUnit4CacheTestCase {
}
}
- protected void createCache(final VM vm1) throws Exception {
- vm1.invoke("Create Cache", () -> {
+ protected void createCache(final VM vm) {
+ vm.invoke("Create Cache", () -> {
createCache(false);
});
}
- protected void createCache(final VM vm1, final Properties props) throws Exception {
- vm1.invoke("Create Cache", () -> {
+ protected void createCache(final VM vm, final Properties props) {
+ vm.invoke("Create Cache", () -> {
createCache(props);
});
}
- private Cache createCache(final Properties props) {
- Cache cache = getCache(props);
+ private Cache createCache(final Properties config) {
+ Cache cache = getCache(config);
managementService = ManagementService.getManagementService(cache);
-
return cache;
}
- protected Cache createCache(final boolean management) {
-
+ protected Cache createCache(final boolean isManager) {
Properties props = new Properties();
- if (management) {
+
+ if (isManager) {
props.setProperty(JMX_MANAGER, "true");
props.setProperty(JMX_MANAGER_START, "false");
props.setProperty(JMX_MANAGER_PORT, "0");
props.setProperty(JMX_MANAGER_HTTP_PORT, "0");
}
+
props.setProperty(ENABLE_TIME_STATISTICS, "true");
props.setProperty(STATISTIC_SAMPLING_ENABLED, "true");
props.setProperty(LOG_FILE, getTestMethodName() + "-.log");
@@ -179,15 +172,15 @@ public abstract class ManagementTestBase extends JUnit4CacheTestCase {
return cache;
}
- protected void createManagementCache(final VM vm1) throws Exception {
- vm1.invoke("Create Management Cache", () -> {
+ protected void createManagementCache(final VM vm) {
+ vm.invoke("Create Management Cache", () -> {
createCache(true);
});
}
- protected void closeCache(final VM vm1) throws Exception {
- vm1.invoke("Close Cache", () -> {
- GemFireCacheImpl existingInstance = GemFireCacheImpl.getInstance();
+ protected void closeCache(final VM vm) {
+ vm.invoke("Close Cache", () -> {
+ InternalCache existingInstance = GemFireCacheImpl.getInstance();
if (existingInstance != null) {
existingInstance.close();
}
@@ -200,7 +193,7 @@ public abstract class ManagementTestBase extends JUnit4CacheTestCase {
protected String getMemberId(final VM vm) {
return vm.invoke("getMemberId", () -> {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
+ InternalCache cache = GemFireCacheImpl.getInstance();
return cache.getDistributedSystem().getDistributedMember().getId();
});
}
@@ -216,11 +209,7 @@ public abstract class ManagementTestBase extends JUnit4CacheTestCase {
@Override
public boolean done() {
SystemManagementService service = (SystemManagementService) managementService;
- if (service.getMBeanProxy(objectName, interfaceClass) != null) {
- return true;
- } else {
- return false;
- }
+ return service.getMBeanProxy(objectName, interfaceClass) != null;
}
}, MAX_WAIT, 500, true);
}
@@ -228,23 +217,21 @@ public abstract class ManagementTestBase extends JUnit4CacheTestCase {
/**
* Marks a VM as Managing
*/
- protected void startManagingNode(final VM vm1) {
- vm1.invoke("Start Being Managing Node", () -> {
+ protected void startManagingNode(final VM vm) {
+ vm.invoke("Start Being Managing Node", () -> {
Cache existingCache = GemFireCacheImpl.getInstance();
- // if (existingCache != null && !existingCache.isClosed()) {
managementService = ManagementService.getManagementService(existingCache);
SystemManagementService service = (SystemManagementService) managementService;
service.createManager();
service.startManager();
- // }
});
}
/**
* Stops a VM as a Managing node
*/
- protected void stopManagingNode(final VM vm1) {
- vm1.invoke("Stop Being Managing Node", () -> {
+ protected void stopManagingNode(final VM vm) {
+ vm.invoke("Stop Being Managing Node", () -> {
Cache existingCache = GemFireCacheImpl.getInstance();
if (existingCache != null && !existingCache.isClosed()) {
if (managementService.isManager()) {
@@ -267,60 +254,14 @@ public abstract class ManagementTestBase extends JUnit4CacheTestCase {
}
/**
- * Creates a Distributed region
- */
- protected void createDistributedRegion(final VM vm, final String regionName)
- throws InterruptedException {
- AsyncInvocation future = createDistributedRegionAsync(vm, regionName);
- future.join(MAX_WAIT);
- if (future.isAlive()) {
- fail("Region not created within" + MAX_WAIT);
- }
- if (future.exceptionOccurred()) {
- throw new RuntimeException(future.getException());
- }
- }
-
- /**
* Creates a Local region
*/
- protected void createLocalRegion(final VM vm, final String localRegionName) throws Exception {
+ protected void createLocalRegion(final VM vm, final String localRegionName) {
vm.invoke("Create Local region", () -> {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
- SystemManagementService service = (SystemManagementService) getManagementService();
- RegionFactory rf = cache.createRegionFactory(RegionShortcut.LOCAL);
-
- LogWriterUtils.getLogWriter().info("Creating Local Region");
- rf.create(localRegionName);
- });
- }
-
- /**
- * Creates a Sub region
- */
- protected void createSubRegion(final VM vm, final String parentRegionPath,
- final String subregionName) throws Exception {
- vm.invoke("Create Sub region", () -> {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
+ InternalCache cache = GemFireCacheImpl.getInstance();
SystemManagementService service = (SystemManagementService) getManagementService();
- Region region = cache.getRegion(parentRegionPath);
-
- LogWriterUtils.getLogWriter().info("Creating Sub Region");
- region.createSubregion(subregionName, region.getAttributes());
- });
- }
-
- /**
- * Creates a Distributed Region
- */
- private AsyncInvocation createDistributedRegionAsync(final VM vm, final String regionName) {
- return vm.invokeAsync("Create Distributed region", () -> {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
- SystemManagementService service = (SystemManagementService) getManagementService();
-
- RegionFactory rf = cache.createRegionFactory(RegionShortcut.REPLICATE);
- LogWriterUtils.getLogWriter().info("Creating Dist Region");
- rf.create(regionName);
+ RegionFactory factory = cache.createRegionFactory(RegionShortcut.LOCAL);
+ factory.create(localRegionName);
});
}
@@ -329,48 +270,19 @@ public abstract class ManagementTestBase extends JUnit4CacheTestCase {
*/
protected void createPartitionRegion(final VM vm, final String partitionRegionName) {
vm.invoke("Create Partitioned region", () -> {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
+ InternalCache cache = GemFireCacheImpl.getInstance();
SystemManagementService service = (SystemManagementService) getManagementService();
- RegionFactory rf = cache.createRegionFactory(RegionShortcut.PARTITION_REDUNDANT);
- LogWriterUtils.getLogWriter().info("Creating Par Region");
- rf.create(partitionRegionName);
+ RegionFactory factory = cache.createRegionFactory(RegionShortcut.PARTITION_REDUNDANT);
+ factory.create(partitionRegionName);
});
}
- protected void waitForAllMembers(final int expectedCount) {
- ManagementService service = getManagementService();
- final DistributedSystemMXBean bean = service.getDistributedSystemMXBean();
-
- assertNotNull(service.getDistributedSystemMXBean());
-
- Wait.waitForCriterion(new WaitCriterion() {
- @Override
- public String description() {
- return "Waiting All members to intimate DistributedSystemMBean";
- }
-
- @Override
- public boolean done() {
- if (bean.listMemberObjectNames() != null) {
- LogWriterUtils.getLogWriter()
- .info("Member Length " + bean.listMemberObjectNames().length);
- }
- if (bean.listMemberObjectNames().length >= expectedCount) {
- return true;
- } else {
- return false;
- }
- }
- }, MAX_WAIT, 500, true);
-
- assertNotNull(bean.getManagerObjectName());
- }
-
protected static void waitForRefresh(final int expectedRefreshCount,
final ObjectName objectName) {
- final ManagementService service = getManagementService();
+ ManagementService service = getManagementService();
Wait.waitForCriterion(new WaitCriterion() {
+
private int actualRefreshCount = 0;
private long lastRefreshTime = service.getLastUpdateTime(objectName);
@@ -387,10 +299,7 @@ public abstract class ManagementTestBase extends JUnit4CacheTestCase {
actualRefreshCount++;
}
- if (actualRefreshCount >= expectedRefreshCount) {
- return true;
- }
- return false;
+ return actualRefreshCount >= expectedRefreshCount;
}
}, MAX_WAIT, 500, true);
}
@@ -398,19 +307,14 @@ public abstract class ManagementTestBase extends JUnit4CacheTestCase {
protected DistributedMember getMember(final VM vm) {
SerializableCallable getMember = new SerializableCallable("Get Member") {
public Object call() {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
+ InternalCache cache = GemFireCacheImpl.getInstance();
return cache.getDistributedSystem().getDistributedMember();
-
}
};
return (DistributedMember) vm.invoke(getMember);
}
- protected boolean mbeanExists(final ObjectName objectName) {
- return ManagementFactory.getPlatformMBeanServer().isRegistered(objectName);
- }
-
- protected <T> T getMBeanProxy(final ObjectName objectName, Class<T> interfaceClass) {
+ protected <T> T getMBeanProxy(final ObjectName objectName, final Class<T> interfaceClass) {
SystemManagementService service =
(SystemManagementService) ManagementService.getManagementService(getCache());
return service.getMBeanProxy(objectName, interfaceClass);
diff --git a/geode-core/src/test/java/org/apache/geode/management/ManagementTestRule.java b/geode-core/src/test/java/org/apache/geode/management/ManagementTestRule.java
index aff5d6c..d4291d4 100644
--- a/geode-core/src/test/java/org/apache/geode/management/ManagementTestRule.java
+++ b/geode-core/src/test/java/org/apache/geode/management/ManagementTestRule.java
@@ -14,9 +14,15 @@
*/
package org.apache.geode.management;
-import static org.apache.geode.distributed.ConfigurationProperties.*;
-import static org.apache.geode.test.dunit.Host.*;
-import static org.assertj.core.api.Assertions.*;
+import static org.apache.geode.distributed.ConfigurationProperties.ENABLE_TIME_STATISTICS;
+import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_PORT;
+import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER;
+import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_PORT;
+import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_START;
+import static org.apache.geode.distributed.ConfigurationProperties.NAME;
+import static org.apache.geode.distributed.ConfigurationProperties.STATISTIC_SAMPLING_ENABLED;
+import static org.apache.geode.test.dunit.Host.getHost;
+import static org.assertj.core.api.Assertions.assertThat;
import java.io.Serializable;
import java.lang.annotation.Annotation;
@@ -42,7 +48,6 @@ import org.apache.geode.test.dunit.VM;
import org.apache.geode.test.dunit.cache.internal.JUnit4CacheTestCase;
import org.apache.geode.test.dunit.internal.JUnit4DistributedTestCase;
import org.apache.geode.test.dunit.standalone.DUnitLauncher;
-import org.apache.geode.test.junit.rules.serializable.SerializableStatement;
/**
* Note: Overriding MethodRule is only way to get {@code Object target}
diff --git a/geode-core/src/test/java/org/apache/geode/management/MemberMBeanAttributesDUnitTest.java b/geode-core/src/test/java/org/apache/geode/management/MemberMBeanAttributesDUnitTest.java
index 97f766e..403b548 100644
--- a/geode-core/src/test/java/org/apache/geode/management/MemberMBeanAttributesDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/MemberMBeanAttributesDUnitTest.java
@@ -14,265 +14,220 @@
*/
package org.apache.geode.management;
+import static org.apache.geode.management.MXBeanAwaitility.await;
+import static org.apache.geode.management.MXBeanAwaitility.getSystemManagementService;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
import java.lang.management.ManagementFactory;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.apache.geode.cache.Cache;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionFactory;
import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.distributed.internal.InternalDistributedSystem;
import org.apache.geode.internal.NanoTimer;
import org.apache.geode.internal.cache.GemFireCacheImpl;
-import org.apache.geode.internal.process.PidUnavailableException;
+import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.process.ProcessUtils;
-import org.apache.geode.test.dunit.LogWriterUtils;
-import org.apache.geode.test.dunit.SerializableRunnable;
+import org.apache.geode.internal.statistics.HostStatSampler;
+import org.apache.geode.internal.statistics.SampleCollector;
import org.apache.geode.test.dunit.VM;
import org.apache.geode.test.junit.categories.DistributedTest;
import org.apache.geode.test.junit.categories.FlakyTest;
/**
- * This test class checks around 89 attributes of Member MBeans
- *
+ * Distributed tests for {@link MemberMXBean} attributes.
*/
@Category(DistributedTest.class)
+@SuppressWarnings({"serial", "unused"})
public class MemberMBeanAttributesDUnitTest extends ManagementTestBase {
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Factor converting bytes to MB
- */
- private static final long MBFactor = 1024 * 1024;
-
- // This must be bigger than the dunit ack-wait-threshold for the revoke
- // tests. The command line is setting the ack-wait-threshold to be
- // 60 seconds.
- private static final int MAX_WAIT = 70 * 1000;
-
- protected static final long SLEEP = 100;
-
-
-
- public MemberMBeanAttributesDUnitTest() {
- super();
- }
-
- protected void sample(VM vm1) {
- vm1.invoke(new SerializableRunnable("Create Cache") {
- public void run() {
- InternalDistributedSystem.getConnectedInstance().getStatSampler().getSampleCollector()
- .sample(NanoTimer.getTime());
- }
-
- });
- }
-
-
+ private static final long BYTES_PER_MEGABYTE = 1024 * 1024;
@Test
public void testReplRegionAttributes() throws Exception {
initManagement(false);
setupForReplicateRegionAttributes(managedNodeList.get(0), 1);
setupForReplicateRegionAttributes(managedNodeList.get(1), 201);
- sample(managedNodeList.get(1));// Sample now
- isReplicatedRegionAttrsOK(managedNodeList.get(1));
- }
+ sampleStatistics(managedNodeList.get(1));// Sample now
+ validateReplicateRegionAttributes(managedNodeList.get(1));
+ }
@Test
public void testPRRegionAttributes() throws Exception {
initManagement(false);
setupForPartitionedRegionAttributes(managedNodeList.get(0), 1);
- sample(managedNodeList.get(0));// Sample now
- isPartitionedRegionAttrsOK(managedNodeList.get(0));
+ sampleStatistics(managedNodeList.get(0));// Sample now
+
+ validatePartitionedRegionAttributes(managedNodeList.get(0));
}
@Test
public void testOSAttributes() throws Exception {
initManagement(false);
- isOSRelatedAttrsOK(managedNodeList.get(0));
+
+ validateSystemAndOSAttributes(managedNodeList.get(0));
}
@Category(FlakyTest.class) // GEODE-1482
@Test
public void testConfigAttributes() throws Exception {
initManagement(false);
- isConfigRelatedAttrsOK(managedNodeList.get(0));
- }
+ validateConfigAttributes(managedNodeList.get(0));
+ }
- public void setupForReplicateRegionAttributes(VM vm1, final int offset) {
- vm1.invoke(new SerializableRunnable("Create Cache") {
- public void run() {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
- RegionFactory rf = cache.createRegionFactory(RegionShortcut.REPLICATE);
- LogWriterUtils.getLogWriter().info("Creating Dist Region");
- rf.create("testRegion1");
- rf.create("testRegion2");
- rf.create("testRegion3");
-
+ private void sampleStatistics(final VM vm) {
+ vm.invoke("sampleStatistics", () -> {
+ InternalDistributedSystem system = getInternalDistributedSystem();
+ HostStatSampler sampler = system.getStatSampler();
+ SampleCollector sampleCollector = sampler.getSampleCollector();
+ sampleCollector.sample(NanoTimer.getTime());
+ });
+ }
- Region r1 = cache.getRegion("/testRegion1");
- rf.createSubregion(r1, "testSubRegion1");
+ private void setupForReplicateRegionAttributes(final VM vm, final int offset) {
+ vm.invoke("setupForReplicateRegionAttributes", () -> {
+ Cache cache = getInternalCache();
- Region r2 = cache.getRegion("/testRegion2");
- rf.createSubregion(r2, "testSubRegion2");
+ RegionFactory regionFactory = cache.createRegionFactory(RegionShortcut.REPLICATE);
+ regionFactory.create("testRegion1");
+ regionFactory.create("testRegion2");
+ regionFactory.create("testRegion3");
- Region r3 = cache.getRegion("/testRegion3");
- rf.createSubregion(r3, "testSubRegion3");
+ Region region1 = cache.getRegion("/testRegion1");
+ regionFactory.createSubregion(region1, "testSubRegion1");
+ Region region2 = cache.getRegion("/testRegion2");
+ regionFactory.createSubregion(region2, "testSubRegion2");
- for (int i = offset; i < offset + 200; i++) {
- r1.put(new Integer(i), new Integer(i));
- r2.put(new Integer(i), new Integer(i));
- r3.put(new Integer(i), new Integer(i));
- }
+ Region region3 = cache.getRegion("/testRegion3");
+ regionFactory.createSubregion(region3, "testSubRegion3");
+ for (int i = offset; i < offset + 200; i++) {
+ region1.put(i, i);
+ region2.put(i, i);
+ region3.put(i, i);
}
});
-
}
- public void setupForPartitionedRegionAttributes(VM vm1, final int offset) {
- vm1.invoke(new SerializableRunnable("Create Cache") {
- public void run() {
- GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
- RegionFactory prRF = cache.createRegionFactory(RegionShortcut.PARTITION_REDUNDANT);
+ private void setupForPartitionedRegionAttributes(final VM vm, final int offset) {
+ vm.invoke("setupForPartitionedRegionAttributes", () -> {
+ Cache cache = getInternalCache();
+ RegionFactory regionFactory = cache.createRegionFactory(RegionShortcut.PARTITION_REDUNDANT);
- prRF.create("testPRRegion1");
- prRF.create("testPRRegion2");
- prRF.create("testPRRegion3");
-
- Region pr1 = cache.getRegion("/testPRRegion1");
- Region pr2 = cache.getRegion("/testPRRegion2");
- Region pr3 = cache.getRegion("/testPRRegion3");
-
- for (int i = offset; i < offset + 200; i++) {
- pr1.put(new Integer(i), new Integer(i));
- pr2.put(new Integer(i), new Integer(i));
- pr3.put(new Integer(i), new Integer(i));
- }
+ regionFactory.create("testPRRegion1");
+ regionFactory.create("testPRRegion2");
+ regionFactory.create("testPRRegion3");
+ Region region1 = cache.getRegion("/testPRRegion1");
+ Region region2 = cache.getRegion("/testPRRegion2");
+ Region region3 = cache.getRegion("/testPRRegion3");
+ for (int i = offset; i < offset + 200; i++) {
+ region1.put(i, i);
+ region2.put(i, i);
+ region3.put(i, i);
}
});
-
}
/**
* This will check all the attributes which does not depend on any distribution message.
- *
- * @param vm1
- * @throws Exception
*/
- @SuppressWarnings("serial")
- public void isPartitionedRegionAttrsOK(VM vm1) {
- vm1.invoke(new SerializableRunnable("Create Cache") {
- public void run() {
- MemberMXBean bean = managementService.getMemberMXBean();
- assertEquals(3, bean.getPartitionRegionCount());
- assertEquals(339, bean.getTotalBucketCount());
- assertEquals(339, bean.getTotalPrimaryBucketCount());
+ private void validatePartitionedRegionAttributes(final VM vm) {
+ vm.invoke("validatePartitionedRegionAttributes", () -> {
+ MemberMXBean memberMXBean = getSystemManagementService().getMemberMXBean();
- }
+ assertEquals(3, memberMXBean.getPartitionRegionCount());
+ assertEquals(339, memberMXBean.getTotalBucketCount());
+ assertEquals(339, memberMXBean.getTotalPrimaryBucketCount());
});
-
}
/**
* This will check all the attributes which does not depend on any distribution message.
- *
- * @param vm1
- * @throws Exception
*/
- @SuppressWarnings("serial")
- public void isReplicatedRegionAttrsOK(VM vm1) {
- vm1.invoke(new SerializableRunnable("Create Cache") {
- public void run() {
- MemberMXBean bean = managementService.getMemberMXBean();
-
- assertEquals(6, bean.getTotalRegionCount());
- assertEquals(1200, bean.getTotalRegionEntryCount());
-
- assertEquals(3, bean.getRootRegionNames().length);
- assertEquals(600, bean.getInitialImageKeysReceived());
- assertEquals(6, bean.listRegions().length);
- }
- });
+ private void validateReplicateRegionAttributes(final VM vm) {
+ vm.invoke("validateReplicateRegionAttributes", () -> {
+ MemberMXBean memberMXBean = getSystemManagementService().getMemberMXBean();
+ assertEquals(6, memberMXBean.getTotalRegionCount());
+ assertEquals(1200, memberMXBean.getTotalRegionEntryCount());
+
+ assertEquals(3, memberMXBean.getRootRegionNames().length);
+ assertEquals(600, memberMXBean.getInitialImageKeysReceived());
+ assertEquals(6, memberMXBean.listRegions().length);
+ });
}
/**
* This will check all the attributes which does not depend on any distribution message.
- *
- * @param vm1
- * @throws Exception
*/
- @SuppressWarnings("serial")
- public void isOSRelatedAttrsOK(VM vm1) {
- vm1.invoke(new SerializableRunnable("Create Cache") {
- public void run() {
- MemberMXBean bean = managementService.getMemberMXBean();
-
- try {
- assertEquals(ProcessUtils.identifyPid(), bean.getProcessId());
- } catch (PidUnavailableException e) {
- e.printStackTrace();
- }
- assertEquals(ManagementFactory.getRuntimeMXBean().getClassPath(), bean.getClassPath());
-
- assertTrue(bean.getCurrentTime() > 0);
- // Sleep for one second
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- assertTrue(bean.getMemberUpTime() > 0);
- assertTrue(bean.getCurrentHeapSize() > 10);
- assertTrue(bean.getFreeHeapSize() > 0);
- assertEquals(bean.getMaximumHeapSize(),
- ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getMax() / MBFactor);
-
- // @TODO Need more definitive test case
- assertTrue(bean.fetchJvmThreads().length > 0);
-
- // @TODO Need more definitive test case
- // System.out.println(" CPU Usage is "+ bean.getCpuUsage());
- // assertTrue(bean.getCpuUsage() > 0.0f);
-
- // bean.getFileDescriptorLimit()
- }
- });
+ private void validateSystemAndOSAttributes(final VM vm) {
+ vm.invoke("validateSystemAndOSAttributes", () -> {
+ MemberMXBean memberMXBean = getSystemManagementService().getMemberMXBean();
- }
+ assertThat(memberMXBean.getProcessId()).isEqualTo(ProcessUtils.identifyPid());
+ assertThat(memberMXBean.getClassPath()).isEqualTo(getClassPath());
+ assertThat(memberMXBean.getCurrentTime()).isGreaterThan(0);
- @SuppressWarnings("serial")
- public void isConfigRelatedAttrsOK(VM vm1) {
- vm1.invoke(new SerializableRunnable("Create Cache") {
- public void run() {
- MemberMXBean bean = managementService.getMemberMXBean();
+ await().until(() -> assertThat(memberMXBean.getMemberUpTime()).isGreaterThan(0));
- assertFalse(bean.hasGatewayReceiver());
- assertFalse(bean.hasGatewaySender());
- assertFalse(bean.isLocator());
- assertFalse(bean.isManager());
- assertFalse(bean.isServer());
- assertFalse(bean.isManagerCreated());
+ assertThat(memberMXBean.getUsedMemory()).isGreaterThan(10);
+ assertThat(memberMXBean.getCurrentHeapSize()).isGreaterThan(10);
+ assertThat(memberMXBean.getFreeMemory()).isGreaterThan(0);
+ assertThat(memberMXBean.getFreeHeapSize()).isGreaterThan(0);
- }
+ assertThat(memberMXBean.getMaxMemory()).isEqualTo(getHeapMemoryUsageMegabytes());
+ assertThat(memberMXBean.getMaximumHeapSize()).isEqualTo(getHeapMemoryUsageMegabytes());
+
+ assertThat(memberMXBean.fetchJvmThreads().length).isGreaterThan(0);
+
+ // TODO: provide better/more validation
+ // System.out.println(" CPU Usage is "+ bean.getCpuUsage());
+ // assertTrue(bean.getCpuUsage() > 0.0f);
+
+ // bean.getFileDescriptorLimit()
});
+ }
+
+ private void validateConfigAttributes(final VM vm) {
+ vm.invoke("validateConfigAttributes", () -> {
+ MemberMXBean memberMXBean = getSystemManagementService().getMemberMXBean();
+
+ assertFalse(memberMXBean.hasGatewayReceiver());
+ assertFalse(memberMXBean.hasGatewaySender());
+ assertFalse(memberMXBean.isLocator());
+ assertFalse(memberMXBean.isManager());
+ assertFalse(memberMXBean.isServer());
+ assertFalse(memberMXBean.isManagerCreated());
+ });
+ }
+
+ private String getClassPath() {
+ return ManagementFactory.getRuntimeMXBean().getClassPath();
+ }
+
+ private long getHeapMemoryUsageMegabytes() {
+ return ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getMax() / BYTES_PER_MEGABYTE;
+ }
+
+ private InternalDistributedSystem getInternalDistributedSystem() {
+ return InternalDistributedSystem.getConnectedInstance();
+ }
+ private InternalCache getInternalCache() {
+ return GemFireCacheImpl.getInstance();
}
}
diff --git a/geode-core/src/test/java/org/apache/geode/management/OffHeapManagementDUnitTest.java b/geode-core/src/test/java/org/apache/geode/management/OffHeapManagementDUnitTest.java
index 25fa3bb..a254f9a 100644
--- a/geode-core/src/test/java/org/apache/geode/management/OffHeapManagementDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/OffHeapManagementDUnitTest.java
@@ -14,10 +14,16 @@
*/
package org.apache.geode.management;
-import static org.awaitility.Awaitility.*;
-import static org.apache.geode.distributed.ConfigurationProperties.*;
-import static org.junit.Assert.*;
-
+import static java.util.concurrent.TimeUnit.MINUTES;
+import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER;
+import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_PORT;
+import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_START;
+import static org.apache.geode.distributed.ConfigurationProperties.OFF_HEAP_MEMORY_SIZE;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
+import static org.junit.Assert.fail;
+
+import java.lang.management.ManagementFactory;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
@@ -32,6 +38,10 @@ import javax.management.Notification;
import javax.management.NotificationListener;
import javax.management.ObjectName;
+import com.google.common.base.Stopwatch;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
@@ -39,15 +49,14 @@ import org.apache.geode.OutOfOffHeapMemoryException;
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.Region;
+import org.apache.geode.cache30.CacheTestCase;
import org.apache.geode.distributed.internal.InternalDistributedSystem;
import org.apache.geode.internal.offheap.OffHeapStorage;
import org.apache.geode.internal.offheap.OffHeapStoredObject;
import org.apache.geode.management.internal.MBeanJMXAdapter;
-import org.apache.geode.management.internal.beans.MemberMBean;
import org.apache.geode.test.dunit.Host;
-import org.apache.geode.test.dunit.SerializableRunnable;
import org.apache.geode.test.dunit.VM;
-import org.apache.geode.test.dunit.cache.internal.JUnit4CacheTestCase;
+import org.apache.geode.test.dunit.rules.DistributedRestoreSystemProperties;
import org.apache.geode.test.junit.categories.DistributedTest;
/**
@@ -55,7 +64,7 @@ import org.apache.geode.test.junit.categories.DistributedTest;
*/
@Category(DistributedTest.class)
@SuppressWarnings("serial")
-public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
+public class OffHeapManagementDUnitTest extends CacheTestCase {
/**
* Specified assertion operations.
@@ -77,7 +86,7 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Expected total off-heap reserved memory (1 megabyte).
*/
- private static final long TOTAL_MEMORY = 1048576;
+ private static final int TOTAL_MEMORY = 1048576;
/**
* Half of expected memory total.
@@ -135,20 +144,41 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Local MBeanServer.
*/
- private static MBeanServer mbeanServer = MBeanJMXAdapter.mbeanServer;
+ private static MBeanServer mbeanServer = ManagementFactory.getPlatformMBeanServer();
- @Override
- public final void postSetUp() throws Exception {
- Host.getHost(0).getVM(0).invoke(() -> {
+ private VM vm;
+
+ @Rule
+ public DistributedRestoreSystemProperties restoreSystemProperties =
+ new DistributedRestoreSystemProperties();
+
+ @Before
+ public void setUp() throws Exception {
+ vm = Host.getHost(0).getVM(0);
+
+ vm.invoke(() -> {
System.setProperty(OffHeapStorage.STAY_CONNECTED_ON_OUTOFOFFHEAPMEMORY_PROPERTY, "true");
});
}
+ @After
+ public void tearDown() throws Exception {
+ doCleanupOnVm(vm);
+ }
+
+ /**
+ * Returns off-heap system properties for enabling off-heap and the JMX system.
+ */
@Override
- public final void preTearDownCacheTestCase() throws Exception {
- Host.getHost(0).getVM(0).invoke(() -> {
- System.clearProperty(OffHeapStorage.STAY_CONNECTED_ON_OUTOFOFFHEAPMEMORY_PROPERTY);
- });
+ public Properties getDistributedSystemProperties() {
+ Properties config = new Properties();
+
+ config.setProperty(OFF_HEAP_MEMORY_SIZE, "1m");
+ config.setProperty(JMX_MANAGER, "true");
+ config.setProperty(JMX_MANAGER_START, "true");
+ config.setProperty(JMX_MANAGER_PORT, "0");
+
+ return config;
}
/**
@@ -156,47 +186,39 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
*/
@Test
public void testOffHeapMBeanAttributesAndStats() throws Exception {
- final VM vm = Host.getHost(0).getVM(0);
-
- try {
- // Setup off-heap memory for cache
- setSystemPropertiesOnVm(vm, true, getSystemProperties());
+ // Setup off-heap memory for cache
+ setSystemPropertiesOnVm(vm, true, getDistributedSystemProperties());
- // Create our off-heap region
- assertNotNull(createOffHeapRegionOnVm(vm, OFF_HEAP_REGION_NAME, DataPolicy.REPLICATE));
+ // Create our off-heap region
+ assertThat(createOffHeapRegionOnVm(vm, OFF_HEAP_REGION_NAME, DataPolicy.REPLICATE)).isNotNull();
- // Make sure our off-heap region has off-heap enabled.
- assertOffHeapRegionAttributesOnVm(vm);
+ // Make sure our off-heap region has off-heap enabled.
+ assertOffHeapRegionAttributesOnVm(vm);
- // Make sure our starting off heap stats are correct
- assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
+ // Make sure our starting off heap stats are correct
+ assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
- /*
- * Perform ops on the off-heap region and assert that the off-heap metrics correctly reflect
- * the ops
- */
- {
- doPutOnVm(vm, KEY, VALUE, OFF_HEAP_REGION_NAME, false);
- assertOffHeapMetricsOnVm(vm, (TOTAL_MEMORY - OBJECT_SIZE), OBJECT_SIZE, 1, 0);
+ /*
+ * Perform ops on the off-heap region and assert that the off-heap metrics correctly reflect the
+ * ops
+ */
+ doPutOnVm(vm, KEY, VALUE, OFF_HEAP_REGION_NAME, false);
+ assertOffHeapMetricsOnVm(vm, (TOTAL_MEMORY - OBJECT_SIZE), OBJECT_SIZE, 1, 0);
- doPutOnVm(vm, KEY2, VALUE, OFF_HEAP_REGION_NAME, false);
- assertOffHeapMetricsOnVm(vm, (TOTAL_MEMORY - (2 * OBJECT_SIZE)), (2 * OBJECT_SIZE), 2, 0);
+ doPutOnVm(vm, KEY2, VALUE, OFF_HEAP_REGION_NAME, false);
+ assertOffHeapMetricsOnVm(vm, (TOTAL_MEMORY - (2 * OBJECT_SIZE)), (2 * OBJECT_SIZE), 2, 0);
- doPutOnVm(vm, KEY3, VALUE, OFF_HEAP_REGION_NAME, false);
- assertOffHeapMetricsOnVm(vm, (TOTAL_MEMORY - (3 * OBJECT_SIZE)), (3 * OBJECT_SIZE), 3, 0);
+ doPutOnVm(vm, KEY3, VALUE, OFF_HEAP_REGION_NAME, false);
+ assertOffHeapMetricsOnVm(vm, (TOTAL_MEMORY - (3 * OBJECT_SIZE)), (3 * OBJECT_SIZE), 3, 0);
- doDestroyOnVm(vm, KEY3, OFF_HEAP_REGION_NAME);
- assertOffHeapMetricsOnVm(vm, (TOTAL_MEMORY - (2 * OBJECT_SIZE)), (2 * OBJECT_SIZE), 2, 0);
+ doDestroyOnVm(vm, KEY3, OFF_HEAP_REGION_NAME);
+ assertOffHeapMetricsOnVm(vm, (TOTAL_MEMORY - (2 * OBJECT_SIZE)), (2 * OBJECT_SIZE), 2, 0);
- doDestroyOnVm(vm, KEY2, OFF_HEAP_REGION_NAME);
- assertOffHeapMetricsOnVm(vm, (TOTAL_MEMORY - OBJECT_SIZE), OBJECT_SIZE, 1, 0);
+ doDestroyOnVm(vm, KEY2, OFF_HEAP_REGION_NAME);
+ assertOffHeapMetricsOnVm(vm, (TOTAL_MEMORY - OBJECT_SIZE), OBJECT_SIZE, 1, 0);
- doDestroyOnVm(vm, KEY, OFF_HEAP_REGION_NAME);
- assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
- }
- } finally {
- doCleanupOnVm(vm);
- }
+ doDestroyOnVm(vm, KEY, OFF_HEAP_REGION_NAME);
+ assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
}
/**
@@ -204,89 +226,78 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
*/
@Test
public void testFragmentationStat() throws Exception {
- final VM vm = Host.getHost(0).getVM(0);
+ // Setup off-heap memory for cache
+ setSystemPropertiesOnVm(vm, true, getDistributedSystemProperties());
- try {
- // Setup off-heap memory for cache
- setSystemPropertiesOnVm(vm, true, getSystemProperties());
-
- // Create our off-heap region
- assertNotNull(createOffHeapRegionOnVm(vm, OFF_HEAP_REGION_NAME, DataPolicy.REPLICATE));
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- Region region = getCache().getRegion(OFF_HEAP_REGION_NAME);
- assertNotNull(region);
- }
- });
-
- // Make sure our off-heap region has off-heap enabled.
- assertOffHeapRegionAttributesOnVm(vm);
-
- // Make sure our starting off heap stats are correct
- assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
-
- // After allocating large chunk (equal to total memory)
- // we should still have no fragmentation
- int largeChunk = (int) TOTAL_MEMORY - OffHeapStoredObject.HEADER_SIZE;
- doPutOnVm(vm, KEY, new byte[largeChunk], OFF_HEAP_REGION_NAME, false);
- // No compaction has run, so fragmentation should be zero
- assertFragmentationStatOnVm(vm, 0, ASSERT_OP.EQUAL);
-
- // Allocate more memory to trigger compaction
- doPutOnVm(vm, KEY, new byte[ALLOCATION_SIZE], OFF_HEAP_REGION_NAME, true);
- // When total memory is used no fragmentation
- assertFragmentationStatOnVm(vm, 0, ASSERT_OP.EQUAL);
-
- // After freeing all memory we should have no fragmentation
- doDestroyOnVm(vm, KEY, OFF_HEAP_REGION_NAME);
- assertFragmentationStatOnVm(vm, 0, ASSERT_OP.EQUAL);
-
- // Allocate HALF_TOTAL_MEMORY twice and release one to create one fragment
- int halfChunk = HALF_TOTAL_MEMORY - OffHeapStoredObject.HEADER_SIZE;
- doPutOnVm(vm, KEY + "0", new byte[halfChunk], OFF_HEAP_REGION_NAME, false);
- doPutOnVm(vm, KEY + "1", new byte[halfChunk], OFF_HEAP_REGION_NAME, false);
- doDestroyOnVm(vm, KEY + "0", OFF_HEAP_REGION_NAME);
-
- // Allocate largeChunk to trigger compaction and fragmentation should be zero
- // as all free memory is available as one fragment
- doPutOnVm(vm, KEY + "1", new byte[largeChunk], OFF_HEAP_REGION_NAME, true);
- assertFragmentationStatOnVm(vm, 0, ASSERT_OP.EQUAL);
-
- // Consume the available fragment as below
- // [16][262120][16][262120][16] = [524288] (HALF_TOTAL_MEMORY)
- int smallChunk = OffHeapStoredObject.MIN_CHUNK_SIZE - OffHeapStoredObject.HEADER_SIZE;
- int mediumChunk = 262112; // (262120 - ObjectChunk.OFF_HEAP_HEADER_SIZE)
- doPutOnVm(vm, KEY + "S1", new byte[smallChunk], OFF_HEAP_REGION_NAME, false);
- doPutOnVm(vm, KEY + "M1", new byte[mediumChunk], OFF_HEAP_REGION_NAME, false);
- doPutOnVm(vm, KEY + "S2", new byte[smallChunk], OFF_HEAP_REGION_NAME, false);
- doPutOnVm(vm, KEY + "M2", new byte[mediumChunk], OFF_HEAP_REGION_NAME, false);
- doPutOnVm(vm, KEY + "S3", new byte[smallChunk], OFF_HEAP_REGION_NAME, false);
-
- // free small chunks to create gaps
- doDestroyOnVm(vm, KEY + "S1", OFF_HEAP_REGION_NAME);
- doDestroyOnVm(vm, KEY + "S2", OFF_HEAP_REGION_NAME);
- doDestroyOnVm(vm, KEY + "S3", OFF_HEAP_REGION_NAME);
-
- // Now free memory should be 48 so allocate a 40 byte object
- doPutOnVm(vm, KEY + "newKey", new byte[40], OFF_HEAP_REGION_NAME, true);
-
- /*
- * Setup a fragmentation attribute monitor
- */
- {
- setupOffHeapMonitorOnVm(vm, "OffHeapFragmentation", 0, 0);
- clearNotificationListenerOnVm(vm);
- }
+ // Create our off-heap region
+ assertThat(createOffHeapRegionOnVm(vm, OFF_HEAP_REGION_NAME, DataPolicy.REPLICATE)).isNotNull();
+ vm.invoke(() -> {
+ Region region = getCache().getRegion(OFF_HEAP_REGION_NAME);
+ assertThat(region).isNotNull();
+ });
- // Make sure we have some fragmentation
- assertFragmentationStatOnVm(vm, 100, ASSERT_OP.EQUAL);
+ // Make sure our off-heap region has off-heap enabled.
+ assertOffHeapRegionAttributesOnVm(vm);
- // Make sure our fragmentation monitor was triggered
- waitForNotificationListenerOnVm(vm, 5000, 500, true);
- } finally {
- doCleanupOnVm(vm);
- }
+ // Make sure our starting off heap stats are correct
+ assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
+
+ // After allocating large chunk (equal to total memory)
+ // we should still have no fragmentation
+ int largeChunk = (int) TOTAL_MEMORY - OffHeapStoredObject.HEADER_SIZE;
+ doPutOnVm(vm, KEY, new byte[largeChunk], OFF_HEAP_REGION_NAME, false);
+ // No compaction has run, so fragmentation should be zero
+ assertFragmentationStatOnVm(vm, 0, ASSERT_OP.EQUAL);
+
+ // Allocate more memory to trigger compaction
+ doPutOnVm(vm, KEY, new byte[ALLOCATION_SIZE], OFF_HEAP_REGION_NAME, true);
+ // When total memory is used no fragmentation
+ assertFragmentationStatOnVm(vm, 0, ASSERT_OP.EQUAL);
+
+ // After freeing all memory we should have no fragmentation
+ doDestroyOnVm(vm, KEY, OFF_HEAP_REGION_NAME);
+ assertFragmentationStatOnVm(vm, 0, ASSERT_OP.EQUAL);
+
+ // Allocate HALF_TOTAL_MEMORY twice and release one to create one fragment
+ int halfChunk = HALF_TOTAL_MEMORY - OffHeapStoredObject.HEADER_SIZE;
+ doPutOnVm(vm, KEY + "0", new byte[halfChunk], OFF_HEAP_REGION_NAME, false);
+ doPutOnVm(vm, KEY + "1", new byte[halfChunk], OFF_HEAP_REGION_NAME, false);
+ doDestroyOnVm(vm, KEY + "0", OFF_HEAP_REGION_NAME);
+
+ // Allocate largeChunk to trigger compaction and fragmentation should be zero
+ // as all free memory is available as one fragment
+ doPutOnVm(vm, KEY + "1", new byte[largeChunk], OFF_HEAP_REGION_NAME, true);
+ assertFragmentationStatOnVm(vm, 0, ASSERT_OP.EQUAL);
+
+ // Consume the available fragment as below
+ // [16][262120][16][262120][16] = [524288] (HALF_TOTAL_MEMORY)
+ int smallChunk = OffHeapStoredObject.MIN_CHUNK_SIZE - OffHeapStoredObject.HEADER_SIZE;
+ int mediumChunk = 262112; // (262120 - ObjectChunk.OFF_HEAP_HEADER_SIZE)
+ doPutOnVm(vm, KEY + "S1", new byte[smallChunk], OFF_HEAP_REGION_NAME, false);
+ doPutOnVm(vm, KEY + "M1", new byte[mediumChunk], OFF_HEAP_REGION_NAME, false);
+ doPutOnVm(vm, KEY + "S2", new byte[smallChunk], OFF_HEAP_REGION_NAME, false);
+ doPutOnVm(vm, KEY + "M2", new byte[mediumChunk], OFF_HEAP_REGION_NAME, false);
+ doPutOnVm(vm, KEY + "S3", new byte[smallChunk], OFF_HEAP_REGION_NAME, false);
+
+ // free small chunks to create gaps
+ doDestroyOnVm(vm, KEY + "S1", OFF_HEAP_REGION_NAME);
+ doDestroyOnVm(vm, KEY + "S2", OFF_HEAP_REGION_NAME);
+ doDestroyOnVm(vm, KEY + "S3", OFF_HEAP_REGION_NAME);
+
+ // Now free memory should be 48 so allocate a 40 byte object
+ doPutOnVm(vm, KEY + "newKey", new byte[40], OFF_HEAP_REGION_NAME, true);
+
+ /*
+ * Setup a fragmentation attribute monitor
+ */
+ setupOffHeapMonitorOnVm(vm, "OffHeapFragmentation", 0, 0);
+ clearNotificationListenerOnVm(vm);
+
+ // Make sure we have some fragmentation
+ assertFragmentationStatOnVm(vm, 100, ASSERT_OP.EQUAL);
+
+ // Make sure our fragmentation monitor was triggered
+ waitForNotificationListenerOnVm(vm, 5000);
}
/**
@@ -294,58 +305,50 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
*/
@Test
public void testCompactionTimeStat() throws Exception {
- final VM vm = Host.getHost(0).getVM(0);
+ // Setup off-heap memory for cache
+ setSystemPropertiesOnVm(vm, true, getDistributedSystemProperties());
- try {
- // Setup off-heap memory for cache
- setSystemPropertiesOnVm(vm, true, getSystemProperties());
+ // Create our off-heap region
+ assertThat(createOffHeapRegionOnVm(vm, OFF_HEAP_REGION_NAME, DataPolicy.REPLICATE)).isNotNull();
- // Create our off-heap region
- assertNotNull(createOffHeapRegionOnVm(vm, OFF_HEAP_REGION_NAME, DataPolicy.REPLICATE));
+ // Make sure our off-heap region has off-heap enabled.
+ assertOffHeapRegionAttributesOnVm(vm);
- // Make sure our off-heap region has off-heap enabled.
- assertOffHeapRegionAttributesOnVm(vm);
+ // Make sure our starting off heap stats are correct
+ assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
- // Make sure our starting off heap stats are correct
- assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
+ // After allocating large chunck we should still have no compaction time
+ doPutOnVm(vm, KEY, new byte[HALF_TOTAL_MEMORY], OFF_HEAP_REGION_NAME, false);
+ assertCompactionTimeStatOnVm(vm, 0, ASSERT_OP.EQUAL);
- // After allocating large chunck we should still have no compaction time
- doPutOnVm(vm, KEY, new byte[HALF_TOTAL_MEMORY], OFF_HEAP_REGION_NAME, false);
- assertCompactionTimeStatOnVm(vm, 0, ASSERT_OP.EQUAL);
+ // After freeing all memory we should have no compaction time
+ doDestroyOnVm(vm, KEY, OFF_HEAP_REGION_NAME);
+ assertCompactionTimeStatOnVm(vm, 0, ASSERT_OP.EQUAL);
- // After freeing all memory we should have no compaction time
- doDestroyOnVm(vm, KEY, OFF_HEAP_REGION_NAME);
- assertCompactionTimeStatOnVm(vm, 0, ASSERT_OP.EQUAL);
+ // Consume all off-heap memory using an allocation size
+ int numAllocations = doConsumeOffHeapMemoryOnVm(vm, ALLOCATION_SIZE);
+ assertThat(numAllocations > 0).isTrue();
- // Consume all off-heap memory using an allocation size
- int numAllocations = doConsumeOffHeapMemoryOnVm(vm, ALLOCATION_SIZE);
- assertTrue(numAllocations > 0);
+ // Randomly free 3 allocations to produce off-heap gaps
+ doFreeOffHeapMemoryOnVm(vm, numAllocations, 3);
- // Randomly free 3 allocations to produce off-heap gaps
- doFreeOffHeapMemoryOnVm(vm, numAllocations, 3);
+ /*
+ * Setup a compaction time attribute monitor
+ */
+ setupOffHeapMonitorOnVm(vm, "OffHeapCompactionTime", 0, 0);
+ clearNotificationListenerOnVm(vm);
- /*
- * Setup a compaction time attribute monitor
- */
- {
- setupOffHeapMonitorOnVm(vm, "OffHeapCompactionTime", 0, 0);
- clearNotificationListenerOnVm(vm);
- }
+ // Allocate enough memory to force compaction which will update compaction time stat
+ doPutOnVm(vm, KEY, new byte[NEW_ALLOCATION_SIZE], OFF_HEAP_REGION_NAME, true);
- // Allocate enough memory to force compaction which will update compaction time stat
- doPutOnVm(vm, KEY, new byte[NEW_ALLOCATION_SIZE], OFF_HEAP_REGION_NAME, true);
+ // Make sure our compaction time monitor was triggered
+ waitForNotificationListenerOnVm(vm, 5000);
- // Make sure our compaction time monitor was triggered
- waitForNotificationListenerOnVm(vm, 5000, 500, true);
-
- /*
- * Make sure we have some compaction time. In some environments the compaction time is
- * reported as 0 due to time sample granularity and compaction speed.
- */
- assertCompactionTimeStatOnVm(vm, 0, ASSERT_OP.GREATER_THAN_OR_EQUAL);
- } finally {
- doCleanupOnVm(vm);
- }
+ /*
+ * Make sure we have some compaction time. In some environments the compaction time is reported
+ * as 0 due to time sample granularity and compaction speed.
+ */
+ assertCompactionTimeStatOnVm(vm, 0, ASSERT_OP.GREATER_THAN_OR_EQUAL);
}
/**
@@ -353,37 +356,28 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
*/
@Test
public void testOffHeapObjectsMonitoring() throws Exception {
- final VM vm = Host.getHost(0).getVM(0);
-
- try {
- // Setup off-heap memory for cache
- setSystemPropertiesOnVm(vm, true, getSystemProperties());
+ // Setup off-heap memory for cache
+ setSystemPropertiesOnVm(vm, true, getDistributedSystemProperties());
- // Create our off-heap region
- assertNotNull(createOffHeapRegionOnVm(vm, OFF_HEAP_REGION_NAME, DataPolicy.REPLICATE));
+ // Create our off-heap region
+ assertThat(createOffHeapRegionOnVm(vm, OFF_HEAP_REGION_NAME, DataPolicy.REPLICATE)).isNotNull();
- // Make sure our off-heap region has off-heap enabled.
- assertOffHeapRegionAttributesOnVm(vm);
+ // Make sure our off-heap region has off-heap enabled.
+ assertOffHeapRegionAttributesOnVm(vm);
- // Make sure our starting off heap stats are correct
- assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
+ // Make sure our starting off heap stats are correct
+ assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
- /*
- * Tests off-heap objects notification
- */
- {
- setupOffHeapMonitorOnVm(vm, "OffHeapObjects", 0, -1);
+ /*
+ * Tests off-heap objects notification
+ */
+ setupOffHeapMonitorOnVm(vm, "OffHeapObjects", 0, -1);
- clearNotificationListenerOnVm(vm);
+ clearNotificationListenerOnVm(vm);
- doPutOnVm(vm, KEY, VALUE, OFF_HEAP_REGION_NAME, false);
+ doPutOnVm(vm, KEY, VALUE, OFF_HEAP_REGION_NAME, false);
- waitForNotificationListenerOnVm(vm, 5000, 500, true);
- }
-
- } finally {
- doCleanupOnVm(vm);
- }
+ waitForNotificationListenerOnVm(vm, 5000);
}
/**
@@ -391,37 +385,28 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
*/
@Test
public void testOffHeapFreeSizeMonitoring() throws Exception {
- final VM vm = Host.getHost(0).getVM(0);
-
- try {
- // Setup off-heap memory for cache
- setSystemPropertiesOnVm(vm, true, getSystemProperties());
+ // Setup off-heap memory for cache
+ setSystemPropertiesOnVm(vm, true, getDistributedSystemProperties());
- // Create our off-heap region
- assertNotNull(createOffHeapRegionOnVm(vm, OFF_HEAP_REGION_NAME, DataPolicy.REPLICATE));
+ // Create our off-heap region
+ assertThat(createOffHeapRegionOnVm(vm, OFF_HEAP_REGION_NAME, DataPolicy.REPLICATE)).isNotNull();
- // Make sure our off-heap region has off-heap enabled.
- assertOffHeapRegionAttributesOnVm(vm);
+ // Make sure our off-heap region has off-heap enabled.
+ assertOffHeapRegionAttributesOnVm(vm);
- // Make sure our starting off heap stats are correct
- assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
+ // Make sure our starting off heap stats are correct
+ assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
- /*
- * Tests off-heap objects notification
- */
- {
- setupOffHeapMonitorOnVm(vm, "OffHeapFreeSize", TOTAL_MEMORY, TOTAL_MEMORY);
+ /*
+ * Tests off-heap objects notification
+ */
+ setupOffHeapMonitorOnVm(vm, "OffHeapFreeSize", TOTAL_MEMORY, TOTAL_MEMORY);
- clearNotificationListenerOnVm(vm);
+ clearNotificationListenerOnVm(vm);
- doPutOnVm(vm, KEY, VALUE, OFF_HEAP_REGION_NAME, false);
+ doPutOnVm(vm, KEY, VALUE, OFF_HEAP_REGION_NAME, false);
- waitForNotificationListenerOnVm(vm, 5000, 500, true);
- }
-
- } finally {
- doCleanupOnVm(vm);
- }
+ waitForNotificationListenerOnVm(vm, 5000);
}
/**
@@ -429,37 +414,28 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
*/
@Test
public void testOffHeapAllocatedSizeMonitoring() throws Exception {
- final VM vm = Host.getHost(0).getVM(0);
-
- try {
- // Setup off-heap memory for cache
- setSystemPropertiesOnVm(vm, true, getSystemProperties());
+ // Setup off-heap memory for cache
+ setSystemPropertiesOnVm(vm, true, getDistributedSystemProperties());
- // Create our off-heap region
- assertNotNull(createOffHeapRegionOnVm(vm, OFF_HEAP_REGION_NAME, DataPolicy.REPLICATE));
+ // Create our off-heap region
+ assertThat(createOffHeapRegionOnVm(vm, OFF_HEAP_REGION_NAME, DataPolicy.REPLICATE)).isNotNull();
- // Make sure our off-heap region has off-heap enabled.
- assertOffHeapRegionAttributesOnVm(vm);
+ // Make sure our off-heap region has off-heap enabled.
+ assertOffHeapRegionAttributesOnVm(vm);
- // Make sure our starting off heap stats are correct
- assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
+ // Make sure our starting off heap stats are correct
+ assertOffHeapMetricsOnVm(vm, TOTAL_MEMORY, 0, 0, 0);
- /*
- * Tests off-heap objects notification
- */
- {
- setupOffHeapMonitorOnVm(vm, "OffHeapAllocatedSize", 0, OBJECT_SIZE);
+ /*
+ * Tests off-heap objects notification
+ */
+ setupOffHeapMonitorOnVm(vm, "OffHeapAllocatedSize", 0, OBJECT_SIZE);
- clearNotificationListenerOnVm(vm);
+ clearNotificationListenerOnVm(vm);
- doPutOnVm(vm, KEY, VALUE, OFF_HEAP_REGION_NAME, false);
+ doPutOnVm(vm, KEY, VALUE, OFF_HEAP_REGION_NAME, false);
- waitForNotificationListenerOnVm(vm, 5000, 500, true);
- }
-
- } finally {
- doCleanupOnVm(vm);
- }
+ waitForNotificationListenerOnVm(vm, 5000);
}
/**
@@ -471,11 +447,8 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
*/
private void doFreeOffHeapMemoryOnVm(final VM vm, final int numAllocations,
final int numDestroys) {
- vm.invoke(new SerializableRunnable() {
- @Override
- public void run() {
- doFreeOffHeapMemory(numAllocations, numDestroys);
- }
+ vm.invoke(() -> {
+ doFreeOffHeapMemory(numAllocations, numDestroys);
});
}
@@ -486,11 +459,11 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
* @param numDestroys the number of destroys to perform
*/
private void doFreeOffHeapMemory(final int numAllocations, final int numDestroys) {
- assertTrue(numDestroys <= numAllocations);
+ assertThat(numDestroys <= numAllocations).isTrue();
Region region = getCache().getRegion(OFF_HEAP_REGION_NAME);
- assertNotNull(region);
- assertTrue(numDestroys <= region.size());
+ assertThat(region).isNotNull();
+ assertThat(numDestroys <= region.size()).isTrue();
String key = "KEY0";
Object value = key;
@@ -531,7 +504,8 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
// Loop until we fail
try {
- while (true) { // TODO: put a time limit on this just in case
+ Stopwatch stopwatch = Stopwatch.createStarted();
+ while (stopwatch.elapsed(MINUTES) < 2) {
doPut("KEY" + (i++), new byte[allocationSize], OFF_HEAP_REGION_NAME, false);
}
} catch (OutOfOffHeapMemoryException e) {
@@ -560,25 +534,25 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
*/
private void assertCompactionTimeStat(final long compactionTime, final ASSERT_OP op) {
ManagementService service = ManagementService.getExistingManagementService(getCache());
- assertNotNull(service);
+ assertThat(service).isNotNull();
- assertTrue(service.isManager());
+ assertThat(service.isManager()).isTrue();
MemberMXBean memberBean = service.getMemberMXBean();
- assertNotNull(memberBean);
+ assertThat(memberBean).isNotNull();
switch (op) {
case EQUAL:
- assertEquals(compactionTime, memberBean.getOffHeapCompactionTime());
+ assertThat(memberBean.getOffHeapCompactionTime()).isEqualTo(compactionTime);
break;
case GREATER_THAN:
- assertTrue(compactionTime < memberBean.getOffHeapCompactionTime());
+ assertThat(compactionTime < memberBean.getOffHeapCompactionTime()).isTrue();
break;
case GREATER_THAN_OR_EQUAL:
- assertTrue(compactionTime <= memberBean.getOffHeapCompactionTime());
+ assertThat(compactionTime <= memberBean.getOffHeapCompactionTime()).isTrue();
break;
case LESS_THAN:
- assertTrue(compactionTime > memberBean.getOffHeapCompactionTime());
+ assertThat(compactionTime > memberBean.getOffHeapCompactionTime()).isTrue();
break;
}
}
@@ -603,41 +577,27 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
*/
private void assertFragmentationStat(final int fragmentation, final ASSERT_OP op) {
ManagementService service = ManagementService.getExistingManagementService(getCache());
- assertNotNull(service);
+ assertThat(service).isNotNull();
- assertTrue(service.isManager());
+ assertThat(service.isManager()).isTrue();
MemberMXBean memberBean = service.getMemberMXBean();
- assertNotNull(memberBean);
+ assertThat(memberBean).isNotNull();
switch (op) {
case EQUAL:
- assertEquals(fragmentation, memberBean.getOffHeapFragmentation());
+ assertThat(memberBean.getOffHeapFragmentation()).isEqualTo(fragmentation);
break;
case GREATER_THAN:
- assertTrue(fragmentation < memberBean.getOffHeapFragmentation());
+ assertThat(fragmentation < memberBean.getOffHeapFragmentation()).isTrue();
break;
case LESS_THAN:
- assertTrue(fragmentation > memberBean.getOffHeapFragmentation());
+ assertThat(fragmentation > memberBean.getOffHeapFragmentation()).isTrue();
break;
}
}
/**
- * Returns off-heap system properties for enabling off-heap and the JMX system.
- */
- private Properties getSystemProperties() {
- Properties props = getDistributedSystemProperties();
-
- props.setProperty(OFF_HEAP_MEMORY_SIZE, "1m");
- props.setProperty(JMX_MANAGER, "true");
- props.setProperty(JMX_MANAGER_START, "true");
- props.setProperty(JMX_MANAGER_PORT, "0");
-
- return props;
- }
-
- /**
* Removes off heap region on vm and disconnects.
*
* @param vm a virtual machine.
@@ -675,17 +635,17 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
*/
private void assertOffHeapRegionAttributes() {
ManagementService service = ManagementService.getExistingManagementService(getCache());
- assertNotNull(service);
+ assertThat(service).isNotNull();
- assertTrue(service.isManager());
+ assertThat(service.isManager()).isTrue();
RegionMXBean regionBean = service.getLocalRegionMBean(OFF_HEAP_REGION_PATH);
- assertNotNull(regionBean);
+ assertThat(regionBean).isNotNull();
RegionAttributesData regionData = regionBean.listRegionAttributes();
- assertNotNull(regionData);
+ assertThat(regionData).isNotNull();
- assertTrue(regionData.getOffHeap());
+ assertThat(regionData.getOffHeap()).isTrue();
}
/**
@@ -697,8 +657,8 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
* @param objects number of objects stored in off-heap memory.
* @param fragmentation the fragmentation percentage.
*/
- private void assertOffHeapMetricsOnVm(final VM vm, final long freeMemory,
- final long allocatedMemory, final long objects, final int fragmentation) {
+ private void assertOffHeapMetricsOnVm(final VM vm, final int freeMemory,
+ final int allocatedMemory, final int objects, final int fragmentation) {
vm.invoke(() -> assertOffHeapMetrics(freeMemory, allocatedMemory, objects, fragmentation));
}
@@ -710,20 +670,20 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
* @param objects number of objects stored in off-heap memory.
* @param fragmentation the fragmentation percentage.
*/
- private void assertOffHeapMetrics(final long freeMemory, final long allocatedMemory,
- final long objects, final int fragmentation) {
+ private void assertOffHeapMetrics(final int freeMemory, final int allocatedMemory,
+ final int objects, final int fragmentation) {
ManagementService service = ManagementService.getExistingManagementService(getCache());
- assertNotNull(service);
+ assertThat(service).isNotNull();
- assertTrue(service.isManager());
+ assertThat(service.isManager()).isTrue();
MemberMXBean memberBean = service.getMemberMXBean();
- assertNotNull(memberBean);
+ assertThat(memberBean).isNotNull();
- assertEquals(freeMemory, memberBean.getOffHeapFreeMemory());
- assertEquals(allocatedMemory, memberBean.getOffHeapUsedMemory());
- assertEquals(objects, memberBean.getOffHeapObjects());
- assertEquals(fragmentation, memberBean.getOffHeapFragmentation());
+ assertThat(memberBean.getOffHeapFreeMemory()).isEqualTo(freeMemory);
+ assertThat(memberBean.getOffHeapUsedMemory()).isEqualTo(allocatedMemory);
+ assertThat(memberBean.getOffHeapObjects()).isEqualTo(objects);
+ assertThat(memberBean.getOffHeapFragmentation()).isEqualTo(fragmentation);
}
/**
@@ -800,7 +760,7 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
*/
private void doDestroy(final Object key, final String regionName) {
Region region = getCache().getRegion(regionName);
- assertNotNull(region);
+ assertThat(region).isNotNull();
region.destroy(key);
}
@@ -828,7 +788,7 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
private void doPut(final Object key, final Object value, final String regionName,
final boolean expectException) {
Region region = getCache().getRegion(regionName);
- assertNotNull(region);
+ assertThat(region).isNotNull();
try {
region.put(key, value);
@@ -843,32 +803,6 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
}
/**
- * Adds an off-heap notification listener to the MemberMXBean for a vm.
- *
- * @param vm a virtual machine.
- */
- private void addOffHeapNotificationListenerOnVm(final VM vm) {
- vm.invoke(() -> addOffHeapNotificationListener());
- }
-
- /**
- * Adds an off-heap notification listener to the MemberMXBean.
- */
- private void addOffHeapNotificationListener() {
- ManagementService service = ManagementService.getExistingManagementService(getCache());
- assertNotNull(service);
-
- assertTrue(service.isManager());
-
- MemberMXBean memberBean = service.getMemberMXBean();
- assertNotNull(memberBean);
-
- assertTrue(memberBean instanceof MemberMBean);
-
- ((MemberMBean) memberBean).addNotificationListener(notificationListener, null, null);
- }
-
- /**
* Creates and adds a generic GaugeMonitor for an attribute of the MemberMXBean on a VM.
*
* @param vm a virtual machine.
@@ -876,8 +810,8 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
* @param highThreshold the high threshold trigger.
* @param lowThreshold the low threshold trigger.
*/
- private void setupOffHeapMonitorOnVm(final VM vm, final String attribute,
- final long highThreshold, final long lowThreshold) {
+ private void setupOffHeapMonitorOnVm(final VM vm, final String attribute, final int highThreshold,
+ final int lowThreshold) {
vm.invoke(() -> setupOffHeapMonitor(attribute, highThreshold, lowThreshold));
}
@@ -888,11 +822,11 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
* @param highThreshold the high threshold trigger.
* @param lowThreshold the low threshold trigger.
*/
- private void setupOffHeapMonitor(final String attribute, final long highThreshold,
- final long lowThreshold) throws JMException {
+ private void setupOffHeapMonitor(final String attribute, final int highThreshold,
+ final int lowThreshold) throws JMException {
ObjectName memberMBeanObjectName = MBeanJMXAdapter.getMemberMBeanName(
InternalDistributedSystem.getConnectedInstance().getDistributedMember());
- assertNotNull(memberMBeanObjectName);
+ assertThat(memberMBeanObjectName).isNotNull();
ObjectName offHeapMonitorName = new ObjectName("monitors:type=Gauge,attr=" + attribute);
mbeanServer.createMBean("javax.management.monitor.GaugeMonitor", offHeapMonitorName);
@@ -914,16 +848,13 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
/**
* Waits to receive MBean notifications.
- *
+ *
* @param vm a virtual machine.
* @param wait how long to wait for in millis.
- * @param interval the polling interval to check for notifications.
- * @param throwOnTimeout throws an exception on timeout if true.
*/
- private void waitForNotificationListenerOnVm(final VM vm, final long wait, final long interval,
- final boolean throwOnTimeout) {
+ private void waitForNotificationListenerOnVm(final VM vm, final long wait) {
vm.invoke(() -> await("Awaiting Notification Listener").atMost(wait, TimeUnit.MILLISECONDS)
- .until(() -> assertTrue(notificationListener.getNotificationSize() > 0)));
+ .until(() -> assertThat(notificationListener.getNotificationSize() > 0).isTrue()));
}
/**
@@ -940,20 +871,20 @@ public class OffHeapManagementDUnitTest extends JUnit4CacheTestCase {
*/
private static class OffHeapNotificationListener implements NotificationListener {
- List<Notification> notificationList =
+ private List<Notification> notificationList =
Collections.synchronizedList(new ArrayList<Notification>());
@Override
public void handleNotification(final Notification notification, final Object handback) {
- this.notificationList.add(notification);
+ notificationList.add(notification);
}
- public void clear() {
- this.notificationList.clear();
+ void clear() {
+ notificationList.clear();
}
- public int getNotificationSize() {
- return this.notificationList.size();
+ int getNotificationSize() {
+ return notificationList.size();
}
}
}
diff --git a/geode-core/src/test/java/org/apache/geode/management/QueryDataDUnitTest.java b/geode-core/src/test/java/org/apache/geode/management/QueryDataDUnitTest.java
index 131d2fc..4a6aafe 100644
--- a/geode-core/src/test/java/org/apache/geode/management/QueryDataDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/QueryDataDUnitTest.java
@@ -14,14 +14,20 @@
*/
package org.apache.geode.management;
-import static com.jayway.jsonpath.matchers.JsonPathMatchers.*;
-import static java.util.concurrent.TimeUnit.*;
-import static org.apache.geode.cache.FixedPartitionAttributes.*;
-import static org.apache.geode.cache.query.Utils.*;
-import static org.apache.geode.management.internal.ManagementConstants.*;
-import static org.apache.geode.management.internal.ManagementStrings.*;
+import static com.jayway.jsonpath.matchers.JsonPathMatchers.hasJsonPath;
+import static com.jayway.jsonpath.matchers.JsonPathMatchers.isJson;
+import static com.jayway.jsonpath.matchers.JsonPathMatchers.withJsonPath;
+import static java.util.concurrent.TimeUnit.MINUTES;
+import static org.apache.geode.cache.FixedPartitionAttributes.createFixedPartition;
+import static org.apache.geode.cache.query.Utils.createPortfoliosAndPositions;
+import static org.apache.geode.management.internal.ManagementConstants.DEFAULT_QUERY_LIMIT;
+import static org.apache.geode.management.internal.ManagementStrings.QUERY__MSG__INVALID_QUERY;
+import static org.apache.geode.management.internal.ManagementStrings.QUERY__MSG__JOIN_OP_EX;
+import static org.apache.geode.management.internal.ManagementStrings.QUERY__MSG__REGIONS_NOT_FOUND;
+import static org.apache.geode.management.internal.ManagementStrings.QUERY__MSG__REGIONS_NOT_FOUND_ON_MEMBERS;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.hamcrest.Matchers.*;
+import static org.hamcrest.Matchers.anything;
+import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import java.io.Serializable;
@@ -55,12 +61,12 @@ import org.apache.geode.cache.PartitionResolver;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionFactory;
import org.apache.geode.cache.RegionShortcut;
-import org.apache.geode.cache.query.data.Portfolio; // TODO
+import org.apache.geode.cache.query.data.Portfolio;
import org.apache.geode.distributed.DistributedMember;
import org.apache.geode.internal.cache.BucketRegion;
import org.apache.geode.internal.cache.PartitionedRegion;
import org.apache.geode.internal.cache.PartitionedRegionHelper;
-import org.apache.geode.internal.cache.partitioned.fixed.SingleHopQuarterPartitionResolver; // TODO
+import org.apache.geode.internal.cache.partitioned.fixed.SingleHopQuarterPartitionResolver;
import org.apache.geode.management.internal.SystemManagementService;
import org.apache.geode.management.internal.beans.BeanUtilFuncs;
import org.apache.geode.management.internal.cli.json.TypedJson;
@@ -162,9 +168,9 @@ public class QueryDataDUnitTest implements Serializable {
@Before
public void before() throws Exception {
- this.member1 = this.managementTestRule.getDistributedMember(this.memberVMs[0]);
- this.member2 = this.managementTestRule.getDistributedMember(this.memberVMs[1]);
- this.member3 = this.managementTestRule.getDistributedMember(this.memberVMs[2]);
+ member1 = managementTestRule.getDistributedMember(memberVMs[0]);
+ member2 = managementTestRule.getDistributedMember(memberVMs[1]);
+ member3 = managementTestRule.getDistributedMember(memberVMs[2]);
createRegionsInNodes();
generateValuesInRegions();
@@ -172,9 +178,9 @@ public class QueryDataDUnitTest implements Serializable {
@Test
public void testQueryOnPartitionedRegion() throws Exception {
- this.managerVM.invoke(this.testName.getMethodName(), () -> {
+ managerVM.invoke(testName.getMethodName(), () -> {
DistributedSystemMXBean distributedSystemMXBean =
- this.managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
+ managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
String jsonString = distributedSystemMXBean.queryData(QUERIES[0], null, 10);
assertThat(jsonString).contains("result").doesNotContain("No Data Found");
@@ -200,9 +206,9 @@ public class QueryDataDUnitTest implements Serializable {
@Test
public void testQueryOnReplicatedRegion() throws Exception {
- this.managerVM.invoke(this.testName.getMethodName(), () -> {
+ managerVM.invoke(testName.getMethodName(), () -> {
DistributedSystemMXBean distributedSystemMXBean =
- this.managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
+ managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
String jsonString = distributedSystemMXBean.queryData(QUERIES_FOR_REPLICATED[0], null, 10);
assertThat(jsonString).contains("result").doesNotContain("No Data Found");
@@ -216,9 +222,9 @@ public class QueryDataDUnitTest implements Serializable {
@Test
public void testMemberWise() throws Exception {
- this.managerVM.invoke(this.testName.getMethodName(), () -> {
+ managerVM.invoke(testName.getMethodName(), () -> {
DistributedSystemMXBean distributedSystemMXBean =
- this.managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
+ managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
byte[] bytes = distributedSystemMXBean.queryDataForCompressedResult(QUERIES_FOR_REPLICATED[0],
member1.getId() + "," + member2.getId(), 2);
@@ -230,11 +236,11 @@ public class QueryDataDUnitTest implements Serializable {
@Test
public void testLimitForQuery() throws Exception {
- this.memberVMs[0].invoke("putBigInstances", () -> putBigInstances(REPLICATE_REGION_NAME4));
+ memberVMs[0].invoke("putBigInstances", () -> putBigInstances(REPLICATE_REGION_NAME4));
- this.managerVM.invoke(this.testName.getMethodName(), () -> {
+ managerVM.invoke(testName.getMethodName(), () -> {
DistributedSystemMXBean distributedSystemMXBean =
- this.managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
+ managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
// Query With Default values
assertThat(distributedSystemMXBean.getQueryCollectionsDepth())
@@ -292,9 +298,9 @@ public class QueryDataDUnitTest implements Serializable {
@Test
public void testErrors() throws Exception {
- this.managerVM.invoke(this.testName.getMethodName(), () -> {
+ managerVM.invoke(testName.getMethodName(), () -> {
DistributedSystemMXBean distributedSystemMXBean =
- this.managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
+ managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
String invalidQuery = "SELECT * FROM " + PARTITIONED_REGION_NAME1;
String invalidQueryResult = distributedSystemMXBean.queryData(invalidQuery, null, 2);
@@ -302,7 +308,7 @@ public class QueryDataDUnitTest implements Serializable {
isJson(withJsonPath("$.message", equalTo(QUERY__MSG__INVALID_QUERY
.toLocalizedString("Region mentioned in query probably missing /")))));
- String nonexistentRegionName = this.testName.getMethodName() + "_NONEXISTENT_REGION";
+ String nonexistentRegionName = testName.getMethodName() + "_NONEXISTENT_REGION";
String regionsNotFoundQuery = "SELECT * FROM /" + nonexistentRegionName
+ " r1, PARTITIONED_REGION_NAME2 r2 WHERE r1.ID = r2.ID";
String regionsNotFoundResult =
@@ -310,11 +316,11 @@ public class QueryDataDUnitTest implements Serializable {
assertThat(regionsNotFoundResult, isJson(withJsonPath("$.message",
equalTo(QUERY__MSG__REGIONS_NOT_FOUND.toLocalizedString("/" + nonexistentRegionName)))));
- String regionName = this.testName.getMethodName() + "_REGION";
+ String regionName = testName.getMethodName() + "_REGION";
String regionsNotFoundOnMembersQuery = "SELECT * FROM /" + regionName;
RegionFactory regionFactory =
- this.managementTestRule.getCache().createRegionFactory(RegionShortcut.REPLICATE);
+ managementTestRule.getCache().createRegionFactory(RegionShortcut.REPLICATE);
regionFactory.create(regionName);
String regionsNotFoundOnMembersResult =
@@ -332,18 +338,18 @@ public class QueryDataDUnitTest implements Serializable {
@Test
public void testNormalRegions() throws Exception {
- this.managerVM.invoke(this.testName.getMethodName(), () -> {
+ managerVM.invoke(testName.getMethodName(), () -> {
DistributedSystemMXBean distributedSystemMXBean =
- this.managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
+ managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
- String normalRegionName1 = this.testName.getMethodName() + "_NORMAL_REGION_1";
- String tempRegionName1 = this.testName.getMethodName() + "_TEMP_REGION_1";
+ String normalRegionName1 = testName.getMethodName() + "_NORMAL_REGION_1";
+ String tempRegionName1 = testName.getMethodName() + "_TEMP_REGION_1";
// to Reverse order of regions while getting Random region in QueryDataFunction [?]
- String normalRegionName2 = this.testName.getMethodName() + "_NORMAL_REGION_2";
- String tempRegionName2 = this.testName.getMethodName() + "_TEMP_REGION_2";
+ String normalRegionName2 = testName.getMethodName() + "_NORMAL_REGION_2";
+ String tempRegionName2 = testName.getMethodName() + "_TEMP_REGION_2";
- Cache cache = this.managementTestRule.getCache();
+ Cache cache = managementTestRule.getCache();
RegionFactory regionFactory = cache.createRegionFactory(RegionShortcut.LOCAL_HEAP_LRU);
regionFactory.create(normalRegionName1);
@@ -372,12 +378,12 @@ public class QueryDataDUnitTest implements Serializable {
@Test
public void testRegionsLocalDataSet() throws Exception {
- String partitionedRegionName = this.testName.getMethodName() + "_PARTITIONED_REGION";
+ String partitionedRegionName = testName.getMethodName() + "_PARTITIONED_REGION";
String[] values1 = new String[] {"val1", "val2", "val3"};
String[] values2 = new String[] {"val4", "val5", "val6"};
- this.memberVMs[0].invoke(this.testName.getMethodName() + " Create Region", () -> {
+ memberVMs[0].invoke(testName.getMethodName() + " Create Region", () -> {
PartitionAttributesFactory partitionAttributesFactory = new PartitionAttributesFactory();
partitionAttributesFactory.setRedundantCopies(2).setTotalNumBuckets(12);
@@ -388,7 +394,7 @@ public class QueryDataDUnitTest implements Serializable {
partitionAttributesFactory.setPartitionResolver(new SingleHopQuarterPartitionResolver());
RegionFactory regionFactory =
- this.managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
+ managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
.setPartitionAttributes(partitionAttributesFactory.create());
Region region = regionFactory.create(partitionedRegionName);
@@ -397,7 +403,7 @@ public class QueryDataDUnitTest implements Serializable {
}
});
- this.memberVMs[1].invoke(this.testName.getMethodName() + " Create Region", () -> {
+ memberVMs[1].invoke(testName.getMethodName() + " Create Region", () -> {
PartitionAttributesFactory partitionAttributesFactory = new PartitionAttributesFactory();
partitionAttributesFactory.setRedundantCopies(2).setTotalNumBuckets(12);
@@ -408,7 +414,7 @@ public class QueryDataDUnitTest implements Serializable {
partitionAttributesFactory.setPartitionResolver(new SingleHopQuarterPartitionResolver());
RegionFactory regionFactory =
- this.managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
+ managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
.setPartitionAttributes(partitionAttributesFactory.create());
Region region = regionFactory.create(partitionedRegionName);
@@ -417,7 +423,7 @@ public class QueryDataDUnitTest implements Serializable {
}
});
- this.memberVMs[2].invoke(this.testName.getMethodName() + " Create Region", () -> {
+ memberVMs[2].invoke(testName.getMethodName() + " Create Region", () -> {
PartitionAttributesFactory partitionAttributesFactory = new PartitionAttributesFactory();
partitionAttributesFactory.setRedundantCopies(2).setTotalNumBuckets(12);
@@ -426,21 +432,21 @@ public class QueryDataDUnitTest implements Serializable {
partitionAttributesFactory.setPartitionResolver(new SingleHopQuarterPartitionResolver());
RegionFactory regionFactory =
- this.managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
+ managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
.setPartitionAttributes(partitionAttributesFactory.create());
regionFactory.create(partitionedRegionName);
});
List<String> member1RealData =
- this.memberVMs[0].invoke(() -> getLocalDataSet(partitionedRegionName));
+ memberVMs[0].invoke(() -> getLocalDataSet(partitionedRegionName));
List<String> member2RealData =
- this.memberVMs[1].invoke(() -> getLocalDataSet(partitionedRegionName));
+ memberVMs[1].invoke(() -> getLocalDataSet(partitionedRegionName));
List<String> member3RealData =
- this.memberVMs[2].invoke(() -> getLocalDataSet(partitionedRegionName));
+ memberVMs[2].invoke(() -> getLocalDataSet(partitionedRegionName));
- this.managerVM.invoke(this.testName.getMethodName(), () -> {
+ managerVM.invoke(testName.getMethodName(), () -> {
DistributedSystemMXBean distributedSystemMXBean =
- this.managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
+ managementTestRule.getSystemManagementService().getDistributedSystemMXBean();
DistributedRegionMXBean distributedRegionMXBean =
awaitDistributedRegionMXBean("/" + partitionedRegionName, 3);
@@ -486,7 +492,7 @@ public class QueryDataDUnitTest implements Serializable {
private void putDataInRegion(final String regionName, final Object[] portfolio, final int from,
final int to) {
- Region region = this.managementTestRule.getCache().getRegion(regionName);
+ Region region = managementTestRule.getCache().getRegion(regionName);
for (int i = from; i < to; i++) {
region.put(new Integer(i), portfolio[i]);
}
@@ -500,32 +506,32 @@ public class QueryDataDUnitTest implements Serializable {
Portfolio[] portfolio = createPortfoliosAndPositions(COUNT_DESTINATION);
// Fill local region
- this.memberVMs[0]
+ memberVMs[0]
.invoke(() -> putDataInRegion(LOCAL_REGION_NAME, portfolio, COUNT_FROM, COUNT_DESTINATION));
// Fill replicated region
- this.memberVMs[0].invoke(
+ memberVMs[0].invoke(
() -> putDataInRegion(REPLICATE_REGION_NAME1, portfolio, COUNT_FROM, COUNT_DESTINATION));
- this.memberVMs[1].invoke(
+ memberVMs[1].invoke(
() -> putDataInRegion(REPLICATE_REGION_NAME2, portfolio, COUNT_FROM, COUNT_DESTINATION));
// Fill Partition Region
- this.memberVMs[0].invoke(
+ memberVMs[0].invoke(
() -> putDataInRegion(PARTITIONED_REGION_NAME1, portfolio, COUNT_FROM, COUNT_DESTINATION));
- this.memberVMs[0].invoke(
+ memberVMs[0].invoke(
() -> putDataInRegion(PARTITIONED_REGION_NAME2, portfolio, COUNT_FROM, COUNT_DESTINATION));
- this.memberVMs[0].invoke(
+ memberVMs[0].invoke(
() -> putDataInRegion(PARTITIONED_REGION_NAME3, portfolio, COUNT_FROM, COUNT_DESTINATION));
- this.memberVMs[0].invoke(
+ memberVMs[0].invoke(
() -> putDataInRegion(PARTITIONED_REGION_NAME4, portfolio, COUNT_FROM, COUNT_DESTINATION));
- this.memberVMs[0].invoke(
+ memberVMs[0].invoke(
() -> putDataInRegion(PARTITIONED_REGION_NAME5, portfolio, COUNT_FROM, COUNT_DESTINATION));
- this.memberVMs[0].invoke(() -> putPdxInstances(REPLICATE_REGION_NAME3));
+ memberVMs[0].invoke(() -> putPdxInstances(REPLICATE_REGION_NAME3));
}
private void putPdxInstances(final String regionName) throws CacheException {
- Region region = this.managementTestRule.getCache().getRegion(regionName);
+ Region region = managementTestRule.getCache().getRegion(regionName);
PdxInstanceFactory pdxInstanceFactory = PdxInstanceFactoryImpl.newCreator("Portfolio", false);
pdxInstanceFactory.writeInt("ID", 111);
@@ -557,7 +563,7 @@ public class QueryDataDUnitTest implements Serializable {
}
private void putBigInstances(final String regionName) {
- Region region = this.managementTestRule.getCache().getRegion(regionName);
+ Region region = managementTestRule.getCache().getRegion(regionName);
for (int i = 0; i < 1200; i++) {
List<String> bigCollection = new ArrayList<>();
@@ -569,36 +575,36 @@ public class QueryDataDUnitTest implements Serializable {
}
private void createLocalRegion() {
- this.managementTestRule.getCache().createRegionFactory(RegionShortcut.LOCAL)
+ managementTestRule.getCache().createRegionFactory(RegionShortcut.LOCAL)
.create(LOCAL_REGION_NAME);
}
private void createReplicatedRegion() {
- this.managementTestRule.getCache().createRegionFactory(RegionShortcut.REPLICATE)
+ managementTestRule.getCache().createRegionFactory(RegionShortcut.REPLICATE)
.create(REPLICATE_REGION_NAME1);
}
private void createColocatedPR() {
PartitionResolver testKeyBasedResolver = new TestPartitionResolver();
- this.managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
+ managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
.setPartitionAttributes(new PartitionAttributesFactory().setTotalNumBuckets(NUM_OF_BUCKETS)
.setPartitionResolver(testKeyBasedResolver).create())
.create(PARTITIONED_REGION_NAME1);
- this.managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
+ managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
.setPartitionAttributes(new PartitionAttributesFactory().setTotalNumBuckets(NUM_OF_BUCKETS)
.setPartitionResolver(testKeyBasedResolver).setColocatedWith(PARTITIONED_REGION_NAME1)
.create())
.create(PARTITIONED_REGION_NAME2);
- this.managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
+ managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
.setPartitionAttributes(new PartitionAttributesFactory().setTotalNumBuckets(NUM_OF_BUCKETS)
.setPartitionResolver(testKeyBasedResolver).setColocatedWith(PARTITIONED_REGION_NAME2)
.create())
.create(PARTITIONED_REGION_NAME3);
- this.managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
+ managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
.setPartitionAttributes(new PartitionAttributesFactory().setTotalNumBuckets(NUM_OF_BUCKETS)
.setPartitionResolver(testKeyBasedResolver).create())
.create(PARTITIONED_REGION_NAME4); // not collocated
- this.managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
+ managementTestRule.getCache().createRegionFactory(RegionShortcut.PARTITION)
.setPartitionAttributes(new PartitionAttributesFactory().setTotalNumBuckets(NUM_OF_BUCKETS)
.setPartitionResolver(testKeyBasedResolver).setColocatedWith(PARTITIONED_REGION_NAME4)
.create())
@@ -606,30 +612,29 @@ public class QueryDataDUnitTest implements Serializable {
}
private void createDistributedRegion(final String regionName) {
- this.managementTestRule.getCache().createRegionFactory(RegionShortcut.REPLICATE)
- .create(regionName);
+ managementTestRule.getCache().createRegionFactory(RegionShortcut.REPLICATE).create(regionName);
}
private void createRegionsInNodes()
throws InterruptedException, TimeoutException, ExecutionException {
// Create local Region on servers
- this.memberVMs[0].invoke(() -> createLocalRegion());
+ memberVMs[0].invoke(() -> createLocalRegion());
// Create ReplicatedRegion on servers
- this.memberVMs[0].invoke(() -> createReplicatedRegion());
- this.memberVMs[1].invoke(() -> createReplicatedRegion());
- this.memberVMs[2].invoke(() -> createReplicatedRegion());
+ memberVMs[0].invoke(() -> createReplicatedRegion());
+ memberVMs[1].invoke(() -> createReplicatedRegion());
+ memberVMs[2].invoke(() -> createReplicatedRegion());
- this.memberVMs[1].invoke(() -> createDistributedRegion(REPLICATE_REGION_NAME2));
- this.memberVMs[0].invoke(() -> createDistributedRegion(REPLICATE_REGION_NAME3));
- this.memberVMs[0].invoke(() -> createDistributedRegion(REPLICATE_REGION_NAME4));
+ memberVMs[1].invoke(() -> createDistributedRegion(REPLICATE_REGION_NAME2));
+ memberVMs[0].invoke(() -> createDistributedRegion(REPLICATE_REGION_NAME3));
+ memberVMs[0].invoke(() -> createDistributedRegion(REPLICATE_REGION_NAME4));
// Create two co-located PartitionedRegions On Servers.
- this.memberVMs[0].invoke(() -> createColocatedPR());
- this.memberVMs[1].invoke(() -> createColocatedPR());
- this.memberVMs[2].invoke(() -> createColocatedPR());
+ memberVMs[0].invoke(() -> createColocatedPR());
+ memberVMs[1].invoke(() -> createColocatedPR());
+ memberVMs[2].invoke(() -> createColocatedPR());
- this.managerVM.invoke("Wait for all Region Proxies to get replicated", () -> {
+ managerVM.invoke("Wait for all Region Proxies to get replicated", () -> {
awaitDistributedRegionMXBean("/" + PARTITIONED_REGION_NAME1, 3);
awaitDistributedRegionMXBean("/" + PARTITIONED_REGION_NAME2, 3);
awaitDistributedRegionMXBean("/" + PARTITIONED_REGION_NAME3, 3);
@@ -644,7 +649,7 @@ public class QueryDataDUnitTest implements Serializable {
private List<String> getLocalDataSet(final String region) {
PartitionedRegion partitionedRegion =
- PartitionedRegionHelper.getPartitionedRegion(region, this.managementTestRule.getCache());
+ PartitionedRegionHelper.getPartitionedRegion(region, managementTestRule.getCache());
Set<BucketRegion> localPrimaryBucketRegions =
partitionedRegion.getDataStore().getAllLocalPrimaryBucketRegions();
@@ -680,7 +685,7 @@ public class QueryDataDUnitTest implements Serializable {
}
private MemberMXBean awaitMemberMXBeanProxy(final DistributedMember member) {
- SystemManagementService service = this.managementTestRule.getSystemManagementService();
+ SystemManagementService service = managementTestRule.getSystemManagementService();
ObjectName objectName = service.getMemberMBeanName(member);
String alias = "awaiting MemberMXBean proxy for " + member;
@@ -691,7 +696,7 @@ public class QueryDataDUnitTest implements Serializable {
}
private DistributedSystemMXBean awaitDistributedSystemMXBean() {
- SystemManagementService service = this.managementTestRule.getSystemManagementService();
+ SystemManagementService service = managementTestRule.getSystemManagementService();
await().until(() -> assertThat(service.getDistributedSystemMXBean()).isNotNull());
@@ -699,7 +704,7 @@ public class QueryDataDUnitTest implements Serializable {
}
private DistributedRegionMXBean awaitDistributedRegionMXBean(final String name) {
- SystemManagementService service = this.managementTestRule.getSystemManagementService();
+ SystemManagementService service = managementTestRule.getSystemManagementService();
await().until(() -> assertThat(service.getDistributedRegionMXBean(name)).isNotNull());
@@ -708,7 +713,7 @@ public class QueryDataDUnitTest implements Serializable {
private DistributedRegionMXBean awaitDistributedRegionMXBean(final String name,
final int memberCount) {
- SystemManagementService service = this.managementTestRule.getSystemManagementService();
+ SystemManagementService service = managementTestRule.getSystemManagementService();
await().until(() -> assertThat(service.getDistributedRegionMXBean(name)).isNotNull());
await().until(() -> assertThat(service.getDistributedRegionMXBean(name).getMemberCount())
diff --git a/geode-core/src/test/java/org/apache/geode/management/QueryDataFunctionIntegrationTest.java b/geode-core/src/test/java/org/apache/geode/management/QueryDataFunctionIntegrationTest.java
index 7f19416..a3f0667 100644
--- a/geode-core/src/test/java/org/apache/geode/management/QueryDataFunctionIntegrationTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/QueryDataFunctionIntegrationTest.java
@@ -109,8 +109,11 @@ public class QueryDataFunctionIntegrationTest {
}
/**
- * #Issue 51048 Tests a model where Objects have a circular reference with object reference. e.g.
- * Order1-- Has--> Items each Item --Has --> OrderN where (OrderN == Order1)
+ * Tests a model where Objects have a circular reference with object reference. e.g. Order1--
+ * Has--> Items each Item --Has --> OrderN where (OrderN == Order1)
+ * <p>
+ *
+ * RegressionTest for TRAC #51048: Disk Read/ Write shows negative at cluster level JMX
*/
@Test
public void testCyclicWithNestedObjectReference() throws Exception {
@@ -316,5 +319,4 @@ public class QueryDataFunctionIntegrationTest {
}
return portfolios;
}
-
}
diff --git a/geode-core/src/test/java/org/apache/geode/management/RegionCreateDestroyDUnitTest.java b/geode-core/src/test/java/org/apache/geode/management/RegionCreateDestroyDUnitTest.java
index d336069..bf141ed 100644
--- a/geode-core/src/test/java/org/apache/geode/management/RegionCreateDestroyDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/RegionCreateDestroyDUnitTest.java
@@ -14,9 +14,11 @@
*/
package org.apache.geode.management;
-import static org.apache.geode.distributed.ConfigurationProperties.*;
+import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS;
+import static org.apache.geode.distributed.ConfigurationProperties.MCAST_PORT;
+import static org.apache.geode.distributed.ConfigurationProperties.SECURITY_LOG_LEVEL;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import java.io.IOException;
diff --git a/geode-core/src/test/java/org/apache/geode/management/RegionManagementDUnitTest.java b/geode-core/src/test/java/org/apache/geode/management/RegionManagementDUnitTest.java
index ee7cb95..c97b83c 100644
--- a/geode-core/src/test/java/org/apache/geode/management/RegionManagementDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/RegionManagementDUnitTest.java
@@ -12,20 +12,6 @@
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
- * agreements. See the NOTICE file distributed with this work for additional information regarding
- * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License. You may obtain a
- * copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
- * or implied. See the License for the specific language governing permissions and limitations under
- * the License.
- */
package org.apache.geode.management;
import static java.lang.management.ManagementFactory.getPlatformMBeanServer;
@@ -34,11 +20,11 @@ import static org.apache.geode.cache.Region.SEPARATOR;
import static org.apache.geode.management.internal.MBeanJMXAdapter.getDistributedRegionMbeanName;
import static org.apache.geode.management.internal.MBeanJMXAdapter.getMemberMBeanName;
import static org.apache.geode.management.internal.MBeanJMXAdapter.getRegionMBeanName;
-import static org.apache.geode.test.dunit.Host.getHost;
import static org.apache.geode.test.dunit.Invoke.invokeInEveryVM;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
+import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
@@ -53,7 +39,7 @@ import javax.management.ObjectName;
import org.awaitility.Awaitility;
import org.awaitility.core.ConditionFactory;
import org.junit.After;
-import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
@@ -85,16 +71,19 @@ import org.apache.geode.test.junit.categories.DistributedTest;
import org.apache.geode.test.junit.categories.FlakyTest;
/**
+ * Distributed tests for {@link RegionMXBean}.
+ * <p>
+ *
* This class checks and verifies various data and operations exposed through RegionMXBean
* interface.
- * </p>
+ * <p>
+ *
* Goal of the Test : RegionMBean gets created once region is created. Data like Region Attributes
* data and stats are of proper value
- * </p>
- * TODO: complete refactoring this test to use ManagementTestRule
*/
@Category(DistributedTest.class)
-public class RegionManagementDUnitTest extends ManagementTestBase {
+@SuppressWarnings({"serial", "unused"})
+public class RegionManagementDUnitTest implements Serializable {
private static final String REGION_NAME = "MANAGEMENT_TEST_REGION";
private static final String PARTITIONED_REGION_NAME = "MANAGEMENT_PAR_REGION";
@@ -111,9 +100,9 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
// field used in manager VM
private static Region fixedPartitionedRegion;
- private static final AtomicReference<List<Notification>> MEMBER_NOTIFICATIONS_REF =
+ private static final AtomicReference<List<Notification>> MEMBER_NOTIFICATIONS =
new AtomicReference<>();
- private static final AtomicReference<List<Notification>> SYSTEM_NOTIFICATIONS_REF =
+ private static final AtomicReference<List<Notification>> SYSTEM_NOTIFICATIONS =
new AtomicReference<>();
@Manager
@@ -122,33 +111,28 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
@Member
private VM[] memberVMs;
- @Before
- public void before() throws Exception {
- this.managerVM = getHost(0).getVM(0);
-
- this.memberVMs = new VM[3];
- this.memberVMs[0] = getHost(0).getVM(1);
- this.memberVMs[1] = getHost(0).getVM(2);
- this.memberVMs[2] = getHost(0).getVM(3);
- }
+ @Rule
+ public ManagementTestRule managementTestRule = ManagementTestRule.builder().build();
@After
public void after() throws Exception {
- invokeInEveryVM(() -> MEMBER_NOTIFICATIONS_REF.set(null));
- invokeInEveryVM(() -> SYSTEM_NOTIFICATIONS_REF.set(null));
- disconnectAllFromDS_tmp();
+ disconnectAllFromDS();
+
+ MEMBER_NOTIFICATIONS.set(null);
+ SYSTEM_NOTIFICATIONS.set(null);
+ invokeInEveryVM(() -> MEMBER_NOTIFICATIONS.set(null));
+ invokeInEveryVM(() -> SYSTEM_NOTIFICATIONS.set(null));
}
/**
- * Tests all Region MBean related Management APIs
- * <p>
- * a) Notification propagated to member MBean while a region is created
+ * Tests all Region MBean related Management APIs:
* <p>
+ * a) Notification propagated to member MBean while a region is created<br>
* b) Creates and check a Distributed Region
*/
@Test
public void testDistributedRegion() throws Exception {
- createMembersAndThenManagers_tmp();
+ createMembersAndThenManagers();
// Adding notification listener for remote cache memberVMs
addMemberNotificationListener(this.managerVM, 3); // TODO: why?
@@ -171,15 +155,14 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
}
/**
- * Tests all Region MBean related Management APIs
- * <p>
- * a) Notification propagated to member MBean while a region is created
+ * Tests all Region MBean related Management APIs:
* <p>
+ * a) Notification propagated to member MBean while a region is created<br>
* b) Created and check a Partitioned Region
*/
@Test
public void testPartitionedRegion() throws Exception {
- createMembersAndThenManagers_tmp();
+ createMembersAndThenManagers();
// Adding notification listener for remote cache memberVMs
addMemberNotificationListener(this.managerVM, 3); // TODO: why?
@@ -200,15 +183,14 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
}
/**
- * Tests all Region MBean related Management APIs
- * <p>
- * a) Notification propagated to member MBean while a region is created
+ * Tests all Region MBean related Management APIs:
* <p>
+ * a) Notification propagated to member MBean while a region is created<br>
* b) Creates and check a Fixed Partitioned Region
*/
@Test
public void testFixedPRRegionMBean() throws Exception {
- createMembersAndThenManagers_tmp();
+ createMembersAndThenManagers();
// Adding notification listener for remote cache memberVMs
addMemberNotificationListener(this.managerVM, 3); // TODO: why?
@@ -234,10 +216,10 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
* Tests a Distributed Region at Managing Node side while region is created in a member node
* asynchronously.
*/
- @Category(FlakyTest.class) // GEODE-1930
@Test
+ @Category(FlakyTest.class) // GEODE-1930
public void testRegionAggregate() throws Exception {
- createManagersAndThenMembers_tmp();
+ createManagersAndThenMembers();
// Adding notification listener for remote cache memberVMs
addSystemNotificationListener(this.managerVM); // TODO: why?
@@ -267,7 +249,7 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
@Test
@Category(FlakyTest.class) // GEODE-3335
public void testNavigationAPIS() throws Exception {
- createManagersAndThenMembers_tmp();
+ createManagersAndThenMembers();
for (VM memberVM : this.memberVMs) {
createDistributedRegion_tmp(memberVM, REGION_NAME);
@@ -292,7 +274,7 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
@Test
public void testSubRegions() throws Exception {
- createMembersAndThenManagers_tmp();
+ createMembersAndThenManagers();
for (VM memberVM : this.memberVMs) {
createLocalRegion_tmp(memberVM, LOCAL_REGION_NAME);
@@ -311,43 +293,45 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
@Test
public void testSpecialRegions() throws Exception {
- createMembersAndThenManagers_tmp();
+ createMembersAndThenManagers();
createSpecialRegion(this.memberVMs[0]);
verifySpecialRegion(this.managerVM);
}
- @Category(FlakyTest.class) // GEODE-1930
@Test
+ @Category(FlakyTest.class) // GEODE-1930
public void testLruStats() throws Exception {
- createMembersAndThenManagers_tmp();
+ createMembersAndThenManagers();
for (VM memberVM : this.memberVMs) {
createDiskRegion(memberVM);
}
verifyEntrySize(this.managerVM, 3);
}
- private void createMembersAndThenManagers_tmp() throws Exception {
- initManagement(false);
+ private void createMembersAndThenManagers() throws Exception {
+ this.managementTestRule.createMembers();
+ this.managementTestRule.createManagers();
}
- private void createManagersAndThenMembers_tmp() throws Exception {
- initManagement(true);
+ private void createManagersAndThenMembers() throws Exception {
+ this.managementTestRule.createManagers();
+ this.managementTestRule.createMembers();
}
- private void disconnectAllFromDS_tmp() {
- disconnectAllFromDS();
+ private void disconnectAllFromDS() {
+ this.managementTestRule.disconnectAllFromDS();
}
- private ManagementService getManagementService_tmp() {
- return getManagementService();
+ private ManagementService getManagementService() {
+ return this.managementTestRule.getManagementService();
}
- private Cache getCache_tmp() {
- return getCache();
+ private Cache getCache() {
+ return this.managementTestRule.getCache();
}
private void closeRegion(final VM anyVM, final String regionPath) {
- anyVM.invoke("closeRegion", () -> getCache_tmp().getRegion(regionPath).close());
+ anyVM.invoke("closeRegion", () -> getCache().getRegion(regionPath).close());
}
private void createSpecialRegion(final VM memberVM) {
@@ -356,7 +340,7 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
attributesFactory.setValueConstraint(Portfolio.class);
RegionAttributes regionAttributes = attributesFactory.create();
- Cache cache = getCache_tmp();
+ Cache cache = getCache();
cache.createRegion("p-os", regionAttributes);
cache.createRegion("p_os", regionAttributes);
});
@@ -376,13 +360,13 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
factory.setEvictionAttributes(EvictionAttributes.createLRUMemoryAttributes(20,
new TestObjectSizerImpl(), EvictionAction.LOCAL_DESTROY));
- Region region = getCache_tmp().createRegion(REGION_NAME, factory.create());
+ Region region = getCache().createRegion(REGION_NAME, factory.create());
LRUStatistics lruStats =
((AbstractRegion) region).getEvictionController().getLRUHelper().getStats();
assertThat(lruStats).isNotNull();
- RegionMXBean regionMXBean = getManagementService_tmp().getLocalRegionMBean(REGION_PATH);
+ RegionMXBean regionMXBean = getManagementService().getLocalRegionMBean(REGION_PATH);
assertThat(regionMXBean).isNotNull();
int total;
@@ -406,21 +390,21 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
private void verifySubRegions(final VM memberVM, final String subRegionPath) {
memberVM.invoke("verifySubRegions", () -> {
- RegionMXBean regionMXBean = getManagementService_tmp().getLocalRegionMBean(subRegionPath);
+ RegionMXBean regionMXBean = getManagementService().getLocalRegionMBean(subRegionPath);
assertThat(regionMXBean).isNotNull();
});
}
private void verifyNullRegions(final VM memberVM, final String subRegionPath) {
memberVM.invoke("verifyNullRegions", () -> {
- RegionMXBean regionMXBean = getManagementService_tmp().getLocalRegionMBean(subRegionPath);
+ RegionMXBean regionMXBean = getManagementService().getLocalRegionMBean(subRegionPath);
assertThat(regionMXBean).isNull();
});
}
private void verifyNavigationApis(final VM managerVM, final List<String> memberIds) {
managerVM.invoke("verifyNavigationApis", () -> {
- ManagementService service = getManagementService_tmp();
+ ManagementService service = getManagementService();
assertThat(service.getDistributedSystemMXBean()).isNotNull();
awaitMemberCount(4);
@@ -522,7 +506,7 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
AttributesFactory attributesFactory = new AttributesFactory();
attributesFactory.setPartitionAttributes(partitionAttributesFactory.create());
- fixedPartitionedRegion = getCache_tmp().createRegion(FIXED_PR_NAME, attributesFactory.create());
+ fixedPartitionedRegion = getCache().createRegion(FIXED_PR_NAME, attributesFactory.create());
assertThat(fixedPartitionedRegion).isNotNull();
RegionMXBean regionMXBean = service.getLocalRegionMBean(FIXED_PR_PATH);
@@ -551,7 +535,7 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
SystemManagementService service = getSystemManagementService_tmp();
List<Notification> notifications = new ArrayList<>();
- MEMBER_NOTIFICATIONS_REF.set(notifications);
+ MEMBER_NOTIFICATIONS.set(notifications);
for (DistributedMember member : otherMemberSet) {
MemberNotificationListener listener = new MemberNotificationListener(notifications);
@@ -573,7 +557,7 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
awaitDistributedSystemMXBean();
List<Notification> notifications = new ArrayList<>();
- SYSTEM_NOTIFICATIONS_REF.set(notifications);
+ SYSTEM_NOTIFICATIONS.set(notifications);
DistributedSystemNotificationListener listener =
new DistributedSystemNotificationListener(notifications);
@@ -585,11 +569,11 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
private void verifyMemberNotifications(final VM managerVM, final String regionName,
final int expectedMembers) {
managerVM.invoke("verifyMemberNotifications", () -> {
- await().until(() -> assertThat(MEMBER_NOTIFICATIONS_REF.get()).hasSize(expectedMembers * 2));
+ await().until(() -> assertThat(MEMBER_NOTIFICATIONS.get()).hasSize(expectedMembers * 2));
int regionCreatedCount = 0;
int regionDestroyedCount = 0;
- for (Notification notification : MEMBER_NOTIFICATIONS_REF.get()) {
+ for (Notification notification : MEMBER_NOTIFICATIONS.get()) {
if (JMXNotificationType.REGION_CREATED.equals(notification.getType())) {
regionCreatedCount++;
assertThat(notification.getMessage()).contains(regionName);
@@ -622,13 +606,13 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
private void verifySystemNotifications(final VM managerVM, final String regionName,
final int expectedMembers) {
managerVM.invoke("verifySystemNotifications", () -> {
- assertThat(SYSTEM_NOTIFICATIONS_REF.get()).isNotNull();
- assertThat(SYSTEM_NOTIFICATIONS_REF.get()).hasSize(expectedMembers + 2); // 2 for the manager
+ assertThat(SYSTEM_NOTIFICATIONS.get()).isNotNull();
+ assertThat(SYSTEM_NOTIFICATIONS.get()).hasSize(expectedMembers + 2); // 2 for the manager
int regionCreatedCount = 0;
int regionDestroyedCount = 0;
- for (Notification notification : SYSTEM_NOTIFICATIONS_REF.get()) {
+ for (Notification notification : SYSTEM_NOTIFICATIONS.get()) {
if (JMXNotificationType.REGION_CREATED.equals(notification.getType())) {
regionCreatedCount++;
assertThat(notification.getMessage()).contains(regionName);
@@ -699,7 +683,7 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
private void verifyDistributedMBean(final VM managerVM, final int expectedMembers) {
managerVM.invoke("verifyDistributedMBean", () -> {
if (expectedMembers == 0) {
- ManagementService service = getManagementService_tmp();
+ ManagementService service = getManagementService();
String alias = "Waiting for the proxy to get deleted at managing node";
await(alias)
.until(() -> assertThat(service.getDistributedRegionMXBean(REGION_PATH)).isNull());
@@ -733,7 +717,7 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
assertThat(partitionAttributesData).isNotNull();
}
- ManagementService service = getManagementService_tmp();
+ ManagementService service = getManagementService();
DistributedRegionMXBean distributedRegionMXBean =
service.getDistributedRegionMXBean(PARTITIONED_REGION_PATH);
assertThat(distributedRegionMXBean.getMembers()).hasSize(3);
@@ -742,7 +726,7 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
private void verifyReplicateRegionAfterCreate(final VM memberVM) {
memberVM.invoke("verifyReplicateRegionAfterCreate", () -> {
- Cache cache = getCache_tmp();
+ Cache cache = getCache();
String memberId =
MBeanJMXAdapter.getMemberNameOrId(cache.getDistributedSystem().getDistributedMember());
@@ -775,7 +759,7 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
private void verifyPartitionRegionAfterCreate(final VM memberVM) {
memberVM.invoke("verifyPartitionRegionAfterCreate", () -> {
- Region region = getCache_tmp().getRegion(PARTITIONED_REGION_PATH);
+ Region region = getCache().getRegion(PARTITIONED_REGION_PATH);
SystemManagementService service = getSystemManagementService_tmp();
RegionMXBean regionMXBean = service.getLocalRegionMBean(PARTITIONED_REGION_PATH);
@@ -791,7 +775,7 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
assertThat(regionMXBean).isNull();
ObjectName objectName = service.getRegionMBeanName(
- getCache_tmp().getDistributedSystem().getDistributedMember(), REGION_PATH);
+ getCache().getDistributedSystem().getDistributedMember(), REGION_PATH);
assertThat(service.getLocalManager().getManagementResourceRepo()
.getEntryFromLocalMonitoringRegion(objectName)).isNull();
});
@@ -799,7 +783,7 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
private void verifyPartitionRegionAfterClose(final VM memberVM) {
memberVM.invoke("verifyPartitionRegionAfterClose", () -> {
- ManagementService service = getManagementService_tmp();
+ ManagementService service = getManagementService();
RegionMXBean regionMXBean = service.getLocalRegionMBean(PARTITIONED_REGION_PATH);
assertThat(regionMXBean).isNull();
});
@@ -1001,14 +985,14 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
}
private void createDistributedRegion_tmp(final String regionName) {
- getCache_tmp().createRegionFactory(RegionShortcut.REPLICATE).create(regionName);
+ getCache().createRegionFactory(RegionShortcut.REPLICATE).create(regionName);
}
private void createPartitionRegion_tmp(final VM vm, final String partitionRegionName) {
vm.invoke("Create Partitioned region", () -> {
SystemManagementService service = getSystemManagementService_tmp();
RegionFactory regionFactory =
- getCache_tmp().createRegionFactory(RegionShortcut.PARTITION_REDUNDANT);
+ getCache().createRegionFactory(RegionShortcut.PARTITION_REDUNDANT);
regionFactory.create(partitionRegionName);
});
}
@@ -1016,7 +1000,7 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
private void createLocalRegion_tmp(final VM vm, final String localRegionName) {
vm.invoke("Create Local region", () -> {
SystemManagementService service = getSystemManagementService_tmp();
- RegionFactory regionFactory = getCache_tmp().createRegionFactory(RegionShortcut.LOCAL);
+ RegionFactory regionFactory = getCache().createRegionFactory(RegionShortcut.LOCAL);
regionFactory.create(localRegionName);
});
}
@@ -1025,31 +1009,31 @@ public class RegionManagementDUnitTest extends ManagementTestBase {
final String subregionName) {
vm.invoke("Create Sub region", () -> {
SystemManagementService service = getSystemManagementService_tmp();
- Region region = getCache_tmp().getRegion(parentRegionPath);
+ Region region = getCache().getRegion(parentRegionPath);
region.createSubregion(subregionName, region.getAttributes());
});
}
private String getDistributedMemberId_tmp(final VM vm) {
return vm.invoke("getMemberId",
- () -> getCache_tmp().getDistributedSystem().getDistributedMember().getId());
+ () -> getCache().getDistributedSystem().getDistributedMember().getId());
}
private DistributedMember getDistributedMember_tmp(final VM anyVM) {
return anyVM.invoke("getDistributedMember_tmp",
- () -> getCache_tmp().getDistributedSystem().getDistributedMember());
+ () -> getCache().getDistributedSystem().getDistributedMember());
}
private SystemManagementService getSystemManagementService_tmp() {
- return (SystemManagementService) getManagementService_tmp();
+ return (SystemManagementService) getManagementService();
}
private DM getDistributionManager_tmp() {
- return ((GemFireCacheImpl) getCache_tmp()).getDistributionManager();
+ return ((GemFireCacheImpl) getCache()).getDistributionManager();
}
private DistributedMember getDistributedMember_tmp() {
- return getCache_tmp().getDistributedSystem().getDistributedMember();
+ return getCache().getDistributedSystem().getDistributedMember();
}
private Set<DistributedMember> getOtherNormalMembers_tmp() {
diff --git a/geode-core/src/test/java/org/apache/geode/management/UniversalMembershipListenerAdapterDUnitTest.java b/geode-core/src/test/java/org/apache/geode/management/UniversalMembershipListenerAdapterDUnitTest.java
index 0773262..5d45239 100644
--- a/geode-core/src/test/java/org/apache/geode/management/UniversalMembershipListenerAdapterDUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/UniversalMembershipListenerAdapterDUnitTest.java
@@ -14,156 +14,159 @@
*/
package org.apache.geode.management;
-import static org.apache.geode.distributed.ConfigurationProperties.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.apache.geode.distributed.ConfigurationProperties.CLUSTER_SSL_CIPHERS;
+import static org.apache.geode.distributed.ConfigurationProperties.CLUSTER_SSL_ENABLED;
+import static org.apache.geode.distributed.ConfigurationProperties.CLUSTER_SSL_PROTOCOLS;
+import static org.apache.geode.distributed.ConfigurationProperties.CLUSTER_SSL_REQUIRE_AUTHENTICATION;
+import static org.apache.geode.distributed.ConfigurationProperties.ENABLE_NETWORK_PARTITION_DETECTION;
+import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS;
+import static org.apache.geode.distributed.ConfigurationProperties.MCAST_PORT;
import static org.apache.geode.distributed.internal.DistributionConfig.RESTRICT_MEMBERSHIP_PORT_RANGE;
-import static org.apache.geode.test.dunit.Assert.*;
-import static org.apache.geode.test.dunit.LogWriterUtils.*;
-
-import org.apache.geode.internal.net.SocketCreator;
-import org.apache.geode.test.dunit.Invoke;
-import org.awaitility.Awaitility;
+import static org.apache.geode.internal.AvailablePort.SOCKET;
+import static org.apache.geode.internal.AvailablePort.getRandomAvailablePort;
+import static org.apache.geode.test.dunit.IgnoredException.addIgnoredException;
+import static org.apache.geode.test.dunit.Invoke.invokeInEveryVM;
+import static org.apache.geode.test.dunit.NetworkUtils.getServerHostName;
+import static org.apache.geode.test.dunit.Wait.pause;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
import java.io.IOException;
+import java.io.Serializable;
+import java.net.ConnectException;
import java.util.Collections;
-import java.util.HashSet;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
-import org.apache.geode.distributed.internal.ServerLocation;
+import org.awaitility.core.ConditionTimeoutException;
+import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.apache.geode.InternalGemFireException;
-import org.apache.geode.LogWriter;
import org.apache.geode.cache.AttributesFactory;
+import org.apache.geode.cache.CacheFactory;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.Scope;
import org.apache.geode.cache.client.PoolManager;
import org.apache.geode.cache.client.ServerConnectivityException;
import org.apache.geode.cache.client.internal.PoolImpl;
import org.apache.geode.cache30.ClientServerTestCase;
-import org.apache.geode.distributed.*;
-import org.apache.geode.internal.*;
-import org.apache.geode.internal.cache.GemFireCacheImpl;
+import org.apache.geode.distributed.DistributedMember;
+import org.apache.geode.distributed.DurableClientAttributes;
+import org.apache.geode.distributed.Role;
+import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.cache.tier.InternalClientMembership;
import org.apache.geode.internal.cache.tier.sockets.ServerConnection;
-import org.apache.geode.internal.logging.InternalLogWriter;
-import org.apache.geode.internal.logging.LocalLogWriter;
+import org.apache.geode.internal.net.SocketCreator;
import org.apache.geode.management.membership.ClientMembership;
import org.apache.geode.management.membership.ClientMembershipEvent;
import org.apache.geode.management.membership.ClientMembershipListener;
import org.apache.geode.management.membership.MembershipEvent;
import org.apache.geode.management.membership.MembershipListener;
import org.apache.geode.management.membership.UniversalMembershipListenerAdapter;
+import org.apache.geode.management.membership.UniversalMembershipListenerAdapter.AdaptedMembershipEvent;
import org.apache.geode.test.dunit.Host;
-import org.apache.geode.test.dunit.IgnoredException;
-import org.apache.geode.test.dunit.NetworkUtils;
import org.apache.geode.test.dunit.SerializableCallable;
import org.apache.geode.test.dunit.SerializableRunnable;
import org.apache.geode.test.dunit.VM;
-import org.apache.geode.test.dunit.Wait;
import org.apache.geode.test.dunit.rules.DistributedRestoreSystemProperties;
import org.apache.geode.test.junit.categories.DistributedTest;
import org.apache.geode.test.junit.categories.FlakyTest;
/**
- * Tests the UniversalMembershipListenerAdapter.
+ * Distributed tests for {@link UniversalMembershipListenerAdapter}.
*
* @since GemFire 4.2.1
*/
@Category(DistributedTest.class)
public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTestCase {
- @ClassRule
- public static DistributedRestoreSystemProperties distributedRestoreSystemProperties =
- new DistributedRestoreSystemProperties();
- protected static final boolean CLIENT = true;
- protected static final boolean SERVER = false;
+ private static final int JOINED = 0;
+ private static final int LEFT = 1;
+ private static final int CRASHED = 2;
- protected static final int JOINED = 0;
- protected static final int LEFT = 1;
- protected static final int CRASHED = 2;
+ /** Maximum millis allowed for client to fully connect before test fails */
+ private static final int JOIN_FAIL_MILLIS = 30 * 1000;
- /** Brief pause for basic testing of asynchronous event notification */
- private static final int BRIEF_PAUSE_MILLIS = 2000;
- /** Maximum millis allowed for bridge client to fully connect before test fails */
- private static final int JOIN_FAIL_MILLIS = 30000;
+ /**
+ * Millis to wait for notification of all three event listeners to be notified
+ * <p>
+ *
+ * Use Integer.MAX_VALUE for debugging
+ */
+ private static final int ASYNC_EVENT_WAIT_MILLIS = 30 * 1000;
+
+ private static int serverPort;
- // the following wait millis are max wait time until notify occurs
+ private final MembershipNotification joinSystemNotification = new MembershipNotification();
+ private final MembershipNotification leftSystemNotification = new MembershipNotification();
+ private final MembershipNotification crashedSystemNotification = new MembershipNotification();
- /** Millis to wait for connection to AdminDS */
- private static final int CONNECT_WAIT_MILLIS = 5000;
- /** Millis to wait for basic synchronous listener to be notified */
- private static final int SYNC_ASYNC_EVENT_WAIT_MILLIS = 2000;
- /** Millis to wait for all three event listeners to be notified */
- private static final int ASYNC_EVENT_WAIT_MILLIS = 30000; // use Integer.MAX_VALUE for debugging
+ private final MembershipNotification joinAdapterNotification = new MembershipNotification();
+ private final MembershipNotification leftAdapterNotification = new MembershipNotification();
+ private final MembershipNotification crashedAdapterNotification = new MembershipNotification();
+
+ private final MembershipNotification joinClientNotification = new MembershipNotification();
+ private final MembershipNotification leftClientNotification = new MembershipNotification();
+ private final MembershipNotification crashedClientNotification = new MembershipNotification();
+
+ @ClassRule
+ public static DistributedRestoreSystemProperties distributedRestoreSystemProperties =
+ new DistributedRestoreSystemProperties();
@Before
- public void setTestToUseIpAddresses() {
+ public void setUp() throws Exception {
SocketCreator.resolve_dns = false;
SocketCreator.use_client_host_name = false;
- Invoke.invokeInEveryVM(() -> {
+ invokeInEveryVM(() -> {
SocketCreator.resolve_dns = false;
SocketCreator.use_client_host_name = false;
});
}
- @Override
- public final void postTearDownCacheTestCase() throws Exception {
+ @After
+ public void tearDown() throws Exception {
+ disconnectAllFromDS();
InternalClientMembership.unregisterAllListeners();
+ ServerConnection.setForceClientCrashEvent(false);
}
@Override
public Properties getDistributedSystemProperties() {
- Properties result = super.getDistributedSystemProperties();
- result.put(ConfigurationProperties.ENABLE_NETWORK_PARTITION_DETECTION, "false");
- return result;
+ Properties config = new Properties();
+ config.put(ENABLE_NETWORK_PARTITION_DETECTION, "false");
+ return config;
}
/**
- * Tests wrapping of BridgeMembershipEvent fired as MembershipEvent.
+ * Tests wrapping of ClientMembershipEvent fired as MembershipEvent.
*/
@Test
public void testAdaptedBridgeEvents() throws Exception {
getSystem();
- final boolean[] fired = new boolean[1];
- final DistributedMember[] member = new DistributedMember[1];
- final String[] memberId = new String[1];
-
- UniversalMembershipListenerAdapter listener = new UniversalMembershipListenerAdapter() {
+ // apparently construction registers with ClientMembership
+ new UniversalMembershipListenerAdapter() {
@Override
- public synchronized void memberJoined(MembershipEvent event) {
- assertFalse(fired[0]); // assures no dupes
- assertNull(member[0]);
- assertNull(memberId[0]);
- fired[0] = true;
- member[0] = event.getDistributedMember();
- memberId[0] = event.getMemberId();
- notify();
+ public void memberJoined(final MembershipEvent event) {
+ joinAdapterNotification.notify(event);
}
-
- @Override
- public void memberLeft(MembershipEvent event) {}
-
- @Override
- public void memberCrashed(MembershipEvent event) {}
};
- DistributedMember clientJoined = new TestDistributedMember("clientJoined");
- InternalClientMembership.notifyClientJoined(clientJoined);
- synchronized (listener) {
- if (!fired[0]) {
- listener.wait(SYNC_ASYNC_EVENT_WAIT_MILLIS);
- }
- }
- assertTrue(fired[0]);
- assertEquals(clientJoined, member[0]);
- assertEquals(clientJoined.getId(), memberId[0]);
+ DistributedMember member = new FakeDistributedMember("member");
+ InternalClientMembership.notifyClientJoined(member);
+
+ joinAdapterNotification.awaitNotification(30, SECONDS);
+ joinAdapterNotification.validate(member);
}
/**
@@ -173,100 +176,57 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
public void testNoDuplicates() throws Exception {
getSystem();
- final boolean[] fired = new boolean[3];
- final DistributedMember[] member = new DistributedMember[3];
- final String[] memberId = new String[3];
-
- UniversalMembershipListenerAdapter listener = new UniversalMembershipListenerAdapter() {
+ // apparently construction registers with ClientMembership
+ new UniversalMembershipListenerAdapter() {
@Override
- public synchronized void memberJoined(MembershipEvent event) {
- assertFalse(fired[JOINED]);
- assertNull(member[JOINED]);
- assertNull(memberId[JOINED]);
- fired[JOINED] = true;
- member[JOINED] = event.getDistributedMember();
- memberId[JOINED] = event.getMemberId();
- notify();
+ public void memberJoined(final MembershipEvent event) {
+ joinAdapterNotification.notify(event);
}
@Override
- public synchronized void memberLeft(MembershipEvent event) {
- assertFalse(fired[LEFT]);
- assertNull(member[LEFT]);
- assertNull(memberId[LEFT]);
- fired[LEFT] = true;
- member[LEFT] = event.getDistributedMember();
- memberId[LEFT] = event.getMemberId();
- notify();
+ public void memberLeft(final MembershipEvent event) {
+ joinAdapterNotification.notify(event);
}
@Override
- public synchronized void memberCrashed(MembershipEvent event) {
- assertFalse(fired[CRASHED]); // assures no dupes
- assertNull(member[CRASHED]);
- assertNull(memberId[CRASHED]);
- fired[CRASHED] = true;
- member[CRASHED] = event.getDistributedMember();
- memberId[CRASHED] = event.getMemberId();
- notify();
+ public void memberCrashed(final MembershipEvent event) {
+ joinAdapterNotification.notify(event);
}
};
- DistributedMember memberA = new TestDistributedMember("memberA");
- ServerLocation serverA = new ServerLocation("serverA", 0);
+ DistributedMember member = new FakeDistributedMember("member");
// first join
- InternalClientMembership.notifyClientJoined(memberA);
- synchronized (listener) {
- if (!fired[JOINED]) {
- listener.wait(SYNC_ASYNC_EVENT_WAIT_MILLIS);
- }
- }
- assertTrue(fired[JOINED]);
- assertEquals(memberA, member[JOINED]);
- assertEquals(memberA.getId(), memberId[JOINED]);
- fired[JOINED] = false;
- member[JOINED] = null;
- memberId[JOINED] = null;
+ InternalClientMembership.notifyClientJoined(member);
+
+ joinAdapterNotification.awaitNotification(30, SECONDS);
+ joinAdapterNotification.validate(member);
+ joinAdapterNotification.reset();
// duplicate join
- InternalClientMembership.notifyClientJoined(memberA);
- Wait.pause(BRIEF_PAUSE_MILLIS);
- assertFalse(fired[JOINED]);
- assertNull(member[JOINED]);
- assertNull(memberId[JOINED]);
+ InternalClientMembership.notifyClientJoined(member);
+
+ joinAdapterNotification.awaitWithoutNotification(5, SECONDS);
+ joinAdapterNotification.validateNotNotified();
// first left
- InternalClientMembership.notifyClientLeft(memberA);
- synchronized (listener) {
- if (!fired[LEFT]) {
- listener.wait(SYNC_ASYNC_EVENT_WAIT_MILLIS);
- }
- }
- assertTrue(fired[LEFT]);
- assertEquals(memberA, member[LEFT]);
- assertEquals(memberA.getId(), memberId[LEFT]);
- fired[LEFT] = false;
- member[LEFT] = null;
- memberId[LEFT] = null;
+ InternalClientMembership.notifyClientLeft(member);
+
+ joinAdapterNotification.awaitNotification(30, SECONDS);
+ joinAdapterNotification.validate(member);
+ joinAdapterNotification.reset();
// duplicate left
- InternalClientMembership.notifyClientLeft(memberA);
- Wait.pause(BRIEF_PAUSE_MILLIS);
- assertFalse(fired[LEFT]);
- assertNull(member[LEFT]);
- assertNull(memberId[LEFT]);
+ InternalClientMembership.notifyClientLeft(member);
+
+ joinAdapterNotification.awaitWithoutNotification(5, SECONDS);
+ joinAdapterNotification.validateNotNotified();
// rejoin
- InternalClientMembership.notifyClientJoined(memberA);
- synchronized (listener) {
- if (!fired[JOINED]) {
- listener.wait(SYNC_ASYNC_EVENT_WAIT_MILLIS);
- }
- }
- assertTrue(fired[JOINED]);
- assertEquals(memberA, member[JOINED]);
- assertEquals(memberA.getId(), memberId[JOINED]);
+ InternalClientMembership.notifyClientJoined(member);
+
+ joinAdapterNotification.awaitNotification(30, SECONDS);
+ joinAdapterNotification.validate(member);
}
/**
@@ -274,178 +234,82 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
*/
@Test
public void testLonerClientEventsInServer() throws Exception {
- try {
- doTestLonerClientEventsInServer();
- } finally {
- disconnectAllFromDS();
- }
- }
-
- private void doTestLonerClientEventsInServer() throws Exception {
- final boolean[] firedSystem = new boolean[3];
- final DistributedMember[] memberSystem = new DistributedMember[3];
- final String[] memberIdSystem = new String[3];
- final boolean[] isClientSystem = new boolean[3];
-
- final boolean[] firedAdapter = new boolean[3];
- final DistributedMember[] memberAdapter = new DistributedMember[3];
- final String[] memberIdAdapter = new String[3];
- final boolean[] isClientAdapter = new boolean[3];
-
- final boolean[] firedBridge = new boolean[3];
- final DistributedMember[] memberBridge = new DistributedMember[3];
- final String[] memberIdBridge = new String[3];
- final boolean[] isClientBridge = new boolean[3];
-
MembershipListener systemListener = new MembershipListener() {
@Override
- public synchronized void memberJoined(MembershipEvent event) {
- assertFalse(firedSystem[JOINED]);
- assertNull(memberSystem[JOINED]);
- assertNull(memberIdSystem[JOINED]);
- firedSystem[JOINED] = true;
- memberSystem[JOINED] = event.getDistributedMember();
- memberIdSystem[JOINED] = event.getMemberId();
- notify();
+ public void memberJoined(final MembershipEvent event) {
+ joinSystemNotification.notify(event);
}
@Override
- public synchronized void memberLeft(MembershipEvent event) {
- assertFalse(firedSystem[LEFT]);
- assertNull(memberSystem[LEFT]);
- assertNull(memberIdSystem[LEFT]);
- firedSystem[LEFT] = true;
- memberSystem[LEFT] = event.getDistributedMember();
- memberIdSystem[LEFT] = event.getMemberId();
- notify();
+ public void memberLeft(final MembershipEvent event) {
+ leftSystemNotification.notify(event);
}
@Override
- public synchronized void memberCrashed(MembershipEvent event) {
- assertFalse(firedSystem[CRASHED]);
- assertNull(memberSystem[CRASHED]);
- assertNull(memberIdSystem[CRASHED]);
- firedSystem[CRASHED] = true;
- memberSystem[CRASHED] = event.getDistributedMember();
- memberIdSystem[CRASHED] = event.getMemberId();
- notify();
+ public void memberCrashed(final MembershipEvent event) {
+ crashedSystemNotification.notify(event);
}
};
UniversalMembershipListenerAdapter adapter = new UniversalMembershipListenerAdapter() {
@Override
- public synchronized void memberJoined(MembershipEvent event) {
- assertFalse(firedAdapter[JOINED]);
- assertNull(memberAdapter[JOINED]);
- assertNull(memberIdAdapter[JOINED]);
- assertFalse(isClientAdapter[JOINED]);
- firedAdapter[JOINED] = true;
- memberAdapter[JOINED] = event.getDistributedMember();
- memberIdAdapter[JOINED] = event.getMemberId();
- isClientAdapter[JOINED] =
- ((UniversalMembershipListenerAdapter.AdaptedMembershipEvent) event).isClient();
- notify();
+ public void memberJoined(final MembershipEvent event) {
+ joinAdapterNotification.notify((AdaptedMembershipEvent) event);
}
@Override
- public synchronized void memberLeft(MembershipEvent event) {
- assertFalse(firedAdapter[LEFT]);
- assertNull(memberAdapter[LEFT]);
- assertNull(memberIdAdapter[LEFT]);
- assertFalse(isClientAdapter[LEFT]);
- firedAdapter[LEFT] = true;
- memberAdapter[LEFT] = event.getDistributedMember();
- memberIdAdapter[LEFT] = event.getMemberId();
- isClientAdapter[LEFT] =
- ((UniversalMembershipListenerAdapter.AdaptedMembershipEvent) event).isClient();
- notify();
+ public void memberLeft(final MembershipEvent event) {
+ leftAdapterNotification.notify((AdaptedMembershipEvent) event);
}
@Override
- public synchronized void memberCrashed(MembershipEvent event) {
- assertFalse(firedAdapter[CRASHED]);
- assertNull(memberAdapter[CRASHED]);
- assertNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
- firedAdapter[CRASHED] = true;
- memberAdapter[CRASHED] = event.getDistributedMember();
- memberIdAdapter[CRASHED] = event.getMemberId();
- isClientAdapter[CRASHED] =
- ((UniversalMembershipListenerAdapter.AdaptedMembershipEvent) event).isClient();
- notify();
+ public synchronized void memberCrashed(final MembershipEvent event) {
+ crashedAdapterNotification.notify((AdaptedMembershipEvent) event);
}
};
ClientMembershipListener bridgeListener = new ClientMembershipListener() {
@Override
- public synchronized void memberJoined(ClientMembershipEvent event) {
- assertFalse(firedBridge[JOINED]);
- assertNull(memberBridge[JOINED]);
- assertNull(memberIdBridge[JOINED]);
- assertFalse(isClientBridge[JOINED]);
- firedBridge[JOINED] = true;
- memberBridge[JOINED] = event.getMember();
- memberIdBridge[JOINED] = event.getMemberId();
- isClientBridge[JOINED] = event.isClient();
- notify();
+ public void memberJoined(final ClientMembershipEvent event) {
+ joinClientNotification.notify(event);
}
@Override
- public synchronized void memberLeft(ClientMembershipEvent event) {
- assertFalse(firedBridge[LEFT]);
- assertNull(memberBridge[LEFT]);
- assertNull(memberIdBridge[LEFT]);
- assertFalse(isClientBridge[LEFT]);
- firedBridge[LEFT] = true;
- memberBridge[LEFT] = event.getMember();
- memberIdBridge[LEFT] = event.getMemberId();
- isClientBridge[LEFT] = event.isClient();
- notify();
+ public void memberLeft(final ClientMembershipEvent event) {
+ leftClientNotification.notify(event);
}
@Override
- public synchronized void memberCrashed(ClientMembershipEvent event) {
- assertFalse(firedBridge[CRASHED]);
- assertNull(memberBridge[CRASHED]);
- assertNull(memberIdBridge[CRASHED]);
- assertFalse(isClientBridge[CRASHED]);
- firedBridge[CRASHED] = true;
- memberBridge[CRASHED] = event.getMember();
- memberIdBridge[CRASHED] = event.getMemberId();
- isClientBridge[CRASHED] = event.isClient();
- notify();
+ public void memberCrashed(final ClientMembershipEvent event) {
+ crashedClientNotification.notify(event);
}
};
- final Host host = Host.getHost(0);
- final VM vm0 = host.getVM(0);
- final String name = this.getUniqueName();
- final int[] ports = new int[1];
+ Host host = Host.getHost(0);
+ VM vm0 = host.getVM(0);
+ String name = this.getUniqueName();
+ int[] ports = new int[1];
- // create BridgeServer in controller vm...
- System.out.println("[testLonerClientEventsInServer] Create BridgeServer");
+ // create CacheServer in controller vm...
getSystem();
+
AttributesFactory factory = new AttributesFactory();
factory.setScope(Scope.LOCAL);
Region region = createRegion(name, factory.create());
- assertNotNull(region);
- assertNotNull(getRootRegion().getSubregion(name));
+
+ assertThat(region).isNotNull();
+ assertThat(getRootRegion().getSubregion(name)).isNotNull();
ports[0] = startBridgeServer(0);
- assertTrue(ports[0] != 0);
- final DistributedMember serverMember = getMemberId();
- final String serverMemberId = serverMember.getId();
- final Properties serverProperties = getSystem().getProperties();
+ assertThat(ports[0] != 0).isTrue();
- System.out.println("[testLonerClientEventsInServer] ports[0]=" + ports[0]);
- System.out.println("[testLonerClientEventsInServer] serverMemberId=" + serverMemberId);
- System.out.println("[testLonerClientEventsInServer] serverMember=" + serverMember);
+ DistributedMember serverMember = getMemberId();
+ String serverMemberId = serverMember.getId();
// register the bridge listener
ClientMembership.registerClientMembershipListener(bridgeListener);
- GemFireCacheImpl cache = GemFireCacheImpl.getExisting();
- assertNotNull(cache);
+ InternalCache cache = getInternalCache();
ManagementService service = ManagementService.getExistingManagementService(cache);
// register the system listener
service.addMembershipListener(systemListener);
@@ -453,11 +317,9 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
// register the universal adapter. Not required as this test is only for BridgeClient test
adapter.registerMembershipListener(service);
-
SerializableCallable createBridgeClient = new SerializableCallable("Create bridge client") {
@Override
public Object call() {
- System.out.println("[testLonerClientEventsInServer] create bridge client");
Properties config = new Properties();
config.setProperty(MCAST_PORT, "0");
config.setProperty(LOCATORS, "");
@@ -465,281 +327,97 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
getSystem(config);
AttributesFactory factory = new AttributesFactory();
factory.setScope(Scope.LOCAL);
- ClientServerTestCase.configureConnectionPool(factory, NetworkUtils.getServerHostName(host),
- ports, false, -1, -1, null);
+ ClientServerTestCase.configureConnectionPool(factory, getServerHostName(host), ports, false,
+ -1, -1, null);
createRegion(name, factory.create());
- assertNotNull(getRootRegion().getSubregion(name));
+ assertThat(getRootRegion().getSubregion(name)).isNotNull();
return getMemberId();
}
};
-
// create bridge client in vm0...
DistributedMember clientMember = (DistributedMember) vm0.invoke(createBridgeClient);
String clientMemberId = clientMember.getId();
// should trigger both adapter and bridge listener but not system listener
- synchronized (adapter) {
- if (!firedAdapter[JOINED]) {
- adapter.wait(ASYNC_EVENT_WAIT_MILLIS);
- }
- }
- synchronized (bridgeListener) {
- if (!firedBridge[JOINED]) {
- bridgeListener.wait(ASYNC_EVENT_WAIT_MILLIS);
- }
- }
+ joinAdapterNotification.awaitNotification(30, SECONDS);
+ joinClientNotification.awaitNotification(30, SECONDS);
- System.out.println("[testLonerClientEventsInServer] assert server detected client join");
- assertTrue(firedBridge[JOINED]);
- assertEquals(clientMember, memberBridge[JOINED]);
- // as of 6.1 the id can change when a bridge is created or a connection pool is created
- // assertIndexDetailsEquals(clientMemberId, memberIdBridge[JOINED]);
- assertTrue(isClientBridge[JOINED]);
- assertFalse(firedBridge[LEFT]);
- assertNull(memberBridge[LEFT]);
- assertNull(memberIdBridge[LEFT]);
- assertFalse(isClientBridge[LEFT]);
- assertFalse(firedBridge[CRASHED]);
- assertNull(memberBridge[CRASHED]);
- assertNull(memberIdBridge[CRASHED]);
- assertFalse(isClientBridge[CRASHED]);
- resetArraysForTesting(firedBridge, memberBridge, memberIdBridge, isClientBridge);
-
- assertFalse(firedSystem[JOINED]);
- assertNull(memberSystem[JOINED]);
- assertNull(memberIdSystem[JOINED]);
- assertFalse(isClientSystem[JOINED]);
- assertFalse(firedSystem[LEFT]);
- assertNull(memberSystem[LEFT]);
- assertNull(memberIdSystem[LEFT]);
- assertFalse(isClientSystem[LEFT]);
- assertFalse(firedSystem[CRASHED]);
- assertNull(memberSystem[CRASHED]);
- assertNull(memberIdSystem[CRASHED]);
- assertFalse(isClientSystem[CRASHED]);
- resetArraysForTesting(firedSystem, memberSystem, memberIdSystem, isClientSystem);
+ joinSystemNotification.validateNotNotified();
+ joinAdapterNotification.validate(clientMember);
+ joinClientNotification.validate(clientMember);
- assertTrue(firedAdapter[JOINED]);
- assertEquals(clientMember, memberAdapter[JOINED]);
- assertFalse(SocketCreator.resolve_dns);
- assertEquals(clientMemberId, memberIdAdapter[JOINED]);
- assertTrue(isClientAdapter[JOINED]);
- assertFalse(firedAdapter[LEFT]);
- assertNull(memberAdapter[LEFT]);
- assertNull(memberIdAdapter[LEFT]);
- assertFalse(isClientAdapter[LEFT]);
- assertFalse(firedAdapter[CRASHED]);
- assertNull(memberAdapter[CRASHED]);
- assertNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
- resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
+ joinSystemNotification.reset();
+ joinAdapterNotification.reset();
+ joinClientNotification.reset();
vm0.invoke(new SerializableRunnable("Wait for client to fully connect") {
+ @Override
public void run() {
- System.out.println("[testLonerClientEventsInServer] wait for client to fully connect");
- final String pl = getRootRegion().getSubregion(name).getAttributes().getPoolName();
- PoolImpl pi = (PoolImpl) PoolManager.find(pl);
- waitForClientToFullyConnect(pi);
+ String poolName = getRootRegion().getSubregion(name).getAttributes().getPoolName();
+ PoolImpl pool = (PoolImpl) PoolManager.find(poolName);
+ waitForClientToFullyConnect(pool);
}
});
vm0.invoke(new SerializableRunnable("Close bridge client region") {
+ @Override
public void run() {
- System.out.println("[testLonerClientEventsInServer] close bridge client region");
getRootRegion().getSubregion(name).close();
PoolManager.close();
}
});
- synchronized (adapter) {
- if (!firedAdapter[LEFT]) {
- adapter.wait(ASYNC_EVENT_WAIT_MILLIS);
- }
- }
- synchronized (bridgeListener) {
- if (!firedBridge[LEFT]) {
- bridgeListener.wait(ASYNC_EVENT_WAIT_MILLIS);
- }
- }
+ leftAdapterNotification.awaitNotification(30, SECONDS);
+ leftClientNotification.awaitNotification(30, SECONDS);
- System.out.println("[testLonerClientEventsInServer] assert server detected client left");
-
- assertFalse(firedBridge[JOINED]);
- assertNull(memberIdBridge[JOINED]);
- assertNull(memberBridge[JOINED]);
- assertFalse(isClientBridge[JOINED]);
- assertTrue(firedBridge[LEFT]);
- assertEquals(clientMember, memberBridge[LEFT]);
- assertEquals(clientMemberId, memberIdBridge[LEFT]);
- assertTrue(isClientBridge[LEFT]);
- assertFalse(firedBridge[CRASHED]);
- assertNull(memberBridge[CRASHED]);
- assertNull(memberIdBridge[CRASHED]);
- assertFalse(isClientBridge[CRASHED]);
- resetArraysForTesting(firedBridge, memberBridge, memberIdBridge, isClientBridge);
+ leftSystemNotification.validateNotNotified();
+ leftAdapterNotification.validate(clientMember);
+ leftClientNotification.validate(clientMember);
- assertFalse(firedSystem[JOINED]);
- assertNull(memberSystem[JOINED]);
- assertNull(memberIdSystem[JOINED]);
- assertFalse(isClientSystem[JOINED]);
- assertFalse(firedSystem[LEFT]);
- assertNull(memberSystem[LEFT]);
- assertNull(memberIdSystem[LEFT]);
- assertFalse(isClientSystem[LEFT]);
- assertFalse(firedSystem[CRASHED]);
- assertNull(memberSystem[CRASHED]);
- assertNull(memberIdSystem[CRASHED]);
- assertFalse(isClientSystem[CRASHED]);
- resetArraysForTesting(firedSystem, memberSystem, memberIdSystem, isClientSystem);
-
- assertFalse(firedAdapter[JOINED]);
- assertNull(memberAdapter[JOINED]);
- assertNull(memberIdAdapter[JOINED]);
- assertFalse(isClientAdapter[JOINED]);
- assertTrue(firedAdapter[LEFT]);
- assertEquals(clientMember, memberAdapter[LEFT]);
- assertEquals(clientMemberId, memberIdAdapter[LEFT]);
- assertTrue(isClientAdapter[LEFT]);
- assertFalse(firedAdapter[CRASHED]);
- assertNull(memberAdapter[CRASHED]);
- assertNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
- resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
+ leftSystemNotification.reset();
+ leftAdapterNotification.reset();
+ leftClientNotification.reset();
// reconnect bridge client to test for crashed event
clientMember = (DistributedMember) vm0.invoke(createBridgeClient);
- clientMemberId = clientMember.getId();
- synchronized (adapter) {
- if (!firedAdapter[JOINED]) {
- adapter.wait(ASYNC_EVENT_WAIT_MILLIS);
- }
- }
- synchronized (bridgeListener) {
- if (!firedBridge[JOINED]) {
- bridgeListener.wait(ASYNC_EVENT_WAIT_MILLIS);
- }
- }
+ joinAdapterNotification.awaitNotification(30, SECONDS);
+ joinClientNotification.awaitNotification(30, SECONDS);
- System.out.println("[testLonerClientEventsInServer] assert server detected client re-join");
- assertTrue(firedBridge[JOINED]);
- assertEquals(clientMember, memberBridge[JOINED]);
- assertEquals(clientMemberId, memberIdBridge[JOINED]);
- assertTrue(isClientBridge[JOINED]);
- assertFalse(firedBridge[LEFT]);
- assertNull(memberBridge[LEFT]);
- assertNull(memberIdBridge[LEFT]);
- assertFalse(isClientBridge[LEFT]);
- assertFalse(firedBridge[CRASHED]);
- assertNull(memberBridge[CRASHED]);
- assertNull(memberIdBridge[CRASHED]);
- assertFalse(isClientBridge[CRASHED]);
- resetArraysForTesting(firedBridge, memberBridge, memberIdBridge, isClientBridge);
-
- assertFalse(firedSystem[JOINED]);
- assertNull(memberSystem[JOINED]);
- assertNull(memberIdSystem[JOINED]);
- assertFalse(isClientSystem[JOINED]);
- assertFalse(firedSystem[LEFT]);
- assertNull(memberSystem[LEFT]);
- assertNull(memberIdSystem[LEFT]);
- assertFalse(isClientSystem[LEFT]);
- assertFalse(firedSystem[CRASHED]);
- assertNull(memberSystem[CRASHED]);
- assertNull(memberIdSystem[CRASHED]);
- assertFalse(isClientSystem[CRASHED]);
- resetArraysForTesting(firedSystem, memberSystem, memberIdSystem, isClientSystem);
+ joinSystemNotification.validateNotNotified();
+ joinAdapterNotification.validate(clientMember);
+ joinClientNotification.validate(clientMember);
- assertTrue(firedAdapter[JOINED]);
- assertEquals(clientMember, memberAdapter[JOINED]);
- assertEquals(clientMemberId, memberIdAdapter[JOINED]);
- assertTrue(isClientAdapter[JOINED]);
- assertFalse(firedAdapter[LEFT]);
- assertNull(memberAdapter[LEFT]);
- assertNull(memberIdAdapter[LEFT]);
- assertFalse(isClientAdapter[LEFT]);
- assertFalse(firedAdapter[CRASHED]);
- assertNull(memberAdapter[CRASHED]);
- assertNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
- resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
+ joinSystemNotification.reset();
+ joinAdapterNotification.reset();
+ joinClientNotification.reset();
vm0.invoke(new SerializableRunnable("Wait for client to fully connect") {
+ @Override
public void run() {
- System.out.println("[testLonerClientEventsInServer] wait for client to fully connect");
- final String pl = getRootRegion().getSubregion(name).getAttributes().getPoolName();
- PoolImpl pi = (PoolImpl) PoolManager.find(pl);
- waitForClientToFullyConnect(pi);
+ String poolName = getRootRegion().getSubregion(name).getAttributes().getPoolName();
+ PoolImpl pool = (PoolImpl) PoolManager.find(poolName);
+ waitForClientToFullyConnect(pool);
}
});
ServerConnection.setForceClientCrashEvent(true);
- try {
- vm0.invoke(new SerializableRunnable("Stop bridge client") {
- public void run() {
- System.out.println("[testLonerClientEventsInServer] Stop bridge client");
- getRootRegion().getSubregion(name).close();
- PoolManager.close();
- }
- });
- synchronized (adapter) {
- if (!firedAdapter[CRASHED]) {
- adapter.wait(ASYNC_EVENT_WAIT_MILLIS);
- }
- }
- synchronized (bridgeListener) {
- if (!firedBridge[CRASHED]) {
- bridgeListener.wait(ASYNC_EVENT_WAIT_MILLIS);
- }
+ vm0.invoke(new SerializableRunnable("Stop bridge client") {
+ @Override
+ public void run() {
+ getRootRegion().getSubregion(name).close();
+ PoolManager.close();
}
+ });
- System.out.println("[testLonerClientEventsInServer] assert server detected client crashed");
- assertFalse(firedBridge[JOINED]);
- assertNull(memberIdBridge[JOINED]);
- assertNull(memberBridge[JOINED]);
- assertFalse(isClientBridge[JOINED]);
- assertFalse(firedBridge[LEFT]);
- assertNull(memberIdBridge[LEFT]);
- assertNull(memberBridge[LEFT]);
- assertFalse(isClientBridge[LEFT]);
- assertTrue(firedBridge[CRASHED]);
- assertEquals(clientMember, memberBridge[CRASHED]);
- assertEquals(clientMemberId, memberIdBridge[CRASHED]);
- assertTrue(isClientBridge[CRASHED]);
- // resetArraysForTesting(firedBridge, memberIdBridge, isClientBridge);
-
- assertFalse(firedSystem[JOINED]);
- assertNull(memberSystem[JOINED]);
- assertNull(memberIdSystem[JOINED]);
- assertFalse(isClientSystem[JOINED]);
- assertFalse(firedSystem[LEFT]);
- assertNull(memberSystem[LEFT]);
- assertNull(memberIdSystem[LEFT]);
- assertFalse(isClientSystem[LEFT]);
- assertFalse(firedSystem[CRASHED]);
- assertNull(memberSystem[CRASHED]);
- assertNull(memberIdSystem[CRASHED]);
- assertFalse(isClientSystem[CRASHED]);
- // resetArraysForTesting(firedSystem, memberIdSystem, isClientSystem);
-
- assertFalse(firedAdapter[JOINED]);
- assertNull(memberAdapter[JOINED]);
- assertNull(memberIdAdapter[JOINED]);
- assertFalse(isClientAdapter[JOINED]);
- assertFalse(firedAdapter[LEFT]);
- assertNull(memberAdapter[LEFT]);
- assertNull(memberIdAdapter[LEFT]);
- assertFalse(isClientAdapter[LEFT]);
- assertTrue(firedAdapter[CRASHED]);
- assertEquals(clientMember, memberAdapter[CRASHED]);
- assertEquals(clientMemberId, memberIdAdapter[CRASHED]);
- assertTrue(isClientAdapter[CRASHED]);
- // resetArraysForTesting(firedAdapter, memberIdAdapter, isClientAdapter);
- } finally {
- ServerConnection.setForceClientCrashEvent(false);
- }
+ crashedAdapterNotification.awaitNotification(30, SECONDS);
+ crashedClientNotification.awaitNotification(30, SECONDS);
+
+ crashedSystemNotification.validateNotNotified();
+ crashedAdapterNotification.validate(clientMember);
+ crashedClientNotification.validate(clientMember);
}
/**
@@ -747,154 +425,142 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
*/
@Test
public void testSystemClientEventsInServer() throws Exception {
- try {
- doTestSystemClientEventsInServer();
- } finally {
- disconnectAllFromDS();
- }
- }
+ boolean[] firedSystem = new boolean[3];
+ DistributedMember[] memberSystem = new DistributedMember[3];
+ String[] memberIdSystem = new String[3];
+ boolean[] isClientSystem = new boolean[3];
- private void doTestSystemClientEventsInServer() throws Exception {
- final boolean[] firedSystem = new boolean[3];
- final DistributedMember[] memberSystem = new DistributedMember[3];
- final String[] memberIdSystem = new String[3];
- final boolean[] isClientSystem = new boolean[3];
+ boolean[] firedAdapter = new boolean[3];
+ DistributedMember[] memberAdapter = new DistributedMember[3];
+ String[] memberIdAdapter = new String[3];
+ boolean[] isClientAdapter = new boolean[3];
- final boolean[] firedAdapter = new boolean[3];
- final DistributedMember[] memberAdapter = new DistributedMember[3];
- final String[] memberIdAdapter = new String[3];
- final boolean[] isClientAdapter = new boolean[3];
+ boolean[] firedBridge = new boolean[3];
+ DistributedMember[] memberBridge = new DistributedMember[3];
+ String[] memberIdBridge = new String[3];
+ boolean[] isClientBridge = new boolean[3];
- final boolean[] firedBridge = new boolean[3];
- final DistributedMember[] memberBridge = new DistributedMember[3];
- final String[] memberIdBridge = new String[3];
- final boolean[] isClientBridge = new boolean[3];
-
- final boolean[] firedSystemDuplicate = new boolean[3];
- final boolean[] firedAdapterDuplicate = new boolean[3];
- final boolean[] firedBridgeDuplicate = new boolean[3];
+ boolean[] firedSystemDuplicate = new boolean[3];
+ boolean[] firedAdapterDuplicate = new boolean[3];
+ boolean[] firedBridgeDuplicate = new boolean[3];
MembershipListener systemListener = new MembershipListener() {
+ @Override
public synchronized void memberJoined(MembershipEvent event) {
firedSystemDuplicate[JOINED] = firedSystem[JOINED];
firedSystem[JOINED] = true;
memberSystem[JOINED] = event.getDistributedMember();
memberIdSystem[JOINED] = event.getMemberId();
- notify();
+ notifyAll();
}
+ @Override
public synchronized void memberLeft(MembershipEvent event) {
firedSystemDuplicate[LEFT] = firedSystem[LEFT];
firedSystem[LEFT] = true;
memberSystem[LEFT] = event.getDistributedMember();
memberIdSystem[LEFT] = event.getMemberId();
- notify();
+ notifyAll();
}
+ @Override
public synchronized void memberCrashed(MembershipEvent event) {
firedSystemDuplicate[CRASHED] = firedSystem[CRASHED];
firedSystem[CRASHED] = true;
memberSystem[CRASHED] = event.getDistributedMember();
memberIdSystem[CRASHED] = event.getMemberId();
- notify();
+ notifyAll();
}
};
UniversalMembershipListenerAdapter adapter = new UniversalMembershipListenerAdapter() {
@Override
public synchronized void memberJoined(MembershipEvent event) {
- getLogWriter()
- .info("[doTestSystemClientEventsInServer] memberJoined >" + event.getMemberId() + "<");
firedAdapterDuplicate[JOINED] = firedAdapter[JOINED];
firedAdapter[JOINED] = true;
memberAdapter[JOINED] = event.getDistributedMember();
memberIdAdapter[JOINED] = event.getMemberId();
- if (event instanceof UniversalMembershipListenerAdapter.AdaptedMembershipEvent) {
- isClientAdapter[JOINED] =
- ((UniversalMembershipListenerAdapter.AdaptedMembershipEvent) event).isClient();
+ if (event instanceof AdaptedMembershipEvent) {
+ isClientAdapter[JOINED] = ((AdaptedMembershipEvent) event).isClient();
}
- notify();
+ notifyAll();
}
@Override
public synchronized void memberLeft(MembershipEvent event) {
- getLogWriter()
- .info("[doTestSystemClientEventsInServer] memberLeft >" + event.getMemberId() + "<");
firedAdapterDuplicate[LEFT] = firedAdapter[LEFT];
firedAdapter[LEFT] = true;
memberAdapter[LEFT] = event.getDistributedMember();
memberIdAdapter[LEFT] = event.getMemberId();
- if (event instanceof UniversalMembershipListenerAdapter.AdaptedMembershipEvent) {
- isClientAdapter[LEFT] =
- ((UniversalMembershipListenerAdapter.AdaptedMembershipEvent) event).isClient();
+ if (event instanceof AdaptedMembershipEvent) {
+ isClientAdapter[LEFT] = ((AdaptedMembershipEvent) event).isClient();
}
- notify();
+ notifyAll();
}
@Override
public synchronized void memberCrashed(MembershipEvent event) {
- getLogWriter()
- .info("[doTestSystemClientEventsInServer] memberCrashed >" + event.getMemberId() + "<");
firedAdapterDuplicate[CRASHED] = firedAdapter[CRASHED];
firedAdapter[CRASHED] = true;
memberAdapter[CRASHED] = event.getDistributedMember();
memberIdAdapter[CRASHED] = event.getMemberId();
- if (event instanceof UniversalMembershipListenerAdapter.AdaptedMembershipEvent) {
- isClientAdapter[CRASHED] =
- ((UniversalMembershipListenerAdapter.AdaptedMembershipEvent) event).isClient();
+ if (event instanceof AdaptedMembershipEvent) {
+ isClientAdapter[CRASHED] = ((AdaptedMembershipEvent) event).isClient();
}
- notify();
+ notifyAll();
}
};
ClientMembershipListener bridgeListener = new ClientMembershipListener() {
+ @Override
public synchronized void memberJoined(ClientMembershipEvent event) {
firedBridgeDuplicate[JOINED] = firedBridge[JOINED];
firedBridge[JOINED] = true;
memberBridge[JOINED] = event.getMember();
memberIdBridge[JOINED] = event.getMemberId();
isClientBridge[JOINED] = event.isClient();
- notify();
+ notifyAll();
}
+ @Override
public synchronized void memberLeft(ClientMembershipEvent event) {
firedBridgeDuplicate[LEFT] = firedBridge[LEFT];
firedBridge[LEFT] = true;
memberBridge[LEFT] = event.getMember();
memberIdBridge[LEFT] = event.getMemberId();
isClientBridge[LEFT] = event.isClient();
- notify();
+ notifyAll();
}
+ @Override
public synchronized void memberCrashed(ClientMembershipEvent event) {
firedBridgeDuplicate[CRASHED] = firedBridge[CRASHED];
firedBridge[CRASHED] = true;
memberBridge[CRASHED] = event.getMember();
memberIdBridge[CRASHED] = event.getMemberId();
isClientBridge[CRASHED] = event.isClient();
- notify();
+ notifyAll();
}
};
- final Host host = Host.getHost(0);
- final VM vm0 = host.getVM(0);
- final String name = this.getUniqueName();
- final int[] ports = new int[1];
+ Host host = Host.getHost(0);
+ VM vm0 = host.getVM(0);
+ String name = this.getUniqueName();
+ int[] ports = new int[1];
- // create BridgeServer in controller vm...
- System.out.println("[doTestSystemClientEventsInServer] Create BridgeServer");
+ // create CacheServer in controller vm...
getSystem();
AttributesFactory factory = new AttributesFactory();
factory.setScope(Scope.LOCAL);
Region region = createRegion(name, factory.create());
- assertNotNull(region);
- assertNotNull(getRootRegion().getSubregion(name));
+ assertThat(region).isNotNull();
+ assertThat(getRootRegion().getSubregion(name)).isNotNull();
ports[0] = startBridgeServer(0);
- assertTrue(ports[0] != 0);
- final DistributedMember serverMember = getMemberId();
- final String serverMemberId = serverMember.getId();
- final Properties serverProperties = getSystem().getProperties();
+ assertThat(ports[0] != 0).isTrue();
+ DistributedMember serverMember = getMemberId();
+ String serverMemberId = serverMember.getId();
+ Properties serverProperties = getSystem().getProperties();
// Below removed properties are already got copied as cluster SSL properties
serverProperties.remove(CLUSTER_SSL_ENABLED);
@@ -902,15 +568,10 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
serverProperties.remove(CLUSTER_SSL_PROTOCOLS);
serverProperties.remove(CLUSTER_SSL_REQUIRE_AUTHENTICATION);
- System.out.println("[doTestSystemClientEventsInServer] ports[0]=" + ports[0]);
- System.out.println("[doTestSystemClientEventsInServer] serverMemberId=" + serverMemberId);
- System.out.println("[doTestSystemClientEventsInServer] serverMember=" + serverMember);
-
// register the bridge listener
ClientMembership.registerClientMembershipListener(bridgeListener);
- GemFireCacheImpl cache = GemFireCacheImpl.getExisting();
- assertNotNull(cache);
+ InternalCache cache = getInternalCache();
ManagementService service = ManagementService.getExistingManagementService(cache);
// register the system listener
service.addMembershipListener(systemListener);
@@ -918,20 +579,18 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
// register the universal adapter.
adapter.registerMembershipListener(service);
-
SerializableCallable createBridgeClient = new SerializableCallable("Create bridge client") {
@Override
public Object call() {
System.setProperty(RESTRICT_MEMBERSHIP_PORT_RANGE, "false");
- System.out.println("[doTestSystemClientEventsInServer] create system bridge client");
- assertTrue(getSystem(serverProperties).isConnected());
- assertFalse(getCache().isClosed());
+ assertThat(getSystem(serverProperties).isConnected()).isTrue();
+ assertThat(getCache().isClosed()).isFalse();
AttributesFactory factory = new AttributesFactory();
factory.setScope(Scope.LOCAL);
- ClientServerTestCase.configureConnectionPool(factory, NetworkUtils.getServerHostName(host),
- ports, false, -1, -1, null);
+ ClientServerTestCase.configureConnectionPool(factory, getServerHostName(host), ports, false,
+ -1, -1, null);
createRegion(name, factory.create());
- assertNotNull(getRootRegion().getSubregion(name));
+ assertThat(getRootRegion().getSubregion(name)).isNotNull();
return getMemberId();
}
};
@@ -957,57 +616,56 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
}
}
- System.out.println("[doTestSystemClientEventsInServer] assert server detected client join");
assertArrayFalse(firedSystemDuplicate);
assertArrayFalse(firedAdapterDuplicate);
assertArrayFalse(firedBridgeDuplicate);
- assertTrue(firedBridge[JOINED]);
- assertEquals(clientMember, memberBridge[JOINED]);
- assertEquals(clientMemberId, memberIdBridge[JOINED]);
- assertTrue(isClientBridge[JOINED]);
- assertFalse(firedBridge[LEFT]);
- assertNull(memberBridge[LEFT]);
- assertNull(memberIdBridge[LEFT]);
- assertFalse(isClientBridge[LEFT]);
- assertFalse(firedBridge[CRASHED]);
- assertNull(memberBridge[CRASHED]);
- assertNull(memberIdBridge[CRASHED]);
- assertFalse(isClientBridge[CRASHED]);
+ assertThat(firedBridge[JOINED]).isTrue();
+ assertThat(memberBridge[JOINED]).isEqualTo(clientMember);
+ assertThat(memberIdBridge[JOINED]).isEqualTo(clientMemberId);
+ assertThat(isClientBridge[JOINED]).isTrue();
+ assertThat(firedBridge[LEFT]).isFalse();
+ assertThat(memberBridge[LEFT]).isNull();
+ assertThat(memberIdBridge[LEFT]).isNull();
+ assertThat(isClientBridge[LEFT]).isFalse();
+ assertThat(firedBridge[CRASHED]).isFalse();
+ assertThat(memberBridge[CRASHED]).isNull();
+ assertThat(memberIdBridge[CRASHED]).isNull();
+ assertThat(isClientBridge[CRASHED]).isFalse();
resetArraysForTesting(firedBridge, memberBridge, memberIdBridge, isClientBridge);
- assertTrue(firedSystem[JOINED]);
- assertEquals(clientMember, memberSystem[JOINED]);
- assertEquals(clientMemberId, memberIdSystem[JOINED]);
- assertFalse(isClientSystem[JOINED]);
- assertFalse(firedSystem[LEFT]);
- assertNull(memberSystem[LEFT]);
- assertNull(memberIdSystem[LEFT]);
- assertFalse(isClientSystem[LEFT]);
- assertFalse(firedSystem[CRASHED]);
- assertNull(memberSystem[CRASHED]);
- assertNull(memberIdSystem[CRASHED]);
- assertFalse(isClientSystem[CRASHED]);
+ assertThat(firedSystem[JOINED]).isTrue();
+ assertThat(memberSystem[JOINED]).isEqualTo(clientMember);
+ assertThat(memberIdSystem[JOINED]).isEqualTo(clientMemberId);
+ assertThat(isClientSystem[JOINED]).isFalse();
+ assertThat(firedSystem[LEFT]).isFalse();
+ assertThat(memberSystem[LEFT]).isNull();
+ assertThat(memberIdSystem[LEFT]).isNull();
+ assertThat(isClientSystem[LEFT]).isFalse();
+ assertThat(firedSystem[CRASHED]).isFalse();
+ assertThat(memberSystem[CRASHED]).isNull();
+ assertThat(memberIdSystem[CRASHED]).isNull();
+ assertThat(isClientSystem[CRASHED]).isFalse();
resetArraysForTesting(firedSystem, memberSystem, memberIdSystem, isClientSystem);
- assertTrue(firedAdapter[JOINED]);
- assertEquals(clientMember, memberAdapter[JOINED]);
- assertEquals(clientMemberId, memberIdAdapter[JOINED]);
- // assertTrue(isClientAdapter[JOINED]);
- assertFalse(firedAdapter[LEFT]);
- assertNull(memberAdapter[LEFT]);
- assertNull(memberIdAdapter[LEFT]);
- assertFalse(isClientAdapter[LEFT]);
- assertFalse(firedAdapter[CRASHED]);
- assertNull(memberAdapter[CRASHED]);
- assertNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
+ assertThat(firedAdapter[JOINED]).isTrue();
+ assertThat(memberAdapter[JOINED]).isEqualTo(clientMember);
+ assertThat(memberIdAdapter[JOINED]).isEqualTo(clientMemberId);
+ // assertThat(isClientAdapter[JOINED]).isTrue();
+ assertThat(firedAdapter[LEFT]).isFalse();
+ assertThat(memberAdapter[LEFT]).isNull();
+ assertThat(memberIdAdapter[LEFT]).isNull();
+ assertThat(isClientAdapter[LEFT]).isFalse();
+ assertThat(firedAdapter[CRASHED]).isFalse();
+ assertThat(memberAdapter[CRASHED]).isNull();
+ assertThat(memberIdAdapter[CRASHED]).isNull();
+ assertThat(isClientAdapter[CRASHED]).isFalse();
resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
vm0.invoke(new SerializableRunnable("Wait for client to fully connect") {
+ @Override
public void run() {
- System.out.println("[doTestSystemClientEventsInServer] wait for client to fully connect");
- final String pl = getRootRegion().getSubregion(name).getAttributes().getPoolName();
+ String pl = getRootRegion().getSubregion(name).getAttributes().getPoolName();
PoolImpl pi = (PoolImpl) PoolManager.find(pl);
waitForClientToFullyConnect(pi);
}
@@ -1015,8 +673,8 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
// close bridge client region
vm0.invoke(new SerializableRunnable("Close bridge client region") {
+ @Override
public void run() {
- System.out.println("[doTestSystemClientEventsInServer] close bridge client region");
getRootRegion().getSubregion(name).close();
PoolManager.close();
}
@@ -1033,51 +691,50 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
}
}
- System.out.println("[doTestSystemClientEventsInServer] assert server detected client left");
assertArrayFalse(firedSystemDuplicate);
assertArrayFalse(firedAdapterDuplicate);
assertArrayFalse(firedBridgeDuplicate);
- assertFalse(firedBridge[JOINED]);
- assertNull(memberIdBridge[JOINED]);
- assertNull(memberBridge[JOINED]);
- assertFalse(isClientBridge[JOINED]);
- assertTrue(firedBridge[LEFT]);
- assertEquals(clientMember, memberBridge[LEFT]);
- assertEquals(clientMemberId, memberIdBridge[LEFT]);
- assertTrue(isClientBridge[LEFT]);
- assertFalse(firedBridge[CRASHED]);
- assertNull(memberBridge[CRASHED]);
- assertNull(memberIdBridge[CRASHED]);
- assertFalse(isClientBridge[CRASHED]);
+ assertThat(firedBridge[JOINED]).isFalse();
+ assertThat(memberIdBridge[JOINED]).isNull();
+ assertThat(memberBridge[JOINED]).isNull();
+ assertThat(isClientBridge[JOINED]).isFalse();
+ assertThat(firedBridge[LEFT]).isTrue();
+ assertThat(memberBridge[LEFT]).isEqualTo(clientMember);
+ assertThat(memberIdBridge[LEFT]).isEqualTo(clientMemberId);
+ assertThat(isClientBridge[LEFT]).isTrue();
+ assertThat(firedBridge[CRASHED]).isFalse();
+ assertThat(memberBridge[CRASHED]).isNull();
+ assertThat(memberIdBridge[CRASHED]).isNull();
+ assertThat(isClientBridge[CRASHED]).isFalse();
resetArraysForTesting(firedBridge, memberBridge, memberIdBridge, isClientBridge);
- assertFalse(firedSystem[JOINED]);
- assertNull(memberSystem[JOINED]);
- assertNull(memberIdSystem[JOINED]);
- assertFalse(isClientSystem[JOINED]);
- assertFalse(firedSystem[LEFT]);
- assertNull(memberSystem[LEFT]);
- assertNull(memberIdSystem[LEFT]);
- assertFalse(isClientSystem[LEFT]);
- assertFalse(firedSystem[CRASHED]);
- assertNull(memberSystem[CRASHED]);
- assertNull(memberIdSystem[CRASHED]);
- assertFalse(isClientSystem[CRASHED]);
+ assertThat(firedSystem[JOINED]).isFalse();
+ assertThat(memberSystem[JOINED]).isNull();
+ assertThat(memberIdSystem[JOINED]).isNull();
+ assertThat(isClientSystem[JOINED]).isFalse();
+ assertThat(firedSystem[LEFT]).isFalse();
+ assertThat(memberSystem[LEFT]).isNull();
+ assertThat(memberIdSystem[LEFT]).isNull();
+ assertThat(isClientSystem[LEFT]).isFalse();
+ assertThat(firedSystem[CRASHED]).isFalse();
+ assertThat(memberSystem[CRASHED]).isNull();
+ assertThat(memberIdSystem[CRASHED]).isNull();
+ assertThat(isClientSystem[CRASHED]).isFalse();
resetArraysForTesting(firedSystem, memberSystem, memberIdSystem, isClientSystem);
- assertFalse(firedAdapter[JOINED]);
- assertNull(memberAdapter[JOINED]);
- assertNull(memberIdAdapter[JOINED]);
- assertFalse(isClientAdapter[JOINED]);
- assertTrue(firedAdapter[LEFT]);
- assertEquals(clientMember, memberAdapter[LEFT]);
- assertEquals(clientMemberId, memberIdAdapter[LEFT]);
- assertTrue(isClientAdapter[LEFT]);
- assertFalse(firedAdapter[CRASHED]);
- assertNull(memberAdapter[CRASHED]);
- assertNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
+ assertThat(firedAdapter[JOINED]).isFalse();
+ assertThat(memberAdapter[JOINED]).isNull();
+ assertThat(memberIdAdapter[JOINED]).isNull();
+ assertThat(isClientAdapter[JOINED]).isFalse();
+ assertThat(firedAdapter[LEFT]).isTrue();
+ assertThat(memberAdapter[LEFT]).isEqualTo(clientMember);
+ assertThat(memberIdAdapter[LEFT]).isEqualTo(clientMemberId);
+ assertThat(isClientAdapter[LEFT]).isTrue();
+ assertThat(firedAdapter[CRASHED]).isFalse();
+ assertThat(memberAdapter[CRASHED]).isNull();
+ assertThat(memberIdAdapter[CRASHED]).isNull();
+ assertThat(isClientAdapter[CRASHED]).isFalse();
resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
// reconnect bridge client
@@ -1095,66 +752,65 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
}
}
- System.out.println("[doTestSystemClientEventsInServer] assert server detected client re-join");
assertArrayFalse(firedSystemDuplicate);
assertArrayFalse(firedAdapterDuplicate);
assertArrayFalse(firedBridgeDuplicate);
- assertTrue(firedBridge[JOINED]);
- assertEquals(clientMember, memberBridge[JOINED]);
- assertEquals(clientMemberId, memberIdBridge[JOINED]);
- assertTrue(isClientBridge[JOINED]);
- assertFalse(firedBridge[LEFT]);
- assertNull(memberBridge[LEFT]);
- assertNull(memberIdBridge[LEFT]);
- assertFalse(isClientBridge[LEFT]);
- assertFalse(firedBridge[CRASHED]);
- assertNull(memberBridge[CRASHED]);
- assertNull(memberIdBridge[CRASHED]);
- assertFalse(isClientBridge[CRASHED]);
+ assertThat(firedBridge[JOINED]).isTrue();
+ assertThat(memberBridge[JOINED]).isEqualTo(clientMember);
+ assertThat(memberIdBridge[JOINED]).isEqualTo(clientMemberId);
+ assertThat(isClientBridge[JOINED]).isTrue();
+ assertThat(firedBridge[LEFT]).isFalse();
+ assertThat(memberBridge[LEFT]).isNull();
+ assertThat(memberIdBridge[LEFT]).isNull();
+ assertThat(isClientBridge[LEFT]).isFalse();
+ assertThat(firedBridge[CRASHED]).isFalse();
+ assertThat(memberBridge[CRASHED]).isNull();
+ assertThat(memberIdBridge[CRASHED]).isNull();
+ assertThat(isClientBridge[CRASHED]).isFalse();
resetArraysForTesting(firedBridge, memberBridge, memberIdBridge, isClientBridge);
- assertFalse(firedSystem[JOINED]);
- assertNull(memberSystem[JOINED]);
- assertNull(memberIdSystem[JOINED]);
- assertFalse(isClientSystem[JOINED]);
- assertFalse(firedSystem[LEFT]);
- assertNull(memberSystem[LEFT]);
- assertNull(memberIdSystem[LEFT]);
- assertFalse(isClientSystem[LEFT]);
- assertFalse(firedSystem[CRASHED]);
- assertNull(memberSystem[CRASHED]);
- assertNull(memberIdSystem[CRASHED]);
- assertFalse(isClientSystem[CRASHED]);
+ assertThat(firedSystem[JOINED]).isFalse();
+ assertThat(memberSystem[JOINED]).isNull();
+ assertThat(memberIdSystem[JOINED]).isNull();
+ assertThat(isClientSystem[JOINED]).isFalse();
+ assertThat(firedSystem[LEFT]).isFalse();
+ assertThat(memberSystem[LEFT]).isNull();
+ assertThat(memberIdSystem[LEFT]).isNull();
+ assertThat(isClientSystem[LEFT]).isFalse();
+ assertThat(firedSystem[CRASHED]).isFalse();
+ assertThat(memberSystem[CRASHED]).isNull();
+ assertThat(memberIdSystem[CRASHED]).isNull();
+ assertThat(isClientSystem[CRASHED]).isFalse();
resetArraysForTesting(firedSystem, memberSystem, memberIdSystem, isClientSystem);
- assertTrue(firedAdapter[JOINED]);
- assertEquals(clientMember, memberAdapter[JOINED]);
- assertEquals(clientMemberId, memberIdAdapter[JOINED]);
- // assertTrue(isClientAdapter[JOINED]);
- assertFalse(firedAdapter[LEFT]);
- assertNull(memberAdapter[LEFT]);
- assertNull(memberIdAdapter[LEFT]);
- assertFalse(isClientAdapter[LEFT]);
- assertFalse(firedAdapter[CRASHED]);
- assertNull(memberAdapter[CRASHED]);
- assertNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
+ assertThat(firedAdapter[JOINED]).isTrue();
+ assertThat(memberAdapter[JOINED]).isEqualTo(clientMember);
+ assertThat(memberIdAdapter[JOINED]).isEqualTo(clientMemberId);
+ // assertThat(isClientAdapter[JOINED]).isTrue();
+ assertThat(firedAdapter[LEFT]).isFalse();
+ assertThat(memberAdapter[LEFT]).isNull();
+ assertThat(memberIdAdapter[LEFT]).isNull();
+ assertThat(isClientAdapter[LEFT]).isFalse();
+ assertThat(firedAdapter[CRASHED]).isFalse();
+ assertThat(memberAdapter[CRASHED]).isNull();
+ assertThat(memberIdAdapter[CRASHED]).isNull();
+ assertThat(isClientAdapter[CRASHED]).isFalse();
resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
vm0.invoke(new SerializableRunnable("Wait for client to fully connect") {
+ @Override
public void run() {
- System.out.println("[doTestSystemClientEventsInServer] wait for client to fully connect");
- final String pl = getRootRegion().getSubregion(name).getAttributes().getPoolName();
- PoolImpl pi = (PoolImpl) PoolManager.find(pl);
- waitForClientToFullyConnect(pi);
+ String poolName = getRootRegion().getSubregion(name).getAttributes().getPoolName();
+ PoolImpl pool = (PoolImpl) PoolManager.find(poolName);
+ waitForClientToFullyConnect(pool);
}
});
// have bridge client disconnect from system
vm0.invoke(new SerializableRunnable("Disconnect bridge client") {
+ @Override
public void run() {
- System.out.println("[doTestSystemClientEventsInServer] disconnect bridge client");
closeCache();
disconnectFromDS();
}
@@ -1176,51 +832,50 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
}
}
- System.out.println("[doTestSystemClientEventsInServer] assert server detected client left");
assertArrayFalse(firedSystemDuplicate);
assertArrayFalse(firedAdapterDuplicate);
assertArrayFalse(firedBridgeDuplicate);
- assertFalse(firedBridge[JOINED]);
- assertNull(memberBridge[JOINED]);
- assertNull(memberIdBridge[JOINED]);
- assertFalse(isClientBridge[JOINED]);
- assertTrue(firedBridge[LEFT]);
- assertEquals(clientMember, memberBridge[LEFT]);
- assertEquals(clientMemberId, memberIdBridge[LEFT]);
- assertTrue(isClientBridge[LEFT]);
- assertFalse(firedBridge[CRASHED]);
- assertNull(memberBridge[CRASHED]);
- assertNull(memberIdBridge[CRASHED]);
- assertFalse(isClientBridge[CRASHED]);
+ assertThat(firedBridge[JOINED]).isFalse();
+ assertThat(memberBridge[JOINED]).isNull();
+ assertThat(memberIdBridge[JOINED]).isNull();
+ assertThat(isClientBridge[JOINED]).isFalse();
+ assertThat(firedBridge[LEFT]).isTrue();
+ assertThat(memberBridge[LEFT]).isEqualTo(clientMember);
+ assertThat(memberIdBridge[LEFT]).isEqualTo(clientMemberId);
+ assertThat(isClientBridge[LEFT]).isTrue();
+ assertThat(firedBridge[CRASHED]).isFalse();
+ assertThat(memberBridge[CRASHED]).isNull();
+ assertThat(memberIdBridge[CRASHED]).isNull();
+ assertThat(isClientBridge[CRASHED]).isFalse();
resetArraysForTesting(firedBridge, memberBridge, memberIdBridge, isClientBridge);
- assertFalse(firedSystem[JOINED]);
- assertNull(memberSystem[JOINED]);
- assertNull(memberIdSystem[JOINED]);
- assertFalse(isClientSystem[JOINED]);
- assertTrue(firedSystem[LEFT]);
- assertEquals(clientMember, memberSystem[LEFT]);
- assertEquals(clientMemberId, memberIdSystem[LEFT]);
- assertFalse(isClientSystem[LEFT]);
- assertFalse(firedSystem[CRASHED]);
- assertNull(memberSystem[CRASHED]);
- assertNull(memberIdSystem[CRASHED]);
- assertFalse(isClientSystem[CRASHED]);
+ assertThat(firedSystem[JOINED]).isFalse();
+ assertThat(memberSystem[JOINED]).isNull();
+ assertThat(memberIdSystem[JOINED]).isNull();
+ assertThat(isClientSystem[JOINED]).isFalse();
+ assertThat(firedSystem[LEFT]).isTrue();
+ assertThat(memberSystem[LEFT]).isEqualTo(clientMember);
+ assertThat(memberIdSystem[LEFT]).isEqualTo(clientMemberId);
+ assertThat(isClientSystem[LEFT]).isFalse();
+ assertThat(firedSystem[CRASHED]).isFalse();
+ assertThat(memberSystem[CRASHED]).isNull();
+ assertThat(memberIdSystem[CRASHED]).isNull();
+ assertThat(isClientSystem[CRASHED]).isFalse();
resetArraysForTesting(firedSystem, memberSystem, memberIdSystem, isClientSystem);
- assertFalse(firedAdapter[JOINED]);
- assertNull(memberAdapter[JOINED]);
- assertNull(memberIdAdapter[JOINED]);
- assertFalse(isClientAdapter[JOINED]);
- assertTrue(firedAdapter[LEFT]);
- assertEquals(clientMember, memberAdapter[LEFT]);
- assertEquals(clientMemberId, memberIdAdapter[LEFT]);
- // assertTrue(isClientAdapter[LEFT]);
- assertFalse(firedAdapter[CRASHED]);
- assertNull(memberAdapter[CRASHED]);
- assertNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
+ assertThat(firedAdapter[JOINED]).isFalse();
+ assertThat(memberAdapter[JOINED]).isNull();
+ assertThat(memberIdAdapter[JOINED]).isNull();
+ assertThat(isClientAdapter[JOINED]).isFalse();
+ assertThat(firedAdapter[LEFT]).isTrue();
+ assertThat(memberAdapter[LEFT]).isEqualTo(clientMember);
+ assertThat(memberIdAdapter[LEFT]).isEqualTo(clientMemberId);
+ // assertThat(isClientAdapter[LEFT]).isTrue();
+ assertThat(firedAdapter[CRASHED]).isFalse();
+ assertThat(memberAdapter[CRASHED]).isNull();
+ assertThat(memberIdAdapter[CRASHED]).isNull();
+ assertThat(isClientAdapter[CRASHED]).isFalse();
resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
// reconnect bridge client
@@ -1243,149 +898,139 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
}
}
- System.out.println("[doTestSystemClientEventsInServer] assert server detected client re-join");
assertArrayFalse(firedSystemDuplicate);
assertArrayFalse(firedAdapterDuplicate);
assertArrayFalse(firedBridgeDuplicate);
- assertTrue(firedBridge[JOINED]);
- assertEquals(clientMember, memberBridge[JOINED]);
- assertEquals(clientMemberId, memberIdBridge[JOINED]);
- assertTrue(isClientBridge[JOINED]);
- assertFalse(firedBridge[LEFT]);
- assertNull(memberBridge[LEFT]);
- assertNull(memberIdBridge[LEFT]);
- assertFalse(isClientBridge[LEFT]);
- assertFalse(firedBridge[CRASHED]);
- assertNull(memberBridge[CRASHED]);
- assertNull(memberIdBridge[CRASHED]);
- assertFalse(isClientBridge[CRASHED]);
+ assertThat(firedBridge[JOINED]).isTrue();
+ assertThat(memberBridge[JOINED]).isEqualTo(clientMember);
+ assertThat(memberIdBridge[JOINED]).isEqualTo(clientMemberId);
+ assertThat(isClientBridge[JOINED]).isTrue();
+ assertThat(firedBridge[LEFT]).isFalse();
+ assertThat(memberBridge[LEFT]).isNull();
+ assertThat(memberIdBridge[LEFT]).isNull();
+ assertThat(isClientBridge[LEFT]).isFalse();
+ assertThat(firedBridge[CRASHED]).isFalse();
+ assertThat(memberBridge[CRASHED]).isNull();
+ assertThat(memberIdBridge[CRASHED]).isNull();
+ assertThat(isClientBridge[CRASHED]).isFalse();
resetArraysForTesting(firedBridge, memberBridge, memberIdBridge, isClientBridge);
- assertTrue(firedSystem[JOINED]);
- assertEquals(clientMember, memberSystem[JOINED]);
- assertEquals(clientMemberId, memberIdSystem[JOINED]);
- assertFalse(isClientSystem[JOINED]);
- assertFalse(firedSystem[LEFT]);
- assertNull(memberSystem[LEFT]);
- assertNull(memberIdSystem[LEFT]);
- assertFalse(isClientSystem[LEFT]);
- assertFalse(firedSystem[CRASHED]);
- assertNull(memberSystem[CRASHED]);
- assertNull(memberIdSystem[CRASHED]);
- assertFalse(isClientSystem[CRASHED]);
+ assertThat(firedSystem[JOINED]).isTrue();
+ assertThat(memberSystem[JOINED]).isEqualTo(clientMember);
+ assertThat(memberIdSystem[JOINED]).isEqualTo(clientMemberId);
+ assertThat(isClientSystem[JOINED]).isFalse();
+ assertThat(firedSystem[LEFT]).isFalse();
+ assertThat(memberSystem[LEFT]).isNull();
+ assertThat(memberIdSystem[LEFT]).isNull();
+ assertThat(isClientSystem[LEFT]).isFalse();
+ assertThat(firedSystem[CRASHED]).isFalse();
+ assertThat(memberSystem[CRASHED]).isNull();
+ assertThat(memberIdSystem[CRASHED]).isNull();
+ assertThat(isClientSystem[CRASHED]).isFalse();
resetArraysForTesting(firedSystem, memberSystem, memberIdSystem, isClientSystem);
- assertTrue(firedAdapter[JOINED]);
- assertEquals(clientMember, memberAdapter[JOINED]);
- assertEquals(clientMemberId, memberIdAdapter[JOINED]);
- // assertTrue(isClientAdapter[JOINED]);
- assertFalse(firedAdapter[LEFT]);
- assertNull(memberAdapter[LEFT]);
- assertNull(memberIdAdapter[LEFT]);
- assertFalse(isClientAdapter[LEFT]);
- assertFalse(firedAdapter[CRASHED]);
- assertNull(memberAdapter[CRASHED]);
- assertNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
+ assertThat(firedAdapter[JOINED]).isTrue();
+ assertThat(memberAdapter[JOINED]).isEqualTo(clientMember);
+ assertThat(memberIdAdapter[JOINED]).isEqualTo(clientMemberId);
+ // assertThat(isClientAdapter[JOINED]).isTrue();
+ assertThat(firedAdapter[LEFT]).isFalse();
+ assertThat(memberAdapter[LEFT]).isNull();
+ assertThat(memberIdAdapter[LEFT]).isNull();
+ assertThat(isClientAdapter[LEFT]).isFalse();
+ assertThat(firedAdapter[CRASHED]).isFalse();
+ assertThat(memberAdapter[CRASHED]).isNull();
+ assertThat(memberIdAdapter[CRASHED]).isNull();
+ assertThat(isClientAdapter[CRASHED]).isFalse();
resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
vm0.invoke(new SerializableRunnable("Wait for client to fully connect") {
+ @Override
public void run() {
- System.out.println("[doTestSystemClientEventsInServer] wait for client to fully connect");
- final String pl = getRootRegion().getSubregion(name).getAttributes().getPoolName();
- PoolImpl pi = (PoolImpl) PoolManager.find(pl);
- waitForClientToFullyConnect(pi);
+ String poolName = getRootRegion().getSubregion(name).getAttributes().getPoolName();
+ PoolImpl pool = (PoolImpl) PoolManager.find(poolName);
+ waitForClientToFullyConnect(pool);
}
});
// close bridge client region with test hook for crash
ServerConnection.setForceClientCrashEvent(true);
- try {
- vm0.invoke(new SerializableRunnable("Close bridge client region") {
- public void run() {
- System.out.println("[doTestSystemClientEventsInServer] close bridge client region");
- getRootRegion().getSubregion(name).close();
- PoolManager.close();
- }
- });
- synchronized (adapter) {
- if (!firedAdapter[CRASHED]) {
- adapter.wait(ASYNC_EVENT_WAIT_MILLIS);
- }
- }
- synchronized (bridgeListener) {
- if (!firedBridge[CRASHED]) {
- bridgeListener.wait(ASYNC_EVENT_WAIT_MILLIS);
- }
+ vm0.invoke(new SerializableRunnable("Close bridge client region") {
+ @Override
+ public void run() {
+ getRootRegion().getSubregion(name).close();
+ PoolManager.close();
}
+ });
- getLogWriter()
- .info("[doTestSystemClientEventsInServer] assert server detected client crashed");
- assertArrayFalse(firedSystemDuplicate);
- assertArrayFalse(firedAdapterDuplicate);
- assertArrayFalse(firedBridgeDuplicate);
-
- assertFalse(firedBridge[JOINED]);
- assertNull(memberBridge[JOINED]);
- assertNull(memberIdBridge[JOINED]);
- assertFalse(isClientBridge[JOINED]);
- assertFalse(firedBridge[LEFT]);
- assertNull(memberBridge[LEFT]);
- assertNull(memberIdBridge[LEFT]);
- assertFalse(isClientBridge[LEFT]);
- assertTrue(firedBridge[CRASHED]);
- assertEquals(clientMember, memberBridge[CRASHED]);
- assertEquals(clientMemberId, memberIdBridge[CRASHED]);
- assertTrue(isClientBridge[CRASHED]);
-
- assertFalse(firedSystem[JOINED]);
- assertNull(memberSystem[JOINED]);
- assertNull(memberIdSystem[JOINED]);
- assertFalse(isClientSystem[JOINED]);
- assertFalse(firedSystem[LEFT]);
- assertNull(memberSystem[LEFT]);
- assertNull(memberIdSystem[LEFT]);
- assertFalse(isClientSystem[LEFT]);
- assertFalse(firedSystem[CRASHED]);
- assertNull(memberSystem[CRASHED]);
- assertNull(memberIdSystem[CRASHED]);
- assertFalse(isClientSystem[CRASHED]);
-
- assertFalse(firedAdapter[JOINED]);
- assertNull(memberAdapter[JOINED]);
- assertNull(memberIdAdapter[JOINED]);
- assertFalse(isClientAdapter[JOINED]);
- assertFalse(firedAdapter[LEFT]);
- assertNull(memberAdapter[LEFT]);
- assertNull(memberIdAdapter[LEFT]);
- assertFalse(isClientAdapter[LEFT]);
- assertTrue(firedAdapter[CRASHED]);
- assertEquals(clientMember, memberAdapter[CRASHED]);
- assertEquals(clientMemberId, memberIdAdapter[CRASHED]);
- assertTrue(isClientAdapter[CRASHED]);
- } finally {
- ServerConnection.setForceClientCrashEvent(false);
+ synchronized (adapter) {
+ if (!firedAdapter[CRASHED]) {
+ adapter.wait(ASYNC_EVENT_WAIT_MILLIS);
+ }
+ }
+ synchronized (bridgeListener) {
+ if (!firedBridge[CRASHED]) {
+ bridgeListener.wait(ASYNC_EVENT_WAIT_MILLIS);
+ }
}
+
+ assertArrayFalse(firedSystemDuplicate);
+ assertArrayFalse(firedAdapterDuplicate);
+ assertArrayFalse(firedBridgeDuplicate);
+
+ assertThat(firedBridge[JOINED]).isFalse();
+ assertThat(memberBridge[JOINED]).isNull();
+ assertThat(memberIdBridge[JOINED]).isNull();
+ assertThat(isClientBridge[JOINED]).isFalse();
+ assertThat(firedBridge[LEFT]).isFalse();
+ assertThat(memberBridge[LEFT]).isNull();
+ assertThat(memberIdBridge[LEFT]).isNull();
+ assertThat(isClientBridge[LEFT]).isFalse();
+ assertThat(firedBridge[CRASHED]).isTrue();
+ assertThat(memberBridge[CRASHED]).isEqualTo(clientMember);
+ assertThat(memberIdBridge[CRASHED]).isEqualTo(clientMemberId);
+ assertThat(isClientBridge[CRASHED]).isTrue();
+
+ assertThat(firedSystem[JOINED]).isFalse();
+ assertThat(memberSystem[JOINED]).isNull();
+ assertThat(memberIdSystem[JOINED]).isNull();
+ assertThat(isClientSystem[JOINED]).isFalse();
+ assertThat(firedSystem[LEFT]).isFalse();
+ assertThat(memberSystem[LEFT]).isNull();
+ assertThat(memberIdSystem[LEFT]).isNull();
+ assertThat(isClientSystem[LEFT]).isFalse();
+ assertThat(firedSystem[CRASHED]).isFalse();
+ assertThat(memberSystem[CRASHED]).isNull();
+ assertThat(memberIdSystem[CRASHED]).isNull();
+ assertThat(isClientSystem[CRASHED]).isFalse();
+
+ assertThat(firedAdapter[JOINED]).isFalse();
+ assertThat(memberAdapter[JOINED]).isNull();
+ assertThat(memberIdAdapter[JOINED]).isNull();
+ assertThat(isClientAdapter[JOINED]).isFalse();
+ assertThat(firedAdapter[LEFT]).isFalse();
+ assertThat(memberAdapter[LEFT]).isNull();
+ assertThat(memberIdAdapter[LEFT]).isNull();
+ assertThat(isClientAdapter[LEFT]).isFalse();
+ assertThat(firedAdapter[CRASHED]).isTrue();
+ assertThat(memberAdapter[CRASHED]).isEqualTo(clientMember);
+ assertThat(memberIdAdapter[CRASHED]).isEqualTo(clientMemberId);
+ assertThat(isClientAdapter[CRASHED]).isTrue();
}
/**
* Waits for client to create an expected number of connections. Note: This probably won't work if
* the pool has more than one Endpoint.
*/
- protected void waitForClientToFullyConnect(final PoolImpl pool) {
- System.out.println("[waitForClientToFullyConnect]");
- final long failMillis = System.currentTimeMillis() + JOIN_FAIL_MILLIS;
+ private void waitForClientToFullyConnect(PoolImpl pool) {
+ long failMillis = System.currentTimeMillis() + JOIN_FAIL_MILLIS;
boolean fullyConnected = false;
while (!fullyConnected) {
- Wait.pause(100);
+ pause(100);
fullyConnected = pool.getConnectionCount() >= pool.getMinConnections();
- assertTrue("Client failed to create " + pool.getMinConnections() + " connections within "
- + JOIN_FAIL_MILLIS + " milliseconds. Only " + pool.getConnectionCount()
- + " connections were created.", System.currentTimeMillis() < failMillis);
+ assertThat(System.currentTimeMillis()).isLessThan(failMillis);
}
- System.out.println("[waitForClientToFullyConnect] fullyConnected=" + fullyConnected);
}
/**
@@ -1410,25 +1055,21 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
}
private void assertArrayFalse(String msg, boolean[] array) {
- for (int i = 0; i < array.length; i++) {
+ for (boolean value : array) {
if (msg == null) {
- assertFalse(array[i]);
+ assertThat(value).isFalse();
} else {
- assertFalse(msg, array[i]);
+ assertThat(value).as(msg).isFalse();
}
}
}
- private void assertArrayTrue(boolean[] array) {
- assertArrayTrue(null, array);
- }
-
private void assertArrayTrue(String msg, boolean[] array) {
for (int i = 0; i < array.length; i++) {
if (msg == null) {
- assertTrue(array[i]);
+ assertThat(array[i]).isTrue();
} else {
- assertTrue(msg, array[i]);
+ assertThat(array[i]).as(msg).isTrue();
}
}
}
@@ -1439,173 +1080,119 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
@Category(FlakyTest.class) // GEODE-1879
@Test
public void testServerEventsInPeerSystem() throws Exception {
- try {
- doTestServerEventsInPeerSystem();
- } finally {
- disconnectAllFromDS();
- }
- }
-
- protected static int testServerEventsInSystemClient_port;
+ boolean[] firedSystem = new boolean[3];
+ DistributedMember[] memberSystem = new DistributedMember[3];
+ String[] memberIdSystem = new String[3];
+ boolean[] isClientSystem = new boolean[3];
- private static int getTestServerEventsInSystemClient_port() {
- return testServerEventsInSystemClient_port;
- }
+ boolean[] firedAdapter = new boolean[3];
+ DistributedMember[] memberAdapter = new DistributedMember[3];
+ String[] memberIdAdapter = new String[3];
+ boolean[] isClientAdapter = new boolean[3];
- private void doTestServerEventsInPeerSystem() throws Exception {
- final boolean[] firedSystem = new boolean[3];
- final DistributedMember[] memberSystem = new DistributedMember[3];
- final String[] memberIdSystem = new String[3];
- final boolean[] isClientSystem = new boolean[3];
+ boolean[] firedBridge = new boolean[3];
+ DistributedMember[] memberBridge = new DistributedMember[3];
+ String[] memberIdBridge = new String[3];
+ boolean[] isClientBridge = new boolean[3];
- final boolean[] firedAdapter = new boolean[3];
- final DistributedMember[] memberAdapter = new DistributedMember[3];
- final String[] memberIdAdapter = new String[3];
- final boolean[] isClientAdapter = new boolean[3];
-
- final boolean[] firedBridge = new boolean[3];
- final DistributedMember[] memberBridge = new DistributedMember[3];
- final String[] memberIdBridge = new String[3];
- final boolean[] isClientBridge = new boolean[3];
-
- final boolean[] firedSystemDuplicate = new boolean[3];
- final boolean[] firedAdapterDuplicate = new boolean[3];
- final boolean[] firedBridgeDuplicate = new boolean[3];
+ boolean[] firedSystemDuplicate = new boolean[3];
+ boolean[] firedAdapterDuplicate = new boolean[3];
+ boolean[] firedBridgeDuplicate = new boolean[3];
MembershipListener systemListener = new MembershipListener() {
+ @Override
public synchronized void memberJoined(MembershipEvent event) {
firedSystemDuplicate[JOINED] = firedSystem[JOINED];
firedSystem[JOINED] = true;
memberSystem[JOINED] = event.getDistributedMember();
memberIdSystem[JOINED] = event.getMemberId();
- notify();
+ notifyAll();
}
+ @Override
public synchronized void memberLeft(MembershipEvent event) {
firedSystemDuplicate[LEFT] = firedSystem[LEFT];
firedSystem[LEFT] = true;
memberSystem[LEFT] = event.getDistributedMember();
memberIdSystem[LEFT] = event.getMemberId();
- notify();
+ notifyAll();
}
+ @Override
public synchronized void memberCrashed(MembershipEvent event) {
firedSystemDuplicate[CRASHED] = firedSystem[CRASHED];
firedSystem[CRASHED] = true;
memberSystem[CRASHED] = event.getDistributedMember();
memberIdSystem[CRASHED] = event.getMemberId();
- notify();
+ notifyAll();
}
};
UniversalMembershipListenerAdapter adapter = new UniversalMembershipListenerAdapter() {
@Override
public synchronized void memberJoined(MembershipEvent event) {
- getLogWriter()
- .info("[testServerEventsInSystemClient] memberJoined >" + event.getMemberId() + "<");
firedAdapterDuplicate[JOINED] = firedAdapter[JOINED];
firedAdapter[JOINED] = true;
memberAdapter[JOINED] = event.getDistributedMember();
memberIdAdapter[JOINED] = event.getMemberId();
- if (event instanceof UniversalMembershipListenerAdapter.AdaptedMembershipEvent) {
- isClientAdapter[JOINED] =
- ((UniversalMembershipListenerAdapter.AdaptedMembershipEvent) event).isClient();
+ if (event instanceof AdaptedMembershipEvent) {
+ isClientAdapter[JOINED] = ((AdaptedMembershipEvent) event).isClient();
}
- notify();
+ notifyAll();
}
@Override
public synchronized void memberLeft(MembershipEvent event) {
- getLogWriter()
- .info("[testServerEventsInSystemClient] memberLeft >" + event.getMemberId() + "<");
firedAdapterDuplicate[LEFT] = firedAdapter[LEFT];
firedAdapter[LEFT] = true;
memberAdapter[LEFT] = event.getDistributedMember();
memberIdAdapter[LEFT] = event.getMemberId();
- if (event instanceof UniversalMembershipListenerAdapter.AdaptedMembershipEvent) {
- isClientAdapter[LEFT] =
- ((UniversalMembershipListenerAdapter.AdaptedMembershipEvent) event).isClient();
+ if (event instanceof AdaptedMembershipEvent) {
+ isClientAdapter[LEFT] = ((AdaptedMembershipEvent) event).isClient();
}
- notify();
+ notifyAll();
}
@Override
public synchronized void memberCrashed(MembershipEvent event) {
- getLogWriter()
- .info("[testServerEventsInSystemClient] memberCrashed >" + event.getMemberId() + "<");
firedAdapterDuplicate[CRASHED] = firedAdapter[CRASHED];
firedAdapter[CRASHED] = true;
memberAdapter[CRASHED] = event.getDistributedMember();
memberIdAdapter[CRASHED] = event.getMemberId();
- if (event instanceof UniversalMembershipListenerAdapter.AdaptedMembershipEvent) {
- isClientAdapter[CRASHED] =
- ((UniversalMembershipListenerAdapter.AdaptedMembershipEvent) event).isClient();
+ if (event instanceof AdaptedMembershipEvent) {
+ isClientAdapter[CRASHED] = ((AdaptedMembershipEvent) event).isClient();
}
- notify();
+ notifyAll();
}
};
- ClientMembershipListener bridgeListener = new ClientMembershipListener() {
- public synchronized void memberJoined(ClientMembershipEvent event) {
- firedBridgeDuplicate[JOINED] = firedBridge[JOINED];
- firedBridge[JOINED] = true;
- memberBridge[JOINED] = event.getMember();
- memberIdBridge[JOINED] = event.getMemberId();
- isClientBridge[JOINED] = event.isClient();
- notify();
- }
-
- public synchronized void memberLeft(ClientMembershipEvent event) {
- firedBridgeDuplicate[LEFT] = firedBridge[LEFT];
- firedBridge[LEFT] = true;
- memberBridge[LEFT] = event.getMember();
- memberIdBridge[LEFT] = event.getMemberId();
- isClientBridge[LEFT] = event.isClient();
- notify();
- }
-
- public synchronized void memberCrashed(ClientMembershipEvent event) {
- firedBridgeDuplicate[CRASHED] = firedBridge[CRASHED];
- firedBridge[CRASHED] = true;
- memberBridge[CRASHED] = event.getMember();
- memberIdBridge[CRASHED] = event.getMemberId();
- isClientBridge[CRASHED] = event.isClient();
- notify();
- }
- };
-
- final Host host = Host.getHost(0);
- final VM vm0 = host.getVM(0);
- final String name = this.getUniqueName();
- final int[] ports = new int[] {AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET)};
- assertTrue(ports[0] != 0);
+ Host host = Host.getHost(0);
+ VM vm0 = host.getVM(0);
+ String name = this.getUniqueName();
+ int[] ports = new int[] {getRandomAvailablePort(SOCKET)};
+ assertThat(ports[0] != 0).isTrue();
// create BridgeServer in controller vm...
- System.out.println("[doTestSystemClientEventsInServer] Create BridgeServer");
getSystem();
AttributesFactory factory = new AttributesFactory();
factory.setScope(Scope.LOCAL);
Region region = createRegion(name, factory.create());
- assertNotNull(region);
- assertNotNull(getRootRegion().getSubregion(name));
+ assertThat(region).isNotNull();
+ assertThat(getRootRegion().getSubregion(name)).isNotNull();
ports[0] = startBridgeServer(0);
- assertTrue(ports[0] != 0);
- final DistributedMember serverMember = getMemberId();
- final String serverMemberId = serverMember.getId();
- final Properties serverProperties = getSystem().getProperties();
+ assertThat(ports[0] != 0).isTrue();
+
+ DistributedMember serverMember = getMemberId();
+ String serverMemberId = serverMember.getId();
+ Properties serverProperties = getSystem().getProperties();
serverProperties.remove(CLUSTER_SSL_ENABLED);
serverProperties.remove(CLUSTER_SSL_CIPHERS);
serverProperties.remove(CLUSTER_SSL_PROTOCOLS);
serverProperties.remove(CLUSTER_SSL_REQUIRE_AUTHENTICATION);
- System.out.println("[testServerEventsInPeerSystem] ports[0]=" + ports[0]);
- System.out.println("[testServerEventsInPeerSystem] serverMemberId=" + serverMemberId);
- System.out.println("[testServerEventsInPeerSystem] serverMember=" + serverMember);
-
- GemFireCacheImpl cache = GemFireCacheImpl.getExisting();
- assertNotNull(cache);
+ InternalCache cache = getInternalCache();
ManagementService service = ManagementService.getExistingManagementService(cache);
// register the system listener
service.addMembershipListener(systemListener);
@@ -1617,13 +1204,12 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
SerializableCallable createPeerCache = new SerializableCallable("Create Peer Cache") {
@Override
public Object call() {
- System.out.println("[testServerEventsInPeerSystem] Create Peer cache");
getSystem(serverProperties);
AttributesFactory factory = new AttributesFactory();
factory.setScope(Scope.LOCAL);
Region region = createRegion(name, factory.create());
- assertNotNull(region);
- assertNotNull(getRootRegion().getSubregion(name));
+ assertThat(region).isNotNull();
+ assertThat(getRootRegion().getSubregion(name)).isNotNull();
return basicGetSystem().getDistributedMember();
}
};
@@ -1631,11 +1217,6 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
DistributedMember peerMember = (DistributedMember) vm0.invoke(createPeerCache);
String peerMemberId = peerMember.getId();
- System.out.println("[testServerEventsInPeerSystem] peerMemberId=" + peerMemberId);
- System.out.println("[testServerEventsInPeerSystem] peerMember=" + peerMember);
-
-
-
synchronized (systemListener) {
if (!firedSystem[JOINED]) {
systemListener.wait(ASYNC_EVENT_WAIT_MILLIS);
@@ -1647,111 +1228,103 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
}
}
- System.out.println("[testServerEventsInPeerSystem] assert server detected peer join");
assertArrayFalse(firedSystemDuplicate);
- assertTrue(firedSystem[JOINED]);
- assertEquals(peerMember, memberSystem[JOINED]);
- assertEquals(peerMemberId, memberIdSystem[JOINED]);
- assertFalse(isClientSystem[JOINED]);
- assertFalse(firedSystem[LEFT]);
- assertNull(memberSystem[LEFT]);
- assertNull(memberIdSystem[LEFT]);
- assertFalse(isClientSystem[LEFT]);
- assertFalse(firedSystem[CRASHED]);
- assertNull(memberSystem[CRASHED]);
- assertNull(memberIdSystem[CRASHED]);
- assertFalse(isClientSystem[CRASHED]);
+ assertThat(firedSystem[JOINED]).isTrue();
+ assertThat(memberSystem[JOINED]).isEqualTo(peerMember);
+ assertThat(memberIdSystem[JOINED]).isEqualTo(peerMemberId);
+ assertThat(isClientSystem[JOINED]).isFalse();
+ assertThat(firedSystem[LEFT]).isFalse();
+ assertThat(memberSystem[LEFT]).isNull();
+ assertThat(memberIdSystem[LEFT]).isNull();
+ assertThat(isClientSystem[LEFT]).isFalse();
+ assertThat(firedSystem[CRASHED]).isFalse();
+ assertThat(memberSystem[CRASHED]).isNull();
+ assertThat(memberIdSystem[CRASHED]).isNull();
+ assertThat(isClientSystem[CRASHED]).isFalse();
+
resetArraysForTesting(firedSystem, memberSystem, memberIdSystem, isClientSystem);
- assertTrue(firedAdapter[JOINED]);
- assertNotNull(memberAdapter[JOINED]);
- assertNotNull(memberIdAdapter[JOINED]);
- assertEquals(peerMember, memberAdapter[JOINED]);
- assertEquals(peerMemberId, memberIdAdapter[JOINED]);
- assertFalse(isClientAdapter[JOINED]);
- assertFalse(firedAdapter[LEFT]);
- assertNull(memberAdapter[LEFT]);
- assertNull(memberIdAdapter[LEFT]);
- assertFalse(isClientAdapter[LEFT]);
- assertFalse(firedAdapter[CRASHED]);
- assertNull(memberAdapter[CRASHED]);
- assertNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
+ assertThat(firedAdapter[JOINED]).isTrue();
+ assertThat(memberAdapter[JOINED]).isNotNull();
+ assertThat(memberIdAdapter[JOINED]).isNotNull();
+ assertThat(memberAdapter[JOINED]).isEqualTo(peerMember);
+ assertThat(memberIdAdapter[JOINED]).isEqualTo(peerMemberId);
+ assertThat(isClientAdapter[JOINED]).isFalse();
+ assertThat(firedAdapter[LEFT]).isFalse();
+ assertThat(memberAdapter[LEFT]).isNull();
+ assertThat(memberIdAdapter[LEFT]).isNull();
+ assertThat(isClientAdapter[LEFT]).isFalse();
+ assertThat(firedAdapter[CRASHED]).isFalse();
+ assertThat(memberAdapter[CRASHED]).isNull();
+ assertThat(memberIdAdapter[CRASHED]).isNull();
+ assertThat(isClientAdapter[CRASHED]).isFalse();
+
resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
+ addIgnoredException(ServerConnectivityException.class.getName());
+ addIgnoredException(IOException.class.getName());
- LogWriter bgexecLogger = new LocalLogWriter(InternalLogWriter.ALL_LEVEL, System.out);
- bgexecLogger
- .info("<ExpectedException action=add>" + "java.io.IOException" + "</ExpectedException>");
- final IgnoredException ex =
- IgnoredException.addIgnoredException(ServerConnectivityException.class.getName());
- try {
- vm0.invoke(new SerializableRunnable("Disconnect Peer server") {
- public void run() {
- System.out.println("[testServerEventsInPeerSystem] disconnect peer server");
- closeCache();
- disconnectFromDS();
- }
- });
+ vm0.invoke(new SerializableRunnable("Disconnect Peer server") {
+ @Override
+ public void run() {
+ disconnectFromDS();
+ }
+ });
- synchronized (systemListener) {
- if (!firedSystem[LEFT]) {
- systemListener.wait(ASYNC_EVENT_WAIT_MILLIS);
- }
+ synchronized (systemListener) {
+ if (!firedSystem[LEFT]) {
+ systemListener.wait(ASYNC_EVENT_WAIT_MILLIS);
}
- synchronized (adapter) {
- if (!firedAdapter[LEFT]) {
- adapter.wait(ASYNC_EVENT_WAIT_MILLIS);
- }
+ }
+ synchronized (adapter) {
+ if (!firedAdapter[LEFT]) {
+ adapter.wait(ASYNC_EVENT_WAIT_MILLIS);
}
- } finally {
- bgexecLogger.info(
- "<ExpectedException action=remove>" + "java.io.IOException" + "</ExpectedException>");
- ex.remove();
}
- System.out.println("[testServerEventsInPeerSystem] assert server detected peer crashed");
- assertArrayFalse(firedSystemDuplicate);
+ // done with IgnoredExceptions
+ assertArrayFalse(firedSystemDuplicate);
assertArrayFalse(firedAdapterDuplicate);
- assertFalse(firedSystem[JOINED]);
- assertNull(memberSystem[JOINED]);
- assertNull(memberIdSystem[JOINED]);
- assertFalse(isClientSystem[JOINED]);
- assertTrue(firedSystem[LEFT]);
- assertEquals(peerMember, memberSystem[LEFT]);
- assertEquals(peerMemberId, memberIdSystem[LEFT]);
- assertFalse(isClientSystem[LEFT]);
- assertFalse(firedSystem[CRASHED]);
- assertNull(memberSystem[CRASHED]);
- assertNull(memberIdSystem[CRASHED]);
- assertFalse(isClientSystem[CRASHED]);
+ assertThat(firedSystem[JOINED]).isFalse();
+ assertThat(memberSystem[JOINED]).isNull();
+ assertThat(memberIdSystem[JOINED]).isNull();
+ assertThat(isClientSystem[JOINED]).isFalse();
+ assertThat(firedSystem[LEFT]).isTrue();
+ assertThat(memberSystem[LEFT]).isEqualTo(peerMember);
+ assertThat(memberIdSystem[LEFT]).isEqualTo(peerMemberId);
+ assertThat(isClientSystem[LEFT]).isFalse();
+ assertThat(firedSystem[CRASHED]).isFalse();
+ assertThat(memberSystem[CRASHED]).isNull();
+ assertThat(memberIdSystem[CRASHED]).isNull();
+ assertThat(isClientSystem[CRASHED]).isFalse();
+
resetArraysForTesting(firedSystem, memberSystem, memberIdSystem, isClientSystem);
- assertFalse("this intermittently fails", firedAdapter[JOINED]);
- assertNull(memberIdAdapter[JOINED]);
- assertFalse(isClientAdapter[JOINED]);
+ assertThat(firedAdapter[JOINED]).isFalse();
+ assertThat(memberIdAdapter[JOINED]).isNull();
+ assertThat(isClientAdapter[JOINED]).isFalse();
// LEFT fired by System listener
- assertTrue(firedAdapter[LEFT]);
- assertEquals(peerMember, memberAdapter[LEFT]);
- assertEquals(peerMemberId, memberIdAdapter[LEFT]);
- assertFalse(isClientAdapter[LEFT]);
+ assertThat(firedAdapter[LEFT]).isTrue();
+ assertThat(memberAdapter[LEFT]).isEqualTo(peerMember);
+ assertThat(memberIdAdapter[LEFT]).isEqualTo(peerMemberId);
+ assertThat(isClientAdapter[LEFT]).isFalse();
// There won't be an adapter crashed event because since the two VMs
// are in the same distributed system, and the server's real member
// id is used now. In this case, two events are sent - one from
- // jgroups (memberDeparted), and one from the server (a memberCrshed).
+ // jgroups (memberDeparted), and one from the server (a memberCrashed).
// The memberCrashed event is deemed a duplicate and not sent - see
// UniversalMembershipListenerAdapter.MembershipListener.isDuplicate
- assertFalse(firedAdapter[CRASHED]);
- assertNull(memberAdapter[CRASHED]);
- assertNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
- resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
+ assertThat(firedAdapter[CRASHED]).isFalse();
+ assertThat(memberAdapter[CRASHED]).isNull();
+ assertThat(memberIdAdapter[CRASHED]).isNull();
+ assertThat(isClientAdapter[CRASHED]).isFalse();
+ resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
}
/**
@@ -1759,411 +1332,411 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
*/
@Test
public void testServerEventsInLonerClient() throws Exception {
- try {
- doTestServerEventsInLonerClient();
- } finally {
- disconnectAllFromDS();
- }
- }
-
- protected static int testServerEventsInLonerClient_port;
-
- private static int getTestServerEventsInLonerClient_port() {
- return testServerEventsInLonerClient_port;
- }
-
- private void doTestServerEventsInLonerClient() throws Exception {
- final boolean[] firedAdapter = new boolean[3];
- final DistributedMember[] memberAdapter = new DistributedMember[3];
- final String[] memberIdAdapter = new String[3];
- final boolean[] isClientAdapter = new boolean[3];
+ boolean[] firedAdapter = new boolean[3];
+ DistributedMember[] memberAdapter = new DistributedMember[3];
+ String[] memberIdAdapter = new String[3];
+ boolean[] isClientAdapter = new boolean[3];
- final boolean[] firedBridge = new boolean[3];
- final DistributedMember[] memberBridge = new DistributedMember[3];
- final String[] memberIdBridge = new String[3];
- final boolean[] isClientBridge = new boolean[3];
+ boolean[] firedBridge = new boolean[3];
+ DistributedMember[] memberBridge = new DistributedMember[3];
+ String[] memberIdBridge = new String[3];
+ boolean[] isClientBridge = new boolean[3];
- final boolean[] firedAdapterDuplicate = new boolean[3];
- final boolean[] firedBridgeDuplicate = new boolean[3];
+ boolean[] firedAdapterDuplicate = new boolean[3];
+ boolean[] firedBridgeDuplicate = new boolean[3];
UniversalMembershipListenerAdapter adapter = new UniversalMembershipListenerAdapter() {
@Override
public synchronized void memberJoined(MembershipEvent event) {
- System.out
- .println("[testServerEventsInLonerClient] memberJoined >" + event.getMemberId() + "<");
firedAdapterDuplicate[JOINED] = firedAdapter[JOINED];
firedAdapter[JOINED] = true;
memberAdapter[JOINED] = event.getDistributedMember();
memberIdAdapter[JOINED] = event.getMemberId();
- if (event instanceof UniversalMembershipListenerAdapter.AdaptedMembershipEvent) {
- isClientAdapter[JOINED] =
- ((UniversalMembershipListenerAdapter.AdaptedMembershipEvent) event).isClient();
+ if (event instanceof AdaptedMembershipEvent) {
+ isClientAdapter[JOINED] = ((AdaptedMembershipEvent) event).isClient();
}
- notify();
+ notifyAll();
}
@Override
public synchronized void memberLeft(MembershipEvent event) {
- System.out
- .println("[testServerEventsInLonerClient] memberLeft >" + event.getMemberId() + "<");
firedAdapterDuplicate[LEFT] = firedAdapter[LEFT];
firedAdapter[LEFT] = true;
memberAdapter[LEFT] = event.getDistributedMember();
memberIdAdapter[LEFT] = event.getMemberId();
- if (event instanceof UniversalMembershipListenerAdapter.AdaptedMembershipEvent) {
- isClientAdapter[LEFT] =
- ((UniversalMembershipListenerAdapter.AdaptedMembershipEvent) event).isClient();
+ if (event instanceof AdaptedMembershipEvent) {
+ isClientAdapter[LEFT] = ((AdaptedMembershipEvent) event).isClient();
}
- notify();
+ notifyAll();
}
@Override
public synchronized void memberCrashed(MembershipEvent event) {
- System.out
- .println("[testServerEventsInLonerClient] memberCrashed >" + event.getMemberId() + "<");
firedAdapterDuplicate[CRASHED] = firedAdapter[CRASHED];
firedAdapter[CRASHED] = true;
memberAdapter[CRASHED] = event.getDistributedMember();
memberIdAdapter[CRASHED] = event.getMemberId();
- if (event instanceof UniversalMembershipListenerAdapter.AdaptedMembershipEvent) {
- isClientAdapter[CRASHED] =
- ((UniversalMembershipListenerAdapter.AdaptedMembershipEvent) event).isClient();
+ if (event instanceof AdaptedMembershipEvent) {
+ isClientAdapter[CRASHED] = ((AdaptedMembershipEvent) event).isClient();
}
- notify();
+ notifyAll();
}
};
ClientMembershipListener bridgeListener = new ClientMembershipListener() {
+ @Override
public synchronized void memberJoined(ClientMembershipEvent event) {
firedBridgeDuplicate[JOINED] = firedBridge[JOINED];
firedBridge[JOINED] = true;
memberBridge[JOINED] = event.getMember();
memberIdBridge[JOINED] = event.getMemberId();
isClientBridge[JOINED] = event.isClient();
- notify();
+ notifyAll();
}
+ @Override
public synchronized void memberLeft(ClientMembershipEvent event) {
firedBridgeDuplicate[LEFT] = firedBridge[LEFT];
firedBridge[LEFT] = true;
memberBridge[LEFT] = event.getMember();
memberIdBridge[LEFT] = event.getMemberId();
isClientBridge[LEFT] = event.isClient();
- notify();
+ notifyAll();
}
+ @Override
public synchronized void memberCrashed(ClientMembershipEvent event) {
firedBridgeDuplicate[CRASHED] = firedBridge[CRASHED];
firedBridge[CRASHED] = true;
memberBridge[CRASHED] = event.getMember();
memberIdBridge[CRASHED] = event.getMemberId();
isClientBridge[CRASHED] = event.isClient();
- notify();
+ notifyAll();
}
};
- final Host host = Host.getHost(0);
- final VM vm0 = host.getVM(0);
- final String name = this.getUniqueName();
- final int[] ports = new int[] {AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET)};
- assertTrue(ports[0] != 0);
+ Host host = Host.getHost(0);
+ VM vm0 = host.getVM(0);
+ String name = getUniqueName();
+ int[] ports = new int[] {getRandomAvailablePort(SOCKET)};
+ assertThat(ports[0] != 0).isTrue();
- System.out.println("[testServerEventsInLonerClient] create loner bridge client");
Properties config = new Properties();
config.put(MCAST_PORT, "0");
config.put(LOCATORS, "");
- // config.put(LOG_LEVEL, "fine");
config.setProperty(ENABLE_NETWORK_PARTITION_DETECTION, "false");
getSystem(config);
- System.out.println("[testServerEventsInLonerClient] create system bridge client");
- getSystem();
-
// register the bridge listener
ClientMembership.registerClientMembershipListener(bridgeListener);
- // adapter should've self-registered w/ BridgeMembership
-
- // String clientMemberId = getMemberId();
- // DistributedMember clientMember = getDistributedMember();
-
- // create BridgeServer in vm0...
+ // create CacheServer in vm0...
SerializableCallable createBridgeServer = new SerializableCallable("Create BridgeServer") {
@Override
public Object call() {
- System.out.println("[testServerEventsInLonerClient] Create BridgeServer");
getSystem();
AttributesFactory factory = new AttributesFactory();
factory.setScope(Scope.LOCAL);
Region region = createRegion(name, factory.create());
- assertNotNull(region);
- assertNotNull(getRootRegion().getSubregion(name));
+ assertThat(region).isNotNull();
+ assertThat(getRootRegion().getSubregion(name)).isNotNull();
+
try {
- testServerEventsInLonerClient_port = startBridgeServer(ports[0]);
+ serverPort = startBridgeServer(ports[0]);
} catch (IOException e) {
- getLogWriter().error(e);
- fail(e.getMessage());
+ throw new AssertionError(e);
}
+
return basicGetSystem().getDistributedMember();
}
};
- DistributedMember serverMember = (DistributedMember) vm0.invoke(createBridgeServer);
- String serverMemberId = serverMember.getId();
+ vm0.invoke(createBridgeServer);
// gather details for later creation of pool...
- assertEquals(ports[0], (int) vm0.invoke("getServerPort",
- () -> UniversalMembershipListenerAdapterDUnitTest.getTestServerEventsInLonerClient_port()));
-
- System.out.println("[testServerEventsInLonerClient] ports[0]=" + ports[0]);
- System.out.println("[testServerEventsInLonerClient] serverMemberId=" + serverMemberId);
- System.out.println("[testServerEventsInLonerClient] serverMember=" + serverMember);
+ assertThat((int) vm0.invoke("getServerPort", () -> serverPort)).isEqualTo(ports[0]);
// create region which connects to bridge server
AttributesFactory factory = new AttributesFactory();
factory.setScope(Scope.LOCAL);
- ClientServerTestCase.configureConnectionPool(factory, NetworkUtils.getServerHostName(host),
- ports, false, -1, -1, null);
+ configureConnectionPool(factory, getServerHostName(host), ports, false, -1, -1, null);
createRegion(name, factory.create());
- assertNotNull(getRootRegion().getSubregion(name));
-
- Awaitility.await("wait for join").atMost(ASYNC_EVENT_WAIT_MILLIS, TimeUnit.MILLISECONDS)
- .until(() -> {
- synchronized (adapter) {
- return firedAdapter[JOINED];
- }
- });
- Awaitility.await("wait for join").atMost(ASYNC_EVENT_WAIT_MILLIS, TimeUnit.MILLISECONDS)
- .until(() -> {
- synchronized (bridgeListener) {
- return firedBridge[JOINED];
- }
- });
-
- System.out.println("[testServerEventsInLonerClient] assert client detected server join");
+ assertThat(getRootRegion().getSubregion(name)).isNotNull();
+
+ await("wait for join").atMost(ASYNC_EVENT_WAIT_MILLIS, MILLISECONDS).until(() -> {
+ synchronized (adapter) {
+ return firedAdapter[JOINED];
+ }
+ });
+ await("wait for join").atMost(ASYNC_EVENT_WAIT_MILLIS, MILLISECONDS).until(() -> {
+ synchronized (bridgeListener) {
+ return firedBridge[JOINED];
+ }
+ });
assertArrayFalse(firedAdapterDuplicate);
assertArrayFalse(firedBridgeDuplicate);
- assertTrue(firedBridge[JOINED]);
- assertNotNull(memberBridge[JOINED]);
- assertNotNull(memberIdBridge[JOINED]);
- assertFalse(isClientBridge[JOINED]);
- assertFalse(firedBridge[LEFT]);
- assertNull(memberBridge[LEFT]);
- assertNull(memberIdBridge[LEFT]);
- assertFalse(isClientBridge[LEFT]);
- assertFalse(firedBridge[CRASHED]);
- assertNull(memberBridge[CRASHED]);
- assertNull(memberIdBridge[CRASHED]);
- assertFalse(isClientBridge[CRASHED]);
+ assertThat(firedBridge[JOINED]).isTrue();
+ assertThat(memberBridge[JOINED]).isNotNull();
+ assertThat(memberIdBridge[JOINED]).isNotNull();
+ assertThat(isClientBridge[JOINED]).isFalse();
+ assertThat(firedBridge[LEFT]).isFalse();
+ assertThat(memberBridge[LEFT]).isNull();
+ assertThat(memberIdBridge[LEFT]).isNull();
+ assertThat(isClientBridge[LEFT]).isFalse();
+ assertThat(firedBridge[CRASHED]).isFalse();
+ assertThat(memberBridge[CRASHED]).isNull();
+ assertThat(memberIdBridge[CRASHED]).isNull();
+ assertThat(isClientBridge[CRASHED]).isFalse();
+
resetArraysForTesting(firedBridge, memberBridge, memberIdBridge, isClientBridge);
- assertTrue(firedAdapter[JOINED]);
- assertNotNull(memberIdAdapter[JOINED]);
- assertFalse(isClientAdapter[JOINED]);
- assertFalse(firedAdapter[LEFT]);
- assertNull(memberAdapter[LEFT]);
- assertNull(memberIdAdapter[LEFT]);
- assertFalse(isClientAdapter[LEFT]);
- assertFalse(firedAdapter[CRASHED]);
- assertNull(memberAdapter[CRASHED]);
- assertNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
+ assertThat(firedAdapter[JOINED]).isTrue();
+ assertThat(memberIdAdapter[JOINED]).isNotNull();
+ assertThat(isClientAdapter[JOINED]).isFalse();
+ assertThat(firedAdapter[LEFT]).isFalse();
+ assertThat(memberAdapter[LEFT]).isNull();
+ assertThat(memberIdAdapter[LEFT]).isNull();
+ assertThat(isClientAdapter[LEFT]).isFalse();
+ assertThat(firedAdapter[CRASHED]).isFalse();
+ assertThat(memberAdapter[CRASHED]).isNull();
+ assertThat(memberIdAdapter[CRASHED]).isNull();
+ assertThat(isClientAdapter[CRASHED]).isFalse();
+
resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
- System.out.println("[testServerEventsInLonerClient] wait for client to fully connect");
- final String pl = getRootRegion().getSubregion(name).getAttributes().getPoolName();
- PoolImpl pi = (PoolImpl) PoolManager.find(pl);
- waitForClientToFullyConnect(pi);
-
- String expected = "java.io.IOException";
- String addExpected = "<ExpectedException action=add>" + expected + "</ExpectedException>";
- String removeExpected = "<ExpectedException action=remove>" + expected + "</ExpectedException>";
-
- String expected2 = "java.net.ConnectException";
- String addExpected2 = "<ExpectedException action=add>" + expected2 + "</ExpectedException>";
- String removeExpected2 =
- "<ExpectedException action=remove>" + expected2 + "</ExpectedException>";
-
- // LogWriter bgexecLogger =
- // new LocalLogWriter(LocalLogWriter.ALL_LEVEL, System.out);
- // bgexecLogger.info(addExpected);
- // bgexecLogger.info(addExpected2);
- LogWriter lw = getSystem().getLogWriter();
- lw.info(addExpected);
- lw.info(addExpected2);
-
- try {
- vm0.invoke(new SerializableRunnable("Disconnect bridge server") {
- public void run() {
- System.out.println("[testServerEventsInLonerClient] disconnect bridge server");
- closeCache();
- }
- });
-
- Awaitility.await("wait for server to leave")
- .atMost(ASYNC_EVENT_WAIT_MILLIS, TimeUnit.MILLISECONDS).until(() -> {
- synchronized (adapter) {
- return firedAdapter[LEFT] || firedAdapter[CRASHED];
- }
- });
- Awaitility.await("wait for server to leave")
- .atMost(ASYNC_EVENT_WAIT_MILLIS, TimeUnit.MILLISECONDS).until(() -> {
- synchronized (bridgeListener) {
- return firedBridge[LEFT] || firedBridge[CRASHED];
- }
- });
-
- } finally {
- // bgexecLogger.info(removeExpected);
- // bgexecLogger.info(removeExpected2);
- lw.info(removeExpected);
- lw.info(removeExpected2);
- }
+ String poolName = getRootRegion().getSubregion(name).getAttributes().getPoolName();
+ PoolImpl pool = (PoolImpl) PoolManager.find(poolName);
+ waitForClientToFullyConnect(pool);
+
+ addIgnoredException(IOException.class.getName());
+ addIgnoredException(ConnectException.class.getName());
+
+ vm0.invoke(new SerializableRunnable("Disconnect bridge server") {
+ @Override
+ public void run() {
+ closeCache();
+ }
+ });
- System.out.println("[testServerEventsInLonerClient] assert client detected server crashed");
+ await("wait for server to leave").atMost(ASYNC_EVENT_WAIT_MILLIS, MILLISECONDS).until(() -> {
+ synchronized (adapter) {
+ return firedAdapter[LEFT] || firedAdapter[CRASHED];
+ }
+ });
+ await("wait for server to leave").atMost(ASYNC_EVENT_WAIT_MILLIS, MILLISECONDS).until(() -> {
+ synchronized (bridgeListener) {
+ return firedBridge[LEFT] || firedBridge[CRASHED];
+ }
+ });
+
+ // done with IgnoredExceptions
assertArrayFalse(firedAdapterDuplicate);
assertArrayFalse(firedBridgeDuplicate);
- assertFalse(firedBridge[JOINED]);
- assertNull(memberIdBridge[JOINED]);
- assertNull(memberBridge[JOINED]);
- assertFalse(isClientBridge[JOINED]);
- assertFalse(
- "Please update testServerEventsInLonerClient to handle memberLeft for BridgeServer.",
- firedBridge[LEFT]);
- assertNull(memberBridge[LEFT]);
- assertNull(memberIdBridge[LEFT]);
- assertFalse(isClientBridge[LEFT]);
- assertTrue(firedBridge[CRASHED]);
- assertNotNull(memberBridge[CRASHED]);
- assertNotNull(memberIdBridge[CRASHED]);
- assertFalse(isClientBridge[CRASHED]);
+ assertThat(firedBridge[JOINED]).isFalse();
+ assertThat(memberIdBridge[JOINED]).isNull();
+ assertThat(memberBridge[JOINED]).isNull();
+ assertThat(isClientBridge[JOINED]).isFalse();
+ assertThat(firedBridge[LEFT]).isFalse();
+ assertThat(memberBridge[LEFT]).isNull();
+ assertThat(memberIdBridge[LEFT]).isNull();
+ assertThat(isClientBridge[LEFT]).isFalse();
+ assertThat(firedBridge[CRASHED]).isTrue();
+ assertThat(memberBridge[CRASHED]).isNotNull();
+ assertThat(memberIdBridge[CRASHED]).isNotNull();
+ assertThat(isClientBridge[CRASHED]).isFalse();
+
resetArraysForTesting(firedBridge, memberBridge, memberIdBridge, isClientBridge);
- assertFalse(firedAdapter[JOINED]);
- assertNull(memberAdapter[JOINED]);
- assertNull(memberIdAdapter[JOINED]);
- assertFalse(isClientAdapter[JOINED]);
- assertFalse("Please update testServerEventsInLonerClient to handle BridgeServer LEFT",
- firedAdapter[LEFT]);
- assertNull(memberAdapter[LEFT]);
- assertNull(memberIdAdapter[LEFT]);
- assertFalse(isClientAdapter[LEFT]);
+ assertThat(firedAdapter[JOINED]).isFalse();
+ assertThat(memberAdapter[JOINED]).isNull();
+ assertThat(memberIdAdapter[JOINED]).isNull();
+ assertThat(isClientAdapter[JOINED]).isFalse();
+ assertThat(firedAdapter[LEFT]).isFalse();
+ assertThat(memberAdapter[LEFT]).isNull();
+ assertThat(memberIdAdapter[LEFT]).isNull();
+ assertThat(isClientAdapter[LEFT]).isFalse();
// CRASHED fired by Bridge listener
- assertTrue(firedAdapter[CRASHED]);
- assertNotNull(memberAdapter[CRASHED]);
- assertNotNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
+ assertThat(firedAdapter[CRASHED]).isTrue();
+ assertThat(memberAdapter[CRASHED]).isNotNull();
+ assertThat(memberIdAdapter[CRASHED]).isNotNull();
+ assertThat(isClientAdapter[CRASHED]).isFalse();
+
resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
// reconnect bridge client to test for crashed event
- serverMember = (DistributedMember) vm0.invoke(createBridgeServer);
- serverMemberId = serverMember.getId();
+ vm0.invoke(createBridgeServer);
// gather details for later creation of pool...
- assertEquals(ports[0], (int) vm0.invoke(
- () -> UniversalMembershipListenerAdapterDUnitTest.getTestServerEventsInLonerClient_port()));
- serverMember =
- vm0.invoke(() -> UniversalMembershipListenerAdapterDUnitTest.getDistributedMember());
-
- System.out.println("[testServerEventsInLonerClient] ports[0]=" + ports[0]);
- System.out.println("[testServerEventsInLonerClient] serverMemberId=" + serverMemberId);
- System.out.println("[testServerEventsInLonerClient] serverMember=" + serverMember);
-
- Awaitility.await("wait for join").atMost(ASYNC_EVENT_WAIT_MILLIS, TimeUnit.MILLISECONDS)
- .until(() -> {
- synchronized (adapter) {
- return firedAdapter[JOINED];
- }
- });
- Awaitility.await("wait for join").atMost(ASYNC_EVENT_WAIT_MILLIS, TimeUnit.MILLISECONDS)
- .until(() -> {
- synchronized (bridgeListener) {
- return firedBridge[JOINED];
- }
- });
-
- System.out.println("[testServerEventsInLonerClient] assert client detected server re-join");
+ assertThat((int) vm0.invoke(() -> serverPort)).isEqualTo(ports[0]);
+
+ await("wait for join").atMost(ASYNC_EVENT_WAIT_MILLIS, MILLISECONDS).until(() -> {
+ synchronized (adapter) {
+ return firedAdapter[JOINED];
+ }
+ });
+ await("wait for join").atMost(ASYNC_EVENT_WAIT_MILLIS, MILLISECONDS).until(() -> {
+ synchronized (bridgeListener) {
+ return firedBridge[JOINED];
+ }
+ });
assertArrayFalse(firedAdapterDuplicate);
assertArrayFalse(firedBridgeDuplicate);
- assertTrue(firedBridge[JOINED]);
- assertNotNull(memberBridge[JOINED]);
- assertNotNull(memberIdBridge[JOINED]);
- assertFalse(isClientBridge[JOINED]);
- assertFalse(firedBridge[LEFT]);
- assertNull(memberBridge[LEFT]);
- assertNull(memberIdBridge[LEFT]);
- assertFalse(isClientBridge[LEFT]);
- assertFalse(firedBridge[CRASHED]);
- assertNull(memberBridge[CRASHED]);
- assertNull(memberIdBridge[CRASHED]);
- assertFalse(isClientBridge[CRASHED]);
+ assertThat(firedBridge[JOINED]).isTrue();
+ assertThat(memberBridge[JOINED]).isNotNull();
+ assertThat(memberIdBridge[JOINED]).isNotNull();
+ assertThat(isClientBridge[JOINED]).isFalse();
+ assertThat(firedBridge[LEFT]).isFalse();
+ assertThat(memberBridge[LEFT]).isNull();
+ assertThat(memberIdBridge[LEFT]).isNull();
+ assertThat(isClientBridge[LEFT]).isFalse();
+ assertThat(firedBridge[CRASHED]).isFalse();
+ assertThat(memberBridge[CRASHED]).isNull();
+ assertThat(memberIdBridge[CRASHED]).isNull();
+ assertThat(isClientBridge[CRASHED]).isFalse();
+
resetArraysForTesting(firedBridge, memberBridge, memberIdBridge, isClientBridge);
- assertTrue(firedAdapter[JOINED]);
- assertNotNull(memberAdapter[JOINED]);
- assertNotNull(memberIdAdapter[JOINED]);
- assertFalse(isClientAdapter[JOINED]);
- assertFalse(firedAdapter[LEFT]);
- assertNull(memberAdapter[LEFT]);
- assertNull(memberIdAdapter[LEFT]);
- assertFalse(isClientAdapter[LEFT]);
- assertFalse(firedAdapter[CRASHED]);
- assertNull(memberAdapter[CRASHED]);
- assertNull(memberIdAdapter[CRASHED]);
- assertFalse(isClientAdapter[CRASHED]);
+ assertThat(firedAdapter[JOINED]).isTrue();
+ assertThat(memberAdapter[JOINED]).isNotNull();
+ assertThat(memberIdAdapter[JOINED]).isNotNull();
+ assertThat(isClientAdapter[JOINED]).isFalse();
+ assertThat(firedAdapter[LEFT]).isFalse();
+ assertThat(memberAdapter[LEFT]).isNull();
+ assertThat(memberIdAdapter[LEFT]).isNull();
+ assertThat(isClientAdapter[LEFT]).isFalse();
+ assertThat(firedAdapter[CRASHED]).isFalse();
+ assertThat(memberAdapter[CRASHED]).isNull();
+ assertThat(memberIdAdapter[CRASHED]).isNull();
+ assertThat(isClientAdapter[CRASHED]).isFalse();
+
resetArraysForTesting(firedAdapter, memberAdapter, memberIdAdapter, isClientAdapter);
}
- // Simple DistributedMember implementation
- static class TestDistributedMember implements DistributedMember {
+ private static InternalCache getInternalCache() {
+ InternalCache cache = (InternalCache) CacheFactory.getAnyInstance();
+ assertThat(cache).isNotNull();
+ return cache;
+ }
+
+ private static class MembershipNotification implements Serializable {
+
+ private final AtomicBoolean notified = new AtomicBoolean();
+ private final AtomicReference<DistributedMember> member = new AtomicReference<>();
+ private final AtomicReference<String> memberId = new AtomicReference<>();
+ private final AtomicBoolean client = new AtomicBoolean();
+
+ void notify(final MembershipEvent event) {
+ validateNotNotified();
+
+ notified.set(true);
+ member.set(event.getDistributedMember());
+ memberId.set(event.getMemberId());
+ }
+
+ void notify(final AdaptedMembershipEvent event) {
+ validateNotNotified();
+
+ notified.set(true);
+ member.set(event.getDistributedMember());
+ memberId.set(event.getMemberId());
+ client.set(event.isClient());
+ }
+
+ void notify(final ClientMembershipEvent event) {
+ validateNotNotified();
+
+ notified.set(true);
+ member.set(event.getMember());
+ memberId.set(event.getMemberId());
+ client.set(event.isClient());
+ }
+
+ void reset() {
+ notified.set(false);
+ member.set(null);
+ memberId.set(null);
+ client.set(false);
+ }
+
+ void awaitNotification(final long timeout, final TimeUnit unit) {
+ await().atMost(timeout, unit).until(() -> notified.get());
+ }
+
+ void awaitWithoutNotification(final long timeout, final TimeUnit unit) {
+ try {
+ awaitNotification(timeout, unit);
+ } catch (ConditionTimeoutException expected) {
+ // do nothing
+ }
+ }
+
+ void validate(DistributedMember clientJoined) {
+ assertThat(notified.get()).isTrue();
+ assertThat(member.get()).isEqualTo(clientJoined);
+ assertThat(memberId.get()).isEqualTo(clientJoined.getId());
+ }
+
+ void validateNotNotified() {
+ assertThat(notified.get()).isFalse();
+ assertThat(member.get()).isNull();
+ assertThat(memberId.get()).isNull();
+ assertThat(client.get()).isFalse();
+ }
+ }
+
+ private static class FakeDistributedMember implements DistributedMember {
- private final String host;
+ private String host;
- public TestDistributedMember(String host) {
+ FakeDistributedMember(String host) {
this.host = host;
}
+ @Override
public String getName() {
return "";
}
+ @Override
public String getHost() {
return this.host;
}
- public Set getRoles() {
- return new HashSet();
+ @Override
+ public Set<Role> getRoles() {
+ return Collections.emptySet();
}
+ @Override
public int getProcessId() {
return 0;
}
+ @Override
public String getId() {
return this.host;
}
+ @Override
public int compareTo(DistributedMember o) {
- if ((o == null) || !(o instanceof TestDistributedMember)) {
+ if ((o == null) || !(o instanceof FakeDistributedMember)) {
throw new InternalGemFireException("Invalidly comparing TestDistributedMember to " + o);
}
- TestDistributedMember tds = (TestDistributedMember) o;
- return getHost().compareTo(tds.getHost());
+ FakeDistributedMember fakeDistributedMember = (FakeDistributedMember) o;
+ return getHost().compareTo(fakeDistributedMember.getHost());
}
@Override
public boolean equals(Object obj) {
- if ((obj == null) || !(obj instanceof TestDistributedMember)) {
- return false;
- }
- return compareTo((TestDistributedMember) obj) == 0;
+ return (obj != null) && obj instanceof FakeDistributedMember
+ && compareTo((FakeDistributedMember) obj) == 0;
}
@Override
@@ -2171,13 +1744,14 @@ public class UniversalMembershipListenerAdapterDUnitTest extends ClientServerTes
return getHost().hashCode();
}
+ @Override
public DurableClientAttributes getDurableClientAttributes() {
return null;
}
+ @Override
public List<String> getGroups() {
return Collections.emptyList();
}
}
-
}
diff --git a/geode-core/src/test/java/org/apache/geode/management/internal/cli/json/TypedJsonPdxIntegrationTest.java b/geode-core/src/test/java/org/apache/geode/management/internal/cli/json/TypedJsonPdxIntegrationTest.java
index 07289d2..e053fa1 100644
--- a/geode-core/src/test/java/org/apache/geode/management/internal/cli/json/TypedJsonPdxIntegrationTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/internal/cli/json/TypedJsonPdxIntegrationTest.java
@@ -1,18 +1,16 @@
/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
+ * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
+ * agreements. See the NOTICE file distributed with this work for additional information regarding
+ * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License. You may obtain a
+ * copy of the License at
*
- * http://www.apache.org/licenses/LICENSE-2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
*
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
*/
package org.apache.geode.management.internal.cli.json;
@@ -36,7 +34,8 @@ import org.apache.geode.pdx.internal.PdxInstanceFactoryImpl;
import org.apache.geode.test.junit.categories.IntegrationTest;
/**
- * Integration tests for {@link TypedJson}.<p>
+ * Integration tests for {@link TypedJson}.
+ * <p>
*
* TODO: add actual assertions
*/
diff --git a/geode-core/src/test/java/org/apache/geode/management/internal/cli/json/TypedJsonTest.java b/geode-core/src/test/java/org/apache/geode/management/internal/cli/json/TypedJsonTest.java
index 48baa7e..de74f82 100644
--- a/geode-core/src/test/java/org/apache/geode/management/internal/cli/json/TypedJsonTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/internal/cli/json/TypedJsonTest.java
@@ -32,7 +32,8 @@ import org.junit.experimental.categories.Category;
import org.apache.geode.test.junit.categories.UnitTest;
/**
- * Extracted from {@link TypedJsonPdxIntegrationTest}.<p>
+ * Extracted from {@link TypedJsonPdxIntegrationTest}.
+ * <p>
*
* TODO: add actual assertions
*/
--
To stop receiving notification emails like this one, please contact
"commits@geode.apache.org" <co...@geode.apache.org>.